diff --git a/.flake8 b/.flake8 index 3837b2b01b..6efeae09f5 100644 --- a/.flake8 +++ b/.flake8 @@ -43,6 +43,8 @@ per-file-ignores = libensemble/gen_funcs/persistent_aposmm.py:E402, E501 libensemble/tests/regression_tests/test_persistent_aposmm*:E402 libensemble/tests/regression_tests/dont_run_test_persistent_aposmm*:E402 + libensemble/tests/regression_tests/test_persistent_gp_multitask_ax.py:E402 + libensemble/tests/regression_tests/dontrun_test_persistent_gp_multitask_ax.py:E402 libensemble/tests/regression_tests/test_uniform_sampling_then_persistent_localopt_runs.py:E402 libensemble/tests/functionality_tests/test_active_persistent_worker_abort.py:E402 libensemble/tests/deprecated_tests/test_old_aposmm*:E402 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1e209ee1c5..9161f5375c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -42,6 +42,17 @@ jobs: comms-type: l mpi-version: 'mpich' do-balsam: true + - os: windows-latest + python-version: '3.10' + comms-type: l + mpi-version: 'msmpi' + do-balsam: false + - os: windows-latest + python-version: '3.10' + comms-type: m + mpi-version: 'msmpi' + do-balsam: false + env: HYDRA_LAUNCHER: 'fork' TERM: xterm-256color @@ -68,6 +79,13 @@ jobs: python --version pip install -I --upgrade certifi + - name: Windows - Add clang path to $PATH env + shell: bash + if: matrix.os == 'windows-latest' + run: | + echo "PATH=$PATH:C:\msys64\mingw64\bin" >> $GITHUB_ENV + echo "PATH=$PATH:C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\amd64" >> $GITHUB_ENV + - name: Install Ubuntu compilers if: matrix.os == 'ubuntu-latest' run: conda install gcc_linux-64 @@ -90,20 +108,30 @@ jobs: mkdir ../sdk; tar xf MacOSX10.14.sdk.tar.xz -C ../sdk conda install clang_osx-64=9.0.1 - - name: Install MPI, mpi4py from conda - if: matrix.python-version != '3.10' + - name: Setup MPI (${{ matrix.mpi-version }}) + uses: mpi4py/setup-mpi@v1 + if: matrix.os == 'windows-latest' + with: + mpi: ${{ matrix.mpi-version }} + + - name: Install mpi4py on Windows + if: matrix.os == 'windows-latest' + run: pip install mpi4py + + - name: Install mpi4py and MPI from conda + if: matrix.python-version != '3.10' && matrix.os != 'windows-latest' run: | conda install ${{ matrix.mpi-version }} conda install mpi4py - - name: Install MPI, mpi4py from pip - if: matrix.python-version == '3.10' + - name: Install mpi4py from pip, MPI from conda + if: matrix.python-version == '3.10' && matrix.os != 'windows-latest' run: | conda install ${{ matrix.mpi-version }} pip install mpi4py - name: Install generator dependencies - if: contains('3.7_3.8_3.9_3.10', matrix.python-version) && matrix.do-balsam == false + if: contains('3.7_3.8_3.9_3.10', matrix.python-version) && matrix.do-balsam == false && matrix.os != 'windows-latest' run: | python -m pip install --upgrade pip conda install nlopt @@ -111,13 +139,22 @@ jobs: conda install superlu_dist conda install hypre conda install mumps-mpi - # pip install petsc - # pip install petsc4py + conda install petsc + conda install petsc4py pip install DFO-LS pip install mpmath + pip install ax-platform python -m pip install --upgrade git+https://github.com/mosesyhc/surmise.git@development/PCGPwM + - name: Install some generator dependencies on Windows + if: matrix.os == 'windows-latest' + run: | + python -m pip install --upgrade pip + conda install nlopt + conda install scipy + pip install mpmath + - name: Install generator dependencies for Ubuntu tests if: matrix.os == 'ubuntu-latest' && matrix.do-balsam == false run: | @@ -132,21 +169,24 @@ jobs: cd heffte/build pwd cmake -D CMAKE_BUILD_TYPE=Release -D BUILD_SHARED_LIBS=ON -D CMAKE_INSTALL_PREFIX=./ -D Heffte_ENABLE_AVX=ON -D Heffte_ENABLE_FFTW=ON ../ - make + make -j 4 make install cp ./benchmarks/speed3d_c2c ../../libensemble/tests/regression_tests/ # end heffte build and dependencies - pip install dragonfly-opt - pip install torch - pip install gpytorch + # pip install dragonfly-opt + pip install git+https://github.com/dragonfly/dragonfly.git + pip install ax-platform - name: Install other testing dependencies + if: matrix.do-balsam == false run: | pip install -r install/testing_requirements.txt pip install psutil pip install pyyaml + pip install funcx + pip install balsam - name: Install Tasmanian on Ubuntu if: matrix.os == 'ubuntu-latest' && matrix.do-balsam == false @@ -158,6 +198,7 @@ jobs: env: BALSAM_DB_PATH: $HOME/test-balsam run: | + pip install -r install/testing_requirements.txt wget https://github.com/argonne-lcf/balsam/archive/refs/tags/0.5.0.tar.gz mkdir ../balsam; tar xf 0.5.0.tar.gz -C ../balsam; python install/configure_balsam_install.py @@ -176,11 +217,8 @@ jobs: - name: Find MPI, Install libEnsemble, flake8, ulimit adjust run: | - python install/find_mpi.py - mpiexec --version pip install -e . flake8 libensemble - ulimit -Sn 10000 - name: Activate API unit test if using mpich if: matrix.mpi-version == 'mpich' @@ -192,10 +230,10 @@ jobs: run: | ./libensemble/tests/run-tests.sh -e -A "-W error" -z -${{ matrix.comms-type }} - #- name: Run simple tests, Ubuntu, Python 3.11 - # if: matrix.python-version == '3.11' - # run: | - # ./libensemble/tests/run-tests.sh -A "-W error" -z -${{ matrix.comms-type }} + - name: Run simple tests, Windows + if: matrix.os == 'windows-latest' + run: | + ./libensemble/tests/run-tests.sh -A "-W error" -z -${{ matrix.comms-type }} - name: Run extensive tests, macOS if: matrix.os == 'macos-latest' diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 815baa34bc..de3e46c31b 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -19,9 +19,9 @@ New capabilities: * Added configuration options for `libE_stats.txt` file. #743 * Support for `spawn` and `forkserver` multiprocessing start methods. #797 - * Note that macOS no longer switches to using `fork`. macOS (since Python 3.8) and Windows - default to using `spawn`. When using `spawn`, we recommend placing calling script code in - an ``if __name__ == "__main__":`` block. The multiprocessing interface can be used to switch methods (https://docs.python.org/3/library/multiprocessing.html#multiprocessing.set_start_method). + * Note that macOS no longer switches to using `fork`. macOS (since Python 3.8) and Windows default to + using `spawn`. When using `spawn`, we recommend placing calling script code in an ``if __name__ == "__main__":`` block. + The multiprocessing interface can be used to switch methods (https://docs.python.org/3/library/multiprocessing.html#multiprocessing.set_start_method). Updates to example functions: diff --git a/README.rst b/README.rst index c09becb1be..dd16366995 100644 --- a/README.rst +++ b/README.rst @@ -31,8 +31,8 @@ Introduction to libEnsemble libEnsemble is a Python_ toolkit for coordinating workflows of asynchronous and dynamic ensembles of calculations. -libEnsemble can help users take advantage of massively parallel resources to solve design, -decision, and inference problems and expand the class of problems that can benefit from +libEnsemble helps users take advantage of massively parallel resources to solve design, +decision, and inference problems and expands the class of problems that can benefit from increased parallelism. libEnsemble aims for: @@ -58,7 +58,7 @@ With a basic familiarity of Python and NumPy_, users can easily incorporate any other mathematics, machine-learning, or resource-management libraries into libEnsemble workflows. -libEnsemble employs a manager/worker scheme that runs on MPI, multiprocessing, +libEnsemble employs a manager/worker scheme that communicates via MPI, multiprocessing, or TCP. Workers control and monitor any level of work using the aforementioned generator and simulator functions, from small subnode tasks to huge many-node computations. @@ -66,12 +66,15 @@ libEnsemble includes an Executor interface so application-launching functions ar portable, resilient, and flexible; it also automatically detects available nodes and cores, and can dynamically assign resources to workers. +libEnsemble performs best on Unix-like systems like Linux and macOS. See the +:ref:`FAQ` for more information. + .. before_dependencies_rst_tag Dependencies ~~~~~~~~~~~~ -Required dependencies: +**Required dependencies**: * Python_ 3.7 or above * NumPy_ @@ -83,7 +86,7 @@ When using ``mpi4py`` for libEnsemble communications: * A functional MPI 1.x/2.x/3.x implementation, such as MPICH_, built with shared/dynamic libraries * mpi4py_ v2.0.0 or above -Optional dependencies: +**Optional dependencies**: * Balsam_ @@ -103,6 +106,12 @@ a function-as-a-service platform to which workers can submit remote generator or simulator function instances. This feature can help distribute an ensemble across systems and heterogeneous resources. +* `psi-j-python`_ + +As of v0.9.2+dev, libEnsemble features a set of command-line utilities for submitting +libEnsemble jobs to almost any system or scheduler via a `PSI/J`_ Python interface. tqdm_ +is also required. + The example simulation and generation functions and tests require the following: * SciPy_ @@ -229,7 +238,8 @@ Resources **Further Information:** - Documentation is provided by ReadtheDocs_. -- An overview of libEnsemble's structure and capabilities is given in this manuscript_ and poster_ +- Contributions_ to libEnsemble are welcome. +- An overview of libEnsemble's structure and capabilities is given in this manuscript_ and poster_. - Examples of production user functions and complete workflows can be viewed, downloaded, and contributed to in the libEnsemble `Community Examples repository`_. **Citation:** @@ -243,7 +253,7 @@ Resources author = {Stephen Hudson and Jeffrey Larson and Stefan M. Wild and David Bindel and John-Luke Navarro}, institution = {Argonne National Laboratory}, - number = {Revision 0.9.2}, + number = {Revision 0.9.2+dev}, year = {2022}, url = {https://buildmedia.readthedocs.org/media/pdf/libensemble/latest/libensemble.pdf} } @@ -305,6 +315,7 @@ See a complete list of `example user scripts`_. .. _Community Examples repository: https://github.com/Libensemble/libe-community-examples .. _Conda: https://docs.conda.io/en/latest/ .. _conda-forge: https://conda-forge.org/ +.. _Contributions: https://github.com/Libensemble/libensemble/blob/main/CONTRIBUTING.rst .. _Coveralls: https://coveralls.io/github/Libensemble/libensemble?branch=main .. _DEAP: https://deap.readthedocs.io/en/master/overview.html .. _DFO-LS: https://github.com/numericalalgorithmsgroup/dfols @@ -330,6 +341,8 @@ See a complete list of `example user scripts`_. .. _petsc4py: https://bitbucket.org/petsc/petsc4py .. _PETSc/TAO: http://www.mcs.anl.gov/petsc .. _poster: https://figshare.com/articles/libEnsemble_A_Python_Library_for_Dynamic_Ensemble-Based_Computations/12559520 +.. _PSI/J: https://exaworks.org/psij +.. _psi-j-python: https://github.com/ExaWorks/psi-j-python .. _psutil: https://pypi.org/project/psutil/ .. _PyPI: https://pypi.org .. _pytest-cov: https://pypi.org/project/pytest-cov/ @@ -348,6 +361,7 @@ See a complete list of `example user scripts`_. .. _tarball: https://github.com/Libensemble/libensemble/releases/latest .. _Tasmanian: https://tasmanian.ornl.gov/ .. _Theta: https://www.alcf.anl.gov/alcf-resources/theta +.. _tqdm: https://tqdm.github.io/ .. _user guide: https://libensemble.readthedocs.io/en/latest/programming_libE.html .. _VTMOP: https://github.com/Libensemble/libe-community-examples#vtmop .. _WarpX: https://warpx.readthedocs.io/en/latest/ diff --git a/docs/FAQ.rst b/docs/FAQ.rst index da70c7f5bd..e29896c241 100644 --- a/docs/FAQ.rst +++ b/docs/FAQ.rst @@ -221,16 +221,67 @@ This effectively puts libEnsemble in silent mode. See the :ref:`Logger Configuration` docs for more information. -macOS-Specific Errors ---------------------- +macOS and Windows Errors +------------------------ + +.. _faqwindows: + +**Can I run libEnsemble on Windows** + +Although we run many libEnsemble workflows successfully on Windows using both MPI and local comms, we do not +rigorously support Windows, and recommend unix-like systems as a preference. Windows tends to produce more +platform-specific issues that are difficult to reproduce and troubleshoot. + +Feel free to check our `Github Actions`_ page to see what tests we run regularly on Windows. + +.. _`Github Actions`: https://github.com/Libensemble/libensemble/actions + +**Windows - How can I run libEnsemble with MPI comms?** + +We have run workflows with MPI comms. However, as most MPI distributions have either dropped Windows support + (MPICH and Open MPI) or are no longer being maintained (``msmpi``), we cannot guarantee success. + +If users wish to try, we recommend experimenting with the many Unix-like emulators, containers, virtual machines, +and other such systems. The `Installing PETSc On Microsoft Windows`_ documentation contains valuable information. + +Otherwise, install ``msmpi`` and ``mpi4py`` from conda and experiment, or use ``local`` comms. + +.. _`Installing PETSc On Microsoft Windows`: https://petsc.org/release/install/windows/#recommended-installation-methods + +**Windows - 'A required privilege is not held by the client'** + +Assuming you were trying to use the ``sim_dir_symlink_files`` or ``gen_dir_symlink_files`` options, this indicates that to +allow libEnsemble to create symlinks, you need to run your current ``cmd`` shell as administrator. + +**"RuntimeError: An attempt has been made to start a new process... this probably means that you are not using fork... +" if __name__ == '__main__': freeze_support() ...** + +You need to place your main calling script code underneath an ``if __name__ == "__main__":`` block. + +Explanation: Python chooses one of three methods to start new processes when using multiprocessing +(``--comms local`` with libEnsemble). These are ``'fork'``, ``'spawn'``, and ``'forkserver'``. ``'fork'`` +is the default on Unix, and in our experience is quicker and more reliable, but ``'spawn'`` is the default +on Windows and macOS (See the `Python multiprocessing docs`_). + +Prior to libEnsemble v0.9.2, if libEnsemble detected macOS, it would automatically switch the multiprocessing +method to ``'fork'``. We decided to stop doing this to avoid overriding defaults and compatibility issues with +some libraries. + +If you'd prefer to use ``'fork'`` or not reformat your code, you can set the multiprocessing start method via +the following, placed near the top of your calling script:: + + import multiprocessing + multiprocessing.set_start_method('fork', force=True) + +.. _`Python multiprocessing docs`: https://docs.python.org/3/library/multiprocessing.html -**"Fatal error in MPI_Init_thread: Other MPI error, error stack: ... gethostbyname failed"** +**"macOS - Fatal error in MPI_Init_thread: Other MPI error, error stack: ... gethostbyname failed"** Resolve this by appending ``127.0.0.1 [your hostname]`` to /etc/hosts. Unfortunately, ``127.0.0.1 localhost`` isn't satisfactory for preventing this error. -**How do I stop the Firewall Security popups when running with the Executor?** +**macOS - How do I stop the Firewall Security popups when running with the Executor?** There are several ways to address this nuisance, but all involve trial and error. An easy (but insecure) solution is temporarily disabling the firewall through diff --git a/docs/conf.py b/docs/conf.py index 76c7028e92..6972705401 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -79,6 +79,7 @@ def __getattr__(cls, name): sys.path.append(os.path.abspath("../libensemble/utils")) sys.path.append(os.path.abspath("../libensemble/tools")) sys.path.append(os.path.abspath("../libensemble/executors")) +sys.path.append(os.path.abspath("../libensemble/executors/balsam_executors")) sys.path.append(os.path.abspath("../libensemble/resources")) # print(sys.path) diff --git a/docs/data_structures/libE_specs.rst b/docs/data_structures/libE_specs.rst index f31cabb0a1..85af8594f6 100644 --- a/docs/data_structures/libE_specs.rst +++ b/docs/data_structures/libE_specs.rst @@ -33,7 +33,7 @@ libEnsemble is primarily customized by setting options within a ``libE_specs`` d processes are then terminated. multiprocessing default: 1 'kill_canceled_sims' [bool]: Will libE try to kill sims that user functions mark 'cancel_requested' as True. - If False, the manager avoid this moderate overhead. + If False, the manager avoids this moderate overhead. Default: True Directory management options: @@ -147,7 +147,9 @@ libEnsemble is primarily customized by setting options within a ``libE_specs`` d Distributed mode means workers share nodes with applications. Default: False 'zero_resource_workers' [list of ints]: - List of workers that require no resources. + List of workers that require no resources. For when a fixed mapping of workers + to resources is required. Otherwise, use "num_resource_sets". + For use with supported allocation functions. 'resource_info' [dict]: Provide resource information that will override automatically detected resources. The allowable fields are given below in 'Overriding Auto-detection' diff --git a/docs/data_structures/work_dict.rst b/docs/data_structures/work_dict.rst index 35af11cdff..64a479c772 100644 --- a/docs/data_structures/work_dict.rst +++ b/docs/data_structures/work_dict.rst @@ -3,27 +3,33 @@ work dictionary =============== -The work dictionary contains integer keys ``i`` and dictionary values to be -given to worker ``i``. ``Work[i]`` has the following form:: +The work dictionary contains metadata that is used by the manager to send a packet +of work to a worker. The dictionary uses integer keys ``i`` and values that determine +the data given to worker ``i``. ``Work[i]`` has the following form:: Work[i]: [dict]: Required keys: - 'persis_info' [dict]: Any persistent info to be sent to worker 'i' 'H_fields' [list]: The field names of the history 'H' to be sent to worker 'i' + 'persis_info' [dict]: Any persistent info to be sent to worker 'i' 'tag' [int]: 'EVAL_SIM_TAG'/'EVAL_GEN_TAG' if worker 'i' is to call sim/gen_func - 'libE_info' [dict]: Info sent to/from worker to help manager update the 'H' + 'libE_info' [dict]: Info sent to/from worker to help manager update the 'H' array - Optional keys are: + libE_info contains the following: 'H_rows' [list of ints]: History rows to send to worker 'i' - 'blocking' [list of ints]: Workers to be blocked by this calculation - 'persistent' [bool]: True if worker 'i' will enter persistent mode + 'rset_team' [list of ints]: The resource sets to be assigned (if dynamic scheduling is used) + 'persistent' [bool]: True if worker 'i' will enter persistent mode (Default: False) + +The work dictionary is typically set using the ``gen_work`` or ``sim_work`` +:doc:`helper functions<../function_guides/allocator>` in the allocation function. +``H_fields``, for example, is usually packed from either ``sim_specs["in"]``, ``gen_specs["in"]`` +or the equivalent "persis_in" variants. .. seealso:: For allocation functions giving work dictionaries using persistent workers, see `start_only_persistent.py`_ or `start_persistent_local_opt_gens.py`_. For a use case where the allocation and generator functions combine to do - simulation evaluations with different resources (blocking some workers), see + simulation evaluations with different resources, see `test_uniform_sampling_with_variable_resources.py`_. .. _start_only_persistent.py: https://github.com/Libensemble/libensemble/blob/develop/libensemble/alloc_funcs/start_only_persistent.py diff --git a/docs/executor/executor.rst b/docs/executor/executor.rst index 6d12a387a0..9d9dd6520d 100644 --- a/docs/executor/executor.rst +++ b/docs/executor/executor.rst @@ -24,7 +24,10 @@ To run MPI applications and use detected resources, use an alternative Executor class, as shown above. .. autoclass:: Executor - :members: __init__, register_app, submit + :members: + :exclude-members: serial_setup, sim_default_app, gen_default_app, get_app, default_app, set_resources, get_task, set_workerID, set_worker_info, new_tasks_timing + + .. automethod:: __init__ .. _task_tag: diff --git a/docs/executor/mpi_executor.rst b/docs/executor/mpi_executor.rst index 60fc1cc782..98b4a30eff 100644 --- a/docs/executor/mpi_executor.rst +++ b/docs/executor/mpi_executor.rst @@ -7,6 +7,7 @@ MPI Executor - MPI apps .. autoclass:: MPIExecutor :show-inheritance: :inherited-members: + :exclude-members: serial_setup, sim_default_app, gen_default_app, get_app, default_app, set_resources, get_task, set_workerID, set_worker_info, new_tasks_timing .. automethod:: __init__ diff --git a/docs/executor/overview.rst b/docs/executor/overview.rst index 069b1de5f3..ba0c15926e 100644 --- a/docs/executor/overview.rst +++ b/docs/executor/overview.rst @@ -76,7 +76,7 @@ In user simulation function:: # Has manager sent a finish signal exctr.manager_poll() - if exctr.manager_signal == 'finish': + if exctr.manager_signal in [MAN_SIGNAL_KILL, MAN_SIGNAL_FINISH]: task.kill() my_cleanup() diff --git a/docs/function_guides/generator.rst b/docs/function_guides/generator.rst index 57d301b82a..4f775e7c6f 100644 --- a/docs/function_guides/generator.rst +++ b/docs/function_guides/generator.rst @@ -52,13 +52,17 @@ any other libraries to serve their needs. Persistent Generators --------------------- -While normal generators return after completing their calculation, persistent -generators receive Work units, perform computations, and communicate results -directly to the manager in a loop, not returning until explicitly instructed by -the manager. The calling worker becomes a dedicated :ref:`persistent worker`. +While non-persistent generators return after completing their calculation, persistent +generators receive work units, perform computations, and communicate results +directly to the manager in a loop. A persistent generator returns either when +explicitly instructed by the manager, or by exiting its main loop based on some +condition. The allocation function can determine what to do once a persistent +generator finishes, such as ending the ensemble. + +The calling worker becomes a dedicated :ref:`persistent worker`. A ``gen_f`` is initiated as persistent by the ``alloc_f``. -Most users prefer persistent generators since they do not need to be +Many users prefer persistent generators since they do not need to be re-initialized every time their past work is completed and evaluated by a simulation, and can evaluate returned simulation results over the course of an entire libEnsemble routine as a single function instance. The :doc:`APOSMM<../examples/aposmm>` @@ -129,31 +133,23 @@ By default, a persistent worker (generator in this case) models the manager/work communications of a regular worker (i.e., the generator is expected to alternately receive and send data in a *ping pong* fashion). To have an irregular communication pattern, a worker can be initiated in *active receive* mode by the allocation -function (see :ref:`start_only_persistent`). +function (see :ref:`start_only_persistent`). In this mode, +the persistent worker will always be considered ready to receive more data +(e.g.,~ evaluation results). It can also send to the manager at any time. The user is responsible for ensuring there are no communication deadlocks in this mode. Note that in manager/worker message exchanges, only the worker-side -receive is blocking. +receive is blocking by default (a non-blocking option is available). Cancelling Simulations ---------------------- Previously submitted simulations can be cancelled by sending a message to the manager. -To do this as a separate communication, a persistent generator should be -in *active receive* mode to prevent a deadlock. -To send out cancellations of previously submitted simulations, the generator -can initiate a history array with just the ``sim_id`` and ``cancel_requested`` fields. -Then fill in the ``sim_id``'s to cancel and set the ``cancel_requested`` field to ``True``. -In the following example, ``sim_ids_to_cancel`` is a list of integers. +To do this a PersistentSupport helper function is provided. -.. code-block:: python - - # Send only these fields to existing H rows and libEnsemble will slot in the change. - H_o = np.zeros(len(sim_ids_to_cancel), dtype=[('sim_id', int), ('cancel_requested', bool)]) - H_o['sim_id'] = sim_ids_to_cancel - H_o['cancel_requested'] = True - my_support.send(H_o) +.. currentmodule:: libensemble.tools.persistent_support.PersistentSupport +.. autofunction:: request_cancel_sim_ids If a generated point is cancelled by the generator before it has been given to a worker for evaluation, then it will never be given. If it has already returned from the @@ -165,6 +161,29 @@ by a user function, otherwise it will be ignored. The :doc:`Borehole Calibration tutorial<../tutorials/calib_cancel_tutorial>` gives an example of the capability to cancel pending simulations. +Modification of existing points +------------------------------- + +To change existing fields of the history array, the generator can initialize an output +array where the *dtype* contains the ``sim_id`` and the fields to be modified (in +place of ``gen_specs["out"]``), and then send to the manager as with regular +communications. Any such message received by the manager will modify the given fields +for the given *sim_ids*. If the changes do not correspond with newly generated points, +then the generator needs to communicate to the manager that it is not ready +to receive completed evaluations. Send to the manager with the ``keep_state`` argument +set to *True*. + +For example, the cancellation function ``request_cancel_sim_ids`` could be replicated by +the following (where ``sim_ids_to_cancel`` is a list of integers): + +.. code-block:: python + + # Send only these fields to existing H rows and libEnsemble will slot in the change. + H_o = np.zeros(len(sim_ids_to_cancel), dtype=[('sim_id', int), ('cancel_requested', bool)]) + H_o['sim_id'] = sim_ids_to_cancel + H_o['cancel_requested'] = True + ps.send(H_o, keep_state=True) + Generator initiated shutdown ---------------------------- @@ -176,5 +195,5 @@ the ensemble as soon a persistent generator returns. The usual return values sho Examples -------- -Examples of normal and persistent generator functions +Examples of non-persistent and persistent generator functions can be found :doc:`here<../examples/gen_funcs>`. diff --git a/docs/images/central_balsam.png b/docs/images/central_balsam.png deleted file mode 100644 index d185082970..0000000000 Binary files a/docs/images/central_balsam.png and /dev/null differ diff --git a/docs/images/centralized_new.png b/docs/images/centralized_new.png deleted file mode 100644 index 66dce35b24..0000000000 Binary files a/docs/images/centralized_new.png and /dev/null differ diff --git a/docs/images/diagram_xml/centralized_new.xml b/docs/images/diagram_xml/centralized_new.xml deleted file mode 100644 index e117931c0f..0000000000 --- a/docs/images/diagram_xml/centralized_new.xml +++ /dev/null @@ -1,2 +0,0 @@ - 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 \ No newline at end of file diff --git a/docs/images/diagram_xml/distributed_new.xml b/docs/images/diagram_xml/distributed_new.xml deleted file mode 100644 index 39509b0ebe..0000000000 --- a/docs/images/diagram_xml/distributed_new.xml +++ /dev/null @@ -1,2 +0,0 @@ - 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 \ No newline at end of file diff --git a/docs/images/diagram_xml/funcx.xml b/docs/images/diagram_xml/funcx.xml deleted file mode 100644 index 5017489f65..0000000000 --- a/docs/images/diagram_xml/funcx.xml +++ /dev/null @@ -1 +0,0 @@ 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 \ No newline at end of file diff --git a/docs/images/distributed_new.png b/docs/images/distributed_new.png deleted file mode 100644 index 367bf1539b..0000000000 Binary files a/docs/images/distributed_new.png and /dev/null differ diff --git a/docs/images/funcx.png b/docs/images/funcx.png deleted file mode 100644 index fc3da631cb..0000000000 Binary files a/docs/images/funcx.png and /dev/null differ diff --git a/docs/images/libE_logo_smaller.png b/docs/images/libE_logo_smaller.png deleted file mode 100644 index 7a5df04606..0000000000 Binary files a/docs/images/libE_logo_smaller.png and /dev/null differ diff --git a/docs/images/logo_manager_worker.png b/docs/images/logo_manager_worker.png deleted file mode 100644 index 823ea93538..0000000000 Binary files a/docs/images/logo_manager_worker.png and /dev/null differ diff --git a/docs/images/using_new.png b/docs/images/using_new.png deleted file mode 100644 index 05807aa0da..0000000000 Binary files a/docs/images/using_new.png and /dev/null differ diff --git a/docs/images/white.png b/docs/images/white.png deleted file mode 100644 index d04873f1ad..0000000000 Binary files a/docs/images/white.png and /dev/null differ diff --git a/docs/introduction_latex.rst b/docs/introduction_latex.rst index c552e18146..95d081f28c 100644 --- a/docs/introduction_latex.rst +++ b/docs/introduction_latex.rst @@ -30,6 +30,7 @@ We now present further information on running and testing libEnsemble. .. _Community Examples repository: https://github.com/Libensemble/libe-community-examples .. _Conda: https://docs.conda.io/en/latest/ .. _conda-forge: https://conda-forge.org/ +.. _Contributions: https://github.com/Libensemble/libensemble/blob/main/CONTRIBUTING.rst .. _Coveralls: https://coveralls.io/github/Libensemble/libensemble?branch=main .. _DEAP: https://deap.readthedocs.io/en/master/overview.html .. _DFO-LS: https://github.com/numericalalgorithmsgroup/dfols @@ -54,6 +55,8 @@ We now present further information on running and testing libEnsemble. .. _petsc4py: https://bitbucket.org/petsc/petsc4py .. _PETSc/TAO: http://www.mcs.anl.gov/petsc .. _poster: https://figshare.com/articles/libEnsemble_A_Python_Library_for_Dynamic_Ensemble-Based_Computations/12559520 +.. _PSI/J: https://exaworks.org/psij +.. _psi-j-python: https://github.com/ExaWorks/psi-j-python .. _psutil: https://pypi.org/project/psutil/ .. _PyPI: https://pypi.org .. _pytest-cov: https://pypi.org/project/pytest-cov/ @@ -72,6 +75,7 @@ We now present further information on running and testing libEnsemble. .. _tarball: https://github.com/Libensemble/libensemble/releases/latest .. _Tasmanian: https://tasmanian.ornl.gov/ .. _Theta: https://www.alcf.anl.gov/alcf-resources/theta +.. _tqdm: https://tqdm.github.io/ .. _user guide: https://libensemble.readthedocs.io/en/latest/programming_libE.html .. _VTMOP: https://informs-sim.org/wsc20papers/311.pdf .. _WarpX: https://warpx.readthedocs.io/en/latest/ diff --git a/docs/platforms/example_scripts.rst b/docs/platforms/example_scripts.rst index 3163aa52f0..f6e9989685 100644 --- a/docs/platforms/example_scripts.rst +++ b/docs/platforms/example_scripts.rst @@ -5,6 +5,10 @@ Below are example submission scripts used to configure and launch libEnsemble on a variety of high-powered systems. See :doc:`here` for more information about the respective systems and configuration. +Alternatively to interacting with the scheduler or configuring submission scripts, +libEnsemble now features a portable set of :ref:`command-line utilities` +for submitting workflows to almost any system or scheduler. + Slurm - Basic ------------- diff --git a/docs/platforms/perlmutter.rst b/docs/platforms/perlmutter.rst index c2f97bdbd3..96998949f7 100644 --- a/docs/platforms/perlmutter.rst +++ b/docs/platforms/perlmutter.rst @@ -114,7 +114,7 @@ four resource sets (the example generator does not need dedicated resources): .. code-block:: python - libE_specs['zero_resource_workers'] = [1] + libE_specs['num_resource_sets'] = 4 The MPIExecutor is also initiated in the calling script, ensuring that ``srun`` is picked up:: diff --git a/docs/platforms/platforms_index.rst b/docs/platforms/platforms_index.rst index ecd8d436dc..3b719c26b0 100644 --- a/docs/platforms/platforms_index.rst +++ b/docs/platforms/platforms_index.rst @@ -139,7 +139,7 @@ Zero-resource workers Users with persistent ``gen_f`` functions may notice that the persistent workers are still automatically assigned system resources. This can be resolved by -using :ref:`zero resource workers`. +:ref:`fixing the number of resource sets`. Overriding Auto-detection ------------------------- @@ -153,6 +153,8 @@ libE_specs option. When using the MPI Executor, it is possible to override the detected information using the `custom_info` argument. See the :doc:`MPI Executor<../executor/mpi_executor>` for more. + .. _funcx_ref: + funcX - Remote User functions ----------------------------- @@ -161,9 +163,9 @@ internet access (laptops, login nodes, other servers, etc.), workers can be inst launch generator or simulator user function instances to separate resources from themselves via funcX_, a distributed, high-performance function-as-a-service platform: - .. image:: ../images/funcx.png + .. image:: ../images/funcxmodel.png :alt: running_with_funcx - :scale: 40 + :scale: 50 :align: center This is useful for running ensembles across machines and heterogeneous resources, but diff --git a/docs/resource_manager/overview.rst b/docs/resource_manager/overview.rst index 7a2dff656e..93f8b02009 100644 --- a/docs/resource_manager/overview.rst +++ b/docs/resource_manager/overview.rst @@ -8,32 +8,28 @@ libEnsemble comes with built-in resource management. This entails the :ref:`detection of available resources` (e.g., nodelists and core counts), and the allocation of resources to workers. -By default, the provisioned resources are divided by the number of workers (excluding -any workers given in the ``zero_resource_workers`` libE_specs option). libEnsemble's -:doc:`MPI Executor<../executor/mpi_executor>` is aware of these supplied resources, -and if not given any of ``num_nodes``, ``num_procs``, or ``procs_per_node`` in the submit -function, it will try to use all nodes and CPU cores available to the worker. +By default, the provisioned resources are divided by the number of workers. +libEnsemble's :doc:`MPI Executor<../executor/mpi_executor>` is aware of +these supplied resources, and if not given any of ``num_nodes``, ``num_procs``, +or ``procs_per_node`` in the submit function, it will try to use all nodes and +CPU cores available to the worker. Detected resources can be overridden using the libE_specs option :ref:`resource_info`. -Resource management can be disabled by setting -``libE_specs['disable_resource_manager'] = True``. This will prevent libEnsemble -from doing any resource detection or management. - Variable resource assignment ---------------------------- In slightly more detail, the resource manager divides resources into **resource sets**. One resource set is the smallest unit of resources that can be assigned (and dynamically reassigned) to workers. By default, the provisioned resources are -divided by the number of workers (excluding any workers given in the ``zero_resource_workers`` -``libE_specs`` option). However, it can also be set directly by the ``num_resource_sets`` -``libE_specs`` option. If the latter is set, the dynamic resource assignment algorithm -will always be used. +divided by the number of workers (excluding any workers given in the +``zero_resource_workers`` ``libE_specs`` option). However, it can also be set +directly by the ``num_resource_sets`` ``libE_specs`` option. If the latter is set, +the dynamic resource assignment algorithm will always be used. If there are more resource sets than nodes, then the resource sets on each node -will be given a slot number, enumerated from zero. For example, if there are three slots -on a node, they will have slot numbers 0, 1, and 2. +will be given a slot number, enumerated from zero. For example, if there are three +slots on a node, they will have slot numbers 0, 1, and 2. The resource manager will not split a resource set over nodes, rather the resource sets on each node will be the integer division of resource sets over nodes, with @@ -41,7 +37,10 @@ the remainder dealt out from the first node. Even breakdowns are generally preferable, however. For example, say a given system has four GPUs per node, and the user has run -libEnsemble on two nodes, with eight workers. The default division of resources would be: +libEnsemble on two nodes, with eight workers. The default division of resources +would be: + +.. _rsets-diagram: .. image:: ../images/variable_resources1.png @@ -66,7 +65,7 @@ In the calling script, use a ``gen_specs['out']`` field called ``resource_sets`` ('x', float, n)] } -For an example calling script, see The libEnsemble regression test +For an example calling script, see the regression test `test_persistent_sampling_CUDA_variable_resources.py`_ In the generator, the ``resource_sets`` field must be set to a value for each point @@ -122,10 +121,9 @@ For example, in *six_hump_camel_CUDA_variable_resources*, the environment variab :emphasize-lines: 3 resources = Resources.resources.worker_resources - if resources.even_slots: # Need same slots on each node - resources.set_env_to_slots("CUDA_VISIBLE_DEVICES") # Use convenience function. - num_nodes = resources.local_node_count - cores_per_node = resources.slot_count # One CPU per GPU + resources.set_env_to_slots("CUDA_VISIBLE_DEVICES") # Use convenience function. + num_nodes = resources.local_node_count + cores_per_node = resources.slot_count # One CPU per GPU In the figure above, this would result in worker one setting:: @@ -196,17 +194,19 @@ Persistent generator You have *one* persistent generator and want *eight* workers for running concurrent simulations. In this case you can run with *nine* workers. -Either use one zero resource worker, if the generator should always be the same worker: +Either explicitly set eight resource sets (recommended): .. code-block:: python - libE_specs['zero_resource_workers'] = [1] + libE_specs['num_resource_sets'] = 8 -Or explicitly set eight resource sets: +Or if the generator should always be the same worker, use one zero resource worker: .. code-block:: python - libE_specs['num_resource_sets'] = 8 + libE_specs['zero_resource_workers'] = [1] + +For the second option, an allocation function supporting zero resource workers must be used. Using the two-node example above, the initial worker mapping in this example will be: diff --git a/docs/resource_manager/resources_index.rst b/docs/resource_manager/resources_index.rst index a1dae387d1..c1eabef0da 100644 --- a/docs/resource_manager/resources_index.rst +++ b/docs/resource_manager/resources_index.rst @@ -5,13 +5,17 @@ Resource Manager libEnsemble comes with built-in resource management. This entails the detection of available resources (e.g. nodelists and core counts), and the allocation of resources to workers. +Resource management can be disabled by setting +``libE_specs['disable_resource_manager'] = True``. This will prevent libEnsemble +from doing any resource detection or management. + .. toctree:: :maxdepth: 2 :titlesonly: :caption: Resource Manager: + Zero-resource workers (e.g.,~ Persistent gen does not need resources) overview resource_detection - zero_resource_workers scheduler_module - worker_resources + Worker Resources Module (query resources for current worker) diff --git a/docs/resource_manager/zero_resource_workers.rst b/docs/resource_manager/zero_resource_workers.rst index 546e4ea83b..c676fa9a88 100644 --- a/docs/resource_manager/zero_resource_workers.rst +++ b/docs/resource_manager/zero_resource_workers.rst @@ -4,34 +4,81 @@ Zero-resource workers ~~~~~~~~~~~~~~~~~~~~~ Users with persistent ``gen_f`` functions may notice that the persistent workers -are still automatically assigned system resources. This can be wasteful if those -workers only run ``gen_f`` routines in-place and don't use the Executor to submit -applications to allocated nodes: +are still automatically assigned resources. This can be wasteful if those workers +only run ``gen_f`` functions in-place (i.e.,~ they do not use the Executor +to submit applications to allocated nodes). Suppose the user is using the +:meth:`parse_args()` function and runs:: + + python run_ensemble_persistent_gen.py --comms local --nworkers 3 + +If three nodes are available in the node allocation, the result may look like the +following. .. image:: ../images/persis_wasted_node.png :alt: persis_wasted_node :scale: 40 :align: center -This can be resolved by using the libE_specs option ``zero_resource_workers``: -.. code-block:: python +To avoid the the wasted node above, add an extra worker:: - libE_specs['zero_resource_workers'] = [1] + python run_ensemble_persistent_gen.py --comms local --nworkers 4 + +and in the calling script (*run_ensemble_persistent_gen.py*), explicitly set the +number of resource sets to the number of workers that will be running simulations. -in the calling script. Set the parameter ``zero_resource_workers`` to a list of -worker IDs that should not have system resources assigned. +.. code-block:: python -Worker 1 will not be allocated resources. Note that additional worker -processes can be added to take advantage of the free resources (if using the -same resource set) for simulation instances: + nworkers, is_manager, libE_specs, _ = parse_args() + libE_specs['num_resource_sets'] = nworkers - 1 + +When the ``num_resource_sets`` option is used, libEnsemble will use the dynamic +resource scheduler, and any worker may assign work to any node. This works well +for most users. .. image:: ../images/persis_add_worker.png :alt: persis_add_worker :scale: 40 :align: center -An alternative, when resource sets are being used, it to set the ``num_resource_sets`` -libE_specs option explicitly to the required value. The difference with declaring -``zero_resource_workers`` is that a fixed worker will have zero resources (this must -be supported by the allocation function, see :ref:`start_only_persistent`) +**Optional**: An alternative way to express the above would be to use the command +line:: + + python run_ensemble_persistent_gen.py --comms local --nsim_workers 3 + +This would automatically set the ``num_resource_sets`` option and add a single +worker for the persistent generator - a common use-case. + +In general, the number of resource sets should be set to enable the maximum +concurrency desired by the ensemble, taking in to account generators and simulators. +The users can set generator resources by setting ``persis_info['gen_resources']`` +to an integer value, representing the number of resource sets to give to the +generator. The default is zero. + +The available nodes are always divided by the number of resource sets, and there +may be multiple nodes or a partition of a node in each resource set. If the split +is uneven, resource sets are not split between nodes. E.g.~ If there are two nodes +and five resource sets, one node will have three resource sets, and the other will +have two. + +Placing zero-resource functions on a fixed worker +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +If the generator must must always be on worker one, then instead of using +``num_resource_sets``, use the ``zero_resource_workers`` *libE_specs* option: + + +.. code-block:: python + + libE_specs['zero_resource_workers'] = [1] + + +in the calling script and worker one will not be allocated resources. In general, +set the parameter ``zero_resource_workers`` to a list of worker IDs that should not +have resources assigned. + +This approach can be useful if running in +:doc:`distributed mode<../platforms/platforms_index>`. + +The use of the ``zero_resource_workers`` *libE_specs* option must be supported by +the allocation function, see :ref:`start_only_persistent`) diff --git a/docs/running_libE.rst b/docs/running_libE.rst index 5a04b2a08e..ab3213a755 100644 --- a/docs/running_libE.rst +++ b/docs/running_libE.rst @@ -106,6 +106,24 @@ The ``libE_specs`` options for TCP are:: 'authkey' [String]: Authkey. +Reverse-ssh interface +^^^^^^^^^^^^^^^^^^^^^ + +Via specifying ``--comms ssh`` on the command line, libEnsemble workers can +be launched to remote ssh-accessible systems without needing to specify ``'port'`` or ``'authkey'``. This allows users +to colocate workers, simulation or generator functions, and any applications they submit on the same machine. Such user +functions can also be persistent, unlike when launching remote functions via :ref:`funcX`. + +The working directory and Python to run on the remote system need to be specified. Running a calling script may resemble:: + + python myscript.py --comms ssh --workers machine1 machine2 --worker_pwd /home/workers --worker_python /home/.conda/.../python + +.. note:: + Setting up public-key authentication on the worker host systems is recommended to avoid entering passwords. + +.. note:: + This interface assumes that all remote machines share a filesystem. We'll be adjusting this in the future. + Limitations of TCP mode ^^^^^^^^^^^^^^^^^^^^^^^ @@ -116,6 +134,147 @@ Further command line options See the **parse_args()** function in :doc:`Convenience Tools` for further command line options. +.. _liberegister: + +liberegister / libesubmit +------------------------- + +libEnsemble now features a pair of command-line utilities for preparing and launching libEnsemble workflows onto almost +any machine and any scheduler, using a `PSI/J`_ Python implementation. This is an alternative approach +to maintaining system or scheduler-specific batch submission scripts. + +- `liberegister` + +Creates an initial, platform-independent PSI/J serialization of a libEnsemble submission. Run this utility on +a calling script in a familiar manner:: + + liberegister my_calling_script.py --comms local --nworkers 4 + +This produces an initial `my_calling_script.json` serialization conforming to PSI/J's specification: + +.. container:: toggle + + .. container:: header + + `my_calling_script.json` + + .. code-block:: JSON + + { + "version": 0.1, + "type": "JobSpec", + "data": { + "name": "libe-job", + "executable": "python", + "arguments": [ + "my_calling_script.py", + "--comms", + "local", + "--nworkers", + "4" + ], + "directory": null, + "inherit_environment": true, + "environment": { + "PYTHONNOUSERSITE": "1" + }, + "stdin_path": null, + "stdout_path": null, + "stderr_path": null, + "resources": { + "node_count": 1, + "process_count": null, + "process_per_node": null, + "cpu_cores_per_process": null, + "gpu_cores_per_process": null, + "exclusive_node_use": true + }, + "attributes": { + "duration": "30", + "queue_name": null, + "project_name": null, + "reservation_id": null, + "custom_attributes": {} + }, + "launcher": null + } + } + +- `libesubmit` + +Further parameterizes a serialization, and submits a corresponding Job to the specified scheduler. +Running ``qsub``, ``sbatch``, etc. on some batch submission script is not needed. For instance:: + + libesubmit my_calling_script.json -q debug -A project -s slurm --nnodes 8 + +Results in:: + + *** libEnsemble 0.9.2+dev *** + Imported PSI/J serialization: my_calling_script.json. Preparing submission... + Calling script: my_calling_script.py + ...found! Proceeding. + Submitting Job!: Job[id=ce4ead75-a3a4-42a3-94ff-c44b3b2c7e61, native_id=None, executor=None, status=JobStatus[NEW, time=1658167808.5125017]] + + $ squeue --long --users=user + Mon Jul 18 13:10:15 2022 + JOBID PARTITION NAME USER STATE TIME TIME_LIMI NODES NODELIST(REASON) + 2508936 debug ce4ead75 user PENDING 0:00 30:00 8 (Priority) + +This also produces a Job-specific representation, e.g: + +.. container:: toggle + + .. container:: header + + `8ba9de56.my_calling_script.json` + + .. code-block:: JSON + + { + "version": 0.1, + "type": "JobSpec", + "data": { + "name": "libe-job", + "executable": "/Users/jnavarro/miniconda3/envs/libe/bin/python3.8", + "arguments": [ + "my_calling_script.py", + "--comms", + "local", + "--nworkers", + "4" + ], + "directory": "/home/user/libensemble/scratch", + "inherit_environment": true, + "environment": { + "PYTHONNOUSERSITE": "1" + }, + "stdin_path": null, + "stdout_path": "8ba9de56.my_calling_script.out", + "stderr_path": "8ba9de56.my_calling_script.err", + "resources": { + "node_count": 8, + "process_count": null, + "process_per_node": null, + "cpu_cores_per_process": null, + "gpu_cores_per_process": null, + "exclusive_node_use": true + }, + "attributes": { + "duration": "30", + "queue_name": "debug", + "project_name": "project", + "reservation_id": null, + "custom_attributes": {} + }, + "launcher": null + } + } + +If libesubmit is run on a ``.json`` serialization from liberegister and can't find the +specified calling script, it'll help search for matching candidate scripts. + +.. _PSI/J: https://exaworks.org/psij + Persistent Workers ------------------ .. _persis_worker: diff --git a/docs/scipy2020.rst b/docs/scipy2020.rst index 8fbd0c98e7..ef9249ef24 100644 --- a/docs/scipy2020.rst +++ b/docs/scipy2020.rst @@ -8,11 +8,6 @@ :width: 33 % :align: right -.. image:: images/white.png - :align: center - :width: 33 % - :height: 1.2 in - ========================================================================= **libEnsemble**: A Python Library for Dynamic Ensemble-Based Computations ========================================================================= @@ -51,11 +46,6 @@ input and a ``sim_f`` function that performs and monitors simulations. The user parameterizes these functions and initiates libEnsemble in a *calling script*. Examples and templates of such scripts and functions are included in the library. -.. image:: images/using_new.png - :alt: Using libEnsemble - :scale: 30 % - :align: center - For example, the ``gen_f`` may contain an optimization routine to generate new simulation parameters on-the-fly based on results from previous ``sim_f`` simulations. @@ -82,11 +72,6 @@ many-node simulations. The *manager* allocates workers to asynchronously execute ``gen_f`` generation functions and ``sim_f`` simulation functions based on produced output, directed by a provided ``alloc_f`` allocation function. -.. image:: images/logo_manager_worker.png - :alt: Managers and Workers - :align: center - :scale: 40 % - Flexible Run Mechanisms ----------------------- @@ -97,14 +82,14 @@ run and launch tasks (user applications) on available nodes. * **Distributed**: Workers are distributed across allocated nodes and launch tasks in-place. Workers share nodes with their applications. -.. image:: images/distributed_new.png +.. image:: images/distributed_new_detailed.png :alt: Distributed :align: center :scale: 30 % * **Centralized**: Workers run on one or more dedicated nodes and launch tasks to the remaining allocated nodes. -.. image:: images/centralized_new.png +.. image:: images/centralized_new_detailed.png :alt: Centralized :align: center :scale: 30 % @@ -132,7 +117,7 @@ Executor can interface with the **Balsam** library, which functions as a proxy job launcher that maintains and submits jobs from a database on front end launch nodes. -.. image:: images/central_balsam.png +.. image:: images/centralized_new_detailed_balsam.png :alt: Central Balsam :align: center :scale: 40 % diff --git a/docs/tutorials/calib_cancel_tutorial.rst b/docs/tutorials/calib_cancel_tutorial.rst index 718d6e4398..1ffd31922c 100644 --- a/docs/tutorials/calib_cancel_tutorial.rst +++ b/docs/tutorials/calib_cancel_tutorial.rst @@ -25,12 +25,8 @@ Overview of the Calibration Problem The generator function featured in this tutorial can be found in ``gen_funcs/persistent_surmise_calib.py`` and uses the `surmise`_ library for its -calibration surrogate model interface. - -.. note:: - Note that this repository is a fork of - the main surmise repository, but it retains support for the "PCGPwM" emulation - method used in the generator. surmise is under active development. +calibration surrogate model interface. The surmise library uses the "PCGPwM" +emulation method in this example. Say there is a computer model :math:`f(\theta, x)` to be calibrated. To calibrate is to find some parameter :math:`\theta_0` such that :math:`f(\theta_0, x)` closely @@ -105,27 +101,25 @@ cancelled ("obviated"). If so, the generator then calls ``cancel_columns()``:: ... c_obviate = info['obviatesugg'] # suggested if len(c_obviate) > 0: - cancel_columns(obs_offset, c_obviate, n_x, pending, comm) + cancel_columns(obs_offset, c_obviate, n_x, pending, ps) ``obs_offset`` is an offset that excludes the observations when mapping points in surmise data structures to ``sim_id``'s, ``c_obviate`` is a selection of columns to cancel, ``n_x`` is the number of ``x`` values, and ``pending`` is used -to check that points marked for cancellation have not already returned. ``comm`` is a -communicator object from :doc:`libE_info<../data_structures/work_dict>` used to send -and receive messages from the Manager. +to check that points marked for cancellation have not already returned. ``ps`` is the +instantiation of the *PersistentSupport* class that is set up for persistent generators, and +provides an interface for communication with the manager. Within ``cancel_columns()``, each column in ``c_obviate`` is iterated over, and if a point is ``pending`` and thus has not yet been evaluated by a simulation, its ``sim_id`` is appended to a list to be sent to the Manager for cancellation. -A new, separate local :doc:`History array<../history_output_logging>` is defined with the -selected ``'sim_id'`` s and the ``'cancel_requested'`` field set to ``True``. This array is -then sent to the Manager using the ``send_mgr_worker_msg`` persistent generator -helper function. Each of these helper functions is described :ref:`here`. -The entire ``cancel_columns()`` routine is listed below: +Cancellation is requested using the helper function ``request_cancel_sim_ids`` provided +by the *PersistentSupport* class. Each of these helper functions is described +:ref:`here`. The entire ``cancel_columns()`` routine is listed below: .. code-block:: python - def cancel_columns(obs_offset, c, n_x, pending, comm): + def cancel_columns(obs_offset, c, n_x, pending, ps): """Cancel columns""" sim_ids_to_cancel = [] columns = np.unique(c) @@ -137,11 +131,7 @@ The entire ``cancel_columns()`` routine is listed below: sim_ids_to_cancel.append(sim_id_cancel) pending[i, c] = 0 - # Send only these fields to existing H rows and libEnsemble will slot in the change. - H_o = np.zeros(len(sim_ids_to_cancel), dtype=[('sim_id', int), ('cancel_requested', bool)]) - H_o['sim_id'] = sim_ids_to_cancel - H_o['cancel_requested'] = True - send_mgr_worker_msg(comm, H_o) + ps.request_cancel_sim_ids(sim_ids_to_cancel) In future calls to the allocation function by the manager, points that would have been distributed for simulation work but are now marked with "cancel_requested" will not @@ -174,11 +164,10 @@ This is calculated from other parameters in the calling script. By default, workers (including persistent workers), are only allocated work when they're in an :doc:`idle or non-active state<../data_structures/worker_array>`. -However, since this generator must asynchronously update its model and -cancel pending evaluations, the worker running this generator remains -in an *active receive* state, until it becomes non-persistent. This means -both the manager and persistent worker (generator in this case) must be -prepared for irregular sending /receiving of data. +However, since this generator must asynchronously update its model, the worker +running this generator remains in an *active receive* state, until it becomes +non-persistent. This means both the manager and persistent worker (generator in +this case) must be prepared for irregular sending/receiving of data. .. Manager - Cancellation, History Updates, and Allocation .. ------------------------------------------------------- @@ -240,7 +229,7 @@ prepared for irregular sending /receiving of data. .. # Poll task for finish and poll manager for kill signals .. while(not task.finished): .. exctr.manager_poll() -.. if exctr.manager_signal == 'kill': +.. if exctr.manager_signal == MAN_SIGNAL_KILL: .. task.kill() .. calc_status = MAN_SIGNAL_KILL .. break @@ -256,7 +245,7 @@ prepared for irregular sending /receiving of data. .. While the launched task isn't finished, the simulator function periodically polls .. both the task's statuses and for signals from the manager via .. the :ref:`executor.manager_poll()` function. -.. Immediately after ``exctr.manager_signal`` is confirmed as ``'kill'``, the current +.. Immediately after ``exctr.manager_signal`` is confirmed as ``MAN_SIGNAL_KILL``, the current .. task is killed and the function returns with the .. ``MAN_SIGNAL_KILL`` :doc:`calc_status<../data_structures/calc_status>`. .. This status will be logged in ``libE_stats.txt``. diff --git a/docs/tutorials/forces_gpu_tutorial.rst b/docs/tutorials/forces_gpu_tutorial.rst index 0ce1054cda..bae79dcc6d 100644 --- a/docs/tutorials/forces_gpu_tutorial.rst +++ b/docs/tutorials/forces_gpu_tutorial.rst @@ -22,9 +22,12 @@ GPU build lines in build_forces.sh_ or similar for your platform. The libEnsemble scripts in this example are available under forces_gpu_ in the libEnsemble repository. -Note that at time of writing the calling script ``run_libe_forces.py`` is identical -to that in ``forces_simple``. The ``forces_simf`` file has slight modifications to -assign GPUs. +Note that at time of writing the calling script **run_libe_forces.py** is functionally +the same as that in *forces_simple*, but contains some commented out lines that can +be used for a variable resources example. The *forces_simf.py* file has slight modifications +to assign GPUs. + +Videos demonstrate running this example on Perlmutter_ and Spock_. Simulation function ------------------- @@ -106,6 +109,11 @@ and the line:: will set the environment variable ``CUDA_VISIBLE_DEVICES`` to match the assigned slots (partitions on the node). +.. note:: + **slots** refers to the ``resource sets`` enumerated on a node (starting with + zero). If a resource set has more than one node, then each node is considered to + have slot zero. [:ref:`diagram`] + Note that if you are on a system that automatically assigns free GPUs on the node, then setting ``CUDA_VISIBLE_DEVICES`` is not necessary unless you want to ensure workers are strictly bound to GPUs. For example, on many **SLURM** systems, you @@ -132,17 +140,14 @@ eight workers. For example:: python run_libe_forces.py --comms local --nworkers 8 -If you are running one persistent generator which does not require -resources, then assign nine workers, and set the following in your -calling script:: - - libE_specs['zero_resource_workers'] = [1] - -Or - if you do not care which worker runs the generator, you could fix the -*resource_sets*:: +Note that if you are running one persistent generator which does not require +resources, then assign nine workers, and fix the number of *resource_sets* in +you calling script:: libE_specs['num_resource_sets'] = 8 +See :ref:`zero resource workers` for more ways to express this. + Changing number of GPUs per worker ---------------------------------- @@ -157,14 +162,20 @@ Varying resources ----------------- The same code can be used when varying worker resources. In this case, you may -choose to set one worker per GPU (as we did originally). Then add ``resource_sets`` -as a ``gen_specs['out']`` in your calling script. Simply assign the -``resource_sets`` field of :doc:`H<../data_structures/history_array>` for each point -generated. +add an integer field called ``resource_sets`` as a ``gen_specs['out']`` in your +calling script. + +In the generator function, assign the ``resource_sets`` field of +:doc:`H<../data_structures/history_array>` for each point generated. For example +if a larger simulation requires two MPI tasks (and two GPUs), set ``resource_sets`` +field to *2* for that sim_id in the generator function. + +The calling script run_libe_forces.py_ contains alternative commented out lines for +a variable resource example. Search for "Uncomment for var resources" -In this case the above code would still work, assigning one CPU processor and -one GPU to each rank. If you want to have one rank with multiple GPUs, then -change source lines 29/30 accordingly. +In this case, the simulator function will still work, assigning one CPU processor +and one GPU to each MPI rank. If you want to have one rank with multiple GPUs, +then change source lines 29/30 accordingly. Further guidance on varying resource to workers can be found under the :doc:`resource manager<../resource_manager/resources_index>`. @@ -229,3 +240,6 @@ resource conflicts on each node. .. _forces_gpu: https://github.com/Libensemble/libensemble/blob/develop/libensemble/tests/scaling_tests/forces/forces_gpu .. _forces.c: https://github.com/Libensemble/libensemble/blob/develop/libensemble/tests/scaling_tests/forces/forces_app/forces.c .. _build_forces.sh: https://github.com/Libensemble/libensemble/blob/develop/libensemble/tests/scaling_tests/forces/forces_app/build_forces.sh +.. _Perlmutter: https://www.youtube.com/watch?v=Av8ctYph7-Y +.. _Spock: https://www.youtube.com/watch?v=XHXcslDORjU +.. _run_libe_forces.py: https://github.com/Libensemble/libensemble/blob/develop/libensemble/tests/scaling_tests/forces/forces_gpu/run_libe_forces.py diff --git a/examples/tutorials/aposmm/tutorial_six_hump_camel.py b/examples/tutorials/aposmm/tutorial_six_hump_camel.py index 3d8a2bb348..fb9ea363c2 100644 --- a/examples/tutorials/aposmm/tutorial_six_hump_camel.py +++ b/examples/tutorials/aposmm/tutorial_six_hump_camel.py @@ -3,7 +3,6 @@ def six_hump_camel(H, persis_info, sim_specs, _): """Six-Hump Camel sim_f.""" - batch = len(H["x"]) # Num evaluations each sim_f call. H_o = np.zeros(batch, dtype=sim_specs["out"]) # Define output array H diff --git a/install/testing_requirements.txt b/install/testing_requirements.txt index c33b06649e..e3d464f3d5 100644 --- a/install/testing_requirements.txt +++ b/install/testing_requirements.txt @@ -5,3 +5,4 @@ pytest-cov==2.12.1 pytest-timeout==1.4.2 mock==4.0.3 coveralls==3.2.0 +python-dateutil \ No newline at end of file diff --git a/libensemble/comms/logs.py b/libensemble/comms/logs.py index 997f312641..628f5bb59a 100644 --- a/libensemble/comms/logs.py +++ b/libensemble/comms/logs.py @@ -120,7 +120,6 @@ def init_worker_logger(logr, lev): def worker_logging_config(comm, worker_id=None): """Add a comm handler with worker ID filter to the indicated logger.""" - logconfig = LogConfig.config logger = logging.getLogger(logconfig.name) slogger = logging.getLogger(logconfig.stats_name) @@ -142,7 +141,6 @@ def worker_logging_config(comm, worker_id=None): def manager_logging_config(): """Add file-based logging at manager.""" - stat_timer = Timer() stat_timer.start() diff --git a/libensemble/executors/balsam_executors/balsam_executor.py b/libensemble/executors/balsam_executors/balsam_executor.py index 969b10ba35..6650f32829 100644 --- a/libensemble/executors/balsam_executors/balsam_executor.py +++ b/libensemble/executors/balsam_executors/balsam_executor.py @@ -12,7 +12,7 @@ In order to initiate a Balsam executor, the calling script should contain :: - from libensemble.executors import BalsamExecutor + from libensemble.executors.balsam_executors import BalsamExecutor exctr = BalsamExecutor() Key differences to consider between this executor and libEnsemble's others is @@ -21,7 +21,7 @@ This process may resemble:: - from libensemble.executors import BalsamExecutor + from libensemble.executors.balsam_executors import BalsamExecutor from balsam.api import ApplicationDefinition class HelloApp(ApplicationDefinition): @@ -79,7 +79,6 @@ class HelloApp(ApplicationDefinition): ExecutorException, TimeoutExpired, jassert, - STATES, ) from libensemble.executors import Executor @@ -120,7 +119,6 @@ def __init__( def _get_time_since_balsam_submit(self): """Return time since balsam task entered ``RUNNING`` state""" - event_query = EventLog.objects.filter(job_id=self.process.id, to_state="RUNNING") if not len(event_query): return 0 @@ -133,7 +131,6 @@ def _get_time_since_balsam_submit(self): def calc_task_timing(self): """Calculate timing information for this task""" - # Get runtime from Balsam self.runtime = self._get_time_since_balsam_submit() @@ -162,13 +159,10 @@ def _set_complete(self, dry_run=False): ]: self.success = True self.state = "FINISHED" - elif balsam_state in STATES: # In my states - self.state = balsam_state else: - logger.warning("Task finished, but in unrecognized " "Balsam state {}".format(balsam_state)) - self.state = "UNKNOWN" + self.state = balsam_state - logger.info("Task {} ended with state {}".format(self.name, self.state)) + logger.info("Task {} ended with state {}".format(self.name, self.state)) def poll(self): """Polls and updates the status attributes of the supplied task. Requests @@ -202,12 +196,7 @@ def poll(self): elif balsam_state in ["RUN_ERROR", "RUN_TIMEOUT", "FAILED"]: self.state = "FAILED" - - else: - raise ExecutorException( - "Task state returned from Balsam is not in known list of " - "Balsam states. Task state is {}".format(balsam_state) - ) + self._set_complete() def wait(self, timeout=None): """Waits on completion of the task or raises ``TimeoutExpired``. @@ -220,9 +209,7 @@ def wait(self, timeout=None): timeout: int or float, optional Time in seconds after which a TimeoutExpired exception is raised. If not set, then simply waits until completion. - Note that the task is not automatically killed if libEnsemble - timeouts from reaching exit_criteria["wallclock_max"]. - + Note that the task is not automatically killed on timeout. """ if self.dry_run: @@ -239,6 +226,9 @@ def wait(self, timeout=None): "POSTPROCESSED", "STAGED_OUT", "JOB_FINISHED", + "RUN_ERROR", + "RUN_TIMEOUT", + "FAILED", ]: time.sleep(0.2) self.process.refresh_from_db() @@ -251,7 +241,6 @@ def wait(self, timeout=None): def kill(self): """Cancels the supplied task. Killing is unsupported at this time.""" - self.process.delete() logger.info("Killing task {}".format(self.name)) @@ -270,7 +259,6 @@ class BalsamExecutor(Executor): def __init__(self): """Instantiate a new ``BalsamExecutor`` instance.""" - super().__init__() self.workflow_name = "libe_workflow" @@ -280,11 +268,11 @@ def serial_setup(self): """Balsam serial setup includes emptying database and adding applications""" pass - def add_app(self, name, site, exepath, desc): + def add_app(self, *args): """Sync application with Balsam service""" pass - def register_app(self, BalsamApp, app_name, calc_type=None, desc=None, precedent=None): + def register_app(self, BalsamApp, app_name=None, calc_type=None, desc=None, precedent=None): """Registers a Balsam ``ApplicationDefinition`` to libEnsemble. This class instance *must* have a ``site`` and ``command_template`` specified. See the Balsam docs for information on other optional fields. @@ -398,7 +386,7 @@ def submit_allocation( return allocation - def revoke_allocation(self, allocation): + def revoke_allocation(self, allocation, timeout=60): """ Terminates a Balsam ``BatchJob`` machine allocation remotely. Balsam apps should no longer be submitted to this allocation. Best to run after libEnsemble @@ -409,16 +397,27 @@ def revoke_allocation(self, allocation): allocation: ``BatchJob`` object a ``BatchJob`` with a corresponding machine allocation that should be cancelled. + + timeout: int, optional + Timeout and warn user after this many seconds of attempting to revoke an allocation. """ allocation.refresh_from_db() + start = time.time() + while not allocation.scheduler_id: time.sleep(1) allocation.refresh_from_db() + if time.time() - start > timeout: + logger.warning( + "Unable to terminate Balsam BatchJob. You may need to login to the machine and manually remove it." + ) + return False batchjob = BatchJob.objects.get(scheduler_id=allocation.scheduler_id) batchjob.state = "pending_deletion" batchjob.save() + return True def set_resources(self, resources): self.resources = resources @@ -523,10 +522,6 @@ def submit( if machinefile is not None: logger.warning("machinefile arg ignored - not supported in Balsam") - jassert( - num_procs or num_nodes or procs_per_node, - "No procs/nodes provided - aborting", - ) task = BalsamTask(app, app_args, workdir, None, None, self.workerID) diff --git a/libensemble/executors/balsam_executors/legacy_balsam_executor.py b/libensemble/executors/balsam_executors/legacy_balsam_executor.py index cf1a7b3aee..ede946a3de 100644 --- a/libensemble/executors/balsam_executors/legacy_balsam_executor.py +++ b/libensemble/executors/balsam_executors/legacy_balsam_executor.py @@ -65,7 +65,6 @@ def read_stderr(self): def _get_time_since_balsam_submit(self): """Return time since balsam task entered RUNNING state""" - # If wait_on_start then can could calculate runtime same a base executor # but otherwise that will return time from task submission. Get from Balsam. @@ -79,7 +78,6 @@ def _get_time_since_balsam_submit(self): def calc_task_timing(self): """Calculate timing information for this task""" - # Get runtime from Balsam self.runtime = self._get_time_since_balsam_submit() @@ -152,8 +150,7 @@ def wait(self, timeout=None): timeout: int or float, optional Time in seconds after which a TimeoutExpired exception is raised. If not set, then simply waits until completion. - Note that the task is not automatically killed if libEnsemble - timeouts from reaching exit_criteria["wallclock_max"]. + Note that the task is not automatically killed on timeout. """ if self.dry_run: @@ -177,7 +174,6 @@ def wait(self, timeout=None): def kill(self, wait_time=None): """Kills or cancels the supplied task""" - dag.kill(self.process) # Could have Wait here and check with Balsam its killed - diff --git a/libensemble/executors/executor.py b/libensemble/executors/executor.py index 5fd19ae0d9..d23b3ead27 100644 --- a/libensemble/executors/executor.py +++ b/libensemble/executors/executor.py @@ -18,8 +18,7 @@ from libensemble.message_numbers import ( UNSET_TAG, - MAN_SIGNAL_FINISH, - MAN_SIGNAL_KILL, + MAN_KILL_SIGNALS, WORKER_DONE, TASK_FAILED, WORKER_KILL_ON_TIMEOUT, @@ -244,8 +243,7 @@ def wait(self, timeout=None): timeout: int or float, optional Time in seconds after which a TimeoutExpired exception is raised. If not set, then simply waits until completion. - Note that the task is not automatically killed if libEnsemble - timeouts from reaching exit_criteria["wallclock_max"]. + Note that the task is not automatically killed on timeout. """ if self.dry_run: @@ -270,8 +268,7 @@ def result(self, timeout=None): timeout: int or float, optional Time in seconds after which a TimeoutExpired exception is raised. If not set, then simply waits until completion. - Note that the task is not automatically killed if libEnsemble - timeouts from reaching exit_criteria["wallclock_max"]. + Note that the task is not automatically killed on timeout. """ self.wait(timeout=timeout) @@ -286,8 +283,7 @@ def exception(self, timeout=None): timeout: int or float, optional Time in seconds after which a TimeoutExpired exception is raised. If not set, then simply waits until completion. - Note that the task is not automatically killed if libEnsemble - timeouts from reaching exit_criteria["wallclock_max"]. + Note that the task is not automatically killed on timeout. """ self.wait(timeout=timeout) @@ -350,6 +346,7 @@ class Executor: **Object Attributes:** :ivar list list_of_tasks: A list of tasks created in this executor + :ivar int manager_signal: The most recent manager signal received since manager_poll() was called. """ executor = None @@ -386,7 +383,7 @@ def __init__(self): This is typically created in the user calling script. """ - self.manager_signal = "none" + self.manager_signal = None self.default_apps = {"sim": None, "gen": None} self.apps = {} @@ -485,7 +482,7 @@ def manager_poll(self): The executor manager_signal attribute will be updated. """ - self.manager_signal = "none" # Reset + self.manager_signal = None # Reset # Check for messages; disregard anything but a stop signal if not self.comm.mail_flag(): @@ -495,16 +492,24 @@ def manager_poll(self): return # Process the signal and push back on comm (for now) - logger.info("Worker received kill signal {} from manager".format(man_signal)) - if man_signal == MAN_SIGNAL_FINISH: - self.manager_signal = "finish" - elif man_signal == MAN_SIGNAL_KILL: - self.manager_signal = "kill" + self.manager_signal = man_signal + + if man_signal in MAN_KILL_SIGNALS: + # Only kill signals exist currently + logger.info("Worker received kill signal {} from manager".format(man_signal)) else: logger.warning("Received unrecognized manager signal {} - ignoring".format(man_signal)) + self.comm.push_to_buffer(mtag, man_signal) return man_signal + def manager_kill_received(self): + """Return True if received kill signal from the manager""" + man_signal = self.manager_poll() + if man_signal in MAN_KILL_SIGNALS: + return True + return False + def polling_loop(self, task, timeout=None, delay=0.1, poll_manager=False): """Optional, blocking, generic task status polling loop. Operates until the task finishes, times out, or is optionally killed via a manager signal. On completion, returns a @@ -542,7 +547,7 @@ def polling_loop(self, task, timeout=None, delay=0.1, poll_manager=False): if poll_manager: man_signal = self.manager_poll() - if self.manager_signal != "none": + if self.manager_signal in MAN_KILL_SIGNALS: task.kill() calc_status = man_signal break diff --git a/libensemble/executors/mpi_executor.py b/libensemble/executors/mpi_executor.py index 7b0697b583..49a2fe3e1a 100644 --- a/libensemble/executors/mpi_executor.py +++ b/libensemble/executors/mpi_executor.py @@ -23,7 +23,13 @@ class MPIExecutor(Executor): - """The MPI executor can create, poll and kill runnable MPI tasks""" + """The MPI executor can create, poll and kill runnable MPI tasks + + **Object Attributes:** + + :ivar list list_of_tasks: A list of tasks created in this executor + :ivar int manager_signal: The most recent manager signal received since manager_poll() was called. + """ def __init__(self, custom_info={}): """Instantiate a new MPIExecutor instance. diff --git a/libensemble/executors/mpi_runner.py b/libensemble/executors/mpi_runner.py index aa6f68c663..30b6b2bf28 100644 --- a/libensemble/executors/mpi_runner.py +++ b/libensemble/executors/mpi_runner.py @@ -18,6 +18,7 @@ def get_runner(mpi_runner_type, runner_name=None): "aprun": APRUN_MPIRunner, "srun": SRUN_MPIRunner, "jsrun": JSRUN_MPIRunner, + "msmpi": MSMPI_MPIRunner, "custom": MPIRunner, } mpi_runner = mpi_runners[mpi_runner_type] @@ -199,6 +200,23 @@ def __init__(self, run_command="aprun"): ] +class MSMPI_MPIRunner(MPIRunner): + def __init__(self, run_command="mpiexec"): + self.run_command = run_command + self.subgroup_launch = False + self.mfile_support = False + self.arg_nprocs = ("-n", "-np") + self.arg_nnodes = ("--LIBE_NNODES_ARG_EMPTY",) + self.arg_ppn = ("-cores",) + self.mpi_command = [ + self.run_command, + "-env {env}", + "-n {num_procs}", + "-cores {procs_per_node}", + "{extra_args}", + ] + + class SRUN_MPIRunner(MPIRunner): def __init__(self, run_command="srun"): self.run_command = run_command diff --git a/libensemble/gen_funcs/old_aposmm.py b/libensemble/gen_funcs/old_aposmm.py index 6c93af2d7f..6510528e42 100644 --- a/libensemble/gen_funcs/old_aposmm.py +++ b/libensemble/gen_funcs/old_aposmm.py @@ -884,7 +884,6 @@ def look_in_history(x, Run_H, vector_return=False): def calc_rk(n, n_s, rk_const, lhs_divisions=0): """ Calculate the critical distance r_k """ - if lhs_divisions == 0: r_k = rk_const*(log(n_s)/n_s)**(1/n) else: diff --git a/libensemble/gen_funcs/persistent_aposmm.py b/libensemble/gen_funcs/persistent_aposmm.py index b82f61ce10..b0a9ae6421 100644 --- a/libensemble/gen_funcs/persistent_aposmm.py +++ b/libensemble/gen_funcs/persistent_aposmm.py @@ -567,7 +567,6 @@ def decide_where_to_start_localopt(H, n, n_s, rk_const, ld=0, mu=0, nu=0): def calc_rk(n, n_s, rk_const, lhs_divisions=0): """ Calculate the critical distance r_k """ - if lhs_divisions == 0: r_k = rk_const*(log(n_s)/n_s)**(1/n) else: diff --git a/libensemble/gen_funcs/persistent_sampling.py b/libensemble/gen_funcs/persistent_sampling.py index 2bfabc1bcd..0cdacfe0a2 100644 --- a/libensemble/gen_funcs/persistent_sampling.py +++ b/libensemble/gen_funcs/persistent_sampling.py @@ -7,7 +7,9 @@ "persistent_uniform", "uniform_random_sample_with_variable_resources", "persistent_request_shutdown", + "uniform_nonblocking", "batched_history_matching", + "persistent_uniform_with_cancellations", ] @@ -204,3 +206,34 @@ def batched_history_matching(H, persis_info, gen_specs, libE_info): Sigma = np.cov(H_o["x"][best_inds].T) return H_o, persis_info, FINISHED_PERSISTENT_GEN_TAG + + +def persistent_uniform_with_cancellations(H, persis_info, gen_specs, libE_info): + + ub = gen_specs["user"]["ub"] + lb = gen_specs["user"]["lb"] + n = len(lb) + b = gen_specs["user"]["initial_batch_size"] + + # Start cancelling points from half initial batch onward + cancel_from = b // 2 # Should get at least this many points back + + ps = PersistentSupport(libE_info, EVAL_GEN_TAG) + + # Send batches until manager sends stop tag + tag = None + while tag not in [STOP_TAG, PERSIS_STOP]: + + H_o = np.zeros(b, dtype=gen_specs["out"]) + H_o["x"] = persis_info["rand_stream"].uniform(lb, ub, (b, n)) + tag, Work, calc_in = ps.send_recv(H_o) + + if hasattr(calc_in, "__len__"): + b = len(calc_in) + + # Cancel as many points as got back + cancel_ids = list(range(cancel_from, cancel_from + b)) + cancel_from += b + ps.request_cancel_sim_ids(cancel_ids) + + return H_o, persis_info, FINISHED_PERSISTENT_GEN_TAG diff --git a/libensemble/gen_funcs/persistent_surmise_calib.py b/libensemble/gen_funcs/persistent_surmise_calib.py index 31842fb3fb..4e8945f7f5 100644 --- a/libensemble/gen_funcs/persistent_surmise_calib.py +++ b/libensemble/gen_funcs/persistent_surmise_calib.py @@ -97,11 +97,7 @@ def cancel_columns(obs_offset, c, n_x, pending, ps): sim_ids_to_cancel.append(sim_id_cancel) pending[i, c] = 0 - # Send only these fields to existing H rows and libEnsemble will slot in the change. - H_o = np.zeros(len(sim_ids_to_cancel), dtype=[("sim_id", int), ("cancel_requested", bool)]) - H_o["sim_id"] = sim_ids_to_cancel - H_o["cancel_requested"] = True - ps.send(H_o) + ps.request_cancel_sim_ids(sim_ids_to_cancel) def assign_priority(n_x, n_thetas): diff --git a/libensemble/gen_funcs/surmise_calib_support.py b/libensemble/gen_funcs/surmise_calib_support.py index b75c8c3c62..c4d475cad3 100644 --- a/libensemble/gen_funcs/surmise_calib_support.py +++ b/libensemble/gen_funcs/surmise_calib_support.py @@ -1,5 +1,4 @@ """Contains supplemental methods for gen function in persistent_surmise_calib.py.""" - import numpy as np import scipy.stats as sps diff --git a/libensemble/history.py b/libensemble/history.py index deabef2982..232a8e3698 100644 --- a/libensemble/history.py +++ b/libensemble/history.py @@ -200,7 +200,7 @@ def update_history_x_in(self, gen_worker, D, safe_mode, gen_started_time): # Ensure there aren't any gaps in the generated sim_id values: assert np.all( np.in1d(np.arange(self.index, np.max(D["sim_id"]) + 1), D["sim_id"]) - ), "The generator function has produced sim_id that are not in order." + ), "The generator function has produced sim_ids that are not in order." num_new = len(np.setdiff1d(D["sim_id"], self.H["sim_id"])) diff --git a/libensemble/libE.py b/libensemble/libE.py index 69afedec36..3df4497834 100644 --- a/libensemble/libE.py +++ b/libensemble/libE.py @@ -102,7 +102,7 @@ On macOS (since Python 3.8) and Windows, the default multiprocessing start method is ``'spawn'`` and you must place most calling script code (or just ``libE()`` / ``Ensemble().run()`` at a minimum) in -an ``if __name__ == "__main__:" block. +an ``if __name__ == "__main__:"`` block. Therefore a calling script that is universal across all platforms and comms-types may resemble: @@ -142,7 +142,7 @@ H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) -Alternatively, you may set the multiprocesing start method to ``'fork'`` via the following: +Alternatively, you may set the multiprocessing start method to ``'fork'`` via the following: from multiprocessing import set_start_method set_start_method("fork") @@ -297,12 +297,12 @@ def manager( on_cleanup=None, ): """Generic manager routine run.""" - logger.info("Logger initializing: [workerID] precedes each line. [0] = Manager") logger.info("libE version v{}".format(__version__)) if "out" in gen_specs and ("sim_id", int) in gen_specs["out"]: - logger.manager_warning(_USER_SIM_ID_WARNING) + if "libensemble.gen_funcs" not in gen_specs["gen_f"].__module__: + logger.manager_warning(_USER_SIM_ID_WARNING) save_H = libE_specs.get("save_H_and_persis_on_abort", True) @@ -364,7 +364,6 @@ def comms_abort(mpi_comm): def libE_mpi_defaults(libE_specs): """Fill in default values for MPI-based communicators.""" - from mpi4py import MPI if "mpi_comm" not in libE_specs: @@ -375,7 +374,6 @@ def libE_mpi_defaults(libE_specs): def libE_mpi(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs, H0): """MPI version of the libE main routine""" - libE_specs, mpi_comm_null = libE_mpi_defaults(libE_specs) if libE_specs["mpi_comm"] == mpi_comm_null: @@ -415,7 +413,6 @@ def libE_mpi(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE def libE_mpi_manager(mpi_comm, sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs, H0): """Manager routine runs on rank 0.""" - from libensemble.comms.mpi import MainMPIComm hist = History(alloc_specs, sim_specs, gen_specs, exit_criteria, H0) @@ -455,7 +452,6 @@ def on_abort(): def libE_mpi_worker(libE_comm, sim_specs, gen_specs, libE_specs): """Worker routines run on ranks > 0.""" - from libensemble.comms.mpi import MainMPIComm comm = MainMPIComm(libE_comm) @@ -468,7 +464,6 @@ def libE_mpi_worker(libE_comm, sim_specs, gen_specs, libE_specs): def start_proc_team(nworkers, sim_specs, gen_specs, libE_specs, log_comm=True): """Launch a process worker team.""" - resources = Resources.resources executor = Executor.executor @@ -493,7 +488,6 @@ def kill_proc_team(wcomms, timeout): def libE_local(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs, H0): """Main routine for thread/process launch of libE.""" - nworkers = libE_specs["nworkers"] check_inputs(libE_specs, alloc_specs, sim_specs, gen_specs, exit_criteria, H0) @@ -559,7 +553,6 @@ def libE_tcp_default_ID(): def libE_tcp(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs, H0): """Main routine for TCP multiprocessing launch of libE.""" - check_inputs(libE_specs, alloc_specs, sim_specs, gen_specs, exit_criteria, H0) is_worker = True if "workerID" in libE_specs else False @@ -612,7 +605,6 @@ def libE_tcp_start_team(manager, nworkers, workers, ip, port, authkey, launchf): def libE_tcp_mgr(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs, H0): """Main routine for TCP multiprocessing launch of libE at manager.""" - hist = History(alloc_specs, sim_specs, gen_specs, exit_criteria, H0) # Set up a worker launcher @@ -660,7 +652,6 @@ def cleanup(): def libE_tcp_worker(sim_specs, gen_specs, libE_specs): """Main routine for TCP worker launched by libE.""" - ip = libE_specs["ip"] port = libE_specs["port"] authkey = libE_specs["authkey"] diff --git a/libensemble/manager.py b/libensemble/manager.py index 6cd5d1d853..af3755f83d 100644 --- a/libensemble/manager.py +++ b/libensemble/manager.py @@ -8,10 +8,12 @@ import glob import logging import socket +import platform import traceback import numpy as np from libensemble.utils.timer import Timer +from libensemble.utils.misc import extract_H_ranges from libensemble.message_numbers import ( EVAL_SIM_TAG, @@ -251,6 +253,8 @@ def _save_every_k(self, fname, count, k): """Saves history every kth step""" count = k * (count // k) filename = fname.format(self.date_start, count) + if platform.system() == "Windows": + filename = filename.replace(":", "-") # ":" is invalid in windows filenames if not os.path.isfile(filename) and count > 0: for old_file in glob.glob(fname.format(self.date_start, "*")): os.remove(old_file) @@ -320,13 +324,11 @@ def _set_resources(self, Work, w): def _freeup_resources(self, w): """Free up resources assigned to the worker""" - if self.resources: self.resources.resource_manager.free_rsets(w) def _send_work_order(self, Work, w): """Sends an allocation function order to a worker""" - logger.debug("Manager sending work unit to worker {}".format(w)) if self.resources: @@ -340,9 +342,7 @@ def _send_work_order(self, Work, w): work_rows = Work["libE_info"]["H_rows"] work_name = calc_type_strings[Work["tag"]] logger.debug( - "Manager sending {} work to worker {}. Rows {}".format( - work_name, w, EnsembleDirectory.extract_H_ranges(Work) or None - ) + "Manager sending {} work to worker {}. Rows {}".format(work_name, w, extract_H_ranges(Work) or None) ) if len(work_rows): if "repack_fields" in globals(): @@ -357,7 +357,6 @@ def _send_work_order(self, Work, w): def _update_state_on_alloc(self, Work, w): """Updates a workers' active/idle status following an allocation order""" - self.W[w - 1]["active"] = Work["tag"] if "libE_info" in Work: if "persistent" in Work["libE_info"]: @@ -415,7 +414,8 @@ def _update_state_on_worker_msg(self, persis_info, D_recv, w): calc_status = D_recv["calc_status"] Manager._check_received_calc(D_recv) - if w not in self.persis_pending and not self.W[w - 1]["active_recv"]: + keep_state = D_recv["libE_info"].get("keep_state", False) + if w not in self.persis_pending and not self.W[w - 1]["active_recv"] and not keep_state: self.W[w - 1]["active"] = 0 if calc_status in [FINISHED_PERSISTENT_SIM_TAG, FINISHED_PERSISTENT_GEN_TAG]: @@ -547,7 +547,6 @@ def _sim_max_given(self): def _get_alloc_libE_info(self): """Selected statistics useful for alloc_f""" - return { "any_idle_workers": any(self.W["active"] == 0), "exit_criteria": self.exit_criteria, diff --git a/libensemble/message_numbers.py b/libensemble/message_numbers.py index 7392fd2086..adfcbc2448 100644 --- a/libensemble/message_numbers.py +++ b/libensemble/message_numbers.py @@ -41,6 +41,8 @@ # last_calc_status_rst_tag CALC_EXCEPTION = 35 # Reserved: Automatically used if user_f raised an exception +MAN_KILL_SIGNALS = [MAN_SIGNAL_FINISH, MAN_SIGNAL_KILL] + calc_status_strings = { UNSET_TAG: "Not set", FINISHED_PERSISTENT_SIM_TAG: "Persis sim finished", diff --git a/libensemble/output_directory.py b/libensemble/output_directory.py index da8a46bbc2..f905e037e0 100644 --- a/libensemble/output_directory.py +++ b/libensemble/output_directory.py @@ -1,10 +1,9 @@ import os import re import shutil -from itertools import groupby -from operator import itemgetter from libensemble.utils.loc_stack import LocationStack +from libensemble.utils.misc import extract_H_ranges from libensemble.tools.fields_keys import libE_spec_sim_dir_keys, libE_spec_gen_dir_keys, libE_spec_calc_dir_misc from libensemble.message_numbers import EVAL_SIM_TAG, calc_type_strings @@ -78,32 +77,13 @@ def make_copyback_check(self): def use_calc_dirs(self, type): """Determines calc_dirs enabling for each calc type""" - if type == EVAL_SIM_TAG: return self.sim_use else: return self.gen_use - @staticmethod - def extract_H_ranges(Work): - """Convert received H_rows into ranges for labeling""" - work_H_rows = Work["libE_info"]["H_rows"] - if len(work_H_rows) == 1: - return str(work_H_rows[0]) - else: - # From https://stackoverflow.com/a/30336492 - ranges = [] - for diff, group in groupby(enumerate(work_H_rows.tolist()), lambda x: x[0] - x[1]): - group = list(map(itemgetter(1), group)) - if len(group) > 1: - ranges.append(str(group[0]) + "-" + str(group[-1])) - else: - ranges.append(str(group[0])) - return "_".join(ranges) - def _make_calc_dir(self, workerID, H_rows, calc_str, locs): """Create calc dirs and intermediate dirs, copy inputs, based on libE_specs""" - if calc_str == "sim": input_dir = self.sim_input_dir do_calc_dirs = self.sim_dirs_make @@ -177,12 +157,11 @@ def _make_calc_dir(self, workerID, H_rows, calc_str, locs): def prep_calc_dir(self, Work, calc_iter, workerID, calc_type): """Determines choice for calc_dir structure, then performs calculation.""" - if not self.loc_stack: self.loc_stack = LocationStack() if calc_type == EVAL_SIM_TAG: - H_rows = self.extract_H_ranges(Work) + H_rows = extract_H_ranges(Work) else: H_rows = str(calc_iter[calc_type]) diff --git a/libensemble/resources/mpi_resources.py b/libensemble/resources/mpi_resources.py index 0abd7feb1b..bbe2764d48 100644 --- a/libensemble/resources/mpi_resources.py +++ b/libensemble/resources/mpi_resources.py @@ -36,7 +36,7 @@ def get_MPI_variant(): Returns ------- mpi_variant: string: - MPI variant 'aprun' or 'jsrun' or 'mpich' or 'openmpi' or 'srun' + MPI variant 'aprun' or 'jsrun' or 'msmpi' or 'mpich' or 'openmpi' or 'srun' """ @@ -52,6 +52,14 @@ def get_MPI_variant(): except Exception: pass + try: + try_msmpi = subprocess.Popen(["mpiexec"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + stdout, _ = try_msmpi.communicate() + if "Microsoft" in stdout.decode(): + return "msmpi" + except Exception: + pass + try: # Explore mpi4py.MPI.get_vendor() and mpi4py.MPI.Get_library_version() for mpi4py try_mpich = subprocess.Popen(["mpirun", "-npernode"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) diff --git a/libensemble/resources/node_resources.py b/libensemble/resources/node_resources.py index b76a649b66..cd6771c901 100644 --- a/libensemble/resources/node_resources.py +++ b/libensemble/resources/node_resources.py @@ -48,7 +48,6 @@ def _get_remote_cpu_resources(launcher): def _get_cpu_resources_from_env(env_resources=None): """Returns logical and physical cores per node by querying environment or None""" - if not env_resources: return None diff --git a/libensemble/resources/resources.py b/libensemble/resources/resources.py index e08e735a65..3f35cf509e 100644 --- a/libensemble/resources/resources.py +++ b/libensemble/resources/resources.py @@ -52,13 +52,11 @@ class Resources: @classmethod def init_resources(cls, libE_specs): """Initiate resource management""" - # If disable_resource_manager is True, then Resources.resources will remain None. disable_resource_manager = libE_specs.get("disable_resource_manager", False) if not disable_resource_manager: top_level_dir = os.getcwd() - if Resources.resources is None: - Resources.resources = Resources(libE_specs=libE_specs, top_level_dir=top_level_dir) + Resources.resources = Resources(libE_specs=libE_specs, top_level_dir=top_level_dir) def __init__(self, libE_specs, top_level_dir=None): """Initiate a new resources object""" @@ -164,9 +162,6 @@ def __init__(self, libE_specs, top_level_dir=None): self.num_resource_sets = libE_specs.get("num_resource_sets", None) self.enforce_worker_core_bounds = libE_specs.get("enforce_worker_core_bounds", False) - if self.dedicated_mode: - logger.debug("Running in dedicated mode") - resource_info = libE_specs.get("resource_info", {}) cores_on_node = resource_info.get("cores_on_node", None) node_file = resource_info.get("node_file", None) @@ -228,6 +223,7 @@ def add_comm_info(self, libE_nodes): self.global_nodelist = GlobalResources.remove_nodes(self.global_nodelist, self.libE_nodes) if not self.global_nodelist: logger.warning("Warning. Node-list for tasks is empty. Remove dedicated_mode or add nodes") + pass @staticmethod def is_nodelist_shortnames(nodelist): @@ -259,18 +255,15 @@ def get_global_nodelist(node_file=Resources.DEFAULT_NODEFILE, rundir=None, env_r node_filepath = os.path.join(top_level_dir, node_file) global_nodelist = [] if os.path.isfile(node_filepath): - logger.debug("node_file found - getting nodelist from node_file") with open(node_filepath, "r") as f: for line in f: global_nodelist.append(line.rstrip()) else: - logger.debug("No node_file found - searching for nodelist in environment") if env_resources: global_nodelist = env_resources.get_nodelist() if not global_nodelist: # Assume a standalone machine - logger.info("Can not find nodelist from environment. Assuming standalone") # global_nodelist.append(env_resources.shortnames([socket.gethostname()])[0]) global_nodelist.append(socket.gethostname()) diff --git a/libensemble/resources/scheduler.py b/libensemble/resources/scheduler.py index e27aff6159..89d02f6876 100644 --- a/libensemble/resources/scheduler.py +++ b/libensemble/resources/scheduler.py @@ -165,7 +165,6 @@ def assign_resources(self, rsets_req): def find_rsets_any_slots(self, rsets_by_group, max_grpsize, rsets_req, ngroups, rsets_per_group): """Find optimal non-matching slots across groups""" - tmp_rsets_by_group = copy.deepcopy(rsets_by_group) max_upper_bound = max_grpsize + 1 diff --git a/libensemble/resources/worker_resources.py b/libensemble/resources/worker_resources.py index bfc9f96403..8633f8ef6c 100644 --- a/libensemble/resources/worker_resources.py +++ b/libensemble/resources/worker_resources.py @@ -65,7 +65,6 @@ def __init__(self, num_workers, resources): def assign_rsets(self, rset_team, worker_id): """Mark the resource sets given by rset_team as assigned to worker_id""" - if rset_team: rteam = self.rsets["assigned"][rset_team] for i, wid in enumerate(rteam): @@ -307,7 +306,6 @@ def set_slot_count(self): @staticmethod def get_local_nodelist(workerID, rset_team, split_list, rsets_per_node): """Returns the list of nodes available to the given worker and the slot dictionary""" - if workerID is None: raise WorkerResourcesException("Worker has no workerID - aborting") diff --git a/libensemble/sim_funcs/borehole_kills.py b/libensemble/sim_funcs/borehole_kills.py index 65a4bbdbd3..1a6fc22c83 100644 --- a/libensemble/sim_funcs/borehole_kills.py +++ b/libensemble/sim_funcs/borehole_kills.py @@ -1,7 +1,7 @@ import numpy as np from libensemble.executors.executor import Executor from libensemble.sim_funcs.surmise_test_function import borehole_true -from libensemble.message_numbers import TASK_FAILED, MAN_SIGNAL_KILL, UNSET_TAG +from libensemble.message_numbers import UNSET_TAG, TASK_FAILED, MAN_KILL_SIGNALS def subproc_borehole(H, delay): @@ -23,7 +23,7 @@ def subproc_borehole(H, delay): task = exctr.submit(app_name="borehole", app_args=args, stdout="out.txt", stderr="err.txt") calc_status = exctr.polling_loop(task, delay=0.01, poll_manager=True) - if calc_status in [MAN_SIGNAL_KILL, TASK_FAILED]: + if calc_status in MAN_KILL_SIGNALS + [TASK_FAILED]: f = np.inf else: f = float(task.read_stdout()) @@ -46,12 +46,15 @@ def borehole(H, persis_info, sim_specs, libE_info): f, calc_status = subproc_borehole(H, delay) - # Failure model (excluding observations) - if sim_id > sim_specs["user"]["num_obs"]: - if (f / borehole_true(H["x"])) > 1.25: - f = np.inf - calc_status = TASK_FAILED - print("Failure of sim_id {}".format(sim_id), flush=True) + if calc_status in MAN_KILL_SIGNALS and "sim_killed" in H_o.dtype.names: + H_o["sim_killed"] = True # For calling script to print only. + else: + # Failure model (excluding observations) + if sim_id > sim_specs["user"]["num_obs"]: + if (f / borehole_true(H["x"])) > 1.25: + f = np.inf + calc_status = TASK_FAILED + print("Failure of sim_id {}".format(sim_id), flush=True) H_o["f"] = f return H_o, persis_info, calc_status diff --git a/libensemble/sim_funcs/branin/branin_obj.py b/libensemble/sim_funcs/branin/branin_obj.py index 87c4e19811..a6189353f2 100644 --- a/libensemble/sim_funcs/branin/branin_obj.py +++ b/libensemble/sim_funcs/branin/branin_obj.py @@ -9,7 +9,6 @@ def call_branin(H, persis_info, sim_specs, _): """Evaluates the Branin function""" - batch = len(H["x"]) H_o = np.zeros(batch, dtype=sim_specs["out"]) diff --git a/libensemble/sim_funcs/executor_hworld.py b/libensemble/sim_funcs/executor_hworld.py index afdf7703eb..f86e15b7ba 100644 --- a/libensemble/sim_funcs/executor_hworld.py +++ b/libensemble/sim_funcs/executor_hworld.py @@ -24,8 +24,7 @@ def custom_polling_loop(exctr, task, timeout_sec=5.0, delay=0.3): while task.runtime < timeout_sec: time.sleep(delay) - exctr.manager_poll() - if exctr.manager_signal == "finish": + if exctr.manager_kill_received(): exctr.kill(task) calc_status = MAN_SIGNAL_FINISH # Worker will pick this up and close down print("Task {} killed by manager on worker {}".format(task.id, exctr.workerID)) @@ -77,101 +76,106 @@ def executor_hworld(H, persis_info, sim_specs, libE_info): wait = False args_for_sim = "sleep 1" + calc_status = UNSET_TAG - if ELAPSED_TIMEOUT: - args_for_sim = "sleep 60" # Manager kill - if signal received else completes - timeout = 65.0 + batch = len(H["x"]) + H_o = np.zeros(batch, dtype=sim_specs["out"]) + + if "six_hump_camel" not in exctr.default_app("sim").full_path: - else: global sim_ended_count sim_ended_count += 1 - timeout = 6.0 - launch_shc = False - print(sim_ended_count) - - if sim_ended_count == 1: - args_for_sim = "sleep 1" # Should finish - elif sim_ended_count == 2: - args_for_sim = "sleep 1 Error" # Worker kill on error - elif sim_ended_count == 3: - wait = True - args_for_sim = "sleep 1" # Should finish - launch_shc = True - elif sim_ended_count == 4: - args_for_sim = "sleep 8" # Worker kill on timeout - timeout = 1.0 - elif sim_ended_count == 5: - args_for_sim = "sleep 2 Fail" # Manager kill - if signal received else completes - - if USE_BALSAM: - task = exctr.submit( - calc_type="sim", - num_procs=cores, - app_args=args_for_sim, - hyperthreads=True, - machinefile="notused", - stdout="notused", - wait_on_start=True, - ) - else: - task = exctr.submit(calc_type="sim", num_procs=cores, app_args=args_for_sim, hyperthreads=True) + print("sim_ended_count", sim_ended_count, flush=True) - if wait: - task.wait() - if not task.finished: - calc_status = UNSET_TAG - if task.state == "FINISHED": - calc_status = WORKER_DONE - elif task.state == "FAILED": - calc_status = TASK_FAILED + if ELAPSED_TIMEOUT: + args_for_sim = "sleep 60" # Manager kill - if signal received else completes + timeout = 65.0 - else: - if not ELAPSED_TIMEOUT: + else: + timeout = 6.0 + launch_shc = False + + if sim_ended_count == 1: + args_for_sim = "sleep 1" # Should finish + elif sim_ended_count == 2: + args_for_sim = "sleep 1 Error" # Worker kill on error + elif sim_ended_count == 3: + wait = True + args_for_sim = "sleep 1" # Should finish + launch_shc = True + elif sim_ended_count == 4: + args_for_sim = "sleep 8" # Worker kill on timeout + timeout = 1.0 + elif sim_ended_count == 5: + args_for_sim = "sleep 2 Fail" # Manager kill - if signal received else completes + + if USE_BALSAM: + task = exctr.submit( + calc_type="sim", + num_procs=cores, + app_args=args_for_sim, + hyperthreads=True, + machinefile="notused", + stdout="notused", + wait_on_start=True, + ) + else: + task = exctr.submit(calc_type="sim", num_procs=cores, app_args=args_for_sim, hyperthreads=True) + + if wait: + task.wait() + if not task.finished: + calc_status = UNSET_TAG + if task.state == "FINISHED": + calc_status = WORKER_DONE + elif task.state == "FAILED": + calc_status = TASK_FAILED + + else: if sim_ended_count >= 2 and not USE_BALSAM: calc_status = exctr.polling_loop(task, timeout=timeout, delay=0.3, poll_manager=True) if sim_ended_count == 2 and task.stdout_exists() and "Error" in task.read_stdout(): calc_status = WORKER_KILL_ON_ERR - else: task, calc_status = custom_polling_loop(exctr, task, timeout) - else: - calc_status = exctr.polling_loop(task, timeout=timeout, delay=0.3, poll_manager=True) - - if USE_BALSAM: - task.read_file_in_workdir("ensemble.log") - try: - task.read_stderr() - except ValueError: - pass - - task = exctr.submit( - app_name="sim_hump_camel_dry_run", - num_procs=cores, - app_args=args_for_sim, - hyperthreads=True, - machinefile="notused", - stdout="notused", - wait_on_start=True, - dry_run=True, - stage_inout=os.getcwd(), - ) - - task.poll() - task.wait() - - # This is temp - return something - so doing six_hump_camel_func again... - batch = len(H["x"]) - H_o = np.zeros(batch, dtype=sim_specs["out"]) - for i, x in enumerate(H["x"]): - H_o["f"][i] = six_hump_camel_func(x) - if launch_shc: - # Test launching a named app. - app_args = " ".join(str(val) for val in list(x[:])) - task = exctr.submit(app_name="six_hump_camel", num_procs=1, app_args=app_args) + if USE_BALSAM: + task.read_file_in_workdir("ensemble.log") + try: + task.read_stderr() + except ValueError: + pass + + task = exctr.submit( + app_name="sim_hump_camel_dry_run", + num_procs=cores, + app_args=args_for_sim, + hyperthreads=True, + machinefile="notused", + stdout="notused", + wait_on_start=True, + dry_run=True, + stage_inout=os.getcwd(), + ) + + task.poll() task.wait() - output = np.float64(task.read_stdout()) - assert np.isclose(H_o["f"][i], output) + + else: + launch_shc = True + calc_status = UNSET_TAG + + # This is temp - return something - so doing six_hump_camel_func again... + for i, x in enumerate(H["x"]): + H_o["f"][i] = six_hump_camel_func(x) + if launch_shc: + # Test launching a named app. + app_args = " ".join(str(val) for val in list(x[:])) + task = exctr.submit(app_name="six_hump_camel", num_procs=1, app_args=app_args) + task.wait() + output = np.float64(task.read_stdout()) + assert np.isclose(H_o["f"][i], output) + calc_status = WORKER_DONE # This is just for testing at calling script level - status of each task H_o["cstat"] = calc_status diff --git a/libensemble/sim_funcs/noisy_vector_mapping.py b/libensemble/sim_funcs/noisy_vector_mapping.py index f9a88553d7..26938d1e8a 100644 --- a/libensemble/sim_funcs/noisy_vector_mapping.py +++ b/libensemble/sim_funcs/noisy_vector_mapping.py @@ -26,7 +26,6 @@ def func_wrapper(H, persis_info, sim_specs, libE_info): def noisy_function(x): """ """ - x1 = x[0] x2 = x[1] term1 = (4 - 2.1 * x1**2 + (x1**4) / 3) * x1**2 diff --git a/libensemble/tests/.coveragerc b/libensemble/tests/.coveragerc index 6156169def..3e1a312766 100644 --- a/libensemble/tests/.coveragerc +++ b/libensemble/tests/.coveragerc @@ -20,7 +20,6 @@ omit = */regression_tests/* */sim_funcs/helloworld.py */sim_funcs/executor_hworld.py - */balsam_executor.py */legacy_balsam_executor.py */forkable_pdb.py */parse_args.py diff --git a/libensemble/tests/deprecated_tests/balsam_tests/setup_balsam_tests.py b/libensemble/tests/deprecated_tests/balsam_tests/setup_balsam_tests.py index 062fbf031d..1ff285e0dd 100755 --- a/libensemble/tests/deprecated_tests/balsam_tests/setup_balsam_tests.py +++ b/libensemble/tests/deprecated_tests/balsam_tests/setup_balsam_tests.py @@ -1,7 +1,6 @@ #!/usr/bin/env python """ Script to set up apps and jobs for balsam tests """ - # Note: To see use of command line interface see bash_scripts/setup_balsam_tests.sh script. # Currently that script does not create deps between jobs so may run simultaneously # This script tests setup within python (could in theory be integrated with job!) diff --git a/libensemble/tests/deprecated_tests/standalone_executor_tests/test_executor_manager_poll.py b/libensemble/tests/deprecated_tests/standalone_executor_tests/test_executor_manager_poll.py index ccd50e4fe3..e74cfc8ed3 100644 --- a/libensemble/tests/deprecated_tests/standalone_executor_tests/test_executor_manager_poll.py +++ b/libensemble/tests/deprecated_tests/standalone_executor_tests/test_executor_manager_poll.py @@ -12,6 +12,7 @@ import os from libensemble.executors.executor import Executor +from libensemble.message_numbers import MAN_SIGNAL_KILL def build_simfunc(): @@ -68,14 +69,14 @@ def polling_loop(exctr, task, timeout_sec=20.0, delay=2.0): exctr.manager_poll(task) - if task.manager_signal == "kill": + if task.manager_signal == MAN_SIGNAL_KILL: print("Manager has sent kill signal - killing task") exctr.kill(task) # In future might support other manager signals eg: - elif task.manager_signal == "pause": - # checkpoint_task() - pass + # elif task.manager_signal == "pause": + # checkpoint_task() + # pass time.sleep(delay) print("Polling at time", time.time() - start) diff --git a/libensemble/tests/regression_tests/check_libE_stats.py b/libensemble/tests/functionality_tests/check_libE_stats.py similarity index 100% rename from libensemble/tests/regression_tests/check_libE_stats.py rename to libensemble/tests/functionality_tests/check_libE_stats.py diff --git a/libensemble/tests/functionality_tests/test_1d_uniform_sampling_with_comm_dup.py b/libensemble/tests/functionality_tests/test_1d_uniform_sampling_with_comm_dup.py index 987b9eea99..ab81c9ce89 100644 --- a/libensemble/tests/functionality_tests/test_1d_uniform_sampling_with_comm_dup.py +++ b/libensemble/tests/functionality_tests/test_1d_uniform_sampling_with_comm_dup.py @@ -13,6 +13,7 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: mpi # TESTSUITE_NPROCS: 2 4 +# TESTSUITE_OS_SKIP: WIN import sys import numpy as np diff --git a/libensemble/tests/functionality_tests/test_executor_hworld_pass_fail.py b/libensemble/tests/functionality_tests/test_executor_hworld_pass_fail.py index ccfa4d1e45..90cb7dfd9b 100644 --- a/libensemble/tests/functionality_tests/test_executor_hworld_pass_fail.py +++ b/libensemble/tests/functionality_tests/test_executor_hworld_pass_fail.py @@ -26,9 +26,10 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: mpi local tcp -# TESTSUITE_OS_SKIP: OSX +# TESTSUITE_OS_SKIP: OSX WIN # TESTSUITE_NPROCS: 2 3 4 # TESTSUITE_OMPI_SKIP: true +# TESTSUITE_EXTRA: true # Main block is necessary only when using local comms with spawn start method (default on macOS and Windows). if __name__ == "__main__": diff --git a/libensemble/tests/functionality_tests/test_executor_hworld_timeout.py b/libensemble/tests/functionality_tests/test_executor_hworld_timeout.py index e953d23739..fa8bb45d08 100644 --- a/libensemble/tests/functionality_tests/test_executor_hworld_timeout.py +++ b/libensemble/tests/functionality_tests/test_executor_hworld_timeout.py @@ -26,7 +26,8 @@ # TESTSUITE_COMMS: mpi local tcp # TESTSUITE_NPROCS: 2 3 4 # TESTSUITE_OMPI_SKIP: true -# TESTSUITE_OS_SKIP: OSX +# TESTSUITE_OS_SKIP: OSX WIN +# TESTSUITE_EXTRA: true # Main block is necessary only when using local comms with spawn start method (default on macOS and Windows). if __name__ == "__main__": @@ -85,23 +86,31 @@ persis_info = add_unique_random_streams({}, nworkers + 1) - exit_criteria = {"wallclock_max": 30} + exit_criteria = {"wallclock_max": 10} - # Perform the run - H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) + # TCP does not support multiple libE calls + if libE_specs["comms"] == "tcp": + iterations = 1 + else: + iterations = 2 - if is_manager: - print("\nChecking expected task status against Workers ...\n") + for i in range(iterations): + + # Perform the run + H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) + + if is_manager: + print("\nChecking expected task status against Workers ...\n") - calc_status_list_in = np.asarray([0]) - calc_status_list = np.repeat(calc_status_list_in, nworkers) + calc_status_list_in = np.asarray([0]) + calc_status_list = np.repeat(calc_status_list_in, nworkers) - # For debug - print("Expecting: {}".format(calc_status_list)) - print("Received: {}\n".format(H["cstat"])) + # For debug + print("Expecting: {}".format(calc_status_list)) + print("Received: {}\n".format(H["cstat"])) - assert np.array_equal(H["cstat"], calc_status_list), "Error - unexpected calc status. Received: " + str( - H["cstat"] - ) + assert np.array_equal(H["cstat"], calc_status_list), "Error - unexpected calc status. Received: " + str( + H["cstat"] + ) - print("\n\n\nRun completed.") + print("\n\n\nRun completed.") diff --git a/libensemble/tests/functionality_tests/test_executor_simple.py b/libensemble/tests/functionality_tests/test_executor_simple.py new file mode 100644 index 0000000000..c09e5037bc --- /dev/null +++ b/libensemble/tests/functionality_tests/test_executor_simple.py @@ -0,0 +1,82 @@ +""" +Runs libEnsemble testing the executor functionality. + +Execute via one of the following commands (e.g. 3 workers): + mpiexec -np 4 python test_executor_hworld.py + python test_executor_hworld.py --nworkers 3 --comms local + python test_executor_hworld.py --nworkers 3 --comms tcp + +The number of concurrent evaluations of the objective function will be 4-1=3. +""" + +import numpy as np + +# Import libEnsemble items for this test +from libensemble.message_numbers import WORKER_DONE +from libensemble.libE import libE +from libensemble.sim_funcs.executor_hworld import executor_hworld as sim_f +import libensemble.sim_funcs.six_hump_camel as six_hump_camel +from libensemble.gen_funcs.sampling import uniform_random_sample as gen_f +from libensemble.tools import parse_args, add_unique_random_streams +from libensemble.executors.mpi_executor import MPIExecutor + + +# Do not change these lines - they are parsed by run-tests.sh +# TESTSUITE_COMMS: mpi local +# TESTSUITE_NPROCS: 4 +# TESTSUITE_OMPI_SKIP: true + +# Main block is necessary only when using local comms with spawn start method (default on macOS and Windows). +if __name__ == "__main__": + + nworkers, is_manager, libE_specs, _ = parse_args() + + cores_per_task = 1 + cores_all_tasks = nworkers * cores_per_task + + sim_app2 = six_hump_camel.__file__ + + exctr = MPIExecutor() + exctr.register_app(full_path=sim_app2, app_name="six_hump_camel", calc_type="sim") # Named app + + sim_specs = { + "sim_f": sim_f, + "in": ["x"], + "out": [("f", float), ("cstat", int)], + "user": {"cores": cores_per_task}, + } + + gen_specs = { + "gen_f": gen_f, + "in": ["sim_id"], + "out": [("x", float, (2,))], + "user": { + "lb": np.array([-3, -2]), + "ub": np.array([3, 2]), + "gen_batch_size": nworkers, + }, + } + + persis_info = add_unique_random_streams({}, nworkers + 1) + + # num sim_ended_count conditions in executor_hworld + exit_criteria = {"sim_max": nworkers * 5} + + # Perform the run + H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) + + if is_manager: + print("\nChecking expected task status against Workers ...\n") + + calc_status_list_in = np.asarray([WORKER_DONE] * 5) + calc_status_list = np.repeat(calc_status_list_in, nworkers) + + # For debug + print("Expecting: {}".format(calc_status_list)) + print("Received: {}\n".format(H["cstat"])) + + assert np.array_equal(H["cstat"], calc_status_list), "Error - unexpected calc status. Received: " + str( + H["cstat"] + ) + + print("\n\n\nRun completed.") diff --git a/libensemble/tests/functionality_tests/test_mpi_runners_zrw_subnode_uneven.py b/libensemble/tests/functionality_tests/test_mpi_runners_zrw_subnode_uneven.py index 933d7c0544..8bbe372884 100644 --- a/libensemble/tests/functionality_tests/test_mpi_runners_zrw_subnode_uneven.py +++ b/libensemble/tests/functionality_tests/test_mpi_runners_zrw_subnode_uneven.py @@ -7,6 +7,13 @@ mpiexec -np 7 python test_mpi_runners_zrw_subnode_uneven.py python test_mpi_runners_zrw_subnode_uneven.py --nworkers 6 --comms local python test_mpi_runners_zrw_subnode_uneven.py --nworkers 6 --comms tcp + +The resource sets are split unevenly between the two nodes (e.g. 3 and 2). + +Two tests are run. In the first, num_resource_sets is used, and thus the dynamic scheduler. +This will fill node two slots first as there are fewer resource sets on node two, and the +scheduler will preference a smaller space for assigning the task. On the second test, +zero_resource_workers are used, and the static scheduler will fill node one first. """ import sys @@ -36,7 +43,6 @@ sim_app = "/path/to/fakeapp.x" comms = libE_specs["comms"] - libE_specs["zero_resource_workers"] = [1] libE_specs["dedicated_mode"] = True libE_specs["enforce_worker_core_bounds"] = True @@ -45,8 +51,7 @@ logger.set_filename(log_file) # For varying size test - relate node count to nworkers - in_place = libE_specs["zero_resource_workers"] - n_gens = len(in_place) + n_gens = 1 nsim_workers = nworkers - n_gens if nsim_workers % 2 == 0: @@ -96,7 +101,6 @@ } alloc_specs = {"alloc_f": alloc_f, "out": []} - persis_info = add_unique_random_streams({}, nworkers + 1) exit_criteria = {"sim_max": (nsim_workers) * rounds} test_list_base = [ @@ -141,7 +145,22 @@ "persis_gens": n_gens, } - # Perform the run - H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs) + iterations = 2 + for prob_id in range(iterations): - # All asserts are in sim func + if prob_id == 0: + # Uses dynamic scheduler - will find node 2 slots first (as fewer) + libE_specs["num_resource_sets"] = nworkers - 1 # Any worker can be the gen + sim_specs["user"]["offset_for_scheduler"] = True # Changes expected values + persis_info = add_unique_random_streams({}, nworkers + 1) + + else: + # Uses static scheduler - will find node 1 slots first + del libE_specs["num_resource_sets"] + libE_specs["zero_resource_workers"] = [1] # Gen must be worker 1 + sim_specs["user"]["offset_for_scheduler"] = False + persis_info = add_unique_random_streams({}, nworkers + 1) + + # Perform the run + H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs) + # Run-line asserts are in sim func diff --git a/libensemble/tests/functionality_tests/test_runlines_adaptive_workers_persistent.py b/libensemble/tests/functionality_tests/test_runlines_adaptive_workers_persistent.py index 38f27fc1f1..9b1c49a170 100644 --- a/libensemble/tests/functionality_tests/test_runlines_adaptive_workers_persistent.py +++ b/libensemble/tests/functionality_tests/test_runlines_adaptive_workers_persistent.py @@ -36,8 +36,9 @@ nworkers, is_manager, libE_specs, _ = parse_args() - libE_specs["zero_resource_workers"] = [1] - num_gens = len(libE_specs["zero_resource_workers"]) + num_gens = 1 + libE_specs["num_resource_sets"] = nworkers - num_gens # Any worker can be the gen + total_nodes = (nworkers - num_gens) // 4 # 4 resourced workers per node. if total_nodes == 1: diff --git a/libensemble/tests/functionality_tests/test_sim_dirs_per_worker.py b/libensemble/tests/functionality_tests/test_sim_dirs_per_worker.py index eeb507b2be..a8ec5c8596 100644 --- a/libensemble/tests/functionality_tests/test_sim_dirs_per_worker.py +++ b/libensemble/tests/functionality_tests/test_sim_dirs_per_worker.py @@ -13,6 +13,7 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: mpi local tcp # TESTSUITE_NPROCS: 2 4 +# TESTSUITE_EXTRA: true import numpy as np import os diff --git a/libensemble/tests/regression_tests/test_stats_output.py b/libensemble/tests/functionality_tests/test_stats_output.py similarity index 100% rename from libensemble/tests/regression_tests/test_stats_output.py rename to libensemble/tests/functionality_tests/test_stats_output.py diff --git a/libensemble/tests/regression_tests/test_persistent_gp_multitask_ax.py b/libensemble/tests/regression_tests/dontrun_test_persistent_gp_multitask_ax.py similarity index 80% rename from libensemble/tests/regression_tests/test_persistent_gp_multitask_ax.py rename to libensemble/tests/regression_tests/dontrun_test_persistent_gp_multitask_ax.py index ce8176d258..1d0e2fabd4 100644 --- a/libensemble/tests/regression_tests/test_persistent_gp_multitask_ax.py +++ b/libensemble/tests/regression_tests/dontrun_test_persistent_gp_multitask_ax.py @@ -26,17 +26,40 @@ from libensemble.tools import save_libE_output, add_unique_random_streams from libensemble.tools import parse_args from libensemble.message_numbers import WORKER_DONE -from libensemble.gen_funcs.persistent_ax_multitask import persistent_gp_mt_ax_gen_f import warnings +# Ax uses a deprecated warn command. +warnings.filterwarnings("ignore", category=UserWarning) +warnings.filterwarnings("ignore", category=DeprecationWarning) + +from libensemble.gen_funcs.persistent_ax_multitask import persistent_gp_mt_ax_gen_f + + +def run_simulation(H, persis_info, sim_specs, libE_info): + # Extract input parameters + values = list(H["x"][0]) + x0 = values[0] + x1 = values[1] + # Extract fidelity parameter + task = H["task"][0] + if task == "expensive_model": + z = 8 + elif task == "cheap_model": + z = 1 + + libE_output = np.zeros(1, dtype=sim_specs["out"]) + calc_status = WORKER_DONE + + # Function that depends on the resolution parameter + libE_output["f"] = -(x0 + 10 * np.cos(x0 + 0.1 * z)) * (x1 + 5 * np.cos(x1 - 0.2 * z)) + + return libE_output, persis_info, calc_status + + # Main block is necessary only when using local comms with spawn start method (default on macOS and Windows). if __name__ == "__main__": - # Ax uses a deprecated warn command. - warnings.filterwarnings("ignore", category=UserWarning) - warnings.filterwarnings("ignore", category=DeprecationWarning) - nworkers, is_manager, libE_specs, _ = parse_args() mt_params = { @@ -48,26 +71,6 @@ "n_opt_lofi": 4, } - def run_simulation(H, persis_info, sim_specs, libE_info): - # Extract input parameters - values = list(H["x"][0]) - x0 = values[0] - x1 = values[1] - # Extract fidelity parameter - task = H["task"][0] - if task == "expensive_model": - z = 8 - elif task == "cheap_model": - z = 1 - - libE_output = np.zeros(1, dtype=sim_specs["out"]) - calc_status = WORKER_DONE - - # Function that depends on the resolution parameter - libE_output["f"] = -(x0 + 10 * np.cos(x0 + 0.1 * z)) * (x1 + 5 * np.cos(x1 - 0.2 * z)) - - return libE_output, persis_info, calc_status - sim_specs = { "sim_f": run_simulation, "in": ["x", "task"], diff --git a/libensemble/tests/regression_tests/dont_run_test_persistent_gp.py b/libensemble/tests/regression_tests/run_test_persistent_gp.py similarity index 100% rename from libensemble/tests/regression_tests/dont_run_test_persistent_gp.py rename to libensemble/tests/regression_tests/run_test_persistent_gp.py diff --git a/libensemble/tests/regression_tests/test_persistent_aposmm_external_localopt.py b/libensemble/tests/regression_tests/test_persistent_aposmm_external_localopt.py index 7d24043446..96b37b58b5 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_external_localopt.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_external_localopt.py @@ -19,7 +19,7 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: local mpi tcp # TESTSUITE_NPROCS: 4 -# TESTSUITE_OS_SKIP: OSX +# TESTSUITE_OS_SKIP: OSX WIN # TESTSUITE_EXTRA: true import sys diff --git a/libensemble/tests/regression_tests/test_persistent_aposmm_nlopt.py b/libensemble/tests/regression_tests/test_persistent_aposmm_nlopt.py index 6b65de580b..cb58850a0e 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_nlopt.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_nlopt.py @@ -14,10 +14,8 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: local mpi tcp # TESTSUITE_NPROCS: 3 -# TESTSUITE_EXTRA: true import sys -import multiprocessing import numpy as np # Import libEnsemble items for this test @@ -38,9 +36,6 @@ # Main block is necessary only when using local comms with spawn start method (default on macOS and Windows). if __name__ == "__main__": - # Temporary solution while we investigate/resolve slowdowns with "spawn" start method. - multiprocessing.set_start_method("fork", force=True) - nworkers, is_manager, libE_specs, _ = parse_args() if is_manager: diff --git a/libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_pounders.py b/libensemble/tests/regression_tests/test_persistent_aposmm_pounders.py similarity index 100% rename from libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_pounders.py rename to libensemble/tests/regression_tests/test_persistent_aposmm_pounders.py diff --git a/libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_tao_blmvm.py b/libensemble/tests/regression_tests/test_persistent_aposmm_tao_blmvm.py similarity index 100% rename from libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_tao_blmvm.py rename to libensemble/tests/regression_tests/test_persistent_aposmm_tao_blmvm.py diff --git a/libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_tao_nm.py b/libensemble/tests/regression_tests/test_persistent_aposmm_tao_nm.py similarity index 100% rename from libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_tao_nm.py rename to libensemble/tests/regression_tests/test_persistent_aposmm_tao_nm.py diff --git a/libensemble/tests/regression_tests/test_persistent_sampling_CUDA_variable_resources.py b/libensemble/tests/regression_tests/test_persistent_sampling_CUDA_variable_resources.py index 96ec1279fe..0240460607 100644 --- a/libensemble/tests/regression_tests/test_persistent_sampling_CUDA_variable_resources.py +++ b/libensemble/tests/regression_tests/test_persistent_sampling_CUDA_variable_resources.py @@ -30,7 +30,12 @@ nworkers, is_manager, libE_specs, _ = parse_args() - libE_specs["zero_resource_workers"] = [1] + # The persistent gen does not need resources + + libE_specs["num_resource_sets"] = nworkers - 1 # Any worker can be the gen + + # libE_specs["zero_resource_workers"] = [1] # If first worker must be gen, use this instead + libE_specs["sim_dirs_make"] = True libE_specs["ensemble_dir_path"] = "./ensemble_CUDA_variable_w" + str(nworkers) diff --git a/libensemble/tests/regression_tests/test_persistent_sim_uniform_sampling.py b/libensemble/tests/regression_tests/test_persistent_sim_uniform_sampling.py index 8ecaa06247..5cb692a42e 100644 --- a/libensemble/tests/regression_tests/test_persistent_sim_uniform_sampling.py +++ b/libensemble/tests/regression_tests/test_persistent_sim_uniform_sampling.py @@ -15,6 +15,7 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: mpi local tcp # TESTSUITE_NPROCS: 3 4 +# TESTSUITE_OS_SKIP: WIN import sys import numpy as np diff --git a/libensemble/tests/regression_tests/test_persistent_surmise_killsims.py b/libensemble/tests/regression_tests/test_persistent_surmise_killsims.py index 62874e2a7c..510b78ab7a 100644 --- a/libensemble/tests/regression_tests/test_persistent_surmise_killsims.py +++ b/libensemble/tests/regression_tests/test_persistent_surmise_killsims.py @@ -80,7 +80,10 @@ sim_specs = { "sim_f": sim_f, "in": ["x", "thetas"], - "out": [("f", float)], + "out": [ + ("f", float), + ("sim_killed", bool), # "sim_killed" is used only for display at the end of this test + ], "user": { "num_obs": n_x, "init_sample_size": init_sample_size, @@ -130,7 +133,8 @@ if is_manager: print("Cancelled sims", H["sim_id"][H["cancel_requested"]]) - print("Killed sims", H["sim_id"][H["kill_sent"]]) + print("Kills sent by manager to running simulations", H["sim_id"][H["kill_sent"]]) + print("Killed sims", H["sim_id"][H["sim_killed"]]) sims_done = np.count_nonzero(H["sim_ended"]) save_libE_output(H, persis_info, __file__, nworkers) assert sims_done == max_evals, "Num of completed simulations should be {}. Is {}".format(max_evals, sims_done) diff --git a/libensemble/tests/regression_tests/test_persistent_uniform_gen_decides_stop.py b/libensemble/tests/regression_tests/test_persistent_uniform_gen_decides_stop.py index 164aaa62e2..96b9af52fa 100644 --- a/libensemble/tests/regression_tests/test_persistent_uniform_gen_decides_stop.py +++ b/libensemble/tests/regression_tests/test_persistent_uniform_gen_decides_stop.py @@ -14,6 +14,7 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: mpi local tcp # TESTSUITE_NPROCS: 5 +# TESTSUITE_OS_SKIP: WIN import sys import numpy as np diff --git a/libensemble/tests/regression_tests/test_persistent_uniform_sampling_cancel.py b/libensemble/tests/regression_tests/test_persistent_uniform_sampling_cancel.py new file mode 100644 index 0000000000..347308cf55 --- /dev/null +++ b/libensemble/tests/regression_tests/test_persistent_uniform_sampling_cancel.py @@ -0,0 +1,74 @@ +""" +Tests libEnsemble with a simple persistent uniform sampling generator +function. + +Execute via one of the following commands (e.g. 3 workers): + mpiexec -np 4 python test_persistent_sampling.py + python test_persistent_uniform_sampling_cancel.py --nworkers 3 --comms local + python test_persistent_uniform_sampling_cancel.py --nworkers 3 --comms tcp + +When running with the above commands, the number of concurrent evaluations of +the objective function will be 2, as one of the three workers will be the +persistent generator. +""" + +# Do not change these lines - they are parsed by run-tests.sh +# TESTSUITE_COMMS: mpi local +# TESTSUITE_NPROCS: 3 4 + +import sys +import numpy as np + +# Import libEnsemble items for this test +from libensemble.libE import libE +from libensemble.sim_funcs.rosenbrock import rosenbrock_eval as sim_f +from libensemble.gen_funcs.persistent_sampling import persistent_uniform_with_cancellations as gen_f +from libensemble.alloc_funcs.start_only_persistent import only_persistent_gens as alloc_f +from libensemble.tools import parse_args, save_libE_output, add_unique_random_streams + +# Main block is necessary only when using local comms with spawn start method (default on macOS and Windows). +if __name__ == "__main__": + + nworkers, is_manager, libE_specs, _ = parse_args() + + if nworkers < 2: + sys.exit("Cannot run with a persistent worker if only one worker -- aborting...") + + n = 2 + + sim_specs = { + "sim_f": sim_f, + "in": ["x"], + "out": [("f", float), ("grad", float, n)], + } + + gen_specs = { + "gen_f": gen_f, + "persis_in": ["x", "f", "grad", "sim_id"], + "out": [("x", float, (n,))], + "user": { + "initial_batch_size": 100, + "lb": np.array([-3, -2]), + "ub": np.array([3, 2]), + }, + } + + alloc_specs = { + "alloc_f": alloc_f, + "user": {"async_return": True}, + } + + exit_criteria = {"gen_max": 150, "wallclock_max": 300} + + persis_info = add_unique_random_streams({}, nworkers + 1) + + # Perform the run + H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs) + + if is_manager: + + # For reproducible test, only tests if cancel requested on points - not whether got evaluated + assert np.all(H["cancel_requested"][:49] == False), "Values cancelled which should not be" # noqa: E712 + assert np.all(H["cancel_requested"][50:100]), "Values not cancelled which should be" + + save_libE_output(H, persis_info, __file__, nworkers) diff --git a/libensemble/tests/regression_tests/test_uniform_sampling_cancel.py b/libensemble/tests/regression_tests/test_uniform_sampling_cancel.py index 2dd4f66877..83d25bfb24 100644 --- a/libensemble/tests/regression_tests/test_uniform_sampling_cancel.py +++ b/libensemble/tests/regression_tests/test_uniform_sampling_cancel.py @@ -34,7 +34,6 @@ def create_H0(persis_info, gen_specs, sim_max): """Create an H0 for give_pregenerated_sim_work""" - # Manually creating H0 ub = gen_specs["user"]["ub"] lb = gen_specs["user"]["lb"] diff --git a/libensemble/tests/regression_tests/test_uniform_sampling_with_variable_resources.py b/libensemble/tests/regression_tests/test_uniform_sampling_with_variable_resources.py index edc3ccbcbf..9c9804da04 100644 --- a/libensemble/tests/regression_tests/test_uniform_sampling_with_variable_resources.py +++ b/libensemble/tests/regression_tests/test_uniform_sampling_with_variable_resources.py @@ -14,6 +14,7 @@ # Do not change these lines - they are parsed by run-tests.sh # TESTSUITE_COMMS: mpi local # TESTSUITE_NPROCS: 2 4 +# TESTSUITE_EXTRA: true import sys import numpy as np diff --git a/libensemble/tests/run-tests.sh b/libensemble/tests/run-tests.sh index 0b506f4858..12fb2b72e9 100755 --- a/libensemble/tests/run-tests.sh +++ b/libensemble/tests/run-tests.sh @@ -92,24 +92,6 @@ print_summary_line() { done } -#Get current time in seconds -#In: Nothing -#Out: Returns time in seconds (seconds since 1970-01-01 00:00:00 UTC) as a string -# Or if bc not available uses SECONDS (whole seconds that script has been running) -current_time() { - local time - #Is bc present - USE_BC=f - bc --version >> /dev/null && USE_BC=t - if [ $USE_BC = 't' ]; then - #time=$(date +%s.%N) - time=$(python -c 'import time; print(time.time())') - else - time=$SECONDS - fi; - echo "$time" -} - #Return a time difference #In: Start and End times as strings #Out: Time difference as a string @@ -339,6 +321,24 @@ fi; PYTHON_RUN="python$PYTHON_VER $PYTHON_FLAGS" echo -e "Python run: $PYTHON_RUN" +#Get current time in seconds +#In: Nothing +#Out: Returns time in seconds (seconds since 1970-01-01 00:00:00 UTC) as a string +# Or if bc not available uses SECONDS (whole seconds that script has been running) +current_time() { + local time + #Is bc present + USE_BC=f + bc --version >> /dev/null && USE_BC=t + if [ $USE_BC = 't' ]; then + #time=$(date +%s.%N) + time=$($PYTHON_RUN -c 'import time; print(time.time())') + else + time=$SECONDS + fi; + echo "$time" +} + textreset=$(tput sgr0) fail_color=$(tput bold; tput setaf 1) #red pass_color=$(tput bold; tput setaf 2) #green @@ -500,11 +500,16 @@ if [ "$root_found" = true ]; then if [ "$RUN_LOCAL" = true ] && [ "$LAUNCHER" = local ]; then RUN_TEST=true; fi if [ "$RUN_TCP" = true ] && [ "$LAUNCHER" = tcp ]; then RUN_TEST=true; fi - if [[ "$OSTYPE" = *"darwin"* ]] && [[ "$OS_SKIP_LIST" = "OSX" ]]; then + if [[ "$OSTYPE" = *"darwin"* ]] && [[ "$OS_SKIP_LIST" = *"OSX"* ]]; then echo "Skipping test number for OSX: " $test_num continue fi + if [[ "$OSTYPE" = *"msys"* ]] && [[ "$OS_SKIP_LIST" = *"WIN"* ]]; then + echo "Skipping test number for Windows: " $test_num + continue + fi + if [[ "$OMPI_SKIP" = "true" ]] && [[ "$MPIEXEC_FLAGS" = "--oversubscribe" ]] && [[ "$RUN_MPI" = true ]]; then echo "Skipping test number for Open MPI: " $test_num continue diff --git a/libensemble/tests/scaling_tests/forces/forces_app/build_forces.sh b/libensemble/tests/scaling_tests/forces/forces_app/build_forces.sh index 3615a076ec..cd9f5914f2 100755 --- a/libensemble/tests/scaling_tests/forces/forces_app/build_forces.sh +++ b/libensemble/tests/scaling_tests/forces/forces_app/build_forces.sh @@ -36,7 +36,7 @@ mpicc -O3 -o forces.x forces.c -lm # xlc_r -O3 -qsmp=omp -qoffload -o forces.x forces.c # Nvidia (nvc) compiler with mpicc and on Cray system with target (Perlmutter) -# mpicc -O3 -fopenmp -mp=gpu -o forces_gpu.x forces_gpu.c +# mpicc -O3 -fopenmp -mp=gpu -o forces.x forces.c # cc -O3 -fopenmp -mp=gpu -target-accel=nvidia80 -o forces.x forces.c # Spock/Crusher (AMD ROCm compiler) diff --git a/libensemble/tests/scaling_tests/forces/forces_simple/run_libe_forces.py b/libensemble/tests/scaling_tests/forces/forces_simple/run_libe_forces.py index 3c4a296706..0d4bc23bad 100644 --- a/libensemble/tests/scaling_tests/forces/forces_simple/run_libe_forces.py +++ b/libensemble/tests/scaling_tests/forces/forces_simple/run_libe_forces.py @@ -9,47 +9,49 @@ from libensemble.tools import parse_args, add_unique_random_streams from libensemble.executors import MPIExecutor -# Parse number of workers, comms type, etc. from arguments -nworkers, is_manager, libE_specs, _ = parse_args() - -# Initialize MPI Executor instance -exctr = MPIExecutor() - -# Register simulation executable with executor -sim_app = os.path.join(os.getcwd(), "../forces_app/forces.x") - -if not os.path.isfile(sim_app): - sys.exit("forces.x not found - please build first in ../forces_app dir") - -exctr.register_app(full_path=sim_app, app_name="forces") - -# State the sim_f, inputs, outputs -sim_specs = { - "sim_f": run_forces, # sim_f, imported above - "in": ["x"], # Name of input for sim_f - "out": [("energy", float)], # Name, type of output from sim_f -} - -# State the gen_f, inputs, outputs, additional parameters -gen_specs = { - "gen_f": uniform_random_sample, # Generator function - "in": [], # Generator input - "out": [("x", float, (1,))], # Name, type and size of data from gen_f - "user": { - "lb": np.array([1000]), # User parameters for the gen_f - "ub": np.array([3000]), - "gen_batch_size": 8, - }, -} - -# Create and work inside separate per-simulation directories -libE_specs["sim_dirs_make"] = True - -# Instruct libEnsemble to exit after this many simulations -exit_criteria = {"sim_max": 8} - -# Seed random streams for each worker, particularly for gen_f -persis_info = add_unique_random_streams({}, nworkers + 1) - -# Launch libEnsemble -H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info=persis_info, libE_specs=libE_specs) +if __name__ == "__main__": + + # Parse number of workers, comms type, etc. from arguments + nworkers, is_manager, libE_specs, _ = parse_args() + + # Initialize MPI Executor instance + exctr = MPIExecutor() + + # Register simulation executable with executor + sim_app = os.path.join(os.getcwd(), "../forces_app/forces.x") + + if not os.path.isfile(sim_app): + sys.exit("forces.x not found - please build first in ../forces_app dir") + + exctr.register_app(full_path=sim_app, app_name="forces") + + # State the sim_f, inputs, outputs + sim_specs = { + "sim_f": run_forces, # sim_f, imported above + "in": ["x"], # Name of input for sim_f + "out": [("energy", float)], # Name, type of output from sim_f + } + + # State the gen_f, inputs, outputs, additional parameters + gen_specs = { + "gen_f": uniform_random_sample, # Generator function + "in": [], # Generator input + "out": [("x", float, (1,))], # Name, type and size of data from gen_f + "user": { + "lb": np.array([1000]), # User parameters for the gen_f + "ub": np.array([3000]), + "gen_batch_size": 8, + }, + } + + # Create and work inside separate per-simulation directories + libE_specs["sim_dirs_make"] = True + + # Instruct libEnsemble to exit after this many simulations + exit_criteria = {"sim_max": 8} + + # Seed random streams for each worker, particularly for gen_f + persis_info = add_unique_random_streams({}, nworkers + 1) + + # Launch libEnsemble + H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info=persis_info, libE_specs=libE_specs) diff --git a/libensemble/tests/unit_tests/test_executor.py b/libensemble/tests/unit_tests/test_executor.py index 5b9e52fecc..9f41be02cf 100644 --- a/libensemble/tests/unit_tests/test_executor.py +++ b/libensemble/tests/unit_tests/test_executor.py @@ -7,10 +7,13 @@ import time import pytest import socket -import mpi4py +import platform -mpi4py.rc.initialize = False -from mpi4py import MPI +if platform.system() != "Windows": + import mpi4py + + mpi4py.rc.initialize = False + from mpi4py import MPI from libensemble.resources.mpi_resources import MPIResourcesException from libensemble.executors.executor import Executor, ExecutorException, TimeoutExpired @@ -202,6 +205,9 @@ def polling_loop_multitask(exctr, task_list, timeout_sec=4.0, delay=0.05): # Tests ======================================================================================== + + +@pytest.mark.extra def test_launch_and_poll(): """Test of launching and polling task and exiting on task finish""" print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) @@ -216,6 +222,7 @@ def test_launch_and_poll(): assert task.run_attempts == 1, "task.run_attempts should be 1. Returned " + str(task.run_attempts) +@pytest.mark.extra def test_launch_and_wait(): """Test of launching and waiting on task""" print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) @@ -232,6 +239,7 @@ def test_launch_and_wait(): assert task.state == "FINISHED", "task.state should be FINISHED. Returned " + str(task.state) +@pytest.mark.extra def test_launch_and_wait_timeout(): """Test of launching and waiting on task timeout (and kill)""" print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) @@ -251,6 +259,7 @@ def test_launch_and_wait_timeout(): assert task.state == "USER_KILLED", "task.state should be USER_KILLED. Returned " + str(task.state) +@pytest.mark.extra def test_launch_wait_on_start(): """Test of launching task with wait_on_start""" print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) @@ -267,6 +276,7 @@ def test_launch_wait_on_start(): assert task.state == "FINISHED", "task.state should be FINISHED. Returned " + str(task.state) +@pytest.mark.extra def test_kill_on_file(): """Test of killing task based on something in output file""" print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) @@ -280,6 +290,7 @@ def test_kill_on_file(): assert task.state == "USER_KILLED", "task.state should be USER_KILLED. Returned " + str(task.state) +@pytest.mark.extra def test_kill_on_timeout(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -292,6 +303,7 @@ def test_kill_on_timeout(): assert task.state == "USER_KILLED", "task.state should be USER_KILLED. Returned " + str(task.state) +@pytest.mark.extra def test_kill_on_timeout_polling_loop_method(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -304,6 +316,7 @@ def test_kill_on_timeout_polling_loop_method(): assert task.state == "USER_KILLED", "task.state should be USER_KILLED. Returned " + str(task.state) +@pytest.mark.extra def test_launch_and_poll_multitasks(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -326,6 +339,7 @@ def test_launch_and_poll_multitasks(): assert task.state == "FINISHED", "task.state should be FINISHED. Returned " + str(task.state) +@pytest.mark.extra def test_get_task(): """Return task from given task id""" print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) @@ -351,6 +365,7 @@ def test_get_task(): assert A is None, "Task found when supplied taskid should not exist" +@pytest.mark.extra @pytest.mark.timeout(30) def test_procs_and_machinefile_logic(): """Test of supplying various input configurations.""" @@ -437,6 +452,7 @@ def test_procs_and_machinefile_logic(): assert task.state == "FINISHED", "task.state should be FINISHED. Returned " + str(task.state) +@pytest.mark.extra @pytest.mark.timeout(20) def test_doublekill(): """Test attempt to kill already killed task @@ -460,6 +476,7 @@ def test_doublekill(): assert task.state == "USER_KILLED", "task.state should be USER_KILLED. Returned " + str(task.state) +@pytest.mark.extra @pytest.mark.timeout(20) def test_finish_and_kill(): """Test attempt to kill already finished task @@ -486,6 +503,7 @@ def test_finish_and_kill(): assert task.state == "FINISHED", "task.state should be FINISHED. Returned " + str(task.state) +@pytest.mark.extra @pytest.mark.timeout(20) def test_launch_and_kill(): """Test launching and immediately killing tasks with no poll""" @@ -506,6 +524,7 @@ def test_launch_and_kill(): assert task.state == "USER_KILLED", "task.state should be USER_KILLED. Returned " + str(task.state) +@pytest.mark.extra def test_launch_as_gen(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -536,6 +555,7 @@ def test_launch_as_gen(): assert 0 +@pytest.mark.extra def test_launch_no_app(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor_noapp() @@ -556,6 +576,7 @@ def test_launch_no_app(): assert 0 +@pytest.mark.extra def test_kill_task_with_no_submit(): from libensemble.executors.executor import Task @@ -586,6 +607,7 @@ def test_kill_task_with_no_submit(): assert 0 +@pytest.mark.extra def test_poll_task_with_no_submit(): from libensemble.executors.executor import Task @@ -606,6 +628,7 @@ def test_poll_task_with_no_submit(): assert 0 +@pytest.mark.extra def test_task_failure(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -618,6 +641,7 @@ def test_task_failure(): assert task.state == "FAILED", "task.state should be FAILED. Returned " + str(task.state) +@pytest.mark.extra def test_retries_launch_fail(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor_fakerunner() @@ -631,6 +655,7 @@ def test_retries_launch_fail(): assert task.run_attempts == 5, "task.run_attempts should be 5. Returned " + str(task.run_attempts) +@pytest.mark.extra def test_retries_run_fail(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -644,6 +669,7 @@ def test_retries_run_fail(): assert task.run_attempts == 5, "task.run_attempts should be 5. Returned " + str(task.run_attempts) +@pytest.mark.extra def test_register_apps(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() # This registers an app my_simtask.x (default sim) @@ -689,6 +715,7 @@ def test_register_apps(): # assert e.args[1] == "Registered applications: ['my_simtask.x', 'fake_app1', 'fake_app2']" +@pytest.mark.extra def test_serial_exes(): setup_serial_executor() exctr = Executor.executor @@ -699,6 +726,7 @@ def test_serial_exes(): assert task.state == "FINISHED", "task.state should be FINISHED. Returned " + str(task.state) +@pytest.mark.extra def test_serial_startup_times(): setup_executor_startups() exctr = Executor.executor @@ -724,6 +752,7 @@ def test_serial_startup_times(): assert 0 < startup_time < 1, "Start up time for python program took " + str(startup_time) +@pytest.mark.extra def test_futures_interface(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -737,6 +766,7 @@ def test_futures_interface(): assert task.done(), "task.done() should return True after task finishes." +@pytest.mark.extra def test_futures_interface_cancel(): print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) setup_executor() @@ -749,6 +779,7 @@ def test_futures_interface_cancel(): assert task.cancelled() and task.done(), "Task should be both cancelled() and done() after cancellation." +@pytest.mark.extra def test_dry_run(): """Test of dry_run in poll""" print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) @@ -761,9 +792,9 @@ def test_dry_run(): task.kill() +@pytest.mark.extra def test_non_existent_app(): """Tests exception on non-existent app""" - from libensemble.executors.executor import Executor exctr = Executor() @@ -781,9 +812,9 @@ def test_non_existent_app(): assert 0 +@pytest.mark.extra def test_non_existent_app_mpi(): """Tests exception on non-existent app""" - from libensemble.executors.mpi_executor import MPIExecutor exctr = MPIExecutor() diff --git a/libensemble/tests/unit_tests/test_executor_balsam.py b/libensemble/tests/unit_tests/test_executor_balsam.py new file mode 100644 index 0000000000..8c64f57d23 --- /dev/null +++ b/libensemble/tests/unit_tests/test_executor_balsam.py @@ -0,0 +1,251 @@ +# !/usr/bin/env python +# Integration Test of executor module for libensemble +# Test does not require running full libensemble +import os +import sys +import mock +import pytest +import datetime +from dataclasses import dataclass + +from libensemble.executors.executor import ( + Executor, + Application, + ExecutorException, + TimeoutExpired, +) + + +# fake Balsam app +class TestLibeApp: + site = "libe-unit-test" + command_template = "python simdir/py_startup.py" + + def sync(): + pass + + +# fake EventLog object +@dataclass +class LogEventTest: + timestamp: datetime.datetime = None + + +def setup_module(module): + try: + print("setup_module module:%s" % module.__name__) + except AttributeError: + print("setup_module (direct run) module:%s" % module) + if Executor.executor is not None: + del Executor.executor + Executor.executor = None + + +def teardown_module(module): + try: + print("teardown_module module:%s" % module.__name__) + except AttributeError: + print("teardown_module (direct run) module:%s" % module) + if Executor.executor is not None: + del Executor.executor + Executor.executor = None + + +# This would typically be in the user calling script +def setup_executor(): + """Set up a Balsam Executor with sim app""" + from libensemble.executors.balsam_executors import BalsamExecutor + + exctr = BalsamExecutor() # noqa F841 + + +# Tests ======================================================================================== + + +@pytest.mark.extra +def test_register_app(): + """Test of registering an App""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + setup_executor() + exctr = Executor.executor + + exctr.serial_setup() # does nothing, compatibility with legacy-balsam-exctr + exctr.add_app("hello", "world") # does nothing, compatibility with legacy-balsam-exctr + exctr.set_resources("hello") # does nothing, compatibility with other executors + + exctr.register_app(TestLibeApp, calc_type="sim", precedent="fake/dir") + assert isinstance( + exctr.apps["python"], Application + ), "Application object not created based on registered Balsam AppDef" + + exctr.register_app(TestLibeApp, app_name="test") + assert isinstance( + exctr.apps["test"], Application + ), "Application object not created based on registered Balsam AppDef" + + +@pytest.mark.extra +def test_submit_app_defaults(): + """Test of submitting an App""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.Job"): + task = exctr.submit(calc_type="sim") + task = exctr.submit(app_name="test") + + assert task in exctr.list_of_tasks, "new task not added to executor's list of tasks" + + assert task == exctr.get_task(task.id), "task retrieved via task ID doesn't match new task" + + with pytest.raises(ExecutorException): + task = exctr.submit() + pytest.fail("Expected exception") + + +@pytest.mark.extra +def test_submit_app_workdir(): + """Test of submitting an App with a workdir""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.Job"): + task = exctr.submit(calc_type="sim", workdir="output", machinefile="nope") + + assert task.workdir == os.path.join(exctr.workflow_name, "output"), "workdir not properly defined for new task" + + +@pytest.mark.extra +def test_submit_app_dry(): + """Test of dry-run submitting an App""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + task = exctr.submit(calc_type="sim", dry_run=True) + task.poll() + + assert all([task.dry_run, task.done()]), "new task from dry_run wasn't marked as such, or set as done" + + +@pytest.mark.extra +def test_submit_app_wait(): + """Test of exctr.submit blocking until app is running""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.Job") as job: + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.EventLog") as log: + job.return_value.state = "RUNNING" + log.objects.filter.return_value = [ + LogEventTest(timestamp=datetime.datetime(2022, 4, 21, 20, 29, 33, 455144)) + ] + task = exctr.submit(calc_type="sim", wait_on_start=True) + assert task.running(), "new task is not marked as running after wait_on_start" + + log.objects.filter.return_value = [LogEventTest(timestamp=None)] + task = exctr.submit(calc_type="sim", wait_on_start=True) + assert task.runtime == 0, "runtime should be 0 without Balsam timestamp evaluated" + + +@pytest.mark.extra +def test_submit_revoke_alloc(): + """Test creating and revoking BatchJob objects through the executor""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.BatchJob"): + alloc = exctr.submit_allocation(site_id="libe-unit-test", num_nodes=1, wall_time_min=30) + + assert alloc in exctr.allocations, "batchjob object not appended to executor's list of allocations" + + alloc.scheduler_id = None + assert not exctr.revoke_allocation( + alloc, timeout=3 + ), "unable to revoke allocation if Balsam never returns scheduler ID" + + alloc.scheduler_id = 1 + assert exctr.revoke_allocation( + alloc, timeout=3 + ), "should've been able to revoke allocation if scheduler ID available" + + +@pytest.mark.extra +def test_task_poll(): + """Test of killing (cancelling) a balsam app""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.Job") as job: + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.EventLog"): + task = exctr.submit(calc_type="sim") + + job.return_value.state = "PREPROCESSED" + task.poll() + assert task.state == "WAITING", "task should've been considered waiting based on balsam state" + + job.return_value.state = "FAILED" + task.poll() + assert task.state == "FAILED", "task should've been considered failed based on balsam state" + + task = exctr.submit(calc_type="sim") + + job.return_value.state = "JOB_FINISHED" + task.poll() + assert task.state == "FINISHED", "task was not finished after wait method" + + assert not task.running(), "task shouldn't be running after wait method returns" + + assert task.done(), "task should be 'done' after wait method" + + +@pytest.mark.extra +def test_task_wait(): + """Test of killing (cancelling) a balsam app""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.Job") as job: + with mock.patch( + "libensemble.executors.balsam_executors.balsam_executor.EventLog" + ): # need to patch since wait polls + task = exctr.submit(calc_type="sim") + + job.return_value.state = "RUNNING" + with pytest.raises(TimeoutExpired): + task.wait(timeout=3) + pytest.fail("Expected exception") + + job.return_value.state = "JOB_FINISHED" + task.wait(timeout=3) + task.wait(timeout=3) # should return immediately since self._check_poll() should return False + assert task.state == "FINISHED", "task was not finished after wait method" + assert not task.running(), "task shouldn't be running after wait method returns" + assert task.done(), "task should be 'done' after wait method" + + task = exctr.submit(calc_type="sim", dry_run=True) + task.wait() # should also return immediately since dry_run + + task = exctr.submit(calc_type="sim") + job.return_value.state = "FAILED" + task.wait(timeout=3) + assert task.state == "FAILED", "Matching Balsam state should've been assigned to task" + + +@pytest.mark.extra +def test_task_kill(): + """Test of killing (cancelling) a balsam app""" + print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + exctr = Executor.executor + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.Job"): + task = exctr.submit(calc_type="sim") + + with mock.patch("libensemble.executors.balsam_executors.balsam_executor.EventLog"): + task.kill() + assert task.finished and task.state == "USER_KILLED", "task not set as killed after kill method" + + +if __name__ == "__main__": + setup_module(__file__) + test_register_app() + test_submit_app_defaults() + test_submit_app_workdir() + test_submit_app_dry() + test_submit_app_wait() + test_submit_revoke_alloc() + test_task_poll() + test_task_wait() + test_task_kill() + teardown_module(__file__) diff --git a/libensemble/tests/unit_tests/test_launcher.py b/libensemble/tests/unit_tests/test_launcher.py index d19dd5a309..951eb287dc 100644 --- a/libensemble/tests/unit_tests/test_launcher.py +++ b/libensemble/tests/unit_tests/test_launcher.py @@ -5,6 +5,7 @@ """ import sys +import pytest import libensemble.utils.launcher as launcher @@ -59,6 +60,7 @@ def xtest_submit(): launcher.cancel(process, 0) +@pytest.mark.extra def test_launch32(): "If we are in Python > 3.2, still check that 3.2 wait func works" saved_wait = launcher.wait @@ -67,6 +69,7 @@ def test_launch32(): launcher.wait = saved_wait +@pytest.mark.extra def test_launch33(): "If we are in Python > 3.2, also check the new-style wait func" if launcher.wait == launcher.wait_py33: diff --git a/libensemble/tests/unit_tests/test_libE_main.py b/libensemble/tests/unit_tests/test_libE_main.py index 0e183e4258..b8cbd70c0e 100644 --- a/libensemble/tests/unit_tests/test_libE_main.py +++ b/libensemble/tests/unit_tests/test_libE_main.py @@ -253,6 +253,7 @@ def test_checking_inputs_single(): check_inputs(libE_specs=libE_specs) +@pytest.mark.extra def test_logging_disabling(): remove_file_if_exists("ensemble.log") remove_file_if_exists("libE_stats.txt") diff --git a/libensemble/tests/unit_tests/test_make_runners.py b/libensemble/tests/unit_tests/test_make_runners.py new file mode 100644 index 0000000000..0628ca88af --- /dev/null +++ b/libensemble/tests/unit_tests/test_make_runners.py @@ -0,0 +1,128 @@ +import numpy as np +import pytest +import mock + +import libensemble.tests.unit_tests.setup as setup +from libensemble.tools.fields_keys import libE_fields +from libensemble.message_numbers import EVAL_SIM_TAG, EVAL_GEN_TAG +from libensemble.utils.runners import Runners + + +def get_ufunc_args(): + sim_specs, gen_specs, exit_criteria = setup.make_criteria_and_specs_0() + + L = exit_criteria["sim_max"] + H = np.zeros(L, dtype=list(set(libE_fields + sim_specs["out"] + gen_specs["out"]))) + + H["sim_id"][-L:] = -1 + H["sim_started_time"][-L:] = np.inf + + sim_ids = np.zeros(1, dtype=int) + Work = { + "tag": EVAL_SIM_TAG, + "persis_info": {}, + "libE_info": {"H_rows": sim_ids}, + "H_fields": sim_specs["in"], + } + calc_in = H[Work["H_fields"]][Work["libE_info"]["H_rows"]] + return calc_in, sim_specs, gen_specs + + +@pytest.mark.extra +def test_normal_runners(): + calc_in, sim_specs, gen_specs = get_ufunc_args() + + runners = Runners(sim_specs, gen_specs) + assert ( + not runners.has_funcx_sim and not runners.has_funcx_gen + ), "funcX use should not be detected without setting endpoint fields" + + ro = runners.make_runners() + assert all( + [i in ro for i in [EVAL_SIM_TAG, EVAL_GEN_TAG]] + ), "Both user function tags should be included in runners dictionary" + + +@pytest.mark.extra +def test_normal_no_gen(): + calc_in, sim_specs, gen_specs = get_ufunc_args() + + runners = Runners(sim_specs, {}) + ro = runners.make_runners() + + assert not ro[2], "generator function shouldn't be provided if not using gen_specs" + + +@pytest.mark.extra +def test_funcx_runner_init(): + calc_in, sim_specs, gen_specs = get_ufunc_args() + + sim_specs["funcx_endpoint"] = "1234" + + with mock.patch("funcx.FuncXClient"): + + runners = Runners(sim_specs, gen_specs) + + assert ( + runners.funcx_exctr is not None + ), "FuncXExecutor should have been instantiated when funcx_endpoint found in specs" + + +@pytest.mark.extra +def test_funcx_runner_pass(): + calc_in, sim_specs, gen_specs = get_ufunc_args() + + sim_specs["funcx_endpoint"] = "1234" + + with mock.patch("funcx.FuncXClient"): + + runners = Runners(sim_specs, gen_specs) + + # Creating Mock funcXExecutor and funcX future object - no exception + funcx_mock = mock.Mock() + funcx_future = mock.Mock() + funcx_mock.submit.return_value = funcx_future + funcx_future.exception.return_value = None + funcx_future.result.return_value = (True, True) + + runners.funcx_exctr = funcx_mock + ro = runners.make_runners() + + libE_info = {"H_rows": np.array([2, 3, 4]), "workerID": 1, "comm": "fakecomm"} + out, persis_info = ro[1](calc_in, {}, libE_info) + + assert all([out, persis_info]), "funcX runner correctly returned results" + + +@pytest.mark.extra +def test_funcx_runner_fail(): + calc_in, sim_specs, gen_specs = get_ufunc_args() + + gen_specs["funcx_endpoint"] = "4321" + + with mock.patch("funcx.FuncXClient"): + + runners = Runners(sim_specs, gen_specs) + + # Creating Mock funcXExecutor and funcX future object - yes exception + funcx_mock = mock.Mock() + funcx_future = mock.Mock() + funcx_mock.submit.return_value = funcx_future + funcx_future.exception.return_value = Exception + + runners.funcx_exctr = funcx_mock + ro = runners.make_runners() + + libE_info = {"H_rows": np.array([2, 3, 4]), "workerID": 1, "comm": "fakecomm"} + + with pytest.raises(Exception): + out, persis_info = ro[2](calc_in, {}, libE_info) + pytest.fail("Expected exception") + + +if __name__ == "__main__": + test_normal_runners() + test_normal_no_gen() + test_funcx_runner_init() + test_funcx_runner_pass() + test_funcx_runner_fail() diff --git a/libensemble/tests/unit_tests/test_manager_main.py b/libensemble/tests/unit_tests/test_manager_main.py index 0d9404f91e..a75d320fad 100644 --- a/libensemble/tests/unit_tests/test_manager_main.py +++ b/libensemble/tests/unit_tests/test_manager_main.py @@ -1,14 +1,19 @@ import time +import pytest +import platform import numpy as np import numpy.lib.recfunctions -from mpi4py import MPI import libensemble.manager as man import libensemble.tests.unit_tests.setup as setup -libE_specs = {"mpi_comm": MPI.COMM_WORLD} +if platform.system() != "Windows": + from mpi4py import MPI + libE_specs = {"mpi_comm": MPI.COMM_WORLD} + +@pytest.mark.extra def test_term_test_1(): # termination_test should be True when we want to stop @@ -19,6 +24,7 @@ def test_term_test_1(): assert not mgr.term_test() +@pytest.mark.extra def test_term_test_2(): # Test 2 - these could also be sep - with a setup or fixture.... # Shouldn't terminate @@ -39,6 +45,7 @@ def test_term_test_2(): assert mgr.term_test() +@pytest.mark.extra def test_term_test_3(): # Test 3. # Terminate because enough time has passed diff --git a/libensemble/tests/unit_tests/test_mpi4py.py b/libensemble/tests/unit_tests/test_mpi4py.py index f4a23980ee..606c38f79a 100644 --- a/libensemble/tests/unit_tests/test_mpi4py.py +++ b/libensemble/tests/unit_tests/test_mpi4py.py @@ -1,3 +1,7 @@ +import pytest + + +@pytest.mark.extra def test_mpi4py(): from mpi4py import MPI diff --git a/libensemble/tests/unit_tests/test_persistent_aposmm.py b/libensemble/tests/unit_tests/test_persistent_aposmm.py index ea68193f0b..7b5fa7749d 100644 --- a/libensemble/tests/unit_tests/test_persistent_aposmm.py +++ b/libensemble/tests/unit_tests/test_persistent_aposmm.py @@ -1,12 +1,14 @@ import pytest +import platform import multiprocessing -multiprocessing.set_start_method("fork", force=True) - import libensemble.gen_funcs libensemble.gen_funcs.rc.aposmm_optimizers = "nlopt" -from libensemble.gen_funcs.persistent_aposmm import aposmm, update_history_optimal + +if platform.system() in ["Linux", "Darwin"]: + multiprocessing.set_start_method("fork", force=True) + from libensemble.gen_funcs.persistent_aposmm import aposmm, update_history_optimal import numpy as np import libensemble.tests.unit_tests.setup as setup diff --git a/libensemble/tests/unit_tests/test_scipy.py b/libensemble/tests/unit_tests/test_scipy.py index cb8347bd72..e50a525229 100644 --- a/libensemble/tests/unit_tests/test_scipy.py +++ b/libensemble/tests/unit_tests/test_scipy.py @@ -10,7 +10,6 @@ def test_cdist_issue(): pytest.skip("scipy or its dependencies not importable. Skipping.") """There is an issue (at least in scipy 1.1.0) with cdist segfaulting.""" - H = np.zeros( 20, dtype=[ @@ -40,7 +39,6 @@ def test_cdist_issue(): @pytest.mark.extra def test_save(): """Seeing if I can save parts of the H array.""" - from libensemble.tests.regression_tests.support import uniform_or_localopt_gen_out as gen_out n = 2 diff --git a/libensemble/tests/unit_tests/test_sim_dir_properties.py b/libensemble/tests/unit_tests/test_sim_dir_properties.py index 71fc5759b7..29e79370d0 100644 --- a/libensemble/tests/unit_tests/test_sim_dir_properties.py +++ b/libensemble/tests/unit_tests/test_sim_dir_properties.py @@ -1,44 +1,40 @@ import os +import pytest import shutil import numpy as np from libensemble.output_directory import EnsembleDirectory from libensemble.utils.loc_stack import LocationStack +from libensemble.utils.misc import extract_H_ranges def test_range_single_element(): """Single H_row labeling""" - work = {"H_fields": ["x", "num_nodes", "procs_per_node"], "libE_info": {"H_rows": np.array([5]), "workerID": 1}} - assert EnsembleDirectory.extract_H_ranges(work) == "5", "Failed to correctly parse single H row" + assert extract_H_ranges(work) == "5", "Failed to correctly parse single H row" def test_range_two_separate_elements(): """Multiple H_rows, non-sequential""" - work = {"H_fields": ["x", "num_nodes", "procs_per_node"], "libE_info": {"H_rows": np.array([2, 8]), "workerID": 1}} - assert EnsembleDirectory.extract_H_ranges(work) == "2_8", "Failed to correctly parse nonsequential H rows" + assert extract_H_ranges(work) == "2_8", "Failed to correctly parse nonsequential H rows" def test_range_two_ranges(): """Multiple sequences of H_rows""" - work = { "H_fields": ["x", "num_nodes", "procs_per_node"], "libE_info": {"H_rows": np.array([0, 1, 2, 3, 7, 8]), "workerID": 1}, } - assert EnsembleDirectory.extract_H_ranges(work) == "0-3_7-8", "Failed to correctly parse multiple H ranges" + assert extract_H_ranges(work) == "0-3_7-8", "Failed to correctly parse multiple H ranges" def test_range_mixes(): """Mix of single rows and sequences of H_rows""" - work = { "H_fields": ["x", "num_nodes", "procs_per_node"], "libE_info": {"H_rows": np.array([2, 3, 4, 6, 8, 9, 11, 14]), "workerID": 1}, } - assert ( - EnsembleDirectory.extract_H_ranges(work) == "2-4_6_8-9_11_14" - ), "Failed to correctly parse H row single elements and ranges." + assert extract_H_ranges(work) == "2-4_6_8-9_11_14", "Failed to correctly parse H row single elements and ranges." def test_copy_back(): @@ -88,6 +84,7 @@ def test_worker_dirs_but_no_sim_dirs(): shutil.rmtree(dir) +@pytest.mark.extra def test_loc_stack_FileExists_exceptions(): inputdir = "./calc" copyfile = "./calc/copy" diff --git a/libensemble/tests/unit_tests_logger/test_logger.py b/libensemble/tests/unit_tests_logger/test_logger.py index eaaf811e6f..18555dd517 100644 --- a/libensemble/tests/unit_tests_logger/test_logger.py +++ b/libensemble/tests/unit_tests_logger/test_logger.py @@ -72,7 +72,10 @@ def test_set_filename(): with open(alt_name, "r") as f: line = f.readline() assert "Cannot set filename after loggers initialized" in line - os.remove(alt_name) + try: + os.remove(alt_name) + except PermissionError: # windows only + pass logs = LogConfig.config logs.logger_set = True diff --git a/libensemble/tests/unit_tests_nompi/conftest.py b/libensemble/tests/unit_tests_nompi/conftest.py new file mode 100644 index 0000000000..3909b231f0 --- /dev/null +++ b/libensemble/tests/unit_tests_nompi/conftest.py @@ -0,0 +1,21 @@ +# https://stackoverflow.com/questions/47559524/pytest-how-to-skip-tests-unless-you-declare-an-option-flag/61193490#61193490 + +import pytest + + +def pytest_addoption(parser): + parser.addoption("--runextra", action="store_true", default=False, help="run extra tests") + + +def pytest_configure(config): + config.addinivalue_line("markers", "extra: mark test as extra to run") + + +def pytest_collection_modifyitems(config, items): + if config.getoption("--runextra"): + # --runextra given in cli: do not skip extra tests + return + skip_extra = pytest.mark.skip(reason="need --runextra option to run") + for item in items: + if "extra" in item.keywords: + item.add_marker(skip_extra) diff --git a/libensemble/tests/unit_tests_nompi/test_aaa_comms.py b/libensemble/tests/unit_tests_nompi/test_aaa_comms.py index 180bba29f6..6dde4ff492 100644 --- a/libensemble/tests/unit_tests_nompi/test_aaa_comms.py +++ b/libensemble/tests/unit_tests_nompi/test_aaa_comms.py @@ -9,6 +9,7 @@ """ import time +import pytest import signal import libensemble.comms.comms as comms @@ -55,6 +56,7 @@ def ignore_handler(signum, frame): print("Ignoring SIGTERM") +@pytest.mark.extra def test_qcomm_proc_terminate3(): "Test that a QCommProcess ignoring SIGTERM manages." diff --git a/libensemble/tools/alloc_support.py b/libensemble/tools/alloc_support.py index e6d3edfb18..79ae6ed31e 100644 --- a/libensemble/tools/alloc_support.py +++ b/libensemble/tools/alloc_support.py @@ -3,7 +3,7 @@ from libensemble.message_numbers import EVAL_SIM_TAG, EVAL_GEN_TAG from libensemble.resources.resources import Resources from libensemble.resources.scheduler import ResourceScheduler, InsufficientFreeResources # noqa: F401 -from libensemble.output_directory import EnsembleDirectory +from libensemble.utils.misc import extract_H_ranges logger = logging.getLogger(__name__) # For debug messages - uncomment @@ -179,9 +179,7 @@ def sim_work(self, wid, H, H_fields, H_rows, persis_info, **libE_info): } logger.debug( - "Alloc func packing SIM work for worker {}. Packing sim_ids: {}".format( - wid, EnsembleDirectory.extract_H_ranges(work) or None - ) + "Alloc func packing SIM work for worker {}. Packing sim_ids: {}".format(wid, extract_H_ranges(work) or None) ) return work @@ -223,9 +221,7 @@ def gen_work(self, wid, H_fields, H_rows, persis_info, **libE_info): } logger.debug( - "Alloc func packing GEN work for worker {}. Packing sim_ids: {}".format( - wid, EnsembleDirectory.extract_H_ranges(work) or None - ) + "Alloc func packing GEN work for worker {}. Packing sim_ids: {}".format(wid, extract_H_ranges(work) or None) ) return work diff --git a/libensemble/tools/parse_args.py b/libensemble/tools/parse_args.py index d365b33713..469ad443e1 100644 --- a/libensemble/tools/parse_args.py +++ b/libensemble/tools/parse_args.py @@ -18,7 +18,10 @@ ) parser.add_argument("--nworkers", type=int, nargs="?", help="Number of local forked processes") parser.add_argument( - "--nsim_workers", type=int, nargs="?", help="Number of workers for sims. 1+ zero-resource gen worker will be added" + "--nsim_workers", + type=int, + nargs="?", + help="Number of workers for sims. 1+ unresourced workers for a persistent generator will be added", ) parser.add_argument("--nresource_sets", type=int, nargs="?", help="Number of resource sets") parser.add_argument("--workers", type=str, nargs="+", help="List of worker nodes") @@ -56,14 +59,14 @@ def _mpi_parse_args(args): # Convenience option which sets other libE_specs options. nsim_workers = args.nsim_workers if nsim_workers is not None: - libE_specs["zero_resource_workers"] = _get_zrw(nworkers, nsim_workers) + # libE_specs["zero_resource_workers"] = _get_zrw(nworkers, nsim_workers) + libE_specs["num_resource_sets"] = libE_specs.get("num_resource_sets", nsim_workers) return nworkers, is_manager, libE_specs, args.tester_args def _local_parse_args(args): """Parses arguments for forked processes using multiprocessing.""" - libE_specs = {"comms": "local"} nworkers = args.nworkers @@ -74,7 +77,8 @@ def _local_parse_args(args): nsim_workers = args.nsim_workers if nsim_workers is not None: nworkers = nworkers or nsim_workers + 1 - libE_specs["zero_resource_workers"] = _get_zrw(nworkers, nsim_workers) + # libE_specs["zero_resource_workers"] = _get_zrw(nworkers, nsim_workers) + libE_specs["num_resource_sets"] = libE_specs.get("num_resource_sets", nsim_workers) nworkers = nworkers or 4 libE_specs["nworkers"] = nworkers @@ -178,21 +182,23 @@ def parse_args(): --comms, Communications medium for manager and workers. Default is 'mpi'. --nworkers, (For 'local' or 'tcp' comms) Set number of workers. - --nsim_workers, (For 'local' or 'mpi' comms) A convenience option for common cases. - If used with no other criteria, will generate one additional - zero-resource worker for use as a generator. If the number of workers - has also been specified, will generate enough zero-resource workers to - match the other criteria. --nresource_sets, Explicitly set the number of resource sets. This sets libE_specs['num_resource_sets']. By default, resources will be divided by workers (excluding zero_resource_workers). + --nsim_workers, (For 'local' or 'mpi' comms) A convenience option for cases with + persistent generators - sets the number of simulation workers. + If used with no other criteria, one additional worker for running a + generator will be added, and the number of resource sets will be assigned + the given value. If '--nworkers' has also been specified, will generate + enough additional workers to match the other criteria. If '--nresource_sets' + is also specified, will not override resource sets. Example command lines: Run with 'local' comms and 4 workers $ python calling_script --comms local --nworkers 4 - Run with 'local' comms and 5 workers - one gen (no resources), and 4 sims. + Run with 'local' comms and 5 workers - one gen worker (no resources), and 4 sim workers. $ python calling_script --comms local --nsim_workers 4 Run with 'local' comms with 4 workers and 8 resource sets. The extra resource sets will diff --git a/libensemble/tools/persistent_support.py b/libensemble/tools/persistent_support.py index 0f302c077e..fbe5ed5ee5 100644 --- a/libensemble/tools/persistent_support.py +++ b/libensemble/tools/persistent_support.py @@ -1,5 +1,6 @@ from libensemble.message_numbers import STOP_TAG, PERSIS_STOP, UNSET_TAG, EVAL_GEN_TAG, EVAL_SIM_TAG, calc_type_strings import logging +import numpy as np logger = logging.getLogger(__name__) @@ -24,12 +25,16 @@ def __init__(self, libE_info, calc_type): ], "The calc_type: {} specifies neither a simulator nor generator.".format(self.calc_type) self.calc_str = calc_type_strings[self.calc_type] - def send(self, output, calc_status=UNSET_TAG): + def send(self, output, calc_status=UNSET_TAG, keep_state=False): """ Send message from worker to manager. :param output: Output array to be sent to manager :param calc_status: Optional, Provides a task status + :param keep_state: Optional, If True the manager will not modify its + record of the workers state (usually the manager changes the + worker's state to inactive, indicating the worker is ready to receive + more work, unless using active receive mode). :returns: None @@ -41,6 +46,8 @@ def send(self, output, calc_status=UNSET_TAG): else: libE_info = self.libE_info + libE_info["keep_state"] = keep_state + D = { "calc_out": output, "libE_info": libE_info, @@ -54,6 +61,8 @@ def recv(self, blocking=True): """ Receive message to worker from manager. + :param blocking: Optional, If True (default), will block until a message is received. + :returns: message tag, Work dictionary, calc_in array """ @@ -102,3 +111,16 @@ def send_recv(self, output, calc_status=UNSET_TAG): """ self.send(output, calc_status) return self.recv() + + def request_cancel_sim_ids(self, sim_ids): + """Request cancellation of sim_ids + + :param sim_ids: A list of sim_ids to cancel + + A message is sent to the manager to mark requested sim_ids as cancel_requested + """ + H_o = np.zeros(len(sim_ids), dtype=[("sim_id", int), ("cancel_requested", bool)]) + H_o["sim_id"] = sim_ids + H_o["cancel_requested"] = True + print(H_o) + self.send(H_o, keep_state=True) diff --git a/libensemble/utils/misc.py b/libensemble/utils/misc.py new file mode 100644 index 0000000000..583e7edfdf --- /dev/null +++ b/libensemble/utils/misc.py @@ -0,0 +1,23 @@ +""" +Misc internal functions +""" + +from itertools import groupby +from operator import itemgetter + + +def extract_H_ranges(Work): + """Convert received H_rows into ranges for labeling""" + work_H_rows = Work["libE_info"]["H_rows"] + if len(work_H_rows) == 1: + return str(work_H_rows[0]) + else: + # From https://stackoverflow.com/a/30336492 + ranges = [] + for diff, group in groupby(enumerate(work_H_rows.tolist()), lambda x: x[0] - x[1]): + group = list(map(itemgetter(1), group)) + if len(group) > 1: + ranges.append(str(group[0]) + "-" + str(group[-1])) + else: + ranges.append(str(group[0])) + return "_".join(ranges) diff --git a/libensemble/utils/runners.py b/libensemble/utils/runners.py new file mode 100644 index 0000000000..806b68258b --- /dev/null +++ b/libensemble/utils/runners.py @@ -0,0 +1,86 @@ +import logging +import logging.handlers + +from libensemble.message_numbers import EVAL_SIM_TAG, EVAL_GEN_TAG + +logger = logging.getLogger(__name__) + + +class Runners: + """Determines and returns methods for workers to run user functions. + + Currently supported: direct-call and funcX + """ + + def __init__(self, sim_specs, gen_specs): + self.sim_specs = sim_specs + self.gen_specs = gen_specs + self.sim_f = sim_specs["sim_f"] + self.gen_f = gen_specs.get("gen_f") + self.has_funcx_sim = len(sim_specs.get("funcx_endpoint", "")) > 0 + self.has_funcx_gen = len(gen_specs.get("funcx_endpoint", "")) > 0 + self.funcx_exctr = None + + if any([self.has_funcx_sim, self.has_funcx_gen]): + try: + from funcx import FuncXClient + from funcx.sdk.executor import FuncXExecutor + + self.funcx_exctr = FuncXExecutor(FuncXClient()) + + except ModuleNotFoundError: + logger.warning("funcX use detected but funcX not importable. Is it installed?") + + def make_runners(self): + """Creates functions to run a sim or gen. These functions are either + called directly by the worker or submitted to a funcX endpoint.""" + + def run_sim(calc_in, persis_info, libE_info): + """Determines how to run sim.""" + if self.has_funcx_sim and self.funcx_exctr: + result = self._funcx_result + else: + result = self._normal_result + + return result(calc_in, persis_info, self.sim_specs, libE_info, self.sim_f) + + if self.gen_specs: + + def run_gen(calc_in, persis_info, libE_info): + """Determines how to run gen.""" + if self.has_funcx_gen and self.funcx_exctr: + result = self._funcx_result + else: + result = self._normal_result + + return result(calc_in, persis_info, self.gen_specs, libE_info, self.gen_f) + + else: + run_gen = [] + + return {EVAL_SIM_TAG: run_sim, EVAL_GEN_TAG: run_gen} + + def _normal_result(self, calc_in, persis_info, specs, libE_info, user_f): + """User function called in-place""" + return user_f(calc_in, persis_info, specs, libE_info) + + def _funcx_result(self, calc_in, persis_info, specs, libE_info, user_f): + """User function submitted to funcX""" + from libensemble.worker import Worker + + libE_info["comm"] = None # 'comm' object not pickle-able + Worker._set_executor(0, None) # ditto for executor + + future = self.funcx_exctr.submit( + user_f, + calc_in, + persis_info, + specs, + libE_info, + endpoint_id=specs["funcx_endpoint"], + ) + remote_exc = future.exception() # blocks until exception or None + if remote_exc is None: + return future.result() + else: + raise remote_exc diff --git a/libensemble/version.py b/libensemble/version.py index a2fecb4576..ddb97c066f 100644 --- a/libensemble/version.py +++ b/libensemble/version.py @@ -1 +1 @@ -__version__ = "0.9.2" +__version__ = "0.9.2+dev" diff --git a/libensemble/worker.py b/libensemble/worker.py index ba1cdb1145..ae8e8196e7 100644 --- a/libensemble/worker.py +++ b/libensemble/worker.py @@ -17,7 +17,9 @@ from libensemble.message_numbers import calc_type_strings, calc_status_strings from libensemble.output_directory import EnsembleDirectory +from libensemble.utils.misc import extract_H_ranges from libensemble.utils.timer import Timer +from libensemble.utils.runners import Runners from libensemble.executors.executor import Executor from libensemble.resources.resources import Resources from libensemble.comms.logs import worker_logging_config @@ -134,72 +136,11 @@ def __init__(self, comm, dtypes, workerID, sim_specs, gen_specs, libE_specs): self.stats_fmt = libE_specs.get("stats_fmt", {}) self.calc_iter = {EVAL_SIM_TAG: 0, EVAL_GEN_TAG: 0} - self._run_calc = Worker._make_runners(sim_specs, gen_specs) + self._run_calc = Runners(sim_specs, gen_specs).make_runners() Worker._set_executor(self.workerID, self.comm) Worker._set_resources(self.workerID, self.comm) self.EnsembleDirectory = EnsembleDirectory(libE_specs=libE_specs) - @staticmethod - def _funcx_result(funcx_exctr, user_f, calc_in, persis_info, specs, libE_info): - libE_info["comm"] = None # 'comm' object not pickle-able - Worker._set_executor(0, None) # ditto for executor - - future = funcx_exctr.submit(user_f, calc_in, persis_info, specs, libE_info, endpoint_id=specs["funcx_endpoint"]) - remote_exc = future.exception() # blocks until exception or None - if remote_exc is None: - return future.result() - else: - raise remote_exc - - @staticmethod - def _get_funcx_exctr(sim_specs, gen_specs): - funcx_sim = len(sim_specs.get("funcx_endpoint", "")) > 0 - funcx_gen = len(gen_specs.get("funcx_endpoint", "")) > 0 - - if any([funcx_sim, funcx_gen]): - try: - from funcx import FuncXClient - from funcx.sdk.executor import FuncXExecutor - - return FuncXExecutor(FuncXClient()), funcx_sim, funcx_gen - except ModuleNotFoundError: - logger.warning("funcX use detected but funcX not importable. Is it installed?") - return None, False, False - except Exception: - return None, False, False - else: - return None, False, False - - @staticmethod - def _make_runners(sim_specs, gen_specs): - """Creates functions to run a sim or gen. These functions are either - called directly by the worker or submitted to a funcX endpoint.""" - - funcx_exctr, funcx_sim, funcx_gen = Worker._get_funcx_exctr(sim_specs, gen_specs) - sim_f = sim_specs["sim_f"] - - def run_sim(calc_in, persis_info, libE_info): - """Calls or submits the sim func.""" - if funcx_sim and funcx_exctr: - return Worker._funcx_result(funcx_exctr, sim_f, calc_in, persis_info, sim_specs, libE_info) - else: - return sim_f(calc_in, persis_info, sim_specs, libE_info) - - if gen_specs: - gen_f = gen_specs["gen_f"] - - def run_gen(calc_in, persis_info, libE_info): - """Calls or submits the gen func.""" - if funcx_gen and funcx_exctr: - return Worker._funcx_result(funcx_exctr, gen_f, calc_in, persis_info, gen_specs, libE_info) - else: - return gen_f(calc_in, persis_info, gen_specs, libE_info) - - else: - run_gen = [] - - return {EVAL_SIM_TAG: run_sim, EVAL_GEN_TAG: run_gen} - @staticmethod def _set_rset_team(rset_team): """Pass new rset_team to worker resources""" @@ -257,7 +198,7 @@ def _handle_calc(self, Work, calc_in): # from output_directory.py if calc_type == EVAL_SIM_TAG: enum_desc = "sim_id" - calc_id = EnsembleDirectory.extract_H_ranges(Work) + calc_id = extract_H_ranges(Work) else: enum_desc = "Gen no" # Use global gen count if available @@ -318,7 +259,6 @@ def _handle_calc(self, Work, calc_in): def _get_calc_msg(self, enum_desc, calc_id, calc_type, timer, status): """Construct line for libE_stats.txt file""" - calc_msg = "{} {}: {} {}".format(enum_desc, calc_id, calc_type, timer) if self.stats_fmt.get("task_timing", False) or self.stats_fmt.get("task_datetime", False): @@ -336,7 +276,6 @@ def _get_calc_msg(self, enum_desc, calc_id, calc_type, timer, status): def _recv_H_rows(self, Work): """Unpacks Work request and receives any history rows""" - libE_info = Work["libE_info"] calc_type = Work["tag"] if len(libE_info["H_rows"]) > 0: @@ -351,7 +290,6 @@ def _recv_H_rows(self, Work): def _handle(self, Work): """Handles a work request from the manager""" - # Check work request and receive second message (if needed) libE_info, calc_type, calc_in = self._recv_H_rows(Work) @@ -385,7 +323,6 @@ def _handle(self, Work): def run(self): """Runs the main worker loop.""" - try: logger.info("Worker {} initiated on node {}".format(self.workerID, socket.gethostname())) diff --git a/scripts/liberegister b/scripts/liberegister new file mode 100644 index 0000000000..c4a42671d6 --- /dev/null +++ b/scripts/liberegister @@ -0,0 +1,164 @@ +#! /usr/bin/env python + +import os +import sys +import shutil +import argparse +from pathlib import Path +from libensemble.version import __version__ +from libensemble.tools.parse_args import parser as callscript_parser + +try: + from psij import Job, JobSpec + from psij.resource_spec import ResourceSpecV1 + from psij.job_attributes import JobAttributes + from psij.serialize import Export +except ModuleNotFoundError: + print(f"*** libEnsemble {__version__} ***") + print("\nThe PSI/J Python interface is not installed. Please install it via the following:\n") + print(" git clone https://github.com/ExaWorks/psi-j-python.git") + print(" cd psi-j-python; pip install -e .\n") + +if __name__ == "__main__": + + parser = argparse.ArgumentParser( + prog="liberegister", + description="Produce a PSI/J representation for a libEnsemble execution.", + epilog="Output representations can be passed to `libesubmit`", + parents=[callscript_parser], + conflict_handler="resolve", + ) + + parser.add_argument("calling_script", nargs="?") + + parser.add_argument( + "-o", + "--outfile", + type=str, + nargs="?", + help="Output PSI/J representation filename.", + default="libe-job.json", + ) + + parser.add_argument( + "-n", "--nnodes", type=int, nargs="?", help="Number of nodes", default=1 + ) + + parser.add_argument( + "-p", + "--python-path", + type=Path, + nargs="?", + help="Which Python to use.", + default="python", + ) + + choices = ["cobalt", "local", "flux", "lsf", "pbspro", "rp", "slurm"] + + parser.add_argument( + "-s", + "--scheduler", + choices=choices, + help="Which scheduler to use.", + default=None, + ) + + parser.add_argument( + "-j", + "--jobname", + type=str, + nargs="?", + help="Scheduler job name.", + default="libe-job", + ) + + parser.add_argument( + "-q", "--queue", type=str, nargs="?", help="Scheduler queue name.", default=None + ) + + parser.add_argument( + "-A", + "--project", + type=str, + nargs="?", + help="Project name for billing hours.", + default=None, + ) + + parser.add_argument( + "-t", + "--wallclock", + type=int, + nargs="?", + help="Total wallclock for job.", + default=30, + ) + + parser.add_argument( + "-d", + "--directory", + type=Path, + nargs="?", + help="Working directory for job.", + default=None, + ) + + jobargs, unknown = parser.parse_known_args(sys.argv[1:]) + + if not jobargs.calling_script: + parser.print_help() + sys.exit( + "\nMust supply a calling script, with the --comms and --nworkers options" + ) + + if not jobargs.calling_script.endswith(".py"): + parser.print_help() + sys.exit("\nFirst argument doesn't appear to be a Python script.") + + basename = jobargs.calling_script.split(".py")[0] + outfile_default = basename + ".json" + + executable = jobargs.python_path + + if jobargs.comms == "local": + arguments = [ + jobargs.calling_script, + "--comms", + jobargs.comms, + ] + + if jobargs.nworkers: + arguments.extend(["--nworkers", str(jobargs.nworkers)]) + + resources = ResourceSpecV1(node_count=jobargs.nnodes) + else: # jobargs.comms == "mpi": + arguments = [jobargs.calling_script] + resources = ResourceSpecV1( + process_count=jobargs.nworkers + 1, processes_per_node=1 + ) + + if jobargs.nsim_workers: + arguments.extend(['--nsim_workers', str(jobargs.nsim_workers)]) + + if jobargs.nresource_sets: + arguments.extend(['--nresource_sets', str(jobargs.nresource_sets)]) + + jobspec = JobSpec( + name=jobargs.jobname, + executable=str(executable), + arguments=arguments, + directory=jobargs.directory, + environment={"PYTHONNOUSERSITE": "1"}, + resources=resources, + attributes=JobAttributes( + duration=jobargs.wallclock, + queue_name=jobargs.queue, + project_name=jobargs.project, + ), + ) + + Export().export(obj=jobspec, dest=outfile_default) + print(f"*** libEnsemble {__version__} ***") + print( + f"Exported PSI/J serialization: {outfile_default}\nOptionally adjust any fields, or specify job attributes on submission to `libesubmit`." + ) diff --git a/scripts/libesubmit b/scripts/libesubmit new file mode 100644 index 0000000000..9adca85369 --- /dev/null +++ b/scripts/libesubmit @@ -0,0 +1,229 @@ +#! /usr/bin/env python + +import os +import sys +import time +import shutil +import argparse +from pathlib import Path + +from libensemble.version import __version__ +from libensemble.resources import node_resources + +try: + from tqdm.auto import tqdm +except ModuleNotFoundError: + print(f"*** libEnsemble {__version__} ***") + print("\ntqdm is not installed, but this only matters if libesubmit can't find your calling script.\n") + print("\ntqdm can be installed via:\n") + print(" pip install tqdm") + +try: + from psij import JobExecutor, Import, Export, JobSpec, Job + from psij.resource_spec import ResourceSpecV1 + from psij.job_attributes import JobAttributes +except ModuleNotFoundError: + print(f"*** libEnsemble {__version__} ***") + print("\nThe PSI/J Python interface is not installed. Please install it via the following:\n") + print(" git clone https://github.com/ExaWorks/psi-j-python.git") + print(" cd psi-j-python; pip install -e .\n") + +if __name__ == "__main__": + + parser = argparse.ArgumentParser( + prog="libesubmit", + description="Submit a libEnsemble PSI/J job representation for execution. Additional options may overwrite the input file.", + conflict_handler="resolve", + ) + + choices = { + "cobalt": "aprun", + "local": "mpirun", + "flux": "mpirun", + "lsf": "jsrun", + "pbspro": "mpirun", + "rp": "mpirun", + "slurm": "srun", + } + + parser.add_argument("-s", "--scheduler", choices=choices.keys(), required=True) + + parser.add_argument( + "-w", + "--wait", + action="store_true", + help="Wait for Job to complete before exiting.", + ) + + parser.add_argument( + "--dry", + action="store_true", + help="Parameterize and re-serialize a Job, without submitting.", + ) + + parser.add_argument( + "-n", "--nnodes", type=int, nargs="?", help="Number of nodes", default=1 + ) + + parser.add_argument( + "-p", + "--python-path", + type=Path, + nargs="?", + help="Which Python to use. Default is current Python.", + default=sys.executable, + ) + + parser.add_argument( + "-q", "--queue", type=str, nargs="?", help="Scheduler queue name.", default=None + ) + + parser.add_argument( + "-A", + "--project", + type=str, + nargs="?", + help="Scheduler project name.", + default=None, + ) + + parser.add_argument( + "-t", + "--wallclock", + type=int, + nargs="?", + help="Total wallclock for job. Default is 30 minutes.", + default=30, + ) + + parser.add_argument( + "-d", + "--directory", + type=Path, + nargs="?", + help="Working directory for job. Default is current directory.", + default=os.getcwd(), + ) + + jobargs, unknown = parser.parse_known_args(sys.argv[1:]) + + script = sys.argv[1] + if not script.endswith(".json"): + parser.print_help() + sys.exit("First argument doesn't appear to be a .json file.") + + print(f"*** libEnsemble {__version__} ***") + print(f"Imported PSI/J serialization: {script}. Preparing submission...") + + importer = Import() + jobspec = importer.load(script) + assert isinstance(jobspec, JobSpec), "Invalid input file." + + jobspec.directory = str(jobargs.directory) + jobspec.attributes.project_name = jobargs.project + jobspec.attributes.queue_name = jobargs.queue + if jobspec.executable == "python": + jobspec.executable = str(jobargs.python_path) + jobspec.attributes.duration = jobargs.wallclock + if jobspec.resources["node_count"] == 1: + jobspec.resources["node_count"] = jobargs.nnodes + + # we enforced passing a python script in liberegister + callscript = [i for i in jobspec.arguments if str(i).endswith(".py")][0] + print(f"Calling script: {callscript}") + + if callscript not in os.listdir(jobargs.directory) and not os.path.isfile( + callscript + ): + print("... not found in Job working directory!") + exit = input("Check somewhere else? (Y/N): ") + if exit.upper() != "Y": + print("Exiting") + sys.exit() + + home = os.path.expanduser("~") + check_dirs = [] + for i in os.listdir(home): + if os.path.isdir(os.path.join(home, i)) and "." not in i: + check_dirs.append(i) + + print(home + ":") + for i in enumerate(check_dirs): + print(f" {i[0]+1}. /{i[1]}") + + inchoice = input("Specify a starting directory: ") + choice = home + "/" + check_dirs[int(inchoice)-1] + + def walkdir(folder): + """Walk through every file in a directory""" + for dirpath, dirs, files in os.walk(folder, topdown=True): + for filename in files: + yield os.path.abspath(os.path.join(dirpath, filename)) + + print("preparing... ctrl+c to abort.") + filescount = 0 + for _ in tqdm(walkdir(choice)): + filescount += 1 + + print("detecting... ctrl+c to abort.") + print(home + ":") + candidate_script_paths = [] + try: + for filepath in tqdm(walkdir(choice), total=filescount): + if callscript in filepath.split("/"): + candidate_script_paths.append(filepath) + tqdm.write( + f" {len(candidate_script_paths)}. {filepath.split(choice)[1]}" + ) + + exit = input("Specify a detected script: ") + new_callscript = candidate_script_paths[int(exit) - 1] + + except KeyboardInterrupt: + exit = input( + "detection interrupted. ctrl+c again to exit, or specify a detected script: " + ) + new_callscript = candidate_script_paths[int(exit) - 1] + + jobspec.arguments[jobspec.arguments.index(callscript)] = new_callscript + + else: + print("...found! Proceeding.") + + # Little bit strange I have to re-initialize this class to re-serialize + if not jobspec.resources[ + "node_count" + ]: # running with MPI - need corresponding executor + jobspec.resources = ResourceSpecV1( + process_count=jobspec.resources["process_count"], + processes_per_node=1, + cpu_cores_per_process=64 + ) + jobspec.launcher = choices[jobargs.scheduler] + else: + jobspec.resources = ResourceSpecV1(node_count=jobspec.resources["node_count"]) + + jex = JobExecutor.get_instance(jobargs.scheduler) + job = Job() + + if job.id.split("-")[0] in script: + reserialdest = script + else: + reserialdest = job.id.split("-")[0] + "." + script + + stdout_path = job.id.split("-")[0] + "." + script.replace("json", "out") + stderr_path = job.id.split("-")[0] + "." + script.replace("json", "err") + jobspec.stdout_path = stdout_path + jobspec.stderr_path = stderr_path + + Export().export(obj=jobspec, dest=reserialdest) + + job.spec = jobspec + + if not jobargs.dry: + print("Submitting Job!:", job) + jex.submit(job) + + if jobargs.wait: + print("Waiting on Job completion...") + job.wait() diff --git a/setup.py b/setup.py index c396af7d3d..94ac971693 100644 --- a/setup.py +++ b/setup.py @@ -99,6 +99,10 @@ def run_tests(self): "sphinx_rtd_theme", ], }, + scripts=[ + "scripts/liberegister", + "scripts/libesubmit", + ], classifiers=[ "Development Status :: 4 - Beta", "Intended Audience :: Developers",