parsl 2025.2.10__py3-none-any.whl → 2025.2.24__py3-none-any.whl

parsl/executors/high_throughput/executor.py

@@ -617,6 +617,12 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         """
         return self.command_client.run("MANAGERS")
 
+    def connected_managers_packages(self) -> Dict[str, Dict[str, str]]:
+        """Returns a dict mapping each manager ID to a dict of installed
+        packages and their versions
+        """
+        return self.command_client.run("MANAGERS_PACKAGES")
+
     def connected_blocks(self) -> List[str]:
         """List of connected block ids"""
         return self.command_client.run("CONNECTED_BLOCKS")

parsl/executors/high_throughput/interchange.py

@@ -257,6 +257,13 @@ class Interchange:
                             'draining': m['draining']}
                     reply.append(resp)
 
+            elif command_req == "MANAGERS_PACKAGES":
+                reply = {}
+                for manager_id in self._ready_managers:
+                    m = self._ready_managers[manager_id]
+                    manager_id_str = manager_id.decode('utf-8')
+                    reply[manager_id_str] = m["packages"]
+
             elif command_req.startswith("HOLD_WORKER"):
                 cmd, s_manager = command_req.split(';')
                 manager_id = s_manager.encode('utf-8')

parsl/executors/high_throughput/manager_record.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, List, Optional
+from typing import Any, Dict, List, Optional
 
 from typing_extensions import TypedDict
 
@@ -18,3 +18,4 @@ class ManagerRecord(TypedDict, total=False):
     timestamp: datetime
     parsl_version: str
     python_version: str
+    packages: Dict[str, str]

parsl/executors/high_throughput/mpi_resource_management.py

@@ -5,7 +5,7 @@ import pickle
 import queue
 import subprocess
 from enum import Enum
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from parsl.multiprocessing import SpawnContext
 from parsl.serialize import pack_res_spec_apply_message, unpack_res_spec_apply_message
@@ -86,8 +86,8 @@ class TaskScheduler:
     def put_task(self, task) -> None:
         return self.pending_task_q.put(task)
 
-    def get_result(self, block: bool, timeout: float):
-        return self.pending_result_q.get(block, timeout=timeout)
+    def get_result(self, block: bool = True, timeout: Optional[float] = None):
+        return self.pending_result_q.get(block, timeout)
 
 
 class MPITaskScheduler(TaskScheduler):
@@ -163,16 +163,17 @@ class MPITaskScheduler(TaskScheduler):
         _f, _args, _kwargs, resource_spec = unpack_res_spec_apply_message(task_package["buffer"])
 
         nodes_needed = resource_spec.get("num_nodes")
+        tid = task_package["task_id"]
         if nodes_needed:
             try:
                 allocated_nodes = self._get_nodes(nodes_needed)
             except MPINodesUnavailable:
-                logger.warning("Not enough resources, placing task into backlog")
+                logger.info(f"Not enough resources, placing task {tid} into backlog")
                 self._backlog_queue.put((nodes_needed, task_package))
                 return
             else:
                 resource_spec["MPI_NODELIST"] = ",".join(allocated_nodes)
-                self._map_tasks_to_nodes[task_package["task_id"]] = allocated_nodes
+                self._map_tasks_to_nodes[tid] = allocated_nodes
                 buffer = pack_res_spec_apply_message(_f, _args, _kwargs, resource_spec)
                 task_package["buffer"] = buffer
                 task_package["resource_spec"] = resource_spec
@@ -190,9 +191,9 @@ class MPITaskScheduler(TaskScheduler):
             # Keep attempting to schedule tasks till we are out of resources
             self._schedule_backlog_tasks()
 
-    def get_result(self, block: bool, timeout: float):
+    def get_result(self, block: bool = True, timeout: Optional[float] = None):
         """Return result and relinquish provisioned nodes"""
-        result_pkl = self.pending_result_q.get(block, timeout=timeout)
+        result_pkl = self.pending_result_q.get(block, timeout)
         result_dict = pickle.loads(result_pkl)
         # TODO (wardlt): If the task did not request nodes, it won't be in `self._map_tasks_to_nodes`.
         #  Causes Parsl to hang. See Issue #3427

parsl/executors/high_throughput/process_worker_pool.py

@@ -14,6 +14,7 @@ import sys
 import threading
 import time
 import uuid
+from importlib.metadata import distributions
 from multiprocessing.managers import DictProxy
 from multiprocessing.sharedctypes import Synchronized
 from typing import Dict, List, Optional, Sequence
@@ -171,18 +172,9 @@ class Manager:
 
         self.cert_dir = cert_dir
         self.zmq_context = curvezmq.ClientContext(self.cert_dir)
-        self.task_incoming = self.zmq_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)
-        self.task_incoming.connect(task_q_url)
 
-        self.result_outgoing = self.zmq_context.socket(zmq.DEALER)
-        self.result_outgoing.setsockopt(zmq.IDENTITY, uid.encode('utf-8'))
-        self.result_outgoing.setsockopt(zmq.LINGER, 0)
-        self.result_outgoing.connect(result_q_url)
-        logger.info("Manager connected to interchange")
+        self._task_q_url = task_q_url
+        self._result_q_url = result_q_url
 
         self.uid = uid
         self.block_id = block_id
@@ -214,6 +206,8 @@ class Manager:
                                      math.floor(cores_on_node / cores_per_worker))
 
         self._mp_manager = SpawnContext.Manager()  # Starts a server process
+        self._tasks_in_progress = self._mp_manager.dict()
+        self._stop_event = threading.Event()  # when set, will begin shutdown process
 
         self.monitoring_queue = self._mp_manager.Queue()
         self.pending_task_queue = SpawnContext.Queue()
@@ -263,6 +257,7 @@ class Manager:
                'python_v': "{}.{}.{}".format(sys.version_info.major,
                                              sys.version_info.minor,
                                              sys.version_info.micro),
+               'packages': {dist.metadata['Name']: dist.version for dist in distributions()},
                'worker_count': self.worker_count,
                'uid': self.uid,
                'block_id': self.block_id,
@@ -278,46 +273,52 @@ class Manager:
         b_msg = json.dumps(msg).encode('utf-8')
         return b_msg
 
-    def heartbeat_to_incoming(self):
+    @staticmethod
+    def heartbeat_to_incoming(task_incoming: zmq.Socket) -> None:
         """ Send heartbeat to the incoming task queue
         """
         msg = {'type': 'heartbeat'}
         # don't need to dumps and encode this every time - could do as a global on import?
         b_msg = json.dumps(msg).encode('utf-8')
-        self.task_incoming.send(b_msg)
+        task_incoming.send(b_msg)
         logger.debug("Sent heartbeat")
 
-    def drain_to_incoming(self):
+    @staticmethod
+    def drain_to_incoming(task_incoming: zmq.Socket) -> None:
         """ Send heartbeat to the incoming task queue
         """
         msg = {'type': 'drain'}
         b_msg = json.dumps(msg).encode('utf-8')
-        self.task_incoming.send(b_msg)
+        task_incoming.send(b_msg)
         logger.debug("Sent drain")
 
     @wrap_with_logs
-    def pull_tasks(self, kill_event):
+    def pull_tasks(self):
         """ Pull tasks from the incoming tasks zmq pipe onto the internal
         pending task queue
