第22章：JIT性能剖析技术

热度计算公式：
hotness = invocation_count + backedge_count * loop_weight

其中：

- loop_weight 通常为5-10
- 考虑方法大小的归一化
- 时间衰减因子（避免冷却代码）

总编译时间 = 100%
├── 解析阶段: 10-15%
├── 优化阶段: 40-50%
│   ├── 内联: 5-15%
│   ├── 逃逸分析: 10-20%
│   └── 循环优化: 15-25%
├── 代码生成: 35-45%
│   ├── 指令选择: 10-15%
│   └── 寄存器分配: 20-30%
└── 安装阶段: 2-5%

// 伪代码示例
start = rdtscp(&cpu_id_start)
// 编译任务
end = rdtscp(&cpu_id_end)

if (cpu_id_start == cpu_id_end) {
  cycles = end - start
  time_ns = cycles * ns_per_cycle
}

// 减少系统调用次数
batch_start = clock_gettime()
for (i = 0; i < N; i++) {
  compile_method[i]()
}
batch_end = clock_gettime()
avg_time = (batch_end - batch_start) / N

// 将编译线程绑定到固定核
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(core_id, &cpuset);
pthread_setaffinity_np(thread, sizeof(cpuset), &cpuset);

struct CompilationPhaseStats {
  uint64_t count;
  uint64_t total_time;
  uint64_t min_time;
  uint64_t max_time;
  uint64_t sum_squares;  // 用于计算方差
  uint64_t histogram[BUCKETS];
};

 void enter_phase(phase_name);
 void exit_phase();
 void report();

bucket_width = (max_time - min_time) / num_buckets
bucket_index = (time - min_time) / bucket_width

// 适用于长尾分布
bucket_index = log2(time / min_time) * scale

mean = μ
std_dev = σ
outlier if: |value - mean| > 3 * std_dev

Q1 = 25th percentile
Q3 = 75th percentile
IQR = Q3 - Q1
outlier if: value < Q1 - 1.5*IQR or value > Q3 + 1.5*IQR

MAD = median(|xi - median(x)|)
outlier if: |value - median| > k * MAD

SMA(n) = (x[i] + x[i-1] + ... + x[i-n+1]) / n
EMA(n) = α * x[i] + (1-α) * EMA[i-1]

regression = (current - baseline) / baseline
alert if: regression > threshold

class CompilationTimer {
  void on_compilation_start(method_id);
  void on_phase_enter(phase_name);
  void on_phase_exit();
  void on_compilation_end();
  void report_statistics();
};

// AOP风格的自动计时
@Timed("optimization.inlining")
void perform_inlining() { ... }

#ifdef ENABLE_TIMING
  #define TIME_PHASE(name) PhaseTimer timer(name)
#else
  #define TIME_PHASE(name) 
#endif

编译开销率 = Σ(编译时间) / 总运行时间

分层分析：

- 启动阶段：通常 > 50%
- 预热阶段：20-30%
- 稳态阶段：< 5%

编译CPU占比 = 编译线程CPU时间 / 总CPU时间

并发编译度 = 平均活跃编译线程数
CPU竞争系数 = 编译CPU时间 / 应用CPU时间

有效吞吐量 = 应用工作量 / (应用时间 + 编译时间)
吞吐量损失 = 1 - (有效吞吐量 / 理论吞吐量)

T_startup = T_init + T_load + T_compile_critical + T_warmup

其中：

- T_init: JIT初始化
- T_load: 类加载和验证
- T_compile_critical: 关键路径编译
- T_warmup: 性能逐步提升

JIT内存 = 编译器工作内存 + IR存储 + 临时数据结构

细分：

- AST/IR节点: 30-40%
- 优化数据结构: 20-30%
- 寄存器分配: 15-20%
- 代码生成缓冲: 10-15%
- 其他: 10-15%

内存峰值 ≈ O(n²) 对于某些优化
其中n = 方法大小（IR节点数）

采样编译线程堆栈
构建编译阶段火焰图
识别热点函数

struct CompilationRecord {
  method_id;
  optimization_level;
  compilation_count;
  deoptimization_count;
  last_compile_reason;
};

优化收益率 = (优化后性能 - 优化前性能) / 优化成本

