1
┌─────────────────────────────────────────────────┐
2
│  Tier 0: 快速编译 (Quick JIT)                   │
3
│  - 几乎不优化                                    │
4
│  - 编译速度优先（< 1ms）                         │
5
│  - 产生"预备份"机器码                            │
6
│  - 主要目的：字节码 → 本机码（越快越好）          │
7
│  - 同时：记录调用计数等运行时数据                 │
8
├─────────────────────────────────────────────────┤
9
│  Tier 1: 优化编译 (Optimizing JIT)               │
10
│  - 方法被调用超过 ~30 次后触发                   │
11
│  - 使用完整的 RyuJIT 优化管线                    │
12
│  - 内联展开、循环优化、边界检查消除               │
13
│  - 基于运行时数据的 profile-guided 优化          │
14
│  - 编译完成后，所有现有调用点热替换为优化版本      │
15
└─────────────────────────────────────────────────┘

1
// 分层编译的实际效果
2
// 冷路径：Tier 0 → 启动快
3
// 热路径：Tier 1 → 运行快
4

5
void GameLoop()
6
{
7
    // 主循环：每帧调用，很快触发 Tier 1
8
    for (int frame = 0; frame < 100000; frame++)
9
    {
10
        UpdateAI();    // 前 30 帧：Tier 0（较慢）
11
                       // 30 帧后：自动切换到 Tier 1（优化后）
12
    }
13

14
    // 启动逻辑：只调用一次，始终 Tier 0
15
    InitializeOnce();  // 永远不需要 Tier 1
16
}

1
// IL2CPP 生成的 C++（高度简化）
2
// 原始 C#：
3
//   public void Damage(int amount) { HP -= amount; }
4

5
// 生成的 C++ 大致逻辑：
6
void Player_Damage_m12345(Player_t* __this, int32_t amount, MethodInfo* method)
7
{
8
    // NullReferenceException 检查
9
    if (__this == NULL)
10
        il2cpp::vm::Exception::RaiseNullReferenceException();
11

12
    // 字段访问 = 偏移量计算
13
    int32_t* hpField = (int32_t*)((uint8_t*)__this + kPlayer_HP_Offset);
14
    *hpField -= amount;
15

16
    // 泛型共享实现（运行时类型信息传入）
17
    // 虚方法调用通过 vtable 间接跳转
18
}

1
// 问题 1：泛型虚拟方法 — IL2CPP 需要提前生成所有可能的实例化
2
public class Processor<T> where T : IProcessable
3
{
4
    public virtual void Process(T item) { /* ... */ }
5
}
6
// IL2CPP 不知道 T 可能是哪些具体类型
7
// 解决：添加 link.xml 保留需要的泛型实例化
8

9
// 问题 2：反射 —— 未直接引用的类型会被 Strip
10
Type.GetType("MyGame.Weapons.LegendarySword");
11
// 如果 LegendarySword 没被直接 new 过，IL2CPP 可能移除它
12
// 解决：link.xml 中 preserve，或使用 [Preserve] 属性
13

14
// 问题 3：System.Reflection.Emit —— 完全不可用
15
// IL2CPP 是 AOT，无法在运行时生成 IL 再编译
16
// 替代：Source Generator (见第八章) 或手写替代代码

1
// === 策略 1：值类型泛型 —— 按大小分组共享 ===
2
// IL2CPP 为每种不同大小的值类型泛型生成独立代码
3
List<int> intList;       // sizeof(int) = 4 → 生成 List_Int32
4
List<float> floatList;   // sizeof(float) = 4 → 可以共享 List_Int32 的代码！
5
List<double> doubleList; // sizeof(double) = 8 → 生成 List_Double
6
List<long> longList;     // sizeof(long) = 8 → 共享 List_Double 的代码
7

8
// 注意：共享的前提是 GC 描述符相同
9
// int 和 float 都是 4 字节且不含引用 → 可以共享
10
// Vector3 (12字节，无引用) 和某个 12 字节 struct → 可以共享
11

12
// === 策略 2：引用类型泛型 —— 全部共享 ===
13
// 所有引用类型泛型共享同一份机器码（和 JIT 一样）
14
List<string> strList;
15
List<Player> playerList;
16
List<Enemy> enemyList;
17
// 三个 list 共享同一份 List<object> 的机器码
18
// 原因：所有引用类型在运行时都是 8 字节指针（64位），行为一致
19

20
// === 策略 3：推测性生成（Speculative Generation） ===
21
// IL2CPP 扫描所有 IL 代码中的显式实例化
22
void KnownUsage()
23
{
24
    var a = new List<int>();           // ✓ 被扫描到 → 生成
25
    var b = new Dictionary<int, string>(); // ✓ 被扫描到 → 生成
26
}
27

28
// 但无法处理反射创建
29
void UnknownUsage()
30
{
31
    Type t = Type.GetType("System.Collections.Generic.List`1");
32
    Type closed = t.MakeGenericType(typeof(SomeRuntimeType));
33
    var instance = Activator.CreateInstance(closed);
34
    // ✗ IL2CPP 不知道 SomeRuntimeType 是什么 → 缺少代码 → 运行时异常！
35
}
36

37
// 解决：在 link.xml 中显式声明
38
// <assembly fullname="mscorlib">
39
//   <type fullname="System.Collections.Generic.List`1">
40
//     <genericargument name="MyGame.SomeRuntimeType" />
41
//   </type>
42
// </assembly>