-
-        Parameters:
-        -----------
-        kill_event : threading.Event
-              Event to let the thread know when it is time to die.
         """
         logger.info("starting")
+
+        # Linger is set to 0, so that the manager can exit even when there might be
+        # messages in the pipe
+        task_incoming = self.zmq_context.socket(zmq.DEALER)
+        task_incoming.setsockopt(zmq.IDENTITY, self.uid.encode('utf-8'))
+        task_incoming.setsockopt(zmq.LINGER, 0)
+        task_incoming.connect(self._task_q_url)
+        logger.info("Manager task pipe connected to interchange")
+
         poller = zmq.Poller()
-        poller.register(self.task_incoming, zmq.POLLIN)
+        poller.register(task_incoming, zmq.POLLIN)
 
         # Send a registration message
         msg = self.create_reg_message()
         logger.debug("Sending registration message: {}".format(msg))
-        self.task_incoming.send(msg)
+        task_incoming.send(msg)
         last_beat = time.time()
         last_interchange_contact = time.time()
         task_recv_counter = 0
 
-        while not kill_event.is_set():
+        while not self._stop_event.is_set():
 
             # This loop will sit inside poller.poll until either a message
             # arrives or one of these event times is reached. This code
@@ -339,12 +340,12 @@ class Manager:
                                                                        pending_task_count))
 
             if time.time() >= last_beat + self.heartbeat_period:
-                self.heartbeat_to_incoming()
+                self.heartbeat_to_incoming(task_incoming)
                 last_beat = time.time()
 
             if time.time() > self.drain_time:
                 logger.info("Requesting drain")
-                self.drain_to_incoming()
+                self.drain_to_incoming(task_incoming)
                 # This will start the pool draining...
                 # Drained exit behaviour does not happen here. It will be
                 # driven by the interchange sending a DRAINED_CODE message.
@@ -356,8 +357,8 @@ class Manager:
             poll_duration_s = max(0, next_interesting_event_time - time.time())
             socks = dict(poller.poll(timeout=poll_duration_s * 1000))
 
-            if self.task_incoming in socks and socks[self.task_incoming] == zmq.POLLIN:
-                _, pkl_msg = self.task_incoming.recv_multipart()
+            if socks.get(task_incoming) == zmq.POLLIN:
+                _, pkl_msg = task_incoming.recv_multipart()
                 tasks = pickle.loads(pkl_msg)
                 last_interchange_contact = time.time()
 
@@ -365,7 +366,7 @@ class Manager:
                     logger.debug("Got heartbeat from interchange")
                 elif tasks == DRAINED_CODE:
                     logger.info("Got fully drained message from interchange - setting kill flag")
-                    kill_event.set()
+                    self._stop_event.set()
                 else:
                     task_recv_counter += len(tasks)
                     logger.debug("Got executor tasks: {}, cumulative count of tasks: {}".format(
@@ -381,22 +382,27 @@ class Manager:
                 # Only check if no messages were received.
                 if time.time() >= last_interchange_contact + self.heartbeat_threshold:
                     logger.critical("Missing contact with interchange beyond heartbeat_threshold")
-                    kill_event.set()
+                    self._stop_event.set()
                     logger.critical("Exiting")
                     break
 
+        task_incoming.close()
+        logger.info("Exiting")
+
     @wrap_with_logs
-    def push_results(self, kill_event):
+    def push_results(self):
         """ Listens on the pending_result_queue and sends out results via zmq
