vibe coded approach lets see how this works

Author: jlnav

docs/overview_usecases.rst

@@ -53,8 +53,8 @@ to support):
 .. dropdown:: **Click Here for Use-Cases**
 
   * A user wants to optimize a simulation calculation. The simulation may
-    already be using parallel resources but not a large fraction of a 
-    computer. libEnsemble can coordinate concurrent evaluations of the 
+    already be using parallel resources but not a large fraction of a
+    computer. libEnsemble can coordinate concurrent evaluations of the
     simulation ``sim_f`` at multiple parameter values based on candidate parameter
     values produced by ``gen_f`` (possibly after each ``sim_f`` output).
 
@@ -117,7 +117,7 @@ its capabilities.
   * **User function**: A generator, simulator, or allocation function. These
     Python functions govern the libEnsemble workflow. They
     must conform to the libEnsemble API for each respective user function, but otherwise can
-    be created or modified by the user. 
+    be created or modified by the user.
     libEnsemble includes many examples of each type.
 
   * **Executor**: The executor provides a simple, portable interface for
@@ -138,15 +138,14 @@ its capabilities.
     allowing them to maintain and update data structures efficiently. These
     calculations and their assigned workers are referred to as *persistent*.
 
-  * **Resource Manager**: libEnsemble includes a built-in resource manager that can detect 
+  * **Resource Manager**: libEnsemble includes a built-in resource manager that can detect
     (or be provided with) available resources (e.g., a node list). Resources are
     divided among workers using *resource sets* and can be dynamically
     reassigned.
 
   * **Resource Set**: The smallest unit of resources that can be assigned (and
     dynamically reassigned) to workers. By default this is the provisioned resources
-    divided by the number of workers (excluding any workers listed in the 
-    ``zero_resource_workers`` ``libE_specs`` option). It can also be set
+    divided by the number of workers. It can also be set
     explicitly using the ``num_resource_sets`` ``libE_specs`` option.
 
   * **Slot**: Resource sets enumerated on a node (starting from zero). If

docs/resource_manager/overview.rst

@@ -33,8 +33,7 @@ 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`` :class:`libE_specs<libensemble.specs.LibeSpecs>` option).
+divided by the number of workers.
 However, it can also be set directly by the ``num_resource_sets``
 :class:`libE_specs<libensemble.specs.LibeSpecs>` option. If the latter is set, the
 dynamic resource assignment algorithm will always be used.
@@ -217,20 +216,12 @@ Persistent generator
 You have *one* persistent generator and want *eight* workers to run concurrent
 simulations. In this case you can run with *nine* workers.
 
-Either explicitly set eight resource sets (recommended):
+Explicitly set eight resource sets (recommended):
 
 .. code-block:: python
 
     libE_specs["num_resource_sets"] = 8
 
-Or if the generator should always be the same worker, use one zero-resource worker:
-
-.. code-block:: python
-
-    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:
 
 .. image:: ../images/variable_resources_persis_gen1.png

docs/resource_manager/resources_index.rst

@@ -16,7 +16,6 @@ from doing any resource detection or management.
    :titlesonly:
    :caption: Resource Manager:
 
-   Zero-resource workers (e.g., Persistent gen does not need resources) <zero_resource_workers>
    overview
    resource_detection
    scheduler_module

docs/tutorials/forces_gpu_tutorial.rst

@@ -35,6 +35,7 @@ from the simple forces example are highlighted:
     # Optional - to print GPU settings
     from libensemble.tools.test_support import check_gpu_setting
 
