AnyMath 文档

分布式计算

分布式并行处理的工具。

addprocs(manager::ClusterManager; kwargs...) -> List of process identifiers

通过指定的集群管理器启动工作进程。

例如，通过包中实现的自定义集群管理器支持Beowulf集群 集群管理者。jl.

新启动的worker等待来自master的连接建立的秒数可以通过变量指定 JULIA_WORKER_TIMEOUT 在工作进程的环境中。 仅在使用TCP/IP作为传输时才相关。

若要在不阻塞REPL的情况下启动工作程序，或在以编程方式启动工作程序的情况下启动包含函数，请执行 addprocs 在自己的任务。

*例子*

# On busy clusters, call `addprocs` asynchronously
t = @async addprocs(...)
# Utilize workers as and when they come online
if nprocs() > 1   # Ensure at least one new worker is available
   ....   # perform distributed execution
end
# Retrieve newly launched worker IDs, or any error messages
if istaskdone(t)   # Check if `addprocs` has completed to ensure `fetch` doesn't block
    if nworkers() == N
        new_pids = fetch(t)
    else
        fetch(t)
    end
end
addprocs(machines; tunnel=false, sshflags=``, max_parallel=10, kwargs...) -> List of process identifiers

通过SSH在远程机器上添加工作进程。 配置使用关键字参数完成（见下文）。 特别是， 名称,名称 关键字可用于指定路径 朱莉娅 远程机器上的二进制文件。

机器 是一个"机器规格"的向量，它以字符串的形式给出 [用户@]主机[:端口][bind_addr[:端口]]. 用户 默认为当前用户和 港口 到标准SSH端口。 如果 [bind_addr[:端口]] 被指定，其他worker将在指定的位置连接到此worker bind_addr 和 港口.

可以通过使用 机器 向量或表格 (机械_spec,计数)，在哪里 计数 是要在指定主机上启动的工作程序数。 传球 :自动 由于worker计数将启动与远程主机上CPU线程数一样多的worker。

*例子*:

addprocs([
    "remote1",               # one worker on 'remote1' logging in with the current username
    "user@remote2",          # one worker on 'remote2' logging in with the 'user' username
    "user@remote3:2222",     # specifying SSH port to '2222' for 'remote3'
    ("user@remote4", 4),     # launch 4 workers on 'remote4'
    ("user@remote5", :auto), # launch as many workers as CPU threads on 'remote5'
])

*关键字参数*:

* 隧道：如果 真的 然后SSH隧道将用于从主进程连接到worker。 默认值为 错误. * 多路复用：如果 真的 然后SSH多路复用用于SSH隧道。 默认值为 错误. * ssh：用于启动工作程序的SSH客户端可执行文件的名称或路径。 默认值为 "ssh". * sshflags:指定其他ssh选项，例如 sshflags=-我/家/foo/酒吧。pem`` * 最大值,最大值:指定主机上并行连接的最大工作程序数。 默认值为10。 * 贝壳:指定ssh在worker上连接到的shell类型。 ** shell=:posix：一个POSIX兼容的Unix/Linux shell（sh，ksh，bash，dash，zsh等). 默认值。 ** 壳=:csh：一个Unix c shell（csh，tcsh）。 ** shell=:wincmd：微软视窗 cmd。exe文件. * 署长:指定worker上的工作目录。 默认为主机的当前目录（如下所示 残疾人士()) * enable_threaded_blas：如果 真的 然后BLAS将在添加的进程中的多个线程上运行。 默认值为 错误. * 名称,名称:名称 朱莉娅 可执行文件。 默认值为 "$(Sys.BINDIR）/朱莉娅" 或 "$(Sys.BINDIR）/julia-debug" 视情况而定。 建议在所有远程计算机上使用通用Julia版本，否则序列化和代码分发可能会失败。 * [医]前袋：传递给工作进程的其他标志。 它可以是一个 Cmd公司，一 字符串 持有一个标志或字符串集合，每个标志有一个元素。 例如。 , "--编译-跟踪=stderr" 或 ["--线程=自动","--编译=所有"]. * 拓扑学:指定worker如何相互连接。 在未连接的工作程序之间发送消息会导致错误。 ** 拓扑=：all_to_all：所有进程都相互连接。 默认值。 ** 拓扑=：master_worker：只有驱动程序进程，即 pid 1连接到工人。 工人不相互连接。 ** 拓扑=：自定义： 推出 群集管理器的方法通过字段指定连接拓扑 ident,ident 和 连接_idents 在 N.工人,工人. 具有群集管理器标识的工作程序 ident,ident 将连接到指定的所有工人 连接_idents. * 懒惰：只适用于 拓扑=：all_to_all. 如果 真的，工作者-工作者连接是懒惰地设置的，即它们是在工作者之间远程调用的第一个实例中设置的。 默认值为true。 * env：提供字符串对的数组，如 env=["JULIA_DEPOT_PATH"=>"/depot"] 请求在远程计算机上设置环境变量。 默认情况下只有环境变量 JULIA_WORKER_TIMEOUT 自动从本地传递到远程环境。 * cmdline_cookie：通过 --工人 命令行选项。 通过ssh stdio传递cookie的（更安全）默认行为可能与使用较旧（Pre-ConPTY）Julia或Windows版本的Windows worker挂起，在这种情况下 cmdline_cookie=真 提供了一个解决方案。

