parsl 2025.8.4__py3-none-any.whl → 2025.11.10__py3-none-any.whl

parsl/jobs/strategy.py

@@ -185,6 +185,11 @@ class Strategy:
 
         for executor in executors:
             label = executor.label
+
+            if executor.bad_state_is_set:
+                logger.info(f"Not strategizing for executor {label} because bad state is set")
+                continue
+
             logger.debug(f"Strategizing for executor {label}")
 
             if self.executors[label]['first']:
@@ -213,12 +218,8 @@ class Strategy:
 
             logger.debug(f"Slot ratio calculation: active_slots = {active_slots}, active_tasks = {active_tasks}")
 
-            if hasattr(executor, 'connected_workers'):
-                logger.debug('Executor {} has {} active tasks, {}/{} running/pending blocks, and {} connected workers'.format(
-                    label, active_tasks, running, pending, executor.connected_workers))
-            else:
-                logger.debug('Executor {} has {} active tasks and {}/{} running/pending blocks'.format(
-                    label, active_tasks, running, pending))
+            logger.debug('Executor {} has {} active tasks and {}/{} running/pending blocks'.format(
+                label, active_tasks, running, pending))
 
             # reset idle timer if executor has active tasks
 

parsl/monitoring/db_manager.py

@@ -18,7 +18,7 @@ from parsl.monitoring.types import MonitoringMessage, TaggedMonitoringMessage
 from parsl.process_loggers import wrap_with_logs
 from parsl.utils import setproctitle
 
-logger = logging.getLogger("database_manager")
+logger = logging.getLogger(__name__)
 
 X = TypeVar('X')
 
@@ -293,13 +293,10 @@ class DatabaseManager:
         self.run_dir = run_dir
         os.makedirs(self.run_dir, exist_ok=True)
 
-        logger.propagate = False
-
         set_file_logger(f"{self.run_dir}/database_manager.log", level=logging_level,
-                        format_string="%(asctime)s.%(msecs)03d %(name)s:%(lineno)d [%(levelname)s] [%(threadName)s %(thread)d] %(message)s",
-                        name="database_manager")
+                        format_string="%(asctime)s.%(msecs)03d %(name)s:%(lineno)d [%(levelname)s] [%(threadName)s %(thread)d] %(message)s")
 
-        logger.debug("Initializing Database Manager process")
+        logger.info("Initializing Database Manager process")
 
         self.db = Database(db_url)
         self.batching_interval = batching_interval
