Zigで行うテキスト処理の基本と応用!独自の文字列操作でパフォーマンスを最大限に引き出す方法

Zig言語のロゴと高速な文字列処理コードが浮かぶ近未来的なプログラミングのイメージ プログラミング言語

Zigで文字列を扱う際、他言語のように気軽に+で連結したり.split()を呼び出したりしていませんか? その裏側で発生する暗黙的なアロケーションこそ、パフォーマンスのボトルネックになることも。

Zigのテキスト処理は、アロケータを明示的に渡すという原則に集約されます。
文字列が[]u8というただのバイトスライスとして扱われるからこそ、どこでメモリが確保され、どこで解放されるのかを完全に制御できます。
GCに依存しないこの設計は、高速なパーサやログ処理基盤を構築する上で大きな武器になります。

本記事では、基本から応用までを一貫した視点で整理します。

  • ゼロコストな基本操作: std.memによる検索・比較・分割で不要なコピーを避ける方法
  • 所有権を意識した構築: ArrayListやArenaAllocatorを使い分けるバッファ戦略
  • 高速化のための応用: SIMDや独自のエンコーディング処理で限界を引き上げるテクニック

単なるAPIの使い方に留まらず、なぜその実装が速いのかという計算機科学的な背景から紐解いていきます。
既存の処理を数倍速くするヒントが、ここにあります。

  1. Zigの文字列はなぜ速いのか?設計思想と基本型を理解する
    1. 他言語と比較して分かるZigの文字列設計の優位性
    2. []u8と[]const u8の違いと所有権の考え方
    3. ヌル終端文字列とsentinel-terminated sliceの使い分け
  2. 基本を押さえる!Zigのテキスト処理で使う標準ライブラリ入門
    1. std.memによる検索・比較・分割の基本操作
    2. std.asciiとstd.fmtで実現する変換処理
  3. メモリ確保を制御する!効率的な文字列構築とアロケータ戦略
    1. ArrayListとArrayListUnmanagedで文字列を連結する方法
    2. ArenaAllocatorで一時的なテキスト処理を高速化する
    3. スタックとヒープを使い分ける最適なバッファ戦略
  4. 実践!Zigで高速な文字列検索・置換・分割を実装する方法
    1. Boyer-Moore法を超える?独自の検索アルゴリズム実装
    2. イテレータパターンでゼロアロケーションなsplitを実現する
  5. パフォーマンスを最大化する!独自の文字列操作とSIMD活用
    1. std.simdを使った複数バイト同時処理の基本
    2. comptimeで生成する最速の文字列マッチャー
    3. キャッシュ効率を意識したデータ構造設計
  6. 文字化けさせない!ZigでUTF-8とUnicodeを正しく扱う方法
    1. UTF-8バリデーションと不正なバイト列の検出方法
    2. コードポイント単位での正確な文字数カウントと走査
  7. エラーに強いテキスト処理!エラー処理とテストで堅牢性を高める
    1. エラー共用体とerrdeferでメモリリークを防ぐ
    2. ファジングとベンチマークで品質を担保する
  8. 応用編!Zigで作る高速CSVパーサとログ解析ツールの実例
    1. 状態機械で実装するゼロコピーCSVパーサ
    2. 数GB級のログを高速に処理するストリーミング解析
  9. まとめ:Zigのテキスト処理でパフォーマンスを最大限に引き出すポイント
    1. 1. 文字列は所有権とビューを分離して考える
    2. 2. アロケータをワークロードに合わせて使い分ける
    3. 3. 汎用から専用へ、そしてハードウェアを意識する
    4. 4. 堅牢性はパフォーマンスの一部である

Zigの文字列はなぜ速いのか?設計思想と基本型を理解する

Zigの文字列が[]u8のスライスとしてメモリ上に配置されている概念図

Zigの文字列処理が速い理由は、言語レベルで文字列という特別な型を用意していない点にあります。
文字列はあくまでu8のスライスに過ぎない。
だからこそ、どのようなメモリレイアウトで、どのようなコストが発生しているのかが完全に可視化されます。
隠れたアロケーションや暗黙的なコピーが存在しないことが、パフォーマンスを最大限に引き出す前提条件になるのです。

他言語と比較して分かるZigの文字列設計の優位性

他言語の文字列設計と比較すると、Zigの思想はより明確になります。

  • Go: 文字列はimmutableなstring型としてランタイムに管理されます。連結のたびに新しい領域が確保されるため、ループ内での処理はGCへの負荷に直結します
  • Rust: Stringと&strで所有権を厳密に管理し、安全性と速度を両立しています。非常に優れた設計ですが、ライフタイムという概念の学習コストが必要です
  • Zig: 文字列専用の型もGCもありません。すべてが[]u8と[]const u8というスライスと、アロケータの組み合わせで表現されます