兼容性

Julia1.6关键字参数 ssh, 贝壳, env 和 cmdline_cookie 在Julia1.6中添加。

环境变量:

如果主进程未能在60.0秒内与新启动的worker建立连接，则worker将其视为致命情况并终止。 这个超时可以通过环境变量来控制 JULIA_WORKER_TIMEOUT. 的价值 JULIA_WORKER_TIMEOUT 在主进程上指定新启动的worker等待连接建立的秒数。

addprocs(np::Integer=Sys.CPU_THREADS; restrict=true, kwargs...) -> List of process identifiers

推出 np 使用内置的本地主机上的工作人员 本地管理员.

本地worker继承当前包环境（即活动项目, LOAD_PATH，和 DEPOT_PATH）从主要过程。

警告注意，工人不运行 ~/.朱莉娅/配置/启动。jl 启动脚本，也不会将其全局状态（如命令行开关、全局变量、新方法定义和加载的模块）与任何其他正在运行的进程同步。

*关键字参数*:

* 限制::Bool：如果 真的 （默认）绑定限制为 127.0.0.1. * 署长, 名称,名称, [医]前袋, env, 拓扑学, 懒惰, enable_threaded_blas：与效果相同 Ssh管理员，请参阅文档 addprocs(机器::AbstractVector).

兼容性

Julia1.9包环境的继承和 env 在Julia1.9中添加了关键字参数。

 
nprocs()

获取可用进程数。

*例子*

julia> nprocs()
3

julia> workers()
2-element Array{Int64,1}:
 2
 3
nworkers()

获取可用工作进程的数量。 这是少了一个比 nprocs(). 等于 nprocs() 如果 nprocs（）==1.

*例子*

$ julia -p 2

julia> nprocs()
3

julia> nworkers()
2
procs()

返回所有进程标识符的列表，包括pid1（不包括由 工人()).

*例子*

$ julia -p 2

julia> procs()
3-element Array{Int64,1}:
 1
 2
 3
procs(pid::Integer)

返回同一物理节点上所有进程标识符的列表。 特别是所有绑定到相同ip地址的工人 pid 被归还。

workers()

返回所有工作进程标识符的列表。

*例子*

$ julia -p 2

julia> workers()
2-element Array{Int64,1}:
 2
 3
rmprocs(pids...; waitfor=typemax(Int))

移除指定的worker。 请注意，只有进程1可以添加或删除工作程序。

论点 等待 指定等待工人关闭的时间:

