Distributed Computing

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

指定したクラスターマネージャーを介してワーカープロセスを起動します。

たとえば、パッケージ ClusterManagers.jl で実装されたカスタムクラスターマネージャーを使って、Beowulf クラスターを利用できます。

新たに起動したワーカーがマスターとの接続確立を待つ秒数は、ワーカープロセスの環境変数 JULIA_WORKER_TIMEOUT で指定できます。この設定が適用されるのは、トランスポートに TCP/IP を使用する場合のみです。

ワーカーの起動中に REPL(プログラムから起動する場合は、呼び出し元の関数)をブロックしないようにするには、addprocs を独立したタスク内で実行します。

Examples

# 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
source
addprocs(machines; tunnel=false, sshflags=``, max_parallel=10, kwargs...) -> List of process identifiers

SSH 経由でリモートマシンにワーカープロセスを追加します。設定はキーワード引数で行います(以下を参照)。特に、exename キーワードを使うと、リモートマシン上の julia バイナリへのパスを指定できます。

machines は、[user@]host[:port] [bind_addr[:port]] 形式の文字列で指定する「マシン指定」のベクトルです。user の既定値は現在のユーザー、port の既定値は標準の SSH ポートです。[bind_addr[:port]] を指定すると、他のワーカーは指定された bind_addr と port でこのワーカーに接続します。

machines ベクトル内でタプルを使うか、(machine_spec, count) 形式を使うと、リモートホスト上で複数のプロセスを起動できます。ここで count は、指定したホスト上で起動するワーカー数です。ワーカー数に :auto を指定すると、リモートホストの CPU スレッド数と同じ数のワーカーが起動します。

例:

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'
])

キーワード引数:

  • tunnel: true の場合、マスタープロセスからワーカーへの接続に SSH トンネリングを使用します。既定値は false です。

  • multiplex: true の場合、SSH トンネリングに SSH 多重化を使用します。既定値は false です。

  • ssh: ワーカーの起動に使用する SSH クライアント実行ファイルの名前またはパスです。既定値は "ssh" です。

  • sshflags: 追加の SSH オプションを指定します。例: sshflags=`-i /home/foo/bar.pem`

  • max_parallel: ホストごとに並列接続するワーカーの最大数を指定します。既定値は 10 です。

  • shell: ワーカー上で SSH が接続するシェルの種類を指定します。

    • shell=:posix: POSIX 互換の Unix/Linux シェル(sh、ksh、bash、dash、zsh など)。既定値です。
    • shell=:csh: Unix の C シェル(csh、tcsh)。
    • shell=:wincmd: Microsoft Windows cmd.exe。
  • dir: ワーカー上の作業ディレクトリを指定します。既定値は、pwd() で取得されるホストの現在のディレクトリです。

  • enable_threaded_blas: true の場合、追加されたプロセスで BLAS が複数スレッドを使って実行されます。既定値は false です。

  • exename: julia 実行ファイルの名前です。既定値は、状況に応じて "$(Sys.BINDIR)/julia" または "$(Sys.BINDIR)/julia-debug" です。シリアライズやコード配布に失敗する可能性があるため、すべてのリモートマシンで同じ Julia バージョンを使うことを推奨します。

  • exeflags: ワーカープロセスに渡す追加のフラグです。Cmd、フラグを 1 つ含む String、またはフラグごとに 1 要素を持つ文字列のコレクションを指定できます。例: $--threads=auto project=.$、"--compile-trace=stderr"、["--threads=auto", "--compile=all"]。

  • topology: ワーカー同士の接続方法を指定します。接続されていないワーカー間でメッセージを送信すると、エラーになります。

    • topology=:all_to_all: すべてのプロセスが相互に接続されます。既定値です。
    • topology=:master_worker: ドライバープロセス、つまり pid 1 のみがワーカーに接続します。ワーカー同士は接続しません。
    • topology=:custom: クラスターマネージャーの launch メソッドが、WorkerConfig 内の ident フィールドと connect_idents フィールドを使って接続トポロジーを指定します。クラスターマネージャーの ID が ident のワーカーは、connect_idents に指定されたすべてのワーカーに接続します。
  • lazy: topology=:all_to_all と併用する場合にのみ適用されます。true の場合、ワーカー間の接続は遅延設定され、ワーカー間でリモート呼び出しが初めて行われた時点で確立されます。既定値は true です。

  • env: env=["JULIA_DEPOT_PATH"=>"/depot"] のような文字列ペアの配列を指定すると、リモートマシン上に環境変数を設定できます。既定では、ローカル環境からリモート環境へ自動的に渡されるのは JULIA_WORKER_TIMEOUT 環境変数のみです。

  • cmdline_cookie: --worker コマンドラインオプションを使って認証 Cookie を渡します。より安全な既定の方法である SSH の標準入出力経由での Cookie の受け渡しは、古い(ConPTY 導入前の)Julia または Windows バージョンを使う Windows ワーカーで停止することがあります。その場合は cmdline_cookie=true を回避策として使用できます。

