HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

超高速アウトオブコアシャッフリング

Accelerated Out of Core Shuffling (quasiben.github.io)

11 pointsby quasiben0 コメント

要約

この記事は、RapidsMPFライブラリを用いた、1.8 TiB/sという驚異的な速度でのアウトオブコア(メモリ外)シャッフリングについて解説しています。シャッフリングはデータ分析における結合、集計、ソートなどの基幹操作に不可欠ですが、メモリ使用量やデータ転送のオーバーヘッドが課題でした。RapidsMPFは、この課題を解決し、GPUメモリを超える大規模データセットでも効率的なシャッフリングを実現します。

全文翻訳

RapidsMPFによる高速なアウトオブコアシャッフリング

1.8 TiB/sでのデータシャッフリング! RapidsMPFは、シャッフリングのOOM(メモリ不足)の悩みを予算内で対応可能なスプリット(一時退避)に転換する、再利用可能なアウトオブコアシャッフラーです。

シャッフリングは、分散型であれそうでなかれ、構造化データ分析の核心です。join、groupby、merge、sortなどの主要なデータ操作のコアコンポーネントです。完全な分散シャッフルは、すべてのプロセスから他のすべてのプロセスへ、つまりオール・トゥ・オールで全データを移動させる可能性があります。これは非常にコストが高いため、この操作を可能な限り回避するための多くの洗練された技術が開発されてきました。シャッフリングは計算的に特に困難ではありません。データをルーティングするためのハッシュを計算するのは比較的容易です。それにもかかわらず、様々な理由でワークフローにおいては高コストになります。

  1. メモリ集約型: シャッフリングは全データの完全なコピーを保持する必要がある場合があり、ストリーミングケースではメモリ圧力が蓄積しOOMを引き起こす可能性があります。
  2. 転送: データは物理的にプロセスAからプロセスB、またはノードAからノードBへ移動する必要があるため、転送レイヤーの速度でしか移動できません。
  3. 同期: 出力データは、すべてのプロデューサーがデータの提供を完了するまで消費できません。バルク同期エンジンでは、このバリアが実行プラン全体を停止させる可能性があります。

シャッフリングは困難で、遅く、メモリ集約型で、かつクリティカルであるため、歴史的にRapidsMPFが始まった場所です。

なぜJoinはシャッフルを必要とするのか?

テーブルの結合に関する簡単な解説です。2つのテーブル partsupp と lineitem があり、それらを結合したい場合、何が起こるでしょうか?

partsupp.join(
   lineitem,
   left_on=["ps_partkey", "ps_suppkey"],
   right_on=["l_partkey", "l_suppkey"],
)

# または

SELECT *
FROM partsupp
JOIN lineitem
  ON partsupp.ps_partkey = lineitem.l_partkey
 AND partsupp.ps_suppkey = lineitem.l_suppkey
インメモリ結合

内部結合は2つのフェーズで構成されます。

  1. ビルドフェーズ: より小さいテーブル(partsupp)をスキャンし、結合キー (ps_partkey, ps_suppkey) 上にハッシュテーブルを構築し、各ハッシュキーをそれが由来する行にマッピングします。このハッシュテーブルは、プローブフェーズが開始される前に完全にポピュレートされます。
  2. プローブフェーズ: より大きいテーブル(lineitem)をスキャンし、各行のキー (l_partkey, l_suppkey) をハッシュします。ビルドテーブルとプローブテーブルの結合キーのハッシュとの一致が出力行を生成し、両方のテーブルの列を結合します。一致しない行はドロップされます(技術的には、ここにはハッシュ衝突の処理も含まれますが、今は無視します)。

注意: 左結合、右結合、完全外部結合は、一致しない行に対する異なるルールで同じビルド/プローブ戦略を使用します

最小限、このインメモリ結合は3つのテーブルを保持します。ビルドテーブル、プローブテーブル、出力テーブル、そしてビルドサイド上に構築されたハッシュテーブルです。

