Source code for torchelastic.agent.server.api

#!/usr/bin/env python3

# Copyright (c) Facebook, Inc. and its affiliates.
# All rights reserved.
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.

import abc
import logging
import socket
import time
from contextlib import closing
from enum import Enum
from typing import Any, Callable, Dict, Tuple

import torchelastic.rendezvous as rdzv
from torchelastic.metrics import prof, put_metric

DEFAULT_ROLE = "default"

log = logging.getLogger(__name__)

[docs]class WorkerSpec: """ Contains blueprint information about a particular type of worker. For a given role, there must only exist a single worker spec. Worker spec is expected to be homogenous across all nodes (machine), that is each node runs the same number of workers for a particular spec. """ __slots__ = [ "role", "local_world_size", "fn", "args", "rdzv_handler", "max_restarts", "monitor_interval", "master_port", ] def __init__( self, role: str, local_world_size: int, fn: Callable, args: Tuple, rdzv_handler: rdzv.RendezvousHandler, max_restarts: int = 100, monitor_interval: float = 5.0, master_port=None, ): r""" Arguments: role (str): user-defined role for the workers with this spec local_world_size (int): number local workers to run fn (Callable): worker main entry point function args (Tuple): arguments to pass to ``fn(args)`` rdzv_handler (RendezvousHandler): handles rdzv for this set of workers max_restarts (int): number of max retries for the workers monitor_interval (int): monitor status of workers every ``n`` seconds master_port (int): fixed port to run the c10d store on rank 0 if not specified then will chose a random free port """ assert local_world_size > 0 assert max_restarts > 0 assert monitor_interval > 0 # Note: role is not used for data parallel, every worker has the same role # wiring it in to handle more elaborate situations later self.role = role self.local_world_size = local_world_size self.fn = fn self.args = args self.rdzv_handler = rdzv_handler self.max_restarts = max_restarts self.monitor_interval = monitor_interval self.master_port = master_port
[docs]class Worker: """ Represents a worker instance. Contrast this with ``WorkerSpec`` that represents the specifications of a worker. A ``Worker`` is created from a ``WorkerSpec``. A ``Worker`` is to a ``WorkerSpec`` as an object is to a class. The ``id`` of the worker is interpreted by the specific implementation of ``ElasticAgent``. For a local agent, it could be the ``pid (int)`` of the worker, for a remote agent it could be encoded as ``host:port (string)``. Arguments: id (Any): uniquely identifies a worker (interpreted by the agent) local_rank (int): local rank of the worker global_rank (int): global rank of the worker world_size (int): number of workers (globally) """ __slots__ = ["id", "local_rank", "global_rank", "world_size"] def __init__(self, local_rank: int): # unique identifier for this worker Any = None # rank of the worker among workers with the same role being monitored # by the same ``agent`` instance. self.local_rank: int = local_rank # rank of the worker among all the workers with the same role # across all ``agent`` instances. # Global rank is not stable between re-rendezvous. # pyre-fixme[8]: Attribute has type `int`; used as `None`. self.global_rank: int = None # total number of workers (globally). Due to elasticity # the world size may change between re-rendezvous. # pyre-fixme[8]: Attribute has type `int`; used as `None`. self.world_size: int = None
[docs]class WorkerState(Enum): """ State of the ``WorkerGroup``. Workers in a worker group change state as a unit. If a single worker in a worker group fails the entire set is considered failed:: UNKNOWN - agent lost track of worker group state, unrecoverable INIT - worker group object created not yet started HEALTHY - workers running and healthy UNHEALTHY - workers running and unhealthy STOPPED - workers stopped (interruped) by the agent SUCCEEDED - workers finished running (exit 0) FAILED - workers failed to successfully finish (exit !0) A worker group starts from an initial ``INIT`` state, then progresses to ``HEALTHY`` or ``UNHEALTHY`` states, and finally reaches a terminal ``SUCCEEDED`` or ``FAILED`` state. Worker groups can be interrupted and temporarily put into ``STOPPED`` state by the agent. Workers in ``STOPPED`` state are scheduled to be restarted in the near future by the agent. Some examples of workers being put into ``STOPPED`` state are: 1. Worker group failure|unhealthy observed 2. Membership change detected When actions (start, stop, rdzv, retry, etc) on worker group fails and results in the action being partially applied to the worker group the state will be ``UNKNOWN``. Typically this happens on uncaught/unhandled exceptions during state change events on the agent. The agent is not expected to recover worker groups in ``UNKNOWN`` state and is better off self terminating and allowing the job manager to retry the node. """ UNKNOWN = 0 INIT = 1 HEALTHY = 2 UNHEALTHY = 4 STOPPED = 8 SUCCEEDED = 16 FAILED = 32 @staticmethod def is_running(state: "WorkerState") -> bool: """ Returns: `` True`` if the worker state represents workers still running (e.g. that the process exists but not necessarily healthy). """ return state in {WorkerState.HEALTHY, WorkerState.UNHEALTHY}
[docs]class WorkerGroup: """ Represents the set of ``Worker`` instances for the given ``WorkerSpec`` managed by ``ElasticAgent``. Whether the worker group contains cross instance workers or not depends on the implementation of the agent. """ __slots__ = ["spec", "workers", "store", "group_rank", "group_world_size", "state"] def __init__(self, spec: WorkerSpec): self.spec = spec self.workers = [Worker(local_rank=i) for i in range(self.spec.local_world_size)] # assigned after rdzv = None self.group_rank = None self.group_world_size = None self.state = WorkerState.INIT
[docs]class MonitorResult: """ Returned by the agent's ``_monitor_workers`` API. A holder object that holds information about the monitoring results. The ``ret_vals`` and ``exceptions`` field map each worker's return value (output) and exceptions (if any) accordingly by the workers global rank. ``state = SUCCEEDED`` will have ``ret_val``. ``state = FAILED`` will have ``exceptions``. For other states both these fields will be empty. """ __slots__ = ["state", "ret_vals", "exceptions"] def __init__( self, state: WorkerState, # pyre-fixme[9]: ret_vals has type `Dict[int, typing.Any]`; used as `None`. ret_vals: Dict[int, Any] = None, # pyre-fixme[9]: exceptions has type `Dict[int, Exception]`; used as `None`. exceptions: Dict[int, Exception] = None, ): self.state = state self.ret_vals = ret_vals self.exceptions = exceptions
class WorkerGroupFailureException(Exception): """ Thrown when the agent cannot or has given up trying to run the workers. This is typically thrown: 1. Exceeded ``max_restarts``. 2. Workers fail with errors that are deemed ``NonRestartable`` When constructing this exception the underlying worker exceptions are provided as a map of the worker's global rank to the exception. """ def __init__(self, msg: str, worker_excs: Dict[int, Exception]): super().__init__(msg) self._worker_excs = worker_excs def get_worker_exceptions(self) -> Dict[int, Exception]: return self._worker_excs def _get_socket_with_port() -> socket.socket: """ Returns a free port on localhost that is "reserved" by binding a temporary socket on it. Close the socket before passing the port to the entity that requires it. Usage example :: sock = _get_socket_with_port() with closing(sock): port = sock.getsockname()[1] sock.close() # there is still a race-condition that some other process # may grab this port before func() runs func(port) """ addrs = socket.getaddrinfo( host="localhost", port=None, family=socket.AF_UNSPEC, type=socket.SOCK_STREAM ) for addr in addrs: family, type, proto, _, _ = addr s = socket.socket(family, type, proto) try: s.bind(("localhost", 0)) s.listen(0) return s except OSError as e: s.close()"Socket creation attempt failed.", exc_info=e) raise RuntimeError("Failed to create a socket") def _get_fq_hostname() -> str: return socket.getfqdn(socket.gethostname())
[docs]class ElasticAgent(abc.ABC): """ Agent process responsible for managing one or more worker processes. The worker processes are assumed to be regular distributed PyTorch scripts. When the worker process is created by the agent, the agent provides the necessary information for the worker processes to properly initialize a torch process group. The exact deployment topology and ratio of agent-to-worker is dependent on the specific implementation of the agent and the user's job placement preferences. For instance, to run a distributed training job on GPU with 8 trainers (one per GPU) one can: 1. Use 8 x single GPU instances, place an agent per instance, managing 1 worker per agent. 2. Use 4 x double GPU instances, place an agent per instance, managing 2 workers per agent. 3. Use 2 x quad GPU instances, place an agent per instance, managing 4 workers per agent. 4. Use 1 x 8 GPU instance, place an agent per instance, managing 8 workers per agent. Usage :: try: results = return results[0] # return rank 0's results except WorkerGroupFailureException as e: exceptions = e.get_worker_exceptions() log.exception(f"worker 0 failed with: {exceptions[0]}") except Exception as e: log.exception(f"error while running agent") """
[docs] @abc.abstractmethod def run(self, role: str = DEFAULT_ROLE) -> Dict[int, Any]: """ Runs the agent, retrying the worker group on failures up to ``max_restarts``. Returns: The return values for each worker mapped by the worker's global rank. Empty if workers have void signature. Raises: WorkerGroupFailureException - workers did not successfully run Exception - any other failures NOT related to worker process """ raise NotImplementedError()
[docs] @abc.abstractmethod def get_worker_group(self, role: str = DEFAULT_ROLE) -> WorkerGroup: """ Returns: The ``WorkerGroup`` for the given ``role``. Note that the worker group is a mutable object and hence in a multi-threaded/process environment it may change state. Implementors are encouraged (but not required) to return a defensive read-only copy. """ raise NotImplementedError()
[docs]class SimpleElasticAgent(ElasticAgent): """ An ``ElasticAgent`` that manages workers (``WorkerGroup``) for a single ``WorkerSpec`` (e.g. one particular type of worker role). """ def __init__(self, spec: WorkerSpec): self._worker_group = WorkerGroup(spec) self._remaining_restarts = self._worker_group.spec.max_restarts # pyre-fixme[14]: `get_worker_group` overrides method defined in `ElasticAgent` # inconsistently.
[docs] def get_worker_group(self) -> WorkerGroup: # TODO return an RO copy (need to create an ROWorkerGroup and ROWorkerSpec # since both these classes contain non-pure-data pointers - e.g. rdzv_handler) return self._worker_group
[docs] @abc.abstractmethod def _start_workers(self, worker_group: WorkerGroup) -> Dict[int, Any]: r""" Starts ``worker_group.spec.local_world_size`` number of workers according to worker spec for the worker group . Returns a map of ``local_rank`` to worker ``id``. """ raise NotImplementedError()
[docs] @abc.abstractmethod def _stop_workers(self, worker_group: WorkerGroup) -> None: r""" Stops all workers in the given worker group. Implementors must deal with workers in all states defined by ``WorkerState``. That is, it must gracefully handle stopping non-existent workers, unhealthy (stuck) workers, etc. """ raise NotImplementedError()
[docs] @abc.abstractmethod def _monitor_workers(self, worker_group: WorkerGroup) -> MonitorResult: r""" Checks on the workers for the ``worker_group`` and returns the new state of the worker group. """ raise NotImplementedError()
@staticmethod def _set_master_addr_port(store, master_port): if master_port is None: sock = _get_socket_with_port() with closing(sock): master_port = sock.getsockname()[1] store.set("MASTER_ADDR", _get_fq_hostname().encode(encoding="UTF-8")) store.set("MASTER_PORT", str(master_port).encode(encoding="UTF-8")) @staticmethod def _get_master_addr_port(store) -> Tuple[str, int]: master_addr = store.get("MASTER_ADDR").decode(encoding="UTF-8") master_port = int(store.get("MASTER_PORT").decode(encoding="UTF-8")) return (master_addr, master_port)
[docs] @prof def _rendezvous(self, worker_group: WorkerGroup) -> None: r""" Runs rendezvous for the workers specified by worker spec. Assigns workers a new global rank and world size. Updates the rendezvous store for the worker group. """ spec = worker_group.spec stride = spec.local_world_size store, group_rank, group_world_size = spec.rdzv_handler.next_rendezvous() world_size = group_world_size * spec.local_world_size = store worker_group.group_rank = group_rank worker_group.group_world_size = group_world_size if group_rank == 0: self._set_master_addr_port(store, spec.master_port) assigned_global_ranks = [] for worker in worker_group.workers: global_rank = (group_rank * stride) + worker.local_rank worker.global_rank = global_rank worker.world_size = world_size assigned_global_ranks.append(global_rank) master_addr, master_port = self._get_master_addr_port(store) restart_count = spec.max_restarts - self._remaining_restarts f"[{spec.role}] Rendezvous complete for workers.\n" f"Result:\n" f"\trestart_count={restart_count}\n" f"\tgroup_rank={group_rank}\n" f"\tgroup_world_size={group_world_size}\n" f"\trank stride={stride}\n" f"\tassigned global_ranks={assigned_global_ranks}\n" f"\tmaster_addr={master_addr}\n" f"\tmaster_port={master_port}\n" )
[docs] @prof def _initialize_workers(self, worker_group: WorkerGroup) -> None: r""" Starts a fresh set of workers for the worker_group. Essentially a rendezvous followed by a start_workers. The caller should first call ``_stop_workers()`` to stop running workers prior to calling this method. Optimistically sets the state of the worker group that just started as ``HEALTHY`` and delegates the actual monitoring of state to ``_monitor_workers()`` method """ role = worker_group.spec.role"[{role}] Rendezvous'ing worker group") # TODO after stopping workers, wait at least monitor_interval*2 for # workers on different nodes to fail on a collective op before waiting # on the rdzv barrier, this way we ensure that nodes enter rdzv # at around the same time and reduce false positive rdzv timeout errors self._rendezvous(worker_group)"[{role}] Starting worker group") worker_ids = self._start_workers(worker_group) for local_rank, id in worker_ids.items(): worker = worker_group.workers[local_rank] = id worker_group.state = WorkerState.HEALTHY
[docs] @prof def _restart_workers(self, worker_group: WorkerGroup) -> None: """ Restarts (stops, rendezvous, starts) all local workers in the group. """ role = worker_group.spec.role"[{role}] Stopping worker group") self._stop_workers(worker_group) worker_group.state = WorkerState.STOPPED self._initialize_workers(worker_group)
[docs] def run(self, role: str = DEFAULT_ROLE) -> Dict[int, Any]: # NOTE: currently only works for a single role spec = self._worker_group.spec role = spec.role"[{role}] starting workers for function: {spec.fn.__name__}") self._initialize_workers(self._worker_group) monitor_interval = spec.monitor_interval rdzv_handler = spec.rdzv_handler while True: assert self._worker_group.state != WorkerState.INIT time.sleep(monitor_interval) monitor_result = self._monitor_workers(self._worker_group) state = monitor_result.state self._worker_group.state = state put_metric(f"workers.{role}.remaining_restarts", self._remaining_restarts) put_metric(f"workers.{role}.{}", 1) if state == WorkerState.SUCCEEDED:"[{role}] All workers successfully finished.") return monitor_result.ret_vals elif state in {WorkerState.UNHEALTHY, WorkerState.FAILED}: if self._remaining_restarts > 0: f"[{role}] Worker group {}. " f"{self._remaining_restarts}/{spec.max_restarts} attempts left;" f" will restart worker group" ) self._remaining_restarts -= 1 self._restart_workers(self._worker_group) else: self._stop_workers(self._worker_group) self._worker_group.state = WorkerState.FAILED raise WorkerGroupFailureException( f"[{role}] exceeded max_restarts={spec.max_restarts}", monitor_result.exceptions, ) elif state == WorkerState.HEALTHY: # membership changes do not count as retries num_nodes_waiting = rdzv_handler.num_nodes_waiting() group_rank = self._worker_group.group_rank if num_nodes_waiting > 0: f"[{role}] Detected {num_nodes_waiting} " f"new nodes from group_rank={group_rank}; " f"will restart worker group" ) self._restart_workers(self._worker_group) else: raise Exception(f"[{role}] Worker group in {} state")


Access comprehensive developer documentation for PyTorch

View Docs


Get in-depth tutorials for beginners and advanced developers

View Tutorials


Find development resources and get your questions answered

View Resources