*如未指定, rmprocs 将等待，直到所有请求 pids,pids 被移除。 *安 ErrorException异常如果在请求之前不能终止所有工人，则提出 等待 几秒钟。 *用一个 等待 值为0，调用立即返回，并计划在不同的任务中删除工作程序。 预定的 任务对象返回。 用户应该调用 等等！在调用任何其他并行调用之前对任务。

*例子*

$ julia -p 5

julia> t = rmprocs(2, 3, waitfor=0)
Task (runnable) @0x0000000107c718d0

julia> wait(t)

julia> workers()
3-element Array{Int64,1}:
 4
 5
 6
interrupt(pids::Integer...)

在指定的worker上中断当前正在执行的任务。 这相当于在本地机器上按Ctrl-C。 如果没有给出参数，则所有工人都被中断。

interrupt(pids::AbstractVector=workers())

在指定的worker上中断当前正在执行的任务。 这相当于在本地机器上按Ctrl-C。 如果没有给出参数，则所有工人都被中断。

myid()

获取当前进程的id。

*例子*

julia> myid()
1

julia> remotecall_fetch(() -> myid(), 4)
4
pmap(f, [::AbstractWorkerPool], c...; distributed=true, batch_size=1, on_error=nothing, retry_delays=[], retry_check=nothing) -> collection

变换集合 c 通过申请 f 使用可用的工作程序和任务到每个元素。

对于多个集合参数，应用 f 元素。

请注意 f 必须提供给所有工作进程；请参阅 代码可用性和加载包了解详细信息。

如果没有指定工作程序池，所有可用的工作程序将通过 [医切池].

默认情况下, pmap 将计算分配给所有指定的worker。 若要仅使用本地进程并在任务上分发，请指定 分布式=错误. 这相当于使用 异步映射. 例如, pmap（f，c;distributed=false） 相当于 asyncmap(f,c;ntasks=()->nworkers()) pmap 也可以通过 批量大小 争论。 对于大于1的批次大小，集合将在多个批次中处理，每个批次的长度为 批量大小 或更少。 一个批处理作为一个单一的请求发送给一个自由的工作者，其中一个本地的 异步映射使用多个并发任务处理批处理中的元素。

任何错误停止 pmap 从处理剩余的集合。 要复盖此行为，您可以通过参数指定错误处理函数 on_error 它接受一个参数，即异常。 该函数可以通过重新抛出错误来停止处理，或者，要继续，返回任何值，然后将其与结果内联返回给调用者。

考虑以下两个例子。 第一个返回内联异常对象，第二个返回0代替任何异常:

julia> pmap(x->iseven(x) ? error("foo") : x, 1:4; on_error=identity)
4-element Array{Any,1}:
 1
  ErrorException("foo")
 3
  ErrorException("foo")

julia>pmap（x->iseven（x）？ 错误（"foo"）：x，1：4;on_error=ex->0）
4元素数组{Int64,1}:
 1
 0
 3
 0

错误也可以通过重试失败的计算来处理。 关键字参数 回传/回传 和 再检查 被传递到 重试作为关键字参数 延误 和 支票 分别。 如果指定了批处理，并且整个批处理失败，则会重试批处理中的所有项目。

请注意，如果两者兼而有之 on_error 和 回传/回传 指定， on_error hook在重试之前被调用。 如果 on_error 不抛出（或重新抛出）异常，元素不会被重试。

示例：在错误时，重试 f 在一个元素上最多3次,在重试之间没有任何延迟.

pmap(f, c; retry_delays = zeros(3))

示例：重试 f 仅当异常不是类型时 N.恐怖,恐怖，具有指数级增加的延迟高达3倍。 返回a 南 为所有人准备好 N.恐怖,恐怖 发生。

pmap(f, c; on_error = e->(isa(e, InexactError) ? NaN : rethrow()), retry_delays = ExponentialBackOff(n = 3))
RemoteException(captured)

捕获远程计算中的异常并在本地重新生成。 A RemoteException 包装 pid 工人和捕获的异常。 A CapturedException异常 捕获引发异常时的远程异常和调用堆栈的可序列化形式。