分散結合

インメモリの場合、すべてのデータはすでに同じメモリ空間内にコロケートされています。テーブルが多くのプロセス/ノード/ランクに分散されている場合や、テーブルが「ストリーミング」結合のためにバッチ処理されている場合、これはもはや当てはまりません。ランク/プロセスは、レジデントメモリ内の行のみを結合できます。最終的にはインメモリ結合が発生しますが、まず、ビルドテーブルとプローブテーブルの両方の対応するキーを同じランクに取得する必要があります。

以下の図は、同じ色の様々な行がどのように同じ出力パーティションにシャッフルされ、それらのパーティションが異なるランクに配置されるかを示しています。

[画像: rapidsmpf shuffle]

分散ハッシュ結合を実行するには、以下を行う必要があります。

  1. ビルドテーブルをスキャンし、各行の結合キーをハッシュして宛先パーティションを選択します hash(keys) % n_out_partitions。各行をそれが所有するランクにパックして送信します。
  2. プローブテーブルをスキャンし、同様の方法で行をルーティングして、プローブキーが同じハッシュを持つビルドキーをすでに保持しているランクに着地するようにします。
  3. すべてのランクが送信を完了するまで待ちます。その時点で初めて、ランクはそれが所有するキーについて、両方のテーブルからのすべての行を保持していることが保証されます。
  4. 各ランクのローカルスライスで上記のインメモリ結合を実行します。そのビルド行上にハッシュテーブルを構築し、プローブ行でそれをプローブし、一致を出力します。

最悪の場合、各ステージが次のステージの前に完全にマテリアライズされると、単一のランクは同時に以下のすべてを保持しています。

  1. ビルドテーブル(ソーススキャン)
  2. プローブテーブル(ソーススキャン)
  3. ステージングされたビルドテーブル(送信用にパック)
  4. ステージングされたプローブテーブル(送信用にパック)
  5. シャッフルされたビルドスライス(受信)
  6. シャッフルされたプローブスライス(受信)
  7. ビルドスライス上のハッシュテーブル
  8. 出力テーブル

これが、シャッフリングが計算集約型ではなくメモリ集約型である理由です。ハッシュ自体は容易であり、ETLエンジンを構築する際にアウトオブコアシャッフルの実装を最優先事項とすべき理由です。さらに、テーブルをシャッフリング前に完全にマテリアライズするのではなく、データをストリーミングできることは、メモリ圧力を削減するために不可欠です。これらの理由から、ストリーミングアウトオブコアシャッフラーを構築するという当初の目標でRapidsMPFを開始しました。

RapidsMPF

RapidsMPFは、その当初の構想から拡大しました。現在、それは2つの大きな部分からなるライブラリです。

  1. スプリット/アウトオブコアメモリハンドリングのために設計されたシャッフルライブラリ、アクセラレーテッド転送付き。
  2. ストリーミングデータパイプラインを構築するためのアクターネットワーク。

ユーザーは現在でもRapidsMPFのシャッフリングコンポーネントのみ(C++またはPythonインターフェース)を採用できます。これはNeMo-Curatorや、実験的にRay Dataで見られます。最も重要なのは、cuDF Polarsがシャッフルとアクターネットワークの両方にRapidsMPFを使用していることです。

フォローアップ投稿でアクターネットワークについて詳しく説明できます。もし今興味があるなら、ストリーミングエンジンのセクションを読むことをお勧めします。

私たちのシャッフル実装は以下を行う必要があります。

  1. 高速であること
  2. スケーラブルであること
  3. VRAM(GPUメモリ)を超えるデータで動作すること(アウトオブコア)
  4. 再利用可能であること

そして、このブログの残りの部分では、メモリ圧力下でのシャッフリングに焦点を当てます。

ベンチマーク設定

