Multi-processing and Distributed Computing

分散メモリ並列計算の実装は、Juliaに同梱される標準ライブラリのモジュールDistributedによって提供されます。

現代のコンピューターの多くは複数のCPUを備えており、複数のコンピューターを組み合わせてクラスターを構成することもできます。これら複数のCPUの能力を活用すれば、多くの計算をより短時間で完了できます。性能に影響する主な要因は、CPU自体の速度と、CPUがメモリにアクセスする速度の2つです。クラスターでは、あるCPUが最も高速にアクセスできるのは、同じコンピューター(ノード)内のRAMであることは明らかでしょう。意外かもしれませんが、一般的なマルチコアのノートPCでも、主記憶とcacheの速度の違いにより、同様の問題が生じます。したがって、優れたマルチプロセッシング環境では、特定のCPUによるメモリ領域の「所有」を制御できる必要があります。Juliaはメッセージパッシングに基づくマルチプロセッシング環境を提供しており、別々のメモリ領域を持つ複数のプロセス上でプログラムを同時に実行できます。

Juliaのメッセージパッシングの実装は、MPI[1]などの他の環境とは異なります。Juliaの通信は一般に「片側通信」です。つまり、2つのプロセスが関わる操作でも、プログラマーが明示的に管理する必要があるのは一方のプロセスだけです。さらに、これらの操作は通常、「メッセージ送信」や「メッセージ受信」という形ではなく、ユーザー関数の呼び出しのような、より高水準の操作に近い形を取ります。

Juliaの分散プログラミングは、リモート参照とリモート呼び出しという2つの基本要素に基づいています。リモート参照は、特定のプロセスに格納されたオブジェクトを、どのプロセスからでも参照できるオブジェクトです。リモート呼び出しは、あるプロセスが別のプロセス(同じプロセスの場合もあります)に対し、指定した引数で特定の関数を呼び出すよう要求するものです。

リモート参照には、FutureとRemoteChannelの2種類があります。

リモート呼び出しは、結果に対するFutureを返します。リモート呼び出しは直ちに戻り、呼び出し元のプロセスは次の操作に進みます。その間、リモート呼び出しは別の場所で実行されます。返されたFutureに対してwaitを呼び出すと、リモート呼び出しの完了を待つことができ、fetchを使うと結果の値全体を取得できます。

一方、RemoteChannelは書き換え可能です。たとえば、複数のプロセスが同じリモートのChannelを参照することで、処理を協調させることができます。

各プロセスには識別子が割り当てられています。対話型のJuliaプロンプトを提供するプロセスのidは、常に1です。並列処理にデフォルトで使用されるプロセスを「ワーカー」と呼びます。プロセスが1つだけの場合、プロセス1がワーカーとみなされます。それ以外の場合は、プロセス1以外のすべてのプロセスがワーカーとみなされます。そのため、pmapのような並列処理手法の恩恵を得るには、2つ以上のプロセスを追加する必要があります。ワーカーで長時間の計算を実行している間にメインプロセスで別の作業を行いたいだけなら、プロセスを1つ追加するだけでも有用です。

実際に試してみましょう。julia -p nで起動すると、ローカルマシン上にn個のワーカープロセスが作成されます。一般に、nはマシンのCPUスレッド数(論理コア数)と同じにするのが適切です。なお、-p引数を指定すると、モジュールDistributedが暗黙的に読み込まれます。

$ julia -p 2

julia> r = remotecall(rand, 2, 2, 2)
Future(2, 1, 4, nothing)

julia> s = @spawnat 2 1 .+ fetch(r)
Future(2, 1, 5, nothing)

julia> fetch(s)
2×2 Matrix{Float64}:
 1.18526  1.50912
 1.16296  1.60607

remotecallの第1引数は、呼び出す関数です。Juliaの並列プログラミングの大部分では、特定のプロセスや使用可能なプロセス数を意識する必要はありませんが、remotecallは、より細かな制御を提供する低水準インターフェースです。remotecallの第2引数は、処理を行うプロセスのidで、それ以降の引数は呼び出す関数に渡されます。

この例では、1行目でプロセス2に2行2列の乱数行列の作成を依頼し、2行目でその行列に1を加えるよう依頼しています。2つの計算の結果は、それぞれFutureであるrとsから取得できます。@spawnatマクロは、第1引数で指定されたプロセス上で第2引数の式を評価します。

リモートで計算した値をすぐに必要とする場合もあります。典型的には、次のローカル操作に必要なデータを得るために、リモートオブジェクトから読み出す場合です。このために用意されているのが関数remotecall_fetchです。これはfetch(remotecall(...))と同等ですが、より効率的です。

julia> remotecall_fetch(r-> fetch(r)[1, 1], 2, r)
0.18526337335308085

これはワーカー2上で配列を取得し、その最初の値を返します。この場合、fetchは配列を所有するワーカー上で実行されるため、データを移動しないことに注意してください。次のようにも書けます。

julia> remotecall_fetch(getindex, 2, r, 1, 1)
0.10824216411304866

getindex(r,1,1)はr[1,1]にequivalentされることを思い出してください。そのため、この呼び出しはFutureであるrの最初の要素を取得します。

より簡単にするには、@spawnatにシンボル:anyを渡すことができます。これにより、操作を実行する場所が自動的に選ばれます。

julia> r = @spawnat :any rand(2,2)
Future(2, 1, 4, nothing)

julia> s = @spawnat :any 1 .+ fetch(r)
Future(3, 1, 5, nothing)

julia> fetch(s)
2×2 Matrix{Float64}:
 1.38854  1.9098
 1.20939  1.57158

ここでは1 .+ rではなく1 .+ fetch(r)を使っている点に注意してください。コードがどこで実行されるか分からないため、一般には加算を実行するプロセスへrを移動するために、fetchが必要になる可能性があります。ただし、この例では@spawnatがrを所有するプロセス上で計算を実行するよう適切に判断するため、fetchは何もしません(処理は行われません)。

(@spawnatは組み込み機能ではなく、Juliaでmacroとして定義されていることも覚えておくとよいでしょう。同様の構文を独自に定義することもできます。)

重要なのは、Futureは一度値を取得すると、その値をローカルにキャッシュするという点です。その後のfetch呼び出しでは、ネットワーク通信は発生しません。参照しているすべてのFutureが値を取得すると、リモートに格納されていた値は削除されます。

Threads.@spawnは@spawnatに似ていますが、タスクを実行するのはローカルプロセス上だけです。ここではこれを使って、各プロセスに仕事を供給する「フィーダー」タスクを作成します。各タスクは、次に計算すべきインデックスを選び、担当プロセスの処理が終わるのを待ってから、インデックスがなくなるまでこれを繰り返します。フィーダータスクの実行が始まるのは、メインタスクが@syncブロックの末尾に到達してからであることに注意してください。この時点でメインタスクは制御を譲り、ローカルのすべてのタスクが完了するのを待ってから関数を戻ります。v0.7以降では、フィーダータスクはすべて同じプロセスで動作するため、nextidxを介して状態を共有できます。Tasksが協調的にスケジュールされる場合でも、asynchronous I/Oのように、状況によってはロックが必要です。協調的なスケジューリングでは、コンテキスト切り替えは明確に定められた時点でのみ発生します。この例では、remotecall_fetchの呼び出し時です。これは現在の実装であり、将来のJuliaでは変更される可能性があります。最大N個のTasksをM個のProcess上で実行する、いわゆるM:N Threadingを可能にすることが目指されているためです。その場合、複数のプロセスが同じリソースを同時に読み書きするのは安全ではないため、nextidxにはロックの取得・解放モデルが必要になります。

Code Availability and Loading Packages

コードは、それを実行するすべてのプロセスで利用可能になっていなければなりません。たとえば、Juliaプロンプトに次を入力してみてください。