Julia 1.6

キーワード引数 ssh、shell、env、cmdline_cookie は Julia 1.6 で追加されました。

環境変数:

マスタープロセスが、新たに起動したワーカーとの接続を 60.0 秒以内に確立できない場合、ワーカーは致命的な状況と判断して終了します。このタイムアウトは環境変数 JULIA_WORKER_TIMEOUT で制御できます。マスタープロセス上の JULIA_WORKER_TIMEOUT の値は、新たに起動したワーカーが接続確立を待つ秒数を指定します。

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

組み込みの LocalManager を使って、ローカルホスト上で np ワーカーを起動します。

ローカルワーカーは、メインプロセスの現在のパッケージ環境(アクティブなプロジェクト、LOAD_PATH、DEPOT_PATH)を引き継ぎます。

Warning

ワーカーは ~/.julia/config/startup.jl 起動スクリプトを実行しません。また、コマンドラインスイッチ、グローバル変数、新しいメソッド定義、読み込み済みモジュールなどのグローバル状態を、ほかの実行中プロセスと同期しないことに注意してください。

キーワード引数:

  • restrict::Bool: true(デフォルト)のバインディングを 127.0.0.1 に制限する場合に指定します。
  • dir、exename、exeflags、env、topology、lazy、enable_threaded_blas: SSHManager と同じ効果があります。詳しくは addprocs(machines::AbstractVector) のドキュメントを参照してください。
Julia 1.9

パッケージ環境の継承と env キーワード引数は、Julia 1.9 で追加されました。

source
Distributed.nprocs — Function
nprocs()

利用可能なプロセス数を取得します。

Examples

julia> nprocs()
3

julia> workers()
2-element Array{Int64,1}:
 2
 3
source
Distributed.nworkers — Function
nworkers()

利用可能なワーカープロセス数を取得します。これは nprocs() より 1 つ少ない数です。nprocs() == 1 の場合は、nprocs() と等しくなります。

Examples

$ julia -p 2

julia> nprocs()
3

julia> nworkers()
2
source
Distributed.procs — Method
procs()

すべてのプロセス識別子を返します。workers()には含まれない pid 1 も含みます。

Examples

$ julia -p 2

julia> procs()
3-element Array{Int64,1}:
 1
 2
 3
source
Distributed.procs — Method
procs(pid::Integer)

同じ物理ノード上にあるすべてのプロセス識別子のリストを返します。具体的には、pid と同じ IP アドレスにバインドされているすべてのワーカーが返されます。

source
Distributed.workers — Function
workers()

すべてのワーカープロセスの識別子を返します。

Examples

$ julia -p 2

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

指定したワーカーを削除します。ワーカーを追加または削除できるのはプロセス 1 だけです。

引数 waitfor は、ワーカーのシャットダウンを待つ時間を指定します。

  • 指定しない場合、rmprocs は、要求されたすべての pids が削除されるまで待機します。
  • 要求された waitfor 秒以内にすべてのワーカーを終了できない場合、ErrorException が発生します。
  • waitfor の値が 0 の場合、呼び出しは直ちに戻り、別のタスクでワーカーの削除がスケジュールされます。スケジュールされた Task オブジェクトが返されます。他の並列呼び出しを行う前に、そのタスクに対して wait を呼び出してください。

Examples

$ 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
source
Distributed.interrupt — Function
interrupt(pids::Integer...)