cuDF/RapidsMPFには、使いやすいC++ベンチマークbench_shuffleがあり、様々なハードウェア(転送、GPU数など)や様々な設定(入力/出力パーティションサイズ、メモリリソースなど)でRapidsMPFのシャッフリング実装がどのように機能するかを研究するのに役立ちます。

現在のbench_shuffleテストがユーザーに公開している機能の完全な内訳と、この記事全体で使用する値は以下の通りです。一般的に、このベンチマークは、ランクごとに調整可能な量のランダムな32ビット(4バイト)整数を構築し、すべてのデータをシャッフルして完了します(ここでは結合はなく、シャッフルのみです)。

フラグ意味ここで使用する値
-C <name>コミュニケータucxx
-c <n>カラム数10
-r <n>テスト実行回数10
-w <n>ウォームアップ実行回数3
-n <n>ランクあたりの行数536870912(4バイト/行でカラムあたり2 GiB)
-p <n>ランクあたりの入力パーティション数1
-o <n>ランクあたりの出力パーティション数8(ランクごとに1つ)
-m <name>RMMメモリリソースpool
-l <n>デバイスメモリ制限(MiB)省略=無制限(バイナリデフォルト-1); スプリットスイープでは32768から12288
-s出力破棄を有効にする(ストリーミングをシミュレート)フラグ、常に設定
-xメモリプロファイリングを有効にするフラグ、常に設定
-g事前パーティション化された入力テーブルを使用するフラグ、常に設定

すべてのテストで、単一のDGXB200を使用し、シャッフルを起動するためにプロセスをNUMAノードにバインドできるMPIライクなマルチプロセス起動ツールであるrrunを使用します。

シンプルなシャッフリング

DGXB200は8基のBlackwell GPUを搭載し、それぞれ180GBのVRAMと2基のIntel® Xeon® Platinum 8570プロセッサを備えています。ベースラインを取得するために、まずGPU全体に余裕で収まるデータをシャッフルすることから始めます。

rrun -n 8 --bind-to cpu --bind-to memory -x UCX_MAX_RNDV_RAILS=1 -x UCX_PROTO_ENABLE=y -x UCX_WARN_UNUSED_ENV_VARS=n libcudf_streaming_bench_shuffle -C ucxx -w 3 -r 10 -m pool -g -s -x -p 1 -o 8 -c 10 -n 536870912

ここではベンチマークを3回ウォームアップし、その後10回実行します。536,870,912行(-n)、10カラム(-c)、ランクあたり1つの入力パーティション(-p)、そしてデータは8つの出力パーティション(-o)にシャッフルされます。また、アクセラレーテッド転送/GPUDirect RDMAを有効にするためにUCXX/UCXを使用しています。

536,870,912行 * 4バイト(32ビット整数)= カラムあたり2 GiB
10カラム * 2 GiB = ランクあたり20 GiB
8ランク * 20 GiB = 合計160 GiB

# ランクあたり20GiBの例出力
[6:PRINT:0:2026-09-16 02:09:53.934930934] elapsed: 17.91 s | local throughput: 1.12 GiB/s | global throughput: 8.93 GiB/s (warmup run)
[5:PRINT:0:2026-09-16 02:09:53.935046244] elapsed: 17.91 s | local throughput: 1.12 GiB/s | global throughput: 8.93 GiB/s (warmup run)
[4:PRINT:0:2026-09-16 02:09:54.072443638] elapsed: 94.58 ms | local throughput: 211.47 GiB/s | global throughput: 1.65 TiB/s (warmup run)
[2:PRINT:0:2026-09-16 02:09:54.072450366] elapsed: 89.15 ms | local throughput: 224.35 GiB/s | global throughput: 1.75 TiB/s (warmup run)
[0:PRINT:0:2026-09-16 02:09:54.328272061] elapsed: 86.89 ms | local throughput: 230.19 GiB/s | global throughput: 1.80 TiB/s
[1:PRINT:0:2026-09-16 02:09:54.328286361] elapsed: 85.38 ms | local throughput: 234.25 GiB/s | global throughput: 1.83 TiB/s
[7:PRINT:0:2026-09-16 02:09:54.328417037] elapsed: 84.58 ms | local throughput: 236.47 GiB/s | global throughput: 1.85 TiB/s
[4:PRINT:0:2026-09-16 02:09:54.328429082] elapsed: 85.15 ms | local throughput: 234.87 GiB/s | global throughput: 1.83 TiB/s
[2:PRINT:0:2026-09-16 02:09:54.328554677] elapsed: 86.28 ms | local throughput: 231.80 GiB/s | global throughput: 1.81 TiB/s