つまり、Zigは「文字列処理のコストはプログラマが100%制御する」という立場を徹底しています。
自動的に行われる親切な処理が、予測不能なレイテンシを生まない。
この透明性が、特にパーサやプロトコル実装のようなホットパスで効いてきます。

[]u8と[]const u8の違いと所有権の考え方

Zigにおける文字列の本質はスライスです。
ここでの区別は極めて重要です。

[]const u8は、内容を変更できない読み取り専用のビューです。
文字列リテラル"hello"の型は*const [5:0]u8であり、通常は[]const u8として扱われます。
誰かの所有するメモリを借りて眺めているだけ、というイメージです。

一方[]u8は、内容の変更が可能な可変ビューです。
このスライスを書き換えると、背後にあるバッファ自体が変更されます。
所有権そのものはスライスが持つのではなく、バッファを確保したアロケータと、それを管理する構造体が持ちます。

const str: []const u8 = "hello"; // 読み取り専用ビュー
var buf: [16]u8 = undefined;
var mutable: []u8 = buf[0..5]; // 書き込み可能なビュー
@memcpy(mutable, str);

このように、ビューとバッファを分離して考えることが、Zigのメモリ安全なテキスト処理の第一歩になります。

ヌル終端文字列とsentinel-terminated sliceの使い分け

C言語との連携を考えると、ヌル終端の扱いは避けて通れません。
Zigではこれを型システムで表現します。

通常のスライス[]const u8は長さで管理され、終端に0は不要です。
しかしCのAPIに渡す必要がある場合は、センチネル付きスライス[:0]const u8を使用します。
この型は、長さに加えて最後の要素が0であることをコンパイラが保証してくれます。

型 終端の保証 主な用途
[]const u8 なし Zig内部での純粋なテキスト処理
[:0]const u8 0で終端 Cライブラリへの受け渡し
[*:0]const u8 0で終端、長さ不明 Cから受け取った文字列の参照

std.mem.spanでCポインタをZigスライスに、std.mem.sliceToで逆方向に変換できます。
必要な時だけ0終端を付与し、普段は長さ管理されたスライスで高速に処理する。
この切り替えを意識的に行うことで、安全性と相互運用性、そしてパフォーマンスを両立できるのです。

基本を押さえる!Zigのテキスト処理で使う標準ライブラリ入門

Zigの標準ライブラリstd.memを使った文字列操作のイメージ画像

Zigでテキスト処理を行う際、最初に向き合うべきはstd.mem、std.ascii、std.fmtの三つのモジュールです。
他言語のようにStringクラスにメソッドが大量に生えているわけではありません。
代わりに、バイト列に対する汎用的な操作が関数として提供されており、それを組み合わせて目的を達成する設計です。
この関数型的なアプローチは、余計なオブジェクト生成を防ぎ、処理の見通しを良くしてくれます。

std.memによる検索・比較・分割の基本操作

テキスト処理の8割はstd.memで完結すると言っても過言ではありません。
[]u8はあくまでメモリのビューなので、そこに意味を与えるのがこのモジュールです。

検索はindexOf系、比較はeqlやstartsWith、分割はsplitSequenceやtokenizeSequenceが担います。
特に重要なのは、これらの操作が基本的にアロケーションを発生させない点です。
splitの結果は元のスライスを指すスライスのイテレータとして返却されるため、巨大な文字列を分割してもメモリ確保のコストはかかりません。

よく使う操作の対応関係を整理します。

やりたいこと 使用する関数 コスト
部分文字列の検索 std.mem.indexOf(u8, haystack, needle) O(n*m)、アロケーションなし
前方一致・後方一致 std.mem.startsWith / endsWith O(m)、アロケーションなし
文字列の分割 std.mem.splitSequence イテレータ生成のみ
const haystack = "name=zig,lang=systems,ver=0.13.0";

var iter = std.mem.splitSequence(u8, haystack, ",");
while (iter.next()) |pair| {
    // pairは "name=zig" のような元の文字列へのビュー
    if (std.mem.indexOf(u8, pair, "=")) |pos| {
        const key = pair[0..pos];
        const value = pair[pos + 1 ..];
        _ = key;
        _ = value;
    }
}

このように、イテレータが返すのは常にビューです。
所有権の移動がないため、ループ内でも安心して使えます。
まずはstd.memの関数でどこまで実現できるか検討するのが、Zigらしい実装への近道です。

