parsl 2023.7.10__tar.gz → 2023.7.17__tar.gz

{parsl-2023.7.10/parsl.egg-info → parsl-2023.7.17}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2023.7.10
+Version: 2023.7.17
 Summary: Simple data dependent workflows in Python
 Home-page: https://github.com/Parsl/parsl
-Download-URL: https://github.com/Parsl/parsl/archive/2023.07.10.tar.gz
+Download-URL: https://github.com/Parsl/parsl/archive/2023.07.17.tar.gz
 Author: The Parsl Team
 Author-email: parsl@googlegroups.com
 License: Apache 2.0

{parsl-2023.7.10 → parsl-2023.7.17}/parsl/executors/high_throughput/executor.py

@@ -595,10 +595,9 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin):
         except TypeError:
             raise SerializationError(func.__name__)
 
-        msg = {"task_id": task_id,
-               "buffer": fn_buf}
+        msg = {"task_id": task_id, "buffer": fn_buf}
 
-        # Post task to the the outgoing queue
+        # Post task to the outgoing queue
         self.outgoing_q.put(msg)
 
         # Return the future

{parsl-2023.7.10 → parsl-2023.7.17}/parsl/executors/high_throughput/process_worker_pool.py

@@ -370,7 +370,7 @@ class Manager:
         logger.critical("Exiting")
 
     @wrap_with_logs
-    def worker_watchdog(self, kill_event):
+    def worker_watchdog(self, kill_event: threading.Event):
         """Keeps workers alive.
 
         Parameters:
@@ -381,7 +381,7 @@ class Manager:
 
         logger.debug("Starting worker watchdog")
 
-        while not kill_event.is_set():
+        while not kill_event.wait(self.heartbeat_period):
             for worker_id, p in self.procs.items():
                 if not p.is_alive():
                     logger.error("Worker {} has died".format(worker_id))
@@ -409,7 +409,6 @@ class Manager:
                                        name="HTEX-Worker-{}".format(worker_id))
                     self.procs[worker_id] = p
                     logger.info("Worker {} has been restarted".format(worker_id))
-                time.sleep(self.heartbeat_period)
 
         logger.critical("Exiting")
 

{parsl-2023.7.10 → parsl-2023.7.17}/parsl/serialize/concretes.py

@@ -28,25 +28,6 @@ class PickleSerializer(SerializerBase):
         return pickle.loads(body)
 
 
-class PickleCallableSerializer(SerializerBase):
-    """This serializer is a variant of the PickleSerializer that will
-    serialize and deserialize callables using an lru_cache, under the
-    assumption that callables are immutable and so can be cached.
-    """
-
-    _identifier = b'C1'
-    _for_code = True
-    _for_data = False
-
-    @functools.lru_cache
-    def serialize(self, data: Any) -> bytes:
-        return pickle.dumps(data)
-
-    @functools.lru_cache
-    def deserialize(self, body: bytes) -> Any:
-        return pickle.loads(body)
-
-
 class DillSerializer(SerializerBase):
     """ Dill serialization works on a superset of object including the ones covered by pickle.
     However for most cases pickle is faster. For most callable objects the additional overhead

{parsl-2023.7.10 → parsl-2023.7.17}/parsl/tests/conftest.py

@@ -1,12 +1,16 @@
 import importlib.util
+import itertools
 import logging
 import os
 import pathlib
+import time
+import types
 import signal
 import sys
 import tempfile
 import threading
 import traceback
+import typing as t
 from datetime import datetime
 from glob import glob
 from itertools import chain
@@ -157,9 +161,9 @@ def load_dfk_local_module(request, pytestconfig):
     parsl.load. It should be a Callable that returns a parsl Config object.
 
     If local_setup and/or local_teardown are callables (such as functions) in
