parsl 2025.6.16__py3-none-any.whl → 2025.6.30__py3-none-any.whl

parsl/configs/osg.py

@@ -25,7 +25,7 @@ python3 -m venv parsl_env; source parsl_env/bin/activate; python3 -m pip install
                 walltime="00:20:00",
             ),
             worker_logdir_root='$OSG_WN_TMP',
-            worker_ports=(31000, 31001)
+            worker_port=31000,
         )
     ],
     usage_tracking=LEVEL_1,

parsl/dataflow/dflow.py

@@ -44,6 +44,7 @@ from parsl.executors.status_handling import BlockProviderExecutor
 from parsl.executors.threads import ThreadPoolExecutor
 from parsl.jobs.job_status_poller import JobStatusPoller
 from parsl.monitoring import MonitoringHub
+from parsl.monitoring.errors import RadioRequiredError
 from parsl.monitoring.message_type import MessageType
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.monitoring.remote import monitor_wrapper
@@ -186,7 +187,8 @@ class DataFlowKernel:
         self.executors: Dict[str, ParslExecutor] = {}
 
         self.data_manager = DataManager(self)
-        parsl_internal_executor = ThreadPoolExecutor(max_threads=config.internal_tasks_max_threads, label='_parsl_internal')
+        parsl_internal_executor = ThreadPoolExecutor(max_threads=config.internal_tasks_max_threads,
+                                                     label='_parsl_internal')
         self.add_executors(config.executors)
         self.add_executors([parsl_internal_executor])
 
@@ -736,17 +738,19 @@ class DataFlowKernel:
         try_id = task_record['fail_count']
 
         if self.monitoring is not None and self.monitoring.resource_monitoring_enabled:
+            if executor.remote_monitoring_radio is None:
+                raise RadioRequiredError()
+
             wrapper_logging_level = logging.DEBUG if self.monitoring.monitoring_debug else logging.INFO
             (function, args, kwargs) = monitor_wrapper(f=function,
                                                        args=args,
                                                        kwargs=kwargs,
                                                        x_try_id=try_id,
                                                        x_task_id=task_id,
-                                                       monitoring_hub_url=self.monitoring.monitoring_hub_url,
+                                                       radio_config=executor.remote_monitoring_radio,
                                                        run_id=self.run_id,
                                                        logging_level=wrapper_logging_level,
                                                        sleep_dur=self.monitoring.resource_monitoring_interval,
-                                                       radio_mode=executor.radio_mode,
                                                        monitor_resources=executor.monitor_resources(),
                                                        run_dir=self.run_dir)
 
@@ -1131,8 +1135,14 @@ class DataFlowKernel:
         for executor in executors:
             executor.run_id = self.run_id
             executor.run_dir = self.run_dir
-            if self.monitoring:
+            if self.monitoring and executor.remote_monitoring_radio is not None:
                 executor.monitoring_messages = self.monitoring.resource_msgs
+                logger.debug("Starting monitoring receiver for executor %s "
+                             "with remote monitoring radio config %s",
+                             executor, executor.remote_monitoring_radio)
+
+                executor.monitoring_receiver = executor.remote_monitoring_radio.create_receiver(resource_msgs=executor.monitoring_messages,
+                                                                                                run_dir=executor.run_dir)
             if hasattr(executor, 'provider'):
                 if hasattr(executor.provider, 'script_dir'):
                     executor.provider.script_dir = os.path.join(self.run_dir, 'submit_scripts')

parsl/executors/base.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import os
 from abc import ABCMeta, abstractmethod
 from concurrent.futures import Future
@@ -8,8 +9,11 @@ from typing import Any, Callable, Dict, Optional
 
 from typing_extensions import Literal, Self
 
+from parsl.monitoring.radios.base import MonitoringRadioReceiver, RadioConfig
 from parsl.monitoring.types import TaggedMonitoringMessage
 