@@ -349,9 +346,9 @@ class DatabaseManager:
         exception_happened = False
 
         while (not self._kill_event.is_set() or
-               self.pending_priority_queue.qsize() != 0 or self.pending_resource_queue.qsize() != 0 or
-               self.pending_node_queue.qsize() != 0 or self.pending_block_queue.qsize() != 0 or
-               resource_queue.qsize() != 0):
+               not self.pending_priority_queue.empty() or not self.pending_resource_queue.empty() or
+               not self.pending_node_queue.empty() or not self.pending_block_queue.empty() or
+               not resource_queue.empty()):
 
             """
             WORKFLOW_INFO and TASK_INFO messages (i.e. priority messages)
@@ -360,9 +357,9 @@ class DatabaseManager:
             try:
                 logger.debug("""Checking STOP conditions: {}, {}, {}, {}, {}, {}""".format(
                                   self._kill_event.is_set(),
-                                  self.pending_priority_queue.qsize() != 0, self.pending_resource_queue.qsize() != 0,
-                                  self.pending_node_queue.qsize() != 0, self.pending_block_queue.qsize() != 0,
-                                  resource_queue.qsize() != 0))
+                                  not self.pending_priority_queue.empty(), not self.pending_resource_queue.empty(),
+                                  not self.pending_node_queue.empty(), not self.pending_block_queue.empty(),
+                                  not resource_queue.empty()))
 
                 # This is the list of resource messages which can be reprocessed as if they
                 # had just arrived because the corresponding first task message has been
@@ -512,7 +509,7 @@ class DatabaseManager:
                             msg['task_status_name'] = States.running.name
                             msg['task_try_time_running'] = msg['timestamp']
 
-                            if task_try_id in inserted_tries:  # TODO: needs to become task_id and try_id, and check against inserted_tries
+                            if task_try_id in inserted_tries:
                                 reprocessable_first_resource_messages.append(msg)
                             else:
                                 if task_try_id in deferred_resource_messages:
@@ -550,19 +547,20 @@ class DatabaseManager:
                     "or some other error. monitoring data may have been lost"
                 )
                 exception_happened = True
+
+            if self.external_exit_event.is_set():
+                self.close()
+
         if exception_happened:
             raise RuntimeError("An exception happened sometime during database processing and should have been logged in database_manager.log")
 
-    @wrap_with_logs(target="database_manager")
-    def _migrate_logs_to_internal(self, logs_queue: queue.Queue, kill_event: threading.Event) -> None:
+    @wrap_with_logs
+    def _migrate_logs_to_internal(self, logs_queue: mpq.Queue, kill_event: threading.Event) -> None:
         logger.info("Starting _migrate_logs_to_internal")
 
-        while not kill_event.is_set() or logs_queue.qsize() != 0:
+        while not kill_event.is_set() or not logs_queue.empty():
             logger.debug("Checking STOP conditions: kill event: %s, queue has entries: %s",
-                         kill_event.is_set(), logs_queue.qsize() != 0)
-
-            if self.external_exit_event.is_set():
-                self.close()
+                         kill_event.is_set(), not logs_queue.empty())
 
             try:
                 x = logs_queue.get(timeout=0.1)
@@ -583,10 +581,10 @@ class DatabaseManager:
         elif x[0] == MessageType.NODE_INFO:
             assert len(x) == 2, "expected NODE_INFO tuple to have exactly two elements"
 
-            logger.info("Will put {} to pending node queue".format(x[1]))
+            logger.debug("Will put {} to pending node queue".format(x[1]))
             self.pending_node_queue.put(x[1])
         elif x[0] == MessageType.BLOCK_INFO:
-            logger.info("Will put {} to pending block queue".format(x[1]))
+            logger.debug("Will put {} to pending block queue".format(x[1]))
             self.pending_block_queue.put(x[-1])
         else:
             logger.error("Discarding message of unknown type {}".format(x[0]))
@@ -682,7 +680,7 @@ class DatabaseManager:
         self._kill_event.set()
 
 
-@wrap_with_logs(target="database_manager")
+@wrap_with_logs
 @typeguard.typechecked
 def dbm_starter(resource_msgs: mpq.Queue,
                 db_url: str,

parsl/monitoring/monitoring.py

@@ -11,9 +11,9 @@ import typeguard
 
 from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.multiprocessing import (
-    SizedQueue,
     SpawnEvent,
     SpawnProcess,
+    SpawnQueue,
     join_terminate_close_proc,
 )
 from parsl.utils import RepresentationMixin
@@ -126,7 +126,7 @@ class MonitoringHub(RepresentationMixin):
         self.monitoring_hub_active = True
 
         self.resource_msgs: Queue[TaggedMonitoringMessage]
-        self.resource_msgs = SizedQueue()
+        self.resource_msgs = SpawnQueue()
 
         self.dbm_exit_event: ms.Event
         self.dbm_exit_event = SpawnEvent()

parsl/monitoring/radios/filesystem.py

@@ -10,11 +10,12 @@ from parsl.monitoring.radios.base import (
     RadioConfig,
 )
 from parsl.monitoring.radios.filesystem_router import FilesystemRadioReceiver
+from parsl.utils import RepresentationMixin
 
 logger = logging.getLogger(__name__)
 
 
-class FilesystemRadio(RadioConfig):
+class FilesystemRadio(RadioConfig, RepresentationMixin):
     """A MonitoringRadioSender that sends messages over a shared filesystem.
 
     The messsage directory structure is based on maildir,

parsl/monitoring/radios/htex.py

@@ -7,11 +7,12 @@ from parsl.monitoring.radios.base import (
     MonitoringRadioSender,
     RadioConfig,
 )
+from parsl.utils import RepresentationMixin
 
 logger = logging.getLogger(__name__)
 
 
-class HTEXRadio(RadioConfig):
+class HTEXRadio(RadioConfig, RepresentationMixin):
     def create_sender(self) -> MonitoringRadioSender:
         return HTEXRadioSender()
 

parsl/monitoring/radios/multiprocessing.py

