内联函数：调用栈的优化 ​

// 函数调用开销分析
class FunctionCallOverhead {
  static demonstrate() {
    console.log('=== 函数调用的开销 ===\n');
    
    console.log('一次函数调用包含的操作：');
    console.log('');
    console.log('  调用前：');
    console.log('    1. 计算参数值');
    console.log('    2. 将参数压入栈或寄存器');
    console.log('    3. 保存返回地址');
    console.log('    4. 跳转到函数代码');
    console.log('');
    console.log('  函数入口：');
    console.log('    5. 创建新的栈帧');
    console.log('    6. 保存调用者的寄存器');
    console.log('    7. 初始化局部变量');
    console.log('');
    console.log('  函数出口：');
    console.log('    8. 准备返回值');
    console.log('    9. 恢复调用者的寄存器');
    console.log('    10. 弹出栈帧');
    console.log('    11. 跳转回调用点\n');
  }
  
  static demonstrateStackFrame() {
    console.log('=== 函数栈帧结构 ===\n');
    
    console.log('调用 foo(1, 2) 时的栈帧：');
    console.log('');
    console.log('  高地址 ┌─────────────────────┐');
    console.log('         │ 参数2: 2            │');
    console.log('         │ 参数1: 1            │');
    console.log('         │ 返回地址            │');
    console.log('         │ 旧的帧指针 (rbp)    │ ← 当前帧指针');
    console.log('         │ 保存的寄存器        │');
    console.log('         │ 局部变量            │');
    console.log('  低地址 │ 临时数据            │ ← 栈指针 (rsp)');
    console.log('         └─────────────────────┘');
    console.log('');
    console.log('每个栈帧占用内存，深度调用链消耗大量栈空间\n');
  }
  
  static demonstrateBenchmark() {
    console.log('=== 调用开销基准测试 ===\n');
    
    // 内联版本：直接计算
    function sumInlined(a, b, c, d) {
      return a + b + c + d;
    }
    
    // 调用版本：通过函数调用
    function add(x, y) {
      return x + y;
    }
    
    function sumWithCalls(a, b, c, d) {
      return add(add(a, b), add(c, d));
    }
    
    const iterations = 10000000;
    
    // 预热
    for (let i = 0; i < 1000; i++) {
      sumInlined(1, 2, 3, 4);
      sumWithCalls(1, 2, 3, 4);
    }
    
    // 测试内联版本
    console.time('直接计算');
    let sum1 = 0;
    for (let i = 0; i < iterations; i++) {
      sum1 += sumInlined(i, i+1, i+2, i+3);
    }
    console.timeEnd('直接计算');
    
    // 测试调用版本
    console.time('函数调用');
    let sum2 = 0;
    for (let i = 0; i < iterations; i++) {
      sum2 += sumWithCalls(i, i+1, i+2, i+3);
    }
    console.timeEnd('函数调用');
    
    console.log('');
    console.log('注意：TurboFan可能会内联add函数，');
    console.log('使两个版本性能接近\n');
  }
  
  static runAll() {
    this.demonstrate();
    this.demonstrateStackFrame();
    this.demonstrateBenchmark();
  }
}

FunctionCallOverhead.runAll();

// 内联基本原理
class InliningBasics {
  static demonstrate() {
    console.log('=== 内联的基本原理 ===\n');
    
    console.log('原始代码：');
    console.log(`
    function square(x) {
      return x * x;
    }
    
    function sumOfSquares(a, b) {
      return square(a) + square(b);
    }
    
    sumOfSquares(3, 4);  // 调用
    `);
    
    console.log('内联后等价于：');
    console.log(`
    function sumOfSquares_inlined(a, b) {
      // square(a) 被替换为 a * a
      const sq_a = a * a;
      // square(b) 被替换为 b * b
      const sq_b = b * b;
      return sq_a + sq_b;
    }
    
    sumOfSquares_inlined(3, 4);
    `);
    
    console.log('进一步优化（常量折叠）：');
    console.log(`
    // 如果参数是常量
    sumOfSquares(3, 4)
    // 可以直接计算
    → 3 * 3 + 4 * 4
    → 9 + 16
    → 25
    `);
  }
  
