# 查看分层编译日志
java -XX:+PrintCompilation \
     -XX:+TieredCompilation \
     -XX:CompileThreshold=1000 \
     MyApp

# 输出格式:
# 时间戳 编译ID 层级 方法名 (字节码大小)
#  1234   1     3    java.lang.String::hashCode (55 bytes)
#  1235   2     4    java.lang.String::hashCode (55 bytes)  # 重新编译到 Level 4

# 分层编译相关参数
-XX:+TieredCompilation              # 启用分层编译（默认开启）
-XX:TieredStopAtLevel=4             # 停止在哪个层级

# C1 相关参数
-XX:Tier0ProfilingStartPercentage=0   # 开始收集 Profile 的百分比
-XX:MaxInlineSize=35                   # C1 内联大小限制

# C2 相关参数
-XX:CompileThreshold=10000            # 编译阈值（方法调用次数）
-XX:OnStackReplacePercentage=140      # OSR 编译阈值百分比
-XX:MaxInlineSize=325                  # C2 内联大小限制

# 实验：关闭分层编译只使用解释器
java -Xint MyApp

# 实验：只使用 C1
java -XX:TieredStopAtLevel=1 MyApp

# 实验：只使用 C2
java -XX:-TieredCompilation MyApp

// C1 HIR 节点示例（概念表示）
// 指令层次结构

// 指令基类
class Instruction {
    enum InstructionType {
        Constant,      // 常量
        LocalAccess,   // 局部变量访问
        FieldAccess,   // 字段访问
        Invoke,        // 方法调用
        Arithmetic,    // 算术运算
        Logic,         // 逻辑运算
        Compare,       // 比较
        Branch,        // 分支
        Return,        // 返回
        // ...
    };
};

// 示例：一个简单的加法
// int result = a + b;
// 
// HIR 表示:
// [LoadLocal a] ──┐
//                  ├── [Add] ── [StoreLocal result]
// [LoadLocal b] ──┘

// Java 源码
public int compute(int x, int y) {
    int a = x + y;
    int b = x * 2;
    return a - b;
}

// C2 Sea of Nodes IR (概念表示)
//
// [Parm x] ──┐              ┌── [Parm x]
//            │              │
//            ▼              ▼
// [Parm y] → [Add]      [Con 2] → [Mul]
//               │                    │
//               ▼                    ▼
//               └──────→ [Sub] ←────┘
//                          │
//                          ▼
//                       [Return]

# 查看 C2 编译的 IR (需要 debug build)
java -XX:+PrintOptoAssembly MyApp

# 使用 Ideal Graph Visualizer (IGV)
java -XX:+UnlockDiagnosticVMOptions \
     -XX:+PrintIdeal \
     -XX:PrintIdealGraphLevel=1 \
     MyApp

# 使用 Graal 替代 C2
java -XX:+UnlockExperimentalVMOptions \
     -XX:+EnableJVMCI \
     -XX:+UseJVMCICompiler \
     -XX:+UseJVMCICompiler \
     MyApp

# 仅在最后一个编译层使用 Graal
java -XX:+UnlockExperimentalVMOptions \
     -XX:+EnableJVMCI \
     -XX:+UseJVMCICompiler \
     -XX:TieredStopAtLevel=4 \
     MyApp

// 标量替换示例
public class EscapeAnalysisDemo {
    
    // 对象不逃逸 - 可以标量替换
    public int scalarReplacement() {
        Point p = new Point(3, 4);  // 对象不逃逸
        return p.x + p.y;           // 替换为: return 3 + 4;
    }
    
    // C2 优化后等价于:
    // public int scalarReplacement() {
    //     return 7;  // 常量折叠
    // }
    
    static class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }
    }
    
    // 对象逃逸 - 无法优化
    private Point savedPoint;
    
    public void globalEscape() {
        Point p = new Point(1, 2);
        savedPoint = p;  // 逃逸到实例字段
    }
    
    // 部分逃逸
    public int partialEscape(boolean condition) {
        Point p = new Point(1, 2);
        if (condition) {
            return p.x + p.y;  // 对象可以标量替换
        }
        return 0;  // 另一条路径不使用 p
    }
}

