CUDAカーネルを実行するとどうなるか?
What happens when you run a CUDA kernel? (fergusfinn.com)
要約
この記事では、シンプルなベクトル加算CUDAプログラムを例に、CUDAカーネルが実行される際の低レベルなプロセスを詳細に解説しています。コンパイル段階におけるPTX(仮想ISA)からSASS(デバイス固有のアセンブリ)への変換、そして実行時にCPUとGPU間でどのようにインタラクションが発生し、最終的に結果が返されるかについて、コード例と出力ファイル構造を交えながら深く掘り下げています。特に、仮想レジスタから物理レジスタへのマッピングや、カーネル引数が定数メモリに配置される理由などが具体的に説明されています。
全文翻訳
CUDAカーネルを実行すると何が起こるか
これは、2つのベクトルを加算する簡単なCUDAプログラムです。
__global__ void vadd(const float* a, const float* b, float* c, int n) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < n) c[i] = a[i] + b[i];
}
int main() {
int n = 1 << 20; // 100万個のfloat (1,048,576)
size_t bytes = n * sizeof(float);
float *a = (float*)malloc(bytes), *b = (float*)malloc(bytes),
*c = (float*)malloc(bytes);
for (int i = 0; i < n; i++) a[i] = b[i] = 1.0f;
float *da, *db, *dc;
cudaMalloc(&da, bytes);
cudaMalloc(&db, bytes);
cudaMalloc(&dc, bytes);
cudaMemcpy(da, a, bytes, cudaMemcpyHostToDevice);
cudaMemcpy(db, b, bytes, cudaMemcpyHostToDevice);
vadd<<<4096, 256>>>(da, db, dc, n); // 4096 * 256 = n スレッド、floatごとに1つ
cudaMemcpy(c, dc, bytes, cudaMemcpyDeviceToHost);
printf("c[0]=%f c[n-1]=%f\n", c[0], c[n-1]);
}
RTX 4090向けにコンパイルして実行すると、1+1=2が100万回正しく計算されます(すべてをチェックしたわけではありません)。
$ nvcc -arch=sm_89 -o vadd vadd.cu && ./vadd
c[0]=2.000000 c[n-1]=2.000000
これには、数千万のCPU命令、数個のデバイスファイル、900回のioctl、そして1つのメモリマップされたドアベルレジスタが関わっています。この記事では、この1つのカーネルをコードからワープ、そして答えまでを追っていきます。なお、この記事はエージェントがもたらした「可読性遷移」の一例です。好奇心と(機械で強化された)粘り強さがあれば、コンピュータについてほとんど何でも調べることができます。AIが私たちが知ることをどのように助けるかについての可読性の意味合いに関する興味深い議論はこちらにあります。
nvcc でプログラムをコンパイルする§
このCUDAプログラムを、デバイスが実際に読み取れるものに変換する方法から始めるべきです。そのためにはコンパイラが必要です。実際には、多くのコンパイラが必要です。
nvcc は、複数のコンパイラを実行してそれらの出力を結合するドライバプログラムです。--keep を渡すと、パイプライン全体をディスクに残してくれるので確認できます。
$ nvcc --keep -arch=sm_89 -o vadd vadd.cu && ls
...
vadd.ptx # PTX形式のデバイスコード (ciccから)
vadd.sm_89.cubin # SASS形式のデバイスコード (ptxasから)
vadd.fatbin # cubin + PTX、バンドル (fatbinaryから)
vadd.cudafe1.stub.c # ホスト起動スタブ + カーネル登録
vadd.o # fatbinが埋め込まれた最終的なホストオブジェクト
...
ホストコードはホストコンパイラに渡されます。デバイスコード(vadd)はさらに多くのステップを踏みます:LLVMベースのコンパイラであるciccがそれをPTXに変換し、次にptxasがPTXをSASSに変換します。
PTXは仮想ISAです。無限に多くの型付きレジスタを持ち、ハードウェアが実際にいくつ持っているかという概念はありません。以下はPTX形式のvaddの(省略された)本体です。
$ cat vadd.ptx
...
mad.lo.s32 %r1, %r3, %r4, %r5; // ctaid*ntid + tid をレジスタr1に設定
setp.ge.s32 %p1, %r1, %r2; // i >= n なら述語p1を設定
@%p1 bra $L__BB0_2; // 範囲外なら終了へスキップ
cvta.to.global.u64 %rd4, %rd1; // ジェネリックポインタ%rd1をグローバルアドレスに変換し、%rd4に格納
mul.wide.s32 %rd5, %r1, 4; // r1を4倍し、結果を%rd5に格納
add.s64 %rd6, %rd4, %rd5; // %rd4と%rd5を加算、結果は%rd6
ld.global.f32 %f2, [%rd6]; // a[i]を%f2にロード
...
add.f32 %f3, %f2, %f1; // %f1と%f2を加算、結果は%f3
st.global.f32 [%rd10], %f3; // c[i] = ... をグローバルメモリにストア
仮想レジスタは %rd1–%rd10、%f1–%f3 のように見えます。プレフィックスは型です:%r は32ビット整数、%rd は64ビット整数、%f は32ビット浮動小数点数、%p は1ビットの述語です。
PTXは予想よりも「冗長」です。例えば、%rd6 で1つのアドレスを形成するには3つのPTX命令が必要です。これはPTXがデバイスに依存しないためです。
なぜ3つなのか?
CUDAポインタはデフォルトで「ジェネリック」であり、グローバル、共有、またはローカルメモリを指す可能性があります。cvta.to.global はポインタがグローバルウィンドウ内にあることをアサートするため、より安価な ld.global を後で使用できます。次に mul.wide.s32 はインデックス i を4(sizeof(float))倍して64ビットに拡張することでバイトオフセットに変換します。add.s64 はそれをベースポインタに加算します。
次に、ptxas はデバイスに依存しないPTXを、あなたのアーキテクチャ用のSASSに変換します。SASSは異なって見えます。
$ cuobjdump -sass vadd
/*0000*/ MOV R1, c[0x0][0x28] ; // スタックポインタを設定 (ABI; ここでは未使用)
/*0010*/ S2R R6, SR_CTAID.X ; // R6 = blockIdx.x
/*0020*/ S2R R3, SR_TID.X ; // R3 = threadIdx.x
/*0030*/ IMAD R6, R6, c[0x0][0x0], R3 ; // i = ctaid*ntid + tid
/*0040*/ ISETP.GE.AND P0, PT, R6, c[0x0][0x178], PT ;// i >= n なら P0 を設定
/*0050*/ @P0 EXIT ; // その場合、終了
/*0060*/ MOV R7, 0x4 ; // リテラル4 (sizeof(float)) をR7にロード (乗数)
/*0070*/ ULDC.64 UR4, c[0x0][0x118] ; // ドライバ提供のシステム値のユニフォームロード
/*0080*/ IMAD.WIDE R4, R6, R7, c[0x0][0x168] ; // &b[i]
/*0090*/ IMAD.WIDE R2, R6, R7, c[0x0][0x160] ; // &a[i]
/*00a0*/ LDG.E R4, [R4.64] ; // b[i] をロード
/*00b0*/ LDG.E R3, [R2.64] ; // a[i] をロード
/*00c0*/ IMAD.WIDE R6, R6, R7, c[0x0][0x170] ; // &c[i]
/*00d0*/ FADD R9, R4, R3 ; // a[i] + b[i]
/*00e0*/ STG.E [R6.64], R9 ; // c[i] = ... をストア
/*00f0*/ EXIT ;
S2R行の動作
S2Rは「Special Register to Register」で、スレッドごとにハードウェアが維持する特殊レジスタ(ここではブロックのインデックス SR_CTAID.X (blockIdx.x) とブロック内のレーンのインデックス SR_TID.X (threadIdx.x))を通常のレジスタにコピーし、IMADで算術演算できるようにします。
10個以上の仮想レジスタが7つの実レジスタに集約されました。ncuは launch__registers_per_thread = 16 と報告しています。逆アセンブリでは R9 までしか名前がありませんが、アロケータはABIとアライメントのためにさらにいくつか予約しています。2つの mul.wide と add のシーケンスは、単一の IMAD.WIDE に融合されました。cvta変換は吸収されてアドレス指定に含まれています。
c[0x0][…] オペランドは定数バンク0であり、ドライバ管理下の小さな領域です。これらはカーネルの引数(ポインタ a, b, c とサイズ n)および起動ジオメトリです。バンクを埋めるのは、ドライバが起動時にGPUに渡す「QMD」(Queue Meta Data)と呼ばれる構造体の仕事です。これは起動自体がカードに到達したときに説明します。
引数が定数バンク0に配置される理由と場所
これらは定数メモリにあります。なぜなら、これはブロードキャスト読み取りだからです:グリッド内のすべてのスレッドは同じポインタを必要とし、定数キャッシュは32レーンすべてを一度に処理できます。レイアウトは固定です — 0x160, 0x168, 0x170 はポインタ a, b, c であり、0x178 は n で、起動ジオメトリがそれらと並んで 0x0(blockDim.x)にあります。バンク0には、MOV R1, c[0x0][0x28] がエントリ時にロードするスタックベースなどのABIパラメータも含まれています。ホストスタブが起動のために引数をパックする際にも、これらのオフセットが再び現れます。
このSASSを含む「cubin」ファイルはELFファイルです — Linuxが通常の実行可能ファイルや共有ライブラリに使用するのと同じオブジェクトファイルコンテナです。cuobjdump -elf はシンボルテーブル、マシンコードを含む .text.vadd セクション、および .nv.callgraph のようなCUDA固有のセクションを表示します。fatbinary 実行可能ファイルは、cubinをPTXとバンドルして単一の「fatbin」を作成し、その結果に対するcuobjdumpは、バイナリに埋め込まれたfatbinが両方を含んでいることを明らかにします。
$ cuobjdump vadd
...
Fatbin elf code: arch = sm_89 # 先ほど読んだSASS
Fatbin ptx code: arch = sm_89 compressed # PTX、これも同梱
SASSはこの4090で実際に実行されるものですが、PTXは将来の互換性のためのフォールバックとして同梱されています。もしこのバイナリを、cubinがカバーしていないアーキテクチャのGPUに持っていくと、ドライバはロード時にPTXを新しいSASSにJITコンパイルできます。
最後に、そのfatbinはホスト実行可能ファイル内にネストされており、readelf -S はそれを独自のセクションとして見つけます。
$ readelf -S vadd
...
[18] .nv_fatbin PROGBITS ...
[19] __nv_module_id PROGBITS ...
[29] .nvFatBinSegment PROGBITS ...
...
nvccが出力するvaddバイナリは、ホストコード、完全なELFオブジェクト(Ada SASSを含む)、およびPTXのコピーを含む単一の実行可能ファイルです。PTXは冗長なプレーンテキストであるため、nvccはデフォルトで圧縮してバイナリサイズを小さく保ちます。ドライバは、バイナリがコンパイル済みのSASSがカバーしていないアーキテクチャで実行された場合にのみ、それを解凍してJITコンパイルします。
ホストはどのようにGPUをトリガーするか§
コンパイルされたGPUマシンコードは、現在 ./vadd 実行可能ファイルの .nv_fatbin セクション内に静かに格納されています。ホストでプログラムを起動すると、2つの世界、つまりホストCPUとPCIeバスを挟んで存在するGPUを橋渡しする必要があります。
橋を渡る方法を知っているホストバイナリを設定するために、フロントエンドコンパイラ(cudafe++)は、main関数の開始前に実行される非表示のコンストラクタをコードに挿入します。そのジョブは、埋め込まれたfatbinaryをCUDAランタイムに登録し、ランタイムが後で使用するマッピングを記録することです:ホスト側の関数ポインタ vadd を、fatbin内のコンパイル済みデバイスカーネルのマングリングされた名前と関連付けます。
コンパイラが vadd<<<4096, 256>>>(da, db, dc, n) に遭遇すると、その高レベルの式は生成されたホスト起動スタブに置き換えられます。このスタブはカーネル引数をホストメモリのバッファにパックします。ポインタ da, db, dc と整数 n は、バイトオフセット 0, 8, 16, 24 に配置されます。これらのオフセットは、SASSマシンコードが定数バンク0から読み取っていたオフセット 0x160, 0x168, 0x170, 0x178 と同じです。
// vadd.cudafe1.stub.c から
void __device_stub__Z4vaddPKfS0_Pfi(const float *__par0, const float *__par1,
float *__par2, int __par3) {
__cudaLaunchPrologue(4);
__cudaSetupArgSimple(__par0, 0UL); // arg buffer offset 0
__cudaSetupArgSimple(__par1, 8UL); // offset 8
__cudaSetupArgSimple(__par2, 16UL); // offset 16
__cudaSetupArgSimple(__par3, 24UL); // offset 24
__cudaLaunch((char*)(void(*)(const float*, const float*, float*, int))vadd);
}
引数がパックされると、スタブは __cudaLaunch を呼び出し、ホスト側のダミー vadd 関数のメモリアドレスを渡します。このホスト関数はCPU上では単なる空のシェルであるため、そのホストメモリアドレスはルックアップキーとして機能します。ランタイムはその登録テーブルをこのアドレスでクエリして、対応するデバイス側シンボル名を見つけ、次にクローズドソースのユーザーモードドライバ(libcuda.so.1)に境界を越えてカーネルの起動を開始します。strace からの libcuda.so.1 は、このマシン上のドライバリリースである libcuda.so.590.48.01 に解決されます。
ランタイムは、プログラム内の最初のGPU呼び出し時にこのドライバを動的に開きます。これは strace を使用してキャッチできます。
$ strace -f -e trace=openat ./vadd
...
openat(..., "/lib/x86_64-linux-gnu/libcuda.so.1", O_RDONLY|O_CLOEXEC) = 3
...
この最初の呼び出しが行われると、「コンテキスト」が作成され、ドライバがデバイスと通信するために必要なすべてのインフラストラクチャが含まれます。これには、CPUがGPUと通信するチャネルも含まれます。これについては次のセクションで詳しく説明します。
この時点では、コンパイルされたマシンコードはまだGPUに到達していません。CUDA 12.2以降、モジュールロードはデフォルトで遅延ロードになります(CUDA_MODULE_LOADING で制御)。CUDA 11.7ではオプトインで提供され、長年 EAGER がデフォルトでしたが、12.xシリーズではデフォルトが LAZY に変更されました(アップフロントでロードコストを支払いたい場合はオーバーライドできます)。libcuda の下にはカーネルモードドライバ nvidia.ko があり、libcuda はデバイスファイルに対して ioctl を呼び出すことでそれにアクセスします。cuLaunchKernel が最終的にGPUに作業を配置する必要がある場合、それはカーネルモジュールとの会話になります。以下は、その会話の仕組みです。
GPUへのロード§
GPUはCPUのような関数呼び出しを受け付けません。ジャンプするエントリポイントもなく、CPUから引数をプッシュするスタックもありません。GPUはPCIeバスを挟んで配置され、ホストメモリからドライバコマンドのストリームを読み取ります。cuLaunchKernel がこれ以降に行うことはすべて、完全に形成された起動コマンドをそのストリームに配置し、GPUに完了したことを伝えるためのものです。
最初に行われるべきことは、GPUコードをデバイスにロードすることです。vadd を最初に実行すると、ドライバはカーネルのコードをコピーします。バッファを割り当て、SASSをそこにコピーします。
コードがGPUにロードされると、CPUはGPUにそれを読み込ませて実行を開始させる必要があります。これは、ホストとデバイスのメモリをまたいだ複雑なダンスを通じて行われます。ホストとGPUの両方が互いのメモリ空間の領域をマップできますが、PCIeバスを越えるアクセスにはペナルティが伴います。カーネル起動を達成するために、両者は両方の空間にまたがるさまざまな構造体に書き込みます。これらの構造体がチャネル、つまりGPUの操作を実行するワークキューを構成します。
ホストRAMに存在する2つの重要な構造体があります:プッシュバッファとGPFIFOで、これらはGPUが実行する必要のある作業リストをまとめて表します。
プッシュバッファは、ドライバがGPUへのコマンド(メソッドと呼ばれる)を書き込むメモリ領域です。メソッドはレジスタアドレスとGPUネイティブコマンドエンコーディングの値のペアであり、GPUが実行すべきアクションを定義します。
GPFIFOは、GPUとCPUがGPUがまだ読み取る必要があるものと、すでに読み取ったものを調整するために使用するポインタのリングバッファです。GPFIFOの各エントリは32ビットワード2つで構成され、プッシュバッファの範囲を記述します。この場合、ベースはホストメモリを指すGPU仮想アドレスです(base, length)。
GPUは継続的にGPFIFOをウォークして作業を見つけます。ドライバとGPUの間で、2つのカーソルを維持する必要があります:GP_GET(GPUが消費した量)とGP_PUT(ドライバが生成した量)。両方のカーソルはUSERD(チャネルごとの小さな構造体)内にあり、ここではデバイスメモリに配置されます。カーネルを起動するには、ドライバはプッシュバッファの範囲を関連するメソッドで埋め、GPFIFOエントリをそれにポイントさせ、GP_PUTを進めます。GPUがエントリを消費すると、GP_GETを進めます。
各部分がどこに配置されるか。
CPU -> ホストRAM -> プッシュバッファ (メソッド + QMD), GPFIFOリング
PCIe -> DMA
GPU -> USERD (GP_GET / GP_PUT), ドアベル (MMIO), ホストエンジン
CPU -> ホストRAM -> プッシュバッファ — メソッド + QMD, GPFIFOリング
PCIe -> 書き込み -> DMA -> GPU
GPU -> USERD — GP_GET / GP_PUT, ドアベル (MMIO), ホストエンジン
私たちの起動は、まず SET_INLINE_QMD_ADDRESS_A/B に続く LOAD_INLINE_QMD_DATA の実行によるメソッドのバーストによってトリガーされます。これらのメソッドは、「Queue Meta Data」(QMD)と呼ばれるオブジェクトをプッシュバッファにストリーミングするために使用されます。
QMDは、コンピュートグリッドの起動記述子です。グリッドとブロックのディメンション(.cu コードからの4096と256)、必要なレジスタ数と共有メモリ、そして2つのアドレス(プログラムの開始点(最初の起動でGPUメモリにロードされたSASS)とカーネルの引数を含む定数バンク)を保持します。そのバンクは、ホストスタブがパックした引数が配置される場所です:ドライバはそれらをコピーし、バンクのアドレスをQMDに記録します。QMDは、SASSの場所、そのSASSを並列プログラムに変換する方法、そしてそのプログラムの完了をどこで通知するかをGPUに伝えます。
GPUが実行を開始するためにすべてが整いました。問題は、GPUのホストエンジン(ホストとインターフェースするGPUの制御ロジック部分)がまだ動作していないことです。現代のカードではカーソルを監視しません。以前は、古いGPUはUSERDをスヌープしていたため、GP_PUT の書き込みだけで十分でした。Turing以降はそうではないため、ドライバは代わりにドアベルを鳴らします。そのため、GP_PUT の変更は、エンジンに見るように指示されるまでそのままになります。
それはドアベルを通じて指示されます。GPUはプロセスのレジスタの小さなウィンドウをマップし、そのうちの1つがドアベルです。ドライバはチャネルのワークサブミットトークンをそれに書き込みます。トークンは、どのチャネルに新しい作業があるかを伝えます。
ドアベルが鳴ると、ホストエンジンは更新された GP_PUT を読み取り、新しいGPFIFOエントリをプッシュバッファスパンにたどり、DMAでメソッドをそこからプルします。QMDを含むコンピュートメソッドに到達すると、それを「コンピュートワークディストリビュータ」に渡します。これについては後ほど詳しく説明します。
CPU側からは起動は完了です:ドアベルが鳴った瞬間に cuLaunchKernel は返りました。呼び出しは非同期であるため、制御はプログラムに戻り、GPUが作業している間CPUは実行を続けます。カーネルが実行された後にホスト側を再開します。
GPUが作業を開始する時が来ました。
命令ごと§
ホストエンジンはQMDをコンピュートワークディストリビュータ(しばしばGigaThread Engineとも呼ばれる。GPU全体に1つある)に渡します。VRAMにはSASS命令の単一の線形リストがあり、コンピュートワークディストリビュータとQMDは、この線形リストの命令をすべてのストリーミングマルチプロセッサ(SM)にわたる大規模な並列プログラムにするための最初のステップです。
スタックを下る旅において、コンピュートワークディストリビュータは現在、256スレッドの4096ブロックを記述したQMDを持っています。ターゲットカードはGeForce RTX 4090チップで、128個のSM(NVIDIAのAD102-300-A1 SKUは、製造歩留まりを最大化するために、フルダイの物理144 SMのうち16個を無効にしています。詳細はNVIDIA Ada GPUアーキテクチャホワイトペーパーに詳述されています)を搭載しています。ディストリビュータのタスクは、これら128個のSMすべてをワークで飽和状態に保つことです。
コンパイルされたマシンコードは、グローバルメモリに単一の線形シーケンスとして存在します。各SMは独自のローカル命令キャッシュ(I-cache)を持ち、GPU上のアクティブな各ワープは、独自のプログラムカウンタ(PC)を維持します。Volta以降、モデルはさらに細かくなっています — 各スレッドが独自のプログラムカウンタとコールスタックを持ち(独立スレッドスケジューリング)、ワープ内のスレッドが自由に分岐・再合流できるようになっています。ただし、発行は依然としてワープごとです:各サイクル、スケジューラは1つのワープを選択し、共通のPCを持つレーンに発行します。
VRAMの1つの命令ストリーム、SMごとにローカルにキャッシュされます。SMは最大48個のワープ(グリッド)を常駐させることができますが、4つのスケジューラはサイクルごとに最大1つの命令を発行します。ここでは、ほとんどのワープが LDG.E ロード(オレンジ色)で待機しており、1つのスロットだけが FADD(緑色)を発行しています。
VRAM -> 128個のSM -> 命令ストリーム (SASS)
SM (128個のうち1つ) -> I-cache, 48個の常駐ワープ, 4つのスケジューラ · 1命令/サイクル
VRAM
命令ストリーム (SASS)
S2R R6, CTAID.X
S2R R3, TID.X
IMAD R6, R6, ntid, R3
ISETP.GE P0, R6, n
@P0 EXIT
IMAD.WIDE R4, …
LDG.E R4, [R4]
LDG.E R3, [R2]
FADD R9, R4, R3
STG.E [R6], R9
EXIT
× 128個のSM
SM (128個のうち1つ)
I-cache
48個の常駐ワープ
4つのスケジューラ · 1命令/サイクル
私たちのSMのハードウェア制約が、同時に実行できるブロックの数を決定します。cudaGetDeviceProperties はこの情報を提供します。
+------------------------------------------------------------+
| AD102 SM リソースキャップ |
+------------------------------------------------------------+
| 最大アクティブスレッド/SM | 1,536 スレッド (48 ワープ) |
| レジスタファイル/SM | 65,536 32ビットレジスタ (256 KB) |
| 共有メモリ/SM | 100 KB |
+------------------------------------------------------------+
私たちの起動構成では、ブロックサイズは256スレッド(8ワープ)であり、ptxas はスレッドあたり16レジスタを予約しました。
- レジスタ容量: 各ブロックは 256 × 16 = 4,096 レジスタを必要とします。レジスタだけで見ると、SMは 65,536 / 4,096 = 16 個の常駐ブロックを収容できます。
- スレッド容量: ハードウェアは各SMを最大1,536スレッドに制限しています。これをブロックサイズで割ると、1,536 / 256 = 6 個の常駐ブロックが得られます。
スレッド容量がより厳しいボトルネックであるため、各SMは最大6ブロック(48ワープ)を同時に保持します。
ディストリビュータはこれらの6個の常駐ブロックをSMに割り当てます。各SMは4つの処理ブロック(サブパーティション)に分割されています。各サブパーティションは自己完結型の実行パイプラインです。
SMは私たちの48個の常駐ワープをこれら4つのサブパーティションに均等に分散するため、SMがいっぱいになると、各ワープスケジューラは12個のアクティブワープ(48 / 4)を管理します。各サイクル、ワープスケジューラはその12個の候補を評価し、適格なワープを1つ選択し、その実行スライスの32個の物理レーン全体に次の命令を発行します。
ワープが適格であるとはどういう意味か?§
GPUは、CPUとは異なる方法で命令の実行準備ができたかを決定します。現代のアウトオブオーダーCPUは、リオーダバッファやレジスタリネーミングを使用して単一スレッドからの並列性を抽出するためにシリコンを費やし、実行時に動的に依存関係を発見します。GPUにはそれが不要です:多数のワープを常駐させ、それらが停止したときに切り替えることでレイテンシを隠蔽します。並列性が重視されるため、重すぎる依存関係処理機構はシリコンの誤った使い方です。そのため、ハードウェアはコンパイラに、タイミングを予測できるすべてをスケジュールさせ、予測できないものについては軽量なハードウェアスコアボードに頼ります。
各128ビットSASS命令には、ptxas が書き込んだパックされた制御コードペイロードが含まれています。これらのスケジューリング制御ビットはハードウェアタイミングを直接決定し、3つの主要なディレクティブを含みます。
- 静的ストールカウント: 固定レイテンシ命令(標準的な整数または浮動小数点演算など)の場合、コンパイラはALUが書き戻すタイミングを正確に知っています。これは、スケジューラに次の命令を発行する前にワープをどれだけ待機させるかを正確に伝えるサイクル数をエンコードします。
- イールドヒント: このワープがスケジューリング優先度を譲るべきかどうかを示す単一ビットです。コンパイラがこのワープがボトルネックに近づいていることを知っている場合、このヒントを設定して、次のクロックサイクルでスケジューラが他のアクティブなワープを優先できるようにします。
- 依存関係バリアインデックス: コンパイル時に期間を予測できない可変レイテンシ操作(特にグローバルメモリロード(
LDG)や特殊関数(MUFU))の場合、ハードウェアはワープごとに6つの物理スコアボードバリア(0から5まで番号付け)を提供します。
これらのビットが逆アセンブリに表示されない理由
NVIDIAの標準ツール nvdisasm を使用してバイナリを逆アセンブルすると、生の制御コードはデフォルトで非表示になります。ツールはそれらを削除して、標準的でクリーンなSASSニーモニックを表示します。ただし、それらは命令と直接一緒に格納されています。cuobjdump -sass を使用して生のバイナリを検査し、16進命令コメント(例:/* 0x... */)を注意深く見ると、これらの制御ビットを格納するパックされた生の16進ワードが表示されます。
それらの正確なレイアウトについて私たちが知っていることは、マイクロベンチマークコミュニティのリバースエンジニアリングの努力によるものです。Maxwell、Volta、Ampere、Ada Lovelaceの間でビットフィールドはシフトおよび進化しましたが、コアアーキテクチャの概念は同一です:コンパイル時の静的スケジューリングメタデータは、SMハードウェアを可能な限りシンプルで電力効率の高いものにするために、命令ストリームに直接パックされます。
私たちの vadd に対して cuobjdump -sass を実行すると、各命令には2つの64ビットワードとして生の128ビットエンコーディングが付属し、各ペアの2番目のワードが制御ペイロードを運びます。
$ cuobjdump -sass vadd # 制御ペイロード
/*00a0*/ LDG.E R4, [R4.64] /* 0x000ea8000c1e1900 */
/*00b0*/ LDG.E R3, [R2.64] /* 0x000ea2000c1e1900 */
/*00c0*/ IMAD.WIDE R6, R6, R7, c[0x0][0x170] /* 0x000fe200078e0207 */
/*00d0*/ FADD R9, R4, R3 /* 0x004fca0000000000 */
/*00e0*/ STG.E [R6.64], R9 /* 0x000fe2000c101904 */
制御ペイロードを抽出すると(最も明確な公開再構築は、Citadelマイクロベンチマーク論文Jia et al., “Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking”とMaxwell用のこれらのmaxas制御コードノートです)、各ディレクティブが作用している ptxas が作成したスケジュールが見えます。
| 命令 | ストール | イールド | セット | 待機対象 |
|---|---|---|---|---|
LDG.E | 4 | はい | B2 | — |
LDG.E | 1 | はい | B2 | — |
IMAD.WIDE | 1 | はい | — | — |
FADD | 5 | いいえ | B2 | B2 |
STG.E | 1 | はい | — | — |
2つのロードはディレクティブ3を利用し、どちらも同じスコアボードバリア B2 を「セット」します。ロードされた R4 と R3 を必要とする最初の命令である FADD は B2 の待機を持ちます。両方のロードが完了しバリアがクリアされるまで、ワープは適格でなく、スケジューラはサブパーティションの他の11個のワープのいずれかをスキップします。
FADD から STG へのハンドオフはディレクティブ1です。浮動小数点加算は固定レイテンシを持つため、バリアはありません:FADD は R9 が STG によって読み取られるまでの数サイクル待機するのにかかる時間を示す stall=5 を持ちます。
イールドビット(ディレクティブ2)は、コンパイラが待機しそうな操作の周りのスケジューリング優先度を調整するため、シーケンス全体でオンとオフを切り替えます。
各サイクル、スケジューラはワープの6ビットバリア状態と小さなストールカウンタを読み取り、各ワープの適格性決定を行います。これがGPUがほとんどオーバーヘッドなしでレイテンシを隠蔽する方法です。
データのロード§
ワープスケジューラが適格なワープを見つけて LDG.E ロードを発行すると、メモリ階層を下にハードウェアリクエストを追跡できます。ワープ内の32個のスレッドはそれぞれアドレスを計算します。スレッドは連続した float 配列の要素(各4バイト)にアクセスするため、ワープは128バイト(32 × 4バイト)の連続したブロックを要求します。
SMのロード/ストアユニットは、この連続アクセスパターンを検出し、リクエストの畳み込み(coalescing)を実行します。これは、32個のスレッドごとの4バイトリクエストを4つの32バイトセクターリクエストにマージします。フェッチは32バイト単位で行われるため、これは完璧です。もし読み取りがこのように連続的かつ畳み込まれていなかった場合、必要以上のデータをロードすることになります。
畳み込まれたリクエストは、まずSMのローカルL1データキャッシュをチェックします。ミスした場合、それらは128個のSMすべてを72MBのL2キャッシュの分散スライスにリンクする高帯域幅クロスバーインターコネクトを経由してルーティングされます。リクエストがL2キャッシュでもミスした場合、それらはメモリコントローラにさらに下降し、メモリバスを横切って物理GDDR6X VRAMチップに到達します。RTX 4090は、A100やH100のようなデータセンタークラスのGPUに見られるHigh-Bandwidth Memory(HBM)ではなく、GDDR6Xメモリを使用しています。ループの最後に c[i] を書き込む STG.E ストアは、逆方向に全く同じパスをたどります。実際には c[i] はVRAMにヒットしません。
NVIDIA Nsight Computeプロファイラ(ncu)でコンパイル済みカーネルを実行すると、示唆に富むメトリクスが得られます。
$ ncu --metrics \
launch__grid_size,launch__block_size,launch__registers_per_thread,\
launch__waves_per_multiprocessor,sm__warps_active.avg.pct_of_peak,\
smsp__issue_active.avg.pct_of_peak,dram__throughput.avg.pct_of_peak,\
gpu__time_duration.sum \
./vadd
...
----------------------------------------------------------
Metric Name Unit Value
----------------------------------------------------------
launch__grid_size 4,096
launch__block_size 256
launch__registers_per_thread 16
launch__waves_per_multiprocessor 5.33
sm__warps_active.avg.pct_of_peak % 82.77
smsp__issue_active.avg.pct_of_peak % 5.17
dram__throughput.avg.pct_of_peak % 79.65
gpu__time_duration.sum us 10.78
----------------------------------------------------------
実行中、ワープの82.77%がアクティブでした。ワープは5.17%の時間命令を発行していました。DRAMは最大利用率の79.65%で動作していました。
カーネルは非常に低い算術強度を持っています:12バイトのデータ転送(2回の4バイトロードと1回の4バイトストア)ごとに、正確に1回の浮動小数点加算(FADD)とわずかなポインタ演算を実行します。
したがって、10.78 μs は、DRAMバスがカーネルに入力を供給できる速度にほぼ依存しています。ここではピーク性能の約5分の4です。入力は2つだけがバスを横断し、12MBのフルデータではありません。ncu はDRAMから8.4MBの読み取りと、実質的に書き込みなしを示しています。4MBの出力 c は72MBのL2に収まり、後続のデバイスからホストへのコピーがそれを読み戻すまでDRAMにフラッシュされません。5分の4のピーク値は読み取り側です — 8.4 MB / 10.78 μs ≈ 780 GB/s。
CPUへの帰還§
結果は現在GPUのL2キャッシュにあります。CPUはターミナルを実行しているため、結果を表示するために結果を取得する必要があります。イベントのCPU側の視点に戻りましょう。
ドアベルが鳴った瞬間に起動はCPUに制御を返しました。そのため、GPUはCPUに完了したことを通知する必要があります。私たちの4096ブロックの最後が完了すると、GPUはQMDが運んでいた完了セマフォ(フェンスフィールド、ワード23-24)を投稿することでそれを実行します。
デバイスからホストへの cudaMemcpy(c, dc, …)(ピン留めメモリの cudaMemcpyAsync は待機をスキップし、ホストを先行させます)はデフォルトストリームでカーネルの後ろに位置するため、GPUのコピーエンジン(転送を実行する)はセマフォによってゲートされます。値が表示されると、GPUはDMAを実行します。c は72MBのL2キャッシュ内にダーティな状態で残っているため — STG.E ストアはそれをDRAMにスピルする必要がなかったため — エンジンの読み取りはL2から直接提供され、データはDRAMへのラウンドトリップなしでPCIeを横断します。
コピーが完了すると、ホストが cudaMemcpy で待機していた独自のセマフォを投稿します。ホスト上で cudaMemcpy が完了し、c は再び通常のホストメモリになり、printf はRAMから c[0] と c[n-1] をロードし、それらを文字列にフォーマットして標準出力への write システムコールに渡します。
全体のパス§
カーネルソースは cicc を経てPTXに、そして ptxas を経てSASSになり、fatbinary がフォールバックコピーのPTXと共にそれをcubinを持つfatbinにパックし、リンカがそれを通常のLinux実行可能ファイルに溶接しました。コンストラクタが起動前にそのfatbinを登録し、ホストスタブをマングリングされたデバイス名にマッピングしました。最初の起動は、cubinをGPUに遅延ロードしました。cuLaunchKernel は起動構成からQMDを構築し、それをプッシュバッファにGPUメソッドとして書き込み、GP_PUT を進め、単一のMMIOストアでドアベルを鳴らしました。これにより、GPUのホストエンジンが作業を取得し、QMDをコンピュートワークディストリビュータに渡しました。ディストリビュータは4096ブロックを128個のSMにフル占有率で分散させ、各SMに4つのワープスケジューラがコンパイラが書き込んだストールカウントを持つ128ビット命令を発行し、畳み込まれたメモリパスがDRAMを通じて入力をピーク帯域幅の5分の4で計算のためにプルし、100万レーンのそれぞれで単一の合計を計算しました。完了セマフォとコピーエンジンがその結果をバスを横断して待機していた printf の場所まで運び、次の結果を知りました。
c[0]=2.000000 c[n-1]=2.000000
新しい投稿をメールで受け取る
付録: 起動の中身を見る方法§
Claudeと私は、カーネル起動のさまざまな部分が発生するのを見るために、多くの異なるトリックを使用しました。その一部は、オープンカーネルモジュールを丹念に読むことから来ています。
この記事のいくつかの主張はオープンソースからは読み取れません。なぜなら libcuda はクローズドソースだからです。それらを理解するために、いくつかの便利な診断フックがあります。
インターセプトフック§
ドライバメソッドの書き込みはシステムコールを通過しません(ドライバはそれを既にマップされたライトコンバインドバッファに直接書き込みます)。そのため、それらを見つけるにはメモリを読む必要があります。私たちは mmap をラップする LD_PRELOAD シムを使用しました。ドライバが /dev/nvidia* ファイルからマップするすべての領域を記録し、起動が返された直後にテストプログラムが呼び出す関数を公開してそれらをダンプします。
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
// 動的リンカ関数ポインタ
static void* (*orig_mmap)(void*, size_t, int, int, int, off_t) = NULL;
// キャプチャされたチャネルマッピングを格納
struct Map {
void* addr;
size_t length;
off_t offset;
char path[256];
} maps[128];
static int map_count = 0;
void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_t offset) {
if (!orig_mmap) {
orig_mmap = dlsym(RTLD_NEXT, "mmap");
}
void* ret = orig_mmap(addr, length, prot, flags, fd, offset);
if (ret != MAP_FAILED && fd != -1 && map_count < 128) {
char proclink[256];
char path[256];
sprintf(proclink, "/proc/self/fd/%d", fd);
ssize_t len = readlink(proclink, path, sizeof(path) - 1);
if (len != -1) {
path[len] = '\0';
// NVIDIAデバイスファイルに関心がある
if (strstr(path, "/dev/nvidia")) {
maps[map_count].addr = ret;
maps[map_count].length = length;
maps[map_count].offset = offset;
strcpy(maps[map_count].path, path);
map_count++;
}
}
}
return ret;
}
// プッシュバッファを保持するメモリ範囲をダンプするための関数を公開
void dump_pushbuffer() {
printf("\n=== [Shim] Dump of Mapped Pushbuffers ===\n");
for (int i = 0; i < map_count; i++) {
// ユーザースペースチャネル/プッシュバッファは大きなサイズでマップされる
if (maps[i].length >= 0x1000) {
unsigned int* ptr = (unsigned int*)maps[i].addr;
printf("Mapping %d: %s, at %p (%zu bytes), offset 0x%lx\n",
i, maps[i].path, maps[i].addr, maps[i].length, (long)maps[i].offset);
// メソッドヘッダーバーストを探してワードをウォーク
for (size_t j = 0; j < maps[i].length / 4; j++) {
unsigned int word = ptr[j];
unsigned int opcode = (word >> 29) & 0x7; // 1 = INC
unsigned int count = (word >> 16) & 0x1FFF; // ペイロードワード
unsigned int method = (word & 0xFFF) << 2; // レジスタオフセット
// 0x318 は SET_INLINE_QMD_ADDRESS_A で、インラインバーストの開始
if (opcode == 1 && method == 0x318) {
printf(" [+] Method burst at word %zu: header = 0x%08X\n", j, word);
printf(" INC, count %d, offset 0x%04X\n", count, method);
for (unsigned int k = 1; k <= count && (j + k) < (maps[i].length / 4); k++) {
printf(" word %02u: 0x%08X\n", k, ptr[j + k]);
}
}
}
}
}
}
共有ライブラリにコンパイルします。
$ gcc -shared -fPIC -o shim.so shim.c -ldl
そして、起動後に dump_pushbuffer() をテストプログラムから呼び出し、シムをプリロードして実行します。
$ LD_PRELOAD=./shim.so ./vadd
ドライバはチャネル用にライトコンバインドバッファをマップします。ダンプはそれをウォークし、起動のメソッドバーストを表示します。それをデコードする必要があります。
プッシュバッファコマンドストリームのデコード§
プッシュバッファメソッドはヘッダーワードとそれに続くデータワードで構成されます。ヘッダーは4つのフィールドをパックします(clc46f.h の NVC46F_DMA_INCR_* マクロとして定義)。
- ビット31:29 — オプコード:
0x1は増加メソッド書き込み(INC_METHOD/INCR_OPCODE_VALUE)、0x3は非増加メソッド書き込み(NON_INC_METHOD)、0x4は即値データ書き込み(IMMD_DATA_METHOD)。 - ビット28:16 — カウント:ペイロードワード数(
NVC46F_DMA_INCR_COUNT)。 - ビット15:13 — サブチャネルインデックス:コマンドを専用バックエンドエンジンコンテキストにルーティングします(
NVC46F_DMA_INCR_SUBCHANNEL)。 - ビット11:0 — メソッドのレジスタオフセット、4で割った値(
NVC46F_DMA_INCR_ADDRESS)。シムはそれを元に戻します。
ここでは2つの起動パスが関連しているようです。メソッドは src/common/sdk/nvidia/inc/class/ のコンピュートクラスごとに定義されています — clc3c0.h (Volta)、clc5c0.h (Turing)、clc6c0.h/clc7c0.h (Ampere)、clc9c0.h (Ada)、clcbc0.h (Hopper)、clcdc0.h (Blackwell)。Adaヘッダー(clc9c0.h)は29行のスタブで、クラス番号 0xC9C0 のみを定義し、Ampereメソッドセットを継承するため、実際に読み取る定義はAmpereヘッダーにあります。
0x0318—SET_INLINE_QMD_ADDRESS_A(AmpereヘッダーでNVC6C0_SET_INLINE_QMD_ADDRESS_Aとして定義され、Adaによって変更なく継承)、これはLOAD_INLINE_QMD_DATA(i)(オフセット0x0320 + i * 4)を介してプッシュバッファに直接ストリーミングされるインラインQMDバーストを開きます。0x02b4—SEND_PCAS_A、これはVRAMの別の場所にあるQMDへのポインタのみを運ぶオフラインパスです。
ダンプから、どちらがプッシュバッファに入るかを判断できます。ダンプはインラインパスを示しています:1つの増加メソッドバースト、カウント66、SET_INLINE_QMD_ADDRESS_A で開きます。66ワードは2つのアドレスワード(SET_INLINE_QMD_ADDRESS_A/_B、0x0318/0x031c)に続き、64個の LOAD_INLINE_QMD_DATA ワード(0x0320 以降)です — インラインで運ばれる256バイトのQMDです。その中で、ワード12は 0x1000、ワード18は 0x100 です — vadd<<<4096, 256>>> の4096と256です。
デバイスメモリの読み取りとQMDレイアウト§
Queue Meta Data (QMD) 構造体はマルチワードレイアウトとして表現され、フィールドは src/common/sdk/nvidia/inc/class/cla0c0qmd.h 内の32ビット境界をまたぐマルチワード(MW)ビットとして定義されています。QMDはいくつかの住所のようなフィールドを格納しますが、それらはすべて同じ種類の値ではありません。
PROGRAM_OFFSET— MW(287:256)(ワード8)は、チャネルのコードベースに対する32ビットエントリポイントオフセットであり、64ビットポインタではありません。CONSTANT_BUFFER_ADDR_LOWER(i)/ADDR_UPPER(i)— MW(959+i64:928+i64)(例:定数バンク0はワード29-30に配置された引数を保持します)。RELEASE0_ADDRESS_LOWER/UPPER— MW(767:736)(ワード23-24)、フェンス/セマフォに使用されます。CIRCULAR_QUEUE_ADDR_LOWER/UPPER— MW(319:288)(ワード9-10)。
これらはCPUが直接読み取れないデバイスメモリを指します:通常のロードはフォルトし、cudaMemcpy と cuMemcpyDtoH は両方ともアドレスを拒否します。
そのため、GPUで読み取る必要があります。小さなカーネルが512バイトを生のポインタからホストが取得できるバッファにコピーします。
__global__ void peek(const unsigned char* src, unsigned char* dst) {
for (int i = blockIdx.x * blockDim.x + threadIdx.x;
i < 512;
i += blockDim.x * gridDim.x) {
dst[i] = src[i];
}
}
QMDフィールドのそれぞれを指すと、SASSの512バイト全体を返すものが1つだけあります。QMD内で有効なGPU仮想アドレスを探すメモリ走査シムを実行すると、ワード48で一致が見つかります。
qmd[48] -> 0x74167b272300 512 / 512 バイト一致
ドライバのプログラムフィールドはワード8の PROGRAM_OFFSET であるのに、なぜSASSがワード48(qmd[48])で一致するのでしょうか?
ワード8はドライバによって設定された32ビットオフセットのみを保持しますが、ワード48/49はハードウェア所有の HW_ONLY_INNER_GET (MW(1566:1536)) と HW_ONLY_INNER_PUT (MW(1598:1568)) フィールドです。起動後のダンプでは、これらのワードは完全な64ビットGPU仮想アドレスを保持し、ワード48の値の逆参照はカーネルSASSを返します。最も単純な解釈は、スケジューラが起動時にプログラムオフセットをこれらのスケジューラ所有フィールドに解決することです。
ドライバのioctlのデコード§
コマンドストリームはメモリから読み取る必要がありますが、libcuda は通常の方法でメモリとGPUオブジェクトを設定します:ドライバのデバイスファイルに対して ioctl を実行します(Michael Kerrisk著、The Linux Programming Interface、第4章と第15章を参照)。単一カーネルプログラムに対する strace は948回の呼び出しを記録します(ほとんどが一度限りのセットアップです。安定した起動ループははるかに少ない呼び出しで済みます)。ほとんどは2つのファイルディスクリプタ — /dev/nvidiactl と /dev/nvidia-uvm — に対して行われます。
$ strace -f -e trace=ioctl ./vadd
...
ioctl(8, _IOC(_IOC_READ|_IOC_WRITE, 0x46, 0x2a, 0x900), ...) # /dev/nvidiactl
ioctl(8, _IOC(_IOC_READ|_IOC_WRITE, 0x46, 0x2b, 0x30), ...) # /dev/nvidiactl
ioctl(9, ...) # /dev/nvidia-uvm
...
マジックバイト 0x46 は「F」であり、NVIDIAリソースマネージャのioctlマジックです。マジックバイトは、NVIDIAのioctlがすべて持つべきチェック値です。詳細はLinuxカーネルドキュメントを参照してください。コマンド番号は、オープンカーネルモジュールのnv_escape.hに対してデコードされます:0x2A は NV_ESC_RM_CONTROL、0x2B は NV_ESC_RM_ALLOC です。
SASS制御ワードのデコード§
ストールカウント、バリア、イールドビットは、適格性のセクションから来ており、ptxas が各命令の2番目の64ビットワードの上部にパックする21ビット制御フィールドから取得されます。cuobjdump -sass はこれをニーモニックの横に表示します。
20 17 16 11 10 8 7 5 4 3 0
┌────────┬───────────┬──────┬──────┬─┬──────┐
│ reuse │ wait mask │ read │write │Y│stall │
│ (4) │ (6) │ barr │ barr │ │ (4) │
└────────┴───────────┴──────┴──────┴─┴──────┘
2つの3ビットインデックスは命令がセットするスコアボードバリアを指定し、6ビットマスクは待機するバリアを指定し、Y はイールドビット、stall は静的サイクルカウントです。レイアウトは文書化されておらず、マイクロベンチマークから再構築されています。最も明確な公開再構築は、Citadelマイクロベンチマーク論文Jia et al., “Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking”とMaxwell用のこれらのmaxas制御コードノートです。
NVCCホスト登録コールバック§
GPUコードを起動時に登録するためにコンパイラが生成する正確なコードを確認したい場合は、nvcc --keep でコンパイルすると vadd.cudafe1.stub.c を確認できます。
プロセスの開始時の登録は、自動生成されたコンストラクタによって処理されます。
// vadd.cudafe1.stub.c から
static void __sti____cudaRegisterAll(void) __attribute__((__constructor__));
static void __nv_cudaEntityRegisterCallback(void **__T4) {
__cudaRegisterEntry(__T4, (void(*)(const float*, const float*, float*, int))vadd,
_Z4vaddPKfS0_Pfi, -1);
}
static void __sti____cudaRegisterAll(void) {
__cudaRegisterBinary(__nv_cudaEntityRegisterCallback);
}
__attribute__((__constructor__)) ディレクティブは、リンカに main 開始前に __sti____cudaRegisterAll を実行するように指示します。これはデバイスバイナリをCUDAランタイムに登録し、コールバックをスケジュールします。実行されると、__cudaRegisterEntry はホスト関数ポインタ vadd をマングリングされたデバイスエントリポイント _Z4vaddPKfS0_Pfi にマッピングし、起動時に cudaLaunchKernel がクエリするハッシュテーブルを構築します。