  static demonstrateBenefits() {
    console.log('=== 内联的好处 ===\n');
    
    console.log('1. 消除调用开销');
    console.log('   • 无需保存/恢复寄存器');
    console.log('   • 无需创建栈帧');
    console.log('   • 无需跳转指令\n');
    
    console.log('2. 启用更多优化');
    console.log('   • 常量传播：参数是常量时可以折叠');
    console.log('   • 死代码消除：移除不需要的代码路径');
    console.log('   • 公共子表达式消除：避免重复计算');
    console.log('   • 逃逸分析：内联后更容易分析对象生命周期\n');
    
    console.log('3. 改善指令缓存');
    console.log('   • 代码更紧凑');
    console.log('   • 减少跳转，提高预取效率\n');
  }
  
  static demonstrateChainedInlining() {
    console.log('=== 链式内联 ===\n');
    
    console.log('原始调用链：');
    console.log(`
    function a(x) { return b(x) + 1; }
    function b(x) { return c(x) * 2; }
    function c(x) { return x + 10; }
    
    a(5);  // 调用链：a → b → c
    `);
    
    console.log('完全内联后：');
    console.log(`
    function a_fully_inlined(x) {
      // c(x) = x + 10
      // b(x) = c(x) * 2 = (x + 10) * 2
      // a(x) = b(x) + 1 = (x + 10) * 2 + 1
      return (x + 10) * 2 + 1;
    }
    
    a_fully_inlined(5);  // 直接计算：31
    `);
    
    // 验证
    function a(x) { return b(x) + 1; }
    function b(x) { return c(x) * 2; }
    function c(x) { return x + 10; }
    
    console.log(`a(5) = ${a(5)}`);
    console.log(`(5 + 10) * 2 + 1 = ${(5 + 10) * 2 + 1}\n`);
  }
  
  static runAll() {
    this.demonstrate();
    this.demonstrateBenefits();
    this.demonstrateChainedInlining();
  }
}

InliningBasics.runAll();

// 内联决策因素
class InliningDecisions {
  static demonstrateFactors() {
    console.log('=== 内联决策因素 ===\n');
    
    console.log('TurboFan考虑的因素：\n');
    
    console.log('1. 函数大小');
    console.log('   • 小函数优先内联');
    console.log('   • 大函数可能不内联（代码膨胀）');
    console.log('   • 阈值约为600字节码\n');
    
    console.log('2. 调用频率');
    console.log('   • 热点调用优先内联');
    console.log('   • 冷路径调用可能不内联');
    console.log('   • 基于类型反馈判断\n');
    
    console.log('3. 调用点类型');
    console.log('   • 单态调用：最容易内联');
    console.log('   • 多态调用：可能部分内联');
    console.log('   • 超态调用：通常不内联\n');
    
    console.log('4. 内联深度');
    console.log('   • 有最大内联深度限制');
    console.log('   • 防止过度内联导致代码膨胀\n');
    
    console.log('5. 内联预算');
    console.log('   • 每个函数有内联大小预算');
    console.log('   • 超出预算后停止内联\n');
  }
  
  static demonstrateSizeThreshold() {
    console.log('=== 函数大小与内联 ===\n');
    
    console.log('小函数（容易内联）：');
    console.log(`
    function isEven(n) {
      return n % 2 === 0;
    }
    
    function double(x) {
      return x * 2;
    }
    
    function getFirst(arr) {
      return arr[0];
    }
    `);
    
    console.log('大函数（可能不内联）：');
    console.log(`
    function processData(data) {
      // 数百行代码...
      // 复杂的业务逻辑
      // 多个循环和条件
      // ...
    }
    `);
    
    console.log('相关V8标志：');
    console.log('  --max-inlined-bytecode-size: 最大内联字节码大小');
    console.log('  --max-inlined-bytecode-size-small: 小函数阈值\n');
  }
  
