スピンロック：5.7 倍高速化と 5.4 倍の電力削減を達成する構築過程

スピンロックとは、ロック取得待ちの間、CPU の制御権を OS に渡さずに**「スピニング（待機ループ）」**を続けるロック方式です。システムコールやコンテキストスイッチが発生せず、待機時間は極めて短いです。

本稿では、スパイラル的に改良を重ねたスピンロックのバージョン（V1〜V4）を紹介し、最終的に5.7 倍の高速化と5.4 倍の消費電力削減を実現する手法を解説します。

1. ベンチマーク環境

共有カウンターへのインクリメント処理を行うスレッドを実行し、以下のようなチューニングされた環境で測定を行います。

• コンパイラ: Clang
• 最適化: すべての最適化オプション有効
• ピン留め: スレッドを特定の CPU コアに固定 (

  pinThread

  )

ベンチマークコード例

template <typename Lockable>
auto BM_SpinLock(benchmark::State& state) -> void {
  alignas(std::hardware_destructive_interference_size) static auto lockable = Lockable{};
  alignas(std::hardware_deestructive_interference_size) static auto counter = std::uint64_t{};

  pinThread(state.thread_index());
  for (auto _ : state) {
    lockable.lock();
    ++counter;
    lockable.unlock();
  }
  benchmark::DoNotOptimize(counter);
}

2. バージョン別改良と分析

V1: ナイーフなスピンロック (Atomic Swap Loop)

std::atomic_bool

exchange

• 仕組み:

  • locked_.exchange(true)

    が成功（戻り値が

    true

    ）する場合、他者のロック中であるため待機を繰り返します。

  • false

    になった場合、ロックを取得できたと判断。

class SpinLockV1 {
  std::atomic_bool locked_{false};

public:
  auto lock() noexcept -> void { 
    while (locked_.exchange(true)); 
  }
  auto unlock() noexcept -> void { 
    locked_.store(false); 
  }
};

V1 のパフォーマンス結果

• 非競合時: 3.14 ns
• 2 スレッド: 61.5 ns（約 20 倍の遅延）
• 4 スレッド: 246 ns

【問題点：ハードウェア負荷】

• キャッシュミス率の暴走: 待機中のスレッド同士がリソースを奪い合い、L1 データキャッシュミス率は 1 スレッド（1.27%）から 4 スレッドで 61.73% に跳ね上がります。
• 分岐予測の失敗: 「交換に成功したか」の判定結果がコアによって異なるため、分岐予測器は学習できず、8 回に分岐のうち 1 回が予測外となります。

$ perf stat -d ./benchmark --benchmark_filter='V1>.*threads:4'
# ブランチミスの 6.17% (原文の数値だが、文脈より高いミス率を示唆)
33,824,516      branch-misses          # 12.52% of all branches
208,756,315      L1-dcache-load-misses  # 61.73% of all L1-dcache accesses

【消費電力】

• 高負荷時の課題: エクチェンジのコロケーションサービスは 32 kW の制限があります。
• V1 (4 スレッド) の消費電力は 64.92 J です（パッケージ全体計測）。

V2: メモリ順序付けの最適化 (

memory_order

)

デフォルトの

seq_cst

• 仕組み:
  • ロック取得時は

    std::memory_order_acquire

  • ロック解放時は

    std::memory_order_release

class SpinLockV2 {
  std::atomic_bool locked_{false};

public:
  auto lock() noexcept -> void {
    while (locked_.exchange(true, std::memory_order_acquire));
  }
  auto unlock() noexcept -> void {
    locked_.store(false, std::memory_order_release);
  }
};

V2 の改善効果 (x86 アーキテクチャ)

unlock

• 非競合時: 3.14 ns → 1.57 ns
• 4 スレッド: 246 ns → 131 ns
• キャッシュミス率の低下: L1-d は 61.73% → 21.16%、分岐は 12.52% → 7.43%
• 消費電力削減: 64.92 J → 34.45 J