julia> function rand2(dims...)
           return 2*rand(dims...)
       end

julia> rand2(2,2)
2×2 Matrix{Float64}:
 0.153756  0.368514
 1.15119   0.918912

julia> fetch(@spawnat :any rand2(2,2))
ERROR: RemoteException(2, CapturedException(UndefVarError(Symbol("#rand2"))))
Stacktrace:
[...]

プロセス1は関数rand2を認識していましたが、プロセス2は認識していませんでした。

通常、コードはファイルやパッケージから読み込みます。どのプロセスにコードを読み込ませるかは、かなり柔軟に制御できます。次のコードを含むファイルDummyModule.jlを考えてみましょう。

module DummyModule

export MyType, f

mutable struct MyType
    a::Int
end

f(x) = x^2+1

println("loaded")

end

すべてのプロセスでMyTypeを参照するには、各プロセスにDummyModule.jlを読み込む必要があります。include("DummyModule.jl")を呼び出すだけでは、1つのプロセスにしか読み込まれません。すべてのプロセスに読み込むには、@everywhereマクロを使います(Juliaはjulia -p 2で起動します)。

julia> @everywhere include("DummyModule.jl")
loaded
      From worker 3:    loaded
      From worker 2:    loaded

通常と同様、これだけでは、どのプロセスでもDummyModuleがスコープ内に導入されることはありません。そのためにはusingまたはimportが必要です。また、あるプロセスでDummyModuleをスコープ内に導入しても、他のプロセスでは導入されません。

julia> using .DummyModule

julia> MyType(7)
MyType(7)

julia> fetch(@spawnat 2 MyType(7))
ERROR: On worker 2:
UndefVarError: `MyType` not defined in `Main`
⋮

julia> fetch(@spawnat 2 DummyModule.MyType(7))
MyType(7)

ただし、たとえばDummyModuleを読み込み済みのプロセスには、それがスコープ内になくても、MyTypeを送ることができます。

julia> put!(RemoteChannel(2), MyType(7))
RemoteChannel{Channel{Any}}(2, 1, 13)

-Lフラグを使えば、起動時に複数のプロセスへファイルを事前に読み込むこともできます。また、ドライバースクリプトを使って計算を進めることもできます。

julia -p <n> -L file1.jl -L file2.jl driver.jl

上の例でドライバースクリプトを実行しているJuliaプロセスのidは、対話型プロンプトを提供するプロセスと同じく1です。

最後に、DummyModule.jlが単独のファイルではなくパッケージである場合、using DummyModuleはすべてのプロセスにDummyModule.jlを読み込みますが、スコープ内に導入するのはusingを呼び出したプロセスだけです。

Starting and managing worker processes

Juliaの基本インストールには、次の2種類のクラスターのサポートが組み込まれています。

  • 上で示したように、-pオプションで指定するローカルクラスター。
  • --machine-fileオプションを使う、複数のマシンにまたがるクラスター。パスワードなしのsshログインを使い、指定したマシン上でJuliaワーカープロセスを起動します(現在のホストと同じパスを使用します)。各マシンの定義は[count*][user@]host[:port] [bind_addr[:port]]という形式です。userのデフォルトは現在のユーザー、portのデフォルトは標準のsshポートです。countは、そのノードで起動するワーカー数で、デフォルトは1です。省略可能なbind-to bind_addr[:port]は、他のワーカーがこのワーカーに接続する際に使うIPアドレスとポートを指定します。
Note

Juliaは一般に後方互換性の維持に努めていますが、ワーカープロセスへのコードの配布にはSerialization.serializeを使用します。対応するドキュメントで説明されているとおり、Juliaのバージョンが異なる場合の動作は保証できません。そのため、すべてのマシンのすべてのワーカーで同じバージョンを使用することをお勧めします。

クラスター内のプロセスをプログラムから追加、削除、照会するために、addprocs、rmprocs、workersなどの関数が用意されています。

julia> using Distributed

julia> addprocs(2)
2-element Vector{Int64}:
 2
 3

addprocsを呼び出す前に、マスタープロセスでモジュールDistributedを明示的に読み込む必要があります。ワーカープロセスでは自動的に利用可能になります。

Note

ワーカーは~/.julia/config/startup.jl起動スクリプトを実行しません。また、コマンドラインオプション、グローバル変数、新しいメソッド定義、読み込み済みモジュールなどのグローバルな状態を、他の実行中のプロセスと同期することもありません。addprocs(exeflags="--project")を使って特定の環境でワーカーを初期化し、その後@everywhere using <modulename>または@everywhere include("file.jl")を使用できます。

他の種類のクラスターにも、独自のClusterManagerを実装することで対応できます。詳細は後述のClusterManagersの節を参照してください。

Data Movement

分散プログラムのオーバーヘッドの大部分は、メッセージの送信とデータの移動によって生じます。性能とスケーラビリティを確保するには、メッセージ数と送信するデータ量を減らすことが極めて重要です。そのためには、Juliaのさまざまな分散プログラミング構文がどのようにデータを移動するかを理解する必要があります。

fetchは、オブジェクトをローカルマシンに移動するよう直接要求するため、明示的なデータ移動操作とみなせます。@spawnat(およびいくつかの関連構文)もデータを移動しますが、それほど明白ではないため、暗黙的なデータ移動操作と呼べます。乱数行列を作成し、その2乗を計算する次の2つの方法を考えてみましょう。

方法1:

julia> A = rand(1000,1000);

julia> Bref = @spawnat :any A^2;

[...]

julia> fetch(Bref);

方法2:

julia> Bref = @spawnat :any rand(1000,1000)^2;

[...]

julia> fetch(Bref);

違いはわずかに見えますが、@spawnatの動作により、実際には大きな差があります。最初の方法では、ローカルで乱数行列を作成し、それを別のプロセスへ送って2乗を計算します。2番目の方法では、乱数行列の作成も2乗の計算も別のプロセス上で行います。したがって、2番目の方法で送信されるデータ量は、最初の方法よりはるかに少なくなります。

この単純な例では、2つの方法の違いを見分けて選択するのは簡単です。しかし実際のプログラムでは、データ移動の設計にもっと検討が必要で、測定も必要になるでしょう。たとえば、最初のプロセスでも行列Aが必要なら、最初の方法が適しているかもしれません。あるいは、Aの計算コストが高く、現在のプロセスしかそれを持っていないなら、別のプロセスへの移動は避けられないかもしれません。また、現在のプロセスが@spawnatからfetch(Bref)までの間にほとんど何も行わないなら、並列化そのものをやめた方がよい可能性もあります。rand(1000,1000)を、よりコストの高い操作に置き換える場合も考えてみてください。その場合は、この処理だけのために@spawnat文をもう1つ追加するのが適切かもしれません。

Global variables

@spawnatを介してリモート実行される式や、remotecallでリモート実行を指定したクロージャは、グローバル変数を参照できます。モジュールMain内のグローバル束縛は、他のモジュール内のグローバル束縛とは少し異なる扱いを受けます。次のコードを考えてみましょう。

A = rand(10,10)
remotecall_fetch(()->sum(A), 2)

この場合、sumはリモートプロセスで必ず定義されていなければなりません。Aはローカルのワークスペースで定義されたグローバル変数です。ワーカー2のMainには、Aという変数はありません。クロージャ()->sum(A)をワーカー2へ送信すると、ワーカー2にMain.Aが定義されます。Main.Aは、remotecall_fetchの呼び出しが戻った後もワーカー2に存在し続けます。グローバル参照を含むリモート呼び出しでは、グローバルを次のように管理します(Mainモジュール内のものに限ります)。

  • リモート呼び出しの一部として参照されると、送信先のワーカーに新しいグローバル束縛が作成されます。

  • グローバル定数は、リモートノードでも定数として宣言されます。

  • グローバルが送信先のワーカーに再送されるのは、リモート呼び出しの際だけであり、かつ値が変更された場合だけです。また、クラスターはノード間でグローバル束縛を同期しません。たとえば、次のようになります。

    A = rand(10,10)
    remotecall_fetch(()->sum(A), 2) # worker 2
    A = rand(10,10)
    remotecall_fetch(()->sum(A), 3) # worker 3
    A = nothing

    上のコードを実行すると、ワーカー2のMain.Aとワーカー3のMain.Aは異なる値になり、ノード1のMain.Aの値はnothingに設定されます。