  static demonstrateCallSiteTypes() {
    console.log('=== 调用点类型与内联 ===\n');
    
    console.log('单态调用（最佳）：');
    console.log(`
    function process(handler) {
      return handler.run();  // 始终同一个handler类型
    }
    
    class MyHandler {
      run() { return 42; }
    }
    
    const handler = new MyHandler();
    for (let i = 0; i < 10000; i++) {
      process(handler);  // 单态：容易内联
    }
    `);
    
    console.log('多态调用（部分内联）：');
    console.log(`
    function process(handler) {
      return handler.run();  // 见到2-4种handler类型
    }
    
    // 可能生成类似这样的代码：
    // if (handler.map === HandlerA_Map) {
    //   return 42;  // HandlerA.run 内联
    // } else if (handler.map === HandlerB_Map) {
    //   return 100; // HandlerB.run 内联
    // } else {
    //   return handler.run();  // 回退到调用
    // }
    `);
    
    console.log('超态调用（不内联）：');
    console.log(`
    function process(handler) {
      return handler.run();  // 见到太多handler类型
    }
    // TurboFan放弃内联，使用通用调用
    `);
  }
  
  static runAll() {
    this.demonstrateFactors();
    this.demonstrateSizeThreshold();
    this.demonstrateCallSiteTypes();
  }
}

InliningDecisions.runAll();

// 内联限制
class InliningLimitations {
  static demonstrateRecursion() {
    console.log('=== 限制1：递归函数 ===\n');
    
    console.log('递归函数无法完全内联：');
    console.log(`
    function factorial(n) {
      if (n <= 1) return 1;
      return n * factorial(n - 1);  // 自调用
    }
    `);
    
    console.log('原因：');
    console.log('  • 内联次数不确定');
    console.log('  • 会导致无限代码膨胀\n');
    
    console.log('TurboFan的处理：');
    console.log('  • 可能展开固定次数');
    console.log('  • 尾递归可能转为循环（如果支持）');
    console.log('  • 大多数情况保持递归调用\n');
  }
  
  static demonstrateTryFinally() {
    console.log('=== 限制2：try-finally块 ===\n');
    
    console.log('包含try-finally的函数难以内联：');
    console.log(`
    function withCleanup(fn) {
      try {
        return fn();
      } finally {
        cleanup();  // 必须执行
      }
    }
    `);
    
    console.log('原因：');
    console.log('  • finally块的控制流复杂');
    console.log('  • 需要处理正常返回和异常');
    console.log('  • 内联后难以保证finally执行\n');
  }
  
  static demonstrateEval() {
    console.log('=== 限制3：使用eval的函数 ===\n');
    
    console.log('使用eval的函数无法内联：');
    console.log(`
    function dynamicCode(code) {
      return eval(code);  // 动态代码
    }
    `);
    
    console.log('原因：');
    console.log('  • eval可能访问局部变量');
    console.log('  • 无法静态分析代码行为');
    console.log('  • 作用域必须保持动态\n');
  }
  
  static demonstrateArguments() {
    console.log('=== 限制4：复杂的arguments使用 ===\n');
    
    console.log('某些arguments用法阻止内联：');
    console.log(`
    function varArgs() {
      // 简单用法可能可以内联
      return arguments[0] + arguments[1];
    }
    
    function leakArguments() {
      // 泄露arguments对象，难以内联
      return Array.from(arguments);
    }
    
    function modifyArguments() {
      // 修改arguments，难以内联
      arguments[0] = 100;
      return arguments[0];
    }
    `);
  }
  
  static demonstrateBuiltins() {
    console.log('=== 限制5：某些内置函数 ===\n');
    
    console.log('某些内置函数不内联：');
    console.log(`
    // 可能内联的内置函数
    Math.abs(x);      // 简单数学运算
    Array.isArray(x); // 简单类型检查
    
    // 通常不内联的内置函数
    JSON.parse(str);  // 复杂解析逻辑
    console.log(msg); // 有副作用
    fetch(url);       // 异步操作
    `);
  }
  
  static runAll() {
    this.demonstrateRecursion();
    this.demonstrateTryFinally();
    this.demonstrateEval();
    this.demonstrateArguments();
    this.demonstrateBuiltins();
  }
}