过度优化指标：

- 优化收益率 < 阈值
- 编译时间/执行时间 > 比率
- 代码膨胀率 > 限制

竞争强度 = 编译线程CPU使用率 / 可用CPU数
影响系数 = 应用线程等待时间 / 总运行时间

优化决策流程：

1. 数据收集 → 指标计算
2. 瓶颈识别 → 原因分析
3. 策略制定 → 效果预测
4. 实施优化 → 效果验证
5. 持续监控 → 迭代改进

全局预算分配：

- 级别1 (C1)：20% 总预算
- 级别2-3：30% 总预算
- 级别4 (C2)：40% 总预算
- 紧急储备：10% 总预算

method_budget = base_budget * complexity_factor * priority_weight

其中：

- base_budget: 基础时间配额
- complexity_factor: 代码复杂度系数
- priority_weight: 热度和优先级权重

新预算 = α * 实际使用 + (1-α) * 历史预算
α = 0.3 (平滑系数)

if (available_budget < minimal_c2_budget) {
  use_c1_compilation();
} else if (method_hotness > threshold && budget_sufficient) {
  use_c2_compilation();
} else {
  use_tiered_compilation();
}

struct OptimizationPass {
  string name;
  float expected_time;
  float expected_benefit;
  bool is_mandatory;

  bool should_run(float remaining_budget) {
    return is_mandatory || 
           (expected_benefit/expected_time > threshold &&
            remaining_budget > expected_time);
  }
};

// 自适应延迟控制
target_latency = percentile(historical_latencies, 0.95);

if (current_queue_length > threshold) {
  // 反压控制
  reduce_compilation_rate();
  lower_optimization_levels();
}

if (predicted_latency > target_latency) {
  // 预测性控制
  use_faster_compilation_strategy();
}

状态空间：

- 系统负载
- 队列长度
- 可用资源
- 历史性能

动作空间：

- 调整预算
- 改变优化级别
- 修改线程数

奖励函数：
reward = α*throughput - β*latency - γ*resource_usage

// 帕累托最优前沿
objectives = [
  minimize(compilation_time),
  maximize(code_quality),
  minimize(memory_usage),
  minimize(cpu_usage)
];

pareto_front = compute_pareto_optimal_solutions();
selected_config = choose_from_pareto_front(weights);

struct BudgetMonitor {
  float allocated_budget;
  float used_budget;
  float burn_rate;  // 消耗速率

  bool is_overrun() {
    return used_budget > allocated_budget * 1.1;  // 10%容忍度
  }

  float time_to_exhaustion() {
    return (allocated_budget - used_budget) / burn_rate;
  }
};

// CUSUM算法检测
S[i] = max(0, S[i-1] + (x[i] - target) - drift);
if (S[i] > threshold) {
  trigger_degradation_alert();
}

cpu_pressure = compilation_cpu_usage / available_cpu;
if (cpu_pressure > 0.8) {
  reduce_compilation_threads();
  increase_batch_size();
}

memory_pressure = jit_memory_usage / available_memory;
if (memory_pressure > 0.7) {
  trigger_code_cache_gc();
  reduce_optimization_level();
}

cache_utilization = used_cache / total_cache;
if (cache_utilization > 0.9) {
  evict_cold_code();
  compact_code_cache();
}

Level 1: 轻度降级

- 减少优化Pass
- 降低内联深度
- 增加批处理

Level 2: 中度降级

- 使用低级编译器
- 停止非关键编译
- 清理部分缓存

Level 3: 重度降级

- 仅保留解释执行
- 紧急GC
- 系统级限流

代码缓存空间布局：
+------------------+
|   热点代码区     | ← 频繁执行的优化代码
+------------------+
|   普通代码区     | ← 一般优化级别代码
+------------------+
|   冷代码区       | ← 低频执行代码
+------------------+
|   存根代码区     | ← 运行时存根、跳板
+------------------+
|   元数据区       | ← 方法表、重定位表
+------------------+
|   保护页         | ← 防止溢出
+------------------+

struct CodeMetadata {
  // 基本信息
  void* code_start;
  size_t code_size;
  uint32_t compilation_id;
  uint32_t optimization_level;

  // 方法信息
  MethodID method_id;
  void* method_metadata;
  uint64_t compilation_timestamp;