各ランクは、シャッフルに費やした時間、ローカルスループット、グローバルトループットを投稿します。すでに、ウォームアップにはコストがかかり、公式の実行よりも遅いことがわかります。最後に、プログラムはランクごとのローカル/グローバルトループットの平均値と、シャッフリング時間、メモリ割り当て時間、スプリット(該当する場合)など、時間が費やされたランクごとのサマリー統計を返します。

注記

グローバルトループットはランクごとに異なる場合がありますが、これは技術的には誤りであり、報告バグです。ベンチマークは、ランク間のローカルスループットを合計するのではなく、各ランクのローカルスループットにランク数を掛けたものをグローバルトループットとして報告します。DGXB200では、ローカルトループットの8倍になります。しかし、バグが修正されるまではこれで十分でしょう。

[0:PRINT:0:2026-09-16 02:09:55.476576210] means: 87.06 ms | local throughput: 229.74 GiB/s | global throughput: 1.79 TiB/s | in_parts: 1 | out_parts: 8 | nranks: 8 | device memory peak: 60 GiB | device memory total

[0:PRINT:0:2026-09-16 02:09:55.476629379] Statistics (of the last run):
 - alloc-device:                                       17.50 GiB | 1.73 ms | 9.90 TiB/s | avg-stream-delay 213.98 us
 - event-loop-total:                                   3.44 ms | avg 2.29 us
 - metadata-payload-exchange-complete-data-transfers:  518.71 us | avg 345.80 ns
 - metadata-payload-exchange-progress:                 2.35 ms | avg 1.57 us
 - metadata-payload-exchange-receive-metadata:         558.98 us | avg 372.65 ns
 - metadata-payload-exchange-send-messages:            557.40 us
 - metadata-payload-exchange-setup-data-receives:      617.31 us | avg 411.54 ns
 - shuffle-payload-recv:                               17.50 GiB | avg 319.95 MiB
 - shuffle-payload-send:                               17.50 GiB | avg 320.01 MiB

Memory Profiling
----------------
Legends:
  ncalls - スコープが実行された回数。
  peak   - スコープによるピークメモリ使用量。
  g-peak - スコープ実行中のグローバルピークメモリ使用量。
  accum  - スコープによる合計累積メモリ割り当て。
  max    - スコープによる最大の単一割り当て。

Ordered by: peak (descending)

  ncalls        peak      g-peak       accum         max  filename:lineno(name)
       1      60 GiB      60 GiB    1.29 TiB       2 GiB  main (all allocations using RmmResourceAdaptor)
       1      40 GiB      40 GiB   44.06 GiB       2 GiB  /libcudf_streaming/src/partition_utils.cpp:183(partition_and_pack)
       1      20 GiB      20 GiB      20 GiB  320.39 MiB  /libcudf_streaming/src/partition_utils.cpp:242(split_and_pack)
       8    2.50 GiB    2.50 GiB      20 GiB  256.12 MiB  /libcudf_streaming/src/partition_utils.cpp:298(unpack_and_concat)
       1         0 B         0 B         0 B         0 B  /libcudf_streaming/benchmarks/bench_shuffle.cpp:277(shuffling)
       4       5 GiB       5 GiB      20 GiB  512.17 MiB  /libcudf_streaming/src/partition_utils.cpp:136(unpack_and_concat)
       1         0 B         0 B         0 B         0 B  /libcudf_streaming/benchmarks/bench_shuffle.cpp:276(shuffling)