InliningLimitations.runAll();

// 代码膨胀
class CodeBloat {
  static demonstrate() {
    console.log('=== 代码膨胀问题 ===\n');
    
    console.log('场景：函数在多处被调用');
    console.log(`
    function helper(x) {
      // 10行代码
    }
    
    function a() { helper(1); }
    function b() { helper(2); }
    function c() { helper(3); }
    // ... 100个调用点
    `);
    
    console.log('不内联：');
    console.log('  • helper代码：10行');
    console.log('  • 调用点代码：100 × 1行 = 100行');
    console.log('  • 总计：约110行\n');
    
    console.log('全部内联：');
    console.log('  • helper代码：0行（被内联）');
    console.log('  • 调用点代码：100 × 10行 = 1000行');
    console.log('  • 总计：约1000行\n');
    
    console.log('代码膨胀的影响：');
    console.log('  • 增加内存使用');
    console.log('  • 降低指令缓存效率');
    console.log('  • 编译时间增加');
    console.log('  • 可能导致整体性能下降\n');
  }
  
  static demonstrateTradeoff() {
    console.log('=== 内联的权衡 ===\n');
    
    console.log('何时内联收益大：');
    console.log('  • 函数很小（几行代码）');
    console.log('  • 调用非常频繁（热点路径）');
    console.log('  • 内联后能启用其他优化');
    console.log('  • 调用点较少\n');
    
    console.log('何时内联收益小或有害：');
    console.log('  • 函数较大');
    console.log('  • 调用不频繁（冷路径）');
    console.log('  • 调用点很多');
    console.log('  • 已经接近代码大小限制\n');
  }
  
  static runAll() {
    this.demonstrate();
    this.demonstrateTradeoff();
  }
}

CodeBloat.runAll();

// 观察内联
class ObservingInlining {
  static demonstrateV8Flags() {
    console.log('=== 使用V8标志观察内联 ===\n');
    
    console.log('Node.js命令：');
    console.log('  node --trace-turbo-inlining script.js\n');
    
    console.log('输出示例：');
    console.log(`
    Inlining square into sumOfSquares
      reason: small function
      bytecode size: 8
    
    Not inlining processData into main
      reason: bytecode size too large
      bytecode size: 1500
    `);
    
    console.log('其他相关标志：');
    console.log('  --trace-opt: 跟踪优化过程');
    console.log('  --print-opt-code: 打印优化代码');
    console.log('  --trace-deopt: 跟踪去优化\n');
  }
  
  static demonstrateInliningInfo() {
    console.log('=== 内联决策信息 ===\n');
    
    console.log('常见的内联原因：');
    console.log('  • "small function": 函数够小');
    console.log('  • "constant function": 函数是常量');
    console.log('  • "always inline": 强制内联\n');
    
    console.log('常见的不内联原因：');
    console.log('  • "bytecode size too large": 函数太大');
    console.log('  • "max inlining depth reached": 深度超限');
    console.log('  • "inline budget exhausted": 预算耗尽');
    console.log('  • "recursive call": 递归调用');
    console.log('  • "not a monomorphic call": 非单态调用');
    console.log('  • "contains try": 包含try块\n');
  }
  
  static runAll() {
    this.demonstrateV8Flags();
    this.demonstrateInliningInfo();
  }
}

ObservingInlining.runAll();

// 编写易于内联的代码
class InliningFriendlyCode {
  static tip1_KeepFunctionsSmall() {
    console.log('=== 技巧1：保持函数小巧 ===\n');
    
    console.log('❌ 大型多功能函数：');
    console.log(`
    function processUser(user, options) {
      // 验证
      if (!user.name) throw new Error('Name required');
      if (!user.email) throw new Error('Email required');
      // ... 更多验证
      
      // 转换
      const normalized = {
        name: user.name.trim(),
        email: user.email.toLowerCase(),
        // ... 更多转换
      };
      
      // 保存
      database.save(normalized);
      
      // 通知
      sendEmail(user.email);
      
      return normalized;
    }
    `);
    
    console.log('✅ 拆分为小函数：');
    console.log(`
    function validateUser(user) {
      if (!user.name) throw new Error('Name required');
      if (!user.email) throw new Error('Email required');
    }
    
    function normalizeUser(user) {
      return {
        name: user.name.trim(),
        email: user.email.toLowerCase()
      };
    }
    
    function processUser(user, options) {
      validateUser(user);
      const normalized = normalizeUser(user);
      database.save(normalized);
      sendEmail(user.email);
      return normalized;
    }
    `);
    
    console.log('好处：');
    console.log('  • validateUser和normalizeUser可能被内联');
    console.log('  • 每个函数职责单一');
    console.log('  • 更易于测试和维护\n');
  }
  
