blog.dopana

戻る

過去数十年にわたり、システムプログラミング言語を選定するエンジニアは常に困難なトレードオフに直面してきました。

  1. C / C++ / Zig: 最大限のパフォーマンスと低レベルな制御が得られる反面、手動でメモリ(malloc / free)を管理しなければならず、use-after-freeやメモリリークといった深刻な脆弱性が常につきまといます。
  2. Go / Java / C#: ガベージコレクション(GC)によって安全性を手に入れたものの、stop-the-worldによる不確定なレイテンシスパイク、余分なCPU負荷、そしてポインタ追跡に伴うメモリ断片化を受け入れる必要があります。
  3. Rust: 所有権とボローチェッカー(Borrow Checker)によりGCなしでメモリ安全と速度を両立させました。しかし、開発者は難解なライフタイム注釈('a)、厳しい排他参照ルール(&mut)、複雑なデータ構造における頻繁な unsafe の利用という高い学習コストを強いられます。

こうした状況において、革新的なブレークスルーを提示するのが Goose 言語です。FlatBuffersの生みの親であり、ゲーム開発やGoogleでの豊富な実績を持つ Wouter van Oortmerssen 氏によって設計されたGooseは、「汎用ヒープアロケータなし、GCなし、ライフタイム注釈なしで完全なメモリ安全性を実現できる」 ことを証明しました。

[!NOTE] 結論(TL;DR): Gooseは汎用ヒープという概念そのものを排除しました。動的なデータはすべてコンパイラが静的に割り当てる データスタック(Data Stacks) 上に配置され、ポインタのインクリメント(bump)によって割り当てられ、スコープ終了時に単一命令で一括破棄されます。ポインタを介さないインライン(フラット)なメモリレイアウトにより、Gooseは最適化されたC++や安全なRustよりも高速かつ低メモリ消費で動作します。

1. メンタルモデル(ELI5):スマートな巻き物ポーチ#

Gooseが既存の言語とどのように根本的に異なるのか、日常の例えで理解してみましょう。

Goose: 単一の連続メモリバッファC++ / Rust / Go: 散乱する小箱とポインタPointerPointerPointerPointerOrder Struct (160 bytes)Heap String: aliceHeap Vector: Items ArrayHeap String: SKU-441Heap String: SKU-7Flat Order Block (29 bytes, 0allocations)[id][alice][SKU-441:2:1999][SKU-7:1:500]
  • 従来の言語(C++, Rust, Go): 勉強机に向かって作業する際、新しい道具(文字列や可変長配列)が必要になるたびに、部屋の隅に小さな段ボール箱(ヒープメモリ)を買い足し、机からその箱へ糸(ポインタ)を張り巡らせるようなものです。片付けの際は、すべての糸をたどって1つずつ箱を処分しなければなりません。もし糸が切れると、忘れ去られたゴミ(メモリリーク)になります。
  • Goose: くるくると広がる布製のツールポーチのようなものです。道具を追加したいときは、ポーチを少しだけ広げて、前の道具のすぐ隣に並べて置くだけです(ポインタの前進)。余計な糸も箱もありません。作業が終わったら、ポーチをクルッと一巻きするたった1つの動作で、100万個の道具が一瞬にして片付きます!

2. 独自のメモリ構造:データスタック(Data Stacks)#

一般的な言語が固定長用のスタックと可変長用のヒープにメモリを分けるのに対し、Gooseには ネイティブコールスタック と、コンパイラが静的に決定する有限個の データスタック(Data Stacks) しか存在しません。

2. スコープ終了時の一括解放1. メモリ割り当てと伸長スタック基底要素0 (参照 first)要素1要素N (スタック頂点)Pointer Bump (ゼロオーバーヘッド)CPU単一ストア命令 (ポインタをリセット)100万要素も1命令で瞬時に消滅

動作のメカニズム:#

  1. 各データスタックは広大な仮想アドレス空間(デフォルトで2GBの予約領域)であり、実際に書き込まれた分だけ物理メモリにコミットされます。
  2. 1つのデータスタックにつき、同時にアクティブになれる可変長データ(resizable value)は最大1つであり、常にスタックの最上位に位置します。
  3. 配列に要素を追加(push)する処理は、単にスタックポインタを前進させるだけです。容量(capacity)チェックも、メモリの再割り当て(realloc)も、メモリの移動も一切発生しません。
  4. その変数を囲むスコープが終了した瞬間、どんなに深くネストされた巨大なデータであっても、CPUの単一ストア命令でポインタを巻き戻すだけで解放されます。デストラクタ呼び出しもGCスキャンも不要です。
scratch.goose
for round in 3 {
    // 伸長専用配列: 割り当ては単なるポインタ前進
    var scratch: u8[>..] = [];
    for i in 100000 {
        scratch.push((i % 256) as! u8);
    }
    print("Round ", round, ": ", scratch.len, " bytes");
} // スコープを抜けると10万要素が一瞬でリセット!
rust

3. 核心的な違い:メモリが絶対に移動しない(Stable References)#

C++(std::vector<T>)やRust(Vec<T>)では、配列の容量が上限に達すると、ヒープ上に新しい大きなメモリ領域を確保し、全要素をコピーして古い領域を解放します(再配置)。

[!WARNING] この再配置により、配列内部を指していたポインタや参照は無効化(ダングリング参照)されます。Rustはこのバグを防ぐため、参照を保持したまま push することをコンパイル時に禁止しています。そのため、Rustではインデックス番号(u32)による間接参照を余儀なくされます。

Gooseでは、メモリが移動することは決してありません。そのため、配列が伸長しても、その内部要素を指す参照は安全に生存し続けます。

stable_ref.goose
struct Item { id: i32, weight: f32 }

var items: Item[>..] = [];
// 最初の要素への参照を直接取得
let first .= items.push(Item { 1, 0.5 });

// その後、100万個の要素を連続で追加
for i: i32 in 2..1000001 {
    items.push(Item { i, 0.0 });
}

// 100万回pushした後でも 'first' は完全に有効かつ安全に変更可能!
first.weight = 99.5;
rust

Gooseの push は新しく追加された要素への型付き参照をそのまま返します。これにより、配列を構築しながら要素同士を直接ポインタでリンクさせることが可能です。

4. ネストされたデータも完全にインライン配置(Flat Layout)#

複数の可変長フィールドを持つデータ構造のメモリサイズを比較してみましょう。

order_book.goose
struct Item  { sku: u8[varint], qty: varint, cents: varint }
struct Order { id: varint, customer: u8[varint], items: Item[varint] }

var book: Order[>..] = [];
book.push(Order {
    id: 1001,
    customer: "alice",
    items: [
        Item { sku: "SKU-441", qty: 2, cents: 1999 },
        Item { sku: "SKU-7",   qty: 1, cents: 500 }
    ]
});
rust

メモリ上のフットプリント比較:

言語使用される型構成メモリ消費量ヒープ割り当て回数
C++std::string + std::vector<Item>160 bytes1回のヒープ確保
RustString + Vec<Item>153 bytes4回のヒープ確保
Gooseu8[varint] + Item[varint]29 bytes0回(ゼロ確保)

Gooseでは、この注文データ全体がわずか 29バイト の連続したバイト列として格納され、ポインタは1つも含まれません。CPUはキャッシュミスを起こすことなく、リニアにデータを先読みして超高速に処理できます。

5. ライフタイム注釈なしで安全な参照を保証(No Lifetimes)#

Rustでは安全性の代償として 'a や 'b といった明示的なライフタイム注釈が必要ですが、Gooseは静的なルート(Static Root)を自動推論することで、注釈なしで安全性を担保します。

lifetimes.goose
fn longest(a: u8[:], b: u8[:]) -> u8[:] {
    if a.len >= b.len { a } else { b }
}

var outer: u8[>..] = [];
var w = outer[..];
{
    var inner: u8[>..] = [];
    format(inner, "inner text");
    w = longest(outer, inner);
    // コンパイルエラー: 'inner' に根ざす参照を保存しようとしましたが、
    // 'inner' は代入先 'w' より長く生存しません!
}
rust

コンパイラはすべての参照の出どころを追跡し、親となる所有者のスコープを超えるような参照の代入をコンパイル時に確実に拒絶します。

6. ポインタより細い相対参照(Relative References)#

通常の64ビットポインタは1つで8バイトを消費します。木構造やグラフ構造では、ポインタのメタデータだけでメモリの大部分が占有されてしまいます。

Gooseの 相対参照(Relative Reference):

  • Node&<u32>: ノード自身の位置からの相対オフセットを32ビット(4バイト)または16ビット(2バイト)で保持します。
  • これにより、データ構造全体が位置非依存(Position-Independent)になります。
binary_tree.goose
// 左右のリンクを含めてわずか12バイトの二分木ノード!
struct Node {
    key: i32,
    left: Node&<u32>?,
    right: Node&<u32>?
}
rust

バイト列の瞬時シリアライズ&ロード:#

データが位置非依存であるため、シリアライザを介さずにメモリ上のバイト列をそのままファイルへ保存・復元できます。

serialization.goose
// メモリイメージをバイト列として瞬時に保存
var image: u8[>..] = tree.to_bytes();

// 1パスで構造検証を行いながら高速復元
var loaded, ok = from_bytes<Node[>..]>(image);

// もしデータが破損していた場合...
image[image.len - 3] = 200;
var bad, bok = from_bytes<Node[>..]>(image);
// bokはfalseを返し、不正ポインタの生成を完璧にブロック!
rust

7. スタック展開のない多段エラー復帰#

Gooseは、関数の呼び出し階層をまたいで直接大元の呼び出し元へエラーを返却できる return err from func 構文を備えています。

中間関数で Result や ? を連鎖させる必要がなく、例外のようなスタックアンワインドの負荷も発生しません。

8. メモリ共有を排除した安全なマルチスレッド#

Gooseでは、スレッド間でのミュータブルなメモリ共有を完全に禁止することでデータ競合(Data Race)を排除しています。

  • 各 thread_fn は、自分専用のデータスタックとグローバル変数を持つ独立したプロセスのように動作します。
  • スレッド間の通信は、型付きキュー(qput, qget)を介して行われます。
  • 送信できるデータは参照を含まないフラットな値に限定されるため、スレッド間転送は高速な memcpy だけで安全に完了します。

9. 主要言語との包括的な比較表#

比較項目C / C++RustGoZigGoose
メモリ管理方式手動(malloc/free)所有権と借用ガベージコレクタ(GC)手動アロケータ静的データスタック(Bump)
汎用ヒープ領域ありありありありなし(完全ゼロヒープ)
空間的・時間的安全❌ UAFや漏れが発生✅ 安全(unsafe除く)✅ 安全(nilパニック有)❌ 手動(UAFリスク有)✅ 100%安全(unsafe不要)
ライフタイム注釈不要必須('a)不要不要不要(静的ルート推論)
伸長時の参照維持❌ 再配置で無効化❌ 借用規則で禁止❌ 再配置される❌ 再配置で無効化✅ 維持される(Stable)
ネストデータ配置ポインタによる分散ポインタによる分散ポインタによる分散ポインタによる分散連続インライン(Flat)
スコープ解放コストO(N)O(N) デストラクタO(N)O(N) デストラクタ不定期なGC停止O(N)O(N) アロケータ解放O(1)O(1)(単一ストア命令)
JIT・即時実行ビルドが遅いビルドが遅いビルドが高速ビルドが高速内蔵TinyCCで瞬時に実行

10. トレードオフと制約事項#

画期的な言語である一方、Gooseには明示的な設計上の制約も存在します。

  1. データ寿命の意識: データの所有者がどこにあり、どのスコープで生きるかを意識する必要があります。循環参照や非階層的なデータには、標準ライブラリの slot_pool や slice_pool を使用します。
  2. 再帰関数での可変長データ: 再帰の深い呼び出しをまたいで可変長配列(T[>..])を保持することはできず、事前に確保したプールを渡す必要があります。
  3. 可変長配列の順次走査: 要素サイズが可変(varint)の配列は、インデックスによる O(1)O(1) ランダムアクセス(array[i])ができず、先頭からの順次走査が基本となります。
  4. プログラム全体のコンパイル(Whole-program): コンパイラがスタックサイズや参照ルートを解析するため、プログラム全体の静的解析が必要です。

11. まとめ#

Gooseは、長らく常識とされてきた「汎用ヒープアロケータ」の存在に疑問を投げかけ、データスタック と フラットなメモリ配置 という明快なアーキテクチャによって、システムプログラミングの新たな地平を切り拓きました。

  • C++やRustを超える実測実行パフォーマンス
  • ピークメモリ消費量を1.3倍〜1.9倍削減
  • GCもライフタイム記法('a)も使わずに完全なメモリ安全性を達成

ゲームエンジン、リアルタイム処理、グラフィックス、組み込みなど、限界までパフォーマンスを引き出したいエンジニアにとって、Gooseは間違いなく注目に値する存在です。

参考文献#