Phase 62A: C7 ULTRA Alloc Dependency Chain Trim - NEUTRAL (-0.71%)

Implemented C7 ULTRA allocation hotpath optimization attempt as per Phase 62A instructions.

Objective: Reduce dependency chain in tiny_c7_ultra_alloc() by:
1. Eliminating per-call tiny_front_v3_c7_ultra_header_light_enabled() checks
2. Using TLS headers_initialized flag set during refill
3. Reducing branch count and register pressure

Implementation:
- New ENV box: core/box/c7_ultra_alloc_depchain_opt_box.h
- HAKMEM_C7_ULTRA_ALLOC_DEPCHAIN_OPT=0/1 gate (default OFF)
- Modified tiny_c7_ultra_alloc() with optimized path
- Preserved original path for compatibility

Results (Mixed benchmark, 10-run):
- Baseline (OPT=0): 59.300 M ops/s (CV 1.98%)
- Treatment (OPT=1): 58.879 M ops/s (CV 1.83%)
- Delta: -0.71% (NEUTRAL, within ±1.0% threshold but negative)
- Status: NEUTRAL → Research box (default OFF)

Root Cause Analysis:
1. LTO optimization already inlines header_light function (call cost = 0)
2. TLS access (memory load + offset) not cheaper than function call
3. Layout tax from code addition (I-cache disruption pattern from Phases 43/46A/47)
4. 5.18% stack % is not optimizable hotspot (already well-optimized)

Key Lessons:
- LTO-optimized function calls can be cheaper than TLS field access
- Micro-optimizations on already-optimized paths show diminishing/negative returns
- 48.34% gap to mimalloc is likely algorithmic, not micro-architectural
- Layout tax remains consistent pattern across attempted micro-optimizations

Decision:
- NEUTRAL verdict → kept as research box with ENV gate (default OFF)
- Not adopted as production default
- Next phases: Option B (production readiness pivot) likely higher ROI than further micro-opts

Box Theory Compliance: ✅ Compliant (single point, reversible, clear boundary)
Performance Compliance: ❌ No (-0.71% regression)

Documentation:
- PHASE62A_C7_ULTRA_DEPCHAIN_OPT_RESULTS.md: Full A/B test analysis
- CURRENT_TASK.md: Updated with results and next phase options

🤖 Generated with Claude Code

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

core/tiny_c7_ultra.c

@@ -11,6 +11,7 @@
 #include "box/tiny_c7_ultra_segment_box.h"
 #include "box/tiny_front_v3_env_box.h"
 #include "box/free_path_stats_box.h"
+#include "box/c7_ultra_alloc_depchain_opt_box.h"
 
 // Phase PERF-ULTRA-REFILL-OPT-1a: Import page size shift macro
 // (defined in tiny_c7_ultra_segment.c for consistency)
@@ -31,21 +32,64 @@ tiny_c7_ultra_tls_t* tiny_c7_ultra_tls_get(void) {
 
 // ============================================================================
 // Phase PERF-ULTRA-ALLOC-OPT-1: Pure TLS pop alloc (hot path)
+// Phase 62A: Dependency Chain Trim optimization
 // ============================================================================
 
 void* tiny_c7_ultra_alloc(size_t size) {
     (void)size;  // C7 dedicated, size unused
     tiny_c7_ultra_tls_t* tls = &g_tiny_c7_ultra_tls;
+
+    // Original path (baseline for compatibility/fallback)
     const bool header_light = tiny_front_v3_c7_ultra_header_light_enabled();
 
-    // Hot path: TLS cache hit (single branch)
+    // Phase 62A: Check optimization flag (compile-time in BENCH_MINIMAL)
+    if (!c7_ultra_alloc_depchain_opt_enabled()) {
+        // Baseline path (default, for compatibility)
+
+        // Hot path: TLS cache hit (single branch)
+        uint16_t n = tls->count;
+        if (__builtin_expect(n > 0, 1)) {
+            void* base = tls->freelist[n - 1];
+            tls->count = n - 1;
+
+            // Convert BASE -> USER pointer
+            if (header_light) {
+                return (uint8_t*)base + 1;  // Header already written
+            }
+            return tiny_region_id_write_header(base, 7);
+        }
+
+        // Cold path: Refill TLS cache from segment
+        if (!tiny_c7_ultra_refill(tls)) {
+            return so_alloc(7);  // Fallback to v3
+        }
+
+        // Retry after refill
+        n = tls->count;
+        if (__builtin_expect(n > 0, 1)) {
+            void* base = tls->freelist[n - 1];
+            tls->count = n - 1;
+
+            if (header_light) {
+                return (uint8_t*)base + 1;
+            }
+            return tiny_region_id_write_header(base, 7);
+        }
+
+        return so_alloc(7);  // Final fallback
+    }
+
+    // Optimized path: Use TLS headers_initialized instead of per-call check
+    // This eliminates the per-call tiny_front_v3_c7_ultra_header_light_enabled() check
+
+    // Hot path: TLS cache hit (minimal branches)
     uint16_t n = tls->count;
     if (__builtin_expect(n > 0, 1)) {
         void* base = tls->freelist[n - 1];
         tls->count = n - 1;
 
-        // Convert BASE -> USER pointer
-        if (header_light) {
+        // Skip header write if already initialized during refill
+        if (tls->headers_initialized) {
             return (uint8_t*)base + 1;  // Header already written
         }
         return tiny_region_id_write_header(base, 7);
@@ -56,13 +100,13 @@ void* tiny_c7_ultra_alloc(size_t size) {
         return so_alloc(7);  // Fallback to v3
     }
 
-    // Retry after refill
+    // Retry after refill (same path as hot hit, headers_initialized set by refill)
     n = tls->count;
     if (__builtin_expect(n > 0, 1)) {
         void* base = tls->freelist[n - 1];
         tls->count = n - 1;
 
-        if (header_light) {
+        if (tls->headers_initialized) {
             return (uint8_t*)base + 1;
         }
         return tiny_region_id_write_header(base, 7);