  // 依赖信息
  DependencyList* dependencies;
  AssumptionList* assumptions;

  // 性能数据
  uint64_t execution_count;
  uint64_t last_execution_time;
  float hotness_score;

  // 调试信息
  PCToLineTable* pc_map;
  ScopeDescTable* scopes;
  ExceptionTable* exceptions;
};

enum RelocationType {
  RELOC_CALL_DIRECT,      // 直接调用
  RELOC_CALL_VIRTUAL,     // 虚拟调用
  RELOC_CONSTANT_POOL,    // 常量池引用
  RELOC_CLASS_INIT,       // 类初始化检查
  RELOC_SAFEPOINT,        // 安全点
  RELOC_EXCEPTION_HANDLER // 异常处理器
};

struct RelocationEntry {
  RelocationType type;
  uint32_t offset;        // 相对代码起始的偏移
  void* target;           // 目标地址或符号
  void* extra_data;       // 额外信息
};

struct DebugSymbolTable {
  // PC到源码行映射
  struct PCToLine {
    void* pc;
    uint32_t line_number;
    uint32_t column;
    const char* source_file;
  };

  // 变量位置信息
  struct VariableLocation {
    const char* name;
    LocationDescriptor location;
    TypeInfo* type;
    LiveRange range;
  };

  // 内联信息
  struct InlineInfo {
    MethodID inlined_method;
    uint32_t inline_depth;
    PCRange pc_range;
    InlineInfo* parent;
  };
};

class CodeCacheAllocator {
  // 小块快速分配（< 1KB）
  class SmallBlockAllocator {
    FreeList free_lists[SIZE_CLASSES];
    void* allocate(size_t size);
    void deallocate(void* ptr, size_t size);
  };

  // 大块分配（>= 1KB）
  class LargeBlockAllocator {
    SegmentedHeap heap;
    void* allocate(size_t size);
    void deallocate(void* ptr);
  };

  // 分配决策
  void* allocate(size_t size, CodeType type) {
    if (size < SMALL_THRESHOLD) {
      return small_allocator.allocate(size);
    } else {
      return large_allocator.allocate(size);
    }
  }
};

// 大小类设计减少内部碎片
const size_t SIZE_CLASSES[] = {
  64, 128, 256, 512, 1024, 2048, 4096, 8192
};

// 伙伴系统减少外部碎片
class BuddyAllocator {
  void* allocate(size_t size) {
    size_t order = get_order(size);
    return split_block(find_free_block(order), size);
  }

  void coalesce_free_blocks() {
    // 合并相邻空闲块
  }
};

 float internal_fragmentation() {
   return (allocated_space - used_space) / allocated_space;
 }

 float allocation_efficiency() {
   return successful_allocations / total_allocation_attempts;
 }

class CodeCacheGC {
  // 标记阶段
  void mark_phase() {
    // 从根集合（活跃栈帧）开始标记
    mark_from_stack_frames();
    mark_from_inline_caches();
    mark_from_virtual_tables();
  }

  // 清理阶段
  void sweep_phase() {
    // 回收未标记的代码
    for (auto& segment : code_segments) {
      if (!segment.is_marked()) {
        reclaim_segment(segment);
      }
    }
  }

  // 压缩阶段（可选）
  void compact_phase() {
    // 移动存活代码，减少碎片
    relocate_live_code();
    update_all_references();
  }
};

class ExecutableMemory {
  void* allocate_executable(size_t size) {
    // W^X保护：写和执行权限互斥
    void* mem = mmap(NULL, size, 
                    PROT_READ | PROT_WRITE,
                    MAP_PRIVATE | MAP_ANONYMOUS, 
                    -1, 0);

    // 写入代码
    write_code(mem, size);

    // 切换为可执行
    mprotect(mem, size, PROT_READ | PROT_EXEC);

    // 刷新指令缓存
    __builtin___clear_cache(mem, mem + size);

    return mem;
  }
};

 // 在指定节点分配
 void* mem = numa_alloc_onnode(size, preferred_node);

 // 设置内存策略
 mbind(mem, size, MPOL_BIND, mask->maskp, 
       mask->size, MPOL_MF_STRICT);

 return mem;