-
-        Parameters:
-        -----------
-        kill_event : threading.Event
-              Event to let the thread know when it is time to die.
         """
-
         logger.debug("Starting result push thread")
 
+        # Linger is set to 0, so that the manager can exit even when there might be
+        # messages in the pipe
+        result_outgoing = self.zmq_context.socket(zmq.DEALER)
+        result_outgoing.setsockopt(zmq.IDENTITY, self.uid.encode('utf-8'))
+        result_outgoing.setsockopt(zmq.LINGER, 0)
+        result_outgoing.connect(self._result_q_url)
+        logger.info("Manager result pipe connected to interchange")
+
         push_poll_period = max(10, self.poll_period) / 1000    # push_poll_period must be atleast 10 ms
         logger.debug("push poll period: {}".format(push_poll_period))
 
@@ -404,7 +410,7 @@ class Manager:
         last_result_beat = time.time()
         items = []
 
-        while not kill_event.is_set():
+        while not self._stop_event.is_set():
             try:
                 logger.debug("Starting pending_result_queue get")
                 r = self.task_scheduler.get_result(block=True, timeout=push_poll_period)
@@ -425,7 +431,7 @@ class Manager:
                 last_beat = time.time()
                 if items:
                     logger.debug(f"Result send: Pushing {len(items)} items")
-                    self.result_outgoing.send_multipart(items)
+                    result_outgoing.send_multipart(items)
                     logger.debug("Result send: Pushed")
                     items = []
                 else:
@@ -433,21 +439,15 @@ class Manager:
             else:
                 logger.debug(f"Result send: check condition not met - deferring {len(items)} result items")
 
-        logger.critical("Exiting")
+        result_outgoing.close()
+        logger.info("Exiting")
 
     @wrap_with_logs
-    def worker_watchdog(self, kill_event: threading.Event):
-        """Keeps workers alive.
-
-        Parameters:
-        -----------
-        kill_event : threading.Event
-              Event to let the thread know when it is time to die.
-        """
-
+    def worker_watchdog(self):
+        """Keeps workers alive."""
         logger.debug("Starting worker watchdog")
 
-        while not kill_event.wait(self.heartbeat_period):
+        while not self._stop_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))
@@ -473,7 +473,7 @@ class Manager:
         logger.critical("Exiting")
 
     @wrap_with_logs
-    def handle_monitoring_messages(self, kill_event: threading.Event):
+    def handle_monitoring_messages(self):
         """Transfer messages from the managed monitoring queue to the result queue.
 
         We separate the queues so that the result queue does not rely on a manager
