eBPF・WASM・Rust・量子計算をPythonから一括ベンチマークするツールを作った

作ったもの

Rocky Linux サーバーで eBPF・WASM・Rust・量子計算・gRPC・ZeroMQ など14カテゴリを自動ベンチマーク＆最適化するツール。

$ sudo python3 ROCKY_ADAPTIVE_SYSTEM_V13_2.py

=== NOVE OS v13.2 "ULTIMATE FUSION" ===
実行時間: 39秒
最終スコア: 2269.01 / 3000 (75.6%) Grade B+

[ZeroMQ]      100 / 100 ✅ Perfect
[gRPC]        100 / 100 ✅ Perfect
[Edge]        100 / 100 ✅ Perfect
[Quantum]      99 / 100 ⭐
[Rust]         99 / 100 ⭐
[Spark]        87 / 100
[WASM]         80 / 100
[Redis]        80 / 100
...

---

各カテゴリの実装

1. ZeroMQ（100点）

ZeroMQ はソケット通信ライブラリ。Publisher-Subscriber パターンで高速メッセージングを計測。

import zmq
import time

def benchmark_zeromq():
    ctx = zmq.Context()

    # Publisher
    pub = ctx.socket(zmq.PUB)
    pub.bind("tcp://127.0.0.1:5555")

    # Subscriber
    sub = ctx.socket(zmq.SUB)
    sub.connect("tcp://127.0.0.1:5555")
    sub.setsockopt_string(zmq.SUBSCRIBE, "")

    time.sleep(0.1)  # 接続待ち

    msg_count = 10000
    start = time.perf_counter()

    for i in range(msg_count):
        pub.send_string(f"msg_{i}", zmq.NOBLOCK)

    received = 0
    while received < msg_count:
        try:
            sub.recv_string(zmq.NOBLOCK)
            received += 1
        except zmq.Again:
            break

    elapsed = time.perf_counter() - start
    throughput = received / elapsed  # メッセージ/秒

    # スコア計算: 50万msg/秒 = 100点
    score = min(100, throughput / 5000)
    return score

ポイント: NOBLOCK で送受信するとバッファリングが起きるため、実際のスループットより少なく見える。スコア計算の閾値設定が重要。

---

2. WebAssembly（80点）

Python から WASM を実行するには wasmtime ライブラリを使う。

import wasmtime

def benchmark_wasm():
    # WAT (WebAssembly Text Format) から直接コンパイル
    wat_code = """
    (module
      (func $fibonacci (export "fibonacci") (param i32) (result i32)
        (if (result i32) (i32.le_s (local.get 0) (i32.const 1))
          (then (local.get 0))
          (else
            (i32.add
              (call $fibonacci (i32.sub (local.get 0) (i32.const 1)))
              (call $fibonacci (i32.sub (local.get 0) (i32.const 2)))
            )
          )
        )
      )
    )
    """

    engine = wasmtime.Engine()
    store  = wasmtime.Store(engine)
    module = wasmtime.Module(engine, wat_code)
    inst   = wasmtime.Instance(store, module, [])
    fib    = inst.exports(store)["fibonacci"]

    start = time.perf_counter()
    for _ in range(100):
        result = fib(store, 30)  # fib(30) = 832040
    elapsed = time.perf_counter() - start

    # 100回/秒以上 = 100点
    score = min(100, (100 / elapsed))
    return score

WASM の強みは「どこでも同じ結果」。サーバーサイドでも使えるのでエッジコンピューティングとの相性がいい。

---

3. Rust（99.87点）

Python から Rust のバイナリを呼び出して計測。

import subprocess
import tempfile
import os

RUST_CODE = """
fn fibonacci(n: u64) -> u64 {
    match n {
        0 | 1 => n,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn main() {
    let start = std::time::Instant::now();
    let mut sum = 0u64;
    for i in 0..1000 {
        sum += fibonacci(i % 40);
    }
    let elapsed = start.elapsed().as_secs_f64();
    println!("{:.6}", elapsed);
}
"""