ProcessExitedException(worker_id::Int)

在客户端Julia进程退出后，进一步尝试引用死亡子进程将引发此异常。

Future(w::Int, rrid::RRID, v::Union{Some, Nothing}=nothing)

A 未来 是未知终止状态和时间的单个计算的占位符。 有关多个潜在计算，请参阅 远程通道. 见 remoteref_id 用于识别 N.抽象,抽象.

RemoteChannel(pid::Integer=myid())

参考一个 频道{Any}(1) 关于过程 pid. 默认值 pid 是当前过程。

RemoteChannel(f::Function, pid::Integer=myid())

创建对特定大小和类型的远程通道的引用。 f 是一个函数，当执行 pid 必须返回一个 [医]抽象通道.

例如, 远程通道(()->通道{Int}(10)，pid)，将返回对类型的通道的引用 Int型 和尺寸10上 pid.

默认值 pid 是当前过程。

fetch(x::Future)

等待并获得a的值 未来. 获取的值在本地缓存。 进一步呼吁 取货/取货 在同一个引用上返回缓存的值。 如果远程值是异常，则抛出 RemoteException捕获远程异常和回溯。

fetch(c::RemoteChannel)

等待并从a中获取值 远程通道. 提出的例外情况与 未来. 不删除提取的项目。

fetch(x::Any)

回来吧 x.

remotecall(f, id::Integer, args...; kwargs...) -> Future

调用函数 f 在指定进程上的给定参数上异步。 返回a 未来. 关键字参数（如果有）传递给 f.

remotecall_wait(f, id::Integer, args...; kwargs...)

执行更快 等待（remotecall（。..)) 在一个消息上 工人 由worker id指定 身份证. 关键字参数（如果有）传递给 f.

请参阅 等等！和 远程呼叫.

remotecall_fetch(f, id::Integer, args...; kwargs...)

表演/表演 fetch(remotecall(...)) 在一个消息。 关键字参数（如果有的话）传递给 f. 任何远程异常捕获在 RemoteException并抛出。

请参阅 取货/取货和 远程呼叫.

*例子*

$ julia -p 2

julia> remotecall_fetch(sqrt, 2, 4)
2.0

julia> remotecall_fetch(sqrt, 2, -4)
ERROR: On worker 2:
DomainError with -4.0:
sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
...
remotecall_eval(m::Module, procs, expression)

在模块下执行表达式 m 在指定的过程中 采购,采购. 在任何过程中的错误被收集到一个 CompositeException并抛出。

请参阅 @无处不在.

remote_do(f, id::Integer, args...; kwargs...) -> nothing

执行 f 关于工人 身份证 异步。 不像 远程呼叫，它不存储计算的结果，也没有办法等待它的完成。

成功调用表示请求已被接受以在远程节点上执行。

连续时 远程呼叫对同一个worker的s按调用顺序序列化，远程worker的执行顺序未定。 例如, remote_do(f1,2);remotecall(f2,2);remote_do(f3,2) 将序列化调用到 f1，其次是 f2 和 f3 按这个顺序。 但是，不能保证 f1 被执行之前 f3 在工人2上。

抛出的任何异常 f 被打印到 斯德尔在远程工作器上。

关键字参数（如果有）传递给 f.

put!(rr::RemoteChannel, args...)

将一组值存储到 远程通道. 如果通道已满，则阻塞直到空间可用。 返回第一个参数。

put!(rr::Future, v)

将值存储到 未来 存款准备金率. 未来s是一次写入的远程引用。 A 放！ 在已经设置 未来 抛出一个 例外情况. 所有异步远程调用返回 未来s并在完成时将值设置为调用的返回值。

take!(rr::RemoteChannel, args...)

从a获取值 远程通道 存款准备金率，删除过程中的值。

isready(rr::RemoteChannel, args...)