指定したワーカー上で現在実行中のタスクを中断します。ローカルマシンで Ctrl-C を押すのと同じです。引数を指定しない場合は、すべてのワーカーを中断します。

source
interrupt(pids::AbstractVector=workers())

指定したワーカー上で現在実行中のタスクを中断します。ローカルマシンで Ctrl-C を押すのと同じです。引数を指定しない場合は、すべてのワーカーが中断されます。

source
Distributed.myid — Function
myid()

現在のプロセスの ID を取得します。

Examples

julia> myid()
1

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

コレクション c の各要素に対して、利用可能なワーカーとタスクを使い、f を適用して変換します。

複数のコレクションを引数に指定した場合は、f を要素ごとに適用します。

f はすべてのワーカープロセスで利用可能にしておく必要があります。詳しくは Code Availability and Loading Packages を参照してください。

ワーカープールを指定しない場合は、CachingPool を介して、利用可能なすべてのワーカーが使用されます。

デフォルトでは、pmap は指定されたすべてのワーカーに計算を分散します。ローカルプロセスのみを使い、タスクに分散させるには、distributed=false を指定します。これは asyncmap を使うのと同じです。たとえば、pmap(f, c; distributed=false) は asyncmap(f,c; ntasks=()->nworkers()) と同等です。

pmap では、batch_size 引数を使って、プロセスとタスクを組み合わせることもできます。バッチサイズが 1 より大きい場合、コレクションは複数のバッチに分けて処理されます。各バッチの長さは batch_size 以下です。バッチは単一のリクエストとして空いているワーカーに送られ、そのワーカー上のローカルな asyncmap が、複数の並行タスクを使ってバッチ内の要素を処理します。

エラーが発生すると、pmap はコレクションの残りの処理を中止します。この動作を変更するには、引数 on_error でエラー処理関数を指定します。この関数は例外を単一の引数として受け取ります。エラーを再スローすると処理を中止でき、処理を続ける場合は任意の値を返します。返された値は結果に含まれ、呼び出し元に返されます。

次の 2 つの例を見てください。1 つ目は例外オブジェクトを結果に含めて返し、2 つ目は例外の代わりに 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) ? error("foo") : x, 1:4; on_error=ex->0)
4-element Array{Int64,1}:
 1
 0
 3
 0

失敗した計算を再試行することで、エラーを処理することもできます。キーワード引数 retry_delays と retry_check は、それぞれキーワード引数 delays と check として retry に渡されます。バッチ処理を指定してバッチ全体が失敗した場合は、そのバッチ内のすべての項目が再試行されます。

on_error と retry_delays の両方を指定した場合、再試行の前に on_error フックが呼び出されることに注意してください。on_error が例外をスロー(または再スロー)しなければ、その要素は再試行されません。

例:エラーが発生した場合、要素に対する f の再試行を、再試行間の待ち時間なしで最大 3 回行います。

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

例:例外が InexactError 型でない場合に限り、f を最大 3 回再試行し、待ち時間を指数関数的に増やします。すべての InexactError の発生箇所では、代わりに NaN を返します。

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

リモート計算で発生した例外は捕捉され、ローカルで再スローされます。RemoteException は、ワーカーの pid と捕捉された例外をラップします。CapturedException は、リモート例外と、例外発生時の呼び出しスタックをシリアライズ可能な形式で捕捉します。

source
Distributed.ProcessExitedException — Type
ProcessExitedException(worker_id::Int)

クライアントの Julia プロセスが終了した後、終了した子プロセスを参照しようとすると、この例外がスローされます。

source
Distributed.Future — Type
Future(w::Int, rrid::RRID, v::Union{Some, Nothing}=nothing)

Future は、終了するかどうかや終了までの時間が不明な単一の計算を表すプレースホルダーです。複数の計算候補については、RemoteChannel を参照してください。AbstractRemoteRef の識別方法については、remoteref_id を参照してください。

source
Distributed.RemoteChannel — Type
RemoteChannel(pid::Integer=myid())

プロセス pid 上の Channel{Any}(1) を参照します。デフォルトの pid は現在のプロセスです。

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