【アセンブリ指令の変化】

unlock

mov byte ptr

// SpinLockV1::unlock() - リード・モディファイ・ライトを追加
// mov     eax, 0
// xchg    byte ptr [rdi], al  // ロックされたリード・モディファイ・ライト
// ret

// SpinLockV2::unlock() - 単純なストア命令
// mov     byte ptr [rdi], 0   // シンプルなストア
// ret

V3: テストとテスト・アンド・セット (Test-and-Test-and-Set)

exchange

• 仕組み:

  1. exchange

     でロックを試みる。
  2. 失敗した場合、**「テスト（ロード）」→「パウズ」**を反復する。
  3. クリティカルセクションの保証は成功した「交換」操作で行うため、読み取り側には弱い順序付け (

     relaxed

     ) で構わない。

class SpinLockV3 {
  std::atomic_bool locked_{false};

public:
  auto lock() noexcept -> void {
    while (locked_.exchange(true, std::memory_order_acquire)) {
      while (locked_.load(std::memory_order_relaxed)) {  
        _mm_pause();                                     // バックオフ（コアをアイドル状態にする）
      }
    }
  }
  auto unlock() noexcept -> void {
    locked_.store(false, std::memory_order_release);
  }
};

V3 の改善効果

• 2 スレッド: 61.5 ns → 32.5 ns (約 2/3 へ改善)
• 4 スレッド: 131 ns → 120 ns (8% 向上)
  • 注: 同じ長さの時間だけパウズするため、ウェッカー（waker）も同時に目覚めますが、予測可能でオーバーヘッドが減ります。
• 消費電力削減: 34.45 J → 30.97 J

【性能向上の理由】 読み取り専用の待機ループにより、キャッシュミスや分岐予測ミスを大幅に減少させます。

$ perf stat -d ./benchmark --benchmark_filter='V3>.*threads:4'
12,089,906      branch-misses          # 3.72% of all branches (大幅改善)
83,836,255      L1-dcache-load-misses  # 17.31% of all L1-dcache accesses

V4: 指数関数的なバックオフ (Exponential Backoff)

Intel の推奨手法に基づき、待機時間を徐々に長くなります。

• 仕組み:
  1. パウズ回数を初期値（1）から設定。
  2. 各ラウンドごとにパウズ回数を倍増させますが、上限（64）まで制御します。
  3. これにより、待機中のスレッド同士が同時に目覚めることを回避できます。

class SpinLockV4 {
  std::atomic_bool locked_{false};

public:
  auto lock() noexcept -> void {
    auto backoff = 1;
    while (locked_.exchange(true, std::memory_order_acquire)) {
      do {
        for (auto i = 0; i < backoff; ++i) _mm_pause();   
        // パウズ回数を指数関数的に増加（最大 64 まで）
        backoff = backoff < 64 ? backoff << 1 : 64;       
      } while (locked_.load(std::memory_order_relaxed));  
    }
  }
  auto unlock() noexcept -> void {
    locked_.store(false, std::memory_order_release);
  }
};

V4 の最終結果（劇的な改善）

• 4 スレッド: 120 ns → 43.0 ns (約 2.8 倍の高速化)
• 消費電力削減: 30.97 J → 11.92 J (V1 の約 5.4 分の 1)

$ perf stat -d ./benchmark --benchmark_filter='V4>.*threads:4'
600,071,010      instructions           # 0.07  insn per cycle (非常に効率化)
8,296,063        branch-misses          # 6.17% of all branches
33,717,087       L1-dcache-load-misses  # 12.88% of all L1-dcache accesses

3. まとめと推奨事項

各バージョンのベンチマーク結果を比較した表です。

推奨アプローチ

多くのコードでは、依然として

std::mutex

• スレッドが専用コアにピン留めされている場合
• ロック争奪戦が極めて短時間で終わることが保証される場合
• シーケンスロック (Seqlock) の検討も、読み取り側が多く書き込み側が少数なケースで有効です。