上記の例はランク0のみですが、ランク1〜7も非常に似ています。ランクはわずかに異なる時間に終了し、スループットにもわずかながら測定可能な変動があります。8つのGPU全体で1,440 GBのVRAMがあるため、RapidsMPFはスプリットを必要とせずにシャッフルするのに十分な余裕があります。上記の構成では、RapidsMPFは約1.8 TiB/sのグローバルトループットを処理します。理論上の上限である14.4 TB/sにはまだ達していませんが、非常に高速です!

メモリプロファイルは、後でスプリットについて議論するのに役立つため、詳しく見る価値があります。各ランクは20 GiBの入力しか保持していませんが、ピークデバイス使用量は60 GiB、つまり入力の3倍です。プロファイルはそれがどこに行くかを正確に示しています。入力自体に20 GiB、入力がハッシュされて宛先ごとのバッファにコピーされる間にpartition_and_packに40 GiBです。シャッフルの場合、プログラムは一時的にローカルデータの元のコピーとコピーの両方を所有する可能性があります。これは、パイプラインのすべてのステージでメモリ管理について深く考える必要がある理由の良い動機となります。

シャッフルがワークフローの必須部分である場合、データは様々なパーティションサイズ、形状、タイプで提供され、GPUはVRAMの量によって異なります。したがって、データとワークフロー全体の形状とサイズが変わると、スループットも変わると予想すべきです。今のところ、単一の20 GiB入力パーティションの同じ設定を使用し続けます。

おっと、少しスプリットしてしまった...

各ランクは20 GiBのデータで初期化され、その後シャッフルされます。しかし、デバイス制限を無制限から12 GiBに下げることで、メモリ圧力を継続的に増加させます。観測されるのは、OOM(メモリ不足)にならないだけでなく、RapidsMPFは不要なデータのやり取りでスレッシングしないことです。注意、この特定のシステムをOOMのリスクにさらしているわけではありません。代わりに、システムがOOMのリスクにある場合に何が起こるかを迅速にシミュレートし、調査するために、設定を20 GiBのデータ/ランクに制限しています。

ベンチマークに人工的なメモリ圧力をかけ、デバイスを32GBに制限してみましょう: -l 32768 そして何が起こるか見てみましょう。

[7:PRINT:0:2026-09-16 02:10:59.613588706] means: 335.15 ms | local throughput: 59.67 GiB/s | global throughput: 477.39 GiB/s | in_parts: 1 | out_parts: 8 | nranks: 8 | device memory peak: 60 GiB | device memory total: 101.56 GiB (avg)

[7:PRINT:0:2026-09-16 02:10:59.613648285] Statistics (of the last run):
 - alloc-device:                                       17.50 GiB | 8.11 ms | 2.11 TiB/s | avg-stream-delay 598.60 us
 - alloc-pinned_host:                                  5.62 GiB | 844 us | 6.51 TiB/s | avg-stream-delay 170.46 us
 - copy-pinned_host-to-device:                         5.62 GiB | 171.80 ms | 32.74 GiB/s | avg-stream-delay 1.78 ms
 - event-loop-total:                                   11.88 ms | avg 1.99 us
 - metadata-payload-exchange-complete-data-transfers:  1.09 ms | avg 183.69 ns
 - metadata-payload-exchange-progress:                 9.76 ms | avg 1.64 us
 - metadata-payload-exchange-receive-metadata:         1.24 ms | avg 207.56 ns
 - metadata-payload-exchange-send-messages:            608.21 us
 - metadata-payload-exchange-setup-data-receives:      5 ms | avg 839.19 ns
 - shuffle-payload-recv:                               17.50 GiB | avg 319.95 MiB
 - shuffle-payload-send:                               17.50 GiB | avg 320.01 MiB

