Multi-Threading

Base.Threads.@threads — Macro
Threads.@threads [schedule] for ... end

for ループを並列実行するマクロです。反復空間は粗粒度のタスクに分割されます。このポリシーは schedule 引数で指定できます。ループの実行は、すべての反復の評価が完了するまで待機します。

@threads が生成するタスクは、:default スレッドプールでスケジュールされます。つまり、メインスレッドから呼び出した場合や、インタラクティブプールのタスクから呼び出した場合でも、@threads は :interactive スレッドプールのスレッドを使用しません。:default スレッドプールは、計算負荷の高い並列ワークロードを対象としています。

関連項目: @spawn および pmap(Distributed)。スレッドプールの詳細については、threadpools の章を参照してください。

Extended help

Semantics

スケジューリングオプションでより強い保証が指定されていない限り、@threads マクロで実行されるループは、次のような意味を持ちます。

@threads マクロは、ループ本体を順序未指定で、場合によっては並行して実行します。タスクとワーカースレッドの正確な割り当ては指定されておらず、実行ごとに異なることがあります。ループ本体のコード(そこから推移的に呼び出されるコードも含む)は、反復がタスクにどのように分配されるか、またはどのワーカースレッドで実行されるかを前提としてはなりません。各反復のループ本体は、他の反復に依存せずに処理を進められ、データ競合が発生しないものでなければなりません。そのため、反復間で不適切な同期を行うとデッドロックする可能性があり、同期されていないメモリアクセスは未定義動作を引き起こす可能性があります。

たとえば、上記の条件から次のことが導かれます。

  • ある反復で取得したロックは、その反復内で必ず解放しなければなりません。
  • Channel などのブロッキングプリミティブを使って反復間で通信するのは誤りです。
  • ロックまたはアトミック操作を使わない限り、反復間で共有されていない場所にのみ書き込んでください。
  • :static スケジュールを使用しない限り、threadid() の値は単一の反復内でも変化することがあります。Task Migration を参照してください。

Schedulers

スケジューラ引数を指定しない場合、正確なスケジューリング方法は未指定であり、Julia のリリースによって異なります。現在は、スケジューラを指定しない場合に :dynamic が使用されます。

Julia 1.5

schedule 引数は Julia 1.5 以降で使用できます。

:dynamic (default)

:dynamic スケジューラは、利用可能なワーカースレッドに反復を動的に割り当てて実行します。現在の実装では、各反復のワークロードが均一であることを前提としています。ただし、将来的にはこの前提がなくなる可能性があります。

このスケジューリングオプションは、基盤となる実行機構へのヒントにすぎません。ただし、いくつかの特性が期待できます。:dynamic スケジューラが使用する Task の数は、利用可能なワーカースレッド数(Threads.threadpoolsize())の小さな定数倍以下に制限されます。各タスクは、反復空間内の連続した領域を処理します。そのため、length(xs) がワーカースレッド数より十分に大きく、f(x) の実行時間がタスクの生成と同期にかかるコスト(通常は 10 マイクロ秒未満)より比較的短い場合、@threads :dynamic for x in xs; f(x); end は通常 @sync for x in xs; @spawn f(x); end より効率的です。

Julia 1.8

schedule 引数の :dynamic オプションは、Julia 1.8 以降で利用可能であり、デフォルトです。

:greedy

:greedy スケジューラは、最大 Threads.threadpoolsize() 個のタスクを生成します。各タスクは、イテレータが値を生成すると、それらを貪欲に処理します。タスクが処理を終えると、次の値をイテレータから取得します。個々のタスクが処理する値は、イテレータ上で連続しているとは限りません。イテレータは値を無限に生成してもかまいません。必要なのはイテレータインターフェースだけであり、インデックスアクセスは不要です。

各反復のワークロードが均一でない場合や、ばらつきが大きい場合には、一般にこのスケジューリングオプションが適しています。

Julia 1.11

schedule 引数の :greedy オプションは、Julia 1.11 以降で使用できます。

:static

:static スケジューラはスレッドごとに1つのタスクを作成し、反復を均等に分割して、それぞれのタスクを特定のスレッドに割り当てます。特に、threadid() の値は、1つの反復内では一定であることが保証されます。別の @threads ループの内部、またはスレッド1以外から呼び出した場合、:static を指定するとエラーになります。