def benchmark_rust():
    with tempfile.TemporaryDirectory() as tmp:
        src = os.path.join(tmp, "bench.rs")
        bin = os.path.join(tmp, "bench")

        with open(src, "w") as f:
            f.write(RUST_CODE)

        # コンパイル（最適化フラグ付き）
        subprocess.run(
            ["rustc", "-O", "-o", bin, src],
            capture_output=True, check=True
        )

        # 実行
        result = subprocess.run([bin], capture_output=True, text=True)
        elapsed = float(result.stdout.strip())

        # 0.1秒以下 = 100点
        score = min(100, max(0, (0.1 - elapsed) / 0.001))
        return score

-O フラグが重要。付け忘れると最適化なしのデバッグビルドになってスコアが半分以下になる（実際に最初やらかした）。

---

4. 量子計算（99.39点）

Qiskit（IBMの量子コンピュータSDK）でシミュレーター計測。

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

def benchmark_quantum():
    simulator = AerSimulator()

    # 10量子ビットの回路
    qc = QuantumCircuit(10, 10)

    # アダマールゲート（重ね合わせ状態生成）
    for i in range(10):
        qc.h(i)

    # CNOT ゲート（量子もつれ生成）
    for i in range(9):
        qc.cx(i, i + 1)

    # 測定
    qc.measure(range(10), range(10))

    start = time.perf_counter()
    job = simulator.run(qc, shots=1024)
    result = job.result()
    elapsed = time.perf_counter() - start

    counts = result.get_counts()

    # 1秒以下で完了 = 100点
    score = min(100, max(0, (1.0 - elapsed) / 0.01))
    return score

実機の量子コンピュータは使っていない（高い）。AerSimulator はCPU上で量子回路をシミュレートする。

---

5. eBPF（60点）

eBPF はLinuxカーネルにプログラムを注入してシステムコールを監視できる技術。Python からは bcc ライブラリ経由で使う。

from bcc import BPF

BPF_PROGRAM = """
#include <uapi/linux/ptrace.h>

BPF_HASH(syscall_count, u32);

TRACEPOINT_PROBE(raw_syscalls, sys_enter) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    u64 *count = syscall_count.lookup(&pid);
    if (count) {
        (*count)++;
    } else {
        u64 one = 1;
        syscall_count.update(&pid, &one);
    }
    return 0;
}
"""

def benchmark_ebpf():
    b = BPF(text=BPF_PROGRAM)

    start = time.perf_counter()
    time.sleep(1)  # 1秒間のシステムコールを計測
    elapsed = time.perf_counter() - start

    total = sum(b["syscall_count"].values())

    # 1万syscall/秒以上 = 100点
    score = min(100, total / 100)
    return score

eBPF はカーネルのroot権限が必要なので sudo で実行する必要がある。

---

スコア推移

バージョン	スコア	最適化数	追加内容
v13.0	1836	14	初期実装
v13.1	1905	14	自動チューニング追加
v13.1.1	1961	14	全カテゴリ手動調整
v13.2	2269	14	量子・Edge・Rust完全最適化
v15.0	2131	30	16個追加→逆に低下

v13.0→v13.2 で +433点（+23.6%） 改善。最適化数を変えずにパラメータとアルゴリズムの改善だけで達成。

---

実行環境

OS: Rocky Linux 9.x
CPU: Intel Core i7 / AMD Ryzen 5 以上推奨
RAM: 16GB 以上推奨
sudo: 必須（eBPF使用のため）

主要ライブラリ：

pyzmq==26.x
wasmtime==23.x
qiskit==1.x
qiskit-aer==0.14.x
bcc (カーネルモジュール)

---

インストール

curl -fsSL https://noveos.jp/install.sh | sudo bash -s <ライセンスキー>

詳細は noveos.jp にて。

---

まとめ

• ZeroMQ/gRPC: Python でも 50万msg/秒クラスの計測が可能
• WASM: wasmtime で Python からネイティブに実行できる
• Rust: subprocess でコンパイル→実行が一番シンプル（-O を忘れずに）
• 量子: Qiskit AerSimulator で手軽にシミュレーション可能
• eBPF: root権限さえあれば Python の bcc で簡単に使える

14カテゴリを39秒で全部測定して最適化できるので、サーバーのポテンシャルを一気に把握できるのが強みです。