-    the test module, they they will be invoked before/after the tests. This
-    can be used to perform more interesting DFK initialisation not possible
-    with local_config.
+    the test module, they will be invoked before/after the tests. This can
+    be used to perform more interesting DFK initialisation not possible with
+    local_config.
     """
 
     config = pytestconfig.getoption('config')[0]
@@ -290,3 +294,67 @@ def pytest_ignore_collect(path):
         return True
     else:
         return False
+
+
+def create_traceback(start: int = 0) -> t.Optional[types.TracebackType]:
+    """
+    Dynamically create a traceback.
+
+    Builds a traceback from the top of the stack (the currently executing frame) on
+    down to the root frame.  Optionally, use start to build from an earlier stack
+    frame.
+
+    N.B. uses `sys._getframe`, which I only know to exist in CPython.
+    """
+    tb = None
+    for depth in itertools.count(start + 1, 1):
+        try:
+            frame = sys._getframe(depth)
+            tb = types.TracebackType(tb, frame, frame.f_lasti, frame.f_lineno)
+        except ValueError:
+            break
+    return tb
+
+
+@pytest.fixture
+def try_assert():
+    def _impl(
+        test_func: t.Callable[[], bool],
+        fail_msg: str = "",
+        timeout_ms: float = 5000,
+        attempts: int = 0,
+        check_period_ms: int = 20,
+    ):
+        tb = create_traceback(start=1)
+        timeout_s = abs(timeout_ms) / 1000.0
+        check_period_s = abs(check_period_ms) / 1000.0
+        if attempts > 0:
+            for _attempt_no in range(attempts):
+                if test_func():
+                    return
+                time.sleep(check_period_s)
+            else:
+                att_fail = (
+                    f"\n  (Still failing after attempt limit [{attempts}], testing"
+                    f" every {check_period_ms}ms)"
+                )
+                exc = AssertionError(f"{str(fail_msg)}{att_fail}".strip())
+                raise exc.with_traceback(tb)
+
+        elif timeout_s > 0:
+            end = time.monotonic() + timeout_s
+            while time.monotonic() < end:
+                if test_func():
+                    return
+                time.sleep(check_period_s)
+            att_fail = (
+                f"\n  (Still failing after timeout [{timeout_ms}ms], with attempts "
+                f"every {check_period_ms}ms)"
+            )
+            exc = AssertionError(f"{str(fail_msg)}{att_fail}".strip())
+            raise exc.with_traceback(tb)
+
+        else:
+            raise AssertionError("Bad assert call: no attempts or timeout period")
+
+    yield _impl

{parsl-2023.7.10 → parsl-2023.7.17}/parsl/tests/test_error_handling/test_htex_worker_failure.py

@@ -1,28 +1,21 @@
 import pytest
 
-import parsl
 from parsl.app.app import python_app
-from parsl.tests.configs.htex_local import fresh_config
-
 from parsl.executors.high_throughput.errors import WorkerLost
 
 
-def local_setup():
+def local_config():
+    from parsl.tests.configs.htex_local import fresh_config
     config = fresh_config()
     config.executors[0].poll_period = 1
     config.executors[0].max_workers = 1
-    parsl.load(config)
-
-
-def local_teardown():
-    parsl.dfk().cleanup()
-    parsl.clear()
+    config.executors[0].heartbeat_period = 1
+    return config
 
 
 @python_app
 def kill_worker():
-    import sys
-    sys.exit(2)
+    raise SystemExit(2)
 
 
 @pytest.mark.local

parsl-2023.7.17/parsl/tests/test_regression/test_1606_wait_for_current_tasks.py

@@ -0,0 +1,42 @@
+import threading
+import time
+
+import pytest
+
+import parsl
+from parsl.tests.configs.local_threads import fresh_config as local_config  # noqa
+
+
+@parsl.python_app
+def slow_app(evt: threading.Event):
+    evt.wait()
+
+
+@pytest.mark.local
+def test_wait_for_tasks():
+    """
+    gh#1606 reported that wait_for_current_tasks fails due to tasks being removed
+    from the DFK tasks dict as they complete; bug introduced in #1543.
+    """
+    def test_kernel(may_wait: threading.Event):
+        e1, e2 = threading.Event(), threading.Event()
+
+        # app_slow is in *middle* of internal DFK data structure
+        app_fast1, app_slow, app_fast2 = slow_app(e1), slow_app(e2), slow_app(e1)
+
+        may_wait.set()  # initiated wait in outer test
+        time.sleep(0.01)
+
+        e1.set()
+
+        while not all(f.done() for f in (app_fast1, app_fast2)):
+            time.sleep(0.01)
+
+        e2.set()
+        app_slow.result()
+
+    may_continue = threading.Event()
+    threading.Thread(target=test_kernel, daemon=True, args=(may_continue,)).start()
+
+    may_continue.wait()
+    parsl.dfk().wait_for_current_tasks()  # per sleeps, waits for all 3 tasks

{parsl-2023.7.10 → parsl-2023.7.17}/parsl/tests/test_scaling/test_regression_1621.py

@@ -1,33 +1,27 @@
-# this test is intended to ensure that only one block is launched when only
-# one app is invoked. this is a regression test.
+import threading
+
+import pytest
 
-import logging
 import parsl
 from parsl.channels import LocalChannel
 from parsl.config import Config
 from parsl.executors import HighThroughputExecutor
 from parsl.launchers import SimpleLauncher
 from parsl.providers import LocalProvider
-import pytest
-
-
-logger = logging.getLogger(__name__)
 
 
 @parsl.python_app
 def app():
     import time
-    time.sleep(45)
+    time.sleep(1)
 
 
 class OneShotLocalProvider(LocalProvider):
     def __init__(self, *args, **kwargs):
-        logger.info("OneShotLocalProvider __init__ with MRO: {}".format(type(self).mro()))
         self.recorded_submits = 0
         super().__init__(*args, **kwargs)
 
     def submit(self, *args, **kwargs):
-        logger.info("OneShotLocalProvider submit")
         self.recorded_submits += 1
         return super().submit(*args, **kwargs)
 
@@ -35,32 +29,44 @@ class OneShotLocalProvider(LocalProvider):
 
 
 @pytest.mark.local
-def test_one_block():
-
+def test_one_block(tmpd_cwd):
+    """
+    this test is intended to ensure that only one block is launched when only
+    one app is invoked. this is a regression test.
+    """
     oneshot_provider = OneShotLocalProvider(
-                    channel=LocalChannel(),
-                    init_blocks=0,
-                    min_blocks=0,
-                    max_blocks=10,
-                    launcher=SimpleLauncher(),
-                )
+        channel=LocalChannel(),
+        init_blocks=0,
+        min_blocks=0,
+        max_blocks=10,
+        launcher=SimpleLauncher(),
+    )
 
     config = Config(
         executors=[
             HighThroughputExecutor(
                 label="htex_local",
+                address="127.0.0.1",
                 worker_debug=True,
                 cores_per_worker=1,
                 provider=oneshot_provider,
+                worker_logdir_root=str(tmpd_cwd)
             )
         ],
         strategy='simple',
     )
 
     parsl.load(config)
+    dfk = parsl.dfk()
+
+    def poller():
+        import time
+        while True:
+            dfk.job_status_poller.poll()
+            time.sleep(0.1)
 
-    f = app()
-    f.result()
+    threading.Thread(target=poller, daemon=True).start()
+    app().result()
     parsl.dfk().cleanup()
     parsl.clear()
 

parsl-2023.7.17/parsl/tests/test_scaling/test_scale_down.py

@@ -0,0 +1,97 @@
+import logging
+import time
+
+import pytest
+
+import parsl
+
+from parsl import File, python_app
+from parsl.providers import LocalProvider
+from parsl.channels import LocalChannel
+from parsl.launchers import SingleNodeLauncher
+from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
+
+logger = logging.getLogger(__name__)
+
+_max_blocks = 5
+_min_blocks = 2
+
+
+def local_config():
+    return Config(
+        executors=[
+            HighThroughputExecutor(
+                heartbeat_period=1,
+                heartbeat_threshold=2,
+                poll_period=100,
+                label="htex_local",
+                address="127.0.0.1",
+                max_workers=1,
+                provider=LocalProvider(
+                    channel=LocalChannel(),
+                    init_blocks=0,
+                    max_blocks=_max_blocks,
+                    min_blocks=_min_blocks,
+                    launcher=SingleNodeLauncher(),
+                ),
+            )
+        ],
+        max_idletime=0.5,
+        strategy='htex_auto_scale',
+    )
+
+
+@python_app
+def waiting_app(ident: int, inputs=()):
+    import pathlib
+    import time
+
+    # Approximate an Event by writing to files; the test logic will poll this file
+    with open(inputs[0], "a") as f:
+        f.write(f"Ready: {ident}\n")
+
+    # Similarly, use Event approximation (file check!) by polling.
+    may_finish_file = pathlib.Path(inputs[1])
+    while not may_finish_file.exists():
+        time.sleep(0.01)
+
+
+# see issue #1885 for details of failures of this test.
+# at the time of issue #1885 this test was failing frequently
+# in CI.
+@pytest.mark.local
+def test_scale_out(tmpd_cwd, try_assert):
+    dfk = parsl.dfk()
+
+    num_managers = len(dfk.executors['htex_local'].connected_managers())
+
+    assert num_managers == 0, "Expected 0 managers at start"
+    assert dfk.executors['htex_local'].outstanding == 0, "Expected 0 tasks at start"
+
+    ntasks = 10
+    ready_path = tmpd_cwd / "workers_ready"
+    finish_path = tmpd_cwd / "workers_may_continue"
+    ready_path.touch()
+    inputs = [File(str(ready_path)), File(str(finish_path))]
+
+    futs = [waiting_app(i, inputs=inputs) for i in range(ntasks)]
+
+    while ready_path.read_text().count("\n") < _max_blocks:
+        time.sleep(0.5)
+
+    assert len(dfk.executors['htex_local'].connected_managers()) == _max_blocks
+
+    finish_path.touch()  # Approximation of Event, via files
+    [x.result() for x in futs]
+
+    assert dfk.executors['htex_local'].outstanding == 0
+
+    def assert_kernel():
+        return len(dfk.executors['htex_local'].connected_managers()) == _min_blocks
+
+    try_assert(
+        assert_kernel,
+        fail_msg=f"Expected {_min_blocks} managers when no tasks (min_blocks)",
+        timeout_ms=15000,
+    )

{parsl-2023.7.10 → parsl-2023.7.17}/parsl/version.py

@@ -3,4 +3,4 @@
 Year.Month.Day[alpha/beta/..]
 Alphas will be numbered like this -> 2024.12.10a0
 """