@@ -487,7 +487,7 @@ class Manager:
 
         poll_period_s = max(10, self.poll_period) / 1000    # Must be at least 10 ms
 
-        while not kill_event.is_set():
+        while not self._stop_event.is_set():
             try:
                 logger.debug("Starting monitor_queue.get()")
                 msg = self.monitoring_queue.get(block=True, timeout=poll_period_s)
@@ -507,9 +507,6 @@ class Manager:
 
         TODO: Move task receiving to a thread
         """
-        self._kill_event = threading.Event()
-        self._tasks_in_progress = self._mp_manager.dict()
-
         self.procs = {}
         for worker_id in range(self.worker_count):
             p = self._start_worker(worker_id)
@@ -517,34 +514,32 @@ class Manager:
 
         logger.debug("Workers started")
 
-        self._task_puller_thread = threading.Thread(target=self.pull_tasks,
-                                                    args=(self._kill_event,),
-                                                    name="Task-Puller")
-        self._result_pusher_thread = threading.Thread(target=self.push_results,
-                                                      args=(self._kill_event,),
-                                                      name="Result-Pusher")
-        self._worker_watchdog_thread = threading.Thread(target=self.worker_watchdog,
-                                                        args=(self._kill_event,),
-                                                        name="worker-watchdog")
-        self._monitoring_handler_thread = threading.Thread(target=self.handle_monitoring_messages,
-                                                           args=(self._kill_event,),
-                                                           name="Monitoring-Handler")
-
-        self._task_puller_thread.start()
-        self._result_pusher_thread.start()
-        self._worker_watchdog_thread.start()
-        self._monitoring_handler_thread.start()
+        thr_task_puller = threading.Thread(target=self.pull_tasks, name="Task-Puller")
+        thr_result_pusher = threading.Thread(
+            target=self.push_results, name="Result-Pusher"
+        )
+        thr_worker_watchdog = threading.Thread(
+            target=self.worker_watchdog, name="worker-watchdog"
+        )
+        thr_monitoring_handler = threading.Thread(
+            target=self.handle_monitoring_messages, name="Monitoring-Handler"
+        )
+
+        thr_task_puller.start()
+        thr_result_pusher.start()
+        thr_worker_watchdog.start()
+        thr_monitoring_handler.start()
 
         logger.info("Manager threads started")
 
         # This might need a multiprocessing event to signal back.
-        self._kill_event.wait()
+        self._stop_event.wait()
         logger.critical("Received kill event, terminating worker processes")
 
-        self._task_puller_thread.join()
-        self._result_pusher_thread.join()
-        self._worker_watchdog_thread.join()
-        self._monitoring_handler_thread.join()
+        thr_task_puller.join()
+        thr_result_pusher.join()
+        thr_worker_watchdog.join()
+        thr_monitoring_handler.join()
         for proc_id in self.procs:
             self.procs[proc_id].terminate()
             logger.critical("Terminating worker {}: is_alive()={}".format(self.procs[proc_id],
@@ -552,8 +547,6 @@ class Manager:
             self.procs[proc_id].join()
             logger.debug("Worker {} joined successfully".format(self.procs[proc_id]))
 
-        self.task_incoming.close()
-        self.result_outgoing.close()
         self.zmq_context.term()
         delta = time.time() - self._start_time
         logger.info("process_worker_pool ran for {} seconds".format(delta))
@@ -809,95 +802,166 @@ def start_file_logger(filename, rank, name='parsl', level=logging.DEBUG, format_
     return logger
 
 
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-d", "--debug", action='store_true',
-                        help="Enable logging at DEBUG level")
-    parser.add_argument("-a", "--addresses", default='',
-                        help="Comma separated list of addresses at which the interchange could be reached")
-    parser.add_argument("--cert_dir", required=True,
-                        help="Path to certificate directory.")
-    parser.add_argument("-l", "--logdir", default="process_worker_pool_logs",
-                        help="Process worker pool log directory")
-    parser.add_argument("-u", "--uid", default=str(uuid.uuid4()).split('-')[-1],
-                        help="Unique identifier string for Manager")
-    parser.add_argument("-b", "--block_id", default=None,
-                        help="Block identifier for Manager")
-    parser.add_argument("-c", "--cores_per_worker", default="1.0",
-                        help="Number of cores assigned to each worker process. Default=1.0")
-    parser.add_argument("-m", "--mem_per_worker", default=0,
-                        help="GB of memory assigned to each worker process. Default=0, no assignment")
-    parser.add_argument("-t", "--task_port", required=True,
-                        help="REQUIRED: Task port for receiving tasks from the interchange")
-    parser.add_argument("--max_workers_per_node", default=float('inf'),
-                        help="Caps the maximum workers that can be launched, default:infinity")
-    parser.add_argument("-p", "--prefetch_capacity", default=0,
-                        help="Number of tasks that can be prefetched to the manager. Default is 0.")
-    parser.add_argument("--hb_period", default=30,
-                        help="Heartbeat period in seconds. Uses manager default unless set")
-    parser.add_argument("--hb_threshold", default=120,
-                        help="Heartbeat threshold in seconds. Uses manager default unless set")
-    parser.add_argument("--drain_period", default=None,
-                        help="Drain this pool after specified number of seconds. By default, does not drain.")
-    parser.add_argument("--address_probe_timeout", default=30,
-                        help="Timeout to probe for viable address to interchange. Default: 30s")
-    parser.add_argument("--poll", default=10,
-                        help="Poll period used in milliseconds")
-    parser.add_argument("-r", "--result_port", required=True,
-                        help="REQUIRED: Result port for posting results to the interchange")
+def get_arg_parser() -> argparse.ArgumentParser:
 
     def strategyorlist(s: str):
-        allowed_strategies = ["none", "block", "alternating", "block-reverse"]
+        s = s.lower()
+        allowed_strategies = ("none", "block", "alternating", "block-reverse")
         if s in allowed_strategies:
             return s
         elif s[0:4] == "list":
             return s
-        else:
-            raise argparse.ArgumentTypeError("cpu-affinity must be one of {} or a list format".format(allowed_strategies))
-
-    parser.add_argument("--cpu-affinity", type=strategyorlist,
-                        required=True,
-                        help="Whether/how workers should control CPU affinity.")
-    parser.add_argument("--available-accelerators", type=str, nargs="*",
-                        help="Names of available accelerators, if not given assumed to be zero accelerators available", default=[])
-    parser.add_argument("--enable_mpi_mode", action='store_true',
-                        help="Enable MPI mode")
-    parser.add_argument("--mpi-launcher", type=str, choices=VALID_LAUNCHERS,
-                        help="MPI launcher to use iff enable_mpi_mode=true")
+        err_msg = f"cpu-affinity must be one of {allowed_strategies} or a list format"
+        raise argparse.ArgumentTypeError(err_msg)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-d", "--debug", action='store_true', help="Enable logging at DEBUG level",
+    )
+    parser.add_argument(
+        "-a",
+        "--addresses",
+        required=True,
+        help="Comma separated list of addresses at which the interchange could be reached",
+    )
+    parser.add_argument(
+        "--cert_dir", required=True, help="Path to certificate directory."
+    )
+    parser.add_argument(
+        "-l",
+        "--logdir",
+        default="process_worker_pool_logs",
+        help="Process worker pool log directory",
+    )
+    parser.add_argument(
+        "-u",
+        "--uid",
+        default=str(uuid.uuid4()).split('-')[-1],
+        help="Unique identifier string for Manager",
+    )
+    parser.add_argument(
+        "-b", "--block_id", default=None, help="Block identifier for Manager"
+    )
+    parser.add_argument(
+        "-c",
+        "--cores_per_worker",
+        default="1.0",
+        help="Number of cores assigned to each worker process. Default=1.0",
+    )
+    parser.add_argument(
+        "-m",
+        "--mem_per_worker",
+        default=0,
+        help="GB of memory assigned to each worker process. Default=0, no assignment",
+    )
+    parser.add_argument(
+        "-t",
+        "--task_port",
+        required=True,
+        help="Task port for receiving tasks from the interchange",
+    )
+    parser.add_argument(
+        "--max_workers_per_node",
+        default=float('inf'),
+        help="Caps the maximum workers that can be launched, default:infinity",
+    )
+    parser.add_argument(
+        "-p",
+        "--prefetch_capacity",
+        default=0,
+        help="Number of tasks that can be prefetched to the manager. Default is 0.",
+    )
+    parser.add_argument(
+        "--hb_period",
+        default=30,
+        help="Heartbeat period in seconds. Uses manager default unless set",
+    )
+    parser.add_argument(
+        "--hb_threshold",
+        default=120,
+        help="Heartbeat threshold in seconds. Uses manager default unless set",
+    )
+    parser.add_argument(
+        "--drain_period",
+        default=None,
+        help="Drain this pool after specified number of seconds. By default, does not drain.",
+    )
+    parser.add_argument(
+        "--address_probe_timeout",
+        default=30,
+        help="Timeout to probe for viable address to interchange. Default: 30s",
+    )
+    parser.add_argument(
+        "--poll", default=10, help="Poll period used in milliseconds"
+    )
+    parser.add_argument(
+        "-r",
+        "--result_port",
+        required=True,
+        help="Result port for posting results to the interchange",
+    )
+    parser.add_argument(
+        "--cpu-affinity",
+        type=strategyorlist,
+        required=True,
+        help="Whether/how workers should control CPU affinity.",
+    )
+    parser.add_argument(
+        "--available-accelerators",
+        type=str,
+        nargs="*",
+        default=[],
+        help="Names of available accelerators, if not given assumed to be zero accelerators available",
+    )
+    parser.add_argument(
+        "--enable_mpi_mode", action='store_true', help="Enable MPI mode"
+    )
+    parser.add_argument(
+        "--mpi-launcher",
+        type=str,
+        choices=VALID_LAUNCHERS,
+        help="MPI launcher to use iff enable_mpi_mode=true",
+    )
+
+    return parser
+
 
+if __name__ == "__main__":
+    parser = get_arg_parser()
     args = parser.parse_args()
 
     os.makedirs(os.path.join(args.logdir, "block-{}".format(args.block_id), args.uid), exist_ok=True)
 
+    logger = start_file_logger(
+        f'{args.logdir}/block-{args.block_id}/{args.uid}/manager.log',
+        0,
+        level=logging.DEBUG if args.debug is True else logging.INFO
+    )
+    logger.info(
+        f"\n  Python version: {sys.version}"
+        f"  Debug logging: {args.debug}"
+        f"  Certificates dir: {args.cert_dir}"
+        f"  Log dir: {args.logdir}"
+        f"  Manager ID: {args.uid}"
+        f"  Block ID: {args.block_id}"
+        f"  cores_per_worker: {args.cores_per_worker}"
+        f"  mem_per_worker: {args.mem_per_worker}"
+        f"  task_port: {args.task_port}"
+        f"  result_port: {args.result_port}"
+        f"  addresses: {args.addresses}"
+        f"  max_workers_per_node: {args.max_workers_per_node}"
+        f"  poll_period: {args.poll}"
+        f"  address_probe_timeout: {args.address_probe_timeout}"
+        f"  Prefetch capacity: {args.prefetch_capacity}"
+        f"  Heartbeat threshold: {args.hb_threshold}"
+        f"  Heartbeat period: {args.hb_period}"
+        f"  Drain period: {args.drain_period}"
+        f"  CPU affinity: {args.cpu_affinity}"
+        f"  Accelerators: {' '.join(args.available_accelerators)}"
+        f"  enable_mpi_mode: {args.enable_mpi_mode}"
+        f"  mpi_launcher: {args.mpi_launcher}"
+    )
     try:
-        logger = start_file_logger('{}/block-{}/{}/manager.log'.format(args.logdir, args.block_id, args.uid),
-                                   0,
-                                   level=logging.DEBUG if args.debug is True else logging.INFO)
-
-        logger.info("Python version: {}".format(sys.version))
-        logger.info("Debug logging: {}".format(args.debug))
-        logger.info("Certificates dir: {}".format(args.cert_dir))
-        logger.info("Log dir: {}".format(args.logdir))
-        logger.info("Manager ID: {}".format(args.uid))
-        logger.info("Block ID: {}".format(args.block_id))
-        logger.info("cores_per_worker: {}".format(args.cores_per_worker))
-        logger.info("mem_per_worker: {}".format(args.mem_per_worker))
-        logger.info("task_port: {}".format(args.task_port))
-        logger.info("result_port: {}".format(args.result_port))
-        logger.info("addresses: {}".format(args.addresses))
-        logger.info("max_workers_per_node: {}".format(args.max_workers_per_node))
-        logger.info("poll_period: {}".format(args.poll))
-        logger.info("address_probe_timeout: {}".format(args.address_probe_timeout))
-        logger.info("Prefetch capacity: {}".format(args.prefetch_capacity))
-        logger.info("Heartbeat threshold: {}".format(args.hb_threshold))
-        logger.info("Heartbeat period: {}".format(args.hb_period))
-        logger.info("Drain period: {}".format(args.drain_period))
-        logger.info("CPU affinity: {}".format(args.cpu_affinity))
-        logger.info("Accelerators: {}".format(" ".join(args.available_accelerators)))
-        logger.info("enable_mpi_mode: {}".format(args.enable_mpi_mode))
-        logger.info("mpi_launcher: {}".format(args.mpi_launcher))
-
         manager = Manager(task_port=args.task_port,
                           result_port=args.result_port,
                           addresses=args.addresses,

parsl/monitoring/visualization/plots/default/workflow_plots.py

@@ -290,10 +290,10 @@ def workflow_dag_plot(df_tasks, group_by_apps=True):
         edge_trace['y'] += tuple([y0, y1, None])
 
     # Create figure:
+    title = go.layout.Title(text='Workflow DAG', font=dict(size=16))
     fig = go.Figure(data=[edge_trace] + node_traces,
                     layout=go.Layout(
-                    title='Workflow DAG',
-                    titlefont=dict(size=16),
+                    title=title,
                     showlegend=True,
                     hovermode='closest',
                     margin=dict(b=20, l=5, r=5, t=40),   # noqa: E741