确定是否 远程通道有一个值存储到它。 请注意，此函数可能会导致竞争条件，因为当您收到其结果时，它可能不再为真。 但是，它可以安全地用于 未来因为他们只分配一次。

isready(rr::Future)

确定是否 未来有一个值存储到它。

如果论点 未来 是由一个不同的节点拥有的，这个调用将阻塞等待答案。 建议等待 存款准备金率 在一个单独的任务，而不是使用本地 频道作为代理:

p = 1
f = Future(p)
errormonitor(@async put!(f, remotecall_fetch(long_computation, p)))
isready(f)  # will not block
AbstractWorkerPool

Worker池的超类型，如 工人池和 [医切池]. 一个 抽象工作者池 应实施:

* 推！-将新工作人员添加到整体池（可用+忙） * 放！-将worker放回可用池 * 拿！-从可用池中取出一个worker（用于远程函数执行） * 等等！-阻止，直到工人可用 * 长度-整体池中可用的工人数量 * 已经准备好了-返回false，如果一个 拿！ 在游泳池上会阻塞，否则是真的

上述的默认实现（在 抽象工作者池)需要字段

* 频道::频道{Int} * 工人::集{Int}

哪里 频道 包含免费的工人pid和 工人 是与此池关联的所有worker的集合。

WorkerPool(workers::Union{Vector{Int},AbstractRange{Int}})

创建一个 工人池 从工作者id的向量或范围。

*例子*

$ julia -p 3

julia> WorkerPool([2, 3])
WorkerPool(Channel{Int64}(sz_max:9223372036854775807,sz_curr:2), Set([2, 3]), RemoteChannel{Channel{Any}}(1, 1, 6))

julia> WorkerPool(2:4)
WorkerPool(Channel{Int64}(sz_max:9223372036854775807,sz_curr:2), Set([4, 2, 3]), RemoteChannel{Channel{Any}}(1, 1, 7))
CachingPool(workers::Vector{Int})

一个实施 抽象工作者池. 远程, remotecall_fetch, pmap（以及其他远程执行函数的远程调用）受益于在工作程序节点上缓存序列化/反序列化函数，特别是闭包（可能捕获大量数据）。

远程缓存在返回的生存期内保持 [医]切池 对象。 要更早清除缓存，请使用 清楚！(泳池).

对于全局变量，闭包中只捕获绑定，而不是数据。 让 块可用于捕获全局数据。

*例子*

const foo = rand(10^8);
wp = CachingPool(workers())
let foo = foo
    pmap(i -> sum(foo) + i, wp, 1:100);
end

以上将转移 [医]脚 只给每个工人一次。

default_worker_pool()

抽象工作者池包含空闲 工人-使用者 远程(f) 和 pmap（默认情况下）。 除非一个通过显式设置 default_worker_pool！(泳池)，默认工作线程池初始化为 工人池.

*例子*

$ julia -p 3

julia> default_worker_pool()
WorkerPool(Channel{Int64}(sz_max:9223372036854775807,sz_curr:3), Set([4, 2, 3]), RemoteChannel{Channel{Any}}(1, 1, 4))
clear!(syms, pids=workers(); mod=Main)

通过将模块中的全局绑定初始化为 什么都没有. 赛姆斯 应类型 符号或集合 符号s. pids,pids 和 国防部 确定要重新初始化全局变量的进程和模块。 只有那些被发现在 国防部 被清除了。

如果请求清除全局常量，则引发异常。

clear!(pool::CachingPool) -> pool

从所有参与的工作程序中删除所有缓存的函数。

remote([p::AbstractWorkerPool], f) -> Function

返回执行function的匿名函数 f 在一个可用的工人（从 工人池 p 如果提供）使用 remotecall_fetch.

remotecall(f, pool::AbstractWorkerPool, args...; kwargs...) -> Future

工人池的变体 remotecall（f，pid，。...). 等待并从一个免费的工人 游泳池 并执行一个 远程呼叫 在上面。

*例子*

$ julia -p 3

