手動メモリ管理は本当に必要？ ZigとRustから考える

システムプログラミング言語として近年注目されている ZigとRust。いずれも「C/C++に代わる低レイヤー言語」として開発が盛んですが、両者の設計思想は意外と大きく異なります。

本記事では、「手動メモリ管理」というキーワードを軸に、ZigとRustを比較していきます。なお、筆者は主にRustユーザであり、Zigの経験はまだ浅いため、Zigについては勉強しながら書いた内容であることをご了承ください。

## Rustがメモリ安全性を保証する仕組み

まずはRustから。Rustは所有権（ownership）と借用（borrowing）の仕組みを使い、コンパイラが参照やライフタイムをチェックします。よく知られているように、この仕組み（通称：borrow checker）のおかげで二重解放やダングリングポインタといったメモリバグをコンパイル時に排除できます。

### メリット:
* 安全性が高い
* マルチスレッドなど高並行な環境で、競合やメモリ破壊リスクを大幅に低減
* プログラム全体を通してのメモリ管理をコンパイラがサポートしてくれるので、大規模開発でも安心

### デメリット:
* 所有権やライフタイムの概念に慣れるのに学習コストがかかる
* すべてをコンパイラが管理できるわけではなく、「どうしても低レベルな制御が必要なケース」に遭遇する可能性はある

## unsafeブロック

Rustには「安全」な部分だけでは実現しにくい処理を可能にするため、unsafeブロックが用意されています。たとえば、

* OSやドライバなどで特定の物理アドレスに直接アクセスする
* C/C++ライブラリとの連携でポインタをやりとりする
* データ構造の配置やアラインメントをきっちり制御したい

こういった場面では、一時的にRustのコンパイラに「ここは手動で気を付けるから！」と伝え、メモリ安全チェックをオフにします。ただし、unsafe = "何でもできる代わりに自己責任"なので、ここでダングリングポインタや二重解放が生じてもコンパイラは警告してくれません。

ポイントは「unsafeは最小限の箇所だけ使う」ということ。たとえばハードウェアとのやりとりや特殊なメモリ操作を行う部分にだけunsafeを閉じ込めて、それ以外の部分は引き続き安全にRustコードを書きます。こうすることで、高い安全性と低レベル制御の両立が可能になります。

## Zigはあえて「何でも手動でやる」スタンス

ここからはZigについて。正直に言うと、筆者はまだZigを使い始めたばかりなので、もし「それは違うよ！」という点があればぜひご指摘いただけると助かります。以下は、現時点での学習内容を踏まえたまとめです。

Zigは Rustのような所有権システムやGC（ガーベジコレクション）を持ちません。Cさながら、プログラマ自身がヒープ領域の確保と解放を行う必要があります。たとえば、Zigで配列を動的に確保しようとすると、アロケータを指定して確保し、自分で解放するコードを書きます。

```zig
const std = @import("std");
pub fn main() !void {
    var allocator = std.heap.page_allocator;
    const array = try allocator.alloc(u8, 100);
    // arrayの利用
    allocator.free(array);
}
```

これはC/C++でmalloc/freeをやるのと似ています。バグるときはバグるし、オーバーランを起こそうと思えば簡単に起こせてしまいます。しかし、Zigは「言語レベルの余計な抽象を排除し、極力素の状態でコントロールできる」ことを重視している、というのが特徴のようです。

しかしZig にはコンパイル時やランタイムでの安全モードがあるようです。ランタイム安全モード（safety mode） では、配列アクセス時に範囲外アクセスを検知してパニックを起こすチェックが行われます。

デフォルト設定やビルドオプションによって挙動が変わる場合があるため、「まったく何もチェックしていない」というわけではありません。

### メリット:
* ランタイムやGCがないため、実行ファイルを小さくできる
* コンパイル時実行（CTFE）が強力で、メタプログラミングがシンプル
* クロスコンパイルが容易（Zigコンパイラ自身が多数のプラットフォームをサポート）

### デメリット:
* 安全性はプログラマの責任になる
* 所有権やライフタイムを言語が自動で見てくれるわけではないので、バグのリスクは高まる

## 「手動メモリ管理が必要なユースケース」って実際どんなもの？

### 1. リアルタイム性・高パフォーマンス重視

ゲームエンジンや組み込みシステムでは、ガーベジコレクションのような仕組みが決まったタイミングで走ると、フレーム落ちやデッドラインミスが発生する恐れがあります。自分でメモリ管理すれば、いつどこでメモリ確保や解放を行うかを完全に制御できるため、パフォーマンスの突発的な劣化が起こりにくいです。

### 2. OS・カーネル・ドライバなど超低レイヤー

OSやカーネルは、標準ライブラリすら使えない環境からスタートする場合が多々あります。そこではGCはもちろん、言語ランタイムにも依存できません。ハードウェアの物理アドレスへの読み書きを直接行う必要があり、あらゆるメモリ管理はプログラマが担うことになります。

### 3. メモリレイアウトの最適化