お気づきかもしれませんが、マスターでグローバルに再代入すると、それに関連するメモリは回収される可能性がある一方、ワーカーでは束縛が有効なままなので、そのような処理は行われません。リモートノード上の特定のグローバルが不要になったら、clear!を使って手動でnothingを再代入できます。これにより、通常のガベージコレクションのサイクルで、関連するメモリが解放されます。

したがって、リモート呼び出しでグローバルを参照する際は注意が必要です。実際には、可能ならグローバルの参照自体を避ける方が望ましいでしょう。どうしても参照する必要がある場合は、letブロックでグローバル変数をローカル化することを検討してください。

たとえば、次のようにします。

julia> A = rand(10,10);

julia> remotecall_fetch(()->A, 2);

julia> B = rand(10,10);

julia> let B = B
           remotecall_fetch(()->B, 2)
       end;

julia> @fetchfrom 2 InteractiveUtils.varinfo()
name           size summary
––––––––– ––––––––– ––––––––––––––––––––––
A         800 bytes 10×10 Array{Float64,2}
Base                Module
Core                Module
Main                Module

この例では、グローバル変数Aはワーカー2に定義されますが、Bはローカル変数としてキャプチャされるため、ワーカー2にBの束縛は存在しません。

Parallel Map and Loops

幸い、有用な並列計算の多くはデータ移動を必要としません。よくある例はモンテカルロシミュレーションで、複数のプロセスが独立した試行を同時に処理できます。@spawnatを使って、2つのプロセスでコイン投げを行ってみましょう。まず、count_heads.jlに次の関数を書きます。

function count_heads(n)
    c::Int = 0
    for i = 1:n
        c += rand(Bool)
    end
    c
end

関数count_headsは、単にn個のランダムなビットを足し合わせます。2台のマシンで試行を行い、結果を足し合わせるには次のようにします。

julia> @everywhere include_string(Main, $(read("count_heads.jl", String)), "count_heads.jl")

julia> a = @spawnat :any count_heads(100000000)
Future(2, 1, 6, nothing)

julia> b = @spawnat :any count_heads(100000000)
Future(3, 1, 7, nothing)

julia> fetch(a)+fetch(b)
100001564

この例は、強力でよく使われる並列プログラミングのパターンを示しています。多数の反復を複数のプロセス上で独立に実行し、その結果を何らかの関数で結合するというものです。この結合処理は、一般にテンソルの階数を減らすため、リダクションと呼ばれます。たとえば、数値のベクトルを1つの数値にまとめたり、行列を1つの行や列にまとめたりします。コードでは通常、x = f(x,v[i])という形になります。ここで、xは累積変数、fはリダクション関数、v[i]はリダクションの対象となる要素です。操作の実行順序が結果に影響しないように、fは結合法則を満たすことが望まれます。

count_headsにこのパターンを適用した方法は、一般化できます。この例では@spawnat文を明示的に2つ使ったため、並列処理は2つのプロセスに限られています。任意の数のプロセスで実行するには、分散メモリ上で動作する並列forループを使用できます。Juliaでは、@distributedを使って次のように書けます。

nheads = @distributed (+) for i = 1:200000000
    Int(rand(Bool))
end

この構文は、反復を複数のプロセスに割り当て、指定したリダクション(この例では(+))で結合するパターンを実装しています。各反復の結果には、ループ内の最後の式の値が使われます。並列ループ式全体の評価結果が、最終的な答えになります。

並列forループは逐次forループに似た見た目ですが、動作は大きく異なることに注意してください。特に、反復の実行順序は定まっていません。また、反復は異なるプロセス上で実行されるため、変数や配列への書き込みは全体から見えるわけではありません。並列ループ内で使われる変数は、各プロセスへコピーされ、配布されます。

たとえば、次のコードは意図どおりには動作しません。

a = zeros(100000)
@distributed for i = 1:100000
    a[i] = i
end

各プロセスがaの別々のコピーを持つため、このコードではその全体を初期化できません。このような並列forループは避けなければなりません。幸い、Shared Arraysを使えば、この制限を回避できます。

using SharedArrays

a = SharedArray{Float64}(10)
@distributed for i = 1:10
    a[i] = i
end

変数が読み取り専用であれば、並列ループ内で「外側」の変数を使うことに問題はありません。

a = randn(1000)
@distributed (+) for i = 1:100000
    f(a[rand(1:end)])
end

ここでは各反復で、すべてのプロセスが共有するベクトルaからランダムに選んだサンプルに、fを適用しています。

これまでの例にあるように、リダクション演算子は不要なら省略できます。その場合、ループは非同期に実行されます。つまり、利用可能なすべてのワーカーで独立したタスクを起動し、完了を待たずにFutureの配列を直ちに返します。呼び出し元は、後でそれらにfetchを呼び出してFutureの完了を待つことができます。また、@sync @distributed forのようにループの前に@syncを付けて、ループの末尾で完了を待つこともできます。

リダクション演算子は不要で、ある範囲内のすべての整数(より一般には、あるコレクション内のすべての要素)に関数を適用したいだけの場合もあります。これも並列mapと呼ばれる有用な操作で、Juliaではpmap関数として実装されています。たとえば、複数の大きな乱数行列の特異値を、次のように並列に計算できます。

julia> M = Matrix{Float64}[rand(1000,1000) for i = 1:10];

julia> pmap(svdvals, M);

Juliaのpmapは、各関数呼び出しが大量の処理を行う場合を想定して設計されています。一方、@distributed forは、各反復が2つの数値を足すだけといった、ごく小さな処理である場合にも対応できます。pmapと@distributed forは、どちらも並列計算にはワーカープロセスだけを使用します。@distributed forの場合、最後のリダクションは呼び出し元のプロセスで行われます。

Remote References and AbstractChannels

リモート参照は、常にAbstractChannelの実装を参照します。

AbstractChannelの具象実装(Channelなど)には、put!、take!、fetch、isready、waitを実装する必要があります。Futureが参照するリモートオブジェクトは、Channel{Any}(1)に格納されます。これは、Any型のオブジェクトを保持できる、サイズ1のChannelです。

書き換え可能なRemoteChannelは、任意の型とサイズのチャネルや、AbstractChannelのその他の実装を参照できます。

コンストラクターRemoteChannel(f::Function, pid)()を使うと、特定の型の値を複数保持するチャネルへの参照を作成できます。fはpid上で実行される関数で、AbstractChannelを返す必要があります。

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

RemoteChannelに対するメソッドput!、take!、fetch、isready、waitは、リモートプロセス上の実体となる格納先に転送されます。

したがって、RemoteChannelを使って、ユーザーが実装したAbstractChannelオブジェクトを参照できます。その簡単な例が、辞書をリモートの格納先として使う次のDictChannelです。

julia> struct DictChannel{T} <: AbstractChannel{T}
           d::Dict
           cond_take::Threads.Condition    # waiting for data to become available
           DictChannel{T}() where {T} = new(Dict(), Threads.Condition())
           DictChannel() = DictChannel{Any}()
       end

