parsl 2024.3.18__py3-none-any.whl → 2025.1.13__py3-none-any.whl

parsl/monitoring/radios/multiprocessing.py

@@ -0,0 +1,17 @@
+from multiprocessing.queues import Queue
+
+from parsl.monitoring.radios.base import MonitoringRadioSender
+
+
+class MultiprocessingQueueRadioSender(MonitoringRadioSender):
+    """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
+    access to a Queue shared with the monitoring database code (bypassing the
+    monitoring router).
+    """
+    def __init__(self, queue: Queue) -> None:
+        self.queue = queue
+
+    def send(self, message: object) -> None:
+        self.queue.put(message)

parsl/monitoring/radios/udp.py

@@ -0,0 +1,56 @@
+import logging
+import pickle
+import socket
+
+from parsl.monitoring.radios.base import MonitoringRadioSender
+
+
+class UDPRadioSender(MonitoringRadioSender):
+
+    def __init__(self, monitoring_url: str, timeout: int = 10):
+        """
+        Parameters
+        ----------
+
+        monitoring_url : str
+            URL of the form <scheme>://<IP>:<PORT>
+        timeout : int
+            timeout, default=10s
+        """
+        self.monitoring_url = monitoring_url
+        self.sock_timeout = timeout
+        try:
+            self.scheme, self.ip, port = (x.strip('/') for x in monitoring_url.split(':'))
+            self.port = int(port)
+        except Exception:
+            raise Exception("Failed to parse monitoring url: {}".format(monitoring_url))
+
+        self.sock = socket.socket(socket.AF_INET,
+                                  socket.SOCK_DGRAM,
+                                  socket.IPPROTO_UDP)  # UDP
+        self.sock.settimeout(self.sock_timeout)
+
+    def send(self, message: object) -> None:
+        """ Sends a message to the UDP receiver
+
+        Parameter
+        ---------
+
+        message: object
+            Arbitrary pickle-able object that is to be sent
+
+        Returns:
+            None
+        """
+        try:
+            buffer = pickle.dumps(message)
+        except Exception:
+            logging.exception("Exception during pickling", exc_info=True)
+            return
+
+        try:
+            self.sock.sendto(buffer, (self.ip, self.port))
+        except socket.timeout:
+            logging.error("Could not send message within timeout limit")
+            return
+        return

parsl/monitoring/radios/zmq.py

@@ -0,0 +1,17 @@
+import zmq
+
+from parsl.monitoring.radios.base import MonitoringRadioSender
+
+
+class ZMQRadioSender(MonitoringRadioSender):
+    """A monitoring radio which connects over ZMQ. This radio is not
+    thread-safe, because its use of ZMQ is not thread-safe.
+    """
+
+    def __init__(self, hub_address: str, hub_zmq_port: int) -> None:
+        self._hub_channel = zmq.Context().socket(zmq.DEALER)
+        self._hub_channel.set_hwm(0)
+        self._hub_channel.connect(f"tcp://{hub_address}:{hub_zmq_port}")
+
+    def send(self, message: object) -> None:
+        self._hub_channel.send_pyobj(message)

parsl/monitoring/remote.py

@@ -1,21 +1,24 @@
+import datetime
+import logging
 import os
 import time
-import logging
-import datetime
 from functools import wraps
-
-from parsl.multiprocessing import ForkProcess
 from multiprocessing import Event
-from parsl.process_loggers import wrap_with_logs
+from typing import Any, Callable, Dict, List, Sequence, Tuple
 
 from parsl.monitoring.message_type import MessageType
-from parsl.monitoring.radios import MonitoringRadio, UDPRadio, HTEXRadio, FilesystemRadio
-from typing import Any, Callable, Dict, List, Sequence, Tuple
+from parsl.monitoring.radios.base import MonitoringRadioSender
+from parsl.monitoring.radios.filesystem import FilesystemRadioSender
+from parsl.monitoring.radios.htex import HTEXRadioSender
+from parsl.monitoring.radios.udp import UDPRadioSender
+from parsl.multiprocessing import ForkProcess
+from parsl.process_loggers import wrap_with_logs
 
 logger = logging.getLogger(__name__)
 
 