L1 Cache: 最热点代码（1-4MB）
L2 Cache: 活跃代码（16-64MB）
L3 Cache: 全部代码（256MB-1GB）

晋升策略：基于执行频率和最近访问时间
降级策略：LRU结合访问频率

Young Generation: 新编译代码
Old Generation: 长期存活代码
Permanent: 核心运行时代码

代际晋升：基于存活时间和执行次数

// 读写锁保护元数据
ReaderWriterLock metadata_lock;

// 无锁代码访问（通过原子指针）
atomic<CodeBlock*> method_code[MAX_METHODS];

// 分段锁减少竞争
Lock segment_locks[NUM_SEGMENTS];

// 代码缓存快照
void create_snapshot(const char* filename);
void restore_snapshot(const char* filename);

// 增量持久化
void persist_hot_methods();
void persist_metadata();

总体利用率 = 已使用空间 / 总分配空间
有效利用率 = 活跃代码大小 / 已使用空间
净利用率 = 活跃代码大小 / 总分配空间

 float utilization() {
   return (float)used_size / total_size;
 }

 float efficiency() {
   return (float)active_size / used_size;
 }

 float overhead() {
   return (float)metadata_size / used_size;
 }

class FragmentationAnalyzer {
  // 外部碎片化：空闲空间分散程度
  float external_fragmentation() {
    size_t total_free = 0;
    size_t max_free_block = 0;

    for (auto& block : free_blocks) {
      total_free += block.size;
      max_free_block = max(max_free_block, block.size);
    }

    if (total_free == 0) return 0.0;
    return 1.0 - (float)max_free_block / total_free;
  }

  // 内部碎片化：分配浪费
  float internal_fragmentation() {
    size_t allocated = 0;
    size_t requested = 0;

    for (auto& alloc : allocations) {
      allocated += alloc.allocated_size;
      requested += alloc.requested_size;
    }

    return (float)(allocated - requested) / allocated;
  }

  // 碎片化指数：综合评分
  float fragmentation_index() {
    float ext_frag = external_fragmentation();
    float int_frag = internal_fragmentation();

    // 加权组合
    return 0.7 * ext_frag + 0.3 * int_frag;
  }
};

 // 计算碎片分布熵
 float distribution_entropy() {
   float total = 0;
   for (auto& [size, count] : free_block_histogram) {
     total += count;
   }

   float entropy = 0;
   for (auto& [size, count] : free_block_histogram) {
     float p = count / total;
     if (p > 0) {
       entropy -= p * log2(p);
     }
   }

   return entropy;
 }

 // 可用性分析
 float allocation_success_probability(size_t request_size) {
   int satisfiable = 0;
   int total = 0;

   for (auto& [size, count] : free_block_histogram) {
     if (size >= request_size) {
       satisfiable += count;
     }
     total += count;
   }

   return (float)satisfiable / total;
 }

class HotnessAnalyzer {
  struct CodeHotness {
    void* code_start;
    size_t code_size;
    uint64_t execution_count;
    uint64_t last_access_time;
    float temperature;  // 归一化热度值

    void update_temperature(uint64_t current_time) {
      // 时间衰减模型
      float time_factor = exp(-(current_time - last_access_time) / DECAY_CONSTANT);
      temperature = log1p(execution_count) * time_factor;
    }
  };

  // 计算热点密度
  float hotspot_density() {
    float total_heat = 0;
    size_t hot_code_size = 0;

    for (auto& code : code_blocks) {
      code.update_temperature(current_time());
      if (code.temperature > HOT_THRESHOLD) {
        total_heat += code.temperature;
        hot_code_size += code.code_size;
      }
    }

    return total_heat / hot_code_size;
  }

  // 空间局部性分析
  float spatial_locality() {
    // 计算热点代码的空间聚集度
    vector<AddressRange> hot_ranges = get_hot_code_ranges();
    size_t total_span = calculate_address_span(hot_ranges);
    size_t actual_size = calculate_total_size(hot_ranges);

    return (float)actual_size / total_span;
  }
};

   for (auto& access : access_log) {
     if (access.timestamp >= window_start && 
         access.timestamp <= window_end) {
       working_set.insert(access.code_block);
     }
   }

   return working_set;
 }

 // 工作集大小趋势
 vector<size_t> working_set_trend(uint64_t window_size, uint64_t step) {
   vector<size_t> trend;

   for (uint64_t t = 0; t < total_time; t += step) {
     auto ws = get_working_set(t, t + window_size);
     size_t ws_size = calculate_size(ws);
     trend.push_back(ws_size);
   }

   return trend;
 }