大規模なデータを扱うシミュレーションなどでキャッシュ効率を上げるため、配列を線形に配置したり、構造体をうまく並べてfalse sharingを回避したりといった微妙な最適化が必要な場合は、言語のメモリアロケーションがどう動くかを知っておくのが重要です。場合によっては自分でメモリプールを用意することがあります。

:::note info
コラム：False Sharingとパフォーマンス最適化




マルチスレッドプログラミングにおいて、時として目に見えないパフォーマンスの落とし穴に遭遇することがあります。その代表的な例の一つが「False Sharing（疑似共有）」です。

## False Sharingとは？

False Sharingは、異なるCPUコアで実行されているスレッドが、同じCPUキャッシュライン上の異なるデータにアクセスする際に発生する問題です。一見すると共有していないように見えるデータが、実はハードウェアレベルでは同じキャッシュラインに存在しているため、意図しない競合が発生してしまうのです。

以下のようなコードを見てみましょう：

```rust
struct Counter {
    value1: u64,  // スレッド1が使用
    value2: u64,  // スレッド2が使用
}
```

この`Counter`構造体では、`value1`と`value2`は異なるスレッドで独立して使用されることを意図しています。しかし、これらの変数は同じキャッシュライン（通常64バイト）に配置される可能性が高く、その場合にFalse Sharingが発生します。

## なぜパフォーマンスが低下するのか？

1. スレッド1が`value1`を更新すると、そのキャッシュラインは他のコアで無効化されます
2. スレッド2が`value2`にアクセスしようとすると、無効化されたキャッシュラインを再読み込みする必要があります
3. この無効化と再読み込みのサイクルが繰り返され、大きなパフォーマンスペナルティとなります

## 解決策

Rustでは、このような問題に対して以下のような対策が可能です：

```rust
use std::sync::atomic::AtomicU64;

#[repr(align(128))]  // 2つのキャッシュラインにまたがらないようにアライメントを指定
struct Counter {
    value1: AtomicU64,
    _pad: [u8; 120],  // パディングを追加
    value2: AtomicU64,
}
```

Zigでも同様のアプローチが可能です：

```zig
const Counter = struct {
    value1: std.atomic.Value(u64),
    _pad: [120]u8 = undefined,
    value2: std.atomic.Value(u64),

    pub fn init() Counter {
        return .{
            .value1 = std.atomic.Value(u64).init(0),
            .value2 = std.atomic.Value(u64).init(0),
        };
    }
};
```

## 最適化の重要性

False Sharingの問題は、特にハイパフォーマンスが要求されるシステムにおいて重要です。RustやZigのような低レベル言語を使用する場合、このようなハードウェアレベルの最適化を意識することで、大幅なパフォーマンス向上を実現できます。

ただし、過度な最適化は可読性を損なう可能性があるため、実際のパフォーマンス測定結果に基づいて判断することが重要です。プロファイリングツールを使用して、False Sharingが実際にボトルネックとなっているかを確認してから、最適化を適用することをお勧めします。

:::

## RustのunsafeとZig、どちらがいい？

「RustのunsafeブロックとZigの自由度は似ている」という意見があります。確かに、RustのunsafeブロックではZigやC同様にポインタを直接触ります。しかしこの2つには大きな違いがあります。

* Rust: 普段は安全な借用チェックがあり、バグを防いでくれる。必要な箇所だけunsafeを使う
* Zig: 言語全体が「unsafe」なイメージで、代わりに言語仕様はシンプル。その分ミスをしても自己責任

言い換えると、Rustはデフォルトで安全を担保しながら"ここだけ手動管理"を行えるのに対し、Zigは最初から全部手動管理してもOK、ただしミスをすると容赦なく落ちるというスタンスです。

## まとめ: 用途に応じて使い分けよう

* Zigは、低レベルの自由度を好み、ランタイムが一切不要な超軽量バイナリや、クロスコンパイルをサクサクしたい人に向いています。Cライクな感覚で書けるため、Cから移行しやすい一方、メモリ安全はすべてプログラマが責任を持つことになります。
  * ※筆者はまだZigを勉強し始めたばかりですが、非常にシンプルな思想が魅力だと感じています。

* Rustは、多人数開発や大規模プロジェクトなどで、コンパイラの持つ強力なメモリ安全機構（所有権システム）を活かしたい人に向いています。安全な部分はコンパイラに任せつつ、どうしても手動管理が必要な場面ではunsafeが使えるため、パフォーマンスと安全性のバランスが取りやすいのが魅力です。

どちらが優れているかは単純には言えません。「開発環境・要求性能・チーム構成に合わせて最適な選択をする」ことが大切です。もしメモリ管理の自由度を存分に発揮しなければならない極限環境を扱うならZigは有力な選択肢ですし、安全性や生産性を重要視するならRustが第一候補になるでしょう。

## 最後に

本記事は筆者自身がZigを使い始めたばかりの段階で書いているため、Zigの詳細についてはご意見・ご指摘を大歓迎しております。実際に使ってみて感じたことやRustと比較して気づいた点など、コメントをいただけるととても励みになります。

もし少しでも参考になれば幸いです！