特定のサイズと型を持つリモートチャネルへの参照を作成します。f は、pid 上で実行すると、AbstractChannel の実装を返す関数です。

たとえば、RemoteChannel(()->Channel{Int}(10), pid) は、pid 上の、型が Int でサイズが 10 のチャネルへの参照を返します。

デフォルトの pid は現在のプロセスです。

source
Base.fetch — Method
fetch(x::Future)

Future の値を取得するまで待機します。取得した値はローカルにキャッシュされます。同じ参照に対して fetch を呼び出すと、キャッシュされた値が返されます。リモートの値が例外の場合は、リモートの例外とバックトレースを保持する RemoteException がスローされます。

source
Base.fetch — Method
fetch(c::RemoteChannel)

RemoteChannelから値が得られるまで待機し、その値を取得します。発生する例外はFutureの場合と同じです。取得した項目は削除されません。

source
fetch(x::Any)

x

source
Distributed.remotecall — Method
remotecall(f, id::Integer, args...; kwargs...) -> Future

指定したプロセス上で、与えられた引数を使って関数 f を非同期に呼び出します。Future を返します。キーワード引数がある場合は、f に渡されます。

source
Distributed.remotecall_wait — Method
remotecall_wait(f, id::Integer, args...; kwargs...)

worker id idで指定したWorkerに対して、1回のメッセージでより高速なwait(remotecall(...))を実行します。キーワード引数がある場合は、fに渡されます。

waitおよびremotecallも参照してください。

source
Distributed.remotecall_fetch — Method
remotecall_fetch(f, id::Integer, args...; kwargs...)

fetch(remotecall(...)) を1つのメッセージ内で実行します。キーワード引数がある場合は、f に渡されます。リモートで発生した例外は RemoteException に格納され、スローされます。

fetch と remotecall も参照してください。

Examples

$ 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)).
...
source
Distributed.remotecall_eval — Function
remotecall_eval(m::Module, procs, expression)

procsで指定されたプロセス上で、モジュールmの式を実行します。いずれかのプロセスで発生したエラーはCompositeExceptionにまとめられ、スローされます。

@everywhereも参照してください。

source
Distributed.remote_do — Method
remote_do(f, id::Integer, args...; kwargs...) -> nothing

fをワーカーid上で非同期に実行します。remotecallとは異なり、計算結果は保存されず、完了を待つ方法もありません。

呼び出しが成功した場合、リモートノードでの実行要求が受け付けられたことを示します。

同じワーカーに対する連続したremotecallは、呼び出された順に直列化されますが、リモートワーカー上での実行順序は決まっていません。たとえば、remote_do(f1, 2); remotecall(f2, 2); remote_do(f3, 2)は、f1、続いてf2、f3の順に呼び出しを直列化します。しかし、ワーカー2上でf1がf3より先に実行される保証はありません。

fがスローした例外は、リモートワーカー上のstderrに出力されます。

キーワード引数がある場合は、fに渡されます。

source
Base.put! — Method
put!(rr::RemoteChannel, args...)

値の集合をRemoteChannelに格納します。チャネルが満杯の場合は、空きができるまでブロックします。最初の引数を返します。

source
Base.put! — Method
put!(rr::Future, v)

値をFuture rrに格納します。Futureは、一度だけ書き込み可能なリモート参照です。すでに設定済みのFutureに対してput!を実行すると、Exceptionがスローされます。すべての非同期リモート呼び出しはFutureを返し、完了時に呼び出しの戻り値を値として設定します。

source
Base.isready — Method
isready(rr::RemoteChannel, args...)

RemoteChannelに値が格納されているかどうかを判定します。この関数は競合状態を引き起こす可能性がある点に注意してください。結果を受け取る時点では、すでにその状態が変わっている場合があります。ただし、Futureは一度しか割り当てられないため、安全に使用できます。

source
Base.isready — Method
isready(rr::Future)

Future に値が格納されているかどうかを判定します。

引数 Future が別のノードに所有されている場合、この呼び出しは応答を待つ間ブロックします。代わりに、別のタスクで rr を待つか、ローカルの Channel をプロキシとして使用することをおすすめします。

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