struct CacheHitMetrics {
  // 直接命中：代码已编译且在缓存中
  uint64_t direct_hits;
  uint64_t direct_misses;

  // 部分命中：需要重编译但可复用部分
  uint64_t partial_hits;

  // 完全未命中：需要从头编译
  uint64_t cold_misses;

  float hit_rate() {
    uint64_t total = direct_hits + direct_misses;
    return (float)direct_hits / total;
  }

  float effective_hit_rate() {
    uint64_t total = direct_hits + partial_hits + cold_misses;
    return (float)(direct_hits + 0.5 * partial_hits) / total;
  }
};

 // Zipf分布参数估计
 float estimate_zipf_parameter() {
   vector<pair<int, uint64_t>> ranked_freq;

   // 按频率排序
   for (auto& [block, freq] : access_frequency) {
     ranked_freq.push_back({ranked_freq.size() + 1, freq});
   }
   sort(ranked_freq.begin(), ranked_freq.end(),
        [](auto& a, auto& b) { return a.second > b.second; });

   // 最小二乘法估计s参数
   return fit_zipf_distribution(ranked_freq);
 }

 // 缓存替换效率
 float replacement_efficiency(string algorithm) {
   CacheSimulator sim(cache_size, algorithm);

   for (auto& access : access_trace) {
     sim.access(access.code_block);
   }

   return sim.get_hit_rate();
 }

struct CacheDumpHeader {
  uint32_t magic;           // 标识符
  uint32_t version;         // 格式版本
  uint64_t timestamp;       // 转储时间
  size_t cache_size;        // 总大小
  size_t used_size;         // 已用大小
  uint32_t block_count;     // 代码块数
  uint32_t metadata_offset; // 元数据偏移
};

class CacheDumper {
  void dump_to_file(const char* filename) {
    // 暂停编译活动
    pause_compilation();

    // 创建一致性快照
    auto snapshot = create_consistent_snapshot();

    // 写入文件
    write_header(filename, snapshot.header);
    write_code_blocks(filename, snapshot.blocks);
    write_metadata(filename, snapshot.metadata);
    write_free_list(filename, snapshot.free_list);

    // 恢复编译
    resume_compilation();
  }
};

 void analyze_utilization() {
   // 空间使用分析
   print_space_usage_report();

   // 碎片化分析
   print_fragmentation_report();

   // 热度分布
   print_hotness_distribution();

   // 年龄分布
   print_age_distribution();
 }

 void visualize() {
   // 生成内存布局图
   generate_memory_layout_svg();

   // 生成热力图
   generate_heatmap();

   // 生成碎片分布图
   generate_fragmentation_chart();
 }

class RealtimeMonitor {
  // 采样器
  class Sampler {
    atomic<bool> enabled;
    uint32_t sample_interval_ms;

    void sample_thread() {
      while (enabled) {
        collect_metrics();
        sleep_for(milliseconds(sample_interval_ms));
      }
    }
  };

  // 指标收集
  void collect_metrics() {
    auto metrics = CacheMetrics{
      .timestamp = current_time(),
      .total_size = get_total_size(),
      .used_size = get_used_size(),
      .active_blocks = count_active_blocks(),
      .fragmentation = calculate_fragmentation(),
      .hit_rate = calculate_hit_rate()
    };

    // 存储到环形缓冲区
    metrics_buffer.push(metrics);

    // 检查告警条件
    check_alerts(metrics);
  }