julia> begin
       function Base.put!(D::DictChannel, k, v)
           @lock D.cond_take begin
               D.d[k] = v
               notify(D.cond_take)
           end
           return D
       end
       function Base.take!(D::DictChannel, k)
           @lock D.cond_take begin
               v = fetch(D, k)
               delete!(D.d, k)
               return v
           end
       end
       Base.isready(D::DictChannel) = @lock D.cond_take !isempty(D.d)
       Base.isready(D::DictChannel, k) = @lock D.cond_take haskey(D.d, k)
       function Base.fetch(D::DictChannel, k)
           @lock D.cond_take begin
               wait(D, k)
               return D.d[k]
           end
       end
       function Base.wait(D::DictChannel, k)
           @lock D.cond_take begin
               while !isready(D, k)
                   wait(D.cond_take)
               end
           end
       end
       end;

julia> d = DictChannel();

julia> isready(d)
false

julia> put!(d, :k, :v);

julia> isready(d, :k)
true

julia> fetch(d, :k)
:v

julia> wait(d, :k)

julia> take!(d, :k)
:v

julia> isready(d, :k)
false

Channels and RemoteChannels

  • Channelはプロセス内でローカルなものです。ワーカー2からワーカー3のChannelを直接参照することはできず、逆も同様です。一方、RemoteChannelでは、ワーカーをまたいで値を格納したり取り出したりできます。
  • RemoteChannelは、Channelへのハンドルと考えることができます。
  • RemoteChannelに対応するプロセスID、pidは、実体となる格納先、つまり背後にあるChannelが存在するプロセスを識別します。
  • RemoteChannelへの参照を持つプロセスは、どれでもそのチャネルに要素を格納したり取り出したりできます。データは、RemoteChannelに対応するプロセスへ自動的に送信されます(または、そのプロセスから取得されます)。
  • Channelをシリアライズすると、チャネル内のデータもシリアライズされます。そのため、デシリアライズすると、実質的に元のオブジェクトのコピーが作成されます。
  • 一方、RemoteChannelのシリアライズでは、ハンドルが参照するChannelの場所とインスタンスを特定する識別子だけがシリアライズされます。したがって、デシリアライズされたRemoteChannelオブジェクトも、どのワーカー上にあっても、元のものと同じ格納先を参照します。

先ほどのチャネルの例は、次のように変更すればプロセス間通信に使えます。

1つのリモートチャネルjobsを処理するために、4つのワーカーを起動します。ID(job_id)で識別されるジョブをチャネルに書き込みます。このシミュレーションでリモート実行される各タスクは、job_idを読み取り、ランダムな時間だけ待ってから、job_id、所要時間、自身のpidをまとめたタプルを結果チャネルへ書き戻します。最後に、マスタープロセスですべてのresultsを出力します。

julia> addprocs(4); # add worker processes

julia> const jobs = RemoteChannel(()->Channel{Int}(32));

julia> const results = RemoteChannel(()->Channel{Tuple}(32));

julia> @everywhere function do_work(jobs, results) # define work function everywhere
           while true
               job_id = take!(jobs)
               exec_time = rand()
               sleep(exec_time) # simulates elapsed time doing actual work
               put!(results, (job_id, exec_time, myid()))
           end
       end

julia> function make_jobs(n)
           for i in 1:n
               put!(jobs, i)
           end
       end;

julia> n = 12;

julia> errormonitor(Threads.@spawn make_jobs(n)); # feed the jobs channel with "n" jobs

julia> for p in workers() # start tasks on the workers to process requests in parallel
           remote_do(do_work, p, jobs, results)
       end

julia> @elapsed while n > 0 # print out results
           job_id, exec_time, worker_id = take!(results)
           println("$job_id finished in $(round(exec_time; digits=2)) seconds on worker $worker_id")
           global n = n - 1
       end
1 finished in 0.18 seconds on worker 4
2 finished in 0.26 seconds on worker 5
6 finished in 0.12 seconds on worker 4
7 finished in 0.18 seconds on worker 4
5 finished in 0.35 seconds on worker 5
4 finished in 0.68 seconds on worker 2
3 finished in 0.73 seconds on worker 3
11 finished in 0.01 seconds on worker 3
12 finished in 0.02 seconds on worker 3
9 finished in 0.26 seconds on worker 5
8 finished in 0.57 seconds on worker 4
10 finished in 0.58 seconds on worker 2
0.055971741

Remote References and Distributed Garbage Collection

リモート参照が指すオブジェクトを解放できるのは、クラスター内で保持されている参照がすべて削除されたときだけです。

値を格納するノードは、どのワーカーがその値への参照を持っているかを追跡します。RemoteChannelや、まだ値を取得していないFutureがワーカーへシリアライズされるたびに、参照先のノードへ通知されます。また、RemoteChannelや、まだ値を取得していないFutureがローカルでガベージコレクションされるたびに、値を所有するノードへ通知されます。これは、クラスターを認識する内部シリアライザーによって実装されています。リモート参照は、実行中のクラスター内でのみ有効です。通常のIOオブジェクトに対して参照をシリアライズしたり、そこからデシリアライズしたりすることはサポートされていません。

通知は「追跡」メッセージを送信することで行われます。参照が別のプロセスへシリアライズされると「参照追加」メッセージが送られ、参照がローカルでガベージコレクションされると「参照削除」メッセージが送られます。

Futureは一度だけ書き込み可能で、ローカルにキャッシュされるため、Futureに対してfetchを実行すると、値を所有するノードの参照追跡情報も更新されます。

値を所有するノードは、その値への参照がすべてなくなった時点で値を解放します。

Futureでは、すでに値を取得済みのFutureを別のノードへシリアライズすると、値も一緒に送信されます。この時点では、元のリモート格納先の値がすでに回収されている可能性があるためです。

オブジェクトがローカルでガベージコレクションされるタイミングは、オブジェクトのサイズと、システムの現在のメモリ逼迫状況によって決まることに注意してください。

リモート参照では、ローカルの参照オブジェクトは非常に小さい一方で、リモートノードに格納された値は非常に大きいことがあります。ローカルオブジェクトはすぐに回収されるとは限らないため、RemoteChannelのローカルインスタンスや、まだ値を取得していないFutureに対しては、finalizeを明示的に呼び出すことをお勧めします。Futureにfetchを呼び出すと、リモート格納先からその参照も削除されるため、値を取得済みのFutureではこれは不要です。finalizeを明示的に呼び出すと、その値への参照を削除するよう、リモートノードへ直ちにメッセージが送信されます。

ファイナライズされた参照は無効になり、それ以降の呼び出しでは使用できません。

Local invocations

リモートノードで実行する際には、必ずデータがそのノードへコピーされます。これは、リモート呼び出しの場合も、別のノード上のRemoteChannel / Futureにデータを格納する場合も同様です。予想どおり、リモートノード上にはシリアライズされたオブジェクトのコピーが作成されます。ただし、宛先ノードがローカルノードである場合、つまり呼び出し元のプロセスIDとリモートノードのIDが同じ場合は、ローカル呼び出しとして実行されます。通常は別のタスクで実行されますが、常にそうとは限りません。また、データのシリアライズやデシリアライズは行われません。そのため、呼び出しは渡されたものと同じオブジェクトインスタンスを参照し、コピーは作成されません。この動作を次の例で示します。

julia> using Distributed

julia> rc = RemoteChannel(()->Channel(3));   # RemoteChannel created on local node

julia> v = [0];

julia> for i in 1:3
           v[1] = i                          # Reusing `v`
           put!(rc, v)
       end;

julia> result = [take!(rc) for _ in 1:3];

julia> println(result);
[[3], [3], [3]]

julia> println("Num Unique objects : ", length(unique(map(objectid, result))));
Num Unique objects : 1

julia> addprocs(1);

julia> rc = RemoteChannel(()->Channel(3), workers()[1]);   # RemoteChannel created on remote node

julia> v = [0];

julia> for i in 1:3
           v[1] = i
           put!(rc, v)
       end;

julia> result = [take!(rc) for _ in 1:3];