Note

:static スケジューリングは、Julia 1.3 より前に書かれたコードの移行を支援するために用意されています。このオプションを使う関数は任意のワーカースレッドから呼び出せないため、新たに作成するライブラリ関数では :static スケジューリングの使用は推奨されません。

Examples

異なるスケジューリング方式を説明するため、指定した秒数だけ実行される、yield しない時間計測ループを含む次の関数 busywait を考えてみましょう。

julia> function busywait(seconds)
            tstart = time_ns()
            while (time_ns() - tstart) / 1e9 < seconds
            end
        end

julia> @time begin
            Threads.@spawn busywait(5)
            Threads.@threads :static for i in 1:Threads.threadpoolsize()
                busywait(1)
            end
        end
6.003001 seconds (16.33 k allocations: 899.255 KiB, 0.25% compilation time)

julia> @time begin
            Threads.@spawn busywait(5)
            Threads.@threads :dynamic for i in 1:Threads.threadpoolsize()
                busywait(1)
            end
        end
2.012056 seconds (16.05 k allocations: 883.919 KiB, 0.66% compilation time)

:dynamic の例は2秒かかります。空いているスレッドの1つが、1秒の反復を2回実行して for ループを完了できるためです。

source
Base.Threads.foreach — Function
Threads.foreach(f, channel::Channel;
                schedule::Threads.AbstractSchedule=Threads.FairSchedule(),
                ntasks=Threads.threadpoolsize())

foreach(f, channel)と同様ですが、channelの反復処理とfの呼び出しは、Threads.@spawnが生成する複数のntasksタスクに分割されます。この関数は、内部で生成したすべてのタスクが完了するまで待ってから戻ります。

schedule isa FairScheduleの場合、Threads.foreachは、Juliaのスケジューラがスレッド間で作業項目をより柔軟に負荷分散できるような方法でタスクを生成します。この方法は一般に項目ごとのオーバーヘッドが大きくなりますが、他のマルチスレッド処理と同時に実行する場合、StaticScheduleより高い性能を発揮することがあります。

schedule isa StaticScheduleの場合、Threads.foreachは、FairScheduleより項目ごとのオーバーヘッドが小さい一方、負荷分散には適していない方法でタスクを生成します。そのため、この方法は粒度が細かく均一なワークロードに適している可能性がありますが、他のマルチスレッド処理と同時に実行する場合、FairScheduleより性能が低下することがあります。

Examples

julia> n = 20

julia> c = Channel{Int}(ch -> foreach(i -> put!(ch, i), 1:n), 1)

julia> d = Channel{Int}(n) do ch
           f = i -> put!(ch, i^2)
           Threads.foreach(f, c)
       end

julia> collect(d)
collect(d) = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]
Julia 1.6

この関数を使用するには、Julia 1.6以降が必要です。

source
Base.Threads.@spawn — Macro
Threads.@spawn [:default|:interactive|:samepool] expr

指定したスレッドプール内で利用可能な任意のスレッド上で実行されるように、Task と schedule を作成します。スレッドプールには :default、:interactive、または呼び出し元と同じものを使う :samepool を指定できます。指定しない場合は :default が使われます。スレッドが利用可能になると、そのスレッドにタスクが割り当てられます。タスクの完了を待つには、このマクロの結果に対して wait を呼び出すか、fetch を呼び出して待機し、戻り値を取得します。

@spawn には、$ を使って値を補間できます。これにより、値が構築される基底のクロージャに直接コピーされます。変数の 値 を挿入できるため、現在のタスクでその変数の値が変更されても、非同期コードには影響しません。

Note

タスクが yield すると、実行されるスレッドが変わることがあります。そのため、タスク内で threadid() を定数として扱わないでください。重要な注意事項については Task Migration と、より広範な multi-threading マニュアルを参照してください。また、threadpools の章も参照してください。

Julia 1.3

このマクロは Julia 1.3 以降で利用できます。

Julia 1.4

$ による値の補間は Julia 1.4 以降で利用できます。

Julia 1.9

Julia 1.9 以降ではスレッドプールを指定できます。

