当前位置: 首页>>代码示例 >>用法及示例精选 >>正文

Python distributed.worker.Worker用法及代码示例


用法:

class distributed.worker.Worker(scheduler_ip: str | None = None, scheduler_port: int | None = None, *, scheduler_file: str | None = None, nthreads: int | None = None, loop: IOLoop | None = None, local_dir: None = None, local_directory: str | None = None, services: dict | None = None, name: Any | None = None, reconnect: bool = True, memory_limit: str | float = 'auto', executor: Executor | dict[str, Executor] | Literal['offload'] | None = None, resources: dict[str, float] | None = None, silence_logs: int | None = None, death_timeout: Any | None = None, preload: list[str] | None = None, preload_argv: list[str] | list[list[str]] | None = None, security: Security | dict[str, Any] | None = None, contact_address: str | None = None, heartbeat_interval: Any = '1s', memory_monitor_interval: Any = '200ms', memory_target_fraction: float | Literal[False] | None = None, memory_spill_fraction: float | Literal[False] | None = None, memory_pause_fraction: float | Literal[False] | None = None, max_spill: float | str | Literal[False] | None = None, extensions: list[type] | None = None, metrics: Mapping[str, Callable[[Worker], Any]] = {}, startup_information: Mapping[str, Callable[[Worker], Any]] = {}, data: MutableMapping[str, Any] | Callable[[], MutableMapping[str, Any]] | tuple[Callable[..., MutableMapping[str, Any]], dict[str, Any]] | None = None, interface: str | None = None, host: str | None = None, port: int | None = None, protocol: str | None = None, dashboard_address: str | None = None, dashboard: bool = False, http_prefix: str = '/', nanny: Nanny | None = None, plugins: tuple[WorkerPlugin, ...] =(), low_level_profiler: bool | None = None, validate: bool | None = None, profile_cycle_interval=None, lifetime: Any | None = None, lifetime_stagger: Any | None = None, lifetime_restart: bool | None = None, **kwargs)

Dask 分布式集群中的工作节点

工人执行两个函数：

  1. 提供来自本地字典的数据

  2. 对该数据和来自同行的数据执行计算

工作人员让调度程序了解他们的数据，并在需要执行计算时使用该调度程序从其他工作人员那里收集数据。

您可以使用 dask-worker 命令行应用程序启动工作程序：

$ dask-worker scheduler-ip:port

使用 --help 标志查看更多选项：

$ dask-worker --help

该文档字符串的其余部分是关于工作人员用于管理和跟踪内部计算的内部状态。

状态

信息状态

这些属性在执行期间不会发生显著变化。

  • 线程： int：

    此工作进程使用的 nthread 数

  • 执行人： dict[str, concurrent.futures.Executor]：

    执行器用于执行计算。始终包含默认执行程序。

  • local_directory: path：

    本地机器上存储临时文件的路径

  • 调度器： rpc：

    调度程序的位置。请参阅.ip/.port 属性。

  • 姓名： string：

    别名

  • 服务： {str: Server}：

    在此工作器上运行的辅助 Web 服务器

  • service_ports: {str: port}：
  • total_out_connections：int

    最大并发传出数据请求数

  • total_in_connections：int

    最大并发传入数据请求数

  • comm_threshold_bytes：int

    只要传输中的总字节数低于此阈值，我们就不会限制单个任务依赖项获取的传出连接数。

  • batched_stream：BatchedSend

    我们与调度程序通信的批处理流

  • 日志：[(message)]

    结构化且可查询的日志。见Worker.story

易变状态

