コンパイラを凌駕する
Beating the Compiler (mattkeeter.com)
要約
現代ではコンパイラは非常に高度ですが、特定の状況、特にインタプリタのコード生成においては、コンパイラが最適でない場合があります。この記事では、Uxn CPUのインタプリタをRustで実装し、そのアセンブリ出力を分析することで、コンパイラによる最適化の限界を探ります。レジスタの使用や間接分岐などの最適化の可能性を検討し、最終的にはアセンブリ言語での手書き実装がパフォーマンス向上に繋がる可能性を示唆しています。
全文翻訳
コンパイラを凌駕する
現代では、アセンブリ言語を書くのは愚かな行為だと誰もが知っています。コンパイラは文字通りのエンジニア・センチュリー(数百年分のエンジニアリング工数)の成果であり、プロセッサのことをあなたよりもずっとよく知っています。
しかし、それでも――噂は耳にします。
古代の書物に記され、静かな酒場で囁かれ、過ぎ去った寺院の壁に書きつけられ、謎めいたテキストで示唆されている――その噂は特定の絵を描き出します。
コンパイラはインタプリタのコード生成が苦手であり、アセンブリ言語でインタプリタを書くことでそれを上回ることが可能である。
私は最近、256個のオペコードを持つスタックベースのアーキテクチャであるUxn CPU用の高速インタプリタRavenを作成しました。このインタプリタは、RAMからバイトを読み取り、適切な命令を選択するシンプルなループです。
impl Uxn {
/// Runs the VM starting at the given address until it terminates
#[inline]
pub fn run<D: Device>(&mut self, dev: &mut D, mut pc: u16) {
loop {
let op = self.ram[usize::from(pc)];
pc = pc.wrapping_add(1);
let Some(next) = self.op(op, dev, pc) else {
break;
};
pc = next;
}
}
/// Executes a single operation
#[inline]
fn op<D: Device>(&mut self, op: u8, dev: &mut D, pc: u16) -> Option<u16> {
match op {
0x00 => op::brk(self, dev, pc),
0x01 => op::inc::<0b000>(self, dev, pc),
0x02 => op::pop::<0b000>(self, dev, pc),
0x03 => op::nip::<0b000>(self, dev, pc),
0x04 => op::swp::<0b000>(self, dev, pc),
0x05 => op::rot::<0b000>(self, dev, pc),
0x06 => op::dup::<0b000>(self, dev, pc),
0x07 => op::ovr::<0b000>(self, dev, pc),
0x08 => op::equ::<0b000>(self, dev, pc),
0x09 => op::neq::<0b000>(self, dev, pc),
0x0a => op::gth::<0b000>(self, dev, pc),
0x0b => op::lth::<0b000>(self, dev, pc),
0x0c => op::jmp::<0b000>(self, dev, pc),
0x0d => op::jcn::<0b000>(self, dev, pc),
0x0e => op::jsr::<0b000>(self, dev, pc),
// ... etc
}
}
}
すべてのオペコードの実装はモノモルフィ化され、Uxn::run(..) の本体にインライン化されます。コンパイラは重要な値をレジスタに保持するのに十分賢いため、これは比較的高速です。リファレンス実装と比較して10〜20%の速度向上が見られます。
コンパイラが何をしているのか、そして私たちがそれよりも良くできるかどうかを調べるために、アセンブリを見てみましょう。コンテキストとして、Uxn CPUには4つの異なるメモリがあります。
- データスタック:
[u8; 256]とu8インデックス - リターンスタック: 同じ形式
- RAM:
[u8; 65535] - デバイスメモリ: 今回は無視します (
D: Device引数と共に)
評価中、プログラムカウンタ pc も追跡します。これはRAMをインデックスするために使用される u16 です。各サイクルで、RAMからバイトをロードし、適切なオペコードを呼び出します。一部のオペコードはRAMの読み書きもできるため、自己変更コードも可能です!
アセンブリを調べることで、どの値がどこに格納されているかをリバースエンジニアリングできます。データスタックのトップにある値をロードしてインクリメントする INC 操作を考えてみましょう。
; INC
0x100002d4c: ldrb w8, [x25] ; read the current data stack index
0x100002d50: ldrb w9, [x24, x8] ; read a byte from the data stack
0x100002d54: add w9, w9, #1 ; increment that byte
0x100002d58: strb w9, [x24, x8] ; write that byte back to the stack
0x100002d5c: b 0x100002d1c ; jump back to the dispatch loop
このアセンブリから、以下のことがわかります。
x25はデータスタックインデックスのアドレスです(値そのものではありません!)。x24はデータスタック配列のアドレスです。w9は一時レジスタとして使用されます。
同様に、リターンスタックのトップ値をインクリメントする INCr は、x22 と x23 がリターンスタックのデータとインデックスのアドレスであることを示しています。
JMP は、プログラムカウンタが w27 に格納されていることを示しています。
; JMP
0x100002eac: ldrb w8, [x25] ; read the current data stack index
0x100002eb0: ldrsb w9, [x24, x8] ; read a signed jump offset from the data stack
0x100002eb4: sub w8, w8, #1 ; decrement the data stack index
0x100002eb8: strb w8, [x25] ; write back the data stack index
0x100002ebc: add w27, w27, w9 ; apply the jump to our program counter
0x100002ec0: b 0x100002d1c ; jump back to the dispatch loop
最後に、ディスパッチループ自体も調べる価値があります。
0x100002d1c: and x10, x27, #0xffff ; mask pc to a u16
0x100002d20: ldr x8, [x20, #256] ; load RAM base from *mut Uxn
0x100002d24: ldrb w10, [x8, x10] ; load opcode byte from RAM
0x100002d28: add w27, w27, #1 ; increment pc
0x100002d2c: adr x11, #-96 ; load base for jump
0x100002d30: ldrh w12, [x27, x10, lsl #1] ; load per-opcode jump amount
0x100002d34: add x11, x11, x12, lsl #2 ; compute jump location
0x100002d38: br x11 ; jump into opcode implementation
コンパイラは256個のオフセット(それぞれ2バイトの値、lsl #1 で示される)のジャンプテーブルを生成しました。このテーブルからオペコード固有の値を取得してジャンプターゲットを計算し、オペコードの実装に間接分岐します。
デバッガでこれを実行し、実際のジャンプテーブルをダンプできます。
(lldb) disas -p -c3
raven-cli`raven_uxn::Uxn::run::had9dba0d7d1b5105:
-> 0x100002d30 <+236>: ldrh w12, [x27, x10, lsl #1]
0x100002d34 <+240>: add x11, x11, x12, lsl #2
0x100002d38 <+244>: br x11
(lldb) reg read x27
x27 = 0x0000000100170b10
(lldb) memory read -s2 -fu -c256 0x0000000100170b10
0x100170b10: 2923
0x100170b12: 31
0x100170b14: 36
0x100170b16: 40
0x100170b18: 44
0x100170b1a: 52
0x100170b1c: 28
0x100170b1e: 64
0x100170b20: 70
0x100170b22: 78
0x100170b24: 86
0x100170b26: 94
0x100170b28: 119
0x100170b2a: 102
0x100170b2c: 110
0x100170b2e: 125
; etc...
(確かに、これがオペコードごとの命令リストを生成した方法です)
アセンブリを見たところ、2つの非効率性の可能性がある点が際立っています。
- 一部の重要な値(スタックインデックス、RAMのベースアドレス)がレジスタではなくメモリに保持されています。例えば、
INCは現在のデータスタックインデックスを取得するために余分なロード操作が必要です。 - ディスパッチループは、オペコード固有の実装への単一の間接分岐を取ります。これは、分岐がほとんど予測不可能になることを意味します!
コードをプロファイリングすると、最もホットな命令はすべてディスパッチループにあります。ldrh は総実行時間の1/3以上を占めています!
[画像: screenshot of profiling info]
(プロファイラが時間を正しい特定の命令に帰属させているか確信はありませんが、雰囲気は確かにディスパッチがコストがかかることを示唆しています)
LuaJIT は、まさに高速インタプリタであり、アセンブリ言語で書かれています。Mike Pall は、その速度に寄与する要因として、状態をレジスタに保持することと間接スレッディングを特に挙げています。これらはアセンブリ言語でしか確実に達成できません。
コンパイラに非常に具体的なパターンを生成させるのは難しいため、独自のアセンブリ言語を書き始めることにしましょう。私のホームマシンはM1 Macbookなので、すべてのアセンブリはAArch64形式になります。実装は汎用レジスタを使用します。w* と x* が同じレジスタの32ビットビューと64ビットビューを参照することに注意してください。
レジスタ割り当て
最初の最適化は、すべての重要なデータをレジスタに格納し、余分なロードとストアを避けることです。私の実装では、9つのレジスタ(x0-x8)といくつかのスクラッチレジスタを使用します。
; x0 - stack pointer (&mut [u8; 256])
; x1 - stack index (u8)
; x2 - return stack pointer (&mut [u8; 256])
; x3 - return stack index (u8)
; x4 - RAM pointer (&mut [u8; 65536])
; x5 - program counter (u16), offset of the next value in RAM
; x6 - VM pointer (&mut Uxn)
; x7 - Device handle pointer (&DeviceHandle)
; x8 - Jump table pointer
; x9-15 - scratch registers
AArch64呼び出し規約では、入力引数は8つしか与えられないため、これらすべてをレジスタに入れて関数を直接呼び出すことはできません。C ABI形式のエントリポイントが必要になります(下記参照)。
間接スレッディング
2番目の最適化は、スレッドコードを使用してディスパッチループを排除することです。各オペコードの実装は、次のオペコードの実装へのジャンプで終わります。
オペコードはVM RAM内の単一バイトとして格納され、ベースアドレスは x4 です。関数ポインタの別のジャンプテーブルを作成し、そのアドレスをレジスタ x8 で渡します。Rust側では、そのテーブルは次のようになります。
extern "C" {
fn BRK();
fn INC();
fn POP();
fn NIP();
fn SWP();
fn ROT();
fn DUP();
fn OVR();
fn EQU();
// ...etc
}
const JUMP_TABLE: [unsafe extern "C" fn(); 256] = [
(BRK as unsafe extern "C" fn()),
(INC as unsafe extern "C" fn()),
(POP as unsafe extern "C" fn()),
(NIP as unsafe extern "C" fn()),
(SWP as unsafe extern "C" fn()),
(ROT as unsafe extern "C" fn()),
(DUP as unsafe extern "C" fn()),
(OVR as unsafe extern "C" fn()),
(EQU as unsafe extern "C" fn()),
(NEQ as unsafe extern "C" fn()),
// ... etc
];
アセンブリでは、VM RAM(x4)から現在のバイトを読み取り、それを使用してジャンプテーブル(x8)内のアドレスを選択し、そのアドレスにジャンプします。このディスパッチを行うマクロを定義しました。
.macro next
ldrb w9, [x4, x5] ; load the byte from RAM
add x5, x5, #1 ; increment the program counter
and x5, x5, #0xffff ; wrap the program counter
ldr x10, [x8, x9, lsl #3] ; load the opcode implementation address
br x10 ; jump to the opcode's implementation
.endm
これは関数ではなくマクロであることに注意してください。各オペコードの末尾に next を追加すると、このテキストに展開されます。
例えば、INC は次のようになります。
.global _INC
_INC:
ldrb w9, [x0, x1] ; read the byte from the top of the stack
add w9, w9, #1 ; increment it
strb w9, [x0, x1] ; write it back
next ; jump to the next opcode
LuaJITとは異なり、命令のデコードステップはありません。レジスタ引数はなく、単一バイトのオペコードがプログラムの動作を一意に定義します。
実装
他の255個のオペコードの実装は、ほとんどが単調作業です。特にエキゾチックなものはありません。良い、正直なアセンブリ言語です。
多くの場合、命令のグループに対するコードを生成するためにヘルパーマクロを使用します。
.macro binary_op op
ldrb w10, [x0, x1] ; read the top value from the data stack
pop ; decrement the data stack index (this is a macro!)
ldrb w11, [x0, x1] ; read the next value from the data stack
\op w10, w11, w10 ; do the actual math operation
strb w10, [x0, x1] ; write the result into the data stack
next
.endm
.global _ADD
_ADD:
binary_op add
.global _SUB
_SUB:
binary_op sub
.global _MUL
_MUL:
binary_op mul
.global _DIV
_DIV:
binary_op udiv
実装全体で約2400行になります。多く聞こえるかもしれませんが、その半分だけがユニークです。ほとんどのオペコードは2つのバリエーション(RETフラグありとなし)があり、使用されるスタックが異なるだけです。
C Shim
もちろん、私のプログラム全体が手書きのアセンブリ言語で書かれているわけではありません。残りの(Rust)実装からアセンブリ関数を呼び出す方法が必要です。これは、(Rustの)entry関数のように見え、(アセンブリの)aarch64_entryエントリポイント(C ABIと互換性があります)を呼び出します。
[画像: diagram showing entry points]
aarch64_entryに実際に何を渡すのでしょうか? 関数引数レジスタ(x0-x7)に渡すには状態が多すぎるため、必要なすべてを含むヘルパーオブジェクトを定義しました。
#[repr(C)]
pub(crate) struct EntryHandle {
stack_data: *mut u8,
stack_index: *mut u8,
ret_data: *mut u8,
ret_index: *mut u8,
ram: *mut u8,
vm: *mut core::ffi::c_void, // *Uxn
dev: *mut core::ffi::c_void, // *DeviceHandle
}
struct DeviceHandle<'a>(&'a mut dyn Device);
DeviceHandleは、&mut dyn Deviceがファットポインタであり、C関数に渡すには安全ではないため必要です。すべてのコンピュータの問題と同様に、これを間接参照の追加レベルで解決します。&mut dyn DeviceをDeviceHandleに入れ、そのアドレスを渡します。
アセンブリへの呼び出しは、EntryHandleオブジェクトを populate し、危険地帯に分岐する簡単な問題です。
// アセンブリで書かれたエントリポイントの宣言
extern "C" {
pub fn aarch64_entry(
h: *const EntryHandle,
pc: u16,
table: *const unsafe extern "C" fn(),
) -> u16;
}
pub fn entry(vm: &mut Uxn, dev: &mut dyn Device, pc: u16) -> u16 {
let mut h = DeviceHandle(dev);
let mut e = EntryHandle {
stack_data: vm.stack.data.as_mut_ptr(),
stack_index: &mut vm.stack.index as *mut _,
ret_data: vm.ret.data.as_mut_ptr(),
ret_index: &mut vm.ret.index as *mut _,
ram: (*vm.ram).as_mut_ptr(),
vm: vm as *mut _ as *mut _,
dev: &mut h as *mut _ as *mut _,
};
// SAFETY: do you trust me?
unsafe {
aarch64::aarch64_entry(&mut e as *mut _, pc, JUMP_TABLE.as_ptr())
}
}
aarch64_entryはアセンブリコードの手書きエントリポイントです。レジスタを並べ替えてオペコードに必要な場所に配置し、通常のnextマクロで実行を開始します。
.global _aarch64_entry
_aarch64_entry:
sub sp, sp, #0x200 ; make room in the stack
stp x29, x30, [sp, 0x0] ; store stack and frame pointer
mov x29, sp
// Unpack from EntryHandle into registers
mov x5, x1 ; move PC (before overwriting x1)
mov x8, x2 ; jump table (before overwriting x2)
ldr x1, [x0, 0x8] ; stack index pointer
ldr x2, [x0, 0x10] ; ret data pointer
ldr x3, [x0, 0x18] ; ret index pointer
ldr x4, [x0, 0x20] ; RAM pointer
ldr x6, [x0, 0x28] ; *mut Uxn
ldr x7, [x0, 0x30] ; *mut DeviceHandle
ldr x0, [x0, 0x00] ; stack data pointer (overwriting *EntryHandle)
; Convert from index pointers to index values in w1 / w3
stp x1, x3, [sp, 0x10] ; save stack index pointers
ldrb w1, [x1] ; load stack index
ldrb w3, [x3] ; load ret index
; Jump into the instruction list
next
最後に、終了時(BRKオペコード経由)には、データスタックとリターンスタックのインデックスを更新し、レジスタから対応するメモリ位置に値を移動する必要があります。
.global _BRK
_BRK:
; Write index values back through index pointers
ldp x9, x10, [sp, 0x10] ; restore stack index pointers
strb w1, [x9] ; save data stack index
strb w3, [x10] ; save return stack index
ldp x29, x30, [sp, 0x0] ; restore stack and frame pointer
add sp, sp, #0x200 ; undo our stack offset
mov x0, x5 ; return PC from function
ret
デバイスIO
DEI および DEO オペコードは「デバイスI/O」を実行し、システムに任意の周辺機器を接続できます。最も一般的な周辺機器セットはVarvaraシステムであり、CPUを実際のコンピュータにするために必要なすべて(画面、キーボードとマウスの入力、オーディオなど)を追加します。
Uxnの実装を汎用的に保つために、デバイス用のトレイトを定義しました。
/// Trait for a Uxn-compatible device
pub trait Device {
/// Performs the `DEI` operation for the given target
///
/// This function must write its output byte to `vm.dev[target]`; the CPU
/// evaluation loop will then copy this value to the stack.
fn dei(&mut self, vm: &mut Uxn, target: u8);
/// Performs the `DEO` operation on the given target
///
/// The input byte will be written to `vm.dev[target]` before this function
/// is called, and can be read by the function.
///
/// Returns `true` if the CPU should keep running, `false` if it should
/// exit.
#[must_use]
fn deo(&mut self, vm: &mut Uxn, target: u8) -> bool;
}
オペコードの実装は &mut dyn Device、つまりこのトレイトを実装するものを取得し、それにトレイトメソッドを呼び出します。
pub fn deo<const FLAGS: u8>(
vm: &mut Uxn,
dev: &mut dyn Device,
pc: u16,
) -> Option<u16> {
let mut s = vm.stack_view::<FLAGS>();
let i = s.pop_byte();
let mut run = true;
match s.pop() {
Value::Short(v) => {
let [lo, hi] = v.to_le_bytes();
let j = i.wrapping_add(1);
vm.dev[usize::from(i)] = hi;
run &= dev.deo(vm, i);
vm.dev[usize::from(j)] = lo;
run &= dev.deo(vm, j);
}
Value::Byte(v) => {
vm.dev[usize::from(i)] = v;
run &= dev.deo(vm, i);
}
}
if run {
Some(pc)
} else {
None
}
}
しかし、この関数はC ABIと互換性がありません。ジェネリックであり、トレイトオブジェクトを受け取るため、アセンブリのDEOオペコードから直接呼び出すことはできません。
オペコードがDEOおよびDEI関数を呼び出せるようにするために、再び多くのシムを記述しました。
#[no_mangle]
extern "C" fn deo_entry(vm: &mut Uxn, dev: &mut DeviceHandle) -> bool {
vm.deo::<0b000>(dev.0, 0).is_some()
}
#[no_mangle]
extern "C" fn deo_2_entry(vm: &mut Uxn, dev: &mut DeviceHandle) -> bool {
vm.deo::<0b001>(dev.0, 0).is_some()
}
#[no_mangle]
extern "C" fn deo_r_entry(vm: &mut Uxn, dev: &mut DeviceHandle) -> bool {
vm.deo::<0b010>(dev.0, 0).is_some()
}
// etc, 全てのDEI / DEOバリアントに対して16個の関数
関数の完全なパスは次のようになります。
[画像: diagram showing deo calls]
アセンブリ側では、1つの微妙な点があります。通常のオペコード処理中、データスタックとリターンスタックのインデックス値を x1 と x3 に保持します(&mut Uxn 内の元の値は変更しません)。関数を呼び出す前に、これらのレジスタを &mut Uxn 内の適切なメモリ位置に書き戻す必要があります。
シム関数を呼び出すためのアセンブリコードは次のとおりです。
.global _DEI
_DEI:
; We have to write our stack index pointers back into the &mut Uxn
ldp x11, x12, [sp, 0x10] ; restore stack index pointers
strb w1, [x11] ; modify stack index pointer
strb w3, [x12] ; modify return stack index pointer
; We're using caller-saved registers, so we have to back them up
stp x0, x1, [sp, #0x20] ; store register state
stp x2, x3, [sp, #0x30]
stp x5, x4, [sp, #0x40]
stp x6, x7, [sp, #0x50]
str x8, [sp, #0x60]
; set up our arguments, then call the shim function:
mov x0, x6 ; x0 = Uxn pointer
mov x1, x7 ; x1 = DeviceHandle pointer
bl _dei_entry
ldp x0, x1, [sp, #0x20] ; restore register state
ldp x2, x3, [sp, #0x30]
ldp x5, x4, [sp, #0x40]
ldp x6, x7, [sp, #0x50]
ldr x8, [sp, #0x60]
; The DEO operation may have changed stack pointers, so reload them here
ldp x11, x12, [sp, 0x10]
ldrb w1, [x11] ; update stack index pointer
ldrb w3, [x12] ; update return stack index pointer
next
パフォーマンス
インタプリタのパフォーマンスをテストするために、2つのCPU負荷の高いワークロードを使用しました。
fib.talを、最初の 35 個のフィボナッチ数列を出力するように変更したもの。mandelbrot.talを、%SCALEを#0020に設定したもの(672 × 512 画像をレンダリング)。
これらのプログラムは両方とも起動時にすべての計算を行うため、エントリベクトル(0x100)での時間を計測するインストルメンテーションを追加しました。
ここでは4つの異なる実装をテストしています。
uxnemuリファレンス実装。私のラップトップでネイティブに実行。- ベースライン
raven-uxnインタプリタ。私のラップトップでネイティブに実行。 - 最適化された
raven-uxnインタプリタ(手書きアセンブリ)。私のラップトップでネイティブに実行。 - ベースライン
raven-uxnインタプリタ。ブラウザで実行(WebAssemblyにコンパイル)。
これが、あなたが待ち望んでいたパフォーマンスデータです。
| インタプリタ | ターゲット | フィボナッチ | マンデルブロ |
|---|---|---|---|
uxnemu (リファレンス) | AArch64 | 1.57 s | 2.03 s |
raven-uxn (ベースライン) | AArch64 | 1.38 s | 1.56 s |
raven-uxn (アセンブリ) | AArch64 | 1.00 s | 1.10 s |
raven-uxn (ベースライン) | wasm32 | 2.54 s | 2.82 s |
3つの明確な傾向があります。
raven-uxnのベースラインインタプリタ(安全なRustで記述)は、リファレンス実装よりも高速です。これは以前の作業からわかっています。- アセンブリ実装は、ベースラインよりも約 30% 高速です!
- WebAssembly は、ベースラインと比較して約1.8倍の遅延を発生させます。
ABLATION TESTING
レジスタに値を保持することによる速度向上なのか、それとも各オペコードの末尾にディスパッチを追加すること(中央の分岐の代わりに)によるものなのかは明らかではありません。
next マクロを変更することで、後者を簡単にテストできます。
.macro next
b next_dispatch
.endm
next_dispatch:
ldrb w9, [x4, x5]
add x5, x5, #1
and x5, x5, #0xffff
ldr x10, [x8, x9, lsl #3]
br x10
これらの新しい結果をチャートに追加すると(「assembly*」として)、「次のようになります。
| インタプリタ | ターゲット | フィボナッチ | マンデルブロ |
|---|---|---|---|
raven-uxn (ベースライン) | AArch64 | 1.38 s | 1.56 s |
raven-uxn (アセンブリ) | AArch64 | 1.00 s | 1.10 s |
raven-uxn (アセンブリ *) | AArch64 | 1.34 s | 1.41 s |
中央集権化されたディスパッチは大幅な遅延であり、ベースラインインタプリタとほぼ同等に遅いです!これはまさに、「幸せな楽しい分岐予測器をからかうな」ということです。
うまくいかなかったこと
他にも多くの実験を行いましたが、速度は向上しませんでした。
- RAMを拡張して、ユーザーバイトとジャンプターゲットの両方を格納しました(つまり、RAMを
[u64; 65536]にしました)。ユーザーバイトはポインタのビット48〜54に格納されました。これらは未使用であり、データコンポーネントを使用しているかポインタコンポーネントを使用しているかに応じてマスキングとシフトを追加しました。これは明らかに遅くなりました。おそらくキャッシュフレンドリーではないためです(64 KiB + 1 KiBのジャンプテーブルではなく512 KiB)。 - すべてのオペコード実装を同じサイズにしました(最大のオペコード実装のサイズにパディングして
.balign 256)、ジャンプテーブルを完全に削除しました。これも遅くなりました。これもキャッシュフレンドリーではないためです。オペコード実装は合計16.6 KiBから64 KiBになります。
結論
インタプリタをアセンブリ言語で書くことが、楽しくてパフォーマンスも良いことを自分で証明しました!
同様のパフォーマンスをハイレベル言語で実現するための戦略があります。計算されたgotoとMassey Meta Machineはどちらも関連する先行技術です。
しかし、これらはどちらもRustでは実現できません。この素晴らしい記事を引用すると。
現時点では、Rustからコンパイルされたマシンコードで計算されたgotoまたは末尾呼び出し最適化を生成するポータブルな方法はありません。
明るい面としては、すべてのアセンブリコードをx86-64に移植するのは比較的簡単であるはずですが、それは誰かへの挑戦として残しておきます!
関連するコードはすべてGitHubにあり、nativeフィーチャーでゲートされています。uxn-cliおよびuxn-gui実行可能ファイルは、アセンブリインタプリタバックエンドを選択するために--nativeフラグを受け入れます。
楽しんでください!
公開後の注記
この記事はHacker Newsで議論されました。特にphireによる分岐予測の詳細な分析を楽しんでいました。
Dan Crossは、システムに関数を呼び出すのではなくasm!ブロックからaarch64_entryに分岐させることに成功しました。これにより、EntryHandleシムを削除できます。ここにコミットがあります。
彼はまた、JUMP_TABLEをアセンブリに移動することを提案しました。ここで実装されています。これは良い変更です。なぜなら、Rustコードから名目上extern "C"関数(実際にはそうではないもの)の多くを削除するからです。
Cliffの提案により、命令の最初(ジャンプしたりRAMを変更したりしない命令の場合)に次のオペコードをRAMからプリフェッチするテストを行いました。終了時(next内)ではなく。ここでの考えは、スタックへの書き込み(x0内)がRAM(x4内)を変更しないことをプロセッサが知らないため、ロードストアハザードを排除することでした。残念ながら、これは速くはありませんでした!
Danはまた、このPRでプログラムカウンタを(ラップアラウンドする)ポインタとして格納するテストを行いましたが、遅延が発生したと報告しました。