std.asciiとstd.fmtで実現する変換処理

検索や分割ができたら、次は変換です。
ここではstd.asciiとstd.fmtが中心的な役割を果たします。

std.asciiは、UTF-8を考慮しない高速なASCII専用の操作を提供します。
例えば大文字小文字変換は、toUpperやtoLowerが1バイト単位で完結するため非常に高速です。
プロトコルのヘッダ解析など、対象がASCIIと分かっている場合は、Unicode対応の重い処理を使う必要はありません。
適材適所の判断が重要です。

一方、より複雑な変換はstd.fmtが担います。
std.fmt.parseIntによる数値パースや、std.fmt.bufPrintによるバッファへの書き込みは、すべてアロケータ非依存で動作します。
出力先のバッファを呼び出し側が用意する形式なので、ここでも暗黙的な確保は発生しません。

const ascii = std.ascii;
var header = "Content-Type".*;
_ = ascii.lowerString(&header, "Content-Type");
// header は "content-type" に変換される

const num_str: []const u8 = "8080";
const port = try std.fmt.parseInt(u16, num_str, 10);

変換処理で意識すべきは、いつヒープを使い、いつスタックで完結させるかという点です。
bufPrintのようにスタック上の固定長バッファで足りるケースでは、わざわざアロケータを呼び出す必要はありません。
この見極めが、レイテンシの安定性に直結します。

メモリ確保を制御する!効率的な文字列構築とアロケータ戦略

Zigのアロケータを使って文字列バッファを効率的に構築する図

Zigのテキスト処理で最も本質的な違いは、文字列を連結する際にアロケータを必ず明示する点です。
他言語ではa + bで済む処理が、Zigでは誰のメモリを使って、どのように拡張するかをコードで表現する必要があります。
面倒に感じるかもしれませんが、この明示性こそがパフォーマンスを制御する最大の武器になります。
どこで確保し、どこで解放するかを設計できるからこそ、不要なコピーを排除できるのです。

ArrayListとArrayListUnmanagedで文字列を連結する方法

可変長の文字列を構築する際の定番がArrayListです。
内部的にバッファを持ち、必要に応じてアロケータ経由で拡張されます。

Zig 0.13以降では、ArrayListとArrayListUnmanagedの使い分けが重要です。

  • ArrayList: アロケータを内部に保持します。init時にアロケータを渡し、あとはappendするだけで使える手軽さがあります
  • ArrayListUnmanaged: アロケータを保持しません。appendのたびにアロケータを渡す必要がありますが、構造体自体が軽量で、所有権の移動が容易です

ライブラリのAPI境界ではUnmanaged版を採用することで、アロケータへの依存を呼び出し側に委譲できます。
どちらも最終的にtoOwnedSlice()で[]u8として所有権を取り出せます。

var list: std.ArrayListUnmanaged(u8) = .{};
defer list.deinit(allocator);

try list.appendSlice(allocator, "hello, ");
try list.appendSlice(allocator, "zig world");

const owned: []u8 = try list.toOwnedSlice(allocator);
defer allocator.free(owned);

このパターンは、JSONのシリアライズやSQLクエリの組み立てなど、長さが事前に分からないテキスト生成で威力を発揮します。

ArenaAllocatorで一時的なテキスト処理を高速化する

リクエスト処理やファイル1行ごとのパースのように、一時的に大量の小さい文字列が生成されるケースでは、個別にfreeするコストが無視できません。
そこで有効なのがArenaAllocatorです。

Arenaは、確保したメモリをまとめて一括で解放します。
deinitを呼ぶまで個々のfreeは実質的に何もせず、単にオフセットを進めるだけです。
そのため、アロケーションが極めて高速です。

var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
const tmp_alloc = arena.allocator();

// このスコープ内の大量のdupeやArrayListはすべて高速
const key = try tmp_alloc.dupe(u8, "some-key");
const val = try tmp_alloc.dupe(u8, "some-value");
_ = key;
_ = val;
// deferで一括解放

一時的なテキスト処理のライフサイクルが明確な場合、Arenaを使うことで解放漏れのリスクを下げつつ、速度も向上させることが可能です。

スタックとヒープを使い分ける最適なバッファ戦略

すべての文字列構築でヒープを使う必要はありません。
長さが予測可能な場合は、スタック上の固定長バッファで完結させるのが最も高速です。

Zigではstd.BoundedArrayやstd.heap.FixedBufferAllocatorがこの用途に適しています。