julia> println(result);
[[1], [2], [3]]

julia> println("Num Unique objects : ", length(unique(map(objectid, result))));
Num Unique objects : 3

このように、ローカルで所有するRemoteChannelに対して、同じオブジェクトvを呼び出し間で変更しながらput!を行うと、格納されるのは同じ1つのオブジェクトインスタンスです。これに対し、rcを所有するノードが別のノードであれば、vのコピーが作成されます。

通常、これは問題にはなりません。考慮が必要なのは、オブジェクトをローカルに格納し、かつ呼び出し後にそのオブジェクトを変更する場合だけです。そのような場合は、オブジェクトのdeepcopyを格納するのが適切なことがあります。

これは、次の例に示すように、ローカルノードへのリモート呼び出しでも同じです。

julia> using Distributed; addprocs(1);

julia> v = [0];

julia> v2 = remotecall_fetch(x->(x[1] = 1; x), myid(), v);     # Executed on local node

julia> println("v=$v, v2=$v2, ", v === v2);
v=[1], v2=[1], true

julia> v = [0];

julia> v2 = remotecall_fetch(x->(x[1] = 1; x), workers()[1], v); # Executed on remote node

julia> println("v=$v, v2=$v2, ", v === v2);
v=[0], v2=[1], false

この例でも、ローカルノードへのリモート呼び出しは、直接呼び出した場合と同じように動作します。引数として渡されたローカルオブジェクトが変更されます。一方、リモートでの実行では、引数のコピーに対して操作が行われます。

繰り返しになりますが、通常、これは問題にはなりません。ローカルノードを計算ノードとしても使用し、呼び出し後に引数を使用する場合は、この動作を考慮する必要があります。必要に応じて、ローカルノードへの呼び出しには引数のディープコピーを渡さなければなりません。リモートノードへの呼び出しは、常に引数のコピーを操作します。

Shared Arrays

共有配列は、システムの共有メモリを使って、同じ配列を複数のプロセスにマッピングします。同じマシン上の2つ以上のプロセスから大量のデータに共同でアクセスしたい場合には、SharedArrayが適しています。共有配列のサポートはモジュールSharedArraysで提供されており、参加するすべてのワーカーで明示的に読み込む必要があります。

これを補完するデータ構造として、外部パッケージDistributedArrays.jlがDArrayを提供しています。SharedArrayと似た点もありますが、DArrayの動作は大きく異なります。SharedArrayでは、「参加する」各プロセスが配列全体にアクセスできます。一方、DArrayでは、各プロセスがローカルにアクセスできるのはデータの一部分だけであり、同じ部分を複数のプロセスで共有することはありません。

SharedArrayのインデックス操作(代入と値へのアクセス)は通常の配列と同じように動作し、基礎となるメモリをローカルプロセスから利用できるため効率的です。そのため、ほとんどのアルゴリズムは、単一プロセスでの実行にはなるものの、SharedArrayに対してそのまま動作します。アルゴリズムが入力としてArrayを要求する場合は、sdataを呼び出すことで、SharedArrayから基礎となる配列を取得できます。他のAbstractArray型では、sdataはオブジェクト自体をそのまま返すため、任意のArray型のオブジェクトに対してsdataを安全に使用できます。

共有配列のコンストラクターは、次の形式です。

SharedArray{T,N}(dims::NTuple; init=false, pids=Int[])

これは、pidsで指定したプロセス間で共有する、要素のbits型がT、サイズがdimsのN次元共有配列を作成します。分散配列とは異なり、共有配列にアクセスできるのは、名前付き引数pidsで指定した参加ワーカーだけです(作成元のプロセスが同じホスト上にある場合は、そのプロセスからもアクセスできます)。SharedArrayでサポートされるのは、isbitsである要素だけであることに注意してください。

シグネチャがinitfn(S::SharedArray)のinit関数を指定すると、参加するすべてのワーカー上で呼び出されます。各ワーカーが配列の異なる部分に対してinit関数を実行するように指定すれば、初期化を並列化できます。

簡単な例を示します。

julia> using Distributed

julia> addprocs(3)
3-element Vector{Int64}:
 2
 3
 4

julia> @everywhere using SharedArrays

julia> S = SharedArray{Int,2}((3,4), init = S -> S[localindices(S)] = repeat([myid()], length(localindices(S))))
3×4 SharedMatrix{Int64}:
 2  2  3  4
 2  3  3  4
 2  3  4  4

julia> S[3,2] = 7
7

julia> S
3×4 SharedMatrix{Int64}:
 2  2  3  4
 2  3  3  4
 2  7  4  4

SharedArrays.localindicesは、互いに重ならない1次元のインデックス範囲を提供するため、プロセス間でタスクを分担する際に便利なことがあります。もちろん、処理は任意の方法で分割できます。

julia> S = SharedArray{Int,2}((3,4), init = S -> S[indexpids(S):length(procs(S)):length(S)] = repeat([myid()], length( indexpids(S):length(procs(S)):length(S))))
3×4 SharedMatrix{Int64}:
 2  2  2  2
 3  3  3  3
 4  4  4  4

すべてのプロセスが基礎となるデータにアクセスできるため、競合が生じないよう注意する必要があります。たとえば、次のコードを考えてみましょう。

@sync begin
    for p in procs(S)
        Threads.@spawn begin
            remotecall_wait(fill!, p, S, p)
        end
    end
end

これは未定義の動作を引き起こします。各プロセスが配列全体を自身のpidで埋めるため、Sの各要素には、最後に書き込んだプロセスのpidが残ります。

より大きく複雑な例として、次の「カーネル」を並列に実行することを考えてみましょう。

q[i,j,t+1] = q[i,j,t] + u[i,j,t]

この場合、1次元のインデックスを使って処理を分割しようとすると、問題が生じる可能性が高くなります。q[i,j,t]があるワーカーに割り当てられた領域の末尾付近にあり、q[i,j,t+1]が別のワーカーに割り当てられた領域の先頭付近にあると、q[i,j,t+1]の計算に必要な時点で、q[i,j,t]がまだ準備できていない可能性が高いからです。このような場合は、配列を手動で分割した方がよいでしょう。ここでは第2次元に沿って分割します。まず、このワーカーに割り当てられた(irange, jrange)のインデックスを返す関数を定義します。

julia> @everywhere function myrange(q::SharedArray)
           idx = indexpids(q)
           if idx == 0 # This worker is not assigned a piece
               return 1:0, 1:0
           end
           nchunks = length(procs(q))
           splits = [round(Int, s) for s in range(0, stop=size(q,2), length=nchunks+1)]
           1:size(q,1), splits[idx]+1:splits[idx+1]
       end

次に、カーネルを定義します。

julia> @everywhere function advection_chunk!(q, u, irange, jrange, trange)
           @show (irange, jrange, trange)  # display so we can see what's happening
           for t in trange, j in jrange, i in irange
               q[i,j,t+1] = q[i,j,t] + u[i,j,t]
           end
           q
       end

SharedArrayによる実装のために、使いやすくするラッパーも定義します。

julia> @everywhere advection_shared_chunk!(q, u) =
           advection_chunk!(q, u, myrange(q)..., 1:size(q,3)-1)

では、3つの異なるバージョンを比較してみましょう。まず、単一プロセスで実行するものです。

julia> advection_serial!(q, u) = advection_chunk!(q, u, 1:size(q,1), 1:size(q,2), 1:size(q,3)-1);

次に、@distributedを使うものです。

julia> function advection_parallel!(q, u)
           for t = 1:size(q,3)-1
               @sync @distributed for j = 1:size(q,2)
                   for i = 1:size(q,1)
                       q[i,j,t+1]= q[i,j,t] + u[i,j,t]
                   end
               end
           end
           q
       end;

最後に、分割した領域ごとに処理を委譲するものです。