@@ -5,9 +5,10 @@ from parsl.monitoring.radios.base import (
     MonitoringRadioSender,
     RadioConfig,
 )
+from parsl.utils import RepresentationMixin
 
 
-class MultiprocessingQueueRadioSender(MonitoringRadioSender):
+class MultiprocessingQueueRadioSender(MonitoringRadioSender, RepresentationMixin):
     """A monitoring radio which connects over a multiprocessing Queue.
     This radio is intended to be used on the submit side, where components
     in the submit process, or processes launched by multiprocessing, will have

parsl/monitoring/radios/udp.py

@@ -13,11 +13,12 @@ from parsl.monitoring.radios.base import (
     RadioConfig,
 )
 from parsl.monitoring.radios.udp_router import start_udp_receiver
+from parsl.utils import RepresentationMixin
 
 logger = logging.getLogger(__name__)
 
 
-class UDPRadio(RadioConfig):
+class UDPRadio(RadioConfig, RepresentationMixin):
     def __init__(self, *, port: Optional[int] = None, atexit_timeout: int = 3, address: str, debug: bool = False, hmac_digest: str = 'sha512'):
         self.port = port
         self.atexit_timeout = atexit_timeout

parsl/monitoring/radios/udp_router.py

@@ -21,9 +21,9 @@ from parsl.monitoring.errors import MonitoringRouterStartError
 from parsl.monitoring.radios.base import MonitoringRadioReceiver
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.multiprocessing import (
-    SizedQueue,
     SpawnEvent,
     SpawnProcess,
+    SpawnQueue,
     join_terminate_close_proc,
 )
 from parsl.process_loggers import wrap_with_logs
@@ -198,7 +198,7 @@ def start_udp_receiver(*,
                        hmac_digest: str) -> UDPRadioReceiver:
 
     udp_comm_q: Queue[Union[int, str]]
-    udp_comm_q = SizedQueue(maxsize=10)
+    udp_comm_q = SpawnQueue(maxsize=10)
 
     router_exit_event = SpawnEvent()
 

parsl/monitoring/radios/zmq_router.py

@@ -19,9 +19,9 @@ from parsl.monitoring.errors import MonitoringRouterStartError
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.multiprocessing import (
-    SizedQueue,
     SpawnEvent,
     SpawnProcess,
+    SpawnQueue,
     join_terminate_close_proc,
 )
 from parsl.process_loggers import wrap_with_logs
@@ -158,7 +158,7 @@ def start_zmq_receiver(*,
                        port_range: Tuple[int, int],
                        logdir: str,
                        worker_debug: bool) -> ZMQRadioReceiver:
-    comm_q = SizedQueue(maxsize=10)
+    comm_q = SpawnQueue(maxsize=10)
 
     router_exit_event = SpawnEvent()
 

parsl/multiprocessing.py

@@ -4,7 +4,6 @@
 import logging
 import multiprocessing
 import multiprocessing.queues
-import platform
 from multiprocessing.context import ForkProcess as ForkProcessType
 from multiprocessing.context import SpawnProcess as SpawnProcessType
 from typing import Callable
@@ -21,54 +20,6 @@ SpawnEvent = SpawnContext.Event
 SpawnQueue = SpawnContext.Queue
 
 
-class MacSafeQueue(multiprocessing.queues.Queue):
-    """ Multiprocessing queues do not have qsize attributes on MacOS.
-    This is slower but more portable version of the multiprocessing Queue
-    that adds a explicit counter
-
-    Reference : https://github.com/keras-team/autokeras/commit/4ddd568b06b4045ace777bc0fb7bc18573b85a75
-    """
-
-    def __init__(self, *args, **kwargs):
-        if 'ctx' not in kwargs:
-            kwargs['ctx'] = multiprocessing.get_context('spawn')
-        super().__init__(*args, **kwargs)
-        self._counter = multiprocessing.Value('i', 0)
-
-    def put(self, *args, **kwargs):
-        # logger.critical("Putting item {}".format(args))
-        x = super().put(*args, **kwargs)
-        with self._counter.get_lock():
-            self._counter.value += 1
-        return x
-
-    def get(self, *args, **kwargs):
-        x = super().get(*args, **kwargs)
-        with self._counter.get_lock():
-            self._counter.value -= 1
-        # logger.critical("Getting item {}".format(x))
-        return x
-
-    def qsize(self):
-        return self._counter.value
-
-    def empty(self):
-        return not self._counter.value
-
-
-# SizedQueue should be constructable using the same calling
-# convention as multiprocessing.Queue but that entire signature
-# isn't expressible in mypy 0.790
-SizedQueue: Callable[..., multiprocessing.Queue]
-
-
-if platform.system() != 'Darwin':
-    import multiprocessing
-    SizedQueue = SpawnQueue
-else:
-    SizedQueue = MacSafeQueue
-
-
 def join_terminate_close_proc(process: SpawnProcessType, *, timeout: int = 30) -> None:
     """Increasingly aggressively terminate a process.
 