戦略 適用場面 利点
スタック固定バッファ 長さが数百バイト以下で確定している場合 アロケーションゼロ、最速
FixedBufferAllocator + ArrayList スタックを使いつつ動的なAPIを使いたい場合 フォールバック制御が可能
ヒープArrayList 長さが予測不能で大きい場合 柔軟性が高い

例えば、HTTPヘッダの組み立ては大抵512バイト以内に収まります。
わざわざヒープを使うよりも、スタックに1024バイトのバッファを用意してbufPrintする方が、キャッシュフレンドリーで高速です。
まずはスタックで試し、足りなければヒープにフォールバックする。
この二段構えの設計が、現実的なアプリケーションでの最適解になることが多いです。

実践!Zigで高速な文字列検索・置換・分割を実装する方法

Zigで高速な文字列の検索と置換アルゴリズムを実装するイメージ

標準ライブラリのindexOfは汎用的で十分に高速ですが、検索対象のパターンが固定されていたり、特定の文字集合での分割が頻発したりする場合には、専用の実装を用意することで桁違いの性能向上が望めます。
Zigは低レベルなメモリ操作とcomptimeを組み合わせられるため、アプリケーション固有のテキスト処理をゼロコストで特化させられます。

Boyer-Moore法を超える?独自の検索アルゴリズム実装

教科書的な高速検索アルゴリズムとしてBoyer-Moore法が知られていますが、現代のCPUでは必ずしも最速ではありません。
分岐予測の失敗やテーブル参照によるキャッシュミスが、むしろボトルネックになることもあります。

Zigでは、対象に合わせてアルゴリズムを選択できます。
例えば、区切り文字が1バイトのカンマやコロンであることが分かっているなら、std.mem.indexOfScalarはSIMD的に最適化されており、単純な線形探索よりも高速です。
さらに、パターン長が非常に短い場合は、素朴な実装の方が速いことすらあります。

より高度な例として、複数の区切り文字を同時に探すケースを考えます。
switchによるテーブル駆動のスキャナを自作することで、分岐を減らせます。

fn indexOfAny(haystack: []const u8, chars: []const u8)?usize {
    // 256要素のルックアップテーブルをスタックに構築
    var table: [256]bool =.{false} ** 256;
    for (chars) |c| table[c] = true;

    for (haystack, 0..) |c, i| {
        if (table[c]) return i;
    }
    return null;
}

このようなO(n)で定数時間のテーブル参照のみを行う実装は、CPUのプリフェッチと相性が良く、Boyer-Mooreのような複雑な前処理が不要な場面ではむしろ高速です。
理論上の計算量だけでなく、実際のハードウェア特性を考慮することが重要です。

イテレータパターンでゼロアロケーションなsplitを実現する

文字列の置換や分割で最もコストがかかるのは、結果を格納するためのアロケーションです。
Zigではイテレータパターンを自作することで、このコストを完全に排除できます。

std.mem.splitSequenceもイテレータですが、独自のロジック、例えばクォートを考慮したCSVの分割や、エスケープを考慮した置換では、自前のイテレータが必要です。
イテレータは元のスライスへのビューをnext()で返すだけの構造体として設計します。

const CsvIterator = struct {
    buffer: []const u8,
    index: usize = 0,

    fn next(self: *CsvIterator)?[]const u8 {
        if (self.index >= self.buffer.len) return null;
        const start = self.index;
        // 次のカンマまたは終端までをスライスとして返す
        if (std.mem.indexOfScalarPos(u8, self.buffer, self.index, ',')) |pos| {
            self.index = pos + 1;
            return self.buffer[start..pos];
        } else {
            self.index = self.buffer.len;
            return self.buffer[start..];
        }
    }
};

この実装では、ヒープアロケーションは一切発生しません。
呼び出し側はwhile (iter.next()) |field| {... }のように、借用したスライスをその場で処理できます。
置換処理も同様に、出力先のArrayListに直接書き込みながらイテレートすることで、中間文字列の生成を避けられます。
所有権を持たず、ビューを流す。
この原則を徹底することが、Zigで高速なテキスト処理を実現する核心です。

パフォーマンスを最大化する!独自の文字列操作とSIMD活用

SIMD命令で複数バイトを同時に処理して高速化するイメージ図

テキスト処理の最適化が一定の段階に達すると、1バイトずつ処理する逐次的なループが限界になります。
そこで登場するのがSIMDとcomptimeです。
Zigはこれらの低レベル最適化を、インラインアセンブリに頼らずとも安全に記述できる数少ない言語です。
コンパイラに意図を正しく伝えることで、ハードウェアのポテンシャルを最大限に引き出せます。