  static tip2_PreferMonomorphicCalls() {
    console.log('=== 技巧2：保持单态调用 ===\n');
    
    console.log('❌ 多态调用（难以内联）：');
    console.log(`
    function process(handler) {
      return handler.execute();  // handler类型多变
    }
    
    process(new HandlerA());
    process(new HandlerB());
    process(new HandlerC());
    `);
    
    console.log('✅ 单态调用（容易内联）：');
    console.log(`
    function processA(handler) {
      return handler.execute();  // 只处理HandlerA
    }
    
    function processB(handler) {
      return handler.execute();  // 只处理HandlerB
    }
    
    // 或使用分发
    function process(handler) {
      if (handler instanceof HandlerA) {
        return processA(handler);
      } else if (handler instanceof HandlerB) {
        return processB(handler);
      }
    }
    `);
  }
  
  static tip3_AvoidDynamicFeatures() {
    console.log('=== 技巧3：避免动态特性 ===\n');
    
    console.log('❌ 使用动态特性：');
    console.log(`
    function calculate(a, b, op) {
      return eval(\`\${a} \${op} \${b}\`);  // eval阻止优化
    }
    
    function callMethod(obj, method) {
      return obj[method]();  // 动态方法调用
    }
    `);
    
    console.log('✅ 静态确定的操作：');
    console.log(`
    function calculate(a, b, op) {
      switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
      }
    }
    
    function callRun(obj) {
      return obj.run();  // 静态方法名
    }
    `);
  }
  
  static tip4_UseInlineHints() {
    console.log('=== 技巧4：利用内联提示 ===\n');
    
    console.log('V8会更积极地内联：');
    console.log('  • 箭头函数（通常较小）');
    console.log('  • getter/setter（通常较小）');
    console.log('  • 立即调用的函数\n');
    
    console.log('示例：');
    console.log(`
    // 箭头函数容易内联
    const double = x => x * 2;
    const square = x => x * x;
    
    // getter容易内联
    class Point {
      constructor(x, y) {
        this._x = x;
        this._y = y;
      }
      get x() { return this._x; }
      get y() { return this._y; }
      get length() { 
        return Math.sqrt(this._x ** 2 + this._y ** 2);
      }
    }
    `);
  }
  
  static runAll() {
    this.tip1_KeepFunctionsSmall();
    this.tip2_PreferMonomorphicCalls();
    this.tip3_AvoidDynamicFeatures();
    this.tip4_UseInlineHints();
  }
}

InliningFriendlyCode.runAll();

// 性能测试
class InliningPerformanceTest {
  static testSmallFunctions() {
    console.log('=== 小函数内联性能测试 ===\n');
    
    // 测试函数
    function add(a, b) { return a + b; }
    function multiply(a, b) { return a * b; }
    
    function combinedOps(x) {
      return multiply(add(x, 1), add(x, 2));
    }
    
    function inlinedOps(x) {
      return (x + 1) * (x + 2);
    }
    
    const iterations = 10000000;
    
    // 预热
    for (let i = 0; i < 10000; i++) {
      combinedOps(i);
      inlinedOps(i);
    }
    
    // 测试函数调用版本
    console.time('函数调用');
    let sum1 = 0;
    for (let i = 0; i < iterations; i++) {
      sum1 += combinedOps(i);
    }
    console.timeEnd('函数调用');
    
    // 测试手动内联版本
    console.time('手动内联');
    let sum2 = 0;
    for (let i = 0; i < iterations; i++) {
      sum2 += inlinedOps(i);
    }
    console.timeEnd('手动内联');
    
    console.log('');
    console.log(`结果1: ${sum1}`);
    console.log(`结果2: ${sum2}`);
    console.log('');
    console.log('注意：TurboFan通常会自动内联这些小函数，');
    console.log('所以两个版本的性能应该接近\n');
  }
  