julia> wp = WorkerPool([2, 3]);

julia> A = rand(3000);

julia> f = remotecall(maximum, wp, A)
Future(2, 1, 6, nothing)

在此示例中，任务在pid2上运行，从pid1调用。

remotecall_wait(f, pool::AbstractWorkerPool, args...; kwargs...) -> Future

工人池的变体 remotecall_wait（f，pid，。...). 等待并从一个免费的工人 游泳池 并执行一个 remotecall_wait 在上面。

*例子*

$ julia -p 3

julia> wp = WorkerPool([2, 3]);

julia> A = rand(3000);

julia> f = remotecall_wait(maximum, wp, A)
Future(3, 1, 9, nothing)

朱莉娅>fetch(f)
0.9995177101692958
remotecall_fetch(f, pool::AbstractWorkerPool, args...; kwargs...) -> result

工人池的变体 remotecall_fetch(f,pid,....). 等待并从 游泳池 并执行一个 remotecall_fetch 在上面。

*例子*

$ julia -p 3

julia> wp = WorkerPool([2, 3]);

julia> A = rand(3000);

julia> remotecall_fetch(maximum, wp, A)
0.9995177101692958
remote_do(f, pool::AbstractWorkerPool, args...; kwargs...) -> nothing

工人池的变体 remote_do(f,pid,....). 等待并从一个免费的工人 游泳池 并执行一个 远程_do 在上面。

请注意，不可能等待a的结果 远程_do() 完成，所以工作人员将立即被放回池中（即可能导致超额认购）。

@spawn expr

围绕表达式创建闭包，并在自动选择的进程上运行它，返回 未来的结果。 此宏已弃用; @spawnat：任何expr 应改为使用。

*例子*

julia> addprocs(3);

julia> f = @spawn myid()
Future(2, 1, 5, nothing)

julia> fetch(f)
2

julia> f = @spawn myid()
Future(3, 1, 7, nothing)

julia> fetch(f)
3
兼容性

Julia1.3自Julia1.3起，此宏已弃用。 使用方法 @spawnat：任何 相反。

 
@spawnat p expr

围绕表达式创建闭包，并在进程上异步运行闭包 p. 返回a 未来的结果。

如果 p 是引用的字面符号 ：任何，然后系统将选择一个处理器自动使用。 使用 ：任何 不会应用任何形式的负载平衡，考虑使用 工人池和 remotecall(f,::WorkerPool)如果您需要负载平衡。

*例子*

julia> addprocs(3);

julia> f = @spawnat 2 myid()
Future(2, 1, 3, nothing)

julia> fetch(f)
2

julia> f = @spawnat :any myid()
Future(3, 1, 7, nothing)

julia> fetch(f)
3
兼容性

朱莉娅1.3 ：任何 自Julia1.3起，参数可用。

 
@fetch expr

相当于 获取（@spawnat：任何expr）. 见 取货/取货和 @产卵.

*例子*

julia> addprocs(3);

julia> @fetch myid()
2

julia> @fetch myid()
3

julia> @fetch myid()
4

julia> @fetch myid()
2
@fetchfrom

相当于 fetch（@spawnat p expr）. 见 取货/取货和 @产卵.

*例子*

julia> addprocs(3);

julia> @fetchfrom 2 myid()
2

julia> @fetchfrom 4 myid()
4
@distributed

一种分布式存储器，形式为循环并行 :

@distributed [reducer] for var = range
    body
end

指定的范围被分区并在所有工作程序中本地执行。 如果指定了可选的reducer函数, @分布式 对每个worker执行本地缩减，并对调用进程执行最终缩减。

请注意，没有减速器功能, @分布式 异步执行，即它在所有可用的worker上生成独立的任务，并立即返回而不等待完成。 要等待完成，请在调用前加上前缀 @同步，像 :

@sync @distributed for var = range
    body
end
@everywhere [procs()] expr

下执行表达式 主要 所有人 采购,采购. 在任何过程中的错误被收集到一个 CompositeException并抛出。 例如:

@everywhere bar = 1

将定义 主要。酒吧 在所有当前进程上。 以后添加的任何进程（比如 addprocs())不会定义表达式。

不像 @产卵, @无处不在 不捕获任何局部变量。 相反，可以使用插值来广播局部变量:

foo = 1
@everywhere bar = $foo

可选参数 采购,采购 允许指定所有进程的子集以执行表达式。

类似于调用 remotecall_eval（Main，procs，expr），但有两个额外的功能:

* 使用 和 进口 语句首先在调用进程上运行，以确保包是预编译的。 *使用的当前源文件路径 包括 被传播到其他进程。

remoteref_id(r::AbstractRemoteRef) -> RRID

未来s和 远程通道s由字段标识:

* 哪里 -指引用所指的底层对象/存储实际存在的节点。 * 从哪儿来的？ -指远程引用创建的节点。 请注意，这与引用的基础对象实际存在的节点不同。 例如调用 远程通道(2) 从主进程将导致 哪里 2和a的值 从哪儿来的？ 值为1。 * 身份证 在由以下指定的worker创建的所有引用中是唯一的 从哪儿来的？.

拢隆拢, 从哪儿来的？ 和 身份证 在所有工作人员中唯一标识一个引用。 remoteref_id 是一个低级API，它返回一个 瑞德 包装的对象 从哪儿来的？ 和 身份证 远程引用的值。

channel_from_id(id) -> c

返回支持的低级API [医]抽象通道 对于一个 身份证 返回者 remoteref_id. 该调用仅在存在支持通道的节点上有效。

worker_id_from_socket(s) -> pid

一个低级API，给定 伊俄 连接或一个 工人，返回 pid 它所连接的工人。 这在编写自定义时很有用 序列化类型的方法，根据接收进程id优化写出的数据。

cluster_cookie() -> cookie

返回集群cookie。

cluster_cookie(cookie) -> cookie

将传递的cookie设置为集群cookie，然后返回它。

集群管理器接口

此接口提供了一种在不同集群环境中启动和管理Julia worker的机制。 有两种类型的经理存在于基地: 本地管理员，用于在同一主机上启动其他工作程序，以及 Ssh管理员，用于通过以下方式在远程主机上启动 ssh. TCP/IP套接字用于在进程之间连接和传输消息。 集群管理器可以提供不同的传输。

ClusterManager

集群管理器的超类型，将工作进程控制为集群。 集群管理器实现了如何添加、删除和与之通信。 Ssh管理员 和 本地管理员 是这个的亚型。

WorkerConfig

使用的类型 集群管理员s控制添加到其集群的worker。 所有群集管理器都使用某些字段来访问主机:

* 伊俄 --用于访问worker的连接（ 伊俄 或 什么都没有) * 主机 --主机地址（无论是一个 字符串 或 什么都没有) * 港口 --用于连接到工作程序的主机上的端口（ Int型 或 什么都没有)

有些是集群管理器用来向已经初始化的主机添加工作程序的:

* 计数 --主机上要启动的工人数量 * 名称,名称 --主机上Julia可执行文件的路径，默认为 "$(Sys.BINDIR）/朱莉娅" 或 "$(Sys.BINDIR）/julia-debug" * [医]前袋 --远程启动Julia时使用的标志

该 [医]userdata 字段用于存储外部经理为每个工人的信息。

有些字段由 Ssh管理员 和类似的管理者:

* 隧道 — 真的 （使用隧道）, 错误 （不要使用隧道），或 什么都没有（管理器使用默认值） * 多路复用 — 真的 （使用SSH多路复用进行隧道）或 错误 * 前进,前进 --用于转发选项 -L ssh的选项 * bind_addr --要绑定到的远程主机上的地址 * sshflags --在建立SSH连接时使用的标志 * 最大值,最大值 --主机上并行连接的最大工人数

有些字段由两者使用 本地管理员s和 Ssh管理员s:

* 连接_at --确定这是工作者到工作者还是驱动程序到工作者设置调用 * 过程 --将连接的过程（通常经理会在 addprocs) * 奥斯皮德 --根据主机操作系统的进程ID，用于中断工作进程 * 环境,环境 --用于本地/SSH管理器存储临时信息的私有字典 * ident,ident --由 集群管理员 * 连接_idents --如果使用自定义拓扑，工作者必须连接到的工作者id列表 * enable_threaded_blas — 真的, 错误，或 什么都没有，是否在worker上使用线程BLAS

launch(manager::ClusterManager, params::Dict, launched::Array, launch_ntfy::Condition)

由集群管理器实现。 对于这个函数启动的每个Julia worker，它应该追加一个 N.工人,工人 进入 推出 并通知 n.发射,发射. 该函数必须在所有工作人员请求后退出 经理 已经推出。 帕拉姆斯 是所有关键字参数的字典 addprocs被叫来了。

manage(manager::ClusterManager, id::Integer, config::WorkerConfig. op::Symbol)

由集群管理器实现。 在工人的一生中，它被调用在主进程上，并具有适当的 op的 价值:

*与 :登记册/:注销登记 当从Julia worker池中添加/删除worker时。 *与 ：中断 何时 中断(工人) 被调用。 该 集群管理员 应用中断信号向适当的工人发信号。 *与 ：敲定 用于清理目的。

kill(manager::ClusterManager, pid::Int, config::WorkerConfig)

由集群管理器实现。 它被调用主进程，由 rmprocs. 它应该导致由指定的远程工作者 pid 退出。 杀(经理::ClusterManager.....) 执行远程 出口() 上 pid.

connect(manager::ClusterManager, pid::Int, config::WorkerConfig) -> (instrm::IO, outstrm::IO)

由集群管理器使用自定义传输实现。 它应该与id的worker建立逻辑连接 pid，由 配置；配置 并返回一对 伊俄 物体。 来自 pid 当前进程将被读出 仪器仪表，而消息要发送到 pid 会写到 外展,外展. 自定义传输实现必须确保完整有序地传递和接收邮件。 connect(manager::ClusterManager.....) 在worker之间设置TCP/IP套接字连接。

init_worker(cookie::AbstractString, manager::ClusterManager=DefaultClusterManager())

由实现自定义传输的集群管理器调用。 它将新启动的进程初始化为worker。 命令行参数 --工人[=<cookie>] 具有使用TCP/IP套接字将进程初始化为worker进行传输的效果。 曲奇饼 是一个 [医克鲁斯特].

start_worker([out::IO=stdout], cookie::AbstractString=readline(stdin); close_stdin::Bool=true, stderr_to_stdout::Bool=true)

开始工作 是一个内部函数，它是通过TCP/IP连接的工作进程的默认入口点。 它将进程设置为Julia集群工作程序。

主机：端口信息写入流 出 （默认为stdout）。

如果需要，该函数从stdin读取cookie，并侦听空闲端口（或者如果指定，则侦听 --绑定到 命令行选项）和调度任务来处理传入的TCP连接和请求。 它还（可选）关闭stdin并将stderr重定向到stdout。

它不会返回。

process_messages(r_stream::IO, w_stream::IO, incoming::Bool=true)

由集群管理器使用自定义传输调用。 当自定义传输实现从远程工作程序接收到第一条消息时，应该调用它。 自定义传输必须管理与远程工作线程的逻辑连接，并提供两个 伊俄 对象，一个用于传入消息，另一个用于发送给远程工作人员的消息。 如果 传入 是 真的，远程对端发起连接。 启动连接的对中的任何一个发送群集cookie及其Julia版本号以执行身份验证握手。

请参阅 [医克鲁斯特].

default_addprocs_params(mgr::ClusterManager) -> Dict{Symbol, Any}

由集群管理器实现。 调用时传递的默认关键字参数 addprocs(经理). 最小的选项集可以通过调用 default_addprocs_params（）