  // 告警规则
  void check_alerts(const CacheMetrics& metrics) {
    if (metrics.used_size > metrics.total_size * 0.9) {
      trigger_alert("Cache usage critical: " + 
                   to_string(metrics.used_size * 100.0 / metrics.total_size) + "%");
    }

    if (metrics.fragmentation > 0.5) {
      trigger_alert("High fragmentation: " + 
                   to_string(metrics.fragmentation));
    }
  }
};

 // 批量更新全局统计
 void flush_thread_stats() {
   global_stats.merge(tls_stats);
   tls_stats.reset();
 }

 // 采样而非全量统计
 bool should_sample() {
   return (random() % SAMPLE_RATE) == 0;
 }

 // 惰性计算复杂指标
 float get_fragmentation() {
   if (fragmentation_stale) {
     fragmentation = calculate_fragmentation();
     fragmentation_stale = false;
   }
   return fragmentation;
 }

class TimeSeriesStore {
  // 多分辨率存储
  struct Resolution {
    duration interval;
    duration retention;
    circular_buffer<MetricPoint> data;
  };

  vector<Resolution> resolutions = {
    {1s, 1h},    // 秒级数据保留1小时
    {1min, 1d},  // 分钟级数据保留1天
    {1h, 30d},   // 小时级数据保留30天
    {1d, 1y}     // 天级数据保留1年
  };

  // 降采样
  void downsample() {
    for (int i = 0; i < resolutions.size() - 1; i++) {
      auto& src = resolutions[i];
      auto& dst = resolutions[i + 1];

      if (should_downsample(src, dst)) {
        auto aggregated = aggregate(src.data, dst.interval);
        dst.data.push_back(aggregated);
      }
    }
  }
};

   // 计算R²
   float r_squared = calculate_r_squared(data, slope, intercept);

   return TrendResult{
     .type = (slope > 0) ? INCREASING : DECREASING,
     .slope = slope,
     .confidence = r_squared
   };
 }

 // 周期性检测
 PeriodicityResult detect_periodicity(const vector<MetricPoint>& data) {
   // FFT分析
   auto spectrum = fft(data);

   // 找出主频
   auto dominant_freq = find_dominant_frequency(spectrum);

   return PeriodicityResult{
     .period = 1.0 / dominant_freq,
     .amplitude = spectrum[dominant_freq],
     .phase = calculate_phase(spectrum, dominant_freq)
   };
 }

 // 异常检测
 vector<Anomaly> detect_anomalies(const vector<MetricPoint>& data) {
   // 使用STL分解
   auto [trend, seasonal, residual] = stl_decompose(data);

   // 在残差中检测异常
   return detect_outliers_in_residual(residual);
 }

class CacheUsagePredictor {
  // 特征工程
  Features extract_features(const TimeWindow& window) {
    return Features{
      .avg_compilation_rate = calculate_avg_compilation_rate(window),
      .method_size_distribution = get_method_size_dist(window),
      .recompilation_rate = calculate_recompilation_rate(window),
      .time_of_day = get_time_features(window),
      .system_load = get_system_load_features(window)
    };
  }

  // LSTM模型预测
  PredictionResult predict_usage(duration horizon) {
    // 准备输入序列
    auto sequence = prepare_input_sequence();

    // 模型推理
    auto raw_prediction = lstm_model.predict(sequence);

    // 后处理和置信区间
    return PredictionResult{
      .point_estimate = raw_prediction.mean(),
      .confidence_interval = calculate_confidence_interval(raw_prediction),
      .prediction_horizon = horizon
    };
  }

  // 自适应模型更新
  void update_model(const ActualMetrics& actual) {
    // 计算预测误差
    float error = calculate_prediction_error(last_prediction, actual);

    // 在线学习更新
    if (error > ERROR_THRESHOLD) {
      online_learning_update(actual);
    }

    // 定期完整重训练
    if (should_retrain()) {
      retrain_model();
    }
  }
};

   // 考虑业务因素
   float business_factor = get_business_growth_factor();

   // 组合预测
   return GrowthProjection{
     .expected_growth = historical_growth * business_factor,
     .pessimistic = historical_growth * business_factor * 1.5,
     .optimistic = historical_growth * business_factor * 0.7
   };
 }

 // 资源需求预测
 ResourceRequirement forecast_requirements(duration period) {
   auto growth = project_growth();
   auto current_usage = get_current_usage();

   return ResourceRequirement{
     .cache_size = current_usage.cache_size * pow(1 + growth.expected_growth, period.count()),
     .compilation_threads = estimate_thread_requirement(growth),
     .memory_bandwidth = estimate_bandwidth_requirement(growth)
   };
 }