Phase 9: FREE-TINY-FAST MONO DUALHOT (GO +2.72%)

Results:
- A/B test: +2.72% on Mixed (10-run, clean env)
- Baseline: 48.89M ops/s
- Optimized: 50.22M ops/s
- Improvement: +1.33M ops/s (+2.72%)
- Stability: Standard deviation reduced by 60.8% (2.44M → 955K ops/s)

Strategy:
- Transplant C0-C3 "second hot" path to monolithic free_tiny_fast()
- Early-exit within monolithic (no hot/cold split)
- FastLane free now benefits from C0-C3 direct path

Success factors:
1. Performance improvement: +2.72% (2.7x GO threshold)
2. Stability improvement: 2.6x more stable (stdev 60.8% reduction)
3. Learned from Phase 7 failure:
   - Phase 7: Function split (hot/cold) → NO-GO
   - Phase 9: Early-exit within monolithic → GO
4. FastLane free compatibility: C0-C3 direct path now works with FastLane
5. Policy snapshot overhead reduction: C0-C3 (48% of Mixed) skip route lookup

Implementation:
- Patch 1: ENV gate box (free_tiny_fast_mono_dualhot_env_box.h)
  - ENV: HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=0/1 (default 0)
  - Probe window: 64 (avoid bench_profile putenv race)
- Patch 2: Early-exit in free_tiny_fast() (malloc_tiny_fast.h)
  - Conditions: class_idx <= 3, !LARSON_FIX, route==LEGACY
  - Direct call: tiny_legacy_fallback_free_base()
- Patch 3: Visibility (free_path_stats_box.h)
  - mono_dualhot_hit counter (compile-out in release)
- Patch 4: cleanenv extension (run_mixed_10_cleanenv.sh)
  - ENV leak protection

Files modified:
- core/bench_profile.h: add to MIXED_TINYV3_C7_SAFE preset
- core/front/malloc_tiny_fast.h: early-exit insertion
- core/box/free_path_stats_box.h: counter
- core/box/free_tiny_fast_mono_dualhot_env_box.h: NEW (ENV gate)
- scripts/run_mixed_10_cleanenv.sh: ENV leak protection

Health check: PASSED (all profiles)

Promotion: Added to MIXED_TINYV3_C7_SAFE preset (default ON, opt-out)

Rollback: HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=0

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

core/bench_profile.h