+logger = logging.getLogger(__name__)
+
 
 class ParslExecutor(metaclass=ABCMeta):
     """Executors are abstractions that represent available compute resources
@@ -27,10 +31,8 @@ class ParslExecutor(metaclass=ABCMeta):
        label: str - a human readable label for the executor, unique
               with respect to other executors.
 
-    Per-executor monitoring behaviour can be influenced by exposing:
-
-       radio_mode: str - a string describing which radio mode should be used to
-              send task resource data back to the submit side.
+       remote_monitoring_radio: RadioConfig describing how tasks on this executor
+              should report task resource status
 
     An executor may optionally expose:
 
@@ -55,7 +57,6 @@ class ParslExecutor(metaclass=ABCMeta):
     """
 
     label: str = "undefined"
-    radio_mode: str = "udp"
 
     def __init__(
         self,
@@ -65,6 +66,10 @@ class ParslExecutor(metaclass=ABCMeta):
         run_id: Optional[str] = None,
     ):
         self.monitoring_messages = monitoring_messages
+
+        self.remote_monitoring_radio: Optional[RadioConfig] = None
+        self.monitoring_receiver: Optional[MonitoringRadioReceiver] = None
+
         self.run_dir = os.path.abspath(run_dir)
         self.run_id = run_id
 
@@ -98,15 +103,20 @@ class ParslExecutor(metaclass=ABCMeta):
     def shutdown(self) -> None:
         """Shutdown the executor.
 
-        This includes all attached resources such as workers and controllers.
+        Executors should call super().shutdown() as part of their overridden
+        implementation.
         """
-        pass
+        if self.monitoring_receiver is not None:
+            logger.info("Starting monitoring receiver shutdown")
+            self.monitoring_receiver.shutdown()
+            logger.info("Done with monitoring receiver shutdown")
 
     def monitor_resources(self) -> bool:
         """Should resource monitoring happen for tasks on running on this executor?
 
-        Parsl resource monitoring conflicts with execution styles which use threads, and
-        can deadlock while running.
+        Parsl resource monitoring conflicts with execution styles which do
+        not directly use a process tree - for example, the ThreadPoolExecutor
+        and the MPIExecutor.
 
         This function allows resource monitoring to be disabled per executor implementation.
         """

parsl/executors/flux/executor.py

@@ -248,6 +248,8 @@ class FluxExecutor(ParslExecutor, RepresentationMixin):
         if wait:
             self._submission_thread.join()
 