Julia 1.12

Julia 1.12 以降では同じスレッドプールを指定できます。

Examples

julia> t() = println("Hello from ", Threads.threadid());

julia> tasks = fetch.([Threads.@spawn t() for i in 1:4]);
Hello from 1
Hello from 1
Hello from 3
Hello from 4
source
Base.Threads.threadid — Function
Threads.threadid([t::Task])::Int

現在実行中のスレッド、またはタスク t が実行されているスレッドの ID 番号を取得します。マスタースレッドの ID は 1 です。

Examples

julia> Threads.threadid()
1

julia> Threads.@threads for i in 1:4
          println(Threads.threadid())
       end
4
2
5
4

julia> Threads.threadid(Threads.@spawn "foo")
2
Note

タスクが実行されるスレッドは、タスクが yield すると変わることがあります。これは Task Migration と呼ばれます。そのため、ほとんどの場合、threadid([task]) を使って、たとえばバッファーや状態を持つオブジェクトのベクターをインデックス指定するのは安全ではありません。

source
Base.Threads.maxthreadid — Function
Threads.maxthreadid()::Int

アトミック取得セマンティクスで、Juliaプロセスが利用できるスレッド数(すべてのスレッドプールの合計)の下限を取得します。この値は、threadid()以上であり、maxthreadidを呼び出す前に観測できた任意のタスクについて、常にthreadid(task)以上になります。

source
Base.Threads.nthreads — Function
Threads.nthreads(:default | :interactive)::Int

指定されたスレッドプール内の現在のスレッド数を取得します。:interactive 内のスレッドの ID 番号は 1:nthreads(:interactive) で、:default 内のスレッドの ID 番号は nthreads(:interactive) .+ (1:nthreads(:default)) です。

LinearAlgebra 標準ライブラリの BLAS.get_num_threads と BLAS.set_num_threads、および Distributed 標準ライブラリの nprocs() と Threads.maxthreadid() も参照してください。

source
Base.Threads.threadpool — Function
Threads.threadpool(tid = threadid())::Symbol

指定したスレッドのスレッドプールを返します。:default、:interactive、または:foreignのいずれかです。

source
Base.Threads.threadpoolsize — Function
Threads.threadpoolsize(pool::Symbol = :default)::Int

デフォルトのスレッドプール(または指定したスレッドプール)で利用可能なスレッド数を取得します。

関連項目:LinearAlgebra標準ライブラリのBLAS.get_num_threadsおよびBLAS.set_num_threads、ならびにDistributed標準ライブラリのnprocs()。

source
Base.Threads.ngcthreads — Function
Threads.ngcthreads()::Int

現在設定されているGCスレッド数を返します。マークスレッドと並行スイープスレッドの両方が含まれます。

source

こちらも参照してください。Multi-Threading。

Atomic operations

atomic — Keyword

unsafeポインター操作は、C11では型が_Atomic、C++23では型がstd::atomicと宣言されたポインターの読み込みおよび書き込みに対応しています。Juliaの型Tをアトミックに読み込む機能がサポートされていない場合、エラーがスローされることがあります。

関連項目: unsafe_load、unsafe_modify!、unsafe_replace!、unsafe_store!、unsafe_swap!

source
Base.@atomic — Macro
@atomic var
@atomic order ex

var または ex をアトミックに実行するものとして指定します。ex がサポートされている式である必要があります。order が指定されていない場合、デフォルトは :sequentially_consistent です。

@atomic a.b.x = new
@atomic a.b.x += addend
@atomic :release a.b.x = new
@atomic :acquire_release a.b.x += addend
@atomic m[idx] = new
@atomic m[idx] += addend
@atomic :release m[idx] = new
@atomic :acquire_release m[idx] += addend

右辺で表されるストア操作をアトミックに実行し、新しい値を返します。

代入(=)の場合、この操作は setproperty!(a.b, :x, new) に変換されます。参照の場合は setindex_atomic!(m, order, new, idx) の呼び出しに変換され、order のデフォルトは :sequentially_consistent です。

変更演算子の場合、この操作は modifyproperty!(a.b, :x, op, addend)[2] に変換されます。参照の場合は modifyindex_atomic!(m, order, op, addend, idx...)[2] の呼び出しに変換され、order のデフォルトは :sequentially_consistent です。