@@ -80,6 +80,8 @@ static inline void bench_apply_profile(void) {
 	    bench_setenv_default("HAKMEM_FRONT_FASTLANE", "1");
 	    // Phase 6-2: Front FastLane Free DeDup (+5.18% proven on Mixed, 10-run)
 	    bench_setenv_default("HAKMEM_FRONT_FASTLANE_FREE_DEDUP", "1");
+	    // Phase 9: FREE-TINY-FAST MONO DUALHOT (+2.72% proven on Mixed, 10-run)
+	    bench_setenv_default("HAKMEM_FREE_TINY_FAST_MONO_DUALHOT", "1");
 	    // Phase 4-4: C6 ULTRA free+alloc 統合を有効化 (default OFF, manual opt-in)
 	    bench_setenv_default("HAKMEM_TINY_C6_ULTRA_FREE_ENABLED", "0");
 	    // Phase MID-V3: Mid/Pool HotBox v3

core/box/free_path_stats_box.h

@@ -33,6 +33,9 @@ typedef struct FreePathStats {
 
     // Phase POLICY-FAST-PATH-V2: Fast-path policy skip
     uint64_t policy_fast_v2_skip;  // Phase POLICY-FAST-PATH-V2 fast-path skips
+
+    // Phase 9: MONO DUALHOT hit
+    uint64_t mono_dualhot_hit;  // Phase 9: C0-C3 direct path (monolithic free_tiny_fast)
 } FreePathStats;
 
 // ENV gate

core/box/free_tiny_fast_mono_dualhot_env_box.h

@@ -0,0 +1,43 @@
+#ifndef HAKMEM_FREE_TINY_FAST_MONO_DUALHOT_ENV_BOX_H
+#define HAKMEM_FREE_TINY_FAST_MONO_DUALHOT_ENV_BOX_H
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+// Phase 9: FREE-TINY-FAST MONO DUALHOT ENV gate
+//
+// Goal: Enable C0-C3 direct path in monolithic free_tiny_fast() without hot/cold split
+// ENV: HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=0/1 (default: 0)
+//
+// Design:
+//   - Probe window: 64 (tolerate bench_profile putenv before gate init)
+//   - Hot path: cached==1/0 immediate return (no overhead)
+//   - A/B: Same binary, flip ENV for immediate rollback
+
+static inline int free_tiny_fast_mono_dualhot_enabled(void) {
+    static int g_enabled = -1;        // -1: unknown, 0: off, 1: on
+    static int g_probe_left = 64;     // Probe window (tolerate early putenv)
+
+    // Fast path: cached
+    if (__builtin_expect(g_enabled == 1, 0)) return 1;
+    if (__builtin_expect(g_enabled == 0, 1)) return 0;
+
+    // Slow path: init (first call or probe window)
+    const char* e = getenv("HAKMEM_FREE_TINY_FAST_MONO_DUALHOT");
+    if (e && *e) {
+        g_enabled = (*e != '0') ? 1 : 0;
+        return g_enabled;
+    }
+
+    // ENV not set: probe window
+    if (g_probe_left-- > 0) {
+        return 0;  // Keep g_enabled==-1, retry later
+    }
+
+    // Probe window exhausted: commit to 0 (OFF)
+    g_enabled = 0;
+    return 0;
+}
+
+#endif // HAKMEM_FREE_TINY_FAST_MONO_DUALHOT_ENV_BOX_H

core/front/malloc_tiny_fast.h

@@ -72,6 +72,7 @@
 #include "../box/hakmem_env_snapshot_box.h" // Phase 4 E1: ENV snapshot consolidation
 #include "../box/free_cold_shape_env_box.h" // Phase 5 E5-3a: Free cold path shape optimization
 #include "../box/free_cold_shape_stats_box.h" // Phase 5 E5-3a: Free cold shape stats
+#include "../box/free_tiny_fast_mono_dualhot_env_box.h" // Phase 9: MONO DUALHOT ENV gate
 
 // Helper: current thread id (low 32 bits) for owner check
 #ifndef TINY_SELF_U32_LOCAL_DEFINED
@@ -768,6 +769,31 @@ static inline int free_tiny_fast(void* ptr) {
     // Phase FREE-LEGACY-BREAKDOWN-1: カウンタ散布 (1. 関数入口)
     FREE_PATH_STAT_INC(total_calls);
 
+    // Phase 9: MONO DUALHOT early-exit for C0-C3 (skip policy snapshot, direct to legacy)
+    // Conditions:
+    //   - ENV: HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=1
+    //   - class_idx <= 3 (C0-C3)
+    //   - !HAKMEM_TINY_LARSON_FIX (cross-thread handling requires full validation)
+    //   - g_tiny_route_snapshot_done == 1 && route == TINY_ROUTE_LEGACY (断定できないときは既存経路)
+    if ((unsigned)class_idx <= 3u) {
+        if (free_tiny_fast_mono_dualhot_enabled()) {
+            static __thread int g_larson_fix = -1;
+            if (__builtin_expect(g_larson_fix == -1, 0)) {
+                const char* e = getenv("HAKMEM_TINY_LARSON_FIX");
+                g_larson_fix = (e && *e && *e != '0') ? 1 : 0;
+            }
+
+            if (!g_larson_fix &&
+                g_tiny_route_snapshot_done == 1 &&
+                g_tiny_route_class[class_idx] == TINY_ROUTE_LEGACY) {
+                // Direct path: Skip policy snapshot, go straight to legacy fallback
+                FREE_PATH_STAT_INC(mono_dualhot_hit);
+                tiny_legacy_fallback_free_base(base, class_idx);
+                return 1;
+            }
+        }
+    }
+
     // Phase v11b-1: C7 ULTRA early-exit (skip policy snapshot for most common case)
     // Phase 4 E1: Use ENV snapshot when enabled (consolidates 3 TLS reads → 1)
     bool c7_ultra_free;

docs/analysis/PHASE9_FREE_TINY_FAST_MONO_DUALHOT_1_AB_TEST_RESULTS.md

@@ -0,0 +1,218 @@
+# Phase 9: FREE-TINY-FAST MONO DUALHOT A/B テスト結果
+
+## 実装概要
+
+### 目的
+
+Phase 6 FastLane + Phase 6-2 Free DeDup により、Mixed の free は主に **FastLane → monolithic `free_tiny_fast()`** を通る。
+
+一方で "第2ホット" の勝ち筋（C0–C3 を policy snapshot なしで最短処理）は、主に **`free_tiny_fast_hot()` 側**に実装されており、Phase 7（FastLane から hot/cold に寄せる）は **NO-GO** だった。
+
+この Phase 9 は、**hot/cold split を持ち込まず**に、勝ち筋だけ（C0–C3 direct）を **monolithic `free_tiny_fast()` 側へ最小固定費で移植**し、FastLane free でも効く状態にする。
+
+### Phase 7 との違い
+
+- **Phase 7**: 関数 split（hot/cold）を合わせに行って負けた
+- **Phase 9**: monolithic 内での early-exit に寄せる（split は持ち込まない）
+
+### 実装内容
+
+#### Patch 1: ENV gate 箱を追加
+
+- ファイル: `core/box/free_tiny_fast_mono_dualhot_env_box.h`
+- ENV: `HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=0/1` (default 0)
+- probe window: 64（bench_profile の putenv 競合を吸収）
+- hot path: cached==1/0 の即 return
+
+#### Patch 2: `free_tiny_fast()` に early-exit を 1 箇所入れる
+
+- 対象: `core/front/malloc_tiny_fast.h` の `free_tiny_fast(void* ptr)`
+- 差し込み位置: header magic / class_idx 確定、`base = tiny_user_to_base_inline(ptr)` 取得直後
+- 条件（すべて満たす場合のみ direct path）:
+  - `HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=1`
+  - `class_idx <= 3`（C0–C3）
+  - `!HAKMEM_TINY_LARSON_FIX`（Larson fix ON のときは cross-thread 判定が必要なので direct 禁止）
+  - `g_tiny_route_snapshot_done == 1` かつ `g_tiny_route_class[class_idx] == TINY_ROUTE_LEGACY`
+- Direct path: `tiny_legacy_fallback_free_base(base, class_idx); return 1;`
+
+#### Patch 3: 見える化
+
+- `core/box/free_path_stats_box.h` に `uint64_t mono_dualhot_hit;` を追加
+- direct path で `FREE_PATH_STAT_INC(mono_dualhot_hit);`
+
+#### Patch 4: cleanenv 拡張
+
+- `scripts/run_mixed_10_cleanenv.sh` に ENV 漏れ対策を追加
+
+---
+
+## A/B テスト結果（Mixed 10-run）
+
+### Baseline (HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=0)
+
+```
+Run 1:  48751476 ops/s
+Run 2:  49756530 ops/s
+Run 3:  49561339 ops/s
+Run 4:  50468743 ops/s
+Run 5:  49104143 ops/s
+Run 6:  49976771 ops/s
+Run 7:  49918119 ops/s
+Run 8:  50546082 ops/s
+Run 9:  41468829 ops/s  (outlier)
+Run 10: 49312894 ops/s
+```
+
+### Optimized (HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=1)
+
+```
+Run 1:  50326269 ops/s
+Run 2:  51064588 ops/s
+Run 3:  49574094 ops/s
+Run 4:  51199820 ops/s
+Run 5:  50943451 ops/s
+Run 6:  50218091 ops/s
+Run 7:  50613466 ops/s
+Run 8:  49949858 ops/s
+Run 9:  50228309 ops/s
+Run 10: 48036385 ops/s
+```
+
+---
+
+## 統計分析
+
+### Baseline (OFF)
+
+- **平均値**: 48,886,492.6 ops/s
+- **中央値**: 49,638,236.5 ops/s
+- **標準偏差**: 2,436,584.5 ops/s
+- **最小値**: 41,468,829 ops/s (Run 9, outlier)
+- **最大値**: 50,546,082 ops/s
+
+### Optimized (ON)
+
+- **平均値**: 50,215,433.1 ops/s
+- **中央値**: 50,272,189.0 ops/s
+- **標準偏差**: 954,838.3 ops/s
+- **最小値**: 48,036,385 ops/s
+- **最大値**: 51,199,820 ops/s
+
+### 性能差分
+
+- **絶対値差分**: +1,328,940.5 ops/s
+- **相対差分**: **+2.72%**
+- **中央値差分**: +633,952.5 ops/s (+1.28%)
+
+### 安定性
+
+- Baseline の標準偏差: 2,436,584.5 ops/s (変動係数: 4.99%)
+- Optimized の標準偏差: 954,838.3 ops/s (変動係数: 1.90%)
+- **Optimized は Baseline より 2.6 倍安定**（標準偏差が 60.8% 減少）
+
+---
+
+## 健康診断結果
+
+```
+== Health Profile 1/2: MIXED_TINYV3_C7_SAFE ==
+Throughput =  50173815 ops/s [iter=1000000 ws=400] time=0.020s
+
+== Health Profile 2/2: C6_HEAVY_LEGACY_POOLV1 ==
+Throughput =  23268418 operations per second, relative time: 0.043s.
+
+OK: health profiles passed
+```
+
+健康診断プロファイルは両方とも正常に完了。
+
+---
+
+## 判定
+
+### 判定基準（Mixed 10-run mean）
+
+- **GO**: +1.0% 以上
+- **NEUTRAL**: ±1.0%
+- **NO-GO**: -1.0% 以下
+
+### 結果
+
+**判定: GO** ✅
+
+- **平均値で +2.72%** の性能向上（判定基準 +1.0% を大きく上回る）
+- 中央値でも +1.28% の改善
+- 標準偏差が 60.8% 減少し、**安定性が大幅に向上**
+- Baseline の Run 9 outlier (41.4M ops/s) に対し、Optimized は全 run が 48M ops/s 以上で安定
+
+---
+
+## 勝因分析
+
+### 1. FastLane free への効果
+
+Phase 6-2 Free DeDup により、Mixed の free は主に `front_fastlane_try_free()` → `free_tiny_fast()` (monolithic) を通る。Phase 7 は hot/cold split を持ち込んで NO-GO だったが、Phase 9 は **monolithic 内での early-exit** に寄せることで、FastLane free でも C0–C3 direct path が効くようになった。
+
+### 2. Policy snapshot overhead の削減
+
+C0–C3（Mixed の約 48%）が以下を skip できる:
+- `small_policy_v7_snapshot()` 呼び出し
+- route table lookup
+- switch 文の分岐
+
+これにより、free の hot path が大幅に軽量化された。
+
+### 3. 安定性の向上
+
+Baseline では Run 9 が outlier (41.4M ops/s) だったが、Optimized では全 run が 48M ops/s 以上で安定。標準偏差が 60.8% 減少したことから、**early-exit による分岐削減が CPU のブランチ予測精度を向上**させたと考えられる。
+
+### 4. Phase 7 との違いが功を奏した
+
+Phase 7 は関数 split（hot/cold）を合わせに行って負けたが、Phase 9 は **monolithic 内での early-exit** に寄せることで成功。これは以下の理由による:
+- 関数呼び出しオーバーヘッドが発生しない
+- I-cache の局所性が保たれる
+- 既存の `free_tiny_fast()` の最適化（inline, branch hint など）をそのまま活用できる
+
+---
+
+## 次のステップ
+
+### 昇格（GO のため）
+
+1. **`core/bench_profile.h` に preset 追加**:
+   - `MIXED_TINYV3_C7_SAFE` に `bench_setenv_default("HAKMEM_FREE_TINY_FAST_MONO_DUALHOT","1")` を追加
+   - `C6_HEAVY_LEGACY_POOLV1` は未設定のまま（C0–C3 専用のため影響が小さい）
+
+2. **`CURRENT_TASK.md` に記録**:
+   - Phase 9 の A/B 数値（+2.72%）
+   - Rollback 手順: `export HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=0`
+
+### 検証済み項目
+
+- ✅ ビルド成功（warnings はあるが既存のもの）
+- ✅ Mixed 10-run で +2.72% の性能向上
+- ✅ 安定性向上（標準偏差 60.8% 減少）
+- ✅ 健康診断プロファイル全通過
+
+---
+
+## Rollback 手順
+
+```sh
+export HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=0
+```
+
+同一バイナリで即座に Baseline の挙動に戻る。
+
+---
+
+## まとめ
+
+Phase 9 FREE-TINY-FAST MONO DUALHOT は **GO** と判定。
+
+- **+2.72%** の性能向上（判定基準 +1.0% を大幅に上回る）
+- **安定性が 2.6 倍向上**（標準偏差 60.8% 減少）
+- Phase 7 の失敗（関数 split）を教訓に、**monolithic 内での early-exit** に寄せることで成功
+- FastLane free でも C0–C3 direct path が効くようになり、Mixed workload で大きな効果
+
+次の Phase は preset 昇格と CURRENT_TASK.md への記録。

hakmem.d

@@ -158,6 +158,7 @@ hakmem.o: core/hakmem.c core/hakmem.h core/hakmem_build_flags.h \
  core/box/../front/../box/hakmem_env_snapshot_box.h \
  core/box/../front/../box/free_cold_shape_env_box.h \
  core/box/../front/../box/free_cold_shape_stats_box.h \
+ core/box/../front/../box/free_tiny_fast_mono_dualhot_env_box.h \
  core/box/tiny_alloc_gate_box.h core/box/tiny_route_box.h \
  core/box/tiny_alloc_gate_shape_env_box.h \
  core/box/tiny_front_config_box.h core/box/wrapper_env_box.h \
@@ -405,6 +406,7 @@ core/box/../front/../box/tiny_free_route_cache_env_box.h:
 core/box/../front/../box/hakmem_env_snapshot_box.h:
 core/box/../front/../box/free_cold_shape_env_box.h:
 core/box/../front/../box/free_cold_shape_stats_box.h:
+core/box/../front/../box/free_tiny_fast_mono_dualhot_env_box.h:
 core/box/tiny_alloc_gate_box.h:
 core/box/tiny_route_box.h:
 core/box/tiny_alloc_gate_shape_env_box.h:

scripts/run_mixed_10_cleanenv.sh

@@ -13,6 +13,7 @@ runs=${RUNS:-10}
 export HAKMEM_TINY_HEADER_WRITE_ONCE=${HAKMEM_TINY_HEADER_WRITE_ONCE:-0}
 export HAKMEM_MALLOC_TINY_DIRECT=${HAKMEM_MALLOC_TINY_DIRECT:-0}
 export HAKMEM_ENV_SNAPSHOT_SHAPE=${HAKMEM_ENV_SNAPSHOT_SHAPE:-0}
+export HAKMEM_FREE_TINY_FAST_MONO_DUALHOT=${HAKMEM_FREE_TINY_FAST_MONO_DUALHOT:-0}
 
 for i in $(seq 1 "${runs}"); do
   echo "=== Run ${i}/${runs} ==="