+        super().shutdown()
+
     def submit(
         self,
         func: Callable,

parsl/executors/globus_compute.py

@@ -134,3 +134,5 @@ class GlobusComputeExecutor(ParslExecutor, RepresentationMixin):
         self.executor.shutdown(wait=False, cancel_futures=True)
         result_watcher = self.executor._get_result_watcher()
         result_watcher.shutdown(wait=False, cancel_futures=True)
+
+        super().shutdown()

parsl/executors/high_throughput/executor.py

@@ -29,6 +29,8 @@ from parsl.executors.high_throughput.manager_selector import (
 )
 from parsl.executors.status_handling import BlockProviderExecutor
 from parsl.jobs.states import TERMINAL_STATES, JobState, JobStatus
+from parsl.monitoring.radios.base import RadioConfig
+from parsl.monitoring.radios.htex import HTEXRadio
 from parsl.monitoring.radios.zmq_router import ZMQRadioReceiver, start_zmq_receiver
 from parsl.process_loggers import wrap_with_logs
 from parsl.providers import LocalProvider
@@ -46,8 +48,7 @@ DEFAULT_LAUNCH_CMD = ("process_worker_pool.py {debug} {max_workers_per_node} "
                       "-c {cores_per_worker} "
                       "-m {mem_per_worker} "
                       "--poll {poll_period} "
-                      "--task_port={task_port} "
-                      "--result_port={result_port} "
+                      "--port={worker_port} "
                       "--cert_dir {cert_dir} "
                       "--logdir={logdir} "
                       "--block_id={{block_id}} "
@@ -100,8 +101,8 @@ GENERAL_HTEX_PARAM_DOCS = """provider : :class:`~parsl.providers.base.ExecutionP
         Supports IPv4 and IPv6 addresses
         default=127.0.0.1
 
-    worker_ports : (int, int)
-        Specify the ports to be used by workers to connect to Parsl. If this option is specified,
+    worker_port : int
+        Specify the port to be used by workers to connect to Parsl. If this option is specified,
         worker_port_range will not be honored.
 
     worker_port_range : (int, int)
@@ -241,7 +242,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
                  interchange_launch_cmd: Optional[Sequence[str]] = None,
                  address: Optional[str] = None,
                  loopback_address: str = "127.0.0.1",
-                 worker_ports: Optional[Tuple[int, int]] = None,
+                 worker_port: Optional[int] = None,
                  worker_port_range: Optional[Tuple[int, int]] = (54000, 55000),
                  interchange_port_range: Optional[Tuple[int, int]] = (55000, 56000),
                  storage_access: Optional[List[Staging]] = None,
@@ -261,7 +262,8 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
                  worker_logdir_root: Optional[str] = None,
                  manager_selector: ManagerSelector = RandomManagerSelector(),
                  block_error_handler: Union[bool, Callable[[BlockProviderExecutor, Dict[str, JobStatus]], None]] = True,
-                 encrypted: bool = False):
+                 encrypted: bool = False,
+                 remote_monitoring_radio: Optional[RadioConfig] = None):
 
         logger.debug("Initializing HighThroughputExecutor")
 
@@ -310,7 +312,13 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
             self._workers_per_node = 1  # our best guess-- we do not have any provider hints
 
         self._task_counter = 0
-        self.worker_ports = worker_ports
+
+        if remote_monitoring_radio is not None:
+            self.remote_monitoring_radio = remote_monitoring_radio
+        else:
+            self.remote_monitoring_radio = HTEXRadio()
+
+        self.worker_port = worker_port
         self.worker_port_range = worker_port_range
         self.interchange_proc: Optional[subprocess.Popen] = None
         self.interchange_port_range = interchange_port_range
@@ -339,7 +347,6 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         self.zmq_monitoring = None
         self.hub_zmq_port = None
 
-    radio_mode = "htex"
     enable_mpi_mode: bool = False
     mpi_launcher: str = "mpiexec"
 
@@ -390,8 +397,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
                                        prefetch_capacity=self.prefetch_capacity,
                                        address_probe_timeout_string=address_probe_timeout_string,
                                        addresses=self.all_addresses,
-                                       task_port=self.worker_task_port,
-                                       result_port=self.worker_result_port,
+                                       worker_port=self.worker_port,
                                        cores_per_worker=self.cores_per_worker,
                                        mem_per_worker=self.mem_per_worker,
                                        max_workers_per_node=max_workers_per_node,
@@ -551,7 +557,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
                                                self.incoming_q.port,
                                                self.command_client.port),
                               "interchange_address": self.address,
-                              "worker_ports": self.worker_ports,
+                              "worker_port": self.worker_port,
                               "worker_port_range": self.worker_port_range,
                               "hub_address": self.loopback_address,
                               "hub_zmq_port": self.hub_zmq_port,
@@ -576,15 +582,14 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         stdin.close()
         logger.debug("Sent config object. Requesting worker ports")
         try:
-            (self.worker_task_port, self.worker_result_port) = self.command_client.run("WORKER_PORTS", timeout_s=120)
+            self.worker_port = self.command_client.run("WORKER_BINDS", timeout_s=120)
         except CommandClientTimeoutError:
             logger.error("Interchange has not completed initialization. Aborting")
             raise Exception("Interchange failed to start")
         logger.debug(
-            "Interchange process started (%r).  Worker ports: %d, %d",
+            "Interchange process started (%r).  Worker port: %d",
             self.interchange_proc,
-            self.worker_task_port,
-            self.worker_result_port
+            self.worker_port,
         )
 
     def _start_result_queue_thread(self):
@@ -881,6 +886,8 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         if self.zmq_monitoring:
             self.zmq_monitoring.close()
 
+        super().shutdown()
+
         logger.info("Finished HighThroughputExecutor shutdown attempt")
 
     def get_usage_information(self):