  static testMethodCalls() {
    console.log('=== 方法调用内联测试 ===\n');
    
    class Vector {
      constructor(x, y) {
        this.x = x;
        this.y = y;
      }
      
      add(other) {
        return new Vector(this.x + other.x, this.y + other.y);
      }
      
      length() {
        return Math.sqrt(this.x * this.x + this.y * this.y);
      }
    }
    
    const v1 = new Vector(3, 4);
    const v2 = new Vector(1, 1);
    
    function testMethods() {
      return v1.add(v2).length();
    }
    
    function testInlined() {
      const rx = v1.x + v2.x;
      const ry = v1.y + v2.y;
      return Math.sqrt(rx * rx + ry * ry);
    }
    
    const iterations = 5000000;
    
    // 预热
    for (let i = 0; i < 10000; i++) {
      testMethods();
      testInlined();
    }
    
    console.time('方法调用');
    let sum1 = 0;
    for (let i = 0; i < iterations; i++) {
      sum1 += testMethods();
    }
    console.timeEnd('方法调用');
    
    console.time('手动内联');
    let sum2 = 0;
    for (let i = 0; i < iterations; i++) {
      sum2 += testInlined();
    }
    console.timeEnd('手动内联');
    
    console.log('');
    console.log('方法调用版本创建中间Vector对象，');
    console.log('如果逃逸分析成功，性能差异会减小\n');
  }
  
  static runAll() {
    this.testSmallFunctions();
    this.testMethodCalls();
  }
}

InliningPerformanceTest.runAll();

// 最佳实践总结
class InliningBestPractices {
  static summary() {
    console.log('=== 内联优化最佳实践 ===\n');
    
    console.log('1. 保持函数小巧');
    console.log('   • 单一职责原则');
    console.log('   • 每个函数10-20行为佳');
    console.log('   • 复杂逻辑拆分为多个小函数\n');
    
    console.log('2. 保持调用点单态');
    console.log('   • 避免传入不同类型的参数');
    console.log('   • 固定调用的方法');
    console.log('   • 必要时按类型分流\n');
    
    console.log('3. 避免阻止内联的特性');
    console.log('   • 不使用eval');
    console.log('   • 谨慎使用try-catch');
    console.log('   • 避免泄露arguments对象\n');
    
    console.log('4. 关注热点路径');
    console.log('   • 优先优化频繁调用的函数');
    console.log('   • 使用性能分析工具识别热点');
    console.log('   • 冷路径可以放宽要求\n');
    
    console.log('5. 信任编译器');
    console.log('   • 不要过度手动内联');
    console.log('   • 保持代码可读性');
    console.log('   • 使用标志验证内联行为\n');
  }
  
  static codeComparison() {
    console.log('=== 代码示例对比 ===\n');
    
    console.log('❌ 不利于内联的代码：');
    console.log(`
    // 大型多功能函数
    function processAll(data, options) {
      // 100+ 行代码
    }
    
    // 多态调用
    function handle(item) {
      return item.process();  // item类型多变
    }
    
    // 使用eval
    function calculate(expr) {
      return eval(expr);
    }
    `);
    
    console.log('✅ 有利于内联的代码：');
    console.log(`
    // 小型单一职责函数
    const validate = data => data.length > 0;
    const transform = data => data.map(x => x * 2);
    const filter = data => data.filter(x => x > 0);
    
    // 单态调用
    function processNumbers(nums) {
      return nums.reduce((a, b) => a + b, 0);
    }
    
    // 静态操作
    function add(a, b) { return a + b; }
    function multiply(a, b) { return a * b; }
    `);
  }
  
  static runAll() {
    this.summary();
    this.codeComparison();
  }
}

InliningBestPractices.runAll();