parsl 2025.6.30__tar.gz → 2025.7.7__tar.gz

{parsl-2025.6.30/parsl.egg-info → parsl-2025.7.7}/PKG-INFO

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

parsl-2025.7.7/parsl/configs/anvil.py

@@ -0,0 +1,34 @@
+from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
+from parsl.launchers import SrunLauncher
+from parsl.providers import SlurmProvider
+from parsl.usage_tracking.levels import LEVEL_1
+
+config = Config(
+    executors=[
+        HighThroughputExecutor(
+            label='Anvil_GPU_Executor',
+            working_dir='/anvil/scratch/path/to/your/directory',
+            max_workers_per_node=1,
+            provider=SlurmProvider(
+                partition='gpu',
+                account='YOUR_ALLOCATION_ON_ANVIL',
+                nodes_per_block=1,
+                cores_per_node=4,
+                mem_per_node=50,
+                init_blocks=1,
+                max_blocks=1,
+                walltime='00:30:00',
+                # string to prepend to #SBATCH blocks in the submit
+                # script to the scheduler
+                scheduler_options='#SBATCH --gres gpu:1 --gpus-per-node=1',
+                # Command to be run before starting a worker, such as:
+                # 'module load Anaconda; source activate parsl_env'.
+                worker_init='module load modtree/gpu',
+                exclusive=False,
+                launcher=SrunLauncher(),
+            ),
+        )
+    ],
+    usage_tracking=LEVEL_1,
+)

parsl-2025.7.7/parsl/configs/delta.py

@@ -0,0 +1,35 @@
+from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
+from parsl.launchers import SrunLauncher
+from parsl.providers import SlurmProvider
+from parsl.usage_tracking.levels import LEVEL_1
+
+config = Config(
+    executors=[
+        HighThroughputExecutor(
+            label='Delta_GPU_Executor',
+            working_dir='/scratch/path/to/your/directory',
+            max_workers_per_node=1,
+            provider=SlurmProvider(
+                partition='gpuA100x4',
+                account='YOUR_ALLOCATION_ON_DELTA',
+                constraint="scratch",
+                nodes_per_block=1,
+                cores_per_node=32,
+                mem_per_node=220,
+                init_blocks=1,
+                max_blocks=1,
+                walltime='00:30:00',
+                # string to prepend to #SBATCH blocks in the submit
+                # script to the scheduler
+                scheduler_options='#SBATCH --gpus-per-node=1 --gpu-bind=closest',
+                # Command to be run before starting a worker, such as:
+                # 'module load Anaconda; source activate parsl_env'.
+                worker_init='',
+                exclusive=False,
+                launcher=SrunLauncher(),
+            ),
+        )
+    ],
+    usage_tracking=LEVEL_1,
+)

{parsl-2025.6.30 → parsl-2025.7.7}/parsl/executors/high_throughput/interchange.py

@@ -369,7 +369,11 @@ class Interchange:
             'Processing message type %r from manager %r', mtype, manager_id
         )
 
-        if mtype == 'registration':
+        if mtype == 'connection_probe':
+            self.manager_sock.send_multipart([manager_id, b''])
+            return
+
+        elif mtype == 'registration':
             ix_minor_py = self.current_platform['python_v'].rsplit('.', 1)[0]
             ix_parsl_v = self.current_platform['parsl_v']
             mgr_minor_py = meta['python_v'].rsplit('.', 1)[0]

parsl-2025.7.7/parsl/executors/high_throughput/probe.py