std.simdを使った複数バイト同時処理の基本

SIMDは、Single Instruction Multiple Dataの略で、1つの命令で複数のデータを並列に処理する仕組みです。
文字列処理では、例えば空白文字の検出や区切り文字の探索に有効です。

Zigのstd.simdは、ベクトル型を抽象化して提供します。
16バイトや32バイトをまとめてロードし、比較演算を一括で行えます。
スカラーでループするよりも、理論上数倍のスループットが期待できます。

const simd = std.simd;
const Vec = @Vector(16, u8);

fn countNewlinesSIMD(text: []const u8) usize {
    var count: usize = 0;
    var i: usize = 0;
    const chunk = text.len - @mod(text.len, 16);
    const splat_nl: Vec = @splat(@as(u8, '\n'));

    while (i < chunk) : (i += 16) {
        const v: Vec = text[i..][0..16].*;
        const mask = v == splat_nl;
        // maskのtrueの数を数える
        count += @popCount(@as(u16, @bitCast(mask)));
    }
    // 残りはスカラーで処理
    for (text[i..]) |c| if (c == '\n') count += 1;
    return count;
}

このように、ベクトル化可能な部分はSIMDで、端数はスカラーで処理するハイブリッドな実装が定石です。
コンパイラが自動でベクトル化してくれる場合もありますが、手動で@Vectorを使うことで確実に意図を反映できます。

comptimeで生成する最速の文字列マッチャー

comptimeはZig最大の特徴の一つです。
コンパイル時に分かっている情報、例えばHTTPメソッドがGETかPOSTかといった固定パターンの判定は、実行時に分岐するよりも、コンパイル時に最適な分岐木やジャンプテーブルを生成する方が高速です。

文字列リテラルの集合がcomptimeで与えられる場合、完全なハッシュテーブルやトライ木をコンパイル時に構築できます。

fn makeMatcher(comptime keywords: []const []const u8) type {
    return struct {
        fn match(s: []const u8) ?usize {
            inline for (keywords, 0..) |kw, idx| {
                if (std.mem.eql(u8, s, kw)) return idx;
            }
            return null;
        }
    };
}

const HttpMethod = makeMatcher(&.{ "GET", "POST", "PUT", "DELETE" });

inline forはコンパイル時に展開され、各キーワードとの比較が直列に並んだ、分岐予測に優しいコードになります。
実行時のハッシュ計算すら不要です。
設定ファイルのパースやキーワード検索など、パターンが固定の場面では極めて有効な手法です。

キャッシュ効率を意識したデータ構造設計

SIMDやcomptime以上に影響が大きいのが、キャッシュ効率です。
いくら演算を速くしても、メモリからデータが来なければCPUは待機します。

文字列処理でやってしまいがちなのが、ポインタの配列[][]const u8を大量に作ることです。
各スライスがヒープのあちこちを指していると、走査のたびにキャッシュミスが頻発します。

対策として有効なのは、SoA(Structure of Arrays)的な配置と、連続したバッファへの格納です。
例えば、すべてのトークンを一つの大きなArrayList(u8)に詰め、オフセットの配列だけを別に持つ構造にします。
データ本体が連続しているため、プリフェッチャが効きやすくなります。

高速なテキスト処理とは、突き詰めればメモリ階層をいかに効率よく使うかという問題に帰着します。
アルゴリズムの計算量だけでなく、データがメモリ上でどう並んでいるかを常に意識することが、最後の数十パーセントを絞り出す鍵になります。

文字化けさせない!ZigでUTF-8とUnicodeを正しく扱う方法

UTF-8のバイト列とUnicodeコードポイントの関係を示す解説図

Zigの文字列が[]u8であるという事実は、UTF-8を扱う上で大きな意味を持ちます。
多くの言語では文字列が内部でUTF-8やUTF-16としてバリデーションされていますが、Zigでは[]u8は単なるバイト列であり、UTF-8として正当であるかは保証されません。
この自由度は高速ですが、同時に文字化けの原因にもなります。
だからこそ、Unicodeを正しく扱うための知識が不可欠になるのです。

UTF-8バリデーションと不正なバイト列の検出方法

UTF-8は可変長エンコーディングです。
1文字が1〜4バイトで表現され、先頭バイトのビットパターンで後続バイト数が決まります。
外部からの入力、例えばファイルやネットワークからのデータは、必ずしも正しいUTF-8とは限りません。