+
     def run_forces(H, persis_info, sim_specs, libE_info):
         """Launches the forces MPI app and auto-assigns ranks and GPU resources.
 
@@ -153,6 +154,7 @@ and use this information however you want.
             output = np.zeros(1, dtype=sim_specs["out"])
             output["energy"][0] = final_energy
 
+
         return output
 
     The above code will assign a GPU to each worker on CUDA-capable systems,
@@ -214,7 +216,6 @@ For example::
 
     python run_libe_forces.py --nworkers 9
 
-See :ref:`zero-resource workers<zero_resource_workers>` for more ways to express this.
 
 Changing the number of GPUs per worker
 --------------------------------------

libensemble/alloc_funcs/start_only_persistent.py

@@ -15,8 +15,8 @@ def only_persistent_gens(W, H, sim_specs, gen_specs, alloc_specs, persis_info, l
     If ``gen_specs["async_return"]`` or ``alloc_specs["user"]["async_return"]`` is set to True, then any
     returned points are given back to the generator.
 
-    If any workers are marked as zero_resource_workers, then these will only
-    be used for generators.
+    "" or ``alloc_specs["user"]["num_active_gens"]``
+    persistent generators (defaulting to one).
 
     If any of the persistent generators has exited, then ensemble shutdown
     is triggered.
@@ -94,11 +94,10 @@ def only_persistent_gens(W, H, sim_specs, gen_specs, alloc_specs, persis_info, l
 
     # Now the give_sim_work_first part
     points_to_evaluate = ~H["sim_started"] & ~H["cancel_requested"]
-    avail_workers = support.avail_worker_ids(persistent=False, zero_resource_workers=False, gen_workers=False)
+    avail_workers = support.avail_worker_ids(persistent=False, gen_workers=False)
     if user.get("alt_type"):
         avail_workers = list(
-            set(support.avail_worker_ids(persistent=False, zero_resource_workers=False))
-            | set(support.avail_worker_ids(persistent=EVAL_SIM_TAG, zero_resource_workers=False))
+            set(support.avail_worker_ids(persistent=False)) | set(support.avail_worker_ids(persistent=EVAL_SIM_TAG))
         )
     for wid in avail_workers:
         if not np.any(points_to_evaluate):
@@ -118,9 +117,9 @@ def only_persistent_gens(W, H, sim_specs, gen_specs, alloc_specs, persis_info, l
 
         points_to_evaluate[sim_ids_to_send] = False
 
-    # Start persistent gens if no worker to give out. Uses zero_resource_workers if defined.
+    # Start persistent gens if no worker to give out.
     if not np.any(points_to_evaluate):
-        avail_workers = support.avail_worker_ids(persistent=False, zero_resource_workers=True, gen_workers=True)
+        avail_workers = support.avail_worker_ids(persistent=False, gen_workers=True)
 
         for wid in avail_workers:
             if gen_count < user.get("num_active_gens", 1):

libensemble/manager.py

@@ -165,7 +165,6 @@ class Manager:
         ("persis_state", int),
         ("active_recv", bool),
         ("gen_started_time", float),
-        ("zero_resource_worker", bool),
     ]
 
     def _run_additional_worker(self, hist, sim_specs, gen_specs, libE_specs):
@@ -252,9 +251,6 @@ def __init__(
         if self.resources is not None:
             gresource = self.resources.glob_resources
             self.scheduler_opts = gresource.update_scheduler_opts(self.scheduler_opts)
-            for wrk in self.W:
-                if wrk["worker_id"] in gresource.zero_resource_workers:
-                    wrk["zero_resource_worker"] = True
 
         for wrk in self.W:
             if wrk["worker_id"] in self.libE_specs.get("gen_workers", []):

libensemble/resources/resources.py

@@ -96,8 +96,6 @@ class GlobalResources:
     :ivar list global_nodelist: list of all nodes available for running user applications
     :ivar int logical_cores_avail_per_node: Logical cores (including SMT threads) available on a node
     :ivar int physical_cores_avail_per_node: Physical cores available on a node
-    :ivar list zero_resource_workers: List of workerIDs to have no resources.
-    :ivar bool dedicated_mode: Whether to remove libE nodes from global nodelist.
     :ivar int num_resource_sets: Number of resource sets, if supplied by the user.
     """
 