@@ -0,0 +1,107 @@
+import logging
+import pickle
+from contextlib import ExitStack
+from typing import Optional
+
+import zmq
+
+from parsl import curvezmq
+
+logger = logging.getLogger(__name__)
+
+
+def probe_addresses(
+    zmq_context: curvezmq.ClientContext,
+    addresses: str,
+    timeout_ms: int = 120_000,
+    identity: Optional[bytes] = None,
+):
+    """
+    Given a single-line CSV list of addresses, return the first proven valid address.
+
+    This function will connect to each address in ``addresses`` (a comma-separated
+    list of URLs) and attempt to send a CONNECTION_PROBE packet.  Returns the first
+    address that receives a response.
+
+    If no address receives a response within the ``timeout_ms`` (specified in
+    milliseconds), then raise ``ConnectionError``.
+
+    :param zmq_context: A ZMQ Context; the call-site may provide an encrypted ZMQ
+        context for assurance that the returned address is the expected and correct
+        endpoint
+    :param addresses: a comma-separated string of addresses to attempt.  Example:
+        ``tcp://127.0.0.1:1234,tcp://[3812::03aa]:5678``
+    :param timeout_ms: how long to wait for a response from the probes.  The probes
+        are initiated and await concurrently, so this timeout will be the total wall
+        time in the worst case of "no addresses are valid."
+    :param identity: a ZMQ connection identity; used for logging connection probes
+        at the interchange
+    :raises: ``ConnectionError`` if no addresses are determined valid
+    :returns: a single address, the first one that received a response
+    """
+    if not addresses:
+        raise ValueError("No address to probe!")
+
+    sock_map = {}
+    urls = addresses.split(",")
+    with ExitStack() as stk:
+        poller = zmq.Poller()
+        for url in urls:
+            logger.debug("Testing ZMQ connection to url: %s", url)
+            s: zmq.Socket = stk.enter_context(zmq_context.socket(zmq.DEALER))
+            s.setsockopt(zmq.LINGER, 0)
+            s.setsockopt(zmq.IPV6, True)
+            if identity:
+                s.setsockopt(zmq.IDENTITY, identity)
+            stk.enter_context(s.connect(url))
+            poller.register(s, zmq.POLLIN)
+            sock_map[s] = url
+
+            s.send(pickle.dumps({'type': 'connection_probe'}))
+
+        for sock, evt in poller.poll(timeout=timeout_ms):
+            sock.recv()  # clear the buffer for good netizenry
+            return sock_map.get(sock)
+
+    addys = ", ".join(urls)  # just slightly more human friendly
+    raise ConnectionError(f"No viable ZMQ url from: {addys}")
+
+
+class TestWorker:
+
+    def __init__(self, addresses, port):
+        uid = str(uuid.uuid4())
+        self.context = zmq.Context()
+        self.task_incoming = self.context.socket(zmq.DEALER)
+        self.task_incoming.setsockopt(zmq.IDENTITY, uid.encode('utf-8'))
+        # Linger is set to 0, so that the manager can exit even when there might be
+        # messages in the pipe
+        self.task_incoming.setsockopt(zmq.LINGER, 0)
+
+        address = probe_addresses(addresses, port)
+        print("Viable address :", address)
+        self.task_incoming.connect(tcp_url(address, port))
+
+    def heartbeat(self):
+        """ Send heartbeat to the incoming task queue
+        """
+        HEARTBEAT_CODE = (2 ** 32) - 1
+        heartbeat = (HEARTBEAT_CODE).to_bytes(4, "little")
+        r = self.task_incoming.send(heartbeat)
+        print("Return from heartbeat: {}".format(r))
+
+
+if __name__ == "__main__":
+    import argparse
+    import uuid
+
+    from parsl.addresses import get_all_addresses, tcp_url
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-p", "--port", required=True,
+                        help="Port to connect to")
+
+    args = parser.parse_args()
+    addresses = get_all_addresses()
+    worker = TestWorker(addresses, args.port)
+    worker.heartbeat()

{parsl-2025.6.30 → parsl-2025.7.7}/parsl/executors/high_throughput/process_worker_pool.py

@@ -154,23 +154,23 @@ class Manager:
 
         self._start_time = time.time()
 
-        try:
-            ix_address = probe_addresses(addresses.split(','), port, timeout=address_probe_timeout)
-            if not ix_address:
-                raise Exception("No viable address found")
-            else:
-                logger.info(f"Connection to Interchange successful on {ix_address}")
-                ix_url = tcp_url(ix_address, port)
-                logger.info(f"Interchange url: {ix_url}")
-        except Exception:
-            logger.exception("Caught exception while trying to determine viable address to interchange")
-            print("Failed to find a viable address to connect to interchange. Exiting")
-            exit(5)
-
         self.cert_dir = cert_dir
         self.zmq_context = curvezmq.ClientContext(self.cert_dir)
 
-        self._ix_url = ix_url
+        addresses = ','.join(tcp_url(a, port) for a in addresses.split(','))
+        try:
+            self._ix_url = probe_addresses(
+                self.zmq_context,
+                addresses,
+                timeout_ms=1_000 * address_probe_timeout,
+                identity=uid.encode('utf-8'),
+            )
+        except ConnectionError:
+            addys = ", ".join(addresses.split(","))
+            logger.error(f"Unable to connect to interchange; attempted addresses: {addys}")
+            raise
+
+        logger.info(f"Probe discovered interchange url: {self._ix_url}")
 
         self.uid = uid
         self.block_id = block_id