WorkerPoolやCachingPoolなどのワーカープールのスーパータイプです。AbstractWorkerPoolでは、次の機能を実装する必要があります。

  • push! - 全体のプール(利用可能なワーカーと使用中のワーカー)に新しいワーカーを追加する
  • put! - ワーカーを利用可能なプールに戻す
  • take! - 利用可能なプールからワーカーを取得する(リモート関数の実行に使用)
  • wait - ワーカーが利用可能になるまでブロックする
  • length - 全体のプールで利用可能なワーカー数を返す
  • isready - プールに対するtake!がブロックする場合はfalseを、そうでなければtrueを返す

上記のデフォルト実装(AbstractWorkerPoolの場合)では、次のフィールドが必要です。

  • channel::Channel{Int}
  • workers::Set{Int}

channelには空きワーカーのPIDが格納され、workersはこのプールに属するすべてのワーカーの集合です。

source
Distributed.WorkerPool — Type
WorkerPool(workers::Union{Vector{Int},AbstractRange{Int}})

ワーカー ID のベクトルまたは範囲から WorkerPool を作成します。

Examples

$ 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))
source
Distributed.CachingPool — Type
CachingPool(workers::Vector{Int})

AbstractWorkerPool の実装では、remote、remotecall_fetch、pmap(および関数をリモートで実行するその他のリモート呼び出し)において、シリアライズ/デシリアライズした関数をワーカーノード上にキャッシュすると効果があります。特に、クロージャ(大量のデータをキャプチャする場合があります)で有効です。

リモートキャッシュは、返された CachingPool オブジェクトの存続期間中保持されます。キャッシュをそれより早くクリアするには、clear!(pool) を使用します。

グローバル変数については、クロージャにキャプチャされるのはバインディングのみで、データ自体はキャプチャされません。グローバルデータをキャプチャするには、let ブロックを使用できます。

Examples

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

上記の方法では、foo は各ワーカーに一度だけ転送されます。

source
Distributed.default_worker_pool — Function
default_worker_pool()

AbstractWorkerPool containing idle workers - remote(f)およびpmapで使用されます(デフォルト)。default_worker_pool!(pool)で明示的に設定しない限り、デフォルトのワーカープールはWorkerPoolに初期化されます。

Examples

$ 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))
source
Distributed.clear! — Function
clear!(syms, pids=workers(); mod=Main)

モジュール内のグローバル束縛を、nothing に初期化することでクリアします。syms は、Symbol 型、または Symbol のコレクションである必要があります。pids と mod は、グローバル変数を再初期化する対象のプロセスとモジュールを指定します。mod の下で定義されていることが確認された名前のみがクリアされます。

グローバル定数をクリアしようとすると、例外が発生します。

source
clear!(pool::CachingPool) -> pool

参加しているすべてのワーカーから、キャッシュされた関数をすべて削除します。

source
Distributed.remote — Function
remote([p::AbstractWorkerPool], f) -> Function

WorkerPool p が指定されている場合はそこから、それ以外の場合は利用可能なワーカーから選んで、f 関数を実行する無名関数を、remotecall_fetch を使って返します。

source
Distributed.remotecall — Method
remotecall(f, pool::AbstractWorkerPool, args...; kwargs...) -> Future

WorkerPool は remotecall(f, pid, ....) のバリアントです。pool から空いているワーカーを待って取得し、そのワーカーに対して remotecall を実行します。

Examples

$ julia -p 3

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

julia> A = rand(3000);

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

この例では、pid 1 から呼び出されたタスクが pid 2 で実行されました。

source
Distributed.remotecall_wait — Method
remotecall_wait(f, pool::AbstractWorkerPool, args...; kwargs...) -> Future

WorkerPool は remotecall_wait(f, pid, ....) のバリアントです。pool から空いているワーカーを待って取得し、そのワーカーに対して remotecall_wait を実行します。

Examples

$ julia -p 3

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

julia> A = rand(3000);

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

julia> fetch(f)
0.9995177101692958
source
Distributed.remotecall_fetch — Method
remotecall_fetch(f, pool::AbstractWorkerPool, args...; kwargs...) -> result

WorkerPool は remotecall_fetch(f, pid, ....) のバリアントです。空いているワーカーが現れるまで待機し、pool からそのワーカーを取得して、remotecall_fetch を実行します。