@@ -121,12 +119,9 @@ def __init__(self, libE_specs: dict, platform_info: dict = {}, top_level_dir: st
             will not be available to worker-launched tasks (user applications). They will
             be removed from the nodelist (if present), before dividing into resource sets.
 
-        zero_resource_workers: List[int], Optional
-            List of workers that require no resources.
-
         num_resource_sets: int, Optional
             The total number of resource sets. Resources will be divided into this number.
-            Default: None. If None, resources will be divided by workers (excluding zero_resource_workers).
+            Default: None. If None, resources will be divided by workers.
 
         cores_on_node: tuple (int, int), Optional
             If supplied gives (physical cores, logical cores) for the nodes. If not supplied,
@@ -166,7 +161,6 @@ def __init__(self, libE_specs: dict, platform_info: dict = {}, top_level_dir: st
         """
         self.top_level_dir = top_level_dir
         self.dedicated_mode = libE_specs.get("dedicated_mode", False)
-        self.zero_resource_workers = libE_specs.get("zero_resource_workers", [])
         self.num_resource_sets = libE_specs.get("num_resource_sets", None)
         self.enforce_worker_core_bounds = libE_specs.get("enforce_worker_core_bounds", False)
         self.gpus_per_group = libE_specs.get("gpus_per_group")

libensemble/resources/rset_resources.py

@@ -129,8 +129,7 @@ def get_rsets_on_a_node(num_rsets, resources):
     @staticmethod
     def get_workers2assign2(num_workers, resources):
         """Returns workers to assign resources to"""
-        zero_resource_list = resources.zero_resource_workers
-        return num_workers - len(zero_resource_list)
+        return num_workers
 
     @staticmethod
     def even_assignment(nnodes, nworkers):

libensemble/resources/worker_resources.py

@@ -3,7 +3,7 @@
 import logging
 import os
 from collections import Counter, OrderedDict
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -51,7 +51,6 @@ def __init__(self, num_workers: int, resources: GlobalResources) -> None:
         self.index_list = ResourceManager.get_index_list(
             self.num_workers,
             self.total_num_rsets,
-            resources.zero_resource_workers,
         )
 
         self.rsets = np.zeros(self.total_num_rsets, dtype=ResourceManager.man_rset_dtype)
@@ -102,20 +101,17 @@ def free_rsets(self, worker=None):
             self.nongpu_rsets_free += np.count_nonzero(~self.rsets["gpus"][rsets_to_free])
 
     @staticmethod
-    def get_index_list(num_workers: int, num_rsets: int, zero_resource_list: list[int | Any]) -> list[int | None]:
+    def get_index_list(num_workers: int, num_rsets: int) -> list[int | None]:
         """Map WorkerID to index into a nodelist"""
         index = 0
         index_list = []
         for i in range(1, num_workers + 1):
-            if i in zero_resource_list:
+            if index >= num_rsets:
+                # Not enough rsets
                 index_list.append(None)
             else:
-                if index >= num_rsets:
-                    # Not enough rsets
-                    index_list.append(None)
-                else:
-                    index_list.append(index)
-                index += 1
+                index_list.append(index)
+            index += 1
         return index_list
 
 
@@ -197,7 +193,6 @@ def __init__(self, num_workers, resources, workerID):
         self.matching_slots = True
         self.slot_count = None
         self.slots_on_node = None
-        self.zero_resource_workers = resources.zero_resource_workers
         self.local_node_count = len(self.local_nodelist)
         self.set_slot_count()
         self.gen_nprocs = None
@@ -306,9 +301,6 @@ def set_rset_team(self, rset_team: list[int]) -> None:
                  slot_count - number of slots on each node
                  local_node_count
         """
-        if self.workerID in self.zero_resource_workers:
-            return
-
         if rset_team != self.rset_team:  # Order matters
             self.rset_team = rset_team
             self.num_rsets = len(rset_team)

libensemble/specs.py

@@ -635,7 +635,7 @@ class LibeSpecs(BaseModel):
     num_resource_sets: int | None = 0
     """
     Total number of resource sets. Resources will be divided into this number.
-    If not set, resources will be divided evenly (excluding zero_resource_workers).
+    If not set, resources will be divided evenly by the number of workers.
     """
 
     gen_num_procs: int | None = 0
@@ -681,13 +681,6 @@ class LibeSpecs(BaseModel):
     libEnsemble processes (manager and workers) are running.
     """
 
-    zero_resource_workers: list[int] | None = []
-    """
-    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.
-    """
-
     gen_workers: list[int] | None = []
     """
     list of workers that should only run generators. All other workers will only