-def monitor_wrapper(f: Any,           # per app
+def monitor_wrapper(*,
+                    f: Any,           # per app
                     args: Sequence,   # per invocation
                     kwargs: Dict,     # per invocation
                     x_try_id: int,    # per invocation
@@ -95,6 +98,20 @@ def monitor_wrapper(f: Any,           # per app
     return (wrapped, args, new_kwargs)
 
 
+def get_radio(radio_mode: str, monitoring_hub_url: str, task_id: int, run_dir: str) -> MonitoringRadioSender:
+    radio: MonitoringRadioSender
+    if radio_mode == "udp":
+        radio = UDPRadioSender(monitoring_hub_url)
+    elif radio_mode == "htex":
+        radio = HTEXRadioSender(monitoring_hub_url)
+    elif radio_mode == "filesystem":
+        radio = FilesystemRadioSender(monitoring_url=monitoring_hub_url,
+                                      run_dir=run_dir)
+    else:
+        raise RuntimeError(f"Unknown radio mode: {radio_mode}")
+    return radio
+
+
 @wrap_with_logs
 def send_first_message(try_id: int,
                        task_id: int,
@@ -118,21 +135,10 @@ def send_first_last_message(try_id: int,
                             monitoring_hub_url: str,
                             run_id: str, radio_mode: str, run_dir: str,
                             is_last: bool) -> None:
-    import platform
     import os
+    import platform
 
-    radio: MonitoringRadio
-    if radio_mode == "udp":
-        radio = UDPRadio(monitoring_hub_url,
-                         source_id=task_id)
-    elif radio_mode == "htex":
-        radio = HTEXRadio(monitoring_hub_url,
-                          source_id=task_id)
-    elif radio_mode == "filesystem":
-        radio = FilesystemRadio(monitoring_url=monitoring_hub_url,
-                                source_id=task_id, run_dir=run_dir)
-    else:
-        raise RuntimeError(f"Unknown radio mode: {radio_mode}")
+    radio = get_radio(radio_mode, monitoring_hub_url, task_id, run_dir)
 
     msg = (MessageType.RESOURCE_INFO,
            {'run_id': run_id,
@@ -171,24 +177,14 @@ def monitor(pid: int,
     """
     import logging
     import platform
+
     import psutil
 
     from parsl.utils import setproctitle
 
     setproctitle("parsl: task resource monitor")
 
-    radio: MonitoringRadio
-    if radio_mode == "udp":
-        radio = UDPRadio(monitoring_hub_url,
-                         source_id=task_id)
-    elif radio_mode == "htex":
-        radio = HTEXRadio(monitoring_hub_url,
-                          source_id=task_id)
-    elif radio_mode == "filesystem":
-        radio = FilesystemRadio(monitoring_url=monitoring_hub_url,
-                                source_id=task_id, run_dir=run_dir)
-    else:
-        raise RuntimeError(f"Unknown radio mode: {radio_mode}")
+    radio = get_radio(radio_mode, monitoring_hub_url, task_id, run_dir)
 
     logging.debug("start of monitor")
 
@@ -199,10 +195,10 @@ def monitor(pid: int,
 
     pm = psutil.Process(pid)
 
-    children_user_time = {}  # type: Dict[int, float]
-    children_system_time = {}  # type: Dict[int, float]
-    children_num_ctx_switches_voluntary = {}  # type: Dict[int, float]
-    children_num_ctx_switches_involuntary = {}  # type: Dict[int, float]
+    children_user_time: Dict[int, float] = {}
+    children_system_time: Dict[int, float] = {}
+    children_num_ctx_switches_voluntary: Dict[int, float] = {}
+    children_num_ctx_switches_involuntary: Dict[int, float] = {}
 
     def accumulate_and_prepare() -> Dict[str, Any]:
         d = {"psutil_process_" + str(k): v for k, v in pm.as_dict().items() if k in simple}

parsl/monitoring/router.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import logging
+import multiprocessing.queues as mpq
+import os
+import pickle
+import socket
+import threading
+import time
+from multiprocessing.synchronize import Event
+from typing import Optional, Tuple
+
+import typeguard
+import zmq
+
+from parsl.log_utils import set_file_logger
+from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
+from parsl.monitoring.types import TaggedMonitoringMessage
+from parsl.process_loggers import wrap_with_logs
+from parsl.utils import setproctitle
+
+logger = logging.getLogger(__name__)
+
+
+class MonitoringRouter:
+
+    def __init__(self,
+                 *,
+                 hub_address: str,
+                 udp_port: Optional[int] = None,
+                 zmq_port_range: Tuple[int, int] = (55050, 56000),
+
+                 monitoring_hub_address: str = "127.0.0.1",
+                 run_dir: str = ".",
+                 logging_level: int = logging.INFO,
+                 atexit_timeout: int = 3,   # in seconds
+                 resource_msgs: mpq.Queue,
+                 exit_event: Event,
+                 ):
+        """ Initializes a monitoring configuration class.
+
+        Parameters
+        ----------
+        hub_address : str
+             The ip address at which the workers will be able to reach the Hub.
+        udp_port : int
+             The specific port at which workers will be able to reach the Hub via UDP. Default: None
+        zmq_port_range : tuple(int, int)
+             The MonitoringHub picks ports at random from the range which will be used by Hub.
+             Default: (55050, 56000)
+        run_dir : str
+             Parsl log directory paths. Logs and temp files go here. Default: '.'
+        logging_level : int
+             Logging level as defined in the logging module. Default: logging.INFO
+        atexit_timeout : float, optional
+            The amount of time in seconds to terminate the hub without receiving any messages, after the last dfk workflow message is received.
+        resource_msgs : multiprocessing.Queue
+            A multiprocessing queue to receive messages to be routed onwards to the database process
+        exit_event : Event
+            An event that the main Parsl process will set to signal that the monitoring router should shut down.
+        """
+        os.makedirs(run_dir, exist_ok=True)
+        self.logger = set_file_logger(f"{run_dir}/monitoring_router.log",
+                                      name="monitoring_router",
+                                      level=logging_level)
+        self.logger.debug("Monitoring router starting")
+
+        self.hub_address = hub_address
+        self.atexit_timeout = atexit_timeout
+
+        self.loop_freq = 10.0  # milliseconds
+
+        # Initialize the UDP socket
+        self.udp_sock = socket.socket(socket.AF_INET,
+                                      socket.SOCK_DGRAM,
+                                      socket.IPPROTO_UDP)
+
+        # We are trying to bind to all interfaces with 0.0.0.0
+        if not udp_port:
+            self.udp_sock.bind(('0.0.0.0', 0))
+            self.udp_port = self.udp_sock.getsockname()[1]
+        else:
+            self.udp_port = udp_port
+            try:
+                self.udp_sock.bind(('0.0.0.0', self.udp_port))
+            except Exception as e:
+                raise RuntimeError(f"Could not bind to udp_port {udp_port} because: {e}")
+        self.udp_sock.settimeout(self.loop_freq / 1000)
+        self.logger.info("Initialized the UDP socket on 0.0.0.0:{}".format(self.udp_port))
+
+        self._context = zmq.Context()
+        self.zmq_receiver_channel = self._context.socket(zmq.DEALER)
+        self.zmq_receiver_channel.setsockopt(zmq.LINGER, 0)
+        self.zmq_receiver_channel.set_hwm(0)
+        self.zmq_receiver_channel.RCVTIMEO = int(self.loop_freq)  # in milliseconds
+        self.logger.debug("hub_address: {}. zmq_port_range {}".format(hub_address, zmq_port_range))
+        self.zmq_receiver_port = self.zmq_receiver_channel.bind_to_random_port("tcp://*",
+                                                                               min_port=zmq_port_range[0],
+                                                                               max_port=zmq_port_range[1])
+
+        self.target_radio = MultiprocessingQueueRadioSender(resource_msgs)
+        self.exit_event = exit_event
+
+    @wrap_with_logs(target="monitoring_router")
+    def start(self) -> None:
+        self.logger.info("Starting UDP listener thread")
+        udp_radio_receiver_thread = threading.Thread(target=self.start_udp_listener, daemon=True)
+        udp_radio_receiver_thread.start()
+
+        self.logger.info("Starting ZMQ listener thread")
+        zmq_radio_receiver_thread = threading.Thread(target=self.start_zmq_listener, daemon=True)
+        zmq_radio_receiver_thread.start()
+
+        self.logger.info("Joining on ZMQ listener thread")
+        zmq_radio_receiver_thread.join()
+        self.logger.info("Joining on UDP listener thread")
+        udp_radio_receiver_thread.join()
+        self.logger.info("Joined on both ZMQ and UDP listener threads")
+
+    @wrap_with_logs(target="monitoring_router")
+    def start_udp_listener(self) -> None:
+        try:
+            while not self.exit_event.is_set():
+                try:
+                    data, addr = self.udp_sock.recvfrom(2048)
+                    resource_msg = pickle.loads(data)
+                    self.logger.debug("Got UDP Message from {}: {}".format(addr, resource_msg))
+                    self.target_radio.send(resource_msg)
+                except socket.timeout:
+                    pass
+
+            self.logger.info("UDP listener draining")
+            last_msg_received_time = time.time()
+            while time.time() - last_msg_received_time < self.atexit_timeout:
+                try:
+                    data, addr = self.udp_sock.recvfrom(2048)
+                    msg = pickle.loads(data)
+                    self.logger.debug("Got UDP Message from {}: {}".format(addr, msg))
+                    self.target_radio.send(msg)
+                    last_msg_received_time = time.time()
+                except socket.timeout:
+                    pass
+
+            self.logger.info("UDP listener finishing normally")
+        finally:
+            self.logger.info("UDP listener finished")
+
+    @wrap_with_logs(target="monitoring_router")
+    def start_zmq_listener(self) -> None:
+        try:
+            while not self.exit_event.is_set():
+                try:
+                    dfk_loop_start = time.time()
+                    while time.time() - dfk_loop_start < 1.0:  # TODO make configurable
+                        # note that nothing checks that msg really is of the annotated type
+                        msg: TaggedMonitoringMessage
+                        msg = self.zmq_receiver_channel.recv_pyobj()
+
+                        assert isinstance(msg, tuple), "ZMQ Receiver expects only tuples, got {}".format(msg)
+                        assert len(msg) >= 1, "ZMQ Receiver expects tuples of length at least 1, got {}".format(msg)
+                        assert len(msg) == 2, "ZMQ Receiver expects message tuples of exactly length 2, got {}".format(msg)
+
+                        self.target_radio.send(msg)
+                except zmq.Again:
+                    pass
+                except Exception:
+                    # This will catch malformed messages. What happens if the
+                    # channel is broken in such a way that it always raises
+                    # an exception? Looping on this would maybe be the wrong
+                    # thing to do.
+                    self.logger.warning("Failure processing a ZMQ message", exc_info=True)
+
+            self.logger.info("ZMQ listener finishing normally")
+        finally:
+            self.logger.info("ZMQ listener finished")
+
+
+@wrap_with_logs
+@typeguard.typechecked
+def router_starter(*,
+                   comm_q: mpq.Queue,
+                   exception_q: mpq.Queue,
+                   resource_msgs: mpq.Queue,
+                   exit_event: Event,
+
+                   hub_address: str,
+                   udp_port: Optional[int],
+                   zmq_port_range: Tuple[int, int],
+
+                   run_dir: str,
+                   logging_level: int) -> None:
+    setproctitle("parsl: monitoring router")
+    try:
+        router = MonitoringRouter(hub_address=hub_address,
+                                  udp_port=udp_port,
+                                  zmq_port_range=zmq_port_range,
+                                  run_dir=run_dir,
+                                  logging_level=logging_level,
+                                  resource_msgs=resource_msgs,
+                                  exit_event=exit_event)
+    except Exception as e:
+        logger.error("MonitoringRouter construction failed.", exc_info=True)
+        comm_q.put(f"Monitoring router construction failed: {e}")
+    else:
+        comm_q.put((router.udp_port, router.zmq_receiver_port))
+
+        router.logger.info("Starting MonitoringRouter in router_starter")
+        try:
+            router.start()
+        except Exception as e:
+            router.logger.exception("router.start exception")
+            exception_q.put(('Hub', str(e)))

parsl/monitoring/types.py

@@ -1,12 +1,11 @@
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Dict, Tuple
+
 from typing_extensions import TypeAlias
+
 from parsl.monitoring.message_type import MessageType
 
-# A basic parsl monitoring message is wrapped by up to two wrappers:
-# The basic monitoring message dictionary can first be tagged, giving
-# a TaggedMonitoringMessage, and then that can be further tagged with
-# an often unused sender address, giving an AddressedMonitoringMessage.
+# A MonitoringMessage dictionary can be tagged, giving a
+# TaggedMonitoringMessage.
 
 MonitoringMessage: TypeAlias = Dict[str, Any]
 TaggedMonitoringMessage: TypeAlias = Tuple[MessageType, MonitoringMessage]
-AddressedMonitoringMessage: TypeAlias = Tuple[TaggedMonitoringMessage, Union[str, int]]

parsl/monitoring/visualization/app.py

@@ -1,8 +1,10 @@
-from flask import Flask
-from parsl.monitoring.visualization.models import db
 import argparse
 import os
 
+from flask import Flask
+
+from parsl.monitoring.visualization.models import db
+
 
 def cli_run():
     """ Instantiates the Monitoring viz server

parsl/monitoring/visualization/models.py

@@ -1,6 +1,5 @@
 from flask_sqlalchemy import SQLAlchemy
 
-
 WORKFLOW = 'workflow'    # Workflow table includes workflow metadata
 TASK = 'task'            # Task table includes task metadata
 STATUS = 'status'        # Status table includes task status

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

@@ -1,13 +1,17 @@
 import math
+
+import networkx as nx
 import numpy as np
 import pandas as pd
-import plotly.graph_objs as go
 import plotly.figure_factory as ff
+import plotly.graph_objs as go
 from plotly.offline import plot
-import networkx as nx
-
-from parsl.monitoring.visualization.utils import timestamp_to_int, num_to_timestamp, DB_DATE_FORMAT
 
+from parsl.monitoring.visualization.utils import (
+    DB_DATE_FORMAT,
+    num_to_timestamp,
+    timestamp_to_int,
+)
 
 # gantt_colors must assign a color value for every state name defined
 # in parsl/dataflow/states.py

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

@@ -1,4 +1,5 @@
 import math
+
 import numpy as np
 import pandas as pd
 import plotly.graph_objs as go

parsl/monitoring/visualization/utils.py

@@ -1,6 +1,5 @@
 from datetime import datetime
 
-
 DB_DATE_FORMAT = '%Y-%m-%d %H:%M:%S'
 
 

parsl/monitoring/visualization/views.py

@@ -1,15 +1,22 @@
-from flask import render_template
-from flask import current_app as app
 import pandas as pd
+from flask import current_app as app
+from flask import render_template
 
 import parsl.monitoring.queries.pandas as queries
-
-from parsl.monitoring.visualization.models import Workflow, Task, Status, db
-
-from parsl.monitoring.visualization.plots.default.workflow_plots import task_gantt_plot, task_per_app_plot, workflow_dag_plot
-from parsl.monitoring.visualization.plots.default.task_plots import time_series_memory_per_task_plot
-from parsl.monitoring.visualization.plots.default.workflow_resource_plots import (resource_distribution_plot,
-                                                                                  resource_efficiency, worker_efficiency)
+from parsl.monitoring.visualization.models import Status, Task, Workflow, db
+from parsl.monitoring.visualization.plots.default.task_plots import (
+    time_series_memory_per_task_plot,
+)
+from parsl.monitoring.visualization.plots.default.workflow_plots import (
+    task_gantt_plot,
+    task_per_app_plot,
+    workflow_dag_plot,
+)
+from parsl.monitoring.visualization.plots.default.workflow_resource_plots import (
+    resource_distribution_plot,
+    resource_efficiency,
+    worker_efficiency,
+)
 
 dummy = True
 

parsl/multiprocessing.py

@@ -6,7 +6,6 @@ import multiprocessing
 import multiprocessing.queues
 import platform
 from multiprocessing.context import ForkProcess as ForkProcessType
-
 from typing import Callable
 
 logger = logging.getLogger(__name__)

parsl/process_loggers.py

@@ -1,7 +1,6 @@
+import functools
 import logging
 import threading
-import functools
-
 from typing import Callable, Optional
 
 

parsl/providers/__init__.py

@@ -1,33 +1,24 @@
-# Workstation Provider
-from parsl.providers.local.local import LocalProvider
-
-# Cluster Providers
-
-from parsl.providers.cobalt.cobalt import CobaltProvider
-from parsl.providers.condor.condor import CondorProvider
-from parsl.providers.grid_engine.grid_engine import GridEngineProvider
-from parsl.providers.slurm.slurm import SlurmProvider
-from parsl.providers.torque.torque import TorqueProvider
-from parsl.providers.pbspro.pbspro import PBSProProvider
-from parsl.providers.lsf.lsf import LSFProvider
-from parsl.providers.ad_hoc.ad_hoc import AdHocProvider
-
 # Cloud Providers
 from parsl.providers.aws.aws import AWSProvider
-from parsl.providers.googlecloud.googlecloud import GoogleCloudProvider
 from parsl.providers.azure.azure import AzureProvider
+from parsl.providers.condor.condor import CondorProvider
+from parsl.providers.googlecloud.googlecloud import GoogleCloudProvider
+from parsl.providers.grid_engine.grid_engine import GridEngineProvider
 
 # Kubernetes
 from parsl.providers.kubernetes.kube import KubernetesProvider
+from parsl.providers.local.local import LocalProvider
+from parsl.providers.lsf.lsf import LSFProvider
+from parsl.providers.pbspro.pbspro import PBSProProvider
+from parsl.providers.slurm.slurm import SlurmProvider
+from parsl.providers.torque.torque import TorqueProvider
 
 __all__ = ['LocalProvider',
-           'CobaltProvider',
            'CondorProvider',
            'GridEngineProvider',
            'SlurmProvider',
            'TorqueProvider',
            'LSFProvider',
-           'AdHocProvider',
            'PBSProProvider',
            'AWSProvider',
            'GoogleCloudProvider',

parsl/providers/aws/aws.py

@@ -4,13 +4,12 @@ import os
 import time
 from string import Template
 
-from parsl.errors import ConfigurationError
+from parsl.errors import ConfigurationError, OptionalModuleMissing
 from parsl.jobs.states import JobState, JobStatus
+from parsl.launchers import SingleNodeLauncher
 from parsl.providers.aws.template import template_string
 from parsl.providers.base import ExecutionProvider
-from parsl.errors import OptionalModuleMissing
 from parsl.utils import RepresentationMixin
-from parsl.launchers import SingleNodeLauncher
 
 logger = logging.getLogger(__name__)
 

parsl/providers/azure/azure.py

@@ -4,22 +4,21 @@ import os
 import time
 from string import Template
 
-from parsl.errors import ConfigurationError
+from parsl.errors import ConfigurationError, OptionalModuleMissing
 from parsl.jobs.states import JobState, JobStatus
+from parsl.launchers import SingleNodeLauncher
 from parsl.providers.azure.template import template_string
 from parsl.providers.base import ExecutionProvider
-from parsl.errors import OptionalModuleMissing
 from parsl.utils import RepresentationMixin
-from parsl.launchers import SingleNodeLauncher
 
 logger = logging.getLogger(__name__)
 
 try:
     from azure.common.credentials import ServicePrincipalCredentials
-    from azure.mgmt.resource import ResourceManagementClient
-    from azure.mgmt.network import NetworkManagementClient
     from azure.mgmt.compute import ComputeManagementClient
     from azure.mgmt.compute.models import DiskCreateOption
+    from azure.mgmt.network import NetworkManagementClient
+    from azure.mgmt.resource import ResourceManagementClient
     from msrestazure.azure_exceptions import CloudError
 
     _api_enabled = True

parsl/providers/base.py

@@ -1,8 +1,7 @@
-from abc import ABCMeta, abstractmethod, abstractproperty
 import logging
+from abc import ABCMeta, abstractmethod, abstractproperty
 from typing import Any, Dict, List, Optional
 
-from parsl.channels.base import Channel
 from parsl.jobs.states import JobStatus
 
 logger = logging.getLogger(__name__)
@@ -12,7 +11,7 @@ class ExecutionProvider(metaclass=ABCMeta):
     """Execution providers are responsible for managing execution resources
     that have a Local Resource Manager (LRM). For instance, campus clusters
     and supercomputers generally have LRMs (schedulers) such as Slurm,
-    Torque/PBS, Condor and Cobalt. Clouds, on the other hand, have API
+    Torque/PBS, and Condor. Clouds, on the other hand, have API
     interfaces that allow much more fine-grained composition of an execution
     environment. An execution provider abstracts these types of resources and
     provides a single uniform interface to them.
@@ -154,18 +153,3 @@ class ExecutionProvider(metaclass=ABCMeta):
         :return: the number of seconds to wait between calls to status()
         """
         pass
-
-
-class Channeled():
-    """A marker type to indicate that parsl should manage a Channel for this provider"""
-    def __init__(self) -> None:
-        self.channel: Channel
-        pass
-
-
-class MultiChanneled():
-    """A marker type to indicate that parsl should manage multiple Channels for this provider"""
-
-    def __init__(self) -> None:
-        self.channels: List[Channel]
-        pass