Examples

$ julia -p 3

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

julia> A = rand(3000);

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

WorkerPool は remote_do(f, pid, ....) のバリアントです。pool から空いているワーカーを待って取得し、そのワーカー上で remote_do を実行します。

remote_do() の完了を待つことはできないため、ワーカーは直ちにプールに戻されます(その結果、過剰な並列実行が発生する可能性があります)。

source
Distributed.@spawn — Macro
@spawn expr

式をクロージャで囲み、自動的に選択されたプロセス上で実行して、結果へのFutureを返します。このマクロは非推奨です。代わりに@spawnat :any exprを使用してください。

Examples

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
Julia 1.3

Julia 1.3以降、このマクロは非推奨です。代わりに@spawnat :anyを使用してください。

source
Distributed.@spawnat — Macro
@spawnat p expr

式をクロージャで囲み、そのクロージャをプロセス p 上で非同期に実行します。結果への Future を返します。

p が引用符で囲まれたリテラルシンボル :any の場合、システムが使用するプロセッサを自動的に選択します。:any では負荷分散は行われません。負荷分散が必要な場合は、WorkerPool と remotecall(f, ::WorkerPool) の使用を検討してください。

Examples

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
Julia 1.3

:any 引数は Julia 1.3 以降で使用できます。

source
Distributed.@fetch — Macro
@fetch expr

fetch(@spawnat :any expr)と同等です。fetchおよび@spawnatを参照してください。

Examples

julia> addprocs(3);

julia> @fetch myid()
2

julia> @fetch myid()
3

julia> @fetch myid()
4

julia> @fetch myid()
2
source
Distributed.@fetchfrom — Macro
@fetchfrom

fetch(@spawnat p expr)と同等です。fetchおよび@spawnatを参照してください。

Examples

julia> addprocs(3);

julia> @fetchfrom 2 myid()
2

julia> @fetchfrom 4 myid()
4
source
Distributed.@distributed — Macro
@distributed

分散メモリ上で並列に実行する for ループは、次の形式です。

@distributed [reducer] for var = range
    body
end

指定した範囲は分割され、すべてのワーカーでローカルに実行されます。オプションのリデューサー関数を指定した場合、@distributed は各ワーカーでローカルなリダクションを行い、呼び出し元のプロセスで最終的なリダクションを行います。

リデューサー関数を指定しない場合、@distributed は非同期に実行されます。つまり、利用可能なすべてのワーカーで独立したタスクを起動し、完了を待たずに直ちに戻ります。完了を待つには、次のように呼び出しの前に @sync を付けます。

@sync @distributed for var = range
    body
end
source
Distributed.@everywhere — Macro
@everywhere [procs()] expr

Main の式を、すべての procs 上で実行します。いずれかのプロセスで発生したエラーは CompositeException にまとめられ、スローされます。たとえば、次のようにします。

@everywhere bar = 1

これにより、現在のすべてのプロセスで Main.bar が定義されます。後から追加されたプロセス(たとえば addprocs())では、この式は定義されません。

@spawnat とは異なり、@everywhere はローカル変数をキャプチャしません。代わりに、補間を使ってローカル変数をブロードキャストできます。

foo = 1
@everywhere bar = $foo

省略可能な引数 procs を指定すると、式を実行するプロセスを全プロセスの一部に限定できます。

remotecall_eval(Main, procs, expr) の呼び出しと同様ですが、次の2つの機能が追加されています。

  • using 文と import 文は、パッケージが事前コンパイルされるよう、まず呼び出し元のプロセスで実行されます。
  • include が使用する現在のソースファイルのパスが、他のプロセスにも引き継がれます。
source
Distributed.remoteref_id — Function
remoteref_id(r::AbstractRemoteRef) -> RRID

FutureとRemoteChannelは、次のフィールドで識別されます。

  • where - 参照先のオブジェクトまたはストレージが実際に存在するノードを指します。
  • whence - リモート参照が作成された元のノードを指します。これは、参照先のオブジェクトが実際に存在するノードとは異なる点に注意してください。たとえば、マスタープロセスからRemoteChannel(2)を呼び出すと、whereの値は2、whenceの値は1になります。
  • idは、whenceで指定されたワーカーから作成されたすべての参照の中で一意です。