parsl/providers/base.py

@@ -33,7 +33,28 @@ class ExecutionProvider(metaclass=ABCMeta):
           [cancel]     <--------|----+
                                 |
                                 +-------------------
-     """
+
+    In addition to the listed methods, an ExecutionProvider instance must always
+    have these attributes, which both default to `None`:
+
+      mem_per_node: Real memory to provision per node in GB.
+
+                    Providers which set this attribute should ask for mem_per_node of memory
+                    when provisioning resources, and set the corresponding environment
+                    variable PARSL_MEMORY_GB before executing submitted commands.
+
+                    If this attribute is set, executors may use it to calculate how many tasks can
+                    run concurrently per node.
+
+      cores_per_node: Number of cores to provision per node.
+
+                    Providers which set this attribute should ask for cores_per_node cores
+                    when provisioning resources, and set the corresponding environment
+                    variable PARSL_CORES before executing submitted commands.
+
+                    If this attribute is set, executors may use it to calculate how many tasks can
+                    run concurrently per node.
+    """
 
     @abstractmethod
     def __init__(self) -> None:
@@ -44,8 +65,8 @@ class ExecutionProvider(metaclass=ABCMeta):
         self.script_dir: Optional[str]
         self.parallelism: float
         self.resources: Dict[object, Any]
-        self._cores_per_node: Optional[int] = None
-        self._mem_per_node: Optional[float] = None
+        self.cores_per_node: Optional[int] = None
+        self.mem_per_node: Optional[float] = None
         pass
 
     @abstractmethod
@@ -111,40 +132,6 @@ class ExecutionProvider(metaclass=ABCMeta):
         ''' Provides the label for this provider '''
         pass
 
-    @property
-    def mem_per_node(self) -> Optional[float]:
-        """Real memory to provision per node in GB.
-
-        Providers which set this property should ask for mem_per_node of memory
-        when provisioning resources, and set the corresponding environment
-        variable PARSL_MEMORY_GB before executing submitted commands.
-
-        If this property is set, executors may use it to calculate how many tasks can
-        run concurrently per node.
-        """
-        return self._mem_per_node
-
-    @mem_per_node.setter
-    def mem_per_node(self, value: float) -> None:
-        self._mem_per_node = value
-
-    @property
-    def cores_per_node(self) -> Optional[int]:
-        """Number of cores to provision per node.
-
-        Providers which set this property should ask for cores_per_node cores
-        when provisioning resources, and set the corresponding environment
-        variable PARSL_CORES before executing submitted commands.
-
-        If this property is set, executors may use it to calculate how many tasks can
-        run concurrently per node.
-        """
-        return self._cores_per_node
-
-    @cores_per_node.setter
-    def cores_per_node(self, value: int) -> None:
-        self._cores_per_node = value
-
     @property
     @abstractmethod
     def status_polling_interval(self) -> int:

parsl/providers/pbspro/pbspro.py

@@ -96,7 +96,7 @@ class PBSProProvider(TorqueProvider):
 
         jobs_missing = list(self.resources.keys())
 
-        retcode, stdout, stderr = self.execute_wait("qstat -f -F json {0}".format(job_id_list))
+        retcode, stdout, stderr = self.execute_wait("qstat -x -f -F json {0}".format(job_id_list))
 
         # If qstat failed do not update job state
         if retcode != 0:

parsl/serialize/__init__.py

@@ -1,16 +1,13 @@
 from parsl.serialize.facade import (
     deserialize,
     pack_apply_message,
-    pack_res_spec_apply_message,
     serialize,
     unpack_apply_message,
-    unpack_res_spec_apply_message,
 )
 