# 查看逃逸分析结果
java -XX:+DoEscapeAnalysis \
     -XX:+PrintEscapeAnalysis \
     -XX:+PrintEliminateAllocations \
     MyApp

// 锁消除示例
public class LockElimination {
    
    // StringBuffer 的锁可以被消除
    public String buildString(String[] items) {
        StringBuffer sb = new StringBuffer();  // sb 不逃逸
        for (String item : items) {
            sb.append(item);  // 锁操作可以消除
        }
        return sb.toString();
    }
    
    // C2 优化后等价于:
    // public String buildString(String[] items) {
    //     StringBuilder sb = new StringBuilder();  // 无锁版本
    //     for (String item : items) {
    //         sb.append(item);
    //     }
    //     return sb.toString();
    // }
    
    // 显式同步块也可以消除
    public int compute(int x) {
        Object lock = new Object();  // lock 不逃逸
        synchronized (lock) {        // 锁可以消除
            return x * 2;
        }
    }
}

// 栈上分配示例
public class StackAllocation {
    
    // 在某些情况下，对象可以在栈上分配
    // 栈上分配的对象无需 GC
    public long stackAllocExample() {
        long sum = 0;
        for (int i = 0; i < 100000; i++) {
            // 这个对象可以栈上分配（理想情况）
            // 实际上 HotSpot 主要使用标量替换而非栈上分配
            Value v = new Value(i);
            sum += v.x;
        }
        return sum;
    }
    
    static class Value {
        final int x;
        Value(int x) { this.x = x; }
    }
}

// 内联示例
public class InliningDemo {
    
    // 小方法 - 容易被内联
    public int square(int x) {
        return x * x;
    }
    
    // 调用方
    public int compute(int a, int b) {
        return square(a) + square(b);
    }
    
    // 内联后等价于:
    // public int compute(int a, int b) {
    //     return (a * a) + (b * b);
    // }
}

# 内联相关参数
-XX:MaxInlineSize=35           # 小方法内联阈值（字节码大小）
-XX:FreqInlineSize=325         # 频繁方法内联阈值
-XX:MaxInlineLevel=9           # 最大内联深度
-XX:InlineSmallCode=2000       # 已编译代码大小阈值
-XX:MaxInlineSize=35           # C1 内联阈值
-XX:MaxInlineSize=325          # C2 内联阈值

# 查看内联决策
java -XX:+UnlockDiagnosticVMOptions \
     -XX:+PrintInlining \
     MyApp

// 虚方法内联
public class VirtualInlining {
    
    // 接口/虚方法
    interface Shape {
        double area();
    }
    
    class Circle implements Shape {
        double radius;
        public double area() { return Math.PI * radius * radius; }
    }
    
    class Rectangle implements Shape {
        double width, height;
        public double area() { return width * height; }
    }
    
    // 如果 Profile 显示主要调用 Circle.area()
    // C2 会推测优化为 Circle.area() 的内联版本
    public double totalArea(Shape[] shapes) {
        double total = 0;
        for (Shape s : shapes) {
            total += s.area();  // 可能被内联
        }
        return total;
    }
    
    // 使用 final 方法可以确保内联
    class OptimizedCircle implements Shape {
        double radius;
        public final double area() {  // final 确保不会被覆盖
            return Math.PI * radius * radius;
        }
    }
}

public class LoopOptimizations {
    
    // 1. 循环展开
    // 原始
    public void loopUnroll(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2;
        }
    }
    // 展开后 (概念)
    // for (int i = 0; i + 3 < arr.length; i += 4) {
    //     arr[i]   = arr[i]   * 2;
    //     arr[i+1] = arr[i+1] * 2;
    //     arr[i+2] = arr[i+2] * 2;
    //     arr[i+3] = arr[i+3] * 2;
    // }
    
    // 2. 循环不变量外提
    public void loopInvariant(int[] arr, int scale) {
        for (int i = 0; i < arr.length; i++) {
            // scale * 100 是循环不变量，可以外提
            arr[i] = scale * 100;
        }
    }
    // 优化后:
    // int temp = scale * 100;
    // for (int i = 0; i < arr.length; i++) {
    //     arr[i] = temp;
    // }
    
    // 3. 范围检查消除
    public int rangeCheck(int[] arr, int index) {
        if (index >= 0 && index < arr.length) {
            return arr[index];  // 边界检查可以消除
        }
        throw new IndexOutOfBoundsException();
    }
    
    // 4. 向量化 (SIMD)
    public void vectorize(float[] a, float[] b, float[] c) {
        for (int i = 0; i < a.length; i++) {
            c[i] = a[i] + b[i];  // 可以使用 SIMD 指令
        }
    }
}