Zigではstd.unicodeモジュールがバリデーションを担います。
utf8ValidateSliceはスライス全体が正当なUTF-8かを検証し、utf8ByteSequenceLengthは先頭バイトから期待されるバイト長を返します。

fn isValidUtf8(s: []const u8) bool {
    return std.unicode.utf8ValidateSlice(s);
}

fn detectInvalid(s: []const u8)?usize {
    var i: usize = 0;
    while (i < s.len) {
        const len = std.unicode.utf8ByteSequenceLength(s[i]) catch {
            return i; // 不正な先頭バイト
        };
        if (i + len > s.len) return i; // 途中で切れている
        if (!std.unicode.utf8ValidateSlice(s[i..][0..len])) return i;
        i += len;
    }
    return null;
}

このように、不正な箇所のインデックスを特定できれば、エラーを返すだけでなく、代替文字U+FFFDに置換するなどのフォールバック処理も実装できます。
入力は常に疑うという原則が、堅牢なテキスト処理の基本です。

コードポイント単位での正確な文字数カウントと走査

UTF-8のバイト長と、ユーザーが認識する文字数は一致しません。
"こんにちは"のバイト長は15ですが、コードポイント数は5です。
s.lenで文字数を数えてしまうのは、典型的なバグです。

正確なカウントには、std.unicode.Utf8ViewやUtf8Iteratorを使用します。
Utf8Viewはバリデーション済みのビューを提供し、iteratorでコードポイント単位に走査できます。

fn countCodepoints(s: []const u8)!usize {
    var view = try std.unicode.Utf8View.init(s);
    var iter = view.iterator();
    var count: usize = 0;
    while (iter.nextCodepointSlice(null)) |_| {
        count += 1;
    }
    return count;
}

ここで注意すべきは、コードポイントと書記素クラスタの違いです。
絵文字の👨‍👩‍👧‍👦は複数のコードポイントから構成されますが、見た目上は1文字です。
std.unicodeはコードポイントまでを扱い、書記素クラスタの分割はより高度なライブラリが必要です。

実用上の指針を整理します。

目的 使うべき方法 注意点
バイト長 s.len 最も高速、文字数ではない
コードポイント数 Utf8View + iterator バリデーションコストがかかる
表示幅の推定 外部ライブラリやwcwidth的な処理 全角・絵文字の考慮が必要

すべての文字列を常にUTF-8として扱う必要はありません。
内部的なプロトコル処理はASCIIやバイト列として高速に処理し、ユーザーに表示する最終段階でのみUTF-8として検証・整形する。
このレイヤー分けが、速度と正確性を両立させる現実的なアプローチです。

エラーに強いテキスト処理!エラー処理とテストで堅牢性を高める

Zigのエラー処理とテストで堅牢なテキスト処理を実装するイメージ

高速なテキスト処理は、正確でなければ意味がありません。
特にZigのように手動でメモリを管理する言語では、不正な入力や途中で発生するエラーがメモリリークやクラッシュに直結します。
パフォーマンスと堅牢性はトレードオフではなく、エラー処理を正しく設計することで両立できます。
Zigのエラー処理機構は、そのために用意されています。

エラー共用体とerrdeferでメモリリークを防ぐ

Zigの関数はエラー共用体!Tを返します。
例えば![]u8は、成功すれば[]u8を、失敗すればerrorを返します。
このエラーは値であり、例外のようにスタックを巻き戻しません。
そのため、エラー発生時に確保したリソースを誰が解放するかを明確にする必要があります。

そこで活躍するのがerrdeferです。
deferがスコープを抜ける際に必ず実行されるのに対し、errdeferはエラーで抜ける場合にのみ実行されます。
テキスト処理で複数のアロケーションが連続する場合に、部分的に確保したメモリを安全に解放できます。

fn parsePair(allocator: std.mem.Allocator, input: []const u8) !Pair {
    var key = try allocator.dupe(u8, input[0..3]);
    errdefer allocator.free(key); // 以降でエラーが起きたらkeyを解放

    var value = try allocator.dupe(u8, input[4..]);
    errdefer allocator.free(value); // さらにエラーならvalueも解放

    // 成功した場合はerrdeferは発動しない
    return Pair{ .key = key, .value = value };
}

このパターンは、確保と解放の対応関係を局所的に記述できるため、レビューが容易でリークしにくいコードになります。
複雑なパーサほど、errdeferの有無で品質が大きく変わります。

ファジングとベンチマークで品質を担保する

テキスト処理のテストで最も怖いのは、想定外の入力です。
空文字列、巨大な文字列、途中で切れたUTF-8、不正なエスケープ。
これらを手動で列挙するのは不可能です。