julia> function advection_shared!(q, u)
           @sync begin
               for p in procs(q)
                   Threads.@spawn remotecall_wait(advection_shared_chunk!, p, q, u)
               end
           end
           q
       end;

SharedArrayを作成してこれらの関数の実行時間を測定すると、次の結果が得られます(julia -p 4を使用)。

julia> q = SharedArray{Float64,3}((500,500,500));

julia> u = SharedArray{Float64,3}((500,500,500));

関数を一度実行してJITコンパイルを済ませ、2回目の実行で@timeを使って測定します。

julia> @time advection_serial!(q, u);
(irange,jrange,trange) = (1:500,1:500,1:499)
 830.220 milliseconds (216 allocations: 13820 bytes)

julia> @time advection_parallel!(q, u);
   2.495 seconds      (3999 k allocations: 289 MB, 2.09% gc time)

julia> @time advection_shared!(q,u);
        From worker 2:       (irange,jrange,trange) = (1:500,1:125,1:499)
        From worker 4:       (irange,jrange,trange) = (1:500,251:375,1:499)
        From worker 3:       (irange,jrange,trange) = (1:500,126:250,1:499)
        From worker 5:       (irange,jrange,trange) = (1:500,376:500,1:499)
 238.119 milliseconds (2264 allocations: 169 KB)

advection_shared!の最大の利点は、ワーカー間の通信を最小限に抑え、それぞれが割り当てられた領域で長時間計算を続けられることです。

Shared Arrays and Distributed Garbage Collection

リモート参照と同様に、共有配列も、参加するすべてのワーカーからの参照を解放するために、作成元ノードのガベージコレクションに依存します。寿命の短い共有配列オブジェクトを多数作成するコードでは、できるだけ早くそれらを明示的にファイナライズすると有効です。これにより、メモリと、共有領域をマッピングするファイルハンドルの両方が、より早く解放されます。

ClusterManagers

Juliaプロセスを起動・管理し、論理的なクラスターとしてネットワーク接続する処理は、クラスターマネージャーを介して行われます。ClusterManagerは、次の役割を担います。

  • クラスター環境でワーカープロセスを起動する
  • 各ワーカーの存続期間中に発生するイベントを管理する
  • 必要に応じて、データ転送機能を提供する

Juliaのクラスターには、次の特徴があります。

  • 最初のJuliaプロセスはmasterとも呼ばれる特別なプロセスで、そのidは1です。
  • ワーカープロセスを追加・削除できるのは、masterプロセスだけです。
  • すべてのプロセスが互いに直接通信できます。

ワーカー間の接続(組み込みのTCP/IPトランスポートを使用)は、次の手順で確立されます。

  • マスタープロセスで、ClusterManagerオブジェクトを指定してaddprocsを呼び出します。
  • addprocsは適切なlaunchメソッドを呼び出し、適切なマシン上に必要な数のワーカープロセスを起動します。
  • 各ワーカーは空きポートで待ち受けを開始し、ホストとポートの情報をstdoutへ出力します。
  • クラスターマネージャーは各ワーカーのstdoutを取得し、マスタープロセスから利用できるようにします。
  • マスタープロセスはこの情報を解析し、各ワーカーへのTCP/IP接続を確立します。
  • 各ワーカーには、クラスター内の他のワーカーの情報も通知されます。
  • 各ワーカーは、自身のidよりもidが小さいすべてのワーカーに接続します。
  • こうして、すべてのワーカーが他のすべてのワーカーと直接接続されたメッシュネットワークが確立されます。

デフォルトのトランスポート層では通常のTCPSocketを使いますが、Juliaクラスターで独自のトランスポートを提供することもできます。

Juliaには、次の2つのクラスターマネージャーが組み込まれています。

LocalManagerは、同じホスト上に追加のワーカーを起動するために使われます。これにより、マルチコアやマルチプロセッサーのハードウェアを活用できます。

したがって、最低限のクラスターマネージャーには次が必要です。

  • 抽象型ClusterManagerのサブタイプであること
  • 新しいワーカーの起動を担うメソッドlaunchを実装すること
  • ワーカーの存続期間中のさまざまなイベント(割り込みシグナルの送信など)で呼び出されるmanageを実装すること

addprocs(manager::FooManager)を利用するには、FooManagerに次を実装する必要があります。

function launch(manager::FooManager, params::Dict, launched::Array, c::Condition)
    [...]
end

function manage(manager::FooManager, id::Integer, config::WorkerConfig, op::Symbol)
    [...]
end

例として、同じホスト上でワーカーを起動するマネージャーであるLocalManagerの実装を見てみましょう。

struct LocalManager <: ClusterManager
    np::Integer
end

function launch(manager::LocalManager, params::Dict, launched::Array, c::Condition)
    [...]
end

function manage(manager::LocalManager, id::Integer, config::WorkerConfig, op::Symbol)
    [...]
end

launchメソッドは、次の引数を受け取ります。

  • manager::ClusterManager:addprocsの呼び出しに指定されたクラスターマネージャー
  • params::Dict:addprocsに渡されたすべてのキーワード引数
  • launched::Array:1つ以上のWorkerConfigオブジェクトを追加する配列
  • c::Condition:ワーカーが起動されるたびに通知する条件変数

launchメソッドは、別のタスクで非同期に呼び出されます。このタスクの終了は、要求されたすべてのワーカーの起動が完了したことを示します。したがって、launch関数は、要求されたすべてのワーカーを起動したら、直ちに終了しなければなりません。

新しく起動したワーカーは、他のワーカーおよびマスタープロセスと全対全で接続されます。コマンドライン引数--worker[=<cookie>]を指定すると、起動したプロセスは自身をワーカーとして初期化し、TCP/IPソケットを介して接続を確立します。

クラスター内のすべてのワーカーは、マスターと同じcookieを共有します。Cookieが指定されていない場合、つまり--workerオプションを使用した場合、ワーカーは標準入力からCookieを読み取ろうとします。LocalManagerとSSHManagerは、どちらも新しく起動したワーカーの標準入力を介してCookieを渡します。

デフォルトでは、ワーカーはgetipaddr()の呼び出しで返されるアドレスの空きポートで待ち受けます。省略可能な引数--bind-to bind_addr[:port]で、待ち受けるアドレスを明示的に指定できます。これは、複数のネットワークインターフェースを持つホストで有用です。

TCP/IP以外のトランスポートの例として、MPIを使用する実装も考えられます。その場合、--workerを指定してはいけません。代わりに、新しく起動したワーカーは、並列処理の構文を使う前にinit_worker(cookie)を呼び出す必要があります。

launchメソッドは、起動したワーカーごとに、適切なフィールドを初期化したWorkerConfigオブジェクトをlaunchedへ追加しなければなりません。

mutable struct WorkerConfig
    # Common fields relevant to all cluster managers
    io::Union{IO, Nothing}
    host::Union{AbstractString, Nothing}
    port::Union{Integer, Nothing}

    # Used when launching additional workers at a host
    count::Union{Int, Symbol, Nothing}
    exename::Union{AbstractString, Cmd, Nothing}
    exeflags::Union{Cmd, Nothing}

    # External cluster managers can use this to store information at a per-worker level
    # Can be a dict if multiple fields need to be stored.
    userdata::Any

    # SSHManager / SSH tunnel connections to workers
    tunnel::Union{Bool, Nothing}
    bind_addr::Union{AbstractString, Nothing}
    sshflags::Union{Cmd, Nothing}
    max_parallel::Union{Integer, Nothing}

    # Used by Local/SSH managers
    connect_at::Any

    [...]
end