-VERSION = '2023.07.10'
+VERSION = '2023.07.17'

{parsl-2023.7.10 → parsl-2023.7.17/parsl.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2023.7.10
+Version: 2023.7.17
 Summary: Simple data dependent workflows in Python
 Home-page: https://github.com/Parsl/parsl
-Download-URL: https://github.com/Parsl/parsl/archive/2023.07.10.tar.gz
+Download-URL: https://github.com/Parsl/parsl/archive/2023.07.17.tar.gz
 Author: The Parsl Team
 Author-email: parsl@googlegroups.com
 License: Apache 2.0

parsl-2023.7.10/parsl/tests/test_regression/test_1606_wait_for_current_tasks.py

@@ -1,17 +0,0 @@
-import parsl
-
-
-@parsl.python_app
-def slow_app(delay):
-    import time
-    time.sleep(delay)
-
-
-def test_wait_for_tasks():
-    slow_app(5)
-    slow_app(10)  # This test has a higher task ID, and runs for a longer period
-    slow_app(3)  # This test has a higher task ID, but runs for a shorter period
-    parsl.dfk().wait_for_current_tasks()
-    # the regression reported in #1606 is that wait_for_current_tasks
-    # fails due to tasks being removed from the DFK tasks dict as they
-    # complete, introduced in #1543.

parsl-2023.7.10/parsl/tests/test_scaling/test_scale_down.py

@@ -1,80 +0,0 @@
-import logging
-import parsl
-import pytest
-import time
-from parsl import python_app
-
-from parsl.providers import LocalProvider
-from parsl.channels import LocalChannel
-# from parsl.launchers import SimpleLauncher
-from parsl.launchers import SingleNodeLauncher
-
-from parsl.config import Config
-from parsl.executors import HighThroughputExecutor
-
-logger = logging.getLogger(__name__)
-
-
-def local_config():
-    return Config(
-        executors=[
-            HighThroughputExecutor(
-                heartbeat_period=2,
-                heartbeat_threshold=6,
-                poll_period=1,
-                label="htex_local",
-                max_workers=1,
-                provider=LocalProvider(
-                    channel=LocalChannel(),
-                    init_blocks=0,
-                    max_blocks=5,
-                    min_blocks=2,
-                    launcher=SingleNodeLauncher(),
-                ),
-            )
-        ],
-        max_idletime=5,
-        strategy='htex_auto_scale',
-    )
-
-
-@python_app
-def sleeper(t):
-    import time
-    time.sleep(t)
-
-
-# see issue #1885 for details of failures of this test.
-# at the time of issue #1885 this test was failing frequently
-# in CI.
-@pytest.mark.local
-def test_scale_out():
-    logger.info("start")
-    dfk = parsl.dfk()
-
-    logger.info("initial asserts")
-    assert len(dfk.executors['htex_local'].connected_managers()) == 0, "Expected 0 managers at start"
-    assert dfk.executors['htex_local'].outstanding == 0, "Expected 0 tasks at start"
-
-    logger.info("launching tasks")
-    fus = [sleeper(i) for i in [15 for x in range(0, 10)]]
-
-    logger.info("waiting for warm up")
-    time.sleep(15)
-
-    logger.info("asserting 5 managers")
-    assert len(dfk.executors['htex_local'].connected_managers()) == 5, "Expected 5 managers after some time"
-
-    logger.info("waiting for all futures to complete")
-    [x.result() for x in fus]
-
-    logger.info("asserting 0 outstanding tasks after completion")
-    assert dfk.executors['htex_local'].outstanding == 0, "Expected 0 outstanding tasks after future completion"
-
-    logger.info("waiting a while for scale down")
-    time.sleep(25)
-
-    logger.info("asserting 2 managers remain")
-    assert len(dfk.executors['htex_local'].connected_managers()) == 2, "Expected 2 managers when no tasks, lower bound by min_blocks"
-
-    logger.info("test passed")