Zig 0.13以降では、std.testing.fuzzによるファジングが標準で利用できます。
ランダムなバイト列をパーサに投入し、クラッシュやリークが発生しないかを自動で検証できます。

また、性能劣化を検知するためにベンチマークも不可欠です。

test "fuzz parser - no crash" {
    const Context = struct {
        fn testOne(_: void, input: []const u8) !void {
            // クラッシュしないことだけを検証
            _ = parsePair(std.testing.allocator, input) catch {};
        }
    };
    try std.testing.fuzz({}, Context.testOne, .{});
}

test "benchmark - count newlines" {
    const text = "a\nb\nc\n" ** 1000;
    var timer = try std.time.Timer.start();
    const start = timer.read();
    _ = countNewlinesSIMD(text);
    const elapsed = timer.read() - start;
    std.debug.print("elapsed: {d} ns\n", .{elapsed});
}

堅牢性を高めるためのチェックリストを整理します。

  • エラー共用体の網羅: tryとcatchで全てのエラー経路をテストしているか
  • errdeferの配置: 複数回dupeやallocする関数で、途中の失敗時にリークしないか
  • ファジングの導入: 不正なUTF-8や極端に長い入力でパニックしないか
  • ベンチマークの継続的計測: 最適化が逆に遅くなっていないか、リグレッションを検知できているか

高速性は、どのような入力でも安全に動作するという信頼があってこそ価値を持ちます。
Zigの持つerrdeferやfuzzといった仕組みを活用し、性能と品質を両立させる実装を目指しましょう。

応用編!Zigで作る高速CSVパーサとログ解析ツールの実例

Zigで作った高速CSVパーサがログファイルを解析している画面イメージ

ここまでで学んだ基本操作、アロケータ戦略、SIMD、comptimeといった要素を組み合わせることで、実用的な高速ツールを構築できます。
ここでは代表的な例として、CSVパーサとログ解析ツールを取り上げます。
どちらもテキスト処理の性能がアプリケーション全体のスループットを決定する典型的なドメインです。

状態機械で実装するゼロコピーCSVパーサ

CSVは一見単純ですが、クォート内のカンマや改行、エスケープされたクォートを正しく扱う必要があります。
正規表現やsplitだけで処理しようとすると、エッジケースで破綻します。
堅牢かつ高速な実装には、状態機械が最適です。

状態機械では、現在の状態と次の1バイトから次の状態が決まります。
Zigではenumで状態を定義し、switchで遷移を記述します。
重要なのは、このパーサが一切アロケーションしない点です。
フィールドの値は元のバッファへの[]const u8スライスとして返却します。

const State = enum { start, unquoted, quoted, quote_in_quoted };

fn parseCsvLine(line: []const u8, out: *std.ArrayList([]const u8))!void {
    var state: State =.start;
    var field_start: usize = 0;
    var i: usize = 0;

    while (i < line.len) : (i += 1) {
        const c = line[i];
        switch (state) {
           .start => {
                if (c == '"') { state =.quoted; field_start = i + 1; }
                else { state =.unquoted; field_start = i; }
            },
           .unquoted => {
                if (c == ',') {
                    try out.append(line[field_start..i]);
                    state =.start;
                }
            },
           .quoted => {
                if (c == '"') state =.quote_in_quoted;
            },
           .quote_in_quoted => {
                if (c == '"') state =.quoted // "" はエスケープされた "
                else if (c == ',') {
                    try out.append(line[field_start.. i - 1]);
                    state =.start;
                }
            },
        }
    }
    if (state!=.start) try out.append(line[field_start..@min(i, line.len)]);
}

この実装は、1バイトずつ前向きにしか走査しないため、CPUの分岐予測とキャッシュに非常に優しい構造です。
comptimeで区切り文字をパラメータ化すれば、TSVや独自のフォーマットにも同じコードベースで対応できます。

数GB級のログを高速に処理するストリーミング解析

数GB級のログファイルをreadToEndAllocで一括で読み込むのは、メモリ効率が悪く現実的ではありません。
Zigではstd.fs.File.readerとBufferedReaderを組み合わせたストリーミング処理が定石です。

さらに、処理を高速化するためのポイントは三つあります。

  • ArenaAllocatorの再利用: 1行ごとにArenaをリセットし、一時的なdupeのコストをゼロに近づけます
  • SIMDによる高速な行分割: 改行コードの探索をstd.mem.indexOfScalarや自作のSIMDルーチンで行い、行の境界を高速に検出します
  • 並列処理: std.Thread.Poolでファイルをチャンクに分割し、各チャンクを独立してパースさせます。Zigのスライスはスレッド間で安全に共有できます