WorkerConfigのフィールドの多くは、組み込みのマネージャーが使用します。独自のクラスターマネージャーでは、通常、io、またはhost / portだけを指定します。

  • ioを指定すると、ホストとポートの情報を読み取るために使われます。Juliaワーカーは起動時にバインド先アドレスとポートを出力します。そのため、ワーカーのポートを手動で設定せずに、利用可能な任意の空きポートで待ち受けることができます。

  • ioを指定しない場合、接続にはhostとportが使われます。

  • count、exename、exeflagsは、ワーカーから追加のワーカーを起動する際に使用します。たとえば、クラスターマネージャーが各ノードにワーカーを1つずつ起動し、それを使って追加のワーカーを起動することができます。

    • countに整数値nを指定すると、合計n個のワーカーが起動します。
    • countに:autoを指定すると、そのマシンのCPUスレッド数(論理コア数)と同じ数のワーカーが起動します。
    • exenameは、フルパスを含むjulia実行ファイルの名前です。
    • exeflagsには、新しいワーカーに必要なコマンドライン引数を設定します。
  • tunnel、bind_addr、sshflags、max_parallelは、マスタープロセスからワーカーへ接続するためにsshトンネルが必要な場合に使われます。

  • userdataは、独自のクラスターマネージャーがワーカー固有の情報を格納するために用意されています。

manage(manager::FooManager, id::Integer, config::WorkerConfig, op::Symbol)は、ワーカーの存続期間中のさまざまなタイミングで、適切なop値を指定して呼び出されます。

  • ワーカーがJuliaのワーカープールに追加・削除されると、それぞれ:register / :deregisterで呼び出されます。
  • interrupt(workers)が呼び出されると、:interruptで呼び出されます。ClusterManagerは、該当するワーカーに割り込みシグナルを送る必要があります。
  • 後処理のために、:finalizeで呼び出されます。

Cluster Managers with Custom Transports

デフォルトのTCP/IPによる全対全のソケット接続を独自のトランスポート層に置き換えるには、もう少し複雑な実装が必要です。各Juliaプロセスは、接続先のワーカー数と同じ数の通信タスクを持ちます。たとえば、32プロセスからなる全対全メッシュネットワークのJuliaクラスターを考えてみましょう。

  • 各Juliaプロセスには、31個の通信タスクがあります。
  • 各タスクはメッセージ処理ループを実行し、1つのリモートワーカーから受信するすべてのメッセージを処理します。
  • メッセージ処理ループは、IOオブジェクト(デフォルト実装ではTCPSocketなど)で待機し、メッセージを1つ丸ごと読み取り、処理してから、次のメッセージを待ちます。
  • プロセスへのメッセージ送信は、通信タスクに限らず、任意のJuliaタスクから直接行われます。この場合も、適切なIOオブジェクトを介して送信します。

デフォルトのトランスポートを置き換えるには、新しい実装でリモートワーカーへの接続を確立し、メッセージ処理ループが待機できる適切なIOオブジェクトを提供する必要があります。実装すべきマネージャー固有のコールバックは、次のとおりです。

connect(manager::FooManager, pid::Integer, config::WorkerConfig)
kill(manager::FooManager, pid::Int, config::WorkerConfig)

TCP/IPソケットを使うデフォルトの実装は、connect(manager::ClusterManager, pid::Integer, config::WorkerConfig)として実装されています。

connectは、IOオブジェクトのペアを返す必要があります。一方はワーカーpidから送られたデータを読み取るためのもの、もう一方はワーカーpidへ送るデータを書き込むためのものです。独自のクラスターマネージャーでは、メモリ内のBufferStreamを橋渡しとして使い、IOに基づかない可能性もある独自のトランスポートと、Juliaに組み込まれた並列処理基盤との間でデータを中継できます。

BufferStreamは、IOのように動作するメモリ内のIOBufferです。つまり、非同期に扱えるストリームです。

Examples repositoryのclustermanager/0mqフォルダーには、ZeroMQを使い、中央に0MQブローカーを配置したスタートポロジーでJuliaワーカーを接続する例があります。なお、Juliaプロセスは論理的には引き続きすべて相互に接続されています。どのワーカーも、トランスポート層で0MQが使われていることを意識せずに、他の任意のワーカーへ直接メッセージを送信できます。

独自のトランスポートを使う場合は、次の点に注意してください。

  • Juliaワーカーを--workerで起動してはいけません。--workerで起動すると、新しく起動したワーカーはデフォルトのTCP/IPソケットトランスポート実装を使用します。
  • ワーカーからの論理接続を受け入れるたびに、Base.process_messages(rd::IO, wr::IO)()を呼び出す必要があります。これにより、IOオブジェクトが表すワーカーとのメッセージの読み書きを処理する、新しいタスクが起動します。
  • ワーカープロセスの初期化の一環として、init_worker(cookie, manager::FooManager)を必ず呼び出さなければなりません。
  • launchの呼び出し時に、クラスターマネージャーはWorkerConfigのフィールドconnect_at::Anyを設定できます。このフィールドの値は、すべてのconnectコールバックに渡されます。通常、このフィールドにはワーカーへの接続方法に関する情報を格納します。たとえば、TCP/IPソケットトランスポートでは、このフィールドでワーカーへの接続先を表す(host, port)タプルを指定します。

kill(manager, pid, config)は、クラスターからワーカーを削除するために呼び出されます。適切に後処理を行うため、実装側でマスタープロセス上の対応するIOオブジェクトを閉じる必要があります。デフォルト実装は、指定したリモートワーカー上でexit()呼び出しを実行するだけです。

Examplesフォルダーのclustermanager/simpleは、UNIXドメインソケットを使ってクラスターを構成する簡単な実装例です。

Network Requirements for LocalManager and SSHManager

Juliaクラスターは、ローカルのノートPC、部門内のクラスター、クラウドなど、すでに安全が確保された環境のインフラストラクチャ上で実行することを想定して設計されています。この節では、組み込みのLocalManagerとSSHManagerに関するネットワークセキュリティ要件を説明します。

  • マスタープロセスは、どのポートでも待ち受けを行いません。ワーカーへの発信接続だけを行います。

  • 各ワーカーは、ローカルインターフェースのうち1つだけにバインドし、OSが割り当てたエフェメラルポート番号で待ち受けます。

  • addprocs(N)が使うLocalManagerは、デフォルトではループバックインターフェースにのみバインドします。つまり、後からリモートホスト上で起動したワーカーや、悪意のある第三者が起動したワーカーは、クラスターに接続できません。addprocs(4)に続けてaddprocs(["remote_host"])を実行すると失敗します。ローカルシステムといくつかのリモートシステムからなるクラスターを作成したい場合は、キーワード引数restrictを使い、LocalManagerに外部ネットワークインターフェースへバインドするよう明示的に指定できます:addprocs(4; restrict=false)。

  • addprocs(list_of_remote_hosts)が使うSSHManagerは、SSHを介してリモートホスト上にワーカーを起動します。デフォルトでは、SSHはJuliaワーカーの起動にのみ使われます。その後のマスター・ワーカー間およびワーカー間の接続には、暗号化されていない通常のTCP/IPソケットが使われます。リモートホストでは、パスワードなしのログインを有効にしておく必要があります。追加のSSHフラグや認証情報は、キーワード引数sshflagsで指定できます。

  • マスター・ワーカー間にもSSH接続を使いたい場合は、addprocs(list_of_remote_hosts; tunnel=true, sshflags=<ssh keys and other flags>)が有用です。典型的な例は、ローカルのノートPCでJulia REPL(つまりマスター)を実行し、クラスターの残りをAmazon EC2などのクラウド上に配置する場合です。この場合、公開鍵基盤(PKI)による認証を行うSSHクライアントを使えば、リモートクラスターではポート22だけを開けば済みます。認証情報はsshflagsで指定でき、たとえばsshflags=`-i <keyfile>`とします。

    デフォルトの全対全トポロジーでは、すべてのワーカーが通常のTCPソケットで相互接続します。そのため、クラスターノードのセキュリティポリシーでは、エフェメラルポートの範囲(OSによって異なります)でワーカー間の通信を自由に行えるようにする必要があります。

    SSHによってワーカー間のすべての通信を保護・暗号化したり、個々のメッセージを暗号化したりするには、独自のClusterManagerを使用できます。

  • addprocsのオプションとしてmultiplex=trueを指定すると、SSH多重化を使ってマスターとワーカーの間にトンネルを作成します。SSH多重化を自分で設定しており、すでに接続が確立されている場合は、multiplexオプションにかかわらずSSH多重化が使われます。多重化が有効な場合、既存の接続を使って転送を設定します(sshの-O forwardオプション)。これは、サーバーがパスワード認証を要求する場合に便利です。addprocsの前にサーバーへログインしておけば、Julia内での認証を省略できます。既存の多重化接続を使用しない限り、セッション中の制御ソケットは~/.ssh/julia-%r@%h:%pに配置されます。なお、1つのノードに複数のプロセスを作成して多重化を有効にすると、各プロセスが1つの多重化TCP接続を共有するため、帯域幅が制限される可能性があります。