@@ -312,6 +312,14 @@ class Manager:
         poller.register(results_sock, zmq.POLLIN)
         poller.register(ix_sock, zmq.POLLIN)
 
+        ix_sock.send(pickle.dumps({"type": "connection_probe"}))
+        evts = dict(poller.poll(timeout=self.heartbeat_period))
+        if evts.get(ix_sock) is None:
+            logger.error(f"Failed to connect to interchange ({self._ix_url}")
+
+        ix_sock.recv()
+        logger.info(f"Successfully connected to interchange via URL: {self._ix_url}")
+
         # Send a registration message
         msg = self.create_reg_message()
         logger.debug("Sending registration message: %s", msg)

{parsl-2025.6.30 → parsl-2025.7.7}/parsl/version.py

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

{parsl-2025.6.30 → parsl-2025.7.7/parsl.egg-info}/PKG-INFO

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

{parsl-2025.6.30 → parsl-2025.7.7}/parsl.egg-info/SOURCES.txt

@@ -32,8 +32,10 @@ parsl/concurrent/__init__.py
 parsl/configs/ASPIRE1.py
 parsl/configs/Azure.py
 parsl/configs/__init__.py
+parsl/configs/anvil.py
 parsl/configs/bridges.py
 parsl/configs/cc_in2p3.py
+parsl/configs/delta.py
 parsl/configs/ec2.py
 parsl/configs/expanse.py
 parsl/configs/frontera.py

parsl-2025.6.30/parsl/executors/high_throughput/probe.py

@@ -1,95 +0,0 @@
-import argparse
-import logging
-import time
-import uuid
-
-import zmq
-from zmq.utils.monitor import recv_monitor_message
-
-from parsl.addresses import get_all_addresses, tcp_url
-
-logger = logging.getLogger(__name__)
-
-
-def probe_addresses(addresses, port, timeout=120):
-    """
-    Parameters
-    ----------
-
-    addresses: [string]
-        List of addresses as strings
-    port: int
-        Port on the interchange
-    timeout: int
-        Timeout in seconds
-
-    Returns
-    -------
-    None or string address
-    """
-    context = zmq.Context()
-    addr_map = {}
-    for addr in addresses:
-        socket = context.socket(zmq.DEALER)
-        socket.setsockopt(zmq.LINGER, 0)
-        socket.setsockopt(zmq.IPV6, True)
-        url = tcp_url(addr, port)
-        logger.debug("Trying to connect back on {}".format(url))
-        socket.connect(url)
-        addr_map[addr] = {'sock': socket,
-                          'mon_sock': socket.get_monitor_socket(events=zmq.EVENT_CONNECTED)}
-
-    start_t = time.time()
-
-    first_connected = None
-    while time.time() < start_t + timeout and not first_connected:
-        for addr in addr_map:
-            try:
-                recv_monitor_message(addr_map[addr]['mon_sock'], zmq.NOBLOCK)
-                first_connected = addr
-                logger.info("Connected to interchange on {}".format(first_connected))
-                break
-            except zmq.Again:
-                pass
-            time.sleep(0.01)
-
-    for addr in addr_map:
-        addr_map[addr]['sock'].close()
-
-    return first_connected
-
-
-class TestWorker:
-
-    def __init__(self, addresses, port):
-        uid = str(uuid.uuid4())
-        self.context = zmq.Context()
-        self.task_incoming = self.context.socket(zmq.DEALER)
-        self.task_incoming.setsockopt(zmq.IDENTITY, uid.encode('utf-8'))
-        # Linger is set to 0, so that the manager can exit even when there might be
-        # messages in the pipe
-        self.task_incoming.setsockopt(zmq.LINGER, 0)
-
-        address = probe_addresses(addresses, port)
-        print("Viable address :", address)
-        self.task_incoming.connect(tcp_url(address, port))
-
-    def heartbeat(self):
-        """ Send heartbeat to the incoming task queue
-        """
-        HEARTBEAT_CODE = (2 ** 32) - 1
-        heartbeat = (HEARTBEAT_CODE).to_bytes(4, "little")
-        r = self.task_incoming.send(heartbeat)
-        print("Return from heartbeat: {}".format(r))
-
-
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-p", "--port", required=True,
-                        help="Port to connect to")
-
-    args = parser.parse_args()
-    addresses = get_all_addresses()
-    worker = TestWorker(addresses, args.port)
-    worker.heartbeat()