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/.gitignore b/.gitignore index af15ee6c3d..a95770896c 100644 --- a/.gitignore +++ b/.gitignore @@ -15,6 +15,7 @@ x.log *.out *.err *.stat +*.csv .vscode build/ 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/examples/tutorials/simple_sine/tutorial_calling.py b/examples/tutorials/simple_sine/tutorial_calling.py index d07fdc68a0..43afd5255a 100644 --- a/examples/tutorials/simple_sine/tutorial_calling.py +++ b/examples/tutorials/simple_sine/tutorial_calling.py @@ -40,7 +40,7 @@ worker_xy = np.extract(H["sim_worker"] == i, H) x = [entry.tolist()[0] for entry in worker_xy["x"]] y = [entry for entry in worker_xy["y"]] - plt.scatter(x, y, label="Worker {}".format(i), c=colors[i - 1]) + plt.scatter(x, y, label=f"Worker {i}", c=colors[i - 1]) plt.title("Sine calculations for a uniformly sampled random distribution") plt.xlabel("x") diff --git a/examples/tutorials/simple_sine/tutorial_calling_mpi.py b/examples/tutorials/simple_sine/tutorial_calling_mpi.py index c6d6690885..fdc69aa101 100644 --- a/examples/tutorials/simple_sine/tutorial_calling_mpi.py +++ b/examples/tutorials/simple_sine/tutorial_calling_mpi.py @@ -45,7 +45,7 @@ worker_xy = np.extract(H["sim_worker"] == i, H) x = [entry.tolist()[0] for entry in worker_xy["x"]] y = [entry for entry in worker_xy["y"]] - plt.scatter(x, y, label="Worker {}".format(i), c=colors[i - 1]) + plt.scatter(x, y, label=f"Worker {i}", c=colors[i - 1]) plt.title("Sine calculations for a uniformly sampled random distribution") plt.xlabel("x") 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/alloc_funcs/start_persistent_consensus.py b/libensemble/alloc_funcs/start_persistent_consensus.py index 31cf287894..b68595bf3a 100644 --- a/libensemble/alloc_funcs/start_persistent_consensus.py +++ b/libensemble/alloc_funcs/start_persistent_consensus.py @@ -133,9 +133,9 @@ def start_consensus_persistent_gens(W, H, sim_specs, gen_specs, alloc_specs, per )[0] if len(consensus_sim_ids) > 0: - assert ( - len(consensus_sim_ids) == 1 - ), "Gen should only send one " + "point for consensus step, received {}".format(len(consensus_sim_ids)) + assert len(consensus_sim_ids) == 1, ( + "Gen should only send one " + f"point for consensus step, received {len(consensus_sim_ids)}" + ) # re-center (since the last_H_len has relative index 0) sim_id = consensus_sim_ids[0] + last_H_len @@ -168,9 +168,7 @@ def start_consensus_persistent_gens(W, H, sim_specs, gen_specs, alloc_specs, per assert num_gens_at_consensus == len( avail_persis_worker_ids - ), "All gens must be available, only {}/{} are though...".format( - len(avail_persis_worker_ids), len(num_gens_at_consensus) - ) + ), f"All gens must be available, only {len(avail_persis_worker_ids)}/{len(num_gens_at_consensus)} are though..." # get index in history array @H where each gen's consensus point lies consensus_ids_in_H = np.array([persis_info[i]["curr_H_ids"][0] for i in avail_persis_worker_ids], dtype=int) @@ -226,12 +224,12 @@ def start_consensus_persistent_gens(W, H, sim_specs, gen_specs, alloc_specs, per persis_info[wid].update({"at_consensus": False}) if print_obj and print_progress: - msg = "F(x)={:.8f}\n".format(fsum) - print("{}con={:.4e}".format(msg, np.dot(x, Ax)), flush=True) + msg = f"F(x)={fsum:.8f}\n" + print(f"{msg}con={np.dot(x, Ax):.4e}", flush=True) elif print_obj: - print("F(x)={:.8f}".format(fsum), flush=True) + print(f"F(x)={fsum:.8f}", flush=True) elif print_progress: - print("con={:.4e}".format(np.dot(x, Ax)), flush=True) + print(f"con={np.dot(x, Ax):.4e}", flush=True) # partition sum of convex functions evenly (only do at beginning) if is_first_iter and len(support.avail_worker_ids(persistent=False)): @@ -308,9 +306,7 @@ def start_consensus_persistent_gens(W, H, sim_specs, gen_specs, alloc_specs, per assert ( l_H_ids == persis_info["next_to_give"] - ), "@next_to_give={} does not match gen's requested work H id of {}".format( - persis_info["next_to_give"], l_H_ids - ) + ), f"@next_to_give={persis_info['next_to_give']} does not match gen's requested work H id of {l_H_ids}" persis_info[wid].update({"params": persis_info.get("sim_params", {})}) diff --git a/libensemble/api.py b/libensemble/api.py index 678882dead..dca5aedb84 100644 --- a/libensemble/api.py +++ b/libensemble/api.py @@ -93,7 +93,7 @@ def __str__(self): Returns pretty-printed representation of Ensemble object. Depicts libEnsemble version, plus representations of major specification dicts. """ - info = "\nlibEnsemble {}\n".format(__version__) + 79 * "*" + "\n" + info = f"\nlibEnsemble {__version__}\n" + 79 * "*" + "\n" info += "\nCalling Script: " + self._filename.split("/")[-1] + "\n" dicts = { @@ -106,7 +106,7 @@ def __str__(self): } for i in dicts: - info += "{}:\n {} \n\n".format(i, pprint.pformat(dicts[i])) + info += f"{i}:\n {pprint.pformat(dicts[i])} \n\n" info += 79 * "*" return info diff --git a/libensemble/comms/comms.py b/libensemble/comms/comms.py index ef7d77e2b3..63dd403385 100644 --- a/libensemble/comms/comms.py +++ b/libensemble/comms/comms.py @@ -344,7 +344,7 @@ def process_message(self, timeout=None): msg_type = msg[0] args = msg[1:] try: - method = "on_{}".format(msg_type) + method = f"on_{msg_type}" handler = getattr(self, method) except AttributeError: return self.on_unhandled_message(msg) @@ -352,7 +352,7 @@ def process_message(self, timeout=None): def on_unhandled_message(self, msg): """Handle any messages for which there are no named handlers.""" - raise ValueError("No handler available for message {0}{1}".format(msg[0], msg[1:])) + raise ValueError(f"No handler available for message {msg[0]}{msg[1:]}") class GenCommHandler(CommHandler): diff --git a/libensemble/comms/logs.py b/libensemble/comms/logs.py index 997f312641..0651022a3c 100644 --- a/libensemble/comms/logs.py +++ b/libensemble/comms/logs.py @@ -79,7 +79,7 @@ def __init__(self, worker_id): self.prefix = "Manager" + " " * (WorkerIDFilter.margin_align) else: worker_str = str(self.worker_id).rjust(WorkerIDFilter.margin_align, " ") - self.prefix = "Worker {}".format(worker_str) + self.prefix = f"Worker {worker_str}" def filter(self, record): """Add worker ID to a LogRecord""" @@ -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() @@ -181,11 +179,11 @@ def manager_logging_config(): else: stat_logger = logging.getLogger(logconfig.stats_name) - stat_logger.info("Starting ensemble at: {}".format(stat_timer.date_start)) + stat_logger.info(f"Starting ensemble at: {stat_timer.date_start}") def exit_logger(): stat_timer.stop() - stat_logger.info("Exiting ensemble at: {} Time Taken: {}".format(stat_timer.date_end, stat_timer.elapsed)) + stat_logger.info(f"Exiting ensemble at: {stat_timer.date_end} Time Taken: {stat_timer.elapsed}") # If closing logs - each libE() call will log to a new file. # fh.close() diff --git a/libensemble/comms/tcp_mgr.py b/libensemble/comms/tcp_mgr.py index 658a64c8fb..cee5fbe369 100644 --- a/libensemble/comms/tcp_mgr.py +++ b/libensemble/comms/tcp_mgr.py @@ -47,11 +47,11 @@ def get_queue(self, name): def get_inbox(self, workerID): """Get a worker inbox queue.""" - return self.get_queue("inbox{}".format(workerID)) + return self.get_queue(f"inbox{workerID}") def get_outbox(self, workerID): """Get a worker outbox queue.""" - return self.get_queue("outbox{}".format(workerID)) + return self.get_queue(f"outbox{workerID}") def get_shared(self): """Get a shared queue for worker subscription.""" @@ -103,11 +103,11 @@ def get_queue(self, name): def get_inbox(self): """Get this worker's inbox.""" - return self.get_queue("inbox{}".format(self.workerID)) + return self.get_queue(f"inbox{self.workerID}") def get_outbox(self): """Get this worker's outbox.""" - return self.get_queue("outbox{}".format(self.workerID)) + return self.get_queue(f"outbox{self.workerID}") def get_shared(self): """Get the shared queue for worker sign-up.""" diff --git a/libensemble/executors/balsam_executors/balsam_executor.py b/libensemble/executors/balsam_executors/balsam_executor.py index 969b10ba35..689f3504ed 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(f"Task {self.name} ended with state {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,10 +241,9 @@ 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)) + logger.info(f"Killing task {self.name}") self.state = "USER_KILLED" self.finished = True self.calc_task_timing() @@ -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. @@ -392,13 +380,12 @@ def submit_allocation( self.allocations.append(allocation) logger.info( - "Submitted Batch allocation to site {}: " - "nodes {} queue {} project {}".format(site_id, num_nodes, queue, project) + f"Submitted Batch allocation to site {site_id}: " f"nodes {num_nodes} queue {queue} project {project}" ) 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 +396,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,16 +521,12 @@ 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) if dry_run: task.dry_run = True - logger.info("Test (No submit) Balsam app {}".format(app_name)) + logger.info(f"Test (No submit) Balsam app {app_name}") task._set_complete(dry_run=True) else: App = app.pyobj @@ -563,9 +557,7 @@ def submit( task.timer.start() task.submit_time = task.timer.tstart # Time not date - may not need if using timer. - logger.info( - "Submitted Balsam App to site {}: " "nodes {} ppn {}".format(App.site, num_nodes, procs_per_node) - ) + logger.info(f"Submitted Balsam App to site {App.site}: " "nodes {num_nodes} ppn {procs_per_node}") self.list_of_tasks.append(task) return task diff --git a/libensemble/executors/balsam_executors/legacy_balsam_executor.py b/libensemble/executors/balsam_executors/legacy_balsam_executor.py index cf1a7b3aee..301b9b5a40 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() @@ -108,10 +106,10 @@ def _set_complete(self, dry_run=False): 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)) + logger.warning(f"Task finished, but in unrecognized Balsam state {balsam_state}") self.state = "UNKNOWN" - logger.info("Task {} ended with state {}".format(self.name, self.state)) + logger.info(f"Task {self.name} ended with state {self.state}") def poll(self): """Polls and updates the status attributes of the supplied task""" @@ -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,13 +174,12 @@ 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 - # but not implemented yet. - logger.info("Killing task {}".format(self.name)) + logger.info(f"Killing task {self.name}") self.state = "USER_KILLED" self.finished = True self.calc_task_timing() @@ -231,7 +227,7 @@ def del_apps(): deletion_objs = AppDef.objects.filter(name__contains=app_type) if deletion_objs: for del_app in deletion_objs.iterator(): - logger.debug("Deleting app {}".format(del_app.name)) + logger.debug(f"Deleting app {del_app.name}") deletion_objs.delete() @staticmethod @@ -241,7 +237,7 @@ def del_tasks(): deletion_objs = models.BalsamJob.objects.filter(name__contains=app_type) if deletion_objs: for del_task in deletion_objs.iterator(): - logger.debug("Deleting task {}".format(del_task.name)) + logger.debug(f"Deleting task {del_task.name}") deletion_objs.delete() @staticmethod @@ -255,7 +251,7 @@ def add_app(name, exepath, desc): # app.default_preprocess = '' # optional # app.default_postprocess = '' # optional app.save() - logger.debug("Added App {}".format(app.name)) + logger.debug(f"Added App {app.name}") def set_resources(self, resources): self.resources = resources @@ -326,7 +322,7 @@ def submit( if dry_run: task.dry_run = True - logger.info("Test (No submit) Runline: {}".format(" ".join(add_task_args))) + logger.info(f"Test (No submit) Runline: {' '.join(add_task_args)}") task._set_complete(dry_run=True) else: task.process = dag.add_job(**add_task_args) @@ -338,9 +334,7 @@ def submit( task.timer.start() task.submit_time = task.timer.tstart # Time not date - may not need if using timer. - logger.info( - "Added task to Balsam database {}: " "nodes {} ppn {}".format(task.name, num_nodes, procs_per_node) - ) + logger.info(f"Added task to Balsam database {task.name}: nodes {num_nodes} ppn {procs_per_node}") # task.workdir = task.process.working_directory # Might not be set yet! self.list_of_tasks.append(task) diff --git a/libensemble/executors/executor.py b/libensemble/executors/executor.py index 5fd19ae0d9..3d9964e12a 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, @@ -67,7 +66,7 @@ def __init__(self, task, timeout): self.timeout = timeout def __str__(self): - return "Task {} timed out after {} seconds".format(self.task, self.timeout) + return f"Task {self.task} timed out after {self.timeout} seconds" def jassert(test, *args): @@ -125,10 +124,10 @@ def __init__(self, app=None, app_args=None, workdir=None, stdout=None, stderr=No self.app_args = app_args self.workerID = workerid - jassert(app is not None, "Task must be created with an app - no app found for task {}".format(self.id)) + jassert(app is not None, f"Task must be created with an app - no app found for task {self.id}") - worker_name = "_worker{}".format(self.workerID) if self.workerID else "" - self.name = Task.prefix + "_{}{}_{}".format(app.name, worker_name, self.id) + worker_name = f"_worker{self.workerID}" if self.workerID else "" + self.name = Task.prefix + f"_{app.name}{worker_name}_{self.id}" self.stdout = stdout or self.name + ".out" self.stderr = stderr or self.name + ".err" self.workdir = workdir @@ -159,7 +158,7 @@ def read_file_in_workdir(self, filename): """Opens and reads the named file in the task's workdir""" path = os.path.join(self.workdir, filename) if not os.path.exists(path): - raise ValueError("{} not found in working directory".format(filename)) + raise ValueError(f"{filename} not found in working directory") with open(path) as f: return f.read() @@ -193,13 +192,9 @@ def calc_task_timing(self): def _check_poll(self): """Check whether polling this task makes sense.""" - jassert( - self.process is not None, "Polled task {} has no process ID - check tasks been launched".format(self.name) - ) + jassert(self.process is not None, f"Polled task {self.name} has no process ID - check tasks been launched") if self.finished: - logger.debug( - "Polled task {} has already finished. " "Not re-polling. Status is {}".format(self.name, self.state) - ) + logger.debug(f"Polled task {self.name} has already finished. Not re-polling. Status is {self.state}") return False return True @@ -214,7 +209,7 @@ def _set_complete(self, dry_run=False): self.errcode = self.process.returncode self.success = self.errcode == 0 self.state = "FINISHED" if self.success else "FAILED" - logger.info("Task {} finished with errcode {} ({})".format(self.name, self.errcode, self.state)) + logger.info(f"Task {self.name} finished with errcode {self.errcode} ({self.state})") def poll(self): """Polls and updates the status attributes of the task""" @@ -244,8 +239,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 +264,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 +279,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) @@ -313,19 +305,17 @@ def kill(self, wait_time=60): return if self.finished: - logger.warning( - "Trying to kill task that is no longer running. Task {}: Status is {}".format(self.name, self.state) - ) + logger.warning(f"Trying to kill task that is no longer running. Task {self.name}: Status is {self.state}") return if self.process is None: time.sleep(0.2) jassert( self.process is not None, - "Attempting to kill task {} that has no process ID - check tasks been launched".format(self.name), + f"Attempting to kill task {self.name} that has no process ID - check tasks been launched", ) - logger.info("Killing task {}".format(self.name)) + logger.info(f"Killing task {self.name}") launcher.cancel(self.process, wait_time) self.state = "USER_KILLED" self.finished = True @@ -350,6 +340,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 @@ -367,7 +358,7 @@ def _wait_on_start(self, task, fail_time=None): while task.state in NOT_STARTED_STATES: time.sleep(0.001) task.poll() - logger.debug("Task {} polled as {} after {} seconds".format(task.name, task.state, time.time() - start)) + logger.debug(f"Task {task.name} polled as {task.state} after {time.time() - start} seconds") if not task.finished: task.timer.start() task.submit_time = task.timer.tstart @@ -377,7 +368,7 @@ def _wait_on_start(self, task, fail_time=None): time.sleep(min(0.01, remaining)) task.poll() remaining = fail_time - task.timer.elapsed - logger.debug("After {} seconds: task {} polled as {}".format(task.timer.elapsed, task.name, task.state)) + logger.debug(f"After {task.timer.elapsed} seconds: task {task.name} polled as {task.state}") def __init__(self): """Instantiate a new Executor instance. @@ -386,7 +377,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 = {} @@ -424,7 +415,7 @@ def get_app(self, app_name): except KeyError: app_keys = list(self.apps.keys()) raise ExecutorException( - "Application {} not found in registry".format(app_name), "Registered applications: {}".format(app_keys) + f"Application {app_name} not found in registry", f"Registered applications: {app_keys}" ) return app @@ -432,7 +423,7 @@ def default_app(self, calc_type): """Gets the default app for a given calc type""" app = self.default_apps.get(calc_type) jassert(calc_type in ["sim", "gen"], "Unrecognized calculation type", calc_type) - jassert(app, "Default {} app is not set".format(calc_type)) + jassert(app, f"Default {calc_type} app is not set") return app def set_resources(self, resources): @@ -485,7 +476,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 +486,23 @@ 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(f"Worker received kill signal {man_signal} from manager") else: - logger.warning("Received unrecognized manager signal {} - ignoring".format(man_signal)) + logger.warning(f"Received unrecognized manager signal {man_signal} - ignoring") 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 +540,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 @@ -560,9 +558,7 @@ def polling_loop(self, task, timeout=None, delay=0.1, poll_manager=False): elif task.state == "FAILED": calc_status = TASK_FAILED else: - logger.warning( - "Warning: Task {} in unknown state {}. Error code {}".format(self.name, self.state, self.errcode) - ) + logger.warning(f"Warning: Task {self.name} in unknown state {self.state}. Error code {self.errcode}") return calc_status @@ -570,7 +566,7 @@ def get_task(self, taskid): """Returns the task object for the supplied task ID""" task = next((j for j in self.list_of_tasks if j.id == taskid), None) if task is None: - logger.warning("Task {} not found in tasklist".format(taskid)) + logger.warning(f"Task {taskid} not found in tasklist") return task def new_tasks_timing(self, datetime=False): @@ -588,9 +584,9 @@ def new_tasks_timing(self, datetime=False): start_task = self.last_task for i, task in enumerate(self.list_of_tasks[start_task:]): if datetime: - timing_msg += " Task {}: {}".format(i, task.timer) + timing_msg += f" Task {i}: {task.timer}" else: - timing_msg += " Task {}: {}".format(i, task.timer.summary()) + timing_msg += f" Task {i}: {task.timer.summary()}" self.last_task += 1 return timing_msg @@ -606,7 +602,7 @@ def set_worker_info(self, comm, workerid=None): def _check_app_exists(self, full_path): """Allows submit function to check if app exists and error if not""" if not os.path.isfile(full_path): - raise ExecutorException("Application does not exist {}".format(full_path)) + raise ExecutorException(f"Application does not exist {full_path}") def submit( self, calc_type=None, app_name=None, app_args=None, stdout=None, stderr=None, dry_run=False, wait_on_start=False @@ -668,10 +664,10 @@ def submit( runline.extend(task.app_args.split()) if dry_run: - logger.info("Test (No submit) Runline: {}".format(" ".join(runline))) + logger.info(f"Test (No submit) Runline: {' '.join(runline)}") else: # Launch Task - logger.info("Launching task {}: {}".format(task.name, " ".join(runline))) + logger.info(f"Launching task {task.name}: {' '.join(runline)}") with open(task.stdout, "w") as out, open(task.stderr, "w") as err: task.process = launcher.launch( runline, diff --git a/libensemble/executors/mpi_executor.py b/libensemble/executors/mpi_executor.py index 7b0697b583..83871834e0 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. @@ -102,8 +108,8 @@ def _launch_with_retries(self, task, runline, subgroup_launch, wait_on_start): while retry_count < self.max_launch_attempts: retry = False try: - retry_string = " (Retry {})".format(retry_count) if retry_count > 0 else "" - logger.info("Launching task {}{}: {}".format(task.name, retry_string, " ".join(runline))) + retry_string = f" (Retry {retry_count})" if retry_count > 0 else "" + logger.info(f"Launching task {task.name}{retry_string}: {' '.join(runline)}") task.run_attempts += 1 with open(task.stdout, "w") as out, open(task.stderr, "w") as err: task.process = launcher.launch( @@ -114,9 +120,7 @@ def _launch_with_retries(self, task, runline, subgroup_launch, wait_on_start): start_new_session=subgroup_launch, ) except Exception as e: - logger.warning( - "task {} submit command failed on try {} with error {}".format(task.name, retry_count, e) - ) + logger.warning(f"task {task.name} submit command failed on try {retry_count} with error {e}") retry = True retry_count += 1 else: @@ -125,14 +129,14 @@ def _launch_with_retries(self, task, runline, subgroup_launch, wait_on_start): if task.state == "FAILED": logger.warning( - "task {} failed within fail_time on " - "try {} with err code {}".format(task.name, retry_count, task.errcode) + f"task {task.name} failed within fail_time on " + f"try {retry_count} with err code {task.errcode}" ) retry = True retry_count += 1 if retry and retry_count < self.max_launch_attempts: - logger.debug("Retry number {} for task {}".format(retry_count, task.name)) + logger.debug(f"Retry number {retry_count} for task {task.name}") time.sleep(retry_count * self.retry_delay_incr) task.reset() # Some cases may require user cleanup else: @@ -265,7 +269,7 @@ def submit( task.runline = " ".join(runline) # Allow to be queried if dry_run: task.dry_run = True - logger.info("Test (No submit) Runline: {}".format(" ".join(runline))) + logger.info(f"Test (No submit) Runline: {' '.join(runline)}") task._set_complete(dry_run=True) else: # Launch Task diff --git a/libensemble/executors/mpi_runner.py b/libensemble/executors/mpi_runner.py index aa6f68c663..a1a1ecf028 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] @@ -92,7 +93,7 @@ def get_mpi_specs( hostlist = None if machinefile and not self.mfile_support: - logger.warning("User machinefile ignored - not supported by {}".format(self.run_command)) + logger.warning(f"User machinefile ignored - not supported by {self.run_command}") machinefile = None if machinefile is None and resources is not None: @@ -171,8 +172,8 @@ def express_spec( machinefile = "machinefile_autogen" if workerID is not None: - machinefile += "_for_worker_{}".format(workerID) - machinefile += "_task_{}".format(task.id) + machinefile += f"_for_worker_{workerID}" + machinefile += f"_task_{task.id}" mfile_created, num_procs, num_nodes, procs_per_node = mpi_resources.create_machinefile( resources, machinefile, num_procs, num_nodes, procs_per_node, hyperthreads ) @@ -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 @@ -243,7 +261,7 @@ def get_mpi_specs( hostlist = None if machinefile and not self.mfile_support: - logger.warning("User machinefile ignored - not supported by {}".format(self.run_command)) + logger.warning(f"User machinefile ignored - not supported by {self.run_command}") machinefile = None if machinefile is None and resources is not None: num_procs, num_nodes, procs_per_node = mpi_resources.get_resources( diff --git a/libensemble/gen_funcs/__init__.py b/libensemble/gen_funcs/__init__.py index 27d8c189bd..c2012c1e29 100644 --- a/libensemble/gen_funcs/__init__.py +++ b/libensemble/gen_funcs/__init__.py @@ -1,19 +1,46 @@ -def rc(**kargs): - """Runtime configuration options. +import os +import csv +import logging - Parameters - ---------- - aposmm_optimizers : string or list of strings - Select the aposmm optimizer/s (to prevent all options being imported). +logger = logging.getLogger(__name__) - """ - for key in kargs: - if not hasattr(rc, key): - raise TypeError("unexpected argument '{0}'".format(key)) - for key, value in kargs.items(): - setattr(rc, key, value) +class RC: + """Runtime configuration options.""" + def __init__(self): -rc.aposmm_optimizers = None -__import__("sys").modules[__name__ + ".rc"] = rc + self._opt_modules = None # optional string or list of strings + self._csv_path: str = __file__.replace("__init__.py", ".opt_modules.csv") + self._csv_exists: bool = os.path.isfile(self._csv_path) + + if self._csv_exists: + with open(self._csv_path) as f: + optreader = csv.reader(f) + self._opt_modules = [opt for opt in optreader][0] # should only be one row + + @property # getter + def aposmm_optimizers(self): + if self._opt_modules or not self._csv_exists: + return self._opt_modules + else: + with open(self._csv_path) as f: + optreader = csv.reader(f) + return [opt for opt in optreader][0] + + @aposmm_optimizers.setter + def aposmm_optimizers(self, values): + + current_opt = self.aposmm_optimizers + if not isinstance(values, list): + values = [values] + + if self._csv_exists and values != current_opt: # avoid rewriting constantly + with open(self._csv_path, "w") as f: + optwriter = csv.writer(f) + optwriter.writerow(values) + + self._opt_modules = values + + +rc = RC() diff --git a/libensemble/gen_funcs/aposmm_localopt_support.py b/libensemble/gen_funcs/aposmm_localopt_support.py index 06fa7b15e1..ef59347589 100644 --- a/libensemble/gen_funcs/aposmm_localopt_support.py +++ b/libensemble/gen_funcs/aposmm_localopt_support.py @@ -24,7 +24,7 @@ optimizers = [optimizers] unrec = set(optimizers) - set(optimizer_list) if unrec: - print('APOSMM Warning: unrecognized optimizers {}'.format(unrec)) + print(f'APOSMM Warning: unrecognized optimizers {unrec}') if 'petsc' in optimizers: from petsc4py import PETSc @@ -248,7 +248,6 @@ def run_local_scipy_opt(user_specs, comm_queue, x0, f0, child_can_read, parent_c Runs a SciPy local optimization run starting at ``x0``, governed by the parameters in ``user_specs``. """ - # Construct the bounds in the form of constraints cons = [] for factor in range(len(x0)): @@ -305,7 +304,7 @@ def run_external_localopt(user_specs, comm_queue, x0, f0, child_can_read, parent # cmd = ["matlab", "-nodisplay", "-nodesktop", "-nojvm", "-nosplash", "-r", cmd = ["octave", "--no-window-system", "--eval", - "x0=[" + " ".join(["{:18.18f}".format(x) for x in x0]) + "];" + "x0=[" + " ".join([f"{x:18.18f}" for x in x0]) + "];" "opt_file='" + opt_file + "';" "x_file='" + x_file + "';" "y_file='" + y_file + "';" @@ -339,7 +338,6 @@ def run_local_dfols(user_specs, comm_queue, x0, f0, child_can_read, parent_can_r Runs a DFOLS local optimization run starting at ``x0``, governed by the parameters in ``user_specs``. """ - # Define bound constraints (lower <= x <= upper) lb = np.zeros(len(x0)) ub = np.ones(len(x0)) @@ -377,7 +375,6 @@ def run_local_tao(user_specs, comm_queue, x0, f0, child_can_read, parent_can_rea Runs a PETSc/TAO local optimization run starting at ``x0``, governed by the parameters in ``user_specs``. """ - assert isinstance(x0, np.ndarray) tao_comm = PETSc.COMM_SELF diff --git a/libensemble/gen_funcs/old_aposmm.py b/libensemble/gen_funcs/old_aposmm.py index 6c93af2d7f..2720611755 100644 --- a/libensemble/gen_funcs/old_aposmm.py +++ b/libensemble/gen_funcs/old_aposmm.py @@ -27,7 +27,7 @@ optimizers = [optimizers] unrec = set(optimizers) - set(optimizer_list) if unrec: - print('APOSMM Warning: unrecognized optimizers {}'.format(unrec)) + print(f'APOSMM Warning: unrecognized optimizers {unrec}') if 'petsc' in optimizers: from petsc4py import PETSc @@ -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: @@ -961,7 +960,7 @@ def display_exception(e): traceback.print_tb(tb) # Fixed format tb_info = traceback.extract_tb(tb) filename, line, func, text = tb_info[-1] - print('An error occurred on line {} of function {} with statement {}'.format(line, func, text), flush=True) + print(f'An error occurred on line {line} of function {func} with statement {text}', flush=True) # PETSc/TAO errors are printed in the following manner: if hasattr(e, '_traceback_'): diff --git a/libensemble/gen_funcs/persistent_aposmm.py b/libensemble/gen_funcs/persistent_aposmm.py index b82f61ce10..74b9d3f9e3 100644 --- a/libensemble/gen_funcs/persistent_aposmm.py +++ b/libensemble/gen_funcs/persistent_aposmm.py @@ -17,8 +17,6 @@ from libensemble.message_numbers import STOP_TAG, PERSIS_STOP, FINISHED_PERSISTENT_GEN_TAG, EVAL_GEN_TAG from libensemble.tools.persistent_support import PersistentSupport -import multiprocessing - def aposmm(H, persis_info, gen_specs, libE_info): """ @@ -143,11 +141,6 @@ def aposmm(H, persis_info, gen_specs, libE_info): """ try: - - if multiprocessing.get_start_method() != "fork": - print("[APOSMM]: Detected multiprocessing start method is currently known to cause slowdowns. This will be fixed in a future release.") - print("[APOSMM]: Set the multiprocessing start method to 'fork' in your calling script to resolve in the meantime.") - user_specs = gen_specs['user'] ps = PersistentSupport(libE_info, EVAL_GEN_TAG) n, n_s, rk_const, ld, mu, nu, comm, local_H = initialize_APOSMM(H, user_specs, libE_info) @@ -427,10 +420,10 @@ def update_history_optimal(x_opt, opt_flag, H, run_inds): failsafe = np.logical_and(H['f'][run_inds] < H['f'][opt_ind], dists < tol_x2) if opt_flag: if np.any(failsafe): - print("[APOSMM] This run has {} point(s) with smaller 'f' value within {} of " + print(f"[APOSMM] This run has {sum(failsafe)} point(s) with smaller 'f' value within {tol_x2} of " "the point ruled to be the run minimum. \nMarking all as being " "a 'local_min' to prevent APOSMM from starting another run " - "immediately from these points.".format(sum(failsafe), tol_x2)) + "immediately from these points.") print("[APOSMM] Sim_ids to be marked optimal: ", opt_ind, run_inds[failsafe]) print("[APOSMM] Check that the local optimizer is working correctly", flush=True) H['local_min'][run_inds[failsafe]] = 1 @@ -567,7 +560,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: @@ -667,7 +659,7 @@ def initialize_children(user_specs): elif user_specs['localopt_method'] in ['pounders', 'dfols']: fields_to_pass = ['x_on_cube', 'fvec'] else: - raise NotImplementedError("Unknown local optimization method " "'{}'.".format(user_specs['localopt_method'])) + raise NotImplementedError(f"Unknown local optimization method {user_specs['localopt_method']}.") return local_opters, sim_id_to_child_inds, run_order, run_pts, total_runs, fields_to_pass diff --git a/libensemble/gen_funcs/persistent_ax_multitask.py b/libensemble/gen_funcs/persistent_ax_multitask.py index 90a218ccbe..99479c4a93 100644 --- a/libensemble/gen_funcs/persistent_ax_multitask.py +++ b/libensemble/gen_funcs/persistent_ax_multitask.py @@ -59,7 +59,7 @@ def persistent_gp_mt_ax_gen_f(H, persis_info, gen_specs, libE_info): for i, (ub, lb) in enumerate(zip(ub_list, lb_list)): parameters.append( RangeParameter( - name="x{}".format(i), + name=f"x{i}", parameter_type=ParameterType.FLOAT, lower=float(lb), upper=float(ub), @@ -210,7 +210,7 @@ def run(self, trial): n_param = len(params) param_array = np.zeros(n_param) for j in range(n_param): - param_array[j] = params["x{}".format(j)] + param_array[j] = params[f"x{j}"] H_o["x"][i] = param_array H_o["resource_sets"][i] = 1 H_o["task"][i] = task diff --git a/libensemble/gen_funcs/persistent_fd_param_finder.py b/libensemble/gen_funcs/persistent_fd_param_finder.py index 405578574e..87423b6f15 100644 --- a/libensemble/gen_funcs/persistent_fd_param_finder.py +++ b/libensemble/gen_funcs/persistent_fd_param_finder.py @@ -101,7 +101,7 @@ def fd_param_finder(H, persis_info, gen_specs, libE_info): "octave", "--no-window-system", "--eval", - "F=[" + " ".join(["{:18.18f}".format(x) for x in Fhist0[i, j, : nf + 1]]) + "];" + "F=[" + " ".join([f"{x:18.18f}" for x in Fhist0[i, j, : nf + 1]]) + "];" "nf=" + str(nf) + "';" "[fnoise, ~, inform] = ECnoise(nf+1, F);" "dlmwrite('fnoise.out', fnoise, 'delimiter', ' ', 'precision', 16);" diff --git a/libensemble/gen_funcs/persistent_independent_optimize.py b/libensemble/gen_funcs/persistent_independent_optimize.py index cef4d25cfb..a3e4c76dda 100644 --- a/libensemble/gen_funcs/persistent_independent_optimize.py +++ b/libensemble/gen_funcs/persistent_independent_optimize.py @@ -48,7 +48,7 @@ def _df(x): print_final_score(res.x, f_i_idxs, gen_specs, libE_info) start_pt, end_pt = f_i_idxs[0], f_i_idxs[-1] - print("[Worker {}]: x={}".format(persis_info["worker_num"], res.x[2 * start_pt : 2 * end_pt]), flush=True) + print(f"[Worker {persis_info['worker_num']}]: x={res.x[2 * start_pt:2 * end_pt]}", flush=True) """ try: res = sciopt.minimize(_f, x0, jac=_df, method="BFGS", tol=eps, diff --git a/libensemble/gen_funcs/persistent_n_agent.py b/libensemble/gen_funcs/persistent_n_agent.py index fe97ef1f01..d0ac923562 100644 --- a/libensemble/gen_funcs/persistent_n_agent.py +++ b/libensemble/gen_funcs/persistent_n_agent.py @@ -45,7 +45,7 @@ def n_agent(H, persis_info, gen_specs, libE_info): prev_gradf_is = np.zeros((len(A_i_data), n), dtype=float) if local_gen_id == 1: - print("[{}%]: ".format(0), flush=True, end="") + print(f"[{0}%]: ", flush=True, end="") print_final_score(x_k, f_i_idxs, gen_specs, libE_info) percent = 0.1 @@ -81,7 +81,7 @@ def n_agent(H, persis_info, gen_specs, libE_info): if (k + 1) / N >= percent: if local_gen_id == 1: - print("[{}%]: ".format(int(percent * 100)), flush=True, end="") + print(f"[{int(percent * 100)}%]: ", flush=True, end="") percent += 0.1 print_final_score(x_k, f_i_idxs, gen_specs, libE_info) diff --git a/libensemble/gen_funcs/persistent_pds.py b/libensemble/gen_funcs/persistent_pds.py index 8184e48c97..7870c70299 100644 --- a/libensemble/gen_funcs/persistent_pds.py +++ b/libensemble/gen_funcs/persistent_pds.py @@ -63,7 +63,7 @@ def opt_slide(H, persis_info, gen_specs, libE_info): prev_T_k = 0 if local_gen_id == 1: - print("[{}%]: ".format(0), flush=True, end="") + print(f"[{0}%]: ", flush=True, end="") print_final_score(prev_x_k, f_i_idxs, gen_specs, libE_info) percent = 0.1 @@ -118,7 +118,7 @@ def opt_slide(H, persis_info, gen_specs, libE_info): if k / N >= percent: curr_x_star = 1.0 / b_k_sum * weighted_x_hk_sum if local_gen_id == 1: - print("[{}%]: ".format(int(percent * 100)), flush=True, end="") + print(f"[{int(percent * 100)}%]: ", flush=True, end="") percent += 0.1 print_final_score(curr_x_star, f_i_idxs, gen_specs, libE_info) diff --git a/libensemble/gen_funcs/persistent_prox_slide.py b/libensemble/gen_funcs/persistent_prox_slide.py index ad95eee526..decb53c8dc 100644 --- a/libensemble/gen_funcs/persistent_prox_slide.py +++ b/libensemble/gen_funcs/persistent_prox_slide.py @@ -45,7 +45,7 @@ def opt_slide(H, persis_info, gen_specs, libE_info): N = N_const * int(((L * D) / (nu * eps)) ** 0.5 + 1) if local_gen_id == 1: - print("[{}%]: ".format(0), flush=True, end="") + print(f"[{0}%]: ", flush=True, end="") print_final_score(x_k, f_i_idxs, gen_specs, libE_info) percent = 0.1 @@ -72,7 +72,7 @@ def opt_slide(H, persis_info, gen_specs, libE_info): if k / N >= percent: if local_gen_id == 1: - print("[{}%]: ".format(int(percent * 100)), flush=True, end="") + print(f"[{int(percent * 100)}%]: ", flush=True, end="") percent += 0.1 print_final_score(post_x_k, f_i_idxs, gen_specs, libE_info) diff --git a/libensemble/gen_funcs/persistent_sampling.py b/libensemble/gen_funcs/persistent_sampling.py index 2bfabc1bcd..8c6f52bc49 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", ] @@ -79,7 +81,7 @@ def uniform_random_sample_with_variable_resources(H, persis_info, gen_specs, lib H_o["x"] = persis_info["rand_stream"].uniform(lb, ub, (b, n)) H_o["resource_sets"] = persis_info["rand_stream"].integers(1, gen_specs["user"]["max_resource_sets"] + 1, b) H_o["priority"] = 10 * H_o["resource_sets"] - print("Created {} sims, with worker_teams req. of size(s) {}".format(b, H_o["resource_sets"]), flush=True) + print(f"Created {b} sims, with worker_teams req. of size(s) {H_o['resource_sets']}", flush=True) tag, Work, calc_in = ps.send_recv(H_o) if calc_in is not None: @@ -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..751f8df7d9 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): @@ -242,7 +238,7 @@ def surmise_calib(H, persis_info, gen_specs, libE_info): # Determine evaluations to cancel c_obviate = info["obviatesugg"] if len(c_obviate) > 0: - print("columns sent for cancel is: {}".format(c_obviate), flush=True) + print(f"columns sent for cancel is: {c_obviate}", flush=True) cancel_columns(obs_offset, c_obviate, n_x, pending, ps) pending[:, c_obviate] = False diff --git a/libensemble/gen_funcs/persistent_tasmanian.py b/libensemble/gen_funcs/persistent_tasmanian.py index cf229df5b5..25d6ccc36d 100644 --- a/libensemble/gen_funcs/persistent_tasmanian.py +++ b/libensemble/gen_funcs/persistent_tasmanian.py @@ -159,7 +159,7 @@ def sparse_grid_batched(H, persis_info, gen_specs, libE_info): ] assert ( "refinement" in U and U["refinement"] in allowed_refinements - ), "Must provide a gen_specs['user']['refinement'] in: {}".format(allowed_refinements) + ), f"Must provide a gen_specs['user']['refinement'] in: {allowed_refinements}" while grid.getNumNeeded() > 0: aPoints = grid.getNeededPoints() @@ -210,7 +210,7 @@ def sparse_grid_async(H, persis_info, gen_specs, libE_info): allowed_refinements = ["getCandidateConstructionPoints", "getCandidateConstructionPointsSurplus"] assert ( "refinement" in U and U["refinement"] in allowed_refinements - ), "Must provide a gen_specs['user']['refinement'] in: {}".format(allowed_refinements) + ), f"Must provide a gen_specs['user']['refinement'] in: {allowed_refinements}" tol = U["_match_tolerance"] if "_match_tolerance" in U else 1.0e-12 # Choose the refinement function based on U['refinement']. 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..e11eeca35b 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") @@ -270,7 +270,7 @@ def libE(sim_specs, gen_specs, exit_criteria, persis_info=None, alloc_specs=None comms_type = libE_specs.get("comms") - assert comms_type in libE_funcs, "Unknown comms type: {}".format(comms_type) + assert comms_type in libE_funcs, f"Unknown comms type: {comms_type}" # Resource management not supported with TCP if comms_type == "tcp": @@ -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__)) + logger.info(f"libE version v{__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) @@ -311,7 +311,7 @@ def manager( persis_info, exit_flag, elapsed_time = manager_main( hist, libE_specs, alloc_specs, sim_specs, gen_specs, exit_criteria, persis_info, wcomms ) - logger.info("Manager total time: {}".format(elapsed_time)) + logger.info(f"Manager total time: {elapsed_time}") except LoggedException: # Exception already logged in manager raise @@ -330,8 +330,8 @@ def manager( raise LoggedException(*e.args, "See error details above and in ensemble.log") from None else: logger.debug("Manager exiting") - logger.debug("Exiting with {} workers.".format(len(wcomms))) - logger.debug("Exiting with exit criteria: {}".format(exit_criteria)) + logger.debug(f"Exiting with {len(wcomms)} workers.") + logger.debug(f"Exiting with exit criteria: {exit_criteria}") finally: if on_cleanup is not None: on_cleanup() @@ -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,12 +452,11 @@ 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) worker_main(comm, sim_specs, gen_specs, libE_specs, log_comm=True) - logger.debug("Worker {} exiting".format(libE_comm.Get_rank())) + logger.debug(f"Worker {libE_comm.Get_rank()} exiting") # ==================== Local version =============================== @@ -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) @@ -549,17 +543,16 @@ def get_ip(): def libE_tcp_authkey(): """Generate an authkey if not assigned by manager.""" nonce = random.randrange(99999) - return "libE_auth_{}".format(nonce) + return f"libE_auth_{nonce}" def libE_tcp_default_ID(): """Assign a (we hope unique) worker ID if not assigned by manager.""" - return "{}_pid{}".format(get_ip(), os.getpid()) + return f"{get_ip()}_pid{os.getpid()}" 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 @@ -598,21 +591,20 @@ def libE_tcp_start_team(manager, nworkers, workers, ip, port, authkey, launchf): specs = {"manager_ip": ip, "manager_port": port, "authkey": authkey} with Timer() as timer: for w in range(1, nworkers + 1): - logger.info("Manager is launching worker {}".format(w)) + logger.info(f"Manager is launching worker {w}") if workers is not None: specs["worker_ip"] = workers[w - 1] specs["tunnel_port"] = 0x71BE specs["workerID"] = w worker_procs.append(launchf(specs)) - logger.info("Manager is awaiting {} workers".format(nworkers)) + logger.info(f"Manager is awaiting {nworkers} workers") wcomms = manager.await_workers(nworkers) - logger.info("Manager connected to {} workers ({} s)".format(nworkers, timer.elapsed)) + logger.info(f"Manager connected to {nworkers} workers ({timer.elapsed} s)") return worker_procs, wcomms 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 @@ -640,7 +632,7 @@ def libE_tcp_mgr(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, else: exit_logger = None - logger.info("Launched server at ({}, {})".format(ip, port)) + logger.info(f"Launched server at ({ip}, {port})") # Launch worker team and set up logger worker_procs, wcomms = libE_tcp_start_team(tcp_manager, nworkers, workers, ip, port, authkey, launchf) @@ -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"] @@ -668,7 +659,7 @@ def libE_tcp_worker(sim_specs, gen_specs, libE_specs): with ClientQCommManager(ip, port, authkey, workerID) as comm: worker_main(comm, sim_specs, gen_specs, libE_specs, workerID=workerID, log_comm=True) - logger.debug("Worker {} exiting".format(workerID)) + logger.debug(f"Worker {workerID} exiting") # ==================== Additional Internal Functions =========================== @@ -677,7 +668,7 @@ def libE_tcp_worker(sim_specs, gen_specs, libE_specs): def _dump_on_abort(hist, persis_info, save_H=True): """Dump history and persis_info on abort""" logger.error("Manager exception raised .. aborting ensemble:") - logger.error("Dumping ensemble history with {} sims evaluated:".format(hist.sim_ended_count)) + logger.error(f"Dumping ensemble history with {hist.sim_ended_count} sims evaluated:") if save_H: np.save("libE_history_at_abort_" + str(hist.sim_ended_count) + ".npy", hist.trim_H()) diff --git a/libensemble/manager.py b/libensemble/manager.py index 6cd5d1d853..179aa99f46 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, @@ -62,8 +64,8 @@ def report_worker_exc(wrk_exc=None): """Write worker exception to log""" if wrk_exc is not None: from_line, msg, exc = wrk_exc.args - logger.error("---- {} ----".format(from_line)) - logger.error("Message: {}".format(msg)) + logger.error(f"---- {from_line} ----") + logger.error(f"Message: {msg}") logger.error(exc) @@ -234,7 +236,7 @@ def term_test(self, logged=True): if key in self.exit_criteria: if testf(self.exit_criteria[key]): if logged: - logger.info("Term test tripped: {}".format(key)) + logger.info(f"Term test tripped: {key}") return retval return 0 @@ -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) @@ -280,7 +284,7 @@ def _check_work_order(self, Work, w): if self.W[w - 1]["active_recv"]: assert "active_recv" in Work["libE_info"], ( "Messages to a worker in active_recv mode should have active_recv" - "set to True in libE_info. Work['libE_info'] is {}".format(Work["libE_info"]) + f"set to True in libE_info. Work['libE_info'] is {Work['libE_info']}" ) else: assert self.W[w - 1]["active"] == 0, ( @@ -291,15 +295,13 @@ def _check_work_order(self, Work, w): work_fields = set(Work["H_fields"]) assert len(work_fields), ( - "Allocation function requested rows={} be sent to worker={}, " - "but requested no fields to be sent.".format(work_rows, w) + f"Allocation function requested rows={work_rows} be sent to worker={w}, " + "but requested no fields to be sent." ) hist_fields = self.hist.H.dtype.names diff_fields = list(work_fields.difference(hist_fields)) - assert not diff_fields, "Allocation function requested invalid fields {} be sent to worker={}.".format( - diff_fields, w - ) + assert not diff_fields, f"Allocation function requested invalid fields {diff_fields} be sent to worker={w}." def _set_resources(self, Work, w): """Check rsets given in Work match rsets assigned in resources. @@ -320,14 +322,12 @@ 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)) + logger.debug(f"Manager sending work unit to worker {w}") if self.resources: self._set_resources(Work, w) @@ -339,11 +339,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 - ) - ) + logger.debug(f"Manager sending {work_name} work to worker {w}. Rows {extract_H_ranges(Work) or None}") if len(work_rows): if "repack_fields" in globals(): new_dtype = [(name, self.hist.H.dtype.fields[name][0]) for name in Work["H_fields"]] @@ -357,7 +353,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"]: @@ -383,11 +378,11 @@ def _check_received_calc(D_recv): assert calc_type in [ EVAL_SIM_TAG, EVAL_GEN_TAG, - ], "Aborting, Unknown calculation type received. Received type: {}".format(calc_type) + ], f"Aborting, Unknown calculation type received. Received type: {calc_type}" assert calc_status in list(calc_status_strings.keys()) + [PERSIS_STOP] or isinstance( calc_status, str - ), "Aborting: Unknown calculation status received. Received status: {}".format(calc_status) + ), f"Aborting: Unknown calculation status received. Received status: {calc_status}" def _receive_from_workers(self, persis_info): """Receives calculation output from workers. Loops over all @@ -415,7 +410,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]: @@ -458,20 +454,20 @@ def _handle_msg_from_worker(self, persis_info, w): msg = self.wcomms[w - 1].recv() tag, D_recv = msg except CommFinishedException: - logger.debug("Finalizing message from Worker {}".format(w)) + logger.debug(f"Finalizing message from Worker {w}") return if isinstance(D_recv, WorkerErrMsg): self.W[w - 1]["active"] = 0 - logger.debug("Manager received exception from worker {}".format(w)) + logger.debug(f"Manager received exception from worker {w}") if not self.WorkerExc: self.WorkerExc = True self._kill_workers() - raise WorkerException("Received error message from worker {}".format(w), D_recv.msg, D_recv.exc) + raise WorkerException(f"Received error message from worker {w}", D_recv.msg, D_recv.exc) elif isinstance(D_recv, logging.LogRecord): - logger.debug("Manager received a log message from worker {}".format(w)) + logger.debug(f"Manager received a log message from worker {w}") logging.getLogger(D_recv.name).handle(D_recv) else: - logger.debug("Manager received data message from worker {}".format(w)) + logger.debug(f"Manager received data message from worker {w}") self._update_state_on_worker_msg(persis_info, D_recv, w) def _kill_cancelled_sims(self): @@ -486,7 +482,7 @@ def _kill_cancelled_sims(self): # Note that a return is still expected when running sims are killed if np.any(kill_sim): - logger.debug("Manager sending kill signals to H indices {}".format(np.where(kill_sim))) + logger.debug(f"Manager sending kill signals to H indices {np.where(kill_sim)}") kill_ids = self.hist.H["sim_id"][kill_sim] kill_on_workers = self.hist.H["sim_worker"][kill_sim] for w in kill_on_workers: @@ -507,7 +503,7 @@ def _final_receive_and_kill(self, persis_info): # Send a handshake signal to each persistent worker. if any(self.W["persis_state"]): for w in self.W["worker_id"][self.W["persis_state"] > 0]: - logger.debug("Manager sending PERSIS_STOP to worker {}".format(w)) + logger.debug(f"Manager sending PERSIS_STOP to worker {w}") if "final_fields" in self.libE_specs: rows_to_send = self.hist.trim_H()["sim_ended"] fields_to_send = self.libE_specs["final_fields"] @@ -547,7 +543,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, @@ -598,8 +593,8 @@ def _alloc_work(self, H, persis_info): def run(self, persis_info): """Runs the manager""" - logger.info("Manager initiated on node {}".format(socket.gethostname())) - logger.info("Manager exit_criteria: {}".format(self.exit_criteria)) + logger.info(f"Manager initiated on node {socket.gethostname()}") + logger.info(f"Manager exit_criteria: {self.exit_criteria}") # Continue receiving and giving until termination test is satisfied try: 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..fcad9937bb 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 @@ -159,7 +139,7 @@ def _make_calc_dir(self, workerID, H_rows, calc_str, locs): # Otherwise, ensemble_dir set as parent dir for sim dirs else: - calc_dir = "{}{}_worker{}".format(calc_str, H_rows, workerID) + calc_dir = f"{calc_str}{H_rows}_worker{workerID}" if not os.path.isdir(self.prefix): os.makedirs(self.prefix, exist_ok=True) calc_prefix = self.prefix @@ -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/env_resources.py b/libensemble/resources/env_resources.py index 1185c6e02f..e8cddfb6be 100644 --- a/libensemble/resources/env_resources.py +++ b/libensemble/resources/env_resources.py @@ -98,7 +98,7 @@ def get_nodelist(self): if self.scheduler: env = self.scheduler env_var = self.nodelists[env] - logger.debug("{} env found - getting nodelist from {}".format(env, env_var)) + logger.debug(f"{env} env found - getting nodelist from {env_var}") get_list_func = self.ndlist_funcs[env] global_nodelist = get_list_func(env_var) return global_nodelist diff --git a/libensemble/resources/mpi_resources.py b/libensemble/resources/mpi_resources.py index 0abd7feb1b..7df46b154f 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) @@ -140,7 +148,7 @@ def get_resources(resources, num_procs=None, num_nodes=None, procs_per_node=None rassert( wresources.even_slots, - "Uneven distribution of node resources not yet supported. Nodes and slots are: {}".format(wresources.slots), + f"Uneven distribution of node resources not yet supported. Nodes and slots are: {wresources.slots}", ) if not num_procs and not procs_per_node: @@ -156,7 +164,7 @@ def get_resources(resources, num_procs=None, num_nodes=None, procs_per_node=None logger.debug( "No decomposition supplied - " "using all available resource. " - "Nodes: {} procs_per_node {}".format(num_nodes, procs_per_node) + f"Nodes: {num_nodes} procs_per_node {procs_per_node}" ) elif not num_nodes and not procs_per_node: if num_procs <= cores_avail_per_node_per_worker: @@ -171,32 +179,32 @@ def get_resources(resources, num_procs=None, num_nodes=None, procs_per_node=None rassert( num_nodes <= local_node_count, - "Not enough nodes to honor arguments. " "Requested {}. Only {} available".format(num_nodes, local_node_count), + "Not enough nodes to honor arguments. " f"Requested {num_nodes}. Only {local_node_count} available", ) if gresources.enforce_worker_core_bounds: rassert( procs_per_node <= cores_avail_per_node, "Not enough processors on a node to honor arguments. " - "Requested {}. Only {} available".format(procs_per_node, cores_avail_per_node), + f"Requested {procs_per_node}. Only {cores_avail_per_node} available", ) rassert( procs_per_node <= cores_avail_per_node_per_worker, "Not enough processors per worker to honor arguments. " - "Requested {}. Only {} available".format(procs_per_node, cores_avail_per_node_per_worker), + f"Requested {procs_per_node}. Only {cores_avail_per_node_per_worker} available", ) rassert( num_procs <= (cores_avail_per_node * local_node_count), "Not enough procs to honor arguments. " - "Requested {}. Only {} available".format(num_procs, cores_avail_per_node * local_node_count), + f"Requested {num_procs}. Only {cores_avail_per_node * local_node_count} available", ) if num_nodes < local_node_count: logger.warning( "User constraints mean fewer nodes being used " - "than available. {} nodes used. {} nodes available".format(num_nodes, local_node_count) + f"than available. {num_nodes} nodes used. {local_node_count} nodes available" ) return num_procs, num_nodes, procs_per_node @@ -214,10 +222,10 @@ def create_machinefile( try: os.remove(machinefile) except Exception as e: - logger.warning("Could not remove existing machinefile: {}".format(e)) + logger.warning(f"Could not remove existing machinefile: {e}") node_list = resources.worker_resources.local_nodelist - logger.debug("Creating machinefile with {} nodes and {} ranks per node".format(num_nodes, procs_per_node)) + logger.debug(f"Creating machinefile with {num_nodes} nodes and {procs_per_node} ranks per node") with open(machinefile, "w") as f: for node in node_list[:num_nodes]: diff --git a/libensemble/resources/node_resources.py b/libensemble/resources/node_resources.py index b76a649b66..52fd886139 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 @@ -69,7 +68,7 @@ def _get_cpu_resources_from_env(env_resources=None): if found_count: # Check all nodes have equal cores - Not doing for other methods currently. if len(set(counter)) != 1: - logger.warning("Detected compute nodes have different core counts: {}".format(set(counter))) + logger.warning(f"Detected compute nodes have different core counts: {set(counter)}") physical_cores_avail_per_node = counter[0] logical_cores_avail_per_node = counter[0] # How to get SMT threads remotely 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/rset_resources.py b/libensemble/resources/rset_resources.py index 5a9919dba6..cbd924467e 100644 --- a/libensemble/resources/rset_resources.py +++ b/libensemble/resources/rset_resources.py @@ -100,9 +100,7 @@ def get_split_list(num_rsets, resources): num_nodes = len(global_nodelist) if not RSetResources.even_assignment(num_nodes, num_rsets): - logger.warning( - "Resource sets ({}) are not distributed evenly to available nodes ({})".format(num_rsets, num_nodes) - ) + logger.warning(f"Resource sets ({num_rsets}) are not distributed evenly to available nodes ({num_nodes})") # If multiple workers per node - create global node_list with N duplicates (for N workers per node) sub_node_workers = num_rsets >= num_nodes @@ -113,7 +111,7 @@ def get_split_list(num_rsets, resources): # Divide global list between workers split_list = list(RSetResources.best_split(global_nodelist, num_rsets)) - logger.debug("split_list is {}".format(split_list)) + logger.debug(f"split_list is {split_list}") return split_list, local_rsets_list @staticmethod diff --git a/libensemble/resources/scheduler.py b/libensemble/resources/scheduler.py index e27aff6159..82863d05ee 100644 --- a/libensemble/resources/scheduler.py +++ b/libensemble/resources/scheduler.py @@ -87,7 +87,7 @@ def assign_resources(self, rsets_req): if rsets_req > self.resources.total_num_rsets: raise InsufficientResourcesError( - "More resource sets requested {} than exist {}".format(rsets_req, self.resources.total_num_rsets) + f"More resource sets requested {rsets_req} than exist {self.resources.total_num_rsets}" ) if rsets_req > self.rsets_free: @@ -156,16 +156,13 @@ def assign_resources(self, rsets_req): logger.debug(self.log_msg) logger.debug( - "rset_team found: Req: {} rsets. Found: {} Avail sets {}".format( - rsets_req, rset_team, self.avail_rsets_by_group - ) + f"rset_team found: Req: {rsets_req} rsets. Found: {rset_team} Avail sets {self.avail_rsets_by_group}" ) return rset_team 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 @@ -285,9 +282,8 @@ def calc_rsets_even_grps(self, rsets_req, max_grpsize, max_groups, extend): rsets_req = num_groups_req * rsets_per_group self.log_msg = ( "Increasing resource requirement to obtain an even partition of resource sets\n" - "to nodes. rsets_req orig: {} New: {} num_groups_req {} rsets_per_group {}".format( - orig_rsets_req, rsets_req, num_groups_req, rsets_per_group - ) + f"to nodes. rsets_req orig: {orig_rsets_req} New: {rsets_req} " + f" num_groups_req {num_groups_req} rsets_per_group {rsets_per_group}" ) else: rsets_per_group = max_grpsize diff --git a/libensemble/resources/worker_resources.py b/libensemble/resources/worker_resources.py index bfc9f96403..3f53207d05 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): @@ -74,8 +73,7 @@ def assign_rsets(self, rset_team, worker_id): self.rsets_free -= 1 elif wid != worker_id: ResourceManagerException( - "Error: Attempting to assign rsets {}" - " already assigned to workers: {}".format(rset_team, rteam) + f"Error: Attempting to assign rsets {rset_team}" f" already assigned to workers: {rteam}" ) def free_rsets(self, worker=None): @@ -307,7 +305,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") @@ -316,7 +313,7 @@ def get_local_nodelist(workerID, rset_team, split_list, rsets_per_node): team_list += split_list[index] local_nodelist = list(OrderedDict.fromkeys(team_list)) # Maintain order of nodes - logger.debug("Worker's local_nodelist is {}".format(local_nodelist)) + logger.debug(f"Worker's local_nodelist is {local_nodelist}") slots = {} for node in local_nodelist: diff --git a/libensemble/sim_funcs/borehole_kills.py b/libensemble/sim_funcs/borehole_kills.py index 65a4bbdbd3..47c17b98fb 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(f"Failure of sim_id {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..d232ab6fcd 100644 --- a/libensemble/sim_funcs/executor_hworld.py +++ b/libensemble/sim_funcs/executor_hworld.py @@ -24,24 +24,22 @@ 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)) + print(f"Task {task.id} killed by manager on worker {exctr.workerID}") break task.poll() if task.finished: break elif task.state == "RUNNING": - print("Task {} still running on worker {} ....".format(task.id, exctr.workerID)) + print(f"Task {task.id} still running on worker {exctr.workerID} ....") if task.stdout_exists(): if "Error" in task.read_stdout(): print( - "Found (deliberate) Error in output file - cancelling " - "task {} on worker {}".format(task.id, exctr.workerID) + "Found (deliberate) Error in output file - cancelling " f"task {task.id} on worker {exctr.workerID}" ) exctr.kill(task) calc_status = WORKER_KILL_ON_ERR @@ -49,7 +47,7 @@ def custom_polling_loop(exctr, task, timeout_sec=5.0, delay=0.3): # After exiting loop if task.finished: - print("Task {} done on worker {}".format(task.id, exctr.workerID)) + print(f"Task {task.id} done on worker {exctr.workerID}") # Fill in calc_status if not already if calc_status == UNSET_TAG: if task.state == "FINISHED": # Means finished successfully @@ -59,10 +57,10 @@ def custom_polling_loop(exctr, task, timeout_sec=5.0, delay=0.3): else: # assert task.state == 'RUNNING', "task.state expected to be RUNNING. Returned: " + str(task.state) - print("Task {} timed out - killing on worker {}".format(task.id, exctr.workerID)) + print(f"Task {task.id} timed out - killing on worker {exctr.workerID}") exctr.kill(task) if task.finished: - print("Task {} done on worker {}".format(task.id, exctr.workerID)) + print(f"Task {task.id} done on worker {exctr.workerID}") calc_status = WORKER_KILL_ON_TIMEOUT return task, calc_status @@ -77,101 +75,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/linear_regression.py b/libensemble/sim_funcs/linear_regression.py index 4073a74623..3d6b9aafcd 100644 --- a/libensemble/sim_funcs/linear_regression.py +++ b/libensemble/sim_funcs/linear_regression.py @@ -55,7 +55,7 @@ def linear_regression_eval(H, persis_info, sim_specs, _): c = persis_info["params"]["c"] reg = persis_info["params"].get("reg", None) - assert (reg is None) or (reg == "l1") or (reg == "l2"), "Incompatible regularization {}".format(reg) + assert (reg is None) or (reg == "l1") or (reg == "l2"), f"Incompatible regularization {reg}" batch = len(H["x"]) H_o = np.zeros(batch, dtype=sim_specs["out"]) diff --git a/libensemble/sim_funcs/logistic_regression.py b/libensemble/sim_funcs/logistic_regression.py index baa9dc9a73..7966a9c9c6 100644 --- a/libensemble/sim_funcs/logistic_regression.py +++ b/libensemble/sim_funcs/logistic_regression.py @@ -57,7 +57,7 @@ def logistic_regression_eval(H, persis_info, sim_specs, _): c = persis_info["params"]["c"] reg = persis_info["params"].get("reg", None) - assert (reg is None) or (reg == "l1") or (reg == "l2"), "Incompatible regularization {}".format(reg) + assert (reg is None) or (reg == "l1") or (reg == "l2"), f"Incompatible regularization {reg}" batch = len(H["x"]) H_o = np.zeros(batch, dtype=sim_specs["out"]) 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/sim_funcs/run_line_check.py b/libensemble/sim_funcs/run_line_check.py index c08abfbe9e..d5db07411a 100644 --- a/libensemble/sim_funcs/run_line_check.py +++ b/libensemble/sim_funcs/run_line_check.py @@ -60,7 +60,7 @@ def runline_check(H, persis_info, sim_specs, libE_info): new_exp_list = exp_nodelist_for_worker(exp_list[i], libE_info["workerID"], npw, p_gens) if outline != new_exp_list: - print("outline is: {}\nexp is: {}".format(outline, new_exp_list), flush=True) + print(f"outline is: {outline}\nexp is: {new_exp_list}", flush=True) assert outline == new_exp_list @@ -108,7 +108,7 @@ def runline_check_by_worker(H, persis_info, sim_specs, libE_info): new_exp_list = exp_list[wid_mod - 1 - p_gens] if outline != new_exp_list: - print("Worker {}:\n outline is: {}\n exp is: {}".format(wid, outline, new_exp_list), flush=True) + print(f"Worker {wid}:\n outline is: {outline}\n exp is: {new_exp_list}", flush=True) assert outline == new_exp_list diff --git a/libensemble/sim_funcs/six_hump_camel.py b/libensemble/sim_funcs/six_hump_camel.py index 09cac1fe6e..769eac6f15 100644 --- a/libensemble/sim_funcs/six_hump_camel.py +++ b/libensemble/sim_funcs/six_hump_camel.py @@ -142,18 +142,15 @@ def six_hump_camel_CUDA_variable_resources(H, persis_info, sim_specs, libE_info) resources = Resources.resources.worker_resources slots = resources.slots - assert resources.matching_slots, "Error: Cannot set CUDA_VISIBLE_DEVICES when unmatching slots on nodes {}".format( - slots - ) + assert resources.matching_slots, f"Error: Cannot set CUDA_VISIBLE_DEVICES when unmatching slots on nodes {slots}" resources.set_env_to_slots("CUDA_VISIBLE_DEVICES") num_nodes = resources.local_node_count cores_per_node = resources.slot_count # One CPU per GPU print( - "Worker {}: CUDA_VISIBLE_DEVICES={} \tnodes {} ppn {} slots {}".format( - libE_info["workerID"], os.environ["CUDA_VISIBLE_DEVICES"], num_nodes, cores_per_node, slots - ) + f"Worker {libE_info['workerID']}: CUDA_VISIBLE_DEVICES={os.environ['CUDA_VISIBLE_DEVICES']}" + f"\tnodes {num_nodes} ppn {cores_per_node} slots {slots}" ) # Create application input file diff --git a/libensemble/sim_funcs/svm.py b/libensemble/sim_funcs/svm.py index e44f64a07c..0e53495e78 100644 --- a/libensemble/sim_funcs/svm.py +++ b/libensemble/sim_funcs/svm.py @@ -62,7 +62,7 @@ def svm_eval(H, persis_info, sim_specs, _): c = persis_info["params"]["c"] reg = persis_info["params"].get("reg", None) - assert (reg is None) or (reg == "l1") or (reg == "l2"), "Incompatible regularization {}".format(reg) + assert (reg is None) or (reg == "l1") or (reg == "l2"), f"Incompatible regularization {reg}" batch = len(H["x"]) H_o = np.zeros(batch, dtype=sim_specs["out"]) 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..be387fbfae 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!) @@ -33,12 +32,12 @@ def add_app(name, exepath, desc): def run_cmd(cmd, echo=False): """Run a bash command""" if echo: - print("\nRunning %s ...\n" % cmd) + print(f"\nRunning {cmd} ...\n") try: subprocess.run(cmd.split(), check=True) except Exception as e: print(e) - raise ("Error: Command %s failed to run" % cmd) + raise (f"Error: Command {cmd} failed to run") # Use relative paths to balsam_tests dir diff --git a/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_1__runjobs.py b/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_1__runjobs.py index df1b732a4d..1feba45b53 100644 --- a/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_1__runjobs.py +++ b/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_1__runjobs.py @@ -13,7 +13,7 @@ def poll_until_state(job, state, timeout_sec=60.0, delay=2.0): job.refresh_from_db() if job.state == state: return True - raise RuntimeError("Task %s failed to reach state %s in %.1f seconds" % (job.cute_id, state, timeout_sec)) + raise RuntimeError(f"Task {job.cute_id} failed to reach state {state} in {timeout_sec:.1f} seconds") myrank = MPI.COMM_WORLD.Get_rank() @@ -32,7 +32,7 @@ def poll_until_state(job, state, timeout_sec=60.0, delay=2.0): os.mkdir(sim_path) except Exception as e: print(e) - raise ("Cannot make simulation directory %s" % sim_path) + raise (f"Cannot make simulation directory {sim_path}") MPI.COMM_WORLD.Barrier() # Ensure output dir created print("Host job rank is %d Output dir is %s" % (myrank, sim_input_dir)) diff --git a/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_2__workerkill.py b/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_2__workerkill.py index 71362aabde..34e2f966cc 100644 --- a/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_2__workerkill.py +++ b/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_2__workerkill.py @@ -15,7 +15,7 @@ def poll_until_state(job, state, timeout_sec=120.0, delay=2.0): return True elif job.state == "USER_KILLED": return False - raise RuntimeError("Task %s failed to reach state %s in %.1f seconds" % (job.cute_id, state, timeout_sec)) + raise RuntimeError(f"Task {job.cute_id} failed to reach state {state} in {timeout_sec:.1f} seconds") myrank = MPI.COMM_WORLD.Get_rank() @@ -34,7 +34,7 @@ def poll_until_state(job, state, timeout_sec=120.0, delay=2.0): os.mkdir(sim_path) except Exception as e: print(e) - raise ("Cannot make simulation directory %s" % sim_path) + raise (f"Cannot make simulation directory {sim_path}") MPI.COMM_WORLD.Barrier() # Ensure output dir created print("Host job rank is %d Output dir is %s" % (myrank, sim_input_dir)) diff --git a/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_3__managerkill.py b/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_3__managerkill.py index 0f8950e07a..e82f723119 100644 --- a/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_3__managerkill.py +++ b/libensemble/tests/deprecated_tests/balsam_tests/test_balsam_3__managerkill.py @@ -15,7 +15,7 @@ def poll_until_state(job, state, timeout_sec=120.0, delay=2.0): return True elif job.state == "USER_KILLED": return False - raise RuntimeError("Task %s failed to reach state %s in %.1f seconds" % (job.cute_id, state, timeout_sec)) + raise RuntimeError(f"Task {job.cute_id} failed to reach state {state} in {timeout_sec:.1f} seconds") myrank = MPI.COMM_WORLD.Get_rank() @@ -34,7 +34,7 @@ def poll_until_state(job, state, timeout_sec=120.0, delay=2.0): os.mkdir(sim_path) except Exception as e: print(e) - raise ("Cannot make simulation directory %s" % sim_path) + raise (f"Cannot make simulation directory {sim_path}") MPI.COMM_WORLD.Barrier() # Ensure output dir created print("Host job rank is %d Output dir is %s" % (myrank, sim_input_dir)) 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/deprecated_tests/standalone_executor_tests/test_executor_multi.py b/libensemble/tests/deprecated_tests/standalone_executor_tests/test_executor_multi.py index 4845010bf1..64cdab39ac 100644 --- a/libensemble/tests/deprecated_tests/standalone_executor_tests/test_executor_multi.py +++ b/libensemble/tests/deprecated_tests/standalone_executor_tests/test_executor_multi.py @@ -69,20 +69,20 @@ def polling_loop(exctr, task_list, timeout_sec=40.0, delay=1.0): for task in task_list: if not task.finished: time.sleep(delay) - print("Polling task {0} at time {1}".format(task.id, time.time() - start)) + print(f"Polling task {task.id} at time {time.time() - start}") task.poll() if task.finished: continue elif task.state == "WAITING": - print("Task {0} waiting to execute".format(task.id)) + print(f"Task {task.id} waiting to execute") elif task.state == "RUNNING": - print("Task {0} still running ....".format(task.id)) + print(f"Task {task.id} still running ....") # Check output file for error if task.stdout_exists(): if "Error" in task.read_stdout(): - print("Found (deliberate) Error in output file - " "cancelling task {}".format(task.id)) + print(f"Found (deliberate) Error in output file - cancelling task {task.id}") exctr.kill(task) time.sleep(delay) # Give time for kill continue @@ -99,21 +99,21 @@ def polling_loop(exctr, task_list, timeout_sec=40.0, delay=1.0): for task in task_list: if task.finished: if task.state == "FINISHED": - print("Task {0} finished successfully. Status: {1}".format(task.id, task.state)) + print(f"Task {task.id} finished successfully. Status: {task.state}") elif task.state == "FAILED": - print("Task {0} failed. Status: {1}".format(task.id, task.state)) + print(f"Task {task.id} failed. Status: {task.state}") elif task.state == "USER_KILLED": - print("Task {0} has been killed. Status: {1}".format(task.id, task.state)) + print(f"Task {task.id} has been killed. Status: {task.state}") else: - print("Task {0} status: {1}".format(task.id, task.state)) + print(f"Task {task.id} status: {task.state}") else: - print("Task {0} timed out. Status: {1}".format(task.id, task.state)) + print(f"Task {task.id} timed out. Status: {task.state}") exctr.kill(task) if task.finished: - print("Task {0} Now killed. Status: {1}".format(task.id, task.state)) + print(f"Task {task.id} Now killed. Status: {task.state}") # double check task.poll() - print("Task {0} state is {1}".format(task.id, task.state)) + print(f"Task {task.id} state is {task.state}") # Tests diff --git a/libensemble/tests/deprecated_tests/test_old_aposmm_with_gradients.py b/libensemble/tests/deprecated_tests/test_old_aposmm_with_gradients.py index 0f855c7e5f..f62fbae4a6 100644 --- a/libensemble/tests/deprecated_tests/test_old_aposmm_with_gradients.py +++ b/libensemble/tests/deprecated_tests/test_old_aposmm_with_gradients.py @@ -123,7 +123,7 @@ def libE_mpi_abort(): if is_manager: if flag != 0: - print("Exit was not on convergence (code {})".format(flag), flush=True) + print(f"Exit was not on convergence (code {flag})", flush=True) libE_abort() tol = 1e-5 diff --git a/libensemble/tests/regression_tests/check_libE_stats.py b/libensemble/tests/functionality_tests/check_libE_stats.py similarity index 89% rename from libensemble/tests/regression_tests/check_libE_stats.py rename to libensemble/tests/functionality_tests/check_libE_stats.py index 1ec8b3a36b..8e4e9c0cc3 100644 --- a/libensemble/tests/regression_tests/check_libE_stats.py +++ b/libensemble/tests/functionality_tests/check_libE_stats.py @@ -31,7 +31,7 @@ def check_datetime(t1, t2): dt = t1 + " " + t2 else: dt = t1 - assert is_date(dt), "Expected a datetime, found {}".format(dt) + assert is_date(dt), f"Expected a datetime, found {dt}" def check_start_end_times(start="Start:", end="End:", everyline=True): @@ -58,9 +58,9 @@ def check_start_end_times(start="Start:", end="End:", everyline=True): e_cnt += 1 if everyline: assert s_cnt > 0, "Expected timings not found" - assert s_cnt == e_cnt, "Start/end count different {} {}".format(s_cnt, e_cnt) + assert s_cnt == e_cnt, f"Start/end count different {s_cnt} {e_cnt}" total_cnt += s_cnt - assert total_cnt > 0, "No timings found starting {}".format(start) + assert total_cnt > 0, f"No timings found starting {start}" def check_libE_stats(task_datetime=False): 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_calc_exception.py b/libensemble/tests/functionality_tests/test_calc_exception.py index 675a832d5f..a232f20bd4 100644 --- a/libensemble/tests/functionality_tests/test_calc_exception.py +++ b/libensemble/tests/functionality_tests/test_calc_exception.py @@ -57,7 +57,7 @@ def six_hump_camel_err(H, persis_info, sim_specs, _): try: H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) except LoggedException as e: - print("Caught deliberate exception: {}".format(e)) + print(f"Caught deliberate exception: {e}") return_flag = 0 if is_manager: 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..a2c2287833 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__": @@ -52,7 +53,7 @@ mess_resources = "Resource manager enabled" if is_manager: - print("\nCores req: {} Cores avail: {}\n {}\n".format(cores_all_tasks, logical_cores, mess_resources)) + print(f"\nCores req: {cores_all_tasks} Cores avail: {logical_cores}\n {mess_resources}\n") sim_app = "./my_simtask.x" if not os.path.isfile(sim_app): @@ -99,8 +100,8 @@ calc_status_list = np.repeat(calc_status_list_in, nworkers) # For debug - print("Expecting: {}".format(calc_status_list)) - print("Received: {}\n".format(H["cstat"])) + print(f"Expecting: {calc_status_list}") + print("Received: {H['cstat']}\n") assert np.array_equal(H["cstat"], calc_status_list), "Error - unexpected calc status. Received: " + str( H["cstat"] diff --git a/libensemble/tests/functionality_tests/test_executor_hworld_timeout.py b/libensemble/tests/functionality_tests/test_executor_hworld_timeout.py index e953d23739..006c89e2a6 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__": @@ -50,7 +51,7 @@ mess_resources = "Resource manager enabled" if is_manager: - print("\nCores req: {} Cores avail: {}\n {}\n".format(cores_all_tasks, logical_cores, mess_resources)) + print(f"\nCores req: {cores_all_tasks} Cores avail: {logical_cores}\n {mess_resources}\n") sim_app = "./my_simtask.x" if not os.path.isfile(sim_app): @@ -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(f"Expecting: {calc_status_list}") + print(f"Received: {H['cstat']}\n") - 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..2115807908 --- /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(f"Expecting: {calc_status_list}") + print(f"Received: {H['cstat']}\n") + + 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_comms.py b/libensemble/tests/functionality_tests/test_mpi_comms.py index 5bb7a3cafa..bd837998db 100644 --- a/libensemble/tests/functionality_tests/test_mpi_comms.py +++ b/libensemble/tests/functionality_tests/test_mpi_comms.py @@ -24,7 +24,7 @@ def check_recv(comm, expected_msg): msg = comm.recv() - assert msg == expected_msg, "Expected {}, received {}".format(expected_msg, msg) + assert msg == expected_msg, f"Expected {expected_msg}, received {msg}" def worker_main(mpi_comm): "Worker main routine" @@ -66,7 +66,7 @@ def check_ranks(mpi_comm, test_exp, test_num): except Exception: rank = -1 comm_ranks_in_world = MPI.COMM_WORLD.allgather(rank) - print("got {}, exp {} ".format(comm_ranks_in_world, test_exp[test_num]), flush=True) + print(f"got {comm_ranks_in_world}, exp {test_exp[test_num]} ", flush=True) # This is really testing the test is testing what is it supposed to test assert comm_ranks_in_world == test_exp[test_num], ( "comm_ranks_in_world are: " + str(comm_ranks_in_world) + " Expected: " + str(test_exp[test_num]) diff --git a/libensemble/tests/functionality_tests/test_mpi_runners_subnode.py b/libensemble/tests/functionality_tests/test_mpi_runners_subnode.py index 59e1c9d380..c90a29591e 100644 --- a/libensemble/tests/functionality_tests/test_mpi_runners_subnode.py +++ b/libensemble/tests/functionality_tests/test_mpi_runners_subnode.py @@ -50,7 +50,7 @@ nsim_workers = nworkers if not (nsim_workers * nodes_per_worker).is_integer(): - sys.exit("Sim workers ({}) must divide evenly into nodes".format(nsim_workers)) + sys.exit(f"Sim workers ({nsim_workers}) must divide evenly into nodes") comms = libE_specs["comms"] node_file = "nodelist_mpi_runners_subnode_comms_" + str(comms) + "_wrks_" + str(nworkers) diff --git a/libensemble/tests/functionality_tests/test_mpi_runners_subnode_uneven.py b/libensemble/tests/functionality_tests/test_mpi_runners_subnode_uneven.py index 96fbbbb64c..7f5cdbbeab 100644 --- a/libensemble/tests/functionality_tests/test_mpi_runners_subnode_uneven.py +++ b/libensemble/tests/functionality_tests/test_mpi_runners_subnode_uneven.py @@ -43,9 +43,7 @@ nsim_workers = nworkers if nsim_workers % 2 == 0: - sys.exit( - "This test must be run with an odd of workers >= 3 and <= 31. There are {} workers.".format(nsim_workers) - ) + sys.exit(f"This test must be run with an odd of workers >= 3 and <= 31. There are {nsim_workers} workers.") comms = libE_specs["comms"] node_file = "nodelist_mpi_runners_subnode_uneven_comms_" + str(comms) + "_wrks_" + str(nworkers) 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_runlines_adaptive_workers_persistent_oversubscribe_rsets.py b/libensemble/tests/functionality_tests/test_runlines_adaptive_workers_persistent_oversubscribe_rsets.py index f13d84843f..17807bb4c4 100644 --- a/libensemble/tests/functionality_tests/test_runlines_adaptive_workers_persistent_oversubscribe_rsets.py +++ b/libensemble/tests/functionality_tests/test_runlines_adaptive_workers_persistent_oversubscribe_rsets.py @@ -40,7 +40,7 @@ num_gens = len(libE_specs["zero_resource_workers"]) total_nodes = (nworkers - num_gens) // 2 # 2 resourced workers per node. - print("sim_workers: {}. rsets: {}. Nodes: {}".format(nsim_workers, rsets, total_nodes), flush=True) + print(f"sim_workers: {nsim_workers}. rsets: {rsets}. Nodes: {total_nodes}", flush=True) if total_nodes == 1: max_rsets = 4 # Up to one node diff --git a/libensemble/tests/functionality_tests/test_sim_dirs_per_calc.py b/libensemble/tests/functionality_tests/test_sim_dirs_per_calc.py index 4555f68a27..8fc80d4649 100644 --- a/libensemble/tests/functionality_tests/test_sim_dirs_per_calc.py +++ b/libensemble/tests/functionality_tests/test_sim_dirs_per_calc.py @@ -67,11 +67,11 @@ H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) if is_manager: - assert os.path.isdir(c_ensemble), "Ensemble directory {} not created.".format(c_ensemble) + assert os.path.isdir(c_ensemble), f"Ensemble directory {c_ensemble} not created." dir_sum = sum(["sim" in i for i in os.listdir(c_ensemble)]) assert ( dir_sum == exit_criteria["sim_max"] - ), "Number of sim directories ({}) does not match sim_max ({}).".format(dir_sum, exit_criteria["sim_max"]) + ), f"Number of sim directories ({dir_sum}) does not match sim_max ({exit_criteria['sim_max']})." input_copied = [] 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..c4cfb29837 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 @@ -67,7 +68,7 @@ H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) if is_manager: - assert os.path.isdir(w_ensemble), "Ensemble directory {} not created.".format(w_ensemble) + assert os.path.isdir(w_ensemble), f"Ensemble directory {w_ensemble} not created." worker_dir_sum = sum(["worker" in i for i in os.listdir(w_ensemble)]) assert worker_dir_sum == nworkers, "Number of worker dirs ({}) does not match nworkers ({}).".format( worker_dir_sum, nworkers @@ -91,5 +92,5 @@ assert ( sim_dir_sum == exit_criteria["sim_max"] - ), "Number of sim directories ({}) does not match sim_max ({}).".format(sim_dir_sum, exit_criteria["sim_max"]) + ), f"Number of sim directories ({sim_dir_sum}) does not match sim_max ({exit_criteria['sim_max']})." assert all(input_copied), "Exact input files not copied or symlinked to each calculation directory" diff --git a/libensemble/tests/functionality_tests/test_sim_dirs_with_exception.py b/libensemble/tests/functionality_tests/test_sim_dirs_with_exception.py index 63cc79b9b0..9e7054cf01 100644 --- a/libensemble/tests/functionality_tests/test_sim_dirs_with_exception.py +++ b/libensemble/tests/functionality_tests/test_sim_dirs_with_exception.py @@ -61,7 +61,7 @@ try: H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) except LoggedException as e: - print("Caught deliberate exception: {}".format(e)) + print(f"Caught deliberate exception: {e}") return_flag = 0 if is_manager: diff --git a/libensemble/tests/functionality_tests/test_sim_dirs_with_gen_dirs.py b/libensemble/tests/functionality_tests/test_sim_dirs_with_gen_dirs.py index bfbdba6abd..9673affd17 100644 --- a/libensemble/tests/functionality_tests/test_sim_dirs_with_gen_dirs.py +++ b/libensemble/tests/functionality_tests/test_sim_dirs_with_gen_dirs.py @@ -92,14 +92,14 @@ def check_copied(type): ) ) - assert all(input_copied), "All input files not copied or symlinked to each {} calc dir".format(type) + assert all(input_copied), f"All input files not copied or symlinked to each {type} calc dir" if is_manager: - assert os.path.isdir(c_ensemble), "Ensemble directory {} not created.".format(c_ensemble) + assert os.path.isdir(c_ensemble), f"Ensemble directory {c_ensemble} not created." sim_dir_sum = sum(["sim" in i for i in os.listdir(c_ensemble)]) assert ( sim_dir_sum == exit_criteria["sim_max"] - ), "Number of sim directories ({}) does not match sim_max ({}).".format(sim_dir_sum, exit_criteria["sim_max"]) + ), f"Number of sim directories ({sim_dir_sum}) does not match sim_max ({exit_criteria['sim_max']})." assert any(["gen" in i for i in os.listdir(c_ensemble)]), "No gen directories created." diff --git a/libensemble/tests/functionality_tests/test_sim_input_dir_option.py b/libensemble/tests/functionality_tests/test_sim_input_dir_option.py index 5237fe9ff3..abd5e515e6 100644 --- a/libensemble/tests/functionality_tests/test_sim_input_dir_option.py +++ b/libensemble/tests/functionality_tests/test_sim_input_dir_option.py @@ -64,7 +64,7 @@ H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) if is_manager: - assert os.path.isdir(o_ensemble), "Ensemble directory {} not created.".format(o_ensemble) + assert os.path.isdir(o_ensemble), f"Ensemble directory {o_ensemble} not created." assert os.path.basename(dir_to_copy) in os.listdir(o_ensemble), "Input file not copied over." with open(os.path.join(o_ensemble, "test_sim_out.txt"), "r") as f: lines = f.readlines() 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/functionality_tests/test_worker_exceptions.py b/libensemble/tests/functionality_tests/test_worker_exceptions.py index 4543da06f6..eab808c7d4 100644 --- a/libensemble/tests/functionality_tests/test_worker_exceptions.py +++ b/libensemble/tests/functionality_tests/test_worker_exceptions.py @@ -58,7 +58,7 @@ try: H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, libE_specs=libE_specs) except LoggedException as e: - print("Caught deliberate exception: {}".format(e)) + print(f"Caught deliberate exception: {e}") return_flag = 0 if is_manager: diff --git a/libensemble/tests/functionality_tests/test_zero_resource_workers_subnode.py b/libensemble/tests/functionality_tests/test_zero_resource_workers_subnode.py index 3dce876dfe..58634da5a1 100644 --- a/libensemble/tests/functionality_tests/test_zero_resource_workers_subnode.py +++ b/libensemble/tests/functionality_tests/test_zero_resource_workers_subnode.py @@ -55,7 +55,7 @@ nsim_workers = nworkers - n_gens if not (nsim_workers * nodes_per_worker).is_integer(): - sys.exit("Sim workers ({}) must divide evenly into nodes".format(nsim_workers)) + sys.exit(f"Sim workers ({nsim_workers}) must divide evenly into nodes") comms = libE_specs["comms"] node_file = "nodelist_zero_resource_workers_subnode_comms_" + str(comms) + "_wrks_" + str(nworkers) diff --git a/libensemble/tests/regression_tests/common.py b/libensemble/tests/regression_tests/common.py index b224816b16..94f55c9862 100644 --- a/libensemble/tests/regression_tests/common.py +++ b/libensemble/tests/regression_tests/common.py @@ -106,7 +106,7 @@ def modify_Balsam_pyCoverage(): old_line = " path = ' '.join((exe, script_path, args))\n" new_line = ( " path = ' '.join((exe, '-m coverage run " - + "--parallel-mode --rcfile={}', script_path, args))\n".format(rcfile) + + f"--parallel-mode --rcfile={rcfile}', script_path, args))\n" ) commandfile = "cli_commands.py" diff --git a/libensemble/tests/regression_tests/script_test_balsam_hworld.py b/libensemble/tests/regression_tests/script_test_balsam_hworld.py index ab1c4c8332..1b4aea37a3 100644 --- a/libensemble/tests/regression_tests/script_test_balsam_hworld.py +++ b/libensemble/tests/regression_tests/script_test_balsam_hworld.py @@ -75,8 +75,8 @@ ) calc_status_list = np.repeat(calc_status_list_in, nworkers) - print("Expecting: {}".format(calc_status_list)) - print("Received: {}\n".format(H["cstat"])) + print(f"Expecting: {calc_status_list}") + print(f"Received: {H['cstat']}\n") assert np.array_equal(H["cstat"], calc_status_list), "Error - unexpected calc status. Received: " + str( H["cstat"] diff --git a/libensemble/tests/regression_tests/scripts_used_by_reg_tests/test_balsam_hworld.py b/libensemble/tests/regression_tests/scripts_used_by_reg_tests/test_balsam_hworld.py index a720047c7e..27812010d8 100644 --- a/libensemble/tests/regression_tests/scripts_used_by_reg_tests/test_balsam_hworld.py +++ b/libensemble/tests/regression_tests/scripts_used_by_reg_tests/test_balsam_hworld.py @@ -15,7 +15,7 @@ def run_Balsam_job(): runstr = "balsam launcher --consume-all --job-mode=mpi --num-transition-threads=1" - print("Executing Balsam job with command: {}".format(runstr)) + print(f"Executing Balsam job with command: {runstr}") subprocess.Popen(runstr.split()) @@ -36,10 +36,10 @@ def wait_for_job_dir(basedb): time.sleep(1) sleeptime += 1 - assert sleeptime < limit, "Balsam Database directory not created within {} seconds.".format(limit) + assert sleeptime < limit, f"Balsam Database directory not created within {limit} seconds." # Stop sleeping once job directory detected within database directory - print("Waiting for Job Directory {}".format(sleeptime)) + print(f"Waiting for Job Directory {sleeptime}") while sleeptime < limit: if len(os.listdir(basedb)) > 0: break @@ -47,7 +47,7 @@ def wait_for_job_dir(basedb): time.sleep(1) sleeptime += 1 - assert sleeptime < limit, "Balsam Job directory not created within {} seconds.".format(limit) + assert sleeptime < limit, f"Balsam Job directory not created within {limit} seconds." # Assumes database dir was empty, now contains single job dir jobdir = os.path.join(basedb, os.listdir(basedb)[0]) @@ -59,7 +59,7 @@ def wait_for_job_output(jobdir): limit = 60 output = os.path.join(jobdir, "job_script_test_balsam_hworld.out") - print("Checking for Balsam output file: {}".format(output)) + print(f"Checking for Balsam output file: {output}") while sleeptime < limit: if os.path.isfile(output): @@ -69,7 +69,7 @@ def wait_for_job_output(jobdir): time.sleep(1) sleeptime += 1 - assert sleeptime < limit, "Balsam output file not created within {} seconds.".format(limit) + assert sleeptime < limit, f"Balsam output file not created within {limit} seconds." return output @@ -94,7 +94,7 @@ def print_job_output(outscript): time.sleep(1) sleeptime += 1 - assert sleeptime < limit, "Expected Balsam Job output-file contents not detected after {} seconds.".format(limit) + assert sleeptime < limit, f"Expected Balsam Job output-file contents not detected after {limit} seconds." def move_job_coverage(jobdir): diff --git a/libensemble/tests/regression_tests/support.py b/libensemble/tests/regression_tests/support.py index 5348af9e0d..85fb91d1b9 100644 --- a/libensemble/tests/regression_tests/support.py +++ b/libensemble/tests/regression_tests/support.py @@ -32,7 +32,7 @@ def write_sim_func(calc_in, persis_info, sim_specs, libE_info): out = np.zeros(1, dtype=sim_specs["out"]) out["f"] = calc_in["x"] with open("test_sim_out.txt", "a") as f: - f.write("sim_f received: {}\n".format(out["f"])) + f.write(f"sim_f received: {out['f']}\n") return out, persis_info @@ -43,7 +43,7 @@ def remote_write_sim_func(calc_in, persis_info, sim_specs, libE_info): calc_dir = sim_specs["user"]["calc_dir"] out["f"] = calc_in["x"] with open(calc_dir + "/test_sim_out.txt", "a") as f: - f.write("sim_f received: {}\n".format(out["f"])) + f.write(f"sim_f received: {out['f']}\n") return out, persis_info @@ -55,7 +55,7 @@ def remote_write_gen_func(calc_in, persis_info, gen_specs, libE_info): H_o = np.zeros(1, dtype=gen_specs["out"]) H_o["x"] = socket.gethostname() + "_" + secrets.token_hex(nbytes=3) with open("test_gen_out.txt", "a") as f: - f.write("gen_f produced: {}\n".format(H_o["x"])) + f.write(f"gen_f produced: {H_o['x']}\n") return H_o, persis_info @@ -67,7 +67,7 @@ def write_uniform_gen_func(H, persis_info, gen_specs, _): H_o = np.zeros(b, dtype=gen_specs["out"]) H_o["x"] = persis_info["rand_stream"].uniform(lb, ub, (b, n)) with open("test_gen_out.txt", "a") as f: - f.write("gen_f produced: {}\n".format(H_o["x"])) + f.write(f"gen_f produced: {H_o['x']}\n") return H_o, persis_info diff --git a/libensemble/tests/regression_tests/test_1d_sampling_with_profile.py b/libensemble/tests/regression_tests/test_1d_sampling_with_profile.py index 2da35c9996..a53a3cb22c 100644 --- a/libensemble/tests/regression_tests/test_1d_sampling_with_profile.py +++ b/libensemble/tests/regression_tests/test_1d_sampling_with_profile.py @@ -60,13 +60,13 @@ assert "manager.prof" in os.listdir(), "Expected manager profile not found after run" os.remove("manager.prof") - prof_files = ["worker_{}.prof".format(i + 1) for i in range(nworkers)] + prof_files = [f"worker_{i+1}.prof" for i in range(nworkers)] # Ensure profile writes complete before checking time.sleep(0.5) for file in prof_files: - assert file in os.listdir(), "Expected profile {} not found after run".format(file) + assert file in os.listdir(), "Expected profile {file} not found after run" with open(file, "r") as f: data = f.read().split() num_worker_funcs_profiled = sum(["worker" in i for i in data]) diff --git a/libensemble/tests/regression_tests/test_persistent_aposmm_dfols.py b/libensemble/tests/regression_tests/test_persistent_aposmm_dfols.py index 5342d91889..81f74e5992 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_dfols.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_dfols.py @@ -42,7 +42,6 @@ def combine_component(x): # 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() diff --git a/libensemble/tests/regression_tests/test_persistent_aposmm_exception.py b/libensemble/tests/regression_tests/test_persistent_aposmm_exception.py index 473d715a4a..7d6d2b3c12 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_exception.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_exception.py @@ -50,7 +50,6 @@ def assertion(passed): # 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() 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..a082129234 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 @@ -46,7 +46,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() 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/test_persistent_aposmm_periodic.py b/libensemble/tests/regression_tests/test_persistent_aposmm_periodic.py index bdaf5d8323..bcdbbab3cb 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_periodic.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_periodic.py @@ -34,7 +34,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() 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 97% rename from libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_pounders.py rename to libensemble/tests/regression_tests/test_persistent_aposmm_pounders.py index 881a83e4de..4f0d7180d1 100644 --- a/libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_pounders.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_pounders.py @@ -44,7 +44,6 @@ def combine_component(x): # 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() diff --git a/libensemble/tests/regression_tests/test_persistent_aposmm_scipy.py b/libensemble/tests/regression_tests/test_persistent_aposmm_scipy.py index 17f437b637..97a2091dbe 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_scipy.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_scipy.py @@ -37,7 +37,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() @@ -109,7 +108,7 @@ print(np.min(np.sum((H[H["local_min"]]["x"] - m) ** 2, 1)), flush=True) if np.min(np.sum((H[H["local_min"]]["x"] - m) ** 2, 1)) < tol: min_found += 1 - assert min_found >= 4, "Found {} minima".format(min_found) + assert min_found >= 4, f"Found {min_found} minima" save_libE_output(H, persis_info, __file__, nworkers) 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 97% 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 index 3f0545214b..e460e6a125 100644 --- a/libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_tao_blmvm.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_tao_blmvm.py @@ -38,7 +38,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() 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 96% 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 index 9c20c77e24..52ed730994 100644 --- a/libensemble/tests/regression_tests/dont_run_test_persistent_aposmm_tao_nm.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_tao_nm.py @@ -35,7 +35,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() diff --git a/libensemble/tests/regression_tests/test_persistent_aposmm_timeout.py b/libensemble/tests/regression_tests/test_persistent_aposmm_timeout.py index a701720eaa..cd281361a2 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_timeout.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_timeout.py @@ -35,7 +35,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() diff --git a/libensemble/tests/regression_tests/test_persistent_aposmm_with_grad.py b/libensemble/tests/regression_tests/test_persistent_aposmm_with_grad.py index a90e73976c..76849d5a82 100644 --- a/libensemble/tests/regression_tests/test_persistent_aposmm_with_grad.py +++ b/libensemble/tests/regression_tests/test_persistent_aposmm_with_grad.py @@ -39,7 +39,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() diff --git a/libensemble/tests/regression_tests/dont_run_test_persistent_gp.py b/libensemble/tests/regression_tests/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/test_persistent_gp.py diff --git a/libensemble/tests/regression_tests/test_persistent_gp_multitask_ax.py b/libensemble/tests/regression_tests/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/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/test_persistent_n_agent.py b/libensemble/tests/regression_tests/test_persistent_n_agent.py index a14a297bda..495346fa51 100644 --- a/libensemble/tests/regression_tests/test_persistent_n_agent.py +++ b/libensemble/tests/regression_tests/test_persistent_n_agent.py @@ -193,7 +193,7 @@ def f(theta, i): ) if is_manager: - print("=== Optimizing {} ===".format(prob_name), flush=True) + print(f"=== Optimizing {prob_name} ===", flush=True) H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs) @@ -236,4 +236,4 @@ def f(theta, i): assert F - fstar < err_const * eps, "Error of {:.4e}, expected {:.4e} (assuming f*={:.4e})".format( F - fstar, err_const * eps, fstar ) - assert consensus_val < eps, "Consensus score of {:.4e}, expected {:.4e}\nx={}".format(consensus_val, eps, x) + assert consensus_val < eps, f"Consensus score of {consensus_val:.4e}, expected {eps:.4e}\nx={x}" diff --git a/libensemble/tests/regression_tests/test_persistent_pds.py b/libensemble/tests/regression_tests/test_persistent_pds.py index edb1b5bbc9..0621116a24 100644 --- a/libensemble/tests/regression_tests/test_persistent_pds.py +++ b/libensemble/tests/regression_tests/test_persistent_pds.py @@ -196,7 +196,7 @@ def f(theta, i): ) if is_manager: - print("=== Optimizing {} ===".format(prob_name), flush=True) + print(f"=== Optimizing {prob_name} ===", flush=True) H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs) @@ -234,4 +234,4 @@ def f(theta, i): assert F - fstar < err_const * eps, "Error of {:.4e}, expected {:.4e} (assuming f*={:.4e})".format( F - fstar, err_const * eps, fstar ) - assert consensus_val < eps, "Consensus score of {:.4e}, expected {:.4e}".format(consensus_val, eps) + assert consensus_val < eps, f"Consensus score of {consensus_val:.4e}, expected {eps:.4e}" diff --git a/libensemble/tests/regression_tests/test_persistent_prox_slide.py b/libensemble/tests/regression_tests/test_persistent_prox_slide.py index 408b08f425..2f94e09bbe 100644 --- a/libensemble/tests/regression_tests/test_persistent_prox_slide.py +++ b/libensemble/tests/regression_tests/test_persistent_prox_slide.py @@ -148,7 +148,7 @@ def df(x, i): ) if is_manager: - print("=== Optimizing {} ===".format(prob_name), flush=True) + print(f"=== Optimizing {prob_name} ===", flush=True) H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs) @@ -191,4 +191,4 @@ def df(x, i): assert F - fstar < err_const * eps, "Error of {:.4e}, expected {:.4e} (assuming f*={:.4e})".format( F - fstar, err_const * eps, fstar ) - assert consensus_val < eps, "Consensus score of {:.4e}, expected {:.4e}\nx={}".format(consensus_val, eps, x) + assert consensus_val < eps, f"Consensus score of {consensus_val:.4e}, expected {eps:.4e}\nx={x}" 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_calib.py b/libensemble/tests/regression_tests/test_persistent_surmise_calib.py index be82a8ee7d..1b7f365e38 100644 --- a/libensemble/tests/regression_tests/test_persistent_surmise_calib.py +++ b/libensemble/tests/regression_tests/test_persistent_surmise_calib.py @@ -117,7 +117,7 @@ print("Cancelled sims", H["sim_id"][H["cancel_requested"]]) 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) + assert sims_done == max_evals, f"Num of completed simulations should be {max_evals}. Is {sims_done}" # The following line is only to cover parts of tstd2theta tstd2theta(H[0]["thetas"].squeeze(), hard=False) diff --git a/libensemble/tests/regression_tests/test_persistent_surmise_killsims.py b/libensemble/tests/regression_tests/test_persistent_surmise_killsims.py index 62874e2a7c..4152fd5886 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) + assert sims_done == max_evals, f"Num of completed simulations should be {max_evals}. Is {sims_done}" diff --git a/libensemble/tests/regression_tests/test_persistent_tasmanian.py b/libensemble/tests/regression_tests/test_persistent_tasmanian.py index 3b1b10c919..a67d33d1e5 100644 --- a/libensemble/tests/regression_tests/test_persistent_tasmanian.py +++ b/libensemble/tests/regression_tests/test_persistent_tasmanian.py @@ -95,7 +95,7 @@ def tasmanian_init_localp(): # the final grid will also be stored in the file gen_specs["user"] = { "tasmanian_init": tasmanian_init_global if run < 2 else tasmanian_init_localp, - "tasmanian_checkpoint_file": "tasmanian{0}.grid".format(run), + "tasmanian_checkpoint_file": f"tasmanian{run}.grid", } # setup the refinement criteria diff --git a/libensemble/tests/regression_tests/test_persistent_tasmanian_async.py b/libensemble/tests/regression_tests/test_persistent_tasmanian_async.py index a1434a9900..0063de3c22 100644 --- a/libensemble/tests/regression_tests/test_persistent_tasmanian_async.py +++ b/libensemble/tests/regression_tests/test_persistent_tasmanian_async.py @@ -99,8 +99,8 @@ def sim_f(H, persis_info, sim_specs, _): run_num += 1 if is_manager: - print("[Manager]: user_specs = {0}".format(user_specs)) - print("[Manager]: exit_criteria = {0}".format(exit_criteria)) + print(f"[Manager]: user_specs = {user_specs}") + print(f"[Manager]: exit_criteria = {exit_criteria}") start_time = time() H, persis_info, flag = libE(sim_specs, gen_specs, exit_criteria, persis_info, alloc_specs, libE_specs) if is_manager: 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..22b7672442 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 @@ -88,8 +89,8 @@ gen_workers = np.unique(H["gen_worker"]) print("Generators that issued points", gen_workers) - assert len(gen_workers) == ngens, "The number of gens used {} does not match num_active_gens {}".format( - len(gen_workers), ngens - ) + assert ( + len(gen_workers) == ngens + ), f"The number of gens used {len(gen_workers)} does not match num_active_gens {ngens}" save_libE_output(H, persis_info, __file__, nworkers) 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/balsam_forces/forces_simf.py b/libensemble/tests/scaling_tests/forces/balsam_forces/forces_simf.py index f1dc63abdc..c3bca2795d 100644 --- a/libensemble/tests/scaling_tests/forces/balsam_forces/forces_simf.py +++ b/libensemble/tests/scaling_tests/forces/balsam_forces/forces_simf.py @@ -26,7 +26,7 @@ def run_forces_balsam(H, persis_info, sim_specs, libE_info): workdir = "sim" + str(libE_info["H_rows"][0]) + "_worker" + str(libE_info["workerID"]) - statfile = "forces{}.stat".format(particles) + statfile = f"forces{particles}.stat" if THIS_SCRIPT_ON_THETA: transfer_statfile_path = GLOBUS_DEST_DIR + statfile @@ -51,7 +51,7 @@ def run_forces_balsam(H, persis_info, sim_specs, libE_info): task.wait(timeout=300) task.poll() - print("Task {} polled. state: {}.".format(task.name, task.state)) + print(f"Task {task.name} polled. state: {task.state}.") while True: time.sleep(1) diff --git a/libensemble/tests/scaling_tests/forces/forces_adv/forces_simf.py b/libensemble/tests/scaling_tests/forces/forces_adv/forces_simf.py index af3a6f8ea4..607ec24a2c 100644 --- a/libensemble/tests/scaling_tests/forces/forces_adv/forces_simf.py +++ b/libensemble/tests/scaling_tests/forces/forces_adv/forces_simf.py @@ -67,7 +67,7 @@ def run_forces(H, persis_info, sim_specs, libE_info): # This is to give a random variance of work-load sim_particles = perturb(sim_particles, seed, particle_variance) - print("seed: {} particles: {}".format(seed, sim_particles)) + print(f"seed: {seed} particles: {sim_particles}") exctr = Executor.executor # Get Executor @@ -117,19 +117,19 @@ def run_forces(H, persis_info, sim_specs, libE_info): if task.finished: if task.state == "FINISHED": - print("Task {} completed".format(task.name)) + print(f"Task {task.name} completed") calc_status = WORKER_DONE if read_last_line(filepath) == "kill": # Generally mark as complete if want results (completed after poll - before readline) print("Warning: Task completed although marked as a bad run (kill flag set in forces.stat)") elif task.state == "FAILED": - print("Warning: Task {} failed: Error code {}".format(task.name, task.errcode)) + print(f"Warning: Task {task.name} failed: Error code {task.errcode}") calc_status = TASK_FAILED elif task.state == "USER_KILLED": - print("Warning: Task {} has been killed".format(task.name)) + print(f"Warning: Task {task.name} has been killed") calc_status = WORKER_KILL else: - print("Warning: Task {} in unknown state {}. Error code {}".format(task.name, task.state, task.errcode)) + print(f"Warning: Task {task.name} in unknown state {task.state}. Error code {task.errcode}") time.sleep(0.2) try: diff --git a/libensemble/tests/scaling_tests/forces/forces_adv/forces_support.py b/libensemble/tests/scaling_tests/forces/forces_adv/forces_support.py index 5aac672c3c..9a10aa5a86 100644 --- a/libensemble/tests/scaling_tests/forces/forces_adv/forces_support.py +++ b/libensemble/tests/scaling_tests/forces/forces_adv/forces_support.py @@ -19,7 +19,7 @@ def test_libe_stats(status): def test_ensemble_dir(libE_specs, dir, nworkers, sim_max): if not os.path.isdir(dir): - print("Specified ensemble directory {} not found.".format(dir)) + print(f"Specified ensemble directory {dir} not found.") return if not libE_specs.get("sim_dirs_make"): @@ -44,7 +44,7 @@ def test_ensemble_dir(libE_specs, dir, nworkers, sim_max): assert ( num_sim_dirs == sim_max - ), "Number of simulation specific-directories ({}) doesn't match sim_max ({})".format(num_sim_dirs, sim_max) + ), f"Number of simulation specific-directories ({num_sim_dirs}) doesn't match sim_max ({sim_max})" assert all( files_found @@ -58,7 +58,7 @@ def test_ensemble_dir(libE_specs, dir, nworkers, sim_max): assert ( len(sim_dirs) == sim_max - ), "Number of simulation specific-directories ({}) doesn't match sim_max ({})".format(len(sim_dirs), sim_max) + ), f"Number of simulation specific-directories ({len(sim_dirs)}) doesn't match sim_max ({sim_max})" files_found = [] for sim_dir in sim_dirs: @@ -68,4 +68,4 @@ def test_ensemble_dir(libE_specs, dir, nworkers, sim_max): files_found ), "Set of expected files ['err.txt', 'forces.stat', 'out.txt'] not found in each sim_dir." - print("Output directory {} passed tests.".format(dir)) + print(f"Output directory {dir} passed tests.") diff --git a/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces.py b/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces.py index 05d29e9b1d..ca320b3c46 100644 --- a/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces.py +++ b/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces.py @@ -34,7 +34,7 @@ sys.exit("forces.x not found - please build first in ../forces_app dir") if is_manager: - print("\nRunning with {} workers\n".format(nworkers)) + print(f"\nRunning with {nworkers} workers\n") # Create executor and register sim to it. diff --git a/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces_from_yaml.py b/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces_from_yaml.py index b47914e80c..7b176b86f9 100644 --- a/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces_from_yaml.py +++ b/libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces_from_yaml.py @@ -22,7 +22,7 @@ forces.logger.set_level("INFO") if forces.is_manager: - print("\nRunning with {} workers\n".format(forces.nworkers)) + print(f"\nRunning with {forces.nworkers} workers\n") exctr = MPIExecutor() exctr.register_app(full_path=sim_app, app_name="forces") 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/scaling_tests/forces/funcx_forces/forces_simf.py b/libensemble/tests/scaling_tests/forces/funcx_forces/forces_simf.py index 04495899cc..b34eda2ba9 100644 --- a/libensemble/tests/scaling_tests/forces/funcx_forces/forces_simf.py +++ b/libensemble/tests/scaling_tests/forces/funcx_forces/forces_simf.py @@ -58,7 +58,7 @@ def read_last_line(filepath): # This is to give a random variance of work-load sim_particles = perturb(sim_particles, seed, particle_variance) - print("seed: {} particles: {}".format(seed, sim_particles)) + print(f"seed: {seed} particles: {sim_particles}") args = str(int(sim_particles)) + " " + str(sim_timesteps) + " " + str(seed) + " " + str(kill_rate) @@ -107,19 +107,19 @@ def read_last_line(filepath): if task.finished: if task.state == "FINISHED": - print("Task {} completed".format(task.name)) + print(f"Task {task.name} completed") calc_status = WORKER_DONE if read_last_line(filepath) == "kill": # Generally mark as complete if want results (completed after poll - before readline) print("Warning: Task completed although marked as a bad run (kill flag set in forces.stat)") elif task.state == "FAILED": - print("Warning: Task {} failed: Error code {}".format(task.name, task.errcode)) + print(f"Warning: Task {task.name} failed: Error code {task.errcode}") calc_status = TASK_FAILED elif task.state == "USER_KILLED": - print("Warning: Task {} has been killed".format(task.name)) + print(f"Warning: Task {task.name} has been killed") calc_status = WORKER_KILL else: - print("Warning: Task {} in unknown state {}. Error code {}".format(task.name, task.state, task.errcode)) + print(f"Warning: Task {task.name} in unknown state {task.state}. Error code {task.errcode}") time.sleep(0.2) try: diff --git a/libensemble/tests/scaling_tests/warpx/warpx_simf.py b/libensemble/tests/scaling_tests/warpx/warpx_simf.py index 286e103775..6e6cf6eaca 100644 --- a/libensemble/tests/scaling_tests/warpx/warpx_simf.py +++ b/libensemble/tests/scaling_tests/warpx/warpx_simf.py @@ -76,12 +76,12 @@ def run_warpx(H, persis_info, sim_specs, libE_info): if task.state == "FINISHED": calc_status = WORKER_DONE elif task.state == "FAILED": - print("Warning: Task {} failed: Error code {}".format(task.name, task.errcode)) + print(f"Warning: Task {task.name} failed: Error code {task.errcode}") calc_status = TASK_FAILED elif task.state == "USER_KILLED": - print("Warning: Task {} has been killed".format(task.name)) + print(f"Warning: Task {task.name} has been killed") else: - print("Warning: Task {} in unknown state {}. Error code {}".format(task.name, task.state, task.errcode)) + print(f"Warning: Task {task.name} in unknown state {task.state}. Error code {task.errcode}") # Safety time.sleep(0.2) diff --git a/libensemble/tests/standalone_tests/comms_test/commtest.py b/libensemble/tests/standalone_tests/comms_test/commtest.py index d2fe840a2c..05d2e6c026 100644 --- a/libensemble/tests/standalone_tests/comms_test/commtest.py +++ b/libensemble/tests/standalone_tests/comms_test/commtest.py @@ -25,7 +25,7 @@ start_time = time.time() if rank == 0: - print("Running comms test on {} processors with {} workers".format(MPI.COMM_WORLD.Get_size(), num_workers)) + print(f"Running comms test on {MPI.COMM_WORLD.Get_size()} processors with {num_workers} workers") # print("Hello from manager") status = MPI.Status() alldone = False @@ -45,7 +45,7 @@ if mess_count >= total_num_mess: alldone = True - print("Manager received and checked {} messages".format(mess_count)) + print(f"Manager received and checked {mess_count} messages") print("Manager finished in time", time.time() - start_time) else: diff --git a/libensemble/tests/standalone_tests/kill_test/killtest.py b/libensemble/tests/standalone_tests/kill_test/killtest.py index 5b66905082..f5d7b314ea 100644 --- a/libensemble/tests/standalone_tests/kill_test/killtest.py +++ b/libensemble/tests/standalone_tests/kill_test/killtest.py @@ -31,7 +31,7 @@ def kill_task_2(process): num_procs = num_nodes * num_procs_per_node print("Running Kill test with program", user_code) -print("Kill type: {} num_nodes: {} procs_per_node: {}".format(kill_type, num_nodes, num_procs_per_node)) +print(f"Kill type: {kill_type} num_nodes: {num_nodes} procs_per_node: {num_procs_per_node}") # Create common components of submit line (currently all of it) @@ -72,7 +72,7 @@ def kill_task_2(process): stdout = "out_" + str(run_num) + ".txt" # runline = ['mpirun', '-np', str(num_procs), user_code] print("---------------------------------------------------------------") - print("\nRun num: {} Runline: {}\n".format(run_num, " ".join(runline))) + print(f"\nRun num: {run_num} Runline: {' '.join(runline)}\n") if kill_type == 1: process = subprocess.Popen(runline, cwd="./", stdout=open(stdout, "w"), shell=False) # with kill 1 @@ -126,7 +126,7 @@ def kill_task_2(process): # Test if task is still producing output with open(stdout, "rb") as fh: line_on_kill = fh.readlines()[-1].decode().rstrip() - print("Last line after task kill: {}".format(line_on_kill)) + print(f"Last line after task kill: {line_on_kill}") if "has finished" in line_on_kill: raise Exception("Task may have already finished - test invalid") @@ -135,14 +135,14 @@ def kill_task_2(process): time.sleep(recheck_period) with open(stdout, "rb") as fh: lastline = fh.readlines()[-1].decode().rstrip() - print("Last line after {} seconds: {}".format(recheck_period * recheck, lastline)) + print(f"Last line after {recheck_period * recheck} seconds: {lastline}") if lastline != line_on_kill: - print("Task {} still producing output".format(run_num)) + print(f"Task {run_num} still producing output") # print("Last line check 1:", line_on_kill) # print("Last line check 2:", lastline) assert 0 total_end_time = time.time() total_time = total_end_time - total_start_time -print("\nTask kill test completed in {} seconds\n".format(total_time)) +print(f"\nTask kill test completed in {total_time} seconds\n") diff --git a/libensemble/tests/standalone_tests/mpi_launch_test/create_mpi_jobs.py b/libensemble/tests/standalone_tests/mpi_launch_test/create_mpi_jobs.py index 5df4e54b58..2367f98878 100644 --- a/libensemble/tests/standalone_tests/mpi_launch_test/create_mpi_jobs.py +++ b/libensemble/tests/standalone_tests/mpi_launch_test/create_mpi_jobs.py @@ -16,8 +16,8 @@ runline.append("helloworld.py") if rank == 0: - print("Total sub-task procs: {}".format(size * int(task_nprocs))) - print("Total procs (parent + sub-tasks): {}".format(size * (int(task_nprocs) + 1))) + print(f"Total sub-task procs: {size * int(task_nprocs)}") + print(f"Total procs (parent + sub-tasks): {size * (int(task_nprocs) + 1)}") # print("Rank {}: {}".format(rank, " ".join(runline))) output = "task_" + str(rank) + ".out" diff --git a/libensemble/tests/unit_tests/launch_busy.py b/libensemble/tests/unit_tests/launch_busy.py index 7aef7aef18..3adca1a7b2 100644 --- a/libensemble/tests/unit_tests/launch_busy.py +++ b/libensemble/tests/unit_tests/launch_busy.py @@ -8,7 +8,7 @@ def ignore_handler(signum, frame): def main(ignore_term=False, wait_time=-1): - print("Call with {}, {}".format(ignore_term, wait_time)) + print(f"Call with {ignore_term}, {wait_time}") if ignore_term: signal.signal(signal.SIGTERM, ignore_handler) if wait_time > 0: diff --git a/libensemble/tests/unit_tests/test_env_resources.py b/libensemble/tests/unit_tests/test_env_resources.py index 0554668c03..9308473594 100644 --- a/libensemble/tests/unit_tests/test_env_resources.py +++ b/libensemble/tests/unit_tests/test_env_resources.py @@ -11,12 +11,12 @@ def teardown_standalone_run(): def setup_function(function): - print("setup_function function:%s" % function.__name__) + print(f"setup_function function:{function.__name__}") os.environ["LIBE_RESOURCES_TEST_NODE_LIST"] = "" def teardown_function(function): - print("teardown_function function:%s" % function.__name__) + print(f"teardown_function function:{function.__name__}") os.environ["LIBE_RESOURCES_TEST_NODE_LIST"] = "" diff --git a/libensemble/tests/unit_tests/test_executor.py b/libensemble/tests/unit_tests/test_executor.py index 5b9e52fecc..bd731edd91 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 @@ -30,9 +33,9 @@ def setup_module(module): try: - print("setup_module module:%s" % module.__name__) + print(f"setup_module module:{module.__name__}") except AttributeError: - print("setup_module (direct run) module:%s" % module) + print(f"setup_module (direct run) module:{module}") if Executor.executor is not None: del Executor.executor Executor.executor = None @@ -40,7 +43,7 @@ def setup_module(module): def setup_function(function): - print("setup_function function:%s" % function.__name__) + print(f"setup_function function:{function.__name__}") if Executor.executor is not None: del Executor.executor Executor.executor = None @@ -48,9 +51,9 @@ def setup_function(function): def teardown_module(module): try: - print("teardown_module module:%s" % module.__name__) + print(f"teardown_module module:{module.__name__}") except AttributeError: - print("teardown_module (direct run) module:%s" % module) + print(f"teardown_module (direct run) module:{module}") if Executor.executor is not None: del Executor.executor Executor.executor = None @@ -202,9 +205,12 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -216,9 +222,10 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -232,9 +239,10 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -251,9 +259,10 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -267,9 +276,10 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -280,8 +290,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -292,8 +303,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -304,8 +316,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor task_list = [] @@ -326,9 +339,10 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor @@ -341,7 +355,7 @@ def test_get_task(): args_for_sim = "sleep 0" task0 = exctr.submit(calc_type="sim", num_procs=cores, app_args=args_for_sim) taskid = task0.id - print("taskid is: {}".format(taskid)) + print(f"taskid is: {taskid}") A = exctr.get_task(taskid) assert A is task0, "Task get_task returned unexpected task" + str(A) task0 = polling_loop(exctr, task0) @@ -351,10 +365,11 @@ 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.""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") # Note: Could test task_partition routine directly - without launching tasks... @@ -437,13 +452,14 @@ 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 Kill should have no effect (except warning message) and should remain in state killed """ - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -460,13 +476,14 @@ 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 Kill should have no effect (except warning message) and should remain in state FINISHED """ - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -486,10 +503,11 @@ 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""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -506,8 +524,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -536,8 +555,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor_noapp() exctr = Executor.executor cores = NCORES @@ -556,10 +576,11 @@ def test_launch_no_app(): assert 0 +@pytest.mark.extra def test_kill_task_with_no_submit(): from libensemble.executors.executor import Task - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor @@ -586,10 +607,11 @@ 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 - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor @@ -606,8 +628,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -618,8 +641,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor_fakerunner() exctr = Executor.executor exctr.retry_delay_incr = 0.05 @@ -631,8 +655,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor exctr.retry_delay_incr = 0.05 @@ -644,8 +669,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() # This registers an app my_simtask.x (default sim) exctr = Executor.executor exctr.register_app(full_path="/path/to/fake_app1.x", app_name="fake_app1") @@ -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,8 +752,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() cores = NCORES args_for_sim = "sleep 3" @@ -737,8 +766,9 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() cores = NCORES args_for_sim = "sleep 3" @@ -749,9 +779,10 @@ 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)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") setup_executor() exctr = Executor.executor cores = NCORES @@ -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..028ed19890 --- /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(f"setup_module module:{module.__name__}") + except AttributeError: + print(f"setup_module (direct run) module:{module}") + if Executor.executor is not None: + del Executor.executor + Executor.executor = None + + +def teardown_module(module): + try: + print(f"teardown_module module:{module.__name__}") + except AttributeError: + print(f"teardown_module (direct run) module:{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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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(f"\nTest: {sys._getframe().f_code.co_name}\n") + 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..b4a3305754 100644 --- a/libensemble/tests/unit_tests/test_libE_main.py +++ b/libensemble/tests/unit_tests/test_libE_main.py @@ -62,7 +62,7 @@ def Get_size(self): # Run by pytest before each function def setup_function(function): - print("setup_function function:%s" % function.__name__) + print(f"setup_function function:{function.__name__}") if Resources.resources is not None: del Resources.resources Resources.resources = None @@ -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_loc_stack.py b/libensemble/tests/unit_tests/test_loc_stack.py index 40213aa995..9497e7fca2 100644 --- a/libensemble/tests/unit_tests/test_loc_stack.py +++ b/libensemble/tests/unit_tests/test_loc_stack.py @@ -15,7 +15,7 @@ def test_location_stack(): "Test correctness of location stack (all in a temp dir)." tmp_dirname = tempfile.mkdtemp() - assert os.path.isdir(tmp_dirname), "Failed to create temporary directory {}.".format(tmp_dirname) + assert os.path.isdir(tmp_dirname), f"Failed to create temporary directory {tmp_dirname}." try: # Record where we started @@ -32,10 +32,10 @@ def test_location_stack(): # Register a valid location tname = s.register_loc(0, "testdir", prefix=tmp_dirname, copy_files=[test_fname]) - assert os.path.isdir(tname), "New directory {} was not created.".format(tname) + assert os.path.isdir(tname), f"New directory {tname} was not created." assert os.path.isfile( os.path.join(tname, "test.txt") - ), "New directory {} failed to copy test.txt from {}.".format(tname, clone_dirname) + ), f"New directory {tname} failed to copy test.txt from {clone_dirname}." # Register an empty location d = s.register_loc(1, None) @@ -61,11 +61,11 @@ def test_location_stack(): ) assert os.path.samefile( os.getcwd(), tname - ), "Directory stack push_loc failed to end up at desired dir." "Wanted {}, at {}".format(tname, os.getcwd()) + ), f"Directory stack push_loc failed to end up at desired dir.Wanted {tname}, at {os.getcwd()}" # Pop the registered location s.pop() - assert s.stack == [None], "Directory stack is incorrect after pop." "Wanted [None], got {}.".format(s.stack) + assert s.stack == [None], f"Directory stack is incorrect after pop.Wanted [None], got {s.stack}." assert os.path.samefile( os.getcwd(), start_dir ), "Directory stack push_loc failed to stay put with input None." "Wanted {}, at {}".format( @@ -79,10 +79,10 @@ def test_location_stack(): ) assert os.path.samefile( os.getcwd(), tname - ), "Directory stack push_loc failed to end up at desired dir." "Wanted {}, at {}".format(tname, os.getcwd()) + ), f"Directory stack push_loc failed to end up at desired dir.Wanted {tname}, at {os.getcwd()}" # Check directory after context - assert s.stack == [None], "Directory stack is incorrect after ctx." "Wanted [None], got {}.".format(s.stack) + assert s.stack == [None], f"Directory stack is incorrect after ctx.Wanted [None], got {s.stack}." assert os.path.samefile(os.getcwd(), start_dir), "Directory looks wrong after ctx." "Wanted {}, at {}".format( start_dir, os.getcwd() ) @@ -93,7 +93,7 @@ def test_location_stack(): # Pop the unregistered location s.pop() - assert not s.stack, "Directory stack should be empty, actually {}.".format(s.stack) + assert not s.stack, f"Directory stack should be empty, actually {s.stack}." assert os.path.samefile( os.getcwd(), start_dir ), "Directory stack push_loc failed to stay put with input None." "Wanted {}, at {}".format( @@ -102,7 +102,7 @@ def test_location_stack(): # Clean up s.clean_locs() - assert not os.path.isdir(tname), "Directory {} should have been removed on cleanup.".format(tname) + assert not os.path.isdir(tname), f"Directory {tname} should have been removed on cleanup." finally: shutil.rmtree(tmp_dirname) 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_node_resources.py b/libensemble/tests/unit_tests/test_node_resources.py index 4cb68635b5..b973517fb9 100644 --- a/libensemble/tests/unit_tests/test_node_resources.py +++ b/libensemble/tests/unit_tests/test_node_resources.py @@ -12,12 +12,12 @@ def teardown_standalone_run(): def setup_function(function): - print("setup_function function:%s" % function.__name__) + print(f"setup_function function:{function.__name__}") os.environ["LIBE_RESOURCES_TEST_NODE_LIST"] = "" def teardown_function(function): - print("teardown_function function:%s" % function.__name__) + print(f"teardown_function function:{function.__name__}") os.environ["LIBE_RESOURCES_TEST_NODE_LIST"] = "" diff --git a/libensemble/tests/unit_tests/test_persistent_aposmm.py b/libensemble/tests/unit_tests/test_persistent_aposmm.py index ea68193f0b..dfe791d052 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 @@ -111,7 +113,7 @@ def test_standalone_persistent_aposmm(): print(np.min(np.sum((H[H["local_min"]]["x"] - m) ** 2, 1)), flush=True) if np.min(np.sum((H[H["local_min"]]["x"] - m) ** 2, 1)) < tol: min_found += 1 - assert min_found >= 6, "Found {} minima".format(min_found) + assert min_found >= 6, f"Found {min_found} minima" @pytest.mark.extra diff --git a/libensemble/tests/unit_tests/test_resource_scheduler.py b/libensemble/tests/unit_tests/test_resource_scheduler.py index 259b8a850f..47c67aaf56 100644 --- a/libensemble/tests/unit_tests/test_resource_scheduler.py +++ b/libensemble/tests/unit_tests/test_resource_scheduler.py @@ -54,7 +54,7 @@ def fixed_assignment(self, assignment): def _fail_to_resource(sched, rsets): with pytest.raises(InsufficientFreeResources): rset_team = sched.assign_resources(rsets_req=rsets) - pytest.fail("Expected InsufficientFreeResources. Found {}".format(rset_team)) + pytest.fail(f"Expected InsufficientFreeResources. Found {rset_team}") def _print_assigned(resources): @@ -65,18 +65,18 @@ def _print_assigned(resources): for g in range(max_groups + 1): filt = rsets["group"] == g print(rsets["assigned"][filt]) - print("free rsets {}\n".format(resources.free_rsets)) + print(f"free rsets {resources.free_rsets}\n") def test_request_zero_rsets(): """Tests requesting zero resource sets""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) # No options sched = ResourceScheduler(user_resources=resources) rset_team = sched.assign_resources(rsets_req=0) - assert rset_team == [], "rset_team is {}. Expected zero".format(rset_team) + assert rset_team == [], f"rset_team is {rset_team}. Expected zero" del sched rset_team = None @@ -86,7 +86,7 @@ def test_request_zero_rsets(): sched_options = {"match_slots": match_slots, "split2fit": split2fit} sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=0) - assert rset_team == [], "rset_team is {}. Expected zero".format(rset_team) + assert rset_team == [], f"rset_team is {rset_team}. Expected zero" del sched rset_team = None del resources @@ -94,7 +94,7 @@ def test_request_zero_rsets(): def test_too_many_rsets(): """Tests request of more resource sets than exist""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) # No options @@ -121,7 +121,7 @@ def test_too_many_rsets(): def test_cannot_split_quick_return(): """Tests the quick return when splitting finds no free even gaps""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(6, 3) resources.fixed_assignment(([1, 0, 0, 0, 3, 3])) sched = ResourceScheduler(user_resources=resources) @@ -134,7 +134,7 @@ def test_schedule_find_gaps_1node(): This test also checks the list is correctly assigned to workers and the freeing of assigned resources. """ - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 1) # Options should make no difference @@ -144,7 +144,7 @@ def test_schedule_find_gaps_1node(): sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=2) - assert rset_team == [0, 1], "rset_team is {}".format(rset_team) + assert rset_team == [0, 1], f"rset_team is {rset_team}" rset_team = sched.assign_resources(rsets_req=3) assert rset_team == [2, 3, 4] @@ -174,7 +174,7 @@ def test_schedule_find_gaps_1node(): def test_schedule_find_gaps_2nodes(): """Tests finding gaps on two nodes with equal resource sets""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) inputs = [2, 3, 1, 2] exp_out = [[0, 1], [4, 5, 6], [7], [2, 3]] @@ -185,7 +185,7 @@ def test_schedule_find_gaps_2nodes(): sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) for i in range(4): rset_team = sched.assign_resources(rsets_req=inputs[i]) - assert rset_team == exp_out[i], "Expected {}, Received rset_team {}".format(exp_out[i], rset_team) + assert rset_team == exp_out[i], f"Expected {exp_out[i]}, Received rset_team {rset_team}" _fail_to_resource(sched, 1) del sched rset_team = None @@ -194,7 +194,7 @@ def test_schedule_find_gaps_2nodes(): def test_split_across_no_matching_slots(): """Must split across - but no split2fit and no matching slots""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(6, 3) # 3 nodes of 2 slots for split2fit in [False, True]: @@ -205,7 +205,7 @@ def test_split_across_no_matching_slots(): sched.match_slots = False rset_team = sched.assign_resources(rsets_req=3) - assert rset_team == [0, 3, 4], "rset_team is {}.".format(rset_team) + assert rset_team == [0, 3, 4], f"rset_team is {rset_team}." del sched rset_team = None del resources @@ -216,7 +216,7 @@ def test_across_nodes_even_split(): Also tests cached variables in scheduler. """ - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") # Options should make no difference for match_slots in [False, True]: @@ -227,8 +227,8 @@ def test_across_nodes_even_split(): rset_team = sched.assign_resources(rsets_req=6) # Expecting even split - assert rset_team == [0, 1, 2, 4, 5, 6], "Even split test did not get expected result {}".format(rset_team) - assert sched.rsets_free == 2, "rsets_free should be 2. Found {}".format(sched.rsets_free) + assert rset_team == [0, 1, 2, 4, 5, 6], f"Even split test did not get expected result {rset_team}" + assert sched.rsets_free == 2, f"rsets_free should be 2. Found {sched.rsets_free}" assert sched.avail_rsets_by_group == {0: [3], 1: [7]} # Now find the remaining 2 slots @@ -236,7 +236,7 @@ def test_across_nodes_even_split(): _fail_to_resource(sched, 2) else: rset_team = sched.assign_resources(rsets_req=2) - assert rset_team == [3, 7], "rsets found {}".format(rset_team) + assert rset_team == [3, 7], f"rsets found {rset_team}" assert sched.rsets_free == 0 assert sched.avail_rsets_by_group == {0: [], 1: []} del sched @@ -255,7 +255,7 @@ def test_across_nodes_even_split(): _fail_to_resource(sched, 6) else: rset_team = sched.assign_resources(rsets_req=6) - assert rset_team == [3, 4, 8, 9, 13, 14], "rsets found {}".format(rset_team) + assert rset_team == [3, 4, 8, 9, 13, 14], f"rsets found {rset_team}" del sched rset_team = None @@ -264,7 +264,7 @@ def test_across_nodes_even_split(): def test_across_nodes_roundup_option_2nodes(): """Tests assignment over two nodes""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) # Options should make no difference @@ -274,8 +274,8 @@ def test_across_nodes_roundup_option_2nodes(): sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=5) # Expecting even split - assert rset_team == [0, 1, 2, 4, 5, 6], "Even split test did not get expected result {}".format(rset_team) - assert sched.rsets_free == 2, "Free slots found {}".format(sched.rsets_free) + assert rset_team == [0, 1, 2, 4, 5, 6], f"Even split test did not get expected result {rset_team}" + assert sched.rsets_free == 2, f"Free slots found {sched.rsets_free}" del sched rset_team = None del resources @@ -283,7 +283,7 @@ def test_across_nodes_roundup_option_2nodes(): def test_across_nodes_roundup_option_3nodes(): """Tests assignment over two nodes""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(9, 3) # Options should make no difference @@ -296,7 +296,7 @@ def test_across_nodes_roundup_option_3nodes(): assert rset_team == [0, 1, 2, 3, 4, 5, 6, 7, 8], "Even split test did not get expected result {}".format( rset_team ) - assert sched.rsets_free == 0, "Free slots found {}".format(sched.rsets_free) + assert sched.rsets_free == 0, f"Free slots found {sched.rsets_free}" del sched rset_team = None del resources @@ -304,7 +304,7 @@ def test_across_nodes_roundup_option_3nodes(): def test_try1node_findon_2nodes_matching_slots(): """Tests finding gaps on two nodes with matching slots""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) fixed_assignments = [ @@ -333,7 +333,7 @@ def test_try1node_findon_2nodes_matching_slots(): def test_try1node_findon_2nodes_different_slots(): """Tests finding gaps on two nodes with non-matching slots""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) fixed_assignments = [ @@ -358,7 +358,7 @@ def test_try1node_findon_2nodes_different_slots(): # Now with match slots False and split2fit True - should find. sched.split2fit = True rset_team = sched.assign_resources(rsets_req=4) - assert rset_team == exp_out[i], "Expected {}, Received rset_team {}".format(exp_out[i], rset_team) + assert rset_team == exp_out[i], f"Expected {exp_out[i]}, Received rset_team {rset_team}" del sched rset_team = None @@ -367,7 +367,7 @@ def test_try1node_findon_2nodes_different_slots(): def test_try1node_findon_3nodes(): """Tests finding gaps on two nodes as cannot fit on one due to others assigned""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(12, 3) resources.fixed_assignment(([1, 1, 0, 0, 0, 2, 2, 0, 3, 0, 3, 3])) sched = ResourceScheduler(user_resources=resources) @@ -380,7 +380,7 @@ def test_try1node_findon_3nodes(): del sched sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=3) - assert rset_team == [2, 4, 9], "rsets found {}".format(rset_team) + assert rset_team == [2, 4, 9], f"rsets found {rset_team}" # Without split2fit, will not split over nodes. sched_options = {"match_slots": False, "split2fit": False} @@ -393,7 +393,7 @@ def test_try1node_findon_3nodes(): del sched sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=3) - assert rset_team == [0, 1, 2], "rsets found {}".format(rset_team) + assert rset_team == [0, 1, 2], f"rsets found {rset_team}" del resources @@ -421,21 +421,21 @@ def test_try2nodes_findon_3nodes(): assigned: 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 """ - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(18, 3) resources.fixed_assignment(([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3])) sched = ResourceScheduler(user_resources=resources) # Can't find 2 groups of 6 so find 3 groups of 4 - with matching slots. rset_team = sched.assign_resources(rsets_req=12) - assert rset_team == [0, 2, 3, 4, 6, 8, 9, 10, 12, 14, 15, 16], "rsets found {}".format(rset_team) + assert rset_team == [0, 2, 3, 4, 6, 8, 9, 10, 12, 14, 15, 16], f"rsets found {rset_team}" # Without matching slots, will find first available slots on each node. sched_options = {"match_slots": False} del sched sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=12) - assert rset_team == [0, 2, 3, 4, 6, 7, 8, 9, 12, 13, 14, 15], "rsets found {}".format(rset_team) + assert rset_team == [0, 2, 3, 4, 6, 7, 8, 9, 12, 13, 14, 15], f"rsets found {rset_team}" # Simulate a new call to allocation function with split2fit False - unable to split to 3 nodes. sched_options = {"match_slots": False, "split2fit": False} @@ -453,18 +453,18 @@ def test_try2nodes_findon_3nodes(): del sched sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=12) - assert rset_team == [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "rsets found {}".format(rset_team) + assert rset_team == [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], f"rsets found {rset_team}" del sched sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) rset_team = sched.assign_resources(rsets_req=12) - assert rset_team == [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "rsets found {}".format(rset_team) + assert rset_team == [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], f"rsets found {rset_team}" del resources def test_split2fit_even_required_fails(): """Test tries one node then two, and both fail""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) resources.fixed_assignment(([1, 1, 1, 0, 2, 2, 0, 0])) @@ -477,14 +477,14 @@ def test_split2fit_even_required_fails(): def test_split2fit_even_required_various(): """Tests trying to fit to an non-even partition, and setting of local rsets_free""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(8, 2) resources.fixed_assignment(([1, 1, 1, 0, 0, 0, 0, 0])) sched = ResourceScheduler(user_resources=resources) assert sched.rsets_free == 5 rset_team = sched.assign_resources(rsets_req=2) - assert rset_team == [4, 5], "rsets found {}".format(rset_team) + assert rset_team == [4, 5], f"rsets found {rset_team}" assert sched.rsets_free == 3 # In same alloc - now try getting 4 rsets, then 3 @@ -494,26 +494,26 @@ def test_split2fit_even_required_various(): assert sched.rsets_free == 3 rset_team = sched.assign_resources(rsets_req=2) - assert rset_team == [6, 7], "rsets found {}".format(rset_team) + assert rset_team == [6, 7], f"rsets found {rset_team}" assert sched.rsets_free == 1 def test_try1node_findon_2_or_4nodes(): """Tests splitting to fit. Needs 4 nodes if matching slots, else 2.""" - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") resources = MyResources(16, 4) resources.fixed_assignment(([1, 1, 0, 1, 2, 2, 0, 0, 1, 0, 0, 1, 0, 4, 0, 4])) sched = ResourceScheduler(user_resources=resources) rset_team = sched.assign_resources(rsets_req=4) - assert rset_team == [2, 6, 10, 14], "rsets found {}".format(rset_team) + assert rset_team == [2, 6, 10, 14], f"rsets found {rset_team}" del sched rset_team = None # I think should always do between tests (esp if expected output is the same). sched_options = {"match_slots": False} # will prob be default. sched = ResourceScheduler(user_resources=resources, sched_opts=sched_options) # noqa E702 rset_team = sched.assign_resources(rsets_req=4) - assert rset_team == [6, 7, 9, 10], "rsets found {}".format(rset_team) + assert rset_team == [6, 7, 9, 10], f"rsets found {rset_team}" del resources @@ -557,7 +557,7 @@ def test_large_match_slots(): To do this need enough slots at each step so tries to find, but in the wrong places, until final iteration. Performance is of interest. """ - print("\nTest: {}\n".format(sys._getframe().f_code.co_name)) + print(f"\nTest: {sys._getframe().f_code.co_name}\n") # Construct rset assignment resources = MyResources(256, 16) @@ -577,7 +577,7 @@ def test_large_match_slots(): assert rset_team == exp_out[match_slots], "Expected {}, Received rset_team {}".format( exp_out[match_slots], rset_team ) - print("Time for large problem (match_slots {}): {}".format(match_slots, time2)) + print(f"Time for large problem (match_slots {match_slots}): {time2}") del sched rset_team = None del resources diff --git a/libensemble/tests/unit_tests/test_resources.py b/libensemble/tests/unit_tests/test_resources.py index a98868ec48..fd2f249899 100644 --- a/libensemble/tests/unit_tests/test_resources.py +++ b/libensemble/tests/unit_tests/test_resources.py @@ -19,7 +19,7 @@ def teardown_standalone_run(): def setup_function(function): - print("setup_function function:%s" % function.__name__) + print(f"setup_function function:{function.__name__}") os.environ["LIBE_RESOURCES_TEST_NODE_LIST"] = "" # if os.environ['LIBE_RESOURCES_TEST_NODE_LIST']: # del os.environ['LIBE_RESOURCES_TEST_NODE_LIST'] @@ -30,7 +30,7 @@ def setup_function(function): def teardown_function(function): - print("teardown_function function:%s" % function.__name__) + print(f"teardown_function function:{function.__name__}") os.environ["LIBE_RESOURCES_TEST_NODE_LIST"] = "" # if os.environ['LIBE_RESOURCES_TEST_NODE_LIST']: # del os.environ['LIBE_RESOURCES_TEST_NODE_LIST'] @@ -259,7 +259,7 @@ def test_remove_libE_nodes(): def _assert_worker_attr(wres, attr, exp): ret = getattr(wres, attr) - assert ret == exp, "{} returned does not match expected. \nRet: {}\nExp: {}".format(attr, ret, exp) + assert ret == exp, f"{attr} returned does not match expected. \nRet: {ret}\nExp: {exp}" # These are all 1 worker per rset. 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/test_task_funcs.py b/libensemble/tests/unit_tests/test_task_funcs.py index 0c402a4103..e4472dfe31 100644 --- a/libensemble/tests/unit_tests/test_task_funcs.py +++ b/libensemble/tests/unit_tests/test_task_funcs.py @@ -7,21 +7,21 @@ def setup_module(module): - print("setup_module module:%s" % module.__name__) + print(f"setup_module module:{module.__name__}") if Executor.executor is not None: del Executor.executor Executor.executor = None def setup_function(function): - print("setup_function function:%s" % function.__name__) + print(f"setup_function function:{function.__name__}") if Executor.executor is not None: del Executor.executor Executor.executor = None def teardown_module(module): - print("teardown_module module:%s" % module.__name__) + print(f"teardown_module module:{module.__name__}") if Executor.executor is not None: del Executor.executor Executor.executor = None diff --git a/libensemble/tests/unit_tests/test_timer.py b/libensemble/tests/unit_tests/test_timer.py index eb7171e557..5dff0a4aa1 100644 --- a/libensemble/tests/unit_tests/test_timer.py +++ b/libensemble/tests/unit_tests/test_timer.py @@ -36,8 +36,8 @@ def test_timer(): assert s1[0:2] == "20", "Start year is 20xx" assert s2[0:2] == "20", "End year is 20xx" - s3 = "{}".format(timer) - assert s3 == "Time: {0:.3f} Start: {1} End: {2}".format(e3, s1, s2), "Check string formatting." + s3 = f"{timer}" + assert s3 == f"Time: {e3:.3f} Start: {s1} End: {s2}", "Check string formatting." time.sleep(0.2) time_start = time.time() 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..791364b4b0 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 @@ -178,11 +178,7 @@ def sim_work(self, wid, H, H_fields, H_rows, persis_info, **libE_info): "libE_info": libE_info, } - logger.debug( - "Alloc func packing SIM work for worker {}. Packing sim_ids: {}".format( - wid, EnsembleDirectory.extract_H_ranges(work) or None - ) - ) + logger.debug(f"Alloc func packing SIM work for worker {wid}. Packing sim_ids: {extract_H_ranges(work) or None}") return work def gen_work(self, wid, H_fields, H_rows, persis_info, **libE_info): @@ -222,11 +218,7 @@ def gen_work(self, wid, H_fields, H_rows, persis_info, **libE_info): "libE_info": libE_info, } - logger.debug( - "Alloc func packing GEN work for worker {}. Packing sim_ids: {}".format( - wid, EnsembleDirectory.extract_H_ranges(work) or None - ) - ) + logger.debug(f"Alloc func packing GEN work for worker {wid}. Packing sim_ids: {extract_H_ranges(work) or None}") return work def _filter_points(self, H_in, pt_filter, low_bound): @@ -320,14 +312,14 @@ def _check_H_rows(H_rows): try: H_rows = np.fromiter(H_rows, int) except Exception: - raise AllocException("H_rows could not be converted to a numpy array. Type {}".format(type(H_rows))) + raise AllocException(f"H_rows could not be converted to a numpy array. Type {type(H_rows)}") return H_rows @staticmethod def _check_H_fields(H_fields): """Ensure no duplicates in H_fields""" if len(H_fields) != len(set(H_fields)): - logger.debug("Removing duplicate field(s) when packing work request. {}".format(H_fields)) + logger.debug(f"Removing duplicate field(s) when packing work request. {H_fields}") H_fields = list(set(H_fields)) # H_fields = list(OrderedDict.fromkeys(H_fields)) # Maintain order return H_fields diff --git a/libensemble/tools/check_inputs.py b/libensemble/tools/check_inputs.py index 3f54c91c83..00e63362ba 100644 --- a/libensemble/tools/check_inputs.py +++ b/libensemble/tools/check_inputs.py @@ -14,10 +14,10 @@ def _check_consistent_field(name, field0, field1): """Checks that new field (field1) is compatible with an old field (field0).""" - assert field0.ndim == field1.ndim, "H0 and H have different ndim for field {}".format(name) + assert field0.ndim == field1.ndim, f"H0 and H have different ndim for field {name}" assert np.all( np.array(field1.shape) >= np.array(field0.shape) - ), "H too small to receive all components of H0 in field {}".format(name) + ), f"H too small to receive all components of H0 in field {name}" def check_libE_specs(libE_specs, serial_check=False): @@ -40,25 +40,19 @@ def check_libE_specs(libE_specs, serial_check=False): ) if k in ["ensemble_copy_back", "use_worker_dirs", "sim_dirs_make", "gen_dirs_make"]: - assert isinstance(libE_specs[k], bool), "Value for libE_specs['{}'] must be boolean".format(k) + assert isinstance(libE_specs[k], bool), f"Value for libE_specs['{k}'] must be boolean" if k in ["sim_input_dir", "gen_input_dir"]: - assert isinstance( - libE_specs[k], str - ), "Value for libE_specs['{}'] must be a single path-like string".format(k) - assert os.path.exists(libE_specs[k]), "libE_specs['{}'] does not refer to an existing path.".format(k) + assert isinstance(libE_specs[k], str), f"Value for libE_specs['{k}'] must be a single path-like string" + assert os.path.exists(libE_specs[k]), f"libE_specs['{k}'] does not refer to an existing path." if k == "ensemble_dir_path": - assert isinstance( - libE_specs[k], str - ), "Value for libE_specs['{}'] must be a single path-like string".format(k) + assert isinstance(libE_specs[k], str), f"Value for libE_specs['{k}'] must be a single path-like string" if k in ["sim_dir_copy_files", "sim_dir_symlink_files", "gen_dir_copy_files", "gen_dir_symlink_files"]: - assert isinstance( - libE_specs[k], list - ), "Value for libE_specs['{}'] must be a list of path-like strings".format(k) + assert isinstance(libE_specs[k], list), f"Value for libE_specs['{k}'] must be a list of path-like strings" for j in libE_specs[k]: - assert os.path.exists(j), "'{}' in libE_specs['{}'] does not refer to an existing path.".format(j, k) + assert os.path.exists(j), f"'{j}' in libE_specs['{k}'] does not refer to an existing path." def check_alloc_specs(alloc_specs): diff --git a/libensemble/tools/consensus_subroutines.py b/libensemble/tools/consensus_subroutines.py index f7f5ed680c..53394d094a 100644 --- a/libensemble/tools/consensus_subroutines.py +++ b/libensemble/tools/consensus_subroutines.py @@ -310,7 +310,7 @@ def readin_csv(fname): datas[i, :] = [float(val) for val in data[2:32]] i += 1 - assert i == n, "Expected {} datapoints, recorded {}".format(n, i) + assert i == n, f"Expected {n} datapoints, recorded {i}" return label, datas @@ -367,7 +367,7 @@ def regls_opt(X, y, c, reg=None): elif reg is None: p = -1 else: - assert False, 'illegal regularization "{}"'.format(reg) + assert False, f'illegal regularization "{reg}"' def obj_fn(X, y, beta, c, p): m = X.shape[0] diff --git a/libensemble/tools/parse_args.py b/libensemble/tools/parse_args.py index d365b33713..7e203c0e37 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 @@ -125,7 +129,7 @@ def _ssh_parse_args(args): str(nworkers), ] cmd = " ".join(cmd) - cmd = "( cd {} ; {} )".format(worker_pwd, cmd) + cmd = f"( cd {worker_pwd} ; {cmd} )" ssh.append(cmd) libE_specs = {"workers": args.workers, "worker_cmd": ssh, "ip": "localhost", "comms": "tcp"} return nworkers, True, libE_specs, args.tester_args @@ -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 @@ -228,5 +234,5 @@ def parse_args(): os.chdir(args.pwd) nworkers, is_manager, libE_specs, tester_args = front_ends[args.comms or "mpi"](args) if is_manager and unknown: - logger.warning("parse_args ignoring unrecognized arguments: {}".format(" ".join(unknown))) + logger.warning(f"parse_args ignoring unrecognized arguments: {' '.join(unknown)}") return nworkers, is_manager, libE_specs, tester_args diff --git a/libensemble/tools/persistent_support.py b/libensemble/tools/persistent_support.py index 0f302c077e..e23c0b83af 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__) @@ -21,15 +22,19 @@ def __init__(self, libE_info, calc_type): assert self.calc_type in [ EVAL_GEN_TAG, EVAL_SIM_TAG, - ], "The calc_type: {} specifies neither a simulator nor generator.".format(self.calc_type) + ], f"The calc_type: {self.calc_type} specifies neither a simulator nor generator." 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,19 +46,23 @@ 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, "calc_status": calc_status, "calc_type": self.calc_type, } - logger.debug("Persistent {} function sending data message to manager".format(self.calc_str)) + logger.debug(f"Persistent {self.calc_str} function sending data message to manager") self.comm.send(self.calc_type, D) 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 """ @@ -64,11 +73,11 @@ def recv(self, blocking=True): tag, Work = self.comm.recv() # Receive meta-data or signal if tag in [STOP_TAG, PERSIS_STOP]: - logger.debug("Persistent {} received signal {} from manager".format(self.calc_str, tag)) + logger.debug(f"Persistent {self.calc_str} received signal {tag} from manager") self.comm.push_to_buffer(tag, Work) return tag, Work, None else: - logger.debug("Persistent {} received work request from manager".format(self.calc_str)) + logger.debug(f"Persistent {self.calc_str} received work request from manager") # Update libE_info # self.libE_info = Work['libE_info'] @@ -81,13 +90,12 @@ def recv(self, blocking=True): # Check for unexpected STOP (e.g. error between sending Work info and rows) if data_tag in [STOP_TAG, PERSIS_STOP]: logger.debug( - "Persistent {} received signal {} ".format(self.calc_str, tag) - + "from manager while expecting work rows" + f"Persistent {self.calc_str} received signal {tag} " + "from manager while expecting work rows" ) self.comm.push_to_buffer(data_tag, calc_in) return data_tag, calc_in, None # calc_in is signal identifier - logger.debug("Persistent {} received work rows from manager".format(self.calc_str)) + logger.debug(f"Persistent {self.calc_str} received work rows from manager") return tag, Work, calc_in def send_recv(self, output, calc_status=UNSET_TAG): @@ -102,3 +110,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/tools/tools.py b/libensemble/tools/tools.py index c758eeaf78..f5cc5375e4 100644 --- a/libensemble/tools/tools.py +++ b/libensemble/tools/tools.py @@ -120,7 +120,7 @@ def save_libE_output(H, persis_info, calling_file, nworkers, mess="Run completed p_filename = short_name + "_persis_info_" + prob_str status_mess = " ".join(["------------------", mess, "-------------------"]) - logger.info("{}\nSaving results to file: {}".format(status_mess, h_filename)) + logger.info(f"{status_mess}\nSaving results to file: {h_filename}") np.save(h_filename, H) with open(p_filename + ".pickle", "wb") as f: 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/utils/timer.py b/libensemble/utils/timer.py index 1ff8362576..25832bb024 100644 --- a/libensemble/utils/timer.py +++ b/libensemble/utils/timer.py @@ -38,7 +38,7 @@ def __init__(self): def __str__(self): """Return a string representation of the timer.""" - return "Time: {0:.3f} Start: {1} End: {2}".format(self.total, self.date_start, self.date_end) + return f"Time: {self.total:.3f} Start: {self.date_start} End: {self.date_end}" @property def date_start(self): @@ -91,8 +91,8 @@ class TaskTimer(Timer): def __str__(self): """Return a string representation of the timer.""" - return "{0:.3f} Tstart: {1} Tend: {2}".format(self.total, self.date_start, self.date_end) + return f"{self.total:.3f} Tstart: {self.date_start} Tend: {self.date_end}" def summary(self): """Return the total time as a string""" - return "{0:.3f}".format(self.total) + return f"{self.total:.3f}" 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..649e3d2842 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""" @@ -218,7 +159,7 @@ def _set_executor(workerID, comm): exctr.set_worker_info(comm, workerID) # When merge update return True else: - logger.debug("No executor set on worker {}".format(workerID)) + logger.debug(f"No executor set on worker {workerID}") return False @staticmethod @@ -229,7 +170,7 @@ def _set_resources(workerID, comm): resources.set_worker_resources(comm.get_num_workers(), workerID) return True else: - logger.debug("No resources set on worker {}".format(workerID)) + logger.debug(f"No resources set on worker {workerID}") return False def _handle_calc(self, Work, calc_in): @@ -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 @@ -271,7 +212,7 @@ def _handle_calc(self, Work, calc_in): timer = Timer() try: - logger.debug("Starting {}: {}".format(enum_desc, calc_id)) + logger.debug(f"Starting {enum_desc}: {calc_id}") calc = self._run_calc[calc_type] with timer: if self.EnsembleDirectory.use_calc_dirs(calc_type): @@ -286,7 +227,7 @@ def _handle_calc(self, Work, calc_in): else: out = calc(calc_in, Work["persis_info"], Work["libE_info"]) - logger.debug("Returned from user function for {} {}".format(enum_desc, calc_id)) + logger.debug(f"Returned from user function for {enum_desc} {calc_id}") assert isinstance(out, tuple), "Calculation output must be a tuple." assert len(out) >= 2, "Calculation output must be at least two elements." @@ -305,7 +246,7 @@ def _handle_calc(self, Work, calc_in): return out[0], out[1], calc_status except Exception as e: - logger.debug("Re-raising exception from calc {}".format(e)) + logger.debug(f"Re-raising exception from calc {e}") calc_status = CALC_EXCEPTION raise finally: @@ -318,8 +259,7 @@ 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) + calc_msg = f"{enum_desc} {calc_id}: {calc_type} {timer}" if self.stats_fmt.get("task_timing", False) or self.stats_fmt.get("task_datetime", False): calc_msg += Executor.executor.new_tasks_timing(datetime=self.stats_fmt.get("task_datetime", False)) @@ -327,16 +267,15 @@ def _get_calc_msg(self, enum_desc, calc_id, calc_type, timer, status): if self.stats_fmt.get("show_resource_sets", False): # Maybe just call option resource_sets if already in sub-dictionary resources = Resources.resources.worker_resources - calc_msg += " rsets: {}".format(resources.rset_team) + calc_msg += f" rsets: {resources.rset_team}" # Always put status last as could involve different numbers of words. Some scripts may assume this. - calc_msg += " Status: {}".format(status) + calc_msg += f" Status: {status}" return calc_msg 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: @@ -344,14 +283,13 @@ def _recv_H_rows(self, Work): else: calc_in = np.zeros(0, dtype=self.dtypes[calc_type]) - logger.debug("Received calc_in ({}) of len {}".format(calc_type_strings[calc_type], np.size(calc_in))) + logger.debug(f"Received calc_in ({calc_type_strings[calc_type]}) of len {np.size(calc_in)}") assert calc_type in [EVAL_SIM_TAG, EVAL_GEN_TAG], "calc_type must either be EVAL_SIM_TAG or EVAL_GEN_TAG" return libE_info, calc_type, calc_in 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) @@ -374,7 +312,7 @@ def _handle(self, Work): return None # Otherwise, send a calc result back to manager - logger.debug("Sending to Manager with status {}".format(calc_status)) + logger.debug(f"Sending to Manager with status {calc_status}") return { "calc_out": calc_out, "persis_info": persis_info, @@ -385,12 +323,11 @@ def _handle(self, Work): def run(self): """Runs the main worker loop.""" - try: - logger.info("Worker {} initiated on node {}".format(self.workerID, socket.gethostname())) + logger.info(f"Worker {self.workerID} initiated on node {socket.gethostname()}") for worker_iter in count(start=1): - logger.debug("Iteration {}".format(worker_iter)) + logger.debug(f"Iteration {worker_iter}") mtag, Work = self.comm.recv() diff --git a/scripts/compare_npy.py b/scripts/compare_npy.py index 52237ea6f6..9fa509c446 100755 --- a/scripts/compare_npy.py +++ b/scripts/compare_npy.py @@ -53,7 +53,7 @@ [np.allclose(exp_results[name], results[name], rtol=rtol, atol=atol, equal_nan=True) for name in compare_fields] ) -print("Compare results: {}\n".format(match)) +print(f"Compare results: {match}\n") if not locate_mismatch: assert match, "Error: Results do NOT match" 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/scripts/plot_libe_histogram.py b/scripts/plot_libe_histogram.py index 3a29b7cb9e..94d026269e 100755 --- a/scripts/plot_libe_histogram.py +++ b/scripts/plot_libe_histogram.py @@ -81,14 +81,14 @@ def append_to_list(mylst, glob_list, found_time): exceptions = True append_to_list(in_times_exception, in_times, found_time) # Assumes Time comes first else: - print("Error: Unknown status - rest of line: {}".format(lst[i + 1 : len(lst)])) + print(f"Error: Unknown status - rest of line: {lst[i + 1:len(lst)]}") sys.exit() found_status = True if found_time and found_status: active_line_count += 1 break -print("Processed {} calcs".format(active_line_count)) +print(f"Processed {active_line_count} calcs") times = np.asarray(in_times, dtype=float) times_ran = np.asarray(in_times_ran, dtype=float) 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",