クラスター内のすべてのプロセスは同じCookieを共有します。デフォルトでは、マスタープロセスでランダムに生成された文字列が使われます。

  • cluster_cookie()はCookieを返します。一方、cluster_cookie(cookie)()はCookieを設定し、新しいCookieを返します。
  • すべての接続で双方向に認証を行い、マスターが起動したワーカーだけが相互に接続できるようにします。
  • Cookieは、起動時に引数--worker=<cookie>でワーカーに渡せます。Cookieを付けずに引数--workerを指定すると、ワーカーは標準入力(stdin)からCookieを読み取ろうとします。Cookieを取得すると、stdinは直ちに閉じられます。
  • ClusterManagerは、マスター上でcluster_cookie()を呼び出すことでCookieを取得できます。デフォルトのTCP/IPトランスポートを使用しないクラスターマネージャー(したがって--workerを指定しないもの)は、マスターと同じCookieでinit_worker(cookie, manager)を呼び出さなければなりません。

より高いセキュリティが必要な環境では、独自のClusterManagerで対応できます。たとえば、Cookieを事前共有しておけば、起動引数で指定する必要はありません。

Specifying Network Topology (Experimental)

addprocsに渡すキーワード引数topologyは、ワーカー同士をどのように接続するかを指定します。

  • :all_to_all(デフォルト):すべてのワーカーを相互に接続します。
  • :master_worker:ドライバープロセス、つまりpidが1のプロセスだけがワーカーに接続します。
  • :custom:クラスターマネージャーのlaunchメソッドが、WorkerConfigのフィールドidentとconnect_identsを介して接続トポロジーを指定します。クラスターマネージャーから識別子identを与えられたワーカーは、connect_identsに指定されたすべてのワーカーに接続します。

キーワード引数lazy=true|falseは、topologyオプションが:all_to_allの場合にのみ影響します。trueの場合、クラスターはマスターがすべてのワーカーに接続した状態で開始します。個々のワーカー間の接続は、その2つのワーカー間で最初にリモート呼び出しを行った時点で確立されます。これにより、クラスター内通信のために初期段階で割り当てるリソースを減らせます。接続は、並列プログラムの実行時の必要に応じて確立されます。lazyのデフォルト値はtrueです。

現時点では、接続されていないワーカー間でメッセージを送信するとエラーになります。この動作は、機能やインターフェースと同様に実験的なものと考えてください。将来のリリースで変更される可能性があります。

Noteworthy external packages

Julia自体の並列処理機能以外にも、紹介すべき外部パッケージは数多くあります。たとえば、MPI.jlはMPIプロトコルのJuliaラッパーであり、Dagger.jlはPythonのDaskと同様の機能を提供します。また、DistributedArrays.jlは、outlined aboveとしてワーカー間に分散した配列操作を提供します。

JuliaのGPUプログラミングのエコシステムにも触れておきましょう。次のようなものが含まれます。

  1. CUDA.jlは、各種CUDAライブラリをラップし、Nvidia GPU向けのJuliaカーネルのコンパイルをサポートします。
  2. oneAPI.jlは、oneAPIの統合プログラミングモデルをラップし、対応するアクセラレーター上でのJuliaカーネルの実行をサポートします。現在サポートされているのはLinuxのみです。
  3. AMDGPU.jlは、AMD ROCmライブラリをラップし、AMD GPU向けのJuliaカーネルのコンパイルをサポートします。現在サポートされているのはLinuxのみです。
  4. KernelAbstractions.jl、Tullio.jl、ArrayFire.jlなどの高水準ライブラリ。

次の例では、DistributedArrays.jlとCUDA.jlの両方を使い、まずdistribute()とCuArray()を介してキャストすることで、配列を複数のプロセスに分散させます。

DistributedArrays.jlをインポートする際は、@everywhereを使ってすべてのプロセスでインポートすることを忘れないでください。

$ ./julia -p 4

julia> addprocs()

julia> @everywhere using DistributedArrays

julia> using CUDA

julia> B = ones(10_000) ./ 2;

julia> A = ones(10_000) .* π;

julia> C = 2 .* A ./ B;

julia> all(C .≈ 4*π)
true

julia> typeof(C)
Vector{Float64} (alias for Array{Float64, 1})

julia> dB = distribute(B);

julia> dA = distribute(A);

julia> dC = 2 .* dA ./ dB;

julia> all(dC .≈ 4*π)
true

julia> typeof(dC)
DistributedArrays.DArray{Float64,1,Vector{Float64}}

julia> cuB = CuArray(B);

julia> cuA = CuArray(A);

julia> cuC = 2 .* cuA ./ cuB;

julia> all(cuC .≈ 4*π);
true

julia> typeof(cuC)
CuArray{Float64,1}

次の例では、DistributedArrays.jlとCUDA.jlの両方を使って配列を複数のプロセスに分散させ、その配列に対して汎用関数を呼び出します。

function power_method(M, v)
    for i in 1:100
        v = M*v
        v /= norm(v)
    end

    return v, norm(M*v) / norm(v)  # or  (M*v) ./ v
end

power_methodは、新しいベクトルを作成して正規化する処理を繰り返します。関数の宣言では型シグネチャを一切指定していません。先ほどのデータ型で動作するか見てみましょう。

julia> M = [2. 1; 1 1];

julia> v = rand(2)
2-element Vector{Float64}:
0.40395
0.445877

julia> power_method(M,v)
([0.850651, 0.525731], 2.618033988749895)

julia> cuM = CuArray(M);

julia> cuv = CuArray(v);

julia> curesult = power_method(cuM, cuv);

julia> typeof(curesult)
CuArray{Float64,1}

julia> dM = distribute(M);

julia> dv = distribute(v);

julia> dC = power_method(dM, dv);

julia> typeof(dC)
Tuple{DistributedArrays.DArray{Float64,1,Vector{Float64}},Float64}

外部パッケージの簡単な紹介の締めくくりとして、MPIプロトコルのJuliaラッパーであるMPI.jlを見てみましょう。内部の関数をすべて取り上げると長くなりすぎるため、ここではプロトコルの実装に使われているアプローチを理解するにとどめます。

次の簡単なスクリプトを考えてみてください。各サブプロセスを呼び出してそのランクを初期化し、マスタープロセスに到達したところでランクの総和を計算します。

import MPI

MPI.Init()

comm = MPI.COMM_WORLD
MPI.Barrier(comm)

root = 0
r = MPI.Comm_rank(comm)

sr = MPI.Reduce(r, MPI.SUM, root, comm)

if(MPI.Comm_rank(comm) == root)
   @printf("sum of ranks: %s\n", sr)
end

MPI.Finalize()
mpirun -np 4 ./julia example.jl