// C# 代码
public int Add(int a, int b) {
    return a + b;
}

// RyuJIT GenTree IR (概念表示)
// 
// GenTreeStmt
// └── GenTreeReturn
//     └── GenTreeOp(ADD)
//         ├── GenTreeLclVar(a)
//         └── GenTreeLclVar(b)

// 更复杂的 IR 示例
public int Compute(int x) {
    int a = x * 2;
    int b = a + 1;
    return b * b;
}

// GenTree 表示 (简化)
// [0] LCL_VAR  x = ARG
// [1] CNS_INT  2
// [2] MUL      a = x * 2
// [3] CNS_INT  1
// [4] ADD      b = a + 1
// [5] MUL      result = b * b
// [6] RETURN   result

// RyuJIT 内联示例
public class InliningDemo {
    
    // 简单方法 - 会被内联
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int Square(int x) => x * x;
    
    // 调用方
    public int Compute(int a, int b) {
        return Square(a) + Square(b);
    }
    // 内联后等价于:
    // return (a * a) + (b * b);
    
    // 避免内联
    [MethodImpl(MethodImplOptions.NoInlining)]
    public void NeverInline() {
        // 这个方法不会被内联
    }
}

// 内联限制
// - 方法体 IL 大小 ≤ 16 字节：总是内联
// - 方法体 IL 大小 > 16 字节：考虑调用频率
// - 虚方法：需要去虚拟化才能内联

// 边界检查消除
public class BoundsCheckDemo {
    
    // 原始代码 - 有边界检查
    public int Sum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.Length; i++) {
            sum += arr[i];  // 每次访问都有边界检查
        }
        return sum;
    }
    
    // RyuJIT 优化后:
    // - 消除了循环内的边界检查
    // - 只保留循环前的长度检查
    
    // 手动优化 - 使用 Span<T>
    public int SumOptimized(int[] arr) {
        int sum = 0;
        Span<int> span = arr.AsSpan();
        for (int i = 0; i < span.Length; i++) {
            sum += span[i];  // 可以更好地优化
        }
        return sum;
    }
    
    // 使用 ref 局部变量
    public void Double(int[] arr) {
        for (int i = 0; i < arr.Length; i++) {
            ref int val = ref arr[i];
            val *= 2;  // 减少索引操作
        }
    }
}

// 结构体优化
public struct Point {
    public double X;
    public double Y;
    
    public Point(double x, double y) {
        X = x;
        Y = y;
    }
    