# 查看循环优化
java -XX:+PrintCompilation \
     -XX:+UnlockDiagnosticVMOptions \
     -XX:+PrintInlining \
     -XX:+PrintOptoAssembly \
     MyApp

# 检查向量化
java -XX:+PrintCompilation \
     -XX:+UnlockDiagnosticVMOptions \
     -XX:+PrintIntrinsics \
     MyApp

# 循环展开参数
-XX:+UseLoopPredicate           # 循环谓词（默认开启）
-XX:+UnrollLimitLoop=16         # 循环展开限制
-XX:LoopUnrollLimit=60          # 循环展开复杂度限制

# 向量化参数
-XX:+UseVectorApiIntrinsics     # 向量 API 内置
-XX:+UseVectorCmov              # 向量条件移动

// Intrinsics 示例
public class IntrinsicsDemo {
    
    // System.arraycopy - 手写的优化内存拷贝
    public void arrayCopy(int[] src, int[] dst) {
        System.arraycopy(src, 0, dst, 0, src.length);
    }
    
    // String.equals - 针对字符串优化的比较
    public boolean stringEquals(String a, String b) {
        return a.equals(b);
    }
    
    // Math.max/min - 直接使用 CPU 指令
    public int max(int a, int b) {
        return Math.max(a, b);
    }
    
    // Integer.bitCount - 使用 POPCNT 指令
    public int bitCount(int x) {
        return Integer.bitCount(x);
    }
    
    // Unsafe 操作 - 直接内存访问
    // VarHandle (Java 9+) - 原子操作
}

# 查看 Intrinsics 使用
java -XX:+UnlockDiagnosticVMOptions \
     -XX:+PrintIntrinsics \
     MyApp

# 基本编译日志
java -XX:+PrintCompilation MyApp

# 详细编译日志（需要 debug build）
java -XX:+UnlockDiagnosticVMOptions \
     -XX:+LogCompilation \
     -XX:LogFile=hotspot.log \
     MyApp

# 使用 JITWatch 工具分析
# https://github.com/AdoptOpenJDK/jitwatch

# 编译阈值
-XX:CompileThreshold=10000       # 方法调用次数阈值
-XX:OnStackReplacePercentage=140 # OSR 编译阈值

# 内联
-XX:MaxInlineSize=35             # 小方法内联阈值
-XX:FreqInlineSize=325           # 频繁方法内联阈值
-XX:MaxInlineLevel=9             # 最大内联深度

# 逃逸分析
-XX:+DoEscapeAnalysis            # 启用逃逸分析（默认开启）
-XX:+EliminateAllocations        # 启用标量替换（默认开启）
-XX:+EliminateLocks              # 启用锁消除（默认开启）

# 分层编译
-XX:+TieredCompilation           # 启用分层编译
-XX:TieredStopAtLevel=4          # 停止在哪个层级

// 使用 JMH 进行基准测试
import org.openjdk.jmh.annotations.*;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@Fork(2)
public class MyBenchmark {

    private int[] data;

    @Setup
    public void setup() {
        data = new int[10000];
        for (int i = 0; i < data.length; i++) {
            data[i] = i;
        }
    }

    @Benchmark
    public long sumArray() {
        long sum = 0;
        for (int v : data) {
            sum += v;
        }
        return sum;
    }

    @Benchmark
    public long sumStream() {
        return Arrays.stream(data).asLongStream().sum();
    }
}

# 运行 JMH 基准测试
mvn clean install
java -jar target/benchmarks.jar

# 使用 JMH 运行并收集 JIT 日志
java -XX:+PrintCompilation -jar target/benchmarks.jar