Show HN: Phobos – タイルDAGサポート付きの小さなスケールフリー・カーネル言語
Show HN: Phobos – A tiny scale-free kernel language with tile-DAG support (joa-ebert.com)
要約
Phobosは、Tritonにインスパイアされた、NVIDIA GPU上で動作するPTXにコンパイルされる小さなカーネル言語です。作者は、低レベルGPU概念の理解を深めるための個人的な研究プロジェクトとして開発しました。この言語は、AI計算に適したモデルを目指しており、特にタイル(テンソル)型を第一級オブジェクトとして扱います。LLVMとMLIRのバインディングを持つRustで実装されており、パフォーマンスはcuBLASの約75%を達成しています。
全文翻訳
Phobos: 非常に小さなスケールフリーカーネル言語
TLDR: Tritonにインスパイアされた、非常に小さなカーネル言語「Phobos」を開発しました。PTXに低レベル化され、NVIDIA GPU上で実行されます。2080 SUPERではcuBLAS SGEMM GFLOP/sの76%(理論ピークGFLOP/sの74%)という許容可能なパフォーマンスを達成します。Phobosは分散タイルDAG設計に自然にマッピングされます。ローカルタイル最適化を実装する際に分散コンピューティングの可能性に気づきました。このプロジェクトは、低レベルGPUの概念をより深く理解するための個人的な研究プロジェクトです。
子供の頃から人工知能やニューラルネットワークに魅了され、自室でオブジェクト認識ソフトウェアを構築するほどでした。大学では認知情報学を専攻しましたが、4日で中退し、パリのスタートアップで働くことになりました。
その後、最適化、コンパイラ、その他の機械学習関連トピックに長年携わってきました。最先端のAI研究や技術からは一歩引いた立場ですが、研究動向は追っています。
再び、手元にある2080 SUPERを使い、学習意欲を燃やしています。
何かを完全に理解するには、実際に手を動かして「作業」をすることが重要だと強く信じています。コンパイラ、最適化、LLVMの経験があるので、GPUをターゲットとする小さな言語とコンパイラを作成することは、私にとって取り組みやすいと考えました。
ソフトウェアエンジニアリングとコンパイラの経験から、慎重に進める必要があることも理解しています。これは学習演習として保ちたいです。間違った方向に行けば、私の時間を過剰に消費するプロジェクトに発展する可能性も十分にあります。コンパイラは特に複雑です。プログラムを最初から最後までコンパイルできなければ、何も見えません。プログラムのコンパイル自体は容易ではないため、いくつかの近道を使います。リンクやフェーズモデルのようなものは一切ありません。
目標: NVIDIA GPUでコンパイル・実行できる小さな言語を作成すること。その過程で、AI計算に適したモデルを選択したい。典型的なAIカーネルの意味論を再構築することなく、最適化を可能にするべきです。ファーストクラスのテンソル型/タイルをサポートしたいと考えています。実際、言語全体がタイルを中心に構成されています。
以下に、コンパイルしたい2つのサンプルプログラムを示します。言語については後ほど詳しく説明します。
ベクトル加算
これは (\vec{c} = \vec{a} + \vec{b}) です。
@autotune(BLOCK in [1024])
kernel add(a: tensor<f32>[N], b: tensor<f32>[N], c: tensor<f32>[N]) {
let base = program_id(0) * BLOCK
c[base :+ BLOCK] = a[base :+ BLOCK] + b[base :+ BLOCK]
}
行列乗算
これは (\mathbf{C}_{M \times N} = \alpha \mathbf{A}_ {M \times K} \mathbf{B}_ {K \times N} + \beta \mathbf{C}_ {M \times N}) です。
@autotune(TILE_M in [32, 128], TILE_N in [64, 256], TILE_K in [16, 64])
kernel sgemm(A: tensor<f32>[M, K],
B: tensor<f32>[K, N],
C: tensor<f32>[M, N],
alpha: f32,
beta: f32) {
let pm = program_id(0)
let pn = program_id(1)
var acc: tile<f32>[TILE_M, TILE_N] = 0.0
for kt in range(0, K, TILE_K) {
var a = A[pm * TILE_M :+ TILE_M, kt :+ TILE_K]
var b = B[kt :+ TILE_K, pn * TILE_N :+ TILE_N]
acc += dot(a, b)
}
let c_old = C[pm * TILE_M :+ TILE_M, pn * TILE_N :+ TILE_N]
C[pm * TILE_M :+ TILE_M, pn * TILE_N :+ TILE_N] = alpha * acc + beta * c_old
}
補足: カーネル開発に詳しい方なら、はい、これはミニ・トライトンです。
未知の領域
まず、CUDAとそのターゲットフォーマットについて理解を深めましょう。CUDA Refresher: Getting started with CUDA のようなリソースを見ると、以下のようなサンプルに遭遇します。
/** CUDA kernel device code - CUDA Sample Codes
* Computes the vector addition of A and B into C.
* The three vectors have the same number of elements as numElements.
*/
__global__ void vectorAdd( float *A, float *B, float *C, int numElements) {
int i = blockDim.x * blockIdx.x + threadIdx.x;
if (i < numElements) {
C[i] = A[i] + B[i];
}
}
私たちはこれには興味がありません。これは高レベルコードです。GPUのx64、C++ではなく、それを求めています。まずNVIDIA CUDA Compiler (NVCC) のドキュメント[1]を見ましたが、nvccは実行ファイル全体をリンクするため、非常に複雑です。CUDAドキュメント[2]自体には、私たちの領域に近いセクションがあります: PTX and low-level programming。低レベルプログラミングこそが私たちが求めているものです。
PTXは、汎用並列プログラミングのための安定したプログラミングモデルと命令セットを提供します。これは、NVIDIA Teslaアーキテクチャによって定義された計算機能をサポートするNVIDIA GPUで効率的に動作するように設計されています。CUDAやC/C++のような言語のハイレベル言語コンパイラは、PTX命令を生成し、それらは最適化され、ネイティブターゲットアーキテクチャ命令に変換されます。[3]
利用できるLLVMバックエンドがあり、NVPTXと呼ばれています。これでパイプラインのアイデアができました。
ソースコード ⟶ レキサー ⟶ パーサー ⟶ コードジェネレータ ⟶ LLVM IR ⟶ NVPTX ⟶ PTX ⟶ GPU
PTXはGPUが実行するマシンコードではありませんが、それに最も近いものです。SASSが実際のマシンコード[4]ですが、ドキュメント化されていません。
しかし、それだけではありません。常にそうです。 機能の増加です。感じています。MLIRこそが今の道です[5]。LLVM IRを生成する代わりに、それを使用しましょう。実際、MLIRの機能、例えばカスタムダイアレクトを使用する予定はありません。しかし、それはCUTLASSのようなパフォーマンスを無料で得るための選択肢を与えてくれます…夢を見ることができます。真面目な話、MLIRは私が必要とする多くの命令を公開しています。
ソースコード ⟶ レキサー ⟶ パーサー ⟶ コードジェネレータ ⟶ MLIR ⟶ PTX ⟶ GPU
このプロジェクトでは、LLVMのRustバインディングであるinkwell、MLIRのmeliorクレートがあり、パターンマッチングをサポートしているため、コンパイラの作成が100倍楽しくなるRustを使用します。MLIRの使用がinkwellの使用と同じくらい「シンプル」であることを期待していましたが、残念ながら、単純なプログラムをコンパイルできるようになるまでに、melior、mlir-sys、tblgen-rsクレートのパッチ適用やその他の多くの苦労に何時間も費やしました。
この小さな冒険を始めたとき、すべてを理解するためにLLVM IRから直接PTXを生成しました。それが私にとって明白な道でした。しかし、すぐにMLIRについて知りました。inkwellの開始は数時間で済みました。meliorとMLIRを動作させるのに2日かかりました。
右から左へ
多くのことがここで壊れる可能性があるため、右から左へと進みます。最も孤立したタスクから始めます: PTXコードをGPUで実行することです。これは最終的にやらなければならないことです。
上記のvectorAddをPTXで記述し、custクレートで実行してみましょう。
まず、GPUのコンピュートキャップを理解する必要があります。私の場合は、Turingファミリーで7.5です。はい、8GB VRAMしかないかなり古いGPUです。残念ながら、float32テンソルコアもありませんが、16ビット精度は利用可能です。それで作業できます。
$ nvidia-smi --query-gpu=name,compute_cap
name, compute_cap
NVIDIA GeForce RTX 2080 SUPER, 7.5
これでPTXの記述を開始できます。LLVM IRを手書きした経験があれば、これは馴染み深いでしょう。少なくとも、すべてをSSA形式で書く必要はありません。いずれにせよ、これは手書きする唯一のPTXコードでした。アセンブラをptxas add.ptxで直接実行することは、Rustや使用しているCUDAクレートからの問題を分離するための有用な健全性チェックでした。nvcc -ptx in.cu -o out.ptxを使用してカーネルをPTXにコンパイルすることも非常に役立ちます。カーネルを記述し、公式ツールチェーンでコンパイルし、生成されたPTX出力を検査できます。
.version 9.0 // 9.3 は動作するはずだが、しない?
.target sm_75 // ターゲットアーキテクチャ(コンピュートキャップ)
.address_size 64
.visible .entry add(
.param .u64 a,
.param .u64 b,
.param .u64 c,
.param .u32 numElements
) {
.reg .pred %p;
.reg .f32 %f<4>;
.reg .b32 %r<5>;
.reg .b64 %rd<11>;
ld.param.u64 %rd1, [a];
ld.param.u64 %rd2, [b];
ld.param.u64 %rd3, [c];
ld.param.u32 %r1, [numElements];
// i = blockIdx.x * blockDim.x + threadIdx.x
mov.u32 %r2, %ctaid.x;
mov.u32 %r3, %ntid.x;
mov.u32 %r4, %tid.x;
mad.lo.s32 %r2, %r2, %r3, %r4; // %r2 が i
// if i >= numElements, return
setp.ge.s32 %p, %r2, %r1;
@%p bra DONE;
// バイトオフセット = i * 4
mul.wide.s32 %rd4, %r2, 4;
// %f1 = a[i * 4]
cvta.to.global.u64 %rd5, %rd1;
add.s64 %rd6, %rd5, %rd4;
ld.global.f32 %f1, [%rd6];
// %f2 = b[i * 4]
cvta.to.global.u64 %rd7, %rd2;
add.s64 %rd8, %rd7, %rd4;
ld.global.f32 %f2, [%rd8];
// %f3 = %f1 + %f2
add.f32 %f3, %f1, %f2;
// c[i * 4] = %f3
cvta.to.global.u64 %rd9, %rd3;
add.s64 %rd10, %rd9, %rd4;
st.global.f32 [%rd10], %f3;
DONE:
ret;
}
$ cargo run
Compiling phobos v0.1.0 (C:\Users\joaeb\code\phobos)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.63s
Running `target\debug\phobos.exe`
1048576 elements correct
テスト目的で後ほど参照するため、Rustコードをここに含めます。
Rust & cust を使用したGPUでのPTX実行
use cust::prelude::*;
const PTX: &str = include_str!("../ptx/add.ptx");
fn main() -> anyhow::Result<()> {
let _ctx = cust::quick_init()?; // init driver
let module = Module::from_ptx(PTX, &[])?; // compile the code
let stream = Stream::new(StreamFlags::NON_BLOCKING, None)?;
let func = module.get_function("add")?;
let n: i32 = 1 << 20; // create some data
let a: Vec<f32> = (0..n).map(|i| i as f32).collect();
let b: Vec<f32> = (0..n).map(|i| (2 * i) as f32).collect();
let mut c = vec![0.0f32; n as usize];
let a_dev = a.as_slice().as_dbuf()?; // write to gpu
let b_dev = b.as_slice().as_dbuf()?;
let c_dev = c.as_slice().as_dbuf()?;
let block: u32 = 256; // run our code
let grid: u32 = (n as u32 + block - 1) / block;
unsafe {
launch!(func<<<grid, block, 0, stream>>>(
a_dev.as_device_ptr(),
b_dev.as_device_ptr(),
c_dev.as_device_ptr(),
n
))?;
}
// wait for gpu to complete
stream.synchronize()?;
// read from gpu
c_dev.copy_to(&mut c)?;
// sanity check
for i in 0..n as usize {
assert_eq!(c[i], a[i] + b[i]);
}
println!("{n} elements correct");
Ok(())
}
提供するソースコード(PTX)は、特定のGPUに対してJITコンパイルされます。同じコードが多くの異なるGPUで実行されることを考えると、これは理にかなっています。PTXにエラーを導入すると、「JIT error」というメッセージが表示されます。ptxasは実際に壊れているものを特定するのに役立ちます。ncuでバイナリをプロファイリングすることもできます。良いですね。
これでスタックについての理解が深まりました。GPU上で低レベルコードを実行し、CPUで検証できます。先ほどのパイプラインに戻りましょう。
ソースコード ⟶ レキサー ⟶ パーサー ⟶ コードジェネレータ ⟶ MLIR ⟶ PTX ⟶ GPU
私たちは終点から始めました。しかし、それは良いことです。少なくとも私にとっては、これが最も不確実な部分でした。それ以降は、ほとんど既知の領域です。
知っていた悪魔
LLVMは非常に気に入っており、Javaバイトコードから始めて、それを独自のIRにパースし、変換を行い、x64またはWASMに出力できるLLVM IRに低レベル化するsea-of-nodes IRでよく使っていました。MLIRは当時存在しませんでした。Javaの高レベル構造をモデル化するには、MLIRは良い選択肢だったでしょう。例えば、プロパティアクセスはNullPointerExceptionをスローします。私が作成した高レベルIRにはnull-checkのようなノードが含まれており、そこから多くのLLVM IRノードを生成していました。カスタムMLIRダイアレクトを使用すれば、これをLLVM IRユニバース内で表現できます[6]。当初は… ⟶ Parser ⟶ IR ⟶ Optimizer ⟶ Codegen ⟶ LLVM IR ⟶ …という同じパターンで行こうと考えていましたが、IRとOptimizerのアイデア全体をMLIRに置き換えることにしました。
Windowsでmeliorを動作させるのに時間がかかりました。幸いなことに、melior、mlir-sys、tblgen-rsにPRを作成しました。私がこれまでに対処した最悪のことの一つは、*.instructions.mdという名前のファイルがリポジトリにコミットされたことです。そして、NTFSはファイル名に*を好まないことをご存知でしょう。この全サガの詳細は省きますが、面白い事実があります:Rustがx64をターゲットにしていた頃、私は最初にx86 LLVMをコンパイルしました。LLVMのコンパイルにどれだけ時間がかかるかを知っていれば、それがどれほどの時間の無駄だったかがわかるでしょう。
これを終えたので、コードから最初のカーネルを生成し始めることができます。
MLIRによるPTXの作成
c[i] = a[i] + b[i]という非常にシンプルなカーネルがPTXにあり、RustとMLIRが連携しています。論理的な次のステップは、MLIRでPTXを再作成して実行することです。
しかし、それほど単純ではありません。meliorは直接PTXに低レベル化できません。外部ツールmlir-optを使用することもできますが、それはMLIRをPTXに低レベル化してくれます。しかし、私はシンプルなことを求めています。すべてはLLVMに帰結します。面白いことに、このプロジェクトを開始したとき、inkwellを使ってプログラムでカーネルを作成し、PTXにコンパイルしました。MLIRモジュールを使用することで、それをLLVM IRに低レベル化し、NVPTXバックエンドを使用します。唯一の欠点は?まあ…前回LLVMをコンパイルしたときは、NVPTXターゲットアーキテクチャなしでした。3度目の正直です!
ソースコード ⟶ レキサー ⟶ パーサー ⟶ コードジェネレータ ⟶ MLIR ⟶ LLVM IR ⟶ NVPTX バックエンド ⟶ PTX ⟶ GPU
コードははるかに冗長になり始めるので、基本的なアイデアを以下に示します。
// PTXコードを文字列として生成する汎用関数。
// 実際の関数本体を埋め込むクロージャを受け取ります。
pub fn gen_ptx<'p, F>(ctx: &'p phobos_base::context::Context, body: F) -> anyhow::Result<String>
where
F: for<'c> FnOnce(
&'p phobos_base::context::Context,
&'c Context,
&Module<'c>,
) -> anyhow::Result<()>,
{
// MLIR セットアップ
let registry = DialectRegistry::new();
register_all_dialects(®istry);
let context = Context::new();
//...
let loc = Location::unknown(&context);
let module = Module::new(loc);
// 関数本体を埋め込む
body(&ctx, &context, &module)?;
// MLIRからPTX(文字列)を生成
lower_mlir_to_ptx(&ctx, &context, module)
}
// MLIRでc[i] = a[i] + b[i]のPTXコードを再作成する
fn build_add_ir<'a>(
_: &'a phobos_base::context::Context,
ctx: &'a Context,
module: &Module<'a>,
) -> anyhow::Result<()> {
let loc = Location::unknown(ctx);
let i32t: Type = IntegerType::new(ctx, 32).into();
let f32t = Type::float32(ctx);
let idx_t = Type::index(ctx);
let mem_space: Attribute = IntegerAttribute::new(IntegerType::new(ctx, 64).into(), 1).into();
let memref_t: Type = MemRefType::new(f32t, &[i64::MIN], None, Some(mem_space)).into();
// ... ここで全ての命令を追加します ...
let gpu_module = OperationBuilder::new("gpu.module", loc)
.add_attributes(&[(
Identifier::new(ctx, "sym_name"),
StringAttribute::new(ctx, "kernels").into(),
)])
.add_regions([gpu_mod_region])
.build()?;
module.body().append_operation(gpu_module);
Ok(())
}
run_on_gpu(gen_ptx(ctx, build_add_ir));
フェーズ1: 生成されたMLIR
これは多くの方法で達成できます。gpuとmemrefダイアレクトを早期に使用したかったのです。memref<?xf32, 1>は次のように述べています:アドレス空間1の未知の次元を持つf32型があります。
memref<1024xf32, 1>と言うこともできますが、ベクトルのサイズは(まだ)わかりません。
module {
gpu.module @kernels {
gpu.func @add(%arg0: memref<?xf32, 1>, %arg1: memref<?xf32, 1>, %arg2: memref<?xf32, 1>, %arg3: i32) kernel {
// i = blockIdx.x * blockDim.x + threadIdx.x
%thread_id_x = gpu.thread_id x
%block_id_x = gpu.block_id x
%block_dim_x = gpu.block_dim x
%0 = arith.index_cast %thread_id_x : index to i32
%1 = arith.index_cast %block_id_x : index to i32
%2 = arith.index_cast %block_dim_x : index to i32
%3 = arith.muli %1, %2 : i32
%4 = arith.addi %3, %0 : i32
// i_index = i as usize
%5 = arith.index_cast %4 : i32 to index
// i < n
%6 = arith.cmpi slt, %4, %arg3 : i32
cf.cond_br %6, ^bb1, ^bb2
^bb1: // pred: ^bb0
// load a[i_index] and b[i_index]
%7 = memref.load %arg0[%5] : memref<?xf32, 1>
%8 = memref.load %arg1[%5] : memref<?xf32, 1>
// a + b
%9 = arith.addf %7, %8 : f32
// assign to c[i_index]
memref.store %9, %arg2[%5] : memref<?xf32, 1>
cf.br ^bb2
^bb2: // 2 preds: ^bb0, ^bb1
gpu.return
}
}
}
フェーズ2: MLIRの低レベル化
memref引数はそれぞれ合計5つに展開されることがわかります。理由は、この小さな例ではmemrefは過剰ですが、それでも良い学習演習だからです。
単一のfloatポインタptrの代わりに、(ptr, align_ptr, offset, size, stride)があります。
例えば、memref.load %arg0[%5] : memref<?xf32, 1>は、element_ptr = align_ptr + (offset + stride * INDEX) * sizeof(element)という擬似コードに展開されます。この場合、型がf32なのでsizeof(element) = 4です。offset=0, stride=1なので、element_ptr = align_ptr + (offset + stride * INDEX) * sizeof(element) = align_ptr + (0 + 1 * INDEX) * 4となり、element_ptr = align_ptr[INDEX * 4]となります。
memref型のレイアウトは実際にはoffset=0, stride=1を指定しています。これらはコンパイル時定数なので、追加の引数は使用されませんが、ABIの一部です。
module {
gpu.module @kernels [#nvvm.target<O = 3, chip = "sm_75", features = "+ptx90">] {
llvm.func @add(%arg0: !llvm.ptr<1>, %arg1: !llvm.ptr<1>, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: !llvm.ptr<1>, %arg6: !llvm.ptr<1>, %arg7: i64, %arg8: i64, %arg9: i64, %arg10: !llvm.ptr<1>, %arg11: !llvm.ptr<1>, %arg12: i64, %arg13: i64, %arg14: i64, %arg15: i32) attributes {gpu.kernel, nvvm.kernel} {
%0 = nvvm.read.ptx.sreg.tid.x : i32
%1 = llvm.sext %0 : i32 to i64
%2 = nvvm.read.ptx.sreg.ctaid.x : i32
%3 = llvm.sext %2 : i32 to i64
%4 = nvvm.read.ptx.sreg.ntid.x : i32
%5 = llvm.sext %4 : i32 to i64
%6 = llvm.trunc %1 : i64 to i32
%7 = llvm.trunc %3 : i64 to i32
%8 = llvm.trunc %5 : i64 to i32
%9 = llvm.mul %7, %8 : i32
%10 = llvm.add %9, %6 : i32
%11 = llvm.sext %10 : i32 to i64
%12 = llvm.icmp "slt" %10, %arg15 : i32
llvm.cond_br %12, ^bb1, ^bb2
^bb1: // pred: ^bb0
%13 = llvm.getelementptr inbounds|nuw %arg1[%11] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, f32
%14 = llvm.load %13 : !llvm.ptr<1> -> f32
%15 = llvm.getelementptr inbounds|nuw %arg6[%11] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, f32
%16 = llvm.load %15 : !llvm.ptr<1> -> f32
%17 = llvm.fadd %14, %16 : f32
%18 = llvm.getelementptr inbounds|nuw %arg11[%11] : (!llvm.ptr<1>, i64) -> !llvm.ptr<1>, f32
llvm.store %17, %18 : f32, !llvm.ptr<1>
llvm.br ^bb2
^bb2: // 2 preds: ^bb0, ^bb1
llvm.return
}
}
}
フェーズ3: MLIRからLLVM IRへ
これはmlir_sys::mlirTranslateModuleToLLVMIRToStringが提供するものです。この時点でLLVMの領域に戻ります。
; ModuleID = 'LLVMDialectModule'
source_filename = "LLVMDialectModule"
define ptx_kernel void @add(ptr addrspace(1) %0, ptr addrspace(1) %1, i64 %2, i64 %3, i64 %4, ptr addrspace(1) %5, ptr addrspace(1) %6, i64 %7, i64 %8, i64 %9, ptr addrspace(1) %10, ptr addrspace(1) %11, i64 %12, i64 %13, i64 %14, i32 %15) {
%17 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
%18 = sext i32 %17 to i64
%19 = call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
%20 = sext i32 %19 to i64
%21 = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
%22 = sext i32 %21 to i64
%23 = trunc i64 %18 to i32
%24 = trunc i64 %20 to i32
%25 = trunc i64 %22 to i32
%26 = mul i32 %24, %25
%27 = add i32 %26, %23
%28 = sext i32 %27 to i64
%29 = icmp slt i32 %27, %15
br i1 %29, label %30, label %37
30: ; preds = %16
%31 = getelementptr inbounds nuw float, ptr addrspace(1) %1, i64 %28
%32 = load float, ptr addrspace(1) %31, align 4
%33 = getelementptr inbounds nuw float, ptr addrspace(1) %6, i64 %28
%34 = load float, ptr addrspace(1) %33, align 4
%35 = fadd float %32, %34
%36 = getelementptr inbounds nuw float, ptr addrspace(1) %11, i64 %28
store float %35, ptr addrspace(1) %36, align 4
br label %37
37: ; preds = %30, %16
ret void
}
; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare noundef range(i32 0, 1024) i32 @llvm.nvvm.read.ptx.sreg.tid.x() #0
; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare noundef range(i32 0, 2147483647) i32 @llvm.nvvm.read.ptx.sreg.ctaid.x() #0
; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare noundef range(i32 1, 1025) i32 @llvm.nvvm.read.ptx.sreg.ntid.x() #0
attributes #0 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
!llvm.module.flags = !{!0}
!0 = !{i32 2, "Debug Info Version", i32 3}
フェーズ4: 生成されたPTX
これは手動で生成したPTXコードに非常に似ています。成功です!LLVM IRがNVPTXバックエンドで低レベル化されたものです。
//
// Generated by LLVM NVPTX Back-End
//
.version 9.0
.target sm_75
.address_size 64
// .globl add
.visible .entry add(
.param .u64 .ptr .global .align 1 add_param_0,
.param .u64 .ptr .global .align 1 add_param_1,
.param .u64 add_param_2,
.param .u64 add_param_3,
.param .u64 add_param_4,
.param .u64 .ptr .global .align 1 add_param_5,
.param .u64 .ptr .global .align 1 add_param_6,
.param .u64 add_param_7,
.param .u64 add_param_8,
.param .u64 add_param_9,
.param .u64 .ptr .global .align 1 add_param_10,
.param .u64 .ptr .global .align 1 add_param_11,
.param .u64 add_param_12,
.param .u64 add_param_13,
.param .u64 add_param_14,
.param .u32 add_param_15
)
{
.reg .pred %p<2>;
.reg .b32 %r<9>;
.reg .b64 %rd<8>;
mov.u32 %r1, %tid.x;
mov.u32 %r2, %ctaid.x;
mov.u32 %r3, %ntid.x;
mad.lo.s32 %r4, %r2, %r3, %r1;
ld.param.b32 %r5, [add_param_15];
setp.ge.s32 %p1, %r4, %r5;
@%p1 bra $L__BB0_2;
ld.param.b64 %rd4, [add_param_1];
ld.param.b64 %rd5, [add_param_6];
mul.wide.s32 %rd6, %r4, 4;
add.s64 %rd1, %rd4, %rd6;
add.s64 %rd2, %rd5, %rd6;
ld.param.b64 %rd7, [add_param_11];
add.s64 %rd3, %rd7, %rd6;
ld.global.b32 %r6, [%rd1];
ld.global.b32 %r7, [%rd2];
add.rn.f32 %r8, %r6, %r7;
st.global.b32 [%rd3], %r8;
$L__BB0_2:
ret;
}
PTXをGPUで実行するのは、上記のcustの例をコピー&ペーストするだけで簡単です。追加のパラメータがあります。
ソースコード ⟶ レキサー ⟶ パーサー ⟶ コードジェネレータ ⟶ MLIR ⟶ LLVM IR ⟶ NVPTX バックエンド ⟶ PTX ⟶ GPU
右から左に進むのは本当に気に入っています。早期に物事を確認し、検証できます。Windows上のRustでMLIRとLLVMをすべて動作させるのは困難でした。
しかし今、私たちは本当にソースコードから始める必要があります。
Phobos言語の紹介
このプロジェクトを開始したきっかけは、Simon Boehm氏のブログ記事「How to Optimize a CUDA Matmul Kernel」でした。単純な行列乗算が70倍も向上するのを見て魅了されました。
GEMMはGeneral Matrix Multiplication (C = \alpha A B + \beta C) の略です。SGEMMはSingle-Precision General Matrix Multiplicationの略です。すべての型は32ビット浮動小数点数です。
Simonは、単純なSGEMM実装の例を以下のように示しています。
__global__ void sgemm_naive(int M, int N, int K, float alpha, const float *A,
const float *B, float beta, float *C) {
// このスレッドが担当するCの位置を計算します
const uint x = blockIdx.x * blockDim.x + threadIdx.x;
const uint y = blockIdx.y * blockDim.y + threadIdx.y;
// MまたはNが32の倍数でない場合に必要となる条件です。
if (x < M && y < N) {
float tmp = 0.0;
for (int i = 0; i < K; ++i) {
tmp += A[x * K + i] * B[i * N + y];
}
// C = α*(A@B)+β*C
C[x * N + y] = alpha * tmp + beta * C[x * N + y];
}
}
心配しないでください。このブログ記事全体をここで再現するつもりはありません。それは素晴らしいものです。ぜひ読んでください。重要なのはこれです。
私は、彼が説明している最適化の一部を私のコンパイラで有効にしたいと考えています。少なくともある程度は。もちろん、少し異なる構文のCUDAクローンを書いても構いません。パイプラインは設定されており、機能するでしょう。しかし、この形式のコードは、私たちが実行したい最適化に対して敵対的です。
ディープラーニングは基本的にマップリデュースのようなものだと常々考えていましたが、行列を介して。計算をタイルレベルで扱うのが理にかなっていると思いました。テンソルコアは結局のところ (M \times N \times K) の処理ユニットです。 (M \times N \times K) GEMMを考えると、多くの最適化は、(M' \le M \land N' \le N \land K' \le K) の値を持つ小さな (M' \times K') および (K' \times N') 行列を計算することです。適切な値の選択は、実際のハードウェア仕様に依存します。したがって、ローカル(テンソルコアを可能な限りビジーに保つ)に適用される最適化と同じ最適化が、データセンターにも(ノードを可能な限り飽和させるように)スケーリングします。
これは私のアイデアではありません。ローカルレベルで同じことを行うTriton言語が存在します。そしてもちろん、NVIDIA CUTLASSもあります。これは、Python DSL(CuTe)の追加とともに、非常に高速なカーネルを作成するためのテンプレートのセットです。
サイドクエスト: TritonとPhobosの比較
TritonはPythonコードのASTをウォークし、カスタムMLIRダイアレクトを使用し、高度に最適化されたコードを生成できます。
Tritonでのベクトル加算は、次のように示されています[7]。
@triton.jit
def add_kernel(x_ptr, # *Pointer* to first input vector.
y_ptr, # *Pointer* to second input vector.
output_ptr, # *Pointer* to output vector.
n_elements, # Size of the vector.
BLOCK_SIZE: tl.constexpr, # Number of elements each program should process.
# NOTE: `constexpr` so it can be used as a shape value.
):
# 複数の「プログラム」が異なるデータを処理しています。どのプログラムかを特定します。
# ここでそれを特定します。
pid = tl.program_id(axis=0) # 1Dローンチグリッドを使用するため、軸は0です。
# このプログラムは、初期データからオフセットされた入力を処理します。
# 例えば、ベクトル長が256でブロックサイズが64の場合、プログラムは
# 要素 [0:64, 64:128, 128:192, 192:256] をそれぞれアクセスします。
# オフセットはポインタのリストであることに注意してください:
block_start = pid * BLOCK_SIZE
offsets = block_start + tl.arange(0, BLOCK_SIZE)
# メモリ操作を境界外アクセスから保護するためのマスクを作成します。
mask = offsets < n_elements
# DRAMからxとyをロードします。入力がブロックサイズの倍数でない場合は、余分な要素をマスクします。
x = tl.load(x_ptr + offsets, mask=mask)
y = tl.load(y_ptr + offsets, mask=mask)
output = x + y
# x + y をDRAMに書き戻します。
tl.store(output_ptr + offsets, output, mask=mask)
Phobos版のベクトル加算は、コメントを無視すればほとんど同じように見えます。
@autotune(BLOCK in [1024])
kernel add(a: tensor<f32>[N], b: tensor<f32>[N], c: tensor<f32>[N]) {
let base = program_id(0) * BLOCK
c[base :+ BLOCK] = a[base :+ BLOCK] + b[base :+ BLOCK]
}
PhobosはTritonとは異なり、はるかにシンプルで機能が少なく、予期せぬ方法で壊れる可能性があります。例えば、テンソルは4の倍数でなければならず、ブロックサイズは32で割り切れる必要がありますなど。これは学習演習であり、本番グレードの言語ではなく、既存の言語を1対1で再現する意味はありません。
Tritonが単独でやらないことは、クラスタリングです。
GPUパフォーマンス
GPUはその並列性のおかげで高速であることは誰もが知っています。しかし、それはF1カーのようなものです。レースに勝つには熟練したドライバーが必要です。ハードウェアの潜在能力を最大限に引き出す必要があります。トレーニングに何千ものGPUを費やすなら、リソースを可能な限り効率的に使用したいはずです。
GPUの入門から始め、メモリレベルとストリーミングマルチプロセッサ(SM)上の協調スレッド配列(CTA)での実行の概念を理解しましょう。
CTAは、スレッド間で同期できるスレッドのグループ[8]です。GPUはCTAをSMにスケジュールし、別のSMには移動しません[9]。SMにはオンチップ共有メモリがあります。
CTA内では、ワープと呼ばれるスレッドのサブセットが、古典的にロックステップ(SIMT)で同じ命令を実行します[10]。
次に、さまざまなメモリ領域を理解する必要があります。
- グローバルメモリ: 重みをアップロードする場所です。グローバルメモリの読み取りは、約300〜600サイクルと遅いです。物理的にはDRAMです。私のカードのようなコンシューマーカードではGDDR、データセンターパーツではHBM(High-Bandwidth Memory)です。
- 共有メモリ: これはSM上のCTAごとのメモリであり、スレッド間で共有できます。グローバルメモリよりもはるかに高速ですが、それでも約20〜30サイクルかかります。物理的にはSRAM(Static Random-Access Memory)でバックアップされています。
- レジスタ: レジスタは物理的に個々のスレッドに割り当てられ、最も高速なメモリ(約1サイクル)です[11]。これらは、ALUやテンソルコアなどの実行ユニットに直接供給される正確なデータフラグメントを保持します。
(C = \alpha \times (A \times B) + \beta \times C) を計算するには、(A)の各行を(B)の各列と乗算する必要があります。問題は、これら両方がグローバルメモリに存在することですが、それは遅いです。実際、単純なカーネルはメモリバウンドになります。なぜなら、実行ユニットは必要なデータをグローバルメモリから取得するよりもはるかに速く数学演算を計算できるからです。
GPUを可能な限りビジーに保ちたいのですが、これはALUとテンソルコアに常にデータを供給できることを保証することで達成されます。しかし、それはそれほど単純ではありません。
Phobosで使用している4つの主要なテクニックを以下に示します。
- Coalescing(合体): ワープ内の32スレッドがランダムな順序でメモリを読み取ると、最大32回の個別のメモリフェッチが発生します。GPUは、アクセスが連続している場合にそれを検出し、必要なトランザクションの最小数に合体させることができます。
- Tiling(タイリング): 共有メモリタイルにデータをプリフェッチすることで、グローバルメモリからのフェッチを削減できます。
- Warp Tiling(ワープタイリング): 共有メモリタイルは、レジスタの再利用を最大化するために、マイクロタイルに再びワープ間でパーティション化されます。各ワープ内のメモリアクセスパターンは、同じメモリバンクへの同時アクセスを試みるワープ内の複数のスレッドがあるバンクコンフリクト[12]を回避するように構造化する必要があります。
- Tensor Cores(テンソルコア): (M \times N \times K) を計算するための特殊なハードウェア。通常のSIMT命令よりも数倍高速です。
これらのテクニックを実装するには、コンパイラはblockIdx.x * blockDim.x + threadIdx.xの算術演算を理解し、各スレッドが何を計算するかを導き出す必要があります。さらに、データポインタ(x * i + y)へのアフィンアクセスを証明し、ポインタがエイリアスするかどうか(A == B)、そして最終的にスレッド間で再利用されるロードを理解する必要があります。これは非常に困難です[13]。
しかし、これが言語によって暗黙的にモデル化されていれば、リバースエンジニアリングする必要はありません。
@autotune(TILE_M in [32, 128], TILE_N in [64, 256], TILE_K in [16, 64])
@launch(256)
@pipeline
@tensorcore
kernel sgemm(A: tensor<f32>[M, K],
B: tensor<f32>[K, N],
C: tensor<f32>[M, N],
alpha: f32,
beta: f32) {
let pm = program_id(0)
let pn = program_id(1)
var acc: tile<f32>[TILE_M, TILE_N] = 0.0
for kt in range(0, K, TILE_K) {
var a = A[pm * TILE_M :+ TILE_M, kt :+ TILE_K]
var b = B[kt :+ TILE_K, pn * TILE_N :+ TILE_N]
acc += dot(a, b)
}
let c_old = C[pm * TILE_M :+ TILE_M, pn * TILE_N :+ TILE_N]
C[pm * TILE_M :+ TILE_M, pn * TILE_N :+ TILE_N] = alpha * acc + beta * c_old
}
@autotuneを使用すると、TILE_Mを[32, 128]の範囲の定数にしたいと指定できます。- ファーストクラスの
tensor<f32>[M, K]は、サイズが不明な2次元テンソルがあることを指定します。これらは実行時にクエリします。 - スレッドIDの算術演算は、
xとy方向の移動方法を示すprogram_idイントリンシックによって抽象化されます。 tile<f32>[TILE_M, TILE_N]はCTA全体のタイルを宣言します。コードジェネレータはそれを共有メモリ、レジスタ、またはその両方に分割して配置します。for kt in range(0, K, TILE_K)は、ktを0からKまでTILE_Kずつ進めます。A[pm * TILE_M :+ TILE_M, kt :+ TILE_K]は、x: pm * TILE_M, y: kt, width: TILE_M, height: TILE_Kを持つAのサブタイルを選択します。acc += dot(a, b)は、2つのタイルのドット積であり、タイルに累積されます。C[pm * TILE_M :+ TILE_M, pn * TILE_N :+ TILE_N] = accは、完全なタイルを代入します。
スレッドを使用して個々の値を計算することはありません。実際、スレッドの概念全体が抽象化されています。代わりに、2Dタイルの算術演算を指定し、コードジェネレータが計算をスレッドに割り当てます。タイルがどのように読み書きされるか(メタルに対して)は、コードジェネレータ次第です。
さらに、TILE_M、TILE_N、TILE_Kは非常に興味深い最適化変数になります。例えば、TILE_M=16、TILE_N=16、TILE_K=16と設定すると、コードジェネレータは私の2080 SUPERのネイティブテンソルコアMMA命令にこのtile<f32>[16, 16]構造を直接マッピングできます[14]。
言語
セミコロンアレルギーなので、Goスタイルのセミコロン挿入を使用しています。A[startOffset : endOffset]はendOffsetが排他的な範囲であり、A[startOffset :+ numItems]はA[startOffset : startOffset + numItems]と同じです。それ以外は、本当に特別なことは何もありません。これは小さな言語です。@attributesがあり、それだけです。
コンパイラにはフェーズモデル、コンパイル単位、リンクはありません。単純なレキサーがパーサーに供給し、それがコードジェネレータに供給します。
コードジェネレータは、ASTを分析して適切な出力を選択するため、最も複雑な部分です。より高度なコンパイラでは、MLIRダイアレクトとカスタムパスを使用したり、別の中間表現を導入したりできます。繰り返しますが、物事をシンプルに保ちたいです。
ソースコード ⟶ レキサー ⟶ パーサー ⟶ コードジェネレータ ⟶ MLIR ⟶ LLVM IR ⟶ NVPTX バックエンド ⟶ PTX ⟶ GPU
ランタイム
これは全体像ではありません。実際、@autotuneアノテーションを見ました。カーネルは特定のユースケースに合わせてチューニングされるべきです。変更できるパラメータがいくつかあります。例えば、共有メモリ領域を定義するタイリングサイズや、ワープタイリングのパディングなどです。
アイデアは、これらのパラメータを指定し、パラメータセットごとにカーネルの異なるバージョンをコンパイルすることです。@autotune(M in [16, 64])を指定した場合、M = 16、M = 32、M = 64のカーネルバージョンを生成します。これはコードジェネレータと、渡される設定と密接に関連しています。最適な設定を見つけるために、すべての設定値のデカルト積を構築し、すべてをコンパイルしてベンチマークし、勝者を選びます。
私はこれを総当たり方式で行います。すべての設定を一度試してから、上位3つを選択し、それらでより長い評価を行います。多くの設定は私のGPUではコンパイルすらできません。TILE_M=256、TILE_N=256のアキュムレータは256 KBのライブデータを持ち、どこかにマテリアライズされる必要があります。両方のオプションには制限があります。レジスタにステージングすると、255レジスタ/スレッドの制限を超えます。共有メモリにステージングすると、BlackwellデータセンターGPUのSMあたり228 KBさえ超えます[15]。
これらすべてを終えて、パフォーマンスにはかなり満足していると言えます。
このプロジェクトに取り組むほど、最適化を追加するほど、探索空間は大きくなりました。現在の
@autotuneパラメータを超えて探索していません。例えば、レジスタ圧力は別の主要な軸だと学びました。タイルのサイズを大きくしたり、アンローリングをより積極的に行ったりすると、スレッドあたりのレジスタ使用量が増え、ローカル再利用が改善される可能性がありますが、SM上に常駐するCTA/ワープの数を減らすこともあります。その占有率のトレードオフは、パフォーマンスに大きな影響を与える可能性があります。
クラスタリング
[画像: Introducing Clustering]
ディープラーニングをマップリデュースのように考えていたことを覚えていますか?現在、ファーストクラスのタイルで達成していることは基本的に次のとおりです。
入力 M x N ⟶ HBM M x N ⟶ SRAM M/m0 x N/n0 ⟶ ワープ ⟶ テンソルコア ⟶ ワープ ⟶ SRAM ⟶ HBM ⟶ 出力 M x N
テンソルコアは私たちの原子であり、可能な限り最小の単位です。
さらにステップを追加して、データはGPUの目的のためには(M \times N)ですが、実際にははるかに大きいと考えることができます。GPUは、はるかに大きなデータセンター規模のスーパータイルのはるかに小さなサブタイルを受け取るだけです。
以前は、テンソルコアをビジーに保つことが重要でした。そして、ピークパフォーマンスを達成するために、SRAMとHBMのレイテンシーを回避します。
今はHBMをビジーに保つことが重要であり、ディスクやネットワークのレイテンシーを回避する必要があります。
同じソースが2回コンパイルされます。言語全体がスケールフリーです。追加の@cluster(TILE_M in [...], ...)アトリビュートは、@autotuneのデバイスタイルよりもさらに上のタイリングレベルを宣言します。同じシンボル名が再利用されます。ソースコードは2つの異なるパスにコンパイルされます。
- AST ⟶ デバイスコードジェネレータ ⟶ MLIR ⟶ PTX: ノードごとのカーネル
- AST ⟶ クラスターコードジェネレータ ⟶ クラスターIR: スーパータイル上の小さなデータフロープログラム
@cluster(TILE_M in [4096, 16384], TILE_N in [4096, 16384], TILE_K in [4096, 16384])
@autotune(TILE_M in [32, 256], TILE_N in [32, 256], TILE_K in [4, 32])
kernel sgemm(A: tensor<f32>[M, K], B: tensor<f32>[K, N], C: tensor<f32>[M, N], alpha: f32, beta: f32) {
// ...
}
スーパータイルはテンソルの大きな断片、例えば8192x8192 f32(256 MiB)であり、ネットワークを横断する唯一のものです(もし必要なら)。カーネルは同じですが、異なるスケールで解釈されます。program_idはスーパータイルのグリッドをインデックスし、スライス x[y:z]は(潜在的にリモートの)スーパータイルを参照します。
そして、カーネルは本当に同じです。@clusterは@autotuneと同じTILE_M、TILE_N、TILE_Kシンボルをバインドするため、クラスターコンパイラが配布するノードごとのカーネルは(ほぼ)元の本体です。唯一変更されるのはエピローグ、つまり最終的なストアです。なぜなら、各ノードは、結果全体ではなく、はるかに大きなスーパータイルの1つのKチャンクに貢献するからです[16]。
純粋なリダクション(C[..] = acc)の場合、それは文字通り1行です。=が+=になり、小さな合成された初期リーフが最初にスーパータイルをゼロにします。
完全なGEMMエピローグalpha*acc + beta*c_oldも同様に機能します。beta*c_old項は+=本体の中に含めることはできません。それは各Kチャンクで再適用されてしまいます。したがって、コンパイラはそれをループの外にホイストします。初期リーフはスーパータイルをbeta*C_origで一度シードし、チャンクごとのストアは暗黙のベータ値1でalpha*acc + c_old計算を維持します。
チャンク全体で合計すると、(\beta C_\text{orig}\ + \alpha \sum{A_k \times B_k} = \alpha \text{acc} + \beta C_\text{orig}) となります。同じ数学演算であり、アキュムレータがネットワークを横断することはありません。これは概念的なIRで示されている分割です。
実際の計算を行う本体は2回解釈されます。一度はデバイススケール(GPU上のCTA)で、もう一度はクラスター(ノード間のスーパータイル)スケールで。すべて同じASTから。
高スループットを達成するために、FLOP/バイトを計算し、それに応じてスーパータイルをスケーリングして、より高い算術強度を得ることができます。これもオートチューンと同様にチューニング可能です。
DAGコンパイラ
クラスターコードジェネレータは、問題の形状M, K, Nがサブミッション時にのみ到着し、ノードトポロジーを知らないため、パラメトリックなクラスターIRを発行します。
スケジューラはそれをALLOC、FETCH、COMPUTE、FREE(ストレージ境界でのLOAD/STOREを追加)の4つのプリミティブ命令の具体的なDAGにインスタンス化します。
その後、行う必要があるのは次のとおりです。
- 各タイルスライスをスーパータイルアラインメント(クラスターのスケルトン)またはイントラタイル(リーフ本体、または実際のカーネル)として分類します。アラインメントのみがこの情報を分割するために使用されます。
- ループでキャリーされるアキュムレータは、読み取り-変更-書き込み(RMW)スーパータイルパラメータに昇格され、スーパータイルのバージョン(t_k \to t_{k+1})のSSAにより、各命令の読み取り/書き込みセットが正確になります。そして、そのセットがDAGであり、それ以外は依存関係情報を運びません。これは昔ながらのコンパイラの定義-使用チェーン分析です。
- DAGにより、各スーパータイルの最後のコンシューマが明示されるため、ライフタイムは後方パスで推論でき、
FREEが配置されます。言語には所有権やライフタイムの構文はありません。すべてグラフから無料で抽出されます。
これは、各出力スーパータイルについて、Kをループして累積し、その後書き込むことを意味します。
// これはクラスターIRの概念的なアイデアです。
// スケジューラが実際のノードにLOAD、FETCH、...、ASSIGN命令を発行するために直接消費するため、
// このようにマテリアライズされることはありません。
cluster sgemm {
params: M, K, N // サブミッション時にバインド
super: SUPER_M, SUPER_N, SUPER_K // クラスターオートチューナーによってバインド
tensors:
A: f32[M, K] in
B: f32[K, N] in
C: f32[M, N] out
scalars:
alpha: f32
beta: f32
grid (pm, pn) in (M/SUPER_M, N/SUPER_N):
t_c_old = ref C(pm, pn)
// beta * C でアキュムレータをシードします
t_acc@0 = compute k_init(beta, t_c_old)
loop kt in 0 .. K/SUPER_K:
t_a = ref A(pm, kt)
t_b = ref B(kt, pn)
// alpha * A_k * B_k を実行中のCタイルに累積します。
t_acc@kt+1 = compute k_body(rmw t_acc@kt, t_a, t_b, alpha)
define C(pm, pn) = t_acc@last
}
4ノードクラスターでFlash Attention[17]を計算する際のスケジューラの計画を生成できます。
[画像: Lowered graph for FlashAttention]
各ノードはQをストレージから直接LOADし、出力を書き戻します。KとVタイルは最初のノードに割り当てられ、他のノードはDCN経由でそれらをFETCHします。これらは4つの独立したローカルプログラムです。各ノードは4つのクエリブロックを所有するため、KとVを一度ロードし、同じバッファからCOMPUTEします。それらのFREEは、2番目のブロックがそれらを使い終えるまで遅延されます。そのライフタイムはグラフの後方パスを通じて現れます。タイルが最後に使用されたときにFREEを挿入します[19]。そして、2番目のブロックのLOADは最初のブロックのCOMPUTEに依存しないため、ノードはそれらをプリフェッチします。これは、デバイスレベルの@pipelineで達成したオーバーラップと基本的に同じですが、レベルが1つ上です。
サブミッションは、入力、出力、カーネルパラメータを含む単純なジョブ記述を介して行われます。
source = examples/flash_attention.ph
dim Nq = 16384
dim Nk = 16384
dim D = 64
tensor Q = read f32 16384x64 file:///tmp/q.tensor
tensor K = read f32 16384x64 file:///tmp/k.tensor
tensor V = read f32 16384x64 file:///tmp/v.tensor
tensor O = write f32 16384x64 file:///tmp/o.tensor
scalar scale = f32 0.125
これはどこに位置づけられるか?
設計上の選択からいくつかの特性が現れました。
SYNCHRONIZEまたはバリア命令はありません。依存関係が同期メカニズムです。したがって、アウトオブオーダータスクエンジンを持っています。- スケジューラはクリティカルパスにありません。ノードの依存関係は常に同じノード上にあります。クロスノードエッジはすべてタイル空間にあります。コンシューマの
FETCHは、タイルが利用可能になるまでサーバー側(ノード上)でブロックされます。その待機が同期であり、スケジューラとのラウンドトリップはありません。プロデューサのFREEは、静的に既知のサーブカウントを待ちます。スケジューラはバッチ完了イベントのみをドレインします。その負荷は、構築により、命令ではなくセグメント+失敗の(O(\text{segments} + \text{failures}))であるべきです。 - タイル識別子は決定的であり、ノードが死んでも、失われたサブグラフを再実行すると同じタイルが生成されます( lineage モデル)[20]。
- 可能な場合、アキュムレータは同じノードに留まり、ネットワークを横断しません。
これは、Single Program, Multiple Data (SPMD) と Asynchronous Many-Task (AMT) の世界の中間に位置します。主にタスクベースの分散線形代数の系統、例えばPaRSEC、Legion、そして最も直接的にはNVIDIAのLegateに属します。タイルDAG、中央スケジューラ、そしてダンプノードがあります。ディープラーニングスタックが収束したSPMD+コレクティブモデル[21][22][23]ではありません。Phobosカーネルは全体プログラムであり、静的な形状とアフィンサブスクリプトを持つため、コンパイラはデータフロー全体を見て、事前にDAGを構築できます(そしてホイストトリックを実行します)。しかし、この設計は静的で密なDAGを前提としており、データ依存の形状やMoEスタイルのルーティングには再考が必要です。しかし、密なテンソル代数では、グローバル配置、推論されたライフタイム、正確な通信アカウンティング、そして lineage ベースのリカバリを提供します。これらはすべて(おそらく)SPMD下では困難です[24]。
[画像: Diagram of the Phobos cluster architecture]
ノード間FETCHを持つ2ノードのクラスターアーキテクチャのハイレベル概要。SVGを開くにはクリック
単一GPUで実行されるPhobosソースコードは、理論的にはGPUクラスターでも実行できます。SPMDと同様に、まったく同じコードがすべてのGPUで同時に実行されます(ただし、アウトオブオーダーですが)。依存関係があるため、もちろんすべてのノードが同じ論理的な同期ポイントに到達します。
依存関係、例えばフォワードパス⟶ リダクションの場合、暗黙的であり自動的に処理されます。ただし、クラスターランタイムによってマイクロ管理されるわけではありません。ノードはデータが必要なときに互いにFETCHし、データが不要であることがわかったときに(最後の依存関係が満たされたときに)FREEします。
したがって、私はAMTの暗黙的な依存関係管理とアウトオブオーダー実行を、スケジューラをクリティカルパスに置かずに持っています。しかし、SPMDのシンプルさも持ち合わせており、タイルに焦点を当てているため、同じコードがどこでも実行されます。タイルサイズは、ヒューリスティックとネットワーク速度対FLOP/バイトのようなパラメータに基づいて自動チューニングすることもできます。
クラスタープロトタイプ
スケジューラとノードデーモンを単一マシンで実行し、各ノードをVRAMの一部のサブセットのみを使用するように制約し、すべてgRPCで通信させることができます。データセンターは持っていないので、そこで止まるしかありません。しかし、コンパイラが1つのカーネルを再解釈するのはかなり満足のいくものです。スケジューラは現在、この設計では単一障害点(SPOF)です。水平スケーラブルにすることは可能でしょう。しかし、それはかなりの労力だと思います(咳 Pathways 咳)。
SGEMM N=20480 (M=N=K), super=10240 -> 2x2 grid = 4 supertiles, 4 nodes
on disk: 4.7 GiB of f32 (A+B+C)
plan: 72 instrs, peak resident 1.2 GiB/node -> arena 1.4 GiB/node
the shared GPU must hold 4 x 1.4 GiB = 5.6 GiB at once (operands replicate per node)
seeded A in 1.3s, B in 1.3s
[ 0.000s INFO] sched: node0 registered (tile server 127.0.0.1:61121)
[ 0.000s INFO] node0: attached to scheduler 127.0.0.1:61119, tile server 127.0.0.1:61121
[ 0.006s INFO] sched: node1 registered (tile server 127.0.0.1:61123)
[ 0.006s INFO] node1: attached to scheduler 127.0.0.1:61119, tile server 127.0.0.1:61123
[ 0.011s INFO] sched: node2 registered (tile server 127.0.0.1:61125)
[ 0.011s INFO] node2: attached to scheduler 127.0.0.1:61119, tile server 127.0.0.1:61125
[ 0.017s INFO] sched: node3 registered (tile server 127.0.0.1:61127)
[ 0.017s INFO] node3: attached to scheduler 127.0.0.1:61119, tile server 127.0.0.1:61127
[ 0.173s INFO] sched: planned 'matmul' supers=[("TILE_K", 10240), ("TILE_M", 10240), ("TILE_N", 10240)] ingest=DirectLoad budget=1440MiB nodes=4 segments/node=[1, 1, 1, 1] peak=1200MiB fetch=0MiB
[ 0.254s INFO] sched: compiled 2 leaf kernel(s)
[ 0.255s INFO] sched: waiting for 4 node(s) to register
[ 0.256s INFO] sched: 4 node(s) registered: ["node0=127.0.0.1:61121", "node1=127.0.0.1:61123", "node2=127.0.0.1:61125", "node3=127.0.0.1:61127"]
[ 0.257s INFO] sched: -> node0 issue segment 0 (18 instrs: 5 ALLOC, 4 LOAD, 3 COMPUTE, 1 STORE, 5 FREE; incr 1200MiB)
[ 0.259s INFO] sched: -> node1 issue segment 1 (18 instrs: 5 ALLOC, 4 LOAD, 3 COMPUTE, 1 STORE, 5 FREE; incr 1200MiB)
[ 0.260s INFO] node0: received segment 0 (18 instrs)
[ 0.260s INFO] sched: -> node2 issue segment 2 (18 instrs: 5 ALLOC, 4 LOAD, 3 COMPUTE, 1 STORE, 5 FREE; incr 1200MiB)
[ 0.261s INFO] node1: received segment 1 (18 instrs)
[ 0.261s INFO] node0: issue #1 ALLOC tile=0x20000000000000 shape=[10240, 10240]
[ 0.262s INFO] sched: -> node3 issue segment 3 (18 instrs: 5 ALLOC, 4 LOAD, 3 COMPUTE, 1 STORE, 5 FREE; incr 1200MiB)
[ 0.262s INFO] node2: received segment 2 (18 instrs)
[ 0.263s INFO] node1: issue #19 ALLOC tile=0x20000000000001 shape=[10240, 10240]
[ 0.266s INFO] node1: issue #21 ALLOC tile=0x0 shape=[10240, 10240]
[...]
[ 12.173s INFO] node0: D2H tile=0x20000000000000 400.0 MiB read back from VRAM, writing to file://C:\Users\joaeb\AppData\Local\Temp\phobos_cluster_correctness\C.bin
[ 12.173s INFO] node2: issue #51 FREE tile=0x3 serves=0
[ 12.175s INFO] node2: issue #52 FREE tile=0x10000000000002 serves=0
[ 12.176s INFO] node2: issue #53 STORE tile=0x20000000000002
[ 12.247s INFO] node2: D2H tile=0x20000000000002 400.0 MiB read back from VRAM, writing to file://C:\Users\joaeb\AppData\Local\Temp\phobos_cluster_correctness\C.bin
[ 12.447s INFO] node0: STORE #17 wrote 400.0 MiB to file://C:\Users\joaeb\AppData\Local\Temp\phobos_cluster_correctness\C.bin
[ 12.449s INFO] node0: issue #18 FREE tile=0x20000000000000 serves=0
[ 12.492s INFO] node2: STORE #53 wrote 400.0 MiB to file://C:\Users\joaeb\AppData\Local\Temp\phobos_cluster_correctness\C.bin
[ 12.494s INFO] node2: issue #54 FREE tile=0x20000000000002 serves=0
[ 12.495s INFO] sched: all 72 instructions accounted (72 retired, 0 abandoned)
dispatched + ran in 12.3s
check: 12 sampled entries, distributed vs CPU reference match (max rel err 2.2e-6)
信じてください: (20480 \times 20480) 行列の12サンプルを検証します。
私は少し奇妙な立場にいます。水平スケーラブルな(可能性のある)スケジューラが協調的な進行とリカバリを可能にしながら、ノードをマイクロマネージメントせず、したがってボトルネックになりにくいという考えは好きです。しかし、それを大規模で検証することはできません。アイデアは本当に「何をすべきかの青写真を提供します、さらにここに仕事をするチームメイトがいます。何か必要なら彼らに話しかけて、終わったら教えてください」 versus 「段階ごとに何をすべきかを正確に伝えます。何か必要なら教えてください。チームメイトと調整します」です。これは仕事に関して言えば、聞き覚えがあるかもしれません。あなたが最初のキャンプにいることを願っています。
中央集権的なスケジューリングは確かに容易ではありません。Pathways[22]が示したように。これは多大な労力であり、Googleのデータフロー言語であるPLAQUEについてもっと学ぶことは非常に興味深かったでしょう。しかし、それは執筆時点ではクローズドソースです。このブログ記事の執筆のために調査している間に、DISTAL[25]についても学びました。それは私の設計と最も近い先行技術とほぼ同じです。そしてSpDISTAL[26]を使えば、このような設計がスパースグラフ/MoEルーティングにさえ機能する可能性があるという希望があります。DISTALはLegion上で実行され、プログラミングモデルは確かに異なりますが、概念的なアイデアは似ています。
cuBLASに到達しましたか?
[画像: Results of phobos-bench]
私のGPUでのphobos-benchの結果。理論上のピークは仕様シート[27]からのものです。PhobosとcuBLASは、完全にメモリバウンドであるsaxpyで同じGFLOP/sを達成します。SGEMM fp16ベンチマークは、縮小精度ですがfp32アキュムレータを使用するテンソルコアを使用します。「不正行為」を参照してください。
autotune: long probe of the top 3
TILE_M=64 TILE_N=128 TILE_K=8: 16.69ms +/- 213.10µs
TILE_M=32 TILE_N=256 TILE_K=8: 17.48ms +/- 272.96µs
TILE_M=128 TILE_N=64 TILE_K=8: 18.43ms +/- 289.87µs
autotune winner: TILE_M=64 TILE_N=128 TILE_K=8
phobos sgemm_fp32: 16.69ms +/- 183.19µs
cublas sgemm : 12.66ms +/- 181.79µs
check: 16777216 elements, both correct
phobos: 8235.9 GFLOP/s, cublas: 10856.7 GFLOP/s
phobos / cublas: 1.32x / 75.86%
Phobosは、執筆時点でM=N=K=4096でのfp32 SGEMMのcublasSgemm_v2スループットの約76%に達しています。私が持っている2080 SUPERは、 fp32[27]で理論上11 TFLOP/sを達成できます。
サイドクエスト: 不正行為
autotune: long probe of the top 3
TILE_M=128 TILE_N=128 TILE_K=16: 18.83ms +/- 12.92ms
TILE_M=64 TILE_N=256 TILE_K=16: 7.46ms +/- 316.64µs
TILE_M=128 TILE_N=64 TILE_K=16: 8.49ms +/- 127.78µs
autotune winner: TILE_M=64 TILE_N=256 TILE_K=16
phobos sgemm_fp16tc_fp32acc: 7.34ms +/- 71.74µs
cublas sgemm : 12.78ms +/- 143.52µs
check: 16777216 elements, both correct
phobos: 18723.8 GFLOP/s, cublas: 10754.0 GFLOP/s
phobos / cublas: 0.57x / 174.11%
これはどうして可能なのでしょうか?テンソルコアを使用していますが、私の2080はfp16しか処理できません。テンソルコアにロードする前にデータをfp16にキャストし、計算を実行し、ロードしてfp32に戻します。アキュムレータはfp32のままですが、もちろん精度は失われます。テンソルコアを使用し、精度が低い状態で計算を行っていますが、cublasSgemm_v2はテンソルコアを使用せず、すべて32ビットで行っています。したがって、これは楽しみのためにのみ含めています。cuBLASよりも高速なことをしたとは主張しません。これはリンゴとオレンジの比較です。cublasHgemm、fp16バリアントは70 TFLOP/sです :) 私の純粋なfp16 GEMMは、実際のcuBLAS fp16の62%に達します。
難しいですが、ここで止めなければなりません。この時点で、収穫逓減の領域に入ります。試すべきアイデアはまだありますが、私の観点からはそれだけの価値はありません。例えば、ping-pongバッファリングとパイプライン処理を追加するためにいくらかトークンを消費しましたが、これはわずかなパフォーマンス向上をもたらしましたが、複雑さが雪だるま式に増えています。
さらに、最新GPUの多くの機能について読みましたが、それらは私の古い2080ではサポートされておらず、間違ったアイデアを追いかけているかもしれないと感じています。
ちょっとした余談: 私は止めることができず、さらに多くの
機能複雑さを追加しました。主にXORスウィズリングレジスタと、異なるテンソルコア命令への移行で、これは悪夢でした。このプロジェクトに数ヶ月費やしており、このブログ記事は開発日記のようなものでした。fp16のパフォーマンスは最近多くの時間を費やした部分ですが、再び、クールな機能の多くはAmpere+ GPUでしか利用できないことを学びました。しかし、今度こそ本当に止めます。
スケジューラとノードデーモンをマシンで実行し、ジョブをサブミットして完了するまで監視できます。つまり、「動作しています」。ただ、大規模で検証するためのGPUがありません。
コンパイラ開発に再び手を汚し、低レベルGPUの概念を探求し、MLIRでLLVMを新鮮な視点で見ることができたのは、私にとって非常に楽しい経験でした。自分自身を刺激し、典型的な「ああ、もう午前1時だ」という瞬間とともに、数晩コンピューターの前に座っていました。
このすべてをナビゲートし、通常は巨大な(企業)フレームワークの下に埋もれているトピックのエントリを見つけるのは難しいと感じました。私は私の目標を達成しました。トレーニング[28]と同じです。時間が必要です。他に方法はありません。ただ作業をするだけです。
Phobosのソースコードはgithub.com/joa/phobosで見つけることができます。
-
ptxas add.ptx -o add.cubinを実行し、cuobjdump --dump-sass add.cubinを実行すると、実際のマシンコードを確認できます。↩︎ -
今、はあなたにとって相対的かもしれません。最後にLLVMを真剣に使用したのは2016年頃で、MLIRは2019年に公開されました(Source)。↩︎
-
これはあなたが思うよりも役立ちます。インライン展開を再構築してLLVM最適化パスを使用するつもりはありませんでした。しかし、その時点で、私の高レベルノードはすべて失われていました。LLVMが特定の最適化を理解できることを願うしかありませんでしたが、高レベルノードが単にインライン展開されていれば、実装ははるかに簡単でした。↩︎
-
__shfl_syncのような命令は、ワープ内のスレッドレジスタ間で実際に値を共有することを可能にします。したがって、レジスタを「スレッドごと」と見なす必要はありません。↩︎ -
共有メモリは、等しいサイズのバンク(通常32バンク、各4バイト幅)に分割されています。これらは同時にアクセスできます。しかし、同じワープ内の複数のスレッドが異なるメモリアドレスを要求し、それらが同じバンクにマッピングされる場合、ハードウェアはそれらを並列に処理できません。要求はシリアル化されます。↩︎
-
Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning AbstractionsとPLUTO言語はこのルートをたどりました。用語はpolyhedral compilationです。↩︎
-
2080 SUPERにはf32テンソルコア命令がないため、まずf16に変換し、テンソルコアを起動してからf32に戻す必要があります。もちろん、これは損失のある変換です。↩︎
-
Kチャンクを単一パスカーネルとは異なる順序で合計するため、浮動小数点数の非結合性により、結果はビット同一ではなく、単一GPU参照に対してε-correctになります。これも興味深いことです。温度=0のLLMは、アキュムレータがネットワークを横断する場合、非決定的になります。なぜなら、リダクション順序は並列性によって異なるからです。しかし、FlashAttentionのようなほとんどのカーネルは、高スループットのためにすでに非決定的です。また、DASH: Deterministic Attention Scheduling for High-throughput Reproducible LLM Training — Qiang et al., 2026も参照してください。↩︎
-
FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness ↩︎
-
IOロードは依然として存在します。各ノードはストレージ/キャッシュにクエリする必要があります。↩︎
-
障害シナリオでこれがどのように機能するか疑問に思っている場合:
FREEはスケジューラによって取り消され、新しく修正されたFREEノードが発行されます。↩︎ -
SparkのResilient Distributed Datasetsは、 lineage ベースのリカバリを普及させました。失われたパーティションをチェックポイントからではなく、決定論的な計算グラフから再導出します:Resilient Distributed Datasets (Zaharia et al., NSDI 2012)。↩︎
-
検証するのは非常に困難です。Accelerating large-scale distributed neural network training with SPMD parallelismは、例えばSPMDデータ依存関係による計算停止を示唆しています。↩︎
-
Table 2. GeForce RTX 3080 vs GeForce RTX 2080 / 2080 Super; P.14 ↩︎ ↩︎
-
Physical :) ↩︎