-__all__ = ['serialize',
-           'deserialize',
-           'pack_apply_message',
-           'unpack_apply_message',
-           'unpack_res_spec_apply_message',
-           'pack_res_spec_apply_message'
-           ]
+__all__ = (
+    "serialize",
+    "deserialize",
+    "pack_apply_message",
+    "unpack_apply_message",
+)

parsl/serialize/facade.py

@@ -62,44 +62,12 @@ def pack_apply_message(func: Any, args: Any, kwargs: Any, buffer_threshold: int
     return packed_buffer
 
 
-def pack_res_spec_apply_message(func: Any, args: Any, kwargs: Any, resource_specification: Any, buffer_threshold: int = int(128 * 1e6)) -> bytes:
-    """Serialize and pack function, parameters, and resource_specification
-
-    Parameters
-    ----------
-
-    func: Function
-        A function to ship
-
-    args: Tuple/list of objects
-        positional parameters as a list
-
-    kwargs: Dict
-        Dict containing named parameters
-
-    resource_specification: Dict
-        Dict containing application resource specification
-
-    buffer_threshold: int
-        Limits buffer to specified size in bytes. Exceeding this limit would give you
-        a warning in the log. Default is 128MB.
-    """
-    return pack_apply_message(func, args, (kwargs, resource_specification), buffer_threshold=buffer_threshold)
-
-
 def unpack_apply_message(packed_buffer: bytes) -> List[Any]:
     """ Unpack and deserialize function and parameters
     """
     return [deserialize(buf) for buf in unpack_buffers(packed_buffer)]
 
 
-def unpack_res_spec_apply_message(packed_buffer: bytes) -> List[Any]:
-    """ Unpack and deserialize function, parameters, and resource_specification
-    """
-    func, args, (kwargs, resource_spec) = unpack_apply_message(packed_buffer)
-    return [func, args, kwargs, resource_spec]
-
-
 def serialize(obj: Any, buffer_threshold: int = int(1e6)) -> bytes:
     """ Try available serialization methods one at a time
 

parsl/tests/configs/local_threads_globus.py

@@ -1,6 +1,5 @@
 from parsl.config import Config
 from parsl.data_provider.data_manager import default_staging
-from parsl.data_provider.globus import GlobusStaging
 from parsl.executors.threads import ThreadPoolExecutor
 
 # If you are a developer running tests, make sure to update parsl/tests/configs/user_opts.py
@@ -10,19 +9,24 @@ from parsl.executors.threads import ThreadPoolExecutor
 #          (i.e., user_opts['swan']['username'] -> 'your_username')
 from .user_opts import user_opts
 
-storage_access = default_staging + [GlobusStaging(
-                endpoint_uuid=user_opts['globus']['endpoint'],
-                endpoint_path=user_opts['globus']['path']
-            )]
 
-config = Config(
-    executors=[
-        ThreadPoolExecutor(
-            label='local_threads_globus',
-            working_dir=user_opts['globus']['path'],
-            storage_access=storage_access
-        )
-    ]
-)
+def fresh_config():
+    from parsl.data_provider.globus import GlobusStaging
+
+    storage_access = default_staging + [GlobusStaging(
+                    endpoint_uuid=user_opts['globus']['endpoint'],
+                    endpoint_path=user_opts['globus']['path']
+                )]
+
+    return Config(
+        executors=[
+            ThreadPoolExecutor(
+                label='local_threads_globus',
+                working_dir=user_opts['globus']['path'],
+                storage_access=storage_access
+            )
+        ]
+    )
+
 
 remote_writeable = user_opts['globus']['remote_writeable']

parsl/tests/configs/taskvine_ex.py

@@ -7,4 +7,4 @@ from parsl.executors.taskvine import TaskVineExecutor, TaskVineManagerConfig
 
 def fresh_config():
     return Config(executors=[TaskVineExecutor(manager_config=TaskVineManagerConfig(port=9000),
-                                              worker_launch_method='factory')])
+                                              worker_launch_method='provider')])

parsl/tests/manual_tests/test_memory_limits.py

@@ -53,7 +53,7 @@ def test_simple(mem_per_worker):
     # Prime a worker
     double(5).result()
     dfk = parsl.dfk()
-    connected = dfk.executors['htex_local'].connected_workers
+    connected = dfk.executors['htex_local'].connected_workers()
     print("Connected : ", connected)
     assert expected_workers == connected, "Expected {} workers, instead got {} workers".format(expected_workers,
                                                                                                connected)

parsl/tests/sites/test_concurrent.py

@@ -1,7 +1,7 @@
 """Tests of the interfaces to Python's concurrent library"""
-from pytest import mark, warns
+from pytest import mark, raises, warns
 
-from parsl import Config, HighThroughputExecutor
+from parsl import Config, HighThroughputExecutor, load, python_app
 from parsl.concurrent import ParslPoolExecutor
 
 
@@ -9,21 +9,43 @@ def f(x):
     return x + 1
 
 
+def g(x):
+    return 2 * x
+
+
+@python_app
+def is_odd(x):
+    if x % 2 == 1:
+        return 1
+    else:
+        return 0
+
+
 def make_config():
     return Config(
         executors=[
             HighThroughputExecutor(
+                label='test_executor',
                 address="127.0.0.1",
                 max_workers_per_node=2,
                 heartbeat_period=2,
                 heartbeat_threshold=4,
-                encrypted=True,
+                encrypted=False,
             )
         ],
         strategy='none',
     )
 
 
+@mark.local
+def test_init_errors():
+    with load(make_config()) as dfk, raises(ValueError, match='Specify only one of config or dfk'):
+        ParslPoolExecutor(config=make_config(), dfk=dfk)
+
+    with raises(ValueError, match='Must specify one of config or dfk'):
+        ParslPoolExecutor()
+
+
 @mark.local
 def test_executor():
     my_config = make_config()
@@ -44,5 +66,31 @@ def test_executor():
         # Make sure only one function was registered
         assert exc.app_count == 1
 
+    with raises(RuntimeError, match='shut down'):
+        exc.submit(f, 1)
+
     with warns(UserWarning):
         ParslPoolExecutor(make_config()).shutdown(False, cancel_futures=True)
+
+
+@mark.local
+def test_with_dfk():
+    config = make_config()
+
+    with load(config) as dfk, ParslPoolExecutor(dfk=dfk, executors=['test_executor']) as exc:
+        future = exc.submit(f, 1)
+        assert future.result() == 2
+        assert exc.get_app(f).executors == ['test_executor']
+
+
+@mark.local
+def test_chaining():
+    """Make sure the executor functions can be chained together"""
+    config = make_config()
+
+    with ParslPoolExecutor(config) as exc:
+        future_odd = exc.submit(f, 10)
+        assert is_odd(future_odd).result()
+
+        future_even = exc.submit(g, future_odd)
+        assert not is_odd(future_even).result()

parsl/tests/test_checkpointing/test_periodic.py

@@ -2,11 +2,17 @@ import pytest
 
 import parsl
 from parsl.app.app import python_app
-from parsl.tests.configs.local_threads_checkpoint_periodic import fresh_config
+from parsl.config import Config
+from parsl.executors.threads import ThreadPoolExecutor
 
 
-def local_setup():
-    parsl.load(fresh_config())
+def fresh_config():
+    tpe = ThreadPoolExecutor(label='local_threads_checkpoint_periodic', max_threads=1)
+    return Config(
+        executors=[tpe],
+        checkpoint_mode='periodic',
+        checkpoint_period='00:00:02'
+    )
 
 
 @python_app(cache=True)
@@ -25,12 +31,12 @@ def tstamp_to_seconds(line):
 def test_periodic():
     """Test checkpointing with task_periodic behavior
     """
-    h, m, s = map(int, parsl.dfk().config.checkpoint_period.split(":"))
-    assert h == 0, "Verify test setup"
-    assert m == 0, "Verify test setup"
-    assert s > 0, "Verify test setup"
-    sleep_for = s + 1
-    with parsl.dfk():
+    with parsl.load(fresh_config()):
+        h, m, s = map(int, parsl.dfk().config.checkpoint_period.split(":"))
+        assert h == 0, "Verify test setup"
+        assert m == 0, "Verify test setup"
+        assert s > 0, "Verify test setup"
+        sleep_for = s + 1
         futs = [slow_double(sleep_for) for _ in range(4)]
         [f.result() for f in futs]
         run_dir = parsl.dfk().run_dir