这些属性跟踪该工作人员尝试完成的任务的进度。在下面的说明中，key 是我们要计算的任务的名称，dep 是我们要从其他人那里收集的一段依赖数据的名称。

  • 任务：{key: TaskState}

    当前在此工作人员上执行的任务(以及这些任务的任何依赖项)

  • 数据： {key: object}：

    优先使用主机属性而不是这个，除非定义了memory_limit和memory_target_fraction或memory_spill_fraction值中的至少一个，在这种情况下，这个属性是一个zict.Buffer，从中可以查询关于LRU缓存的信息.

  • 数据.内存： {key: object}：

    字典映射键到存储在内存中的实际值。仅当满足数据为 zict.Buffer 的条件时才可用。

  • 数据磁盘： {key: object}：

    字典映射键到存储在磁盘上的实际值。仅当满足数据为 zict.Buffer 的条件时才可用。

  • data_needed: 唯一任务堆

    仍然需要数据才能执行的任务，优先级为堆

  • 准备好：[键]

    准备好运行的键。存储在 LIFO 堆栈中

  • 受约束的：[键]

    我们拥有要运行的数据但正在等待 GPU 等抽象资源的键。存储在 FIFO 双端队列中

  • executing_count：int

    当前在此工作人员上执行的任务计数

  • executed_count: 整数

    该工作人员在其生命周期中运行的许多任务

  • long_running: {键}

    一组正在运行并已启动自己的long-running 客户端的任务键。

  • has_what：{worker: {deps}}

    我们认为工人拥有的我们关心的数据

  • pending_data_per_worker：{worker: UniqueTaskHeap}

    我们仍然想要的每个工人的数据，优先作为一个堆

  • in_flight_tasks：int

    当前peer-to-peer连接中的任务数

  • in_flight_workers：{worker: {task}}

    我们目前从中收集数据的工作人员以及我们期望从这些连接中获得的依赖关系

  • comm_bytes：int

    飞行中的总字节数

  • 线程：{key: int}

    运行任务的线程的 ID

  • active_threads：{int: key}

    当前在活动线程上运行的键

  • waiting_for_data_count：int

    当前正在等待数据的任务数量的计数

  • 一代：int

    每次调度程序调用 compute-task 处理程序时计数器都会减少。它附加到 TaskState.priority 并充当调度程序上具有相同优先级的任务之间的tie-breaker，确定它们之间的后进先出顺序。

参数：

scheduler_ip: str, optional：
scheduler_port: int, optional：
scheduler_file: str, optional：
ip: str, optional：
data: MutableMapping, type, None：

用于存储的对象，默认构建一个disk-backed LRU dict

nthreads: int, optional：
loop: tornado.ioloop.IOLoop：
local_directory: str, optional：

我们放置本地资源的目录

name: str, optional：
memory_limit: int, float, string：

此工作程序应使用的内存字节数。设置为零无限制。设置为 ‘auto’ 以作为系统计算。MEMORY_LIMIT * min(1, nthreads /total_cores) 使用字符串或数字，如 5GB 或 5e9

memory_target_fraction: float or False：

试图保持在下面的内存部分(默认值：从配置键 Distributed.worker.memory.target 读取)

memory_spill_fraction: float or false：

我们开始溢出到磁盘的内存部分(默认值：从配置键 Distributed.worker.memory.spill 读取)

memory_pause_fraction: float or False：

我们停止运行新任务的内存部分(默认值：从配置键 Distributed.worker.memory.pause 读取)

max_spill: int, string or False：

要溢出到磁盘上的字节数限制。 (默认：从配置键中读取分布式.worker.memory.max-spill)

executor: concurrent.futures.Executor, dict[str, concurrent.futures.Executor], “offload”：
要使用的执行者。根据类型，它具有以下含义：
  • 执行器实例：默认执行器。
  • Dict[str, Executor]：将名称映射到 Executor 实例。如果 “default” 键不在字典中，将使用 ThreadPoolExecutor(nthreads) 创建 “default” 执行程序。
  • Str：字符串“offload”，指的是用于卸载通信的同一线程池。这导致同一个线程被用于反序列化和计算。
resources: dict：

该工作人员拥有的资源如{'GPU': 2}

nanny: str：

联系保姆的地址(如果有)

lifetime: str：

像“1 小时”这样的时间量，之后我们优雅地关闭了 worker。这默认为无，这意味着没有明确的关闭时间。

lifetime_stagger: str：

像“5分钟”这样的时间来错开生命周期值实际生命周期将在生命周期+/-之间随机均匀选择lifetime_stagger

lifetime_restart: bool：

是否在工作人员达到其生命周期后重新启动它 默认 False

kwargs: optional：

ServerNode 构造函数的附加参数

例子：

使用命令行启动一个worker：

$ dask-scheduler
Start scheduler at 127.0.0.1:8786

$ dask-worker 127.0.0.1:8786
Start worker at:               127.0.0.1:1234
Registered with scheduler at:  127.0.0.1:8786

相关用法


注：本文由纯净天空筛选整理自dask.org大神的英文原创作品 distributed.worker.Worker。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。