Memory Profiling
----------------
Legends:
  ncalls - スコープが実行された回数。
  peak   - スコープによるピークメモリ使用量。
  g-peak - スコープ実行中のグローバルピークメモリ使用量。
  accum  - スコープによる合計累積メモリ割り当て。
  max    - スコープによる最大の単一割り当て。

Ordered by: peak (descending)

  ncalls        peak      g-peak       accum         max  filename:lineno(name)
       1      60 GiB      60 GiB    1.29 TiB       2 GiB  main (all allocations using RmmResourceAdaptor)
       1      40 GiB      40 GiB   44.06 GiB       2 GiB  /libcudf_streaming/src/partition_utils.cpp:183(partition_and_pack)
       1      20 GiB      20 GiB      20 GiB  320.39 MiB  /libcudf_streaming/src/partition_utils.cpp:242(split_and_pack)
       8    2.50 GiB    2.50 GiB      20 GiB  256.11 MiB  /libcudf_streaming/src/partition_utils.cpp:298(unpack_and_concat)
       1         0 B         0 B         0 B         0 B  /libcudf_streaming/benchmarks/bench_shuffle.cpp:277(shuffling)

興味深い!グローバルトループットは大幅に低下し、~480 GiB/sとなり、統計に2つの新しい行が表示されます: alloc-pinned_hostとcopy-pinned_host-to-device -- しかし、copy-device-to-pinned_hostという行は表示されません。その不在が興味深い点です。私たちは同じ量のデータをシャッフルしています。各ランクは20 GiBのデータを持ち、他の7ランクから17.5 GiBを受け取ります。32 GBの制限では、各ランクはすでに制限を超えています。しかし!RapidsMPFがデータを移動する際、受信側はメモリ圧力を検知し、設定されたデバイス制限を認識できます。デバイスとホスト間で何度もデータを移動してスレッシングする代わりに、受信側はスレッシングを回避するためにデバイスではなくホストでバッファを受け入れることができます -- UCXXのおかげです!

言い換えれば、デバイスから何も追い出されませんでした。データはそもそもそこに到達しませんでした。スプリットが発生しないスプリットが最も安価なスプリットです。

[画像: rapidsmpf shuffle pipeline]

なぜこれほど大きなパフォーマンス低下が発生するのか? 報告された335.15 msのうち、RapidsMPFは171.8 msをデータデバイスへの移動に費やしています。

  • copy-pinned_host-to-device: 5.62 GiB | 171.80 ms | 32.74 GiB/s | avg-stream-delay 1.78 ms

DGXB200はPCIe Gen 5を搭載しており、16レーン全体で64 GB/sの転送速度があります。RapidsMPFは、このバスをGPUあたり平均32 GiB/sの速度でデータを移動しています。これらのシャッフルはピン留めされたメモリを使用していますが、それでもスプリットのボトルネックとなっています。x86チップを交換し、C2Cを備えたGrace-Blackwell構成を使用すれば、ホストとデバイス間の帯域幅を簡単に5倍から10倍にできます。C2Cは最大900 GB/sで転送できます。

以下は、同じ初期設定をスイープし、デバイスメモリ制限を段階的に下げ、それに応じてメモリ圧力が増加してより多くのスプリットが発生する表です。