    public double DistanceTo(Point other) {
        double dx = X - other.X;
        double dy = Y - other.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

public class StructOptimization {
    // 结构体通常在栈上分配，无需 GC
    public double ComputeDistance() {
        Point p1 = new Point(1, 2);
        Point p2 = new Point(4, 6);
        return p1.DistanceTo(p2);
    }
    
    // readonly struct - 更多优化机会
    public readonly struct Vector3 {
        public readonly double X, Y, Z;
        
        public Vector3(double x, double y, double z) {
            X = x; Y = y; Z = z;
        }
        
        public double Length => Math.Sqrt(X * X + Y * Y + Z * Z);
    }
}

// 启用分层编译 (默认启用)
// dotnet run -c Release

// 或在 .csproj 中配置
// <PropertyGroup>
//     <TieredCompilation>true</TieredCompilation>
// </PropertyGroup>

# 查看分层编译日志
DOTNET_TieredCompilation=1 dotnet run -c Release
DOTNET_JitEnableNoGC=1 dotnet run -c Release

# 关闭分层编译
DOTNET_TieredCompilation=0 dotnet run -c Release

# 只使用 Tier 0 (快速 JIT)
DOTNET_TieredCompilation=0 DOTNET_TieredQuickJit=1 dotnet run -c Release

// .NET 7+ 支持 OSR
// 允许正在执行的方法被替换为优化版本

public class OSRDemo {
    public long HotLoop() {
        long sum = 0;
        // 长时间运行的循环
        // 当循环变热时，可以被 OSR 替换为优化版本
        for (long i = 0; i < 100_000_000; i++) {
            sum += i;
        }
        return sum;
    }
}

// .NET 8+ 默认启用动态 PGO
// 无需代码更改，运行时自动优化

public class DynamicPGODemo {
    
    // 运行时会收集以下信息:
    // - 方法调用频率
    // - 分支预测信息
    // - 类型分布
    // - 循环次数
    
    public int ProcessShape(Shape shape) {
        // PGO 记录: 99% 的调用是 Circle
        if (shape is Circle circle) {
            return (int)(circle.Radius * circle.Radius * Math.PI);
        }
        else if (shape is Rectangle rect) {
            return rect.Width * rect.Height;
        }
        return 0;
    }
    
    // 基于 PGO 的优化:
    // 1. 类型检查顺序优化（Circle 放在前面）
    // 2. 内联热路径
    // 3. 分支预测优化
}

# 启用动态 PGO (默认启用)
DOTNET_TieredPGO=1 dotnet run -c Release

# 查看 PGO 统计
DOTNET_JitPrintInlinedMethods=1 dotnet run -c Release

// 静态 PGO - 使用收集的 profile 数据
// 1. 收集 profile
// dotnet run -c Release -- --pgo-collect

// 2. 使用 profile 编译
// dotnet publish -c Release /p:PGOEnabled=true

// .csproj 配置
// <PropertyGroup>
//     <TieredPGO>true</TieredPGO>
//     <ReadyToRun>true</ReadyToRun>
// </PropertyGroup>

// PGO 优化示例

// 1. 条件分支优化
public int BranchOptimization(bool flag) {
    // PGO 发现 flag 99% 为 true
    if (flag) {      // 热路径，优化执行
        return 1;
    } else {         // 冷路径
        return 0;
    }
}

// 2. 去虚拟化
public int ProcessShape(Shape shape) {
    // PGO 发现 shape 90% 是 Circle
    // 编译器生成: if (shape.GetType() == typeof(Circle)) { 内联Circle代码 }
    return shape.Area();
}

// 3. 内联决策
public int HotMethod(int x) {
    // PGO 发现此方法被频繁调用
    // 即使方法体较大也可能被内联
    return Compute(x) + Transform(x);
}

<!-- 启用 ReadyToRun -->
<PropertyGroup>
    <PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>

# 发布 ReadyToRun 版本
dotnet publish -c Release -r linux-x64 /p:PublishReadyToRun=true

// 使用 Span<T> 减少分配
public class SpanDemo {
    
    // ❌ 会分配新数组
    public byte[] ProcessArray(byte[] data) {
        byte[] result = new byte[data.Length];
        for (int i = 0; i < data.Length; i++) {
            result[i] = (byte)(data[i] * 2);
        }
        return result;
    }
    
    // ✅ 使用 Span<T> 零分配
    public void ProcessSpan(Span<byte> data) {
        for (int i = 0; i < data.Length; i++) {
            data[i] = (byte)(data[i] * 2);
        }
    }
    
    // 字符串处理
    public int CountWords(ReadOnlySpan<char> text) {
        int count = 0;
        bool inWord = false;
        
        foreach (char c in text) {
            if (char.IsWhiteSpace(c)) {
                inWord = false;
            } else if (!inWord) {
                inWord = true;
                count++;
            }
        }
        return count;
    }
}

// 装箱优化
public class BoxingDemo {
    
    // ❌ 装箱 - 分配堆内存
    public void PrintValue(object value) {
        Console.WriteLine(value);  // 值类型会被装箱
    }
    
    // ✅ 泛型 - 避免装箱
    public void PrintValue<T>(T value) {
        Console.WriteLine(value);  // 无装箱
    }
    
    // ❌ 接口装箱
    public void Process(IComparable comparable) {
        // comparable.CompareTo(...) 会导致装箱
    }
    
    // ✅ 泛型约束
    public void Process<T>(T value) where T : IComparable<T> {
        // value.CompareTo(...) 无装箱
    }
}

// 使用 System.Numerics.Vector
using System.Numerics;

public class SimdDemo {
    
    // SIMD 向量加法
    public void AddVectors(float[] a, float[] b, float[] result) {
        int simdLength = Vector<float>.Count;
        int i = 0;
        
        // SIMD 处理
        for (; i <= a.Length - simdLength; i += simdLength) {
            var va = new Vector<float>(a, i);
            var vb = new Vector<float>(b, i);
            (va + vb).CopyTo(result, i);
        }
        
        // 处理剩余元素
        for (; i < a.Length; i++) {
            result[i] = a[i] + b[i];
        }
    }
    
    // .NET 8+ Vector128/Vector256
    public void AddVectors128(float[] a, float[] b, float[] result) {
        int i = 0;
        for (; i <= a.Length - Vector128<float>.Count; i += Vector128<float>.Count) {
            var va = Vector128.LoadUnsafe(ref a[i]);
            var vb = Vector128.LoadUnsafe(ref b[i]);
            (va + vb).StoreUnsafe(ref result[i]);
        }
        for (; i < a.Length; i++) {
            result[i] = a[i] + b[i];
        }
    }
}

// 零分配模式
public class ZeroAllocation {
    
    // 使用 ArrayPool
    public void ProcessLargeData(int size) {
        var pool = ArrayPool<int>.Shared;
        int[] buffer = pool.Rent(size);
        
        try {
            // 使用 buffer
            for (int i = 0; i < size; i++) {
                buffer[i] = i;
            }
        } finally {
            pool.Return(buffer);
        }
    }
    
    // 使用 stackalloc
    public void SmallBuffer() {
        Span<byte> buffer = stackalloc byte[256];
        // 使用 buffer
    }
    
    // 使用对象池
    private readonly ObjectPool<StringBuilder> _sbPool =
        new DefaultObjectPoolProvider().CreateStringBuilderPool();
    
    public string BuildString(IEnumerable<string> items) {
        var sb = _sbPool.Get();
        try {
            foreach (var item in items) {
                sb.Append(item);
            }
            return sb.ToString();
        } finally {
            _sbPool.Return(sb);
        }
    }
}

# 安装 dotnet-trace
dotnet tool install --global dotnet-trace

# 收集跟踪
dotnet-trace collect --process-id <PID>

# 使用 Chromium 查看
# chrome://tracing/

// 使用 BenchmarkDotNet
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
[DisassemblyDiagnoser]
public class MyBenchmarks {
    private int[] data;
    
    [GlobalSetup]
    public void Setup() {
        data = Enumerable.Range(0, 10000).ToArray();
    }
    
    [Benchmark(Baseline = true)]
    public long ForLoop() {
        long sum = 0;
        for (int i = 0; i < data.Length; i++) {
            sum += data[i];
        }
        return sum;
    }
    
    [Benchmark]
    public long Foreach() {
        long sum = 0;
        foreach (var item in data) {
            sum += item;
        }
        return sum;
    }
    
    [Benchmark]
    public long Linq() => data.Sum(x => (long)x);
}

// 运行
// BenchmarkRunner.Run<MyBenchmarks>();

# JIT 编译信息
DOTNET_JitPrintInlinedMethods=1 dotnet run -c Release

# 导出 JIT 日志
DOTNET_JitEnableNoGC=1 dotnet run -c Release

# 使用 jitutils
# https://github.com/dotnet/jitutils
dotnet tool install --global jitutils