whenceとidを組み合わせると、すべてのワーカーにわたって参照を一意に識別できます。

remoteref_idは低レベルAPIで、リモート参照のwhence値とid値をラップするRRIDオブジェクトを返します。

source
Distributed.channel_from_id — Function
channel_from_id(id) -> c

remoteref_idが返すidのバックエンドとなるAbstractChannelを返す低レベルAPIです。この呼び出しは、バックエンドチャネルが存在するノードでのみ有効です。

source
Distributed.worker_id_from_socket — Function
worker_id_from_socket(s) -> pid

IO 接続または Worker を受け取り、接続先ワーカーの pid を返す低レベル API です。受信側のプロセス ID に応じて書き出すデータを最適化する、型のカスタム serialize メソッドを作成する際に役立ちます。

source
Distributed.cluster_cookie — Method
cluster_cookie(cookie) -> cookie

渡された Cookie をクラスター Cookie として設定し、その Cookie を返します。

source

Cluster Manager Interface

このインターフェースを使うと、さまざまなクラスタ環境で Julia ワーカーを起動し、管理できます。Base には 2 種類のマネージャーがあります。LocalManager は同じホスト上でワーカーを追加起動し、SSHManager は ssh 経由でリモートホスト上にワーカーを起動します。プロセス間の接続とメッセージの転送には TCP/IP ソケットを使用します。クラスタマネージャーによっては、別のトランスポートを提供することもできます。

Distributed.ClusterManager — Type
ClusterManager

ワーカープロセスをクラスターとして制御するクラスターマネージャーのスーパータイプです。クラスターマネージャーは、ワーカーの追加・削除方法や、ワーカーとの通信方法を実装します。SSHManager と LocalManager は、この型のサブタイプです。

source
Distributed.WorkerConfig — Type
WorkerConfig

ClusterManagerがクラスターに追加するワーカーを制御するために使用する型です。一部のフィールドは、すべてのクラスター管理ツールがホストにアクセスする際に使用します。

  • io – ワーカーへの接続(IOまたはNothingのサブタイプ)
  • host – ホストアドレス(StringまたはNothing)
  • port – ワーカーへの接続に使用するホスト上のポート(IntまたはNothing)

一部のフィールドは、初期化済みのホストにワーカーを追加する際に、クラスター管理ツールが使用します。

  • count – ホスト上で起動するワーカーの数
  • exename – ホスト上のJulia実行ファイルへのパス。デフォルトは"$(Sys.BINDIR)/julia"または"$(Sys.BINDIR)/julia-debug"
  • exeflags – リモートでJuliaを起動する際に使用するフラグ

userdataフィールドは、外部管理ツールが各ワーカーの情報を格納するために使用します。

一部のフィールドは、SSHManagerなどの管理ツールが使用します。

  • tunnel – true(トンネリングを使用)、false(トンネリングを使用しない)、またはnothing(管理ツールのデフォルトを使用)
  • multiplex – true(トンネリングにSSH多重化を使用)またはfalse
  • forward – sshの-Lオプションに使用する転送オプション
  • bind_addr – リモートホストでバインドするアドレス
  • sshflags – SSH接続の確立に使用するフラグ
  • max_parallel – ホスト上で並列に接続するワーカーの最大数

一部のフィールドは、LocalManagerとSSHManagerの両方が使用します。

  • connect_at – ワーカー間接続か、ドライバーからワーカーへの接続かを判定します
  • process – 接続対象のプロセス(通常、管理ツールがaddprocs中に割り当てます)
  • ospid – ホストOS上のプロセスID。ワーカープロセスの割り込みに使用します
  • environ – Local/SSH管理ツールが一時情報を格納するためのプライベート辞書
  • ident – ClusterManagerで識別されるワーカー
  • connect_idents – カスタムトポロジーを使用する場合に、ワーカーが接続する必要のあるワーカーIDのリスト
  • enable_threaded_blas – true、false、またはnothing。ワーカーでスレッド化BLASを使用するかどうかを指定します
source
Distributed.launch — Function
launch(manager::ClusterManager, params::Dict, launched::Array, launch_ntfy::Condition)