スケールされたスプリット DGXB200
ラベルスプリット制限ピークデバイスローカルパフォーマンスグローバルトループットD2H(ピン留め)量 / 時間 / レートH2D(ピン留め)量 / 時間 / レート
no-spill∞ GiB60.0 GiB229.7 GiB/s1.79 TiB/s00
onset-spill32 GiB60.0 GiB60.0 GiB/s480.2 GiB/s05.6 GiB / 191.4 ms / 29.4 GiB/s
light-spill28 GiB60.0 GiB35.9 GiB/s287.0 GiB/s09.7 GiB / 379.0 ms / 25.6 GiB/s
moderate-spill24 GiB60.0 GiB26.5 GiB/s211.7 GiB/s013.8 GiB / 491.0 ms / 28.0 GiB/s
heavy-spill20 GiB60.0 GiB14.8 GiB/s118.6 GiB/s0.3 GiB / 9.6 ms / 32.6 GiB/s17.5 GiB / 622.3 ms / 28.1 GiB/s
very-heavy-spill16 GiB60.0 GiB10.1 GiB/s80.5 GiB/s4.1 GiB / 128.7 ms / 31.6 GiB/s18.1 GiB / 1340.0 ms / 13.5 GiB/s
extreme-spill12 GiB60.0 GiB6.9 GiB/s55.5 GiB/s8.1 GiB / 264.5 ms / 30.7 GiB/s18.8 GiB / 1170.0 ms / 16.1 GiB/s

表の読み方に関する注記: スループット列はランク0のもので、スプリット量と時間は8つのランクのうち最悪のランクのものです。なぜなら、実際に待たされるのはそれだからです。生のログと実行スクリプトは、scaled-spilling-b200にあります。さらに詳しく調べたい場合は、そちらを参照してください。

表を下に読み進めると、いくつかの点が際立ちます。

  1. 低下は滑らかで単調です。 デバイスメモリ制限を下げるにつれて、ホストとデバイス間でのデータ転送にPCIe Gen 5速度でより多くの時間を費やすようになりますが、重要なのはOOMにならないことです。
  2. 受信側メカニズムは無駄なスレッシングを回避できます。 copy-device-to-pinned_host は最初の4つのスプリットレベルでは0であり、RapidsMPFは何も追い出さず、課したデバイスメモリ制限を緩和するためにホストで受信バッファを受け入れます。入力サイズと制限が等しくなる20 GiBの制限になって初めて、実際のデバイスからホストへのスプリットが発生します。
  3. スプリットが高コストです。 copy-pinned_host-to-device は5.6 GiBから18.8 GiBに増加し、転送時間は191 msから1170 msに増加します。ただし、ホストとデバイス間の転送速度は、ピン留めされたメモリバッファ(前述)によって緩和されます。ハードウェアを変更して900 GB/sの帯域幅を持つC2Cを使用すれば、はるかに良くなるでしょう。

まとめ

シャッフリング(およびそれに伴う結合、ソートなど)がどれほど困難でメモリ集約的であるかを十分に実証したと思います。制約がない場合、RapidsMPFはDGX B200で約1.8 TiB/sのグローバルトループットを処理します。おそらくより重要なのは、RapidsMPFが、アクセラレーテッド転送を活用しながら、無駄なスレッシングやOOMなしでシャッフルを成功させることができることです。さらに、ホストとデバイス間の転送のチョークポイントを緩和するためのハードウェアソリューションがすでに導入されています。

シャッフルの課題を思い出してください: メモリ集約型、転送、同期。RapidsMPFはこれらの問題を軽減します。

  1. メモリ集約型: RapidsMPFは、調整可能な制限でデバイスからバッファをスプリット/追い出すことができ、さらに、不要なスレッシングを防ぐためにホストでバイトを受け入れることができます。
  2. 転送: RapidsMPFはUCXXを利用しており、NVLink、InfiniBand、EFA、TCPなどを介した転送を可能にします。
  3. 同期: RapidsMPFは、シャッフルを他の準備完了した作業とオーバーラップさせる非同期/ストリーミング実行モデルでこの課題に対処します。フォローアップ投稿でこれらの詳細について説明します。

私たちは、高速でスケーラブルで、VRAMを超えるデータを処理できるシャッフルを求めて出発し、RapidsMPFでそれを実現しました。ユーザーはこのライブラリを直接再利用するか、独自のプロジェクトにこれらのアイデアを実装できます。

後続の投稿では、NVL72でのスケーリングの研究に戻ります。弱および強のプロットにご期待ください!