1
┌──────────────────────────────────────────┐
2
│ Type 对象 (托管堆，反射可见)               │
3
│  - Name, Namespace, Assembly              │
4
│  - GetMethods(), GetProperties()          │
5
│  - 慢路径：每次调用都查内部结构            │
6
└──────────────┬───────────────────────────┘
7
               │ 每个 Type 持有一个指针
8
┌──────────────▼───────────────────────────┐
9
│ MethodTable (EE 堆，仅 CLR 内部可见)      │
10
│  - 虚方法槽表 (vtable slots)              │
11
│  - 接口映射表 (interface dispatch map)     │
12
│  - 基类指针 (parent MethodTable)          │
13
│  - 字段布局描述 (offset + size)           │
14
│  - GC 描述符 (哪些字段是引用，需要 GC 追踪) │
15
└──────────────────────────────────────────┘

1
// 这段代码在 IL2CPP 下的开销远大于 Mono JIT
2
void ProcessObjects(List<object> items)
3
{
4
    foreach (var item in items)
5
    {
6
        if (item is IDamageable d)  // 每次迭代：isinst IL 指令
7
            d.TakeDamage(10);       // 接口虚调用：查接口映射表
8
    }
9
}
10

11
// 优化：如果可以确定类型，避免频繁的 is 检查和接口调用
12
// 将 IDamageable 作为存储类型而非 object
13
void ProcessObjects(List<IDamageable> items)
14
{
15
    foreach (var item in items)
16
        item.TakeDamage(10);  // 省去 isinst，但接口调度仍然存在
17
}

1
// 游戏的热更新系统 —— 使用 AssemblyLoadContext 实现 DLL 热替换
2
public class HotUpdateManager
3
{
4
    private AssemblyLoadContext _currentContext;
5
    private Type _gameLogicType;
6
    private object _gameLogicInstance;
7

8
    public bool LoadHotUpdateDll(string dllPath)
9
    {
10
        // 卸载旧版本
11
        if (_currentContext != null)
12
        {
13
            _gameLogicInstance = null;
14
            _gameLogicType = null;
15
            _currentContext.Unload();
16
            GC.Collect();
17
            GC.WaitForPendingFinalizers();
18
        }
19

20
        // 加载新版本
21
        _currentContext = new AssemblyLoadContext("HotUpdate", isCollectible: true);
22
        var asm = _currentContext.LoadFromAssemblyPath(dllPath);
23
        _gameLogicType = asm.GetType("HotUpdate.GameLogic");
24
        _gameLogicInstance = Activator.CreateInstance(_gameLogicType);
25

26
        return true;
27
    }
28

29
    public void Update()
30
    {
31
        // 通过反射调用热更 DLL 中的方法
32
        _gameLogicType?.GetMethod("OnUpdate")?.Invoke(_gameLogicInstance, null);
33
    }
34
}

1
// 为 IL2CPP 准备的泛型代码 —— 避免运行时无法解析的泛型实例化
2
public static class IL2CPPSafeGenerics
3
{
4
    // 这些显式调用确保 IL2CPP 生成所需的泛型实例化
5
    static IL2CPPSafeGenerics()
6
    {
7
        // 强制 IL2CPP 生成这些具体类型
8
        ForceGeneric<List<int>>();
9
        ForceGeneric<List<float>>();
10
        ForceGeneric<List<string>>();
11
        ForceGeneric<Dictionary<int, string>>();
12
        ForceGeneric<Dictionary<string, object>>();
13
    }
14

15
    [MethodImpl(MethodImplOptions.NoInlining)]
16
    static void ForceGeneric<T>() { /* 空方法，只为触发泛型代码生成 */ }
17
}
18

19
// 或者使用 link.xml：
20
// <linker>
21
//   <assembly fullname="mscorlib">
22
//     <type fullname="System.Collections.Generic.List`1">
23
//       <genericargument name="MyGame.Player" />
24
//     </type>
25
//   </assembly>
26
// </linker>

1
// 在 Loading 场景"预热"关键代码路径
2
public class JITWarmup : MonoBehaviour
3
{
4
    IEnumerator Start()
5
    {
6
        var progress = ShowLoadingScreen("正在优化性能...");
7

8
        // 强制 JIT 编译以下方法（Tier 1 优化会在游戏开始前完成）
9
        yield return null;
10
        WarmupMath();
11

12
        progress.SetText("准备战斗系统...");
13
        yield return null;
14
        WarmupCombat();
15

16
        progress.SetText("准备 AI 系统...");
17
        yield return null;
18
        WarmupAI();
19

20
        progress.Complete();
21
        SceneManager.LoadScene("Game");
22
    }
23

24
    void WarmupMath()
25
    {
26
        // 多次调用触发 Tier 1 优化
27
        for (int i = 0; i < 100; i++)
28
        {
29
            Vector3.Dot(Vector3.one, Vector3.up);
30
            Mathf.Sin(i * 0.1f);
31
        }
32
    }
33

34
    void WarmupCombat()
35
    {
36
        var dummy = new DamageCalculator();
37
        for (int i = 0; i < 50; i++)
38
        {
39
            dummy.CalculateDamage(i * 10, 50, 0.2f);
40
        }
41
    }
42

43
    void WarmupAI()
44
    {
45
        var dummy = new PathFinder();
46
        for (int i = 0; i < 50; i++)
47
        {
48
            dummy.FindPath(Vector3.zero, new Vector3(i * 2, 0, i * 2));
49
        }
50
    }
51
}