@atomic a.b.x max arg2
@atomic a.b.x + arg2
@atomic max(a.b.x, arg2)
@atomic :acquire_release max(a.b.x, arg2)
@atomic :acquire_release a.b.x + arg2
@atomic :acquire_release a.b.x max arg2
@atomic m[idx] max arg2
@atomic m[idx] + arg2
@atomic max(m[idx], arg2)
@atomic :acquire_release max(m[idx], arg2)
@atomic :acquire_release m[idx] + arg2
@atomic :acquire_release m[idx] max arg2

右辺で表される二項演算をアトミックに実行します。結果を第1引数のフィールドまたは参照に格納し、値 (old, new) を返します。

この操作は modifyproperty!(a.b, :x, func, arg2) に変換されます。参照の場合は modifyindex_atomic!(m, order, func, arg2, idx) の呼び出しに変換され、order のデフォルトは :sequentially_consistent です。

詳細については、マニュアルの Per-field atomics セクションを参照してください。

Examples

julia> mutable struct Atomic{T}; @atomic x::T; end

julia> a = Atomic(1)
Atomic{Int64}(1)

julia> @atomic a.x # fetch field x of a, with sequential consistency
1

julia> @atomic :sequentially_consistent a.x = 2 # set field x of a, with sequential consistency
2

julia> @atomic a.x += 1 # increment field x of a, with sequential consistency
3

julia> @atomic a.x + 1 # increment field x of a, with sequential consistency
3 => 4

julia> @atomic a.x # fetch field x of a, with sequential consistency
4

julia> @atomic max(a.x, 10) # change field x of a to the max value, with sequential consistency
4 => 10

julia> @atomic a.x max 5 # again change field x of a to the max value, with sequential consistency
10 => 10
julia> mem = AtomicMemory{Int}(undef, 2);

julia> @atomic mem[1] = 2 # set mem[1] to value 2 with sequential consistency
2

julia> @atomic :monotonic mem[1] # fetch the first value of mem, with monotonic consistency
2

julia> @atomic mem[1] += 1 # increment the first value of mem, with sequential consistency
3

julia> @atomic mem[1] + 1 # increment the first value of mem, with sequential consistency
3 => 4

julia> @atomic mem[1] # fetch the first value of mem, with sequential consistency
4

julia> @atomic max(mem[1], 10) # change the first value of mem to the max value, with sequential consistency
4 => 10

julia> @atomic mem[1] max 5 # again change the first value of mem to the max value, with sequential consistency
10 => 10
Julia 1.7

アトミックフィールド機能を使用するには、Julia 1.7 以降が必要です。

Julia 1.12

アトミック参照機能を使用するには、Julia 1.12 以降が必要です。

source
Base.@atomicswap — Macro
@atomicswap a.b.x = new
@atomicswap :sequentially_consistent a.b.x = new
@atomicswap m[idx] = new
@atomicswap :sequentially_consistent m[idx] = new

newをa.b.xに格納します(参照の場合はm[idx])。また、以前の値であるa.b.x(参照の場合はm[idx]に格納されていた値)を返します。

この操作は、swapproperty!(a.b, :x, new)呼び出しに変換されます。参照の場合はswapindex_atomic!(mem, order, new, idx)呼び出しとなり、orderのデフォルト値は:sequentially_consistentです。

詳細については、マニュアルのPer-field atomicsセクションを参照してください。

Examples

julia> mutable struct Atomic{T}; @atomic x::T; end

julia> a = Atomic(1)
Atomic{Int64}(1)

julia> @atomicswap a.x = 2+2 # replace field x of a with 4, with sequential consistency
1

julia> @atomic a.x # fetch field x of a, with sequential consistency
4
julia> mem = AtomicMemory{Int}(undef, 2);

julia> @atomic mem[1] = 1;

julia> @atomicswap mem[1] = 4 # replace the first value of `mem` with 4, with sequential consistency
1

julia> @atomic mem[1] # fetch the first value of mem, with sequential consistency
4
Julia 1.7

Atomicフィールド機能には、Julia 1.7以降が必要です。