var file = try std.fs.cwd().openFile("access.log",.{});
defer file.close();

var buf_reader = std.io.bufferedReader(file.reader());
var reader = buf_reader.reader();

var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();

while (try reader.readUntilDelimiterOrEofAlloc(arena.allocator(), '\n', 8192)) |line| {
    defer _ = arena.reset(.retain_capacity);
    // lineはArena上のスライス、ここで高速に解析
    try processLogLine(line);
}

このパターンでは、最大メモリ使用量は1行の長さに抑えられ、GCの停止もありません。
ArenaAllocatorをretain_capacityでリセットすることで、2行目以降のアロケーションはほぼ発生しなくなります。
Zigの手動メモリ管理は、このようなストリーミング処理でこそ真価を発揮します。
数GBという規模でも、安定したレイテンシで処理し続けることが可能です。

まとめ:Zigのテキスト処理でパフォーマンスを最大限に引き出すポイント

Zigの高速なテキスト処理技術の要点をまとめた総括イメージ

本記事では、Zigにおけるテキスト処理の基本から応用までを、パフォーマンスを軸に整理してきました。
Zigの文字列処理は、一見すると低レベルで手間がかかるように見えます。
しかし、その手間の正体は、他言語では隠蔽されていたメモリ確保やコピーのコストを、プログラマが明示的に制御できるようにした結果です。
この透明性こそが、Zigが高速である最大の理由です。

最後に、実務でパフォーマンスを最大限に引き出すための要点を振り返ります。

1. 文字列は所有権とビューを分離して考える

Zigの文字列は[]u8というスライスです。
データを所有するのはアロケータであり、スライスはそれを借りて眺めるビューに過ぎません。
この分離を徹底することで、不要なdupeを避けられます。

  • 関数の引数は原則[]const u8で受け取る
  • 返す値が呼び出し元より長生きする場合のみallocator.dupeする
  • 一時的な結合にはArrayListUnmanagedを使い、所有権の移動はtoOwnedSliceで一度だけ行う

この原則を守るだけで、多くのプログラムでアロケーション回数は半分以下になります。

2. アロケータをワークロードに合わせて使い分ける

すべての場面でGeneralPurposeAllocatorを使う必要はありません。
ワークロードのライフサイクルに合わせてアロケータを選択することが、速度と安定性の鍵です。

ワークロード 推奨アロケータ 理由
1行ごとの一時的なパース ArenaAllocator 一括解放で解放コストがゼロに近い
固定長ヘッダの組み立て FixedBufferAllocator + スタックバッファ ヒープを一切使わず最速
長寿命な文字列の蓄積 ArrayList + GPA 柔軟に拡張可能

特にArenaAllocatorをretain_capacity付きでリセットするパターンは、ログ解析のようなストリーミング処理で絶大な効果を発揮します。

3. 汎用から専用へ、そしてハードウェアを意識する

まずはstd.memの汎用関数で正しく動く実装を作ります。
その上で、ボトルネックが明確になった箇所だけを特化させます。

  • 区切り文字が固定なら、indexOfよりもindexOfScalarやルックアップテーブルによる自作スキャナが高速
  • キーワード集合がcomptimeで確定しているなら、inline forで展開されたマッチャーを生成する
  • 大量のバイト列走査はstd.simdで16バイトずつ処理し、残りをスカラーで処理するハイブリッド実装にする
  • そして最も重要なのが、データの連続性です。ポインタの配列でキャッシュミスを起こすよりも、一つの連続バッファに詰めて走査する方が、SIMD化よりも効果が大きいこともあります

4. 堅牢性はパフォーマンスの一部である

いくら速くても、不正な入力でクラッシュしたりメモリリークしたりしては本番で使えません。

errdeferで確保と解放を局所的に対応させ、std.testing.fuzzで不正なUTF-8や巨大な入力を自動テストし、ベンチマークでリグレッションを検知する。
このサイクルを回すことで、どのような入力でも安全に、そして速く動き続ける実装が完成します。

Zigのテキスト処理は、言語が何も隠さないからこそ、学ぶことが多くあります。
しかし、一つ一つのコストを理解し、制御できるようになった時、他言語では到達できないレベルの効率性と予測可能性が手に入ります。
本記事で紹介したパターンを、ぜひご自身のプロジェクトで試してみてください。
小さなパーサから始めることで、Zigという言語の本当の強さが実感できるはずです。

コメント

タイトルとURLをコピーしました