クラスター管理者によって実装されます。この関数が起動する Julia ワーカーごとに、launched に WorkerConfig エントリーを追加し、launch_ntfy に通知する必要があります。manager で要求されたすべてのワーカーを起動したら、この関数は必ず終了しなければなりません。params は、addprocs の呼び出し時に指定されたすべてのキーワード引数を格納する辞書です。

source
Distributed.manage — Function
manage(manager::ClusterManager, id::Integer, config::WorkerConfig. op::Symbol)

クラスタマネージャーによって実装されます。ワーカーの稼働中にマスタープロセス上で呼び出され、状況に応じて次のop値が渡されます。

  • Juliaのワーカープールにワーカーが追加/削除されたときは、:register/:deregisterが渡されます。
  • interrupt(workers)が呼び出されたときは、:interruptが渡されます。ClusterManagerは、該当するワーカーに割り込みシグナルを送る必要があります。
  • クリーンアップのために、:finalizeが渡されます。
source
Base.kill — Method
kill(manager::ClusterManager, pid::Int, config::WorkerConfig)

クラスタマネージャーによって実装されます。マスタープロセス上で、rmprocsによって呼び出されます。pidで指定されたリモートワーカーを終了させます。kill(manager::ClusterManager.....)は、pid上でリモートのexit()を実行します。

source
Sockets.connect — Method
connect(manager::ClusterManager, pid::Int, config::WorkerConfig) -> (instrm::IO, outstrm::IO)

カスタムトランスポートを使用するクラスターマネージャーによって実装されます。configで指定された、IDがpidのワーカーへの論理接続を確立し、IOオブジェクトのペアを返します。pidから現在のプロセス宛てのメッセージはinstrmから読み取られ、pid宛てに送信するメッセージはoutstrmに書き込まれます。カスタムトランスポートの実装では、メッセージが完全な形で順序どおりに送受信されるようにする必要があります。connect(manager::ClusterManager.....)は、ワーカー間のTCP/IPソケット接続を確立します。

source
Distributed.init_worker — Function
init_worker(cookie::AbstractString, manager::ClusterManager=DefaultClusterManager())

独自のトランスポートを実装するクラスターマネージャーから呼び出されます。新たに起動したプロセスをワーカーとして初期化します。コマンドライン引数 --worker[=<cookie>] を指定すると、TCP/IP ソケットをトランスポートに使用するワーカーとしてプロセスが初期化されます。cookie は cluster_cookie です。

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

start_worker は、TCP/IP 経由で接続するワーカープロセスのデフォルトのエントリーポイントとなる内部関数です。プロセスを Julia クラスタのワーカーとして設定します。

host:port の情報は、ストリーム out に書き込まれます(デフォルトは標準出力です)。

必要に応じて標準入力から Cookie を読み取り、空いているポート(または指定されている場合は、コマンドラインオプション --bind-to で指定されたポート)で待ち受け、受信した TCP 接続とリクエストを処理するタスクをスケジュールします。また、標準入力を閉じ、標準エラー出力を標準出力にリダイレクトすることもできます(いずれも任意です)。

この関数は戻りません。

source
Distributed.process_messages — Function
process_messages(r_stream::IO, w_stream::IO, incoming::Bool=true)

カスタムトランスポートを使用するクラスターマネージャーから呼び出されます。カスタムトランスポートの実装がリモートワーカーから最初のメッセージを受信したときに呼び出してください。カスタムトランスポートは、リモートワーカーとの論理接続を管理し、受信メッセージ用とリモートワーカー宛てのメッセージ用の2つの IO オブジェクトを提供する必要があります。incoming が true の場合、リモートピアが接続を開始しています。どちらが接続を開始した場合でも、認証ハンドシェイクを行うために、クラスタクッキーと自身の Julia バージョン番号を送信します。

関連項目: cluster_cookie。

source
Distributed.default_addprocs_params — Function
default_addprocs_params(mgr::ClusterManager) -> Dict{Symbol, Any}

クラスターマネージャーによって実装されています。addprocs(mgr) の呼び出し時に渡されるデフォルトのキーワード引数です。最小限のオプションセットは、default_addprocs_params() を呼び出すことで利用できます。

source