Julia 1.12

Atomic参照機能には、Julia 1.12以降が必要です。

source
Base.@atomicreplace — Macro
@atomicreplace a.b.x expected => desired
@atomicreplace :sequentially_consistent a.b.x expected => desired
@atomicreplace :sequentially_consistent :monotonic a.b.x expected => desired
@atomicreplace m[idx] expected => desired
@atomicreplace :sequentially_consistent m[idx] expected => desired
@atomicreplace :sequentially_consistent :monotonic m[idx] expected => desired

ペアで指定された条件付き置換をアトミックに実行し、値 (old, success::Bool) を返します。置換が完了したかどうかは success で示されます。

この操作は replaceproperty!(a.b, :x, expected, desired) に変換されます。参照の場合は replaceindex_atomic!(mem, success_order, fail_order, expected, desired, idx) の呼び出しに変換され、どちらの順序もデフォルトでは :sequentially_consistent です。

詳しくは、マニュアルの Per-field atomics セクションを参照してください。

Examples

julia> mutable struct Atomic{T}; @atomic x::T; end

julia> a = Atomic(1)
Atomic{Int64}(1)

julia> @atomicreplace a.x 1 => 2 # replace field x of a with 2 if it was 1, with sequential consistency
(old = 1, success = true)

julia> @atomic a.x # fetch field x of a, with sequential consistency
2

julia> @atomicreplace a.x 1 => 3 # replace field x of a with 2 if it was 1, with sequential consistency
(old = 2, success = false)

julia> xchg = 2 => 0; # replace field x of a with 0 if it was 2, with sequential consistency

julia> @atomicreplace a.x xchg
(old = 2, success = true)

julia> @atomic a.x # fetch field x of a, with sequential consistency
0
julia> mem = AtomicMemory{Int}(undef, 2);

julia> @atomic mem[1] = 1;

julia> @atomicreplace mem[1] 1 => 2 # replace the first value of mem with 2 if it was 1, with sequential consistency
(old = 1, success = true)

julia> @atomic mem[1] # fetch the first value of mem, with sequential consistency
2

julia> @atomicreplace mem[1] 1 => 3 # replace field x of a with 2 if it was 1, with sequential consistency
(old = 2, success = false)

julia> xchg = 2 => 0; # replace field x of a with 0 if it was 2, with sequential consistency

julia> @atomicreplace mem[1] xchg
(old = 2, success = true)

julia> @atomic mem[1] # fetch the first value of mem, with sequential consistency
0
Julia 1.7

Atomic フィールド機能を使用するには、Julia 1.7 以降が必要です。

Julia 1.12

Atomic 参照機能を使用するには、Julia 1.12 以降が必要です。

source
Base.@atomiconce — Macro
@atomiconce a.b.x = value
@atomiconce :sequentially_consistent a.b.x = value
@atomiconce :sequentially_consistent :monotonic a.b.x = value
@atomiconce m[idx] = value
@atomiconce :sequentially_consistent m[idx] = value
@atomiconce :sequentially_consistent :monotonic m[idx] = value

値がまだ設定されていない場合に、条件付き代入をアトミックに実行します。返される値 success::Bool は、代入が完了したかどうかを示します。

この操作は setpropertyonce!(a.b, :x, value) に変換されます。参照の場合は setindexonce_atomic!(m, success_order, fail_order, value, idx) の呼び出しに変換され、どちらも順序の既定値は :sequentially_consistent です。

詳細については、マニュアルの Per-field atomics セクションを参照してください。

Examples

julia> mutable struct AtomicOnce
           @atomic x
           AtomicOnce() = new()
       end

julia> a = AtomicOnce()
AtomicOnce(#undef)

julia> @atomiconce a.x = 1 # set field x of a to 1, if unset, with sequential consistency
true

julia> @atomic a.x # fetch field x of a, with sequential consistency
1

julia> @atomiconce :monotonic a.x = 2 # set field x of a to 1, if unset, with monotonic consistence
false
julia> mem = AtomicMemory{Vector{Int}}(undef, 1);

julia> isassigned(mem, 1)
false

julia> @atomiconce mem[1] = [1] # set the first value of mem to [1], if unset, with sequential consistency
true

julia> isassigned(mem, 1)
true

julia> @atomic mem[1] # fetch the first value of mem, with sequential consistency
1-element Vector{Int64}:
 1

julia> @atomiconce :monotonic mem[1] = [2] # set the first value of mem to [2], if unset, with monotonic
false

julia> @atomic mem[1]
1-element Vector{Int64}:
 1
Julia 1.11

アトミックフィールド機能には、Julia 1.11 以降が必要です。

Julia 1.12

アトミック参照機能には、Julia 1.12 以降が必要です。

source
Core.AtomicMemory — Type
AtomicMemory{T} == GenericMemory{:atomic, T, Core.CPU}

固定サイズのDenseVector{T}です。個々の要素の取得は、(デフォルトでは:monotonic順で)アトミックに行われます。

Warning

AtomicMemoryへのアクセスには、@atomicマクロ、または低レベルインターフェース関数であるBase.getindex_atomic、Base.setindex_atomic!、Base.setindexonce_atomic!、Base.swapindex_atomic!、Base.modifyindex_atomic!、Base.replaceindex_atomic!のいずれかを使用する必要があります。

詳しくは、Atomic Operations、および@atomic、@atomiconce、@atomicswap、@atomicreplaceの各マクロを参照してください。

Julia 1.11

この型を使用するには、Julia 1.11以降が必要です。

Julia 1.12

低レベルインターフェース関数または@atomicマクロを使用するには、Julia 1.12以降が必要です。

source

unsafe 関数群には、メモリ順序を指定するオプションのパラメーターもあります。このパラメーターを unsafe_load、unsafe_store!、unsafe_swap!、unsafe_replace!、unsafe_modify! に指定すると、これらのアトミック操作の C/C++ 互換バージョンが選択されます。

Warning

以下の API は非推奨ですが、今後数回のリリースにわたってサポートが継続される見込みです。

Base.Threads.Atomic — Type
Threads.Atomic{T}

T 型のオブジェクトへの参照を保持し、そのオブジェクトへのアクセスが常にアトミック(スレッドセーフ)になるようにします。

非アトミックな値から新しいアトミックオブジェクトを作成できます。値を指定しない場合、アトミックオブジェクトはゼロで初期化されます。

アトミックオブジェクトには、次の [] 記法でアクセスできます。

Examples

julia> x = Threads.Atomic{Int}(3)
Base.Threads.Atomic{Int64}(3)

julia> x[] = 1
1

julia> x[]
1

アトミック操作では、atomic_ という接頭辞を使用します。たとえば、atomic_add!、atomic_xchg! などです。

source
Base.Threads.atomic_cas! — Function
Threads.atomic_cas!(x::Atomic{T}, cmp::T, newval::T) where T

アトミックな比較交換 x

x の値を cmp とアトミックに比較します。一致した場合は、newval を x に書き込みます。一致しない場合、x は変更されません。古い値を x で返します。返された値を cmp と比較することで(=== を使用)、x が変更され、新しい値 newval を保持しているかどうかがわかります。

詳しくは、LLVM の cmpxchg 命令を参照してください。

この関数は、トランザクションのセマンティクスを実装するために使用できます。トランザクションの前に、x の値を記録します。トランザクションの後、新しい値は、途中で x が変更されていない場合にのみ保存されます。

Examples

julia> x = Threads.Atomic{Int}(3)
Base.Threads.Atomic{Int64}(3)

julia> Threads.atomic_cas!(x, 4, 2);

julia> x
Base.Threads.Atomic{Int64}(3)

julia> Threads.atomic_cas!(x, 3, 2);

julia> x
Base.Threads.Atomic{Int64}(2)
source
Base.Threads.atomic_xchg! — Function
Threads.atomic_xchg!(x::Atomic{T}, newval::T) where T

x の値をアトミックに交換します。

x の値を newval とアトミックに交換します。古い値を返します。

詳しくは、LLVM の atomicrmw xchg 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(3)
Base.Threads.Atomic{Int64}(3)

julia> Threads.atomic_xchg!(x, 2)
3

julia> x[]
2
source
Base.Threads.atomic_add! — Function
Threads.atomic_add!(x::Atomic{T}, val::T) where T <: ArithmeticTypes

val を x にアトミックに加算します。

x[] += val をアトミックに実行します。古い値を返します。Atomic{Bool} には定義されていません。

詳しくは、LLVM の atomicrmw add 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(3)
Base.Threads.Atomic{Int64}(3)

julia> Threads.atomic_add!(x, 2)
3

julia> x[]
5
source
Base.Threads.atomic_sub! — Function
Threads.atomic_sub!(x::Atomic{T}, val::T) where T <: ArithmeticTypes

val を x からアトミックに減算します。

x[] -= val をアトミックに実行します。古い値を返します。Atomic{Bool} では定義されていません。

詳しくは、LLVM の atomicrmw sub 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(3)
Base.Threads.Atomic{Int64}(3)

julia> Threads.atomic_sub!(x, 2)
3

julia> x[]
1
source
Base.Threads.atomic_and! — Function
Threads.atomic_and!(x::Atomic{T}, val::T) where T

x と val のビット単位の AND をアトミックに実行します。

x[] &= val をアトミックに実行します。古い値を返します。

詳しくは、LLVM の atomicrmw and 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(3)
Base.Threads.Atomic{Int64}(3)

julia> Threads.atomic_and!(x, 2)
3

julia> x[]
2
source
Base.Threads.atomic_nand! — Function
Threads.atomic_nand!(x::Atomic{T}, val::T) where T

x と val のビット単位の NAND(NOT-AND)をアトミックに実行します。

x[] = ~(x[] & val) をアトミックに実行します。古い値を返します。

詳しくは、LLVM の atomicrmw nand 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(3)
Base.Threads.Atomic{Int64}(3)

julia> Threads.atomic_nand!(x, 2)
3

julia> x[]
-3
source
Base.Threads.atomic_or! — Function
Threads.atomic_or!(x::Atomic{T}, val::T) where T

x と val のビット単位の OR をアトミックに実行します。

x[] |= val をアトミックに実行します。古い値を返します。

詳しくは、LLVM の atomicrmw or 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(5)
Base.Threads.Atomic{Int64}(5)

julia> Threads.atomic_or!(x, 7)
5

julia> x[]
7
source
Base.Threads.atomic_xor! — Function
Threads.atomic_xor!(x::Atomic{T}, val::T) where T

x と val のビット単位の排他的論理和(XOR)をアトミックに実行します。

x[] $= val をアトミックに実行します。古い値を返します。

詳しくは、LLVM の atomicrmw xor 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(5)
Base.Threads.Atomic{Int64}(5)

julia> Threads.atomic_xor!(x, 7)
5

julia> x[]
2
source
Base.Threads.atomic_max! — Function
Threads.atomic_max!(x::Atomic{T}, val::T) where T

x と val のうち大きい方を、x にアトミックに格納します。

x[] = max(x[], val) をアトミックに実行します。古い値を返します。

詳しくは、LLVM の atomicrmw max 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(5)
Base.Threads.Atomic{Int64}(5)

julia> Threads.atomic_max!(x, 7)
5

julia> x[]
7
source
Base.Threads.atomic_min! — Function
Threads.atomic_min!(x::Atomic{T}, val::T) where T

x と val の最小値を、x にアトミックに格納します。

x[] = min(x[], val) をアトミックに実行します。古い値を返します。

詳しくは、LLVM の atomicrmw min 命令を参照してください。

Examples

julia> x = Threads.Atomic{Int}(7)
Base.Threads.Atomic{Int64}(7)

julia> Threads.atomic_min!(x, 5)
7

julia> x[]
5
source
Base.Threads.atomic_fence — Function
Threads.atomic_fence()

逐次一貫性のメモリフェンスを挿入する

逐次一貫性の順序付けセマンティクスを持つメモリフェンスを挿入します。取得/解放の順序付けでは不十分で、この操作が必要となるアルゴリズムがあります。

この操作は非常にコストが高い可能性があります。Julia のほかのアトミック操作はすべて、すでに取得/解放のセマンティクスを持つため、ほとんどの場合、明示的なフェンスは不要です。

詳しくは、LLVM の fence 命令を参照してください。

source

ccall using a libuv threadpool (Experimental)

Base.@threadcall — Macro
@threadcall((cfunc, clib), rettype, (argtypes...), argvals...)

@threadcall マクロは、ccall と同じ方法で呼び出しますが、処理は別のスレッドで行われます。これにより、ブロッキングを伴う C 関数を呼び出しても、現在の julia スレッドがブロックされるのを防げます。同時実行数は libuv スレッドプールのサイズによって制限されます。デフォルトは 4 スレッドですが、UV_THREADPOOL_SIZE 環境変数を設定して julia プロセスを再起動すれば、増やすことができます。

呼び出される関数から Julia を呼び出してはならない点に注意してください。

source

Low-level synchronization primitives

これらの基本要素を使って、通常の同期オブジェクトを作成します。

Base.Threads.AbstractSpinLock — Type
abstract type AbstractSpinLock <: AbstractLock end

再入不可のテスト・アンド・テスト・アンド・セット方式のスピンロックです。再帰的に使用するとデッドロックが発生します。この種のロックは、実行時間が短く、ブロックしない(たとえば、I/O を行わない)コードの周囲でのみ使用してください。一般には、代わりに ReentrantLock を使用してください。

各 lock には、対応する unlock が必要です。!islocked(lck::AbstractSpinLock) が成り立つ場合、ほかのタスクが「同時に」ロックを取得しようとしていなければ、trylock(lck) は成功します。

テスト・アンド・テスト・アンド・セット方式のスピンロックが最も高速なのは、競合するスレッドが約 30 個までの場合です。それ以上の競合がある場合は、別の同期方式を検討してください。

Julia 1.13

この型を使用するには、Julia 1.13 以降が必要です。

source
Base.Threads.SpinLock — Type
SpinLock() <: AbstractSpinLock

スピンロックにはパディングがないため、偽共有が発生することがあります。PaddedSpinLockも参照してください。

正しい使い方については、AbstractSpinLockのドキュメントを参照してください。

source
Base.Threads.PaddedSpinLock — Type
PaddedSpinLock() <: AbstractSpinLock

PaddedSpinLocksは、偽共有を避けるため、それぞれが必ず独立したキャッシュラインに配置されるようパディングされています。SpinLockも参照してください。

正しい使い方については、AbstractSpinLockのドキュメントを参照してください。

Julia 1.13

この型を使用するには、Julia 1.13以降が必要です。

source

Task metrics (Experimental)

Base.Experimental.task_metrics — Function
Base.Experimental.task_metrics(::Bool)

タスクごとのメトリクス収集を有効または無効にします。Task は、Base.Experimental.task_metrics(true) が有効な状態で作成されると、Base.Experimental.task_running_time_ns と Base.Experimental.task_wall_time_ns のタイミング情報を利用できます。

Note

タスクメトリクスは、起動時に --task-metrics=yes コマンドラインオプションで有効にできます。

source
Base.Experimental.task_running_time_ns — Function
Base.Experimental.task_running_time_ns(t::Task)::Union{UInt64, Nothing}

タスク t の実行時間の合計をナノ秒単位で返します。このメトリクスは、t が yield するか完了したときにのみ更新されます。ただし、現在のタスクが t の場合は、継続的に更新されます。Base.Experimental.task_wall_time_ns も参照してください。

タスクの実行時間計測が有効でない場合は、nothing を返します。Base.Experimental.task_metrics も参照してください。

このメトリクスは Julia スケジューラによるものです

OS スケジューラによって OS スレッドの実行が中断されている間も、その時間はこのメトリクスに含まれます。

Julia 1.12

このメソッドは Julia 1.12 で追加されました。

source
Base.Experimental.task_wall_time_ns — Function
Base.Experimental.task_wall_time_ns(t::Task)::Union{UInt64, Nothing}

タスク t が実行可能だった合計時間をナノ秒単位で返します。これは、タスクが初めて実行キューに入ってから完了するまでの時間です。タスクがまだ完了していない場合は、現在までの時間を返します。Base.Experimental.task_running_time_ns も参照してください。

タスクのタイミング計測が有効になっていない場合は、nothing を返します。Base.Experimental.task_metrics を参照してください。

Julia 1.12

このメソッドは Julia 1.12 で追加されました。

source