parsl 2025.9.8__py3-none-any.whl → 2025.11.10__py3-none-any.whl

parsl/executors/high_throughput/mpi_resource_management.py

@@ -9,7 +9,6 @@ from enum import Enum
 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
 
 logger = logging.getLogger(__name__)
 
@@ -146,11 +145,11 @@ class MPITaskScheduler(TaskScheduler):
         )
         acquired_nodes = []
         with self._free_node_counter.get_lock():
-            if num_nodes <= self._free_node_counter.value:  # type: ignore[attr-defined]
-                self._free_node_counter.value -= num_nodes  # type: ignore[attr-defined]
+            if num_nodes <= self._free_node_counter.value:
+                self._free_node_counter.value -= num_nodes
             else:
                 raise MPINodesUnavailable(
-                    requested=num_nodes, available=self._free_node_counter.value  # type: ignore[attr-defined]
+                    requested=num_nodes, available=self._free_node_counter.value
                 )
 
             for i in range(num_nodes):
@@ -163,17 +162,14 @@ class MPITaskScheduler(TaskScheduler):
         for node in nodes:
             self.nodes_q.put(node)
         with self._free_node_counter.get_lock():
-            self._free_node_counter.value += len(nodes)  # type: ignore[attr-defined]
+            self._free_node_counter.value += len(nodes)
 
     def put_task(self, task_package: dict):
         """Schedule task if resources are available otherwise backlog the task"""
-        user_ns = locals()
-        user_ns.update({"__builtins__": __builtins__})
-        _f, _args, _kwargs, resource_spec = unpack_res_spec_apply_message(task_package["buffer"])
+        resource_spec = task_package.get("context", {}).get("resource_spec", {})
 
-        nodes_needed = resource_spec.get("num_nodes")
-        tid = task_package["task_id"]
-        if nodes_needed:
+        if nodes_needed := resource_spec.get("num_nodes"):
+            tid = task_package["task_id"]
             try:
                 allocated_nodes = self._get_nodes(nodes_needed)
             except MPINodesUnavailable:
@@ -183,9 +179,6 @@ class MPITaskScheduler(TaskScheduler):
             else:
                 resource_spec["MPI_NODELIST"] = ",".join(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
 
         self.pending_task_q.put(task_package)
 

parsl/executors/high_throughput/process_worker_pool.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 import argparse
+import importlib
 import logging
 import math
 import multiprocessing
@@ -17,7 +18,7 @@ from importlib.metadata import distributions
 from multiprocessing.context import SpawnProcess
 from multiprocessing.managers import DictProxy
 from multiprocessing.sharedctypes import Synchronized
-from typing import Dict, List, Optional, Sequence
+from typing import Callable, Dict, List, Optional, Sequence
 
 import psutil
 import zmq
@@ -348,7 +349,7 @@ class Manager:
 
             logger.debug(
                 'ready workers: %d, pending tasks: %d',
-                self.ready_worker_count.value,  # type: ignore[attr-defined]
+                self.ready_worker_count.value,
                 pending_task_count,
             )
 
@@ -373,10 +374,12 @@ class Manager:
             if socks.get(ix_sock) == zmq.POLLIN:
                 pkl_msg = ix_sock.recv()
                 tasks = pickle.loads(pkl_msg)
+                del pkl_msg
+
                 last_interchange_contact = time.time()
 
                 if tasks == HEARTBEAT_CODE:
-                    logger.debug("Got heartbeat from interchange")
+                    logger.debug("Got heartbeat response from interchange")
                 elif tasks == DRAINED_CODE:
                     logger.info("Got fully drained message from interchange - setting kill flag")
                     self._stop_event.set()
@@ -454,6 +457,7 @@ class Manager:
                                               'exception': serialize(RemoteExceptionWrapper(*sys.exc_info()))}
                             pkl_package = pickle.dumps(result_package)
                             self.pending_result_queue.put(pkl_package)
+                            del pkl_package
                     except KeyError:
                         logger.info("Worker {} was not busy when it died".format(worker_id))
 
@@ -603,6 +607,10 @@ def update_resource_spec_env_vars(mpi_launcher: str, resource_spec: Dict, node_i
 
 
 def _init_mpi_env(mpi_launcher: str, resource_spec: Dict):
+    for varname in resource_spec:
+        envname = "PARSL_" + str(varname).upper()
+        os.environ[envname] = str(resource_spec[varname])
+
     node_list = resource_spec.get("MPI_NODELIST")
     if node_list is None:
         return
@@ -753,8 +761,8 @@ def worker(
             worker_enqueued = True
 
         try:
-            # The worker will receive {'task_id':<tid>, 'buffer':<buf>}
             req = task_queue.get(timeout=task_queue_timeout)
+            # req is {'task_id':<tid>, 'buffer':<buf>, 'resource_spec':<dict>}
         except queue.Empty:
             continue
 
@@ -766,17 +774,33 @@ def worker(
             ready_worker_count.value -= 1
         worker_enqueued = False
 
-        _init_mpi_env(mpi_launcher=mpi_launcher, resource_spec=req["resource_spec"])
+        ctxt = req["context"]
+        res_spec = ctxt.get("resource_spec", {})
+
+        _init_mpi_env(mpi_launcher=mpi_launcher, resource_spec=res_spec)
+
+        exec_func: Callable = execute_task
+        exec_args = ()
+        exec_kwargs = {}
 
         try:
-            result = execute_task(req['buffer'])
+            if task_executor := ctxt.get("task_executor", None):
+                mod_name, _, fn_name = task_executor["f"].rpartition(".")
+                exec_mod = importlib.import_module(mod_name)
+                exec_func = getattr(exec_mod, fn_name)
+
+                exec_args = task_executor.get("a", ())
+                exec_kwargs = task_executor.get("k", {})
+
+            result = exec_func(req['buffer'], *exec_args, **exec_kwargs)
             serialized_result = serialize(result, buffer_threshold=1000000)
         except Exception as e:
             logger.info('Caught an exception: {}'.format(e))
             result_package = {'type': 'result', 'task_id': tid, 'exception': serialize(RemoteExceptionWrapper(*sys.exc_info()))}
         else:
             result_package = {'type': 'result', 'task_id': tid, 'result': serialized_result}
-            # logger.debug("Result: {}".format(result))
+            del serialized_result
+        del req
 
         logger.info("Completed executor task {}".format(tid))
         try:
@@ -788,6 +812,7 @@ def worker(
                                         })
 
         result_queue.put(pkl_package)
+        del pkl_package, result_package
         tasks_in_progress.pop(worker_id)
         logger.info("All processing finished for executor task {}".format(tid))
 

parsl/executors/high_throughput/zmq_pipes.py

@@ -74,51 +74,37 @@ class CommandClient:
 
         reply = '__PARSL_ZMQ_PIPES_MAGIC__'
         with self._lock:
-            for _ in range(max_retries):
-                try:
-                    logger.debug("Sending command client command")
-
-                    if timeout_s is not None:
-                        remaining_time_s = start_time_s + timeout_s - time.monotonic()
-                        poll_result = self.zmq_socket.poll(timeout=remaining_time_s * 1000, flags=zmq.POLLOUT)
-                        if poll_result == zmq.POLLOUT:
-                            pass  # this is OK, so continue
-                        elif poll_result == 0:
-                            raise CommandClientTimeoutError("Waiting for command channel to be ready for a command")
-                        else:
-                            raise InternalConsistencyError(f"ZMQ poll returned unexpected value: {poll_result}")
-
-                    self.zmq_socket.send_pyobj(message, copy=True)
-
-                    if timeout_s is not None:
-                        logger.debug("Polling for command client response or timeout")
-                        remaining_time_s = start_time_s + timeout_s - time.monotonic()
-                        poll_result = self.zmq_socket.poll(timeout=remaining_time_s * 1000, flags=zmq.POLLIN)
-                        if poll_result == zmq.POLLIN:
-                            pass  # this is OK, so continue
-                        elif poll_result == 0:
-                            logger.error("Command timed-out - command client is now bad forever")
-                            self.ok = False
-                            raise CommandClientTimeoutError("Waiting for a reply from command channel")
-                        else:
-                            raise InternalConsistencyError(f"ZMQ poll returned unexpected value: {poll_result}")
-
-                    logger.debug("Receiving command client response")
-                    reply = self.zmq_socket.recv_pyobj()
-                    logger.debug("Received command client response")
-                except zmq.ZMQError:
-                    logger.exception("Potential ZMQ REQ-REP deadlock caught")
-                    logger.info("Trying to reestablish context")
-                    self.zmq_context.recreate()
-                    self.create_socket_and_bind()
+            logger.debug("Sending command client command")
+
+            if timeout_s is not None:
+                remaining_time_s = start_time_s + timeout_s - time.monotonic()
+                poll_result = self.zmq_socket.poll(timeout=remaining_time_s * 1000, flags=zmq.POLLOUT)
+                if poll_result == zmq.POLLOUT:
+                    pass  # this is OK, so continue
+                elif poll_result == 0:
+                    raise CommandClientTimeoutError("Waiting for command channel to be ready for a command")
                 else:
-                    break
-
-        if reply == '__PARSL_ZMQ_PIPES_MAGIC__':
-            logger.error("Command channel run retries exhausted. Unable to run command")
-            raise Exception("Command Channel retries exhausted")
+                    raise InternalConsistencyError(f"ZMQ poll returned unexpected value: {poll_result}")
+
+            self.zmq_socket.send_pyobj(message, copy=True)
+
+            if timeout_s is not None:
+                logger.debug("Polling for command client response or timeout")
+                remaining_time_s = start_time_s + timeout_s - time.monotonic()
+                poll_result = self.zmq_socket.poll(timeout=remaining_time_s * 1000, flags=zmq.POLLIN)
+                if poll_result == zmq.POLLIN:
+                    pass  # this is OK, so continue
+                elif poll_result == 0:
+                    logger.error("Command timed-out - command client is now bad forever")
+                    self.ok = False
+                    raise CommandClientTimeoutError("Waiting for a reply from command channel")
+                else:
+                    raise InternalConsistencyError(f"ZMQ poll returned unexpected value: {poll_result}")
 
-        return reply
+            logger.debug("Receiving command client response")
+            reply = self.zmq_socket.recv_pyobj()
+            logger.debug("Received command client response")
+            return reply
 
     def close(self):
         self.zmq_socket.close()
@@ -150,30 +136,18 @@ class TasksOutgoing:
         self.port = self.zmq_socket.bind_to_random_port(tcp_url(ip_address),
                                                         min_port=port_range[0],
                                                         max_port=port_range[1])
-        self.poller = zmq.Poller()
-        self.poller.register(self.zmq_socket, zmq.POLLOUT)
 
     def put(self, message):
         """ This function needs to be fast at the same time aware of the possibility of
         ZMQ pipes overflowing.
 
-        The timeout increases slowly if contention is detected on ZMQ pipes.
         We could set copy=False and get slightly better latency but this results
         in ZMQ sockets reaching a broken state once there are ~10k tasks in flight.
         This issue can be magnified if each the serialized buffer itself is larger.
         """
-        timeout_ms = 1
-        while True:
-            socks = dict(self.poller.poll(timeout=timeout_ms))
-            if self.zmq_socket in socks and socks[self.zmq_socket] == zmq.POLLOUT:
-                # The copy option adds latency but reduces the risk of ZMQ overflow
-                logger.debug("Sending TasksOutgoing message")
-                self.zmq_socket.send_pyobj(message, copy=True)
-                logger.debug("Sent TasksOutgoing message")
-                return
-            else:
-                timeout_ms *= 2
-                logger.debug("Not sending due to non-ready zmq pipe, timeout: {} ms".format(timeout_ms))
+        logger.debug("Sending TasksOutgoing message")
+        self.zmq_socket.send_pyobj(message)
+        logger.debug("Sent TasksOutgoing message")
 
     def close(self):
         self.zmq_socket.close()
@@ -206,20 +180,15 @@ class ResultsIncoming:
         self.port = self.results_receiver.bind_to_random_port(tcp_url(ip_address),
                                                               min_port=port_range[0],
                                                               max_port=port_range[1])
-        self.poller = zmq.Poller()
-        self.poller.register(self.results_receiver, zmq.POLLIN)
 
     def get(self, timeout_ms=None):
         """Get a message from the queue, returning None if timeout expires
         without a message. timeout is measured in milliseconds.
         """
-        socks = dict(self.poller.poll(timeout=timeout_ms))
-        if self.results_receiver in socks and socks[self.results_receiver] == zmq.POLLIN:
-            m = self.results_receiver.recv_multipart()
-            logger.debug("Received ResultsIncoming message")
-            return m
-        else:
-            return None
+        if zmq.POLLIN == self.results_receiver.poll(timeout_ms, zmq.POLLIN):
+            logger.debug("Receiving ResultsIncoming multipart message")
+            return self.results_receiver.recv_multipart()
+        return None
 
     def close(self):
         self.results_receiver.close()

parsl/executors/radical/executor.py

@@ -20,7 +20,7 @@ from parsl.app.errors import BashExitFailure, RemoteExceptionWrapper
 from parsl.app.python import timeout
 from parsl.data_provider.files import File
 from parsl.executors.base import ParslExecutor
-from parsl.serialize import deserialize, pack_res_spec_apply_message
+from parsl.serialize import deserialize, pack_apply_message
 from parsl.serialize.errors import DeserializationError, SerializationError
 from parsl.utils import RepresentationMixin
 
@@ -441,11 +441,7 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
 
     def _pack_and_apply_message(self, func, args, kwargs):
         try:
-            buffer = pack_res_spec_apply_message(func,
-                                                 args,
-                                                 kwargs,
-                                                 resource_specification={},
-                                                 buffer_threshold=1024 * 1024)
+            buffer = pack_apply_message(func, args, kwargs, buffer_threshold=1 << 20)
             task_func = rp.utils.serialize_bson(buffer)
         except TypeError:
             raise SerializationError(func.__name__)

parsl/executors/radical/rpex_worker.py

@@ -5,7 +5,7 @@ import radical.pilot as rp
 import parsl.app.errors as pe
 from parsl.app.bash import remote_side_bash_executor
 from parsl.executors.execute_task import execute_task
-from parsl.serialize import serialize, unpack_res_spec_apply_message
+from parsl.serialize import serialize, unpack_apply_message
 
 
 class ParslWorker:
@@ -33,7 +33,7 @@ class ParslWorker:
 
         try:
             buffer = rp.utils.deserialize_bson(task['description']['executable'])
-            func, args, kwargs, _resource_spec = unpack_res_spec_apply_message(buffer)
+            func, args, kwargs = unpack_apply_message(buffer)
             ret = remote_side_bash_executor(func, *args, **kwargs)
             exc = (None, None)
             val = None

parsl/executors/taskvine/executor.py

@@ -107,13 +107,17 @@ class TaskVineExecutor(BlockProviderExecutor, putils.RepresentationMixin):
                  function_exec_mode: Union[Literal['regular'], Literal['serverless']] = 'regular',
                  manager_config: TaskVineManagerConfig = TaskVineManagerConfig(),
                  factory_config: TaskVineFactoryConfig = TaskVineFactoryConfig(),
-                 provider: Optional[ExecutionProvider] = LocalProvider(init_blocks=1),
+                 provider: Optional[ExecutionProvider] = None,
                  storage_access: Optional[List[Staging]] = None,
                  remote_monitoring_radio: Optional[RadioConfig] = None):
 
         # Set worker launch option for this executor
         if worker_launch_method == 'factory' or worker_launch_method == 'manual':
             provider = None
+        elif worker_launch_method == 'provider' and provider is None:
+            # provider method chosen, but no explicit provider supplied to __init__
+            # so default to LocalProvider
+            provider = LocalProvider(init_blocks=1)
 
         # Initialize the parent class with the execution provider and block error handling enabled.
         # If provider is None, then no worker is launched via the provider method.

parsl/executors/threads.py

@@ -29,12 +29,15 @@ class ThreadPoolExecutor(ParslExecutor, RepresentationMixin):
 
     @typeguard.typechecked
     def __init__(self, label: str = 'threads', max_threads: Optional[int] = 2,
-                 thread_name_prefix: str = '', storage_access: Optional[List[Staging]] = None,
+                 thread_name_prefix: str | None = None, storage_access: Optional[List[Staging]] = None,
                  working_dir: Optional[str] = None, remote_monitoring_radio: Optional[RadioConfig] = None):
         ParslExecutor.__init__(self)
         self.label = label
         self.max_threads = max_threads
-        self.thread_name_prefix = thread_name_prefix
+        if thread_name_prefix is None:
+            self.thread_name_prefix = "ThreadPoolExecutor-" + label
+        else:
+            self.thread_name_prefix = thread_name_prefix
 
         # we allow storage_access to be None now, which means something else to [] now
         # None now means that a default storage access list will be used, while

parsl/jobs/states.py

@@ -10,7 +10,7 @@ class JobState(IntEnum):
     """Defines a set of states that a job can be in"""
 
     UNKNOWN = 0
-    """The batch provider is unable to determinate a state for this job"""
+    """The batch provider is unable to determine a state for this job"""
 
     PENDING = 1
     """"This job is in the batch queue but has not started running"""
@@ -40,7 +40,7 @@ class JobState(IntEnum):
     """This job is held/suspended in the batch system"""
 
     MISSING = 8
-    """This job has reached a terminal state without the resources(managers/workers)
+    """This job has reached a terminal state without the resources (managers/workers)
     launched in the job connecting back to the Executor. This state is set by HTEX
     when it is able to infer that the block failed to start workers for eg due to
     bad worker environment or network connectivity issues.

parsl/jobs/strategy.py

@@ -185,6 +185,11 @@ class Strategy:
 
         for executor in executors:
             label = executor.label
+
+            if executor.bad_state_is_set:
+                logger.info(f"Not strategizing for executor {label} because bad state is set")
+                continue
+
             logger.debug(f"Strategizing for executor {label}")
 
             if self.executors[label]['first']:
@@ -213,12 +218,8 @@ class Strategy:
 
             logger.debug(f"Slot ratio calculation: active_slots = {active_slots}, active_tasks = {active_tasks}")
 
-            if hasattr(executor, 'connected_workers'):
-                logger.debug('Executor {} has {} active tasks, {}/{} running/pending blocks, and {} connected workers'.format(
-                    label, active_tasks, running, pending, executor.connected_workers()))
-            else:
-                logger.debug('Executor {} has {} active tasks and {}/{} running/pending blocks'.format(
-                    label, active_tasks, running, pending))
+            logger.debug('Executor {} has {} active tasks and {}/{} running/pending blocks'.format(
+                label, active_tasks, running, pending))
 
             # reset idle timer if executor has active tasks
 

parsl/monitoring/monitoring.py

@@ -11,9 +11,9 @@ import typeguard
 
 from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.multiprocessing import (
-    SizedQueue,
     SpawnEvent,
     SpawnProcess,
+    SpawnQueue,
     join_terminate_close_proc,
 )
 from parsl.utils import RepresentationMixin
@@ -126,7 +126,7 @@ class MonitoringHub(RepresentationMixin):
         self.monitoring_hub_active = True
 
         self.resource_msgs: Queue[TaggedMonitoringMessage]
-        self.resource_msgs = SizedQueue()
+        self.resource_msgs = SpawnQueue()
 
         self.dbm_exit_event: ms.Event
         self.dbm_exit_event = SpawnEvent()

parsl/monitoring/radios/filesystem.py

@@ -10,11 +10,12 @@ from parsl.monitoring.radios.base import (
     RadioConfig,
 )
 from parsl.monitoring.radios.filesystem_router import FilesystemRadioReceiver
+from parsl.utils import RepresentationMixin
 
 logger = logging.getLogger(__name__)
 
 
-class FilesystemRadio(RadioConfig):
+class FilesystemRadio(RadioConfig, RepresentationMixin):
     """A MonitoringRadioSender that sends messages over a shared filesystem.
 
     The messsage directory structure is based on maildir,

parsl/monitoring/radios/htex.py

@@ -7,11 +7,12 @@ from parsl.monitoring.radios.base import (
     MonitoringRadioSender,
     RadioConfig,
 )
+from parsl.utils import RepresentationMixin
 
 logger = logging.getLogger(__name__)
 
 
-class HTEXRadio(RadioConfig):
+class HTEXRadio(RadioConfig, RepresentationMixin):
     def create_sender(self) -> MonitoringRadioSender:
         return HTEXRadioSender()
 

parsl/monitoring/radios/multiprocessing.py

@@ -5,9 +5,10 @@ from parsl.monitoring.radios.base import (
     MonitoringRadioSender,
     RadioConfig,
 )
+from parsl.utils import RepresentationMixin
 
 
-class MultiprocessingQueueRadioSender(MonitoringRadioSender):
+class MultiprocessingQueueRadioSender(MonitoringRadioSender, RepresentationMixin):
     """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

parsl/monitoring/radios/udp.py

@@ -13,11 +13,12 @@ from parsl.monitoring.radios.base import (
     RadioConfig,
 )
 from parsl.monitoring.radios.udp_router import start_udp_receiver
+from parsl.utils import RepresentationMixin
 
 logger = logging.getLogger(__name__)
 
 
-class UDPRadio(RadioConfig):
+class UDPRadio(RadioConfig, RepresentationMixin):
     def __init__(self, *, port: Optional[int] = None, atexit_timeout: int = 3, address: str, debug: bool = False, hmac_digest: str = 'sha512'):
         self.port = port
         self.atexit_timeout = atexit_timeout

parsl/multiprocessing.py

@@ -4,7 +4,6 @@
 import logging
 import multiprocessing
 import multiprocessing.queues
-import platform
 from multiprocessing.context import ForkProcess as ForkProcessType
 from multiprocessing.context import SpawnProcess as SpawnProcessType
 from typing import Callable
@@ -21,54 +20,6 @@ SpawnEvent = SpawnContext.Event
 SpawnQueue = SpawnContext.Queue
 
 
-class MacSafeQueue(multiprocessing.queues.Queue):
-    """ Multiprocessing queues do not have qsize attributes on MacOS.
-    This is slower but more portable version of the multiprocessing Queue
-    that adds a explicit counter
-
-    Reference : https://github.com/keras-team/autokeras/commit/4ddd568b06b4045ace777bc0fb7bc18573b85a75
-    """
-
-    def __init__(self, *args, **kwargs):
-        if 'ctx' not in kwargs:
-            kwargs['ctx'] = multiprocessing.get_context('spawn')
-        super().__init__(*args, **kwargs)
-        self._counter = multiprocessing.Value('i', 0)
-
-    def put(self, *args, **kwargs):
-        # logger.critical("Putting item {}".format(args))
-        x = super().put(*args, **kwargs)
-        with self._counter.get_lock():
-            self._counter.value += 1
-        return x
-
-    def get(self, *args, **kwargs):
-        x = super().get(*args, **kwargs)
-        with self._counter.get_lock():
-            self._counter.value -= 1
-        # logger.critical("Getting item {}".format(x))
-        return x
-
-    def qsize(self):
-        return self._counter.value
-
-    def empty(self):
-        return not self._counter.value
-
-
-# SizedQueue should be constructable using the same calling
-# convention as multiprocessing.Queue but that entire signature
-# isn't expressible in mypy 0.790
-SizedQueue: Callable[..., multiprocessing.Queue]
-
-
-if platform.system() != 'Darwin':
-    import multiprocessing
-    SizedQueue = SpawnQueue
-else:
-    SizedQueue = MacSafeQueue
-
-
 def join_terminate_close_proc(process: SpawnProcessType, *, timeout: int = 30) -> None:
     """Increasingly aggressively terminate a process.
 

parsl/providers/base.py

@@ -33,7 +33,28 @@ class ExecutionProvider(metaclass=ABCMeta):
           [cancel]     <--------|----+
                                 |
                                 +-------------------
-     """
+
+    In addition to the listed methods, an ExecutionProvider instance must always
+    have these attributes, which both default to `None`:
+
+      mem_per_node: Real memory to provision per node in GB.
+
+                    Providers which set this attribute should ask for mem_per_node of memory
+                    when provisioning resources, and set the corresponding environment
+                    variable PARSL_MEMORY_GB before executing submitted commands.
+
+                    If this attribute is set, executors may use it to calculate how many tasks can
+                    run concurrently per node.
+
+      cores_per_node: Number of cores to provision per node.
+
+                    Providers which set this attribute should ask for cores_per_node cores
+                    when provisioning resources, and set the corresponding environment
+                    variable PARSL_CORES before executing submitted commands.
+
+                    If this attribute is set, executors may use it to calculate how many tasks can
+                    run concurrently per node.
+    """
 
     @abstractmethod
     def __init__(self) -> None:
@@ -44,8 +65,8 @@ class ExecutionProvider(metaclass=ABCMeta):
         self.script_dir: Optional[str]
         self.parallelism: float
         self.resources: Dict[object, Any]
-        self._cores_per_node: Optional[int] = None
-        self._mem_per_node: Optional[float] = None
+        self.cores_per_node: Optional[int] = None
+        self.mem_per_node: Optional[float] = None
         pass
 
     @abstractmethod
@@ -111,40 +132,6 @@ class ExecutionProvider(metaclass=ABCMeta):
         ''' Provides the label for this provider '''
         pass
 
-    @property
-    def mem_per_node(self) -> Optional[float]:
-        """Real memory to provision per node in GB.
-
-        Providers which set this property should ask for mem_per_node of memory
-        when provisioning resources, and set the corresponding environment
-        variable PARSL_MEMORY_GB before executing submitted commands.
-
-        If this property is set, executors may use it to calculate how many tasks can
-        run concurrently per node.
-        """
-        return self._mem_per_node
-
-    @mem_per_node.setter
-    def mem_per_node(self, value: float) -> None:
-        self._mem_per_node = value
-
-    @property
-    def cores_per_node(self) -> Optional[int]:
-        """Number of cores to provision per node.
-
-        Providers which set this property should ask for cores_per_node cores
-        when provisioning resources, and set the corresponding environment
-        variable PARSL_CORES before executing submitted commands.
-
-        If this property is set, executors may use it to calculate how many tasks can
-        run concurrently per node.
-        """
-        return self._cores_per_node
-
-    @cores_per_node.setter
-    def cores_per_node(self, value: int) -> None:
-        self._cores_per_node = value
-
     @property
     @abstractmethod
     def status_polling_interval(self) -> int: