启动优化-观测

Edit Scheme → Run → Arguments → Environment Variables

# 查看 initializer 执行顺序
DYLD_PRINT_INITIALIZERS = 1

# 输出示例：
dyld[12345]: running initializer 0x100001234 in /path/to/libA.dylib
dyld[12345]: running initializer 0x100005678 in /path/to/MyApp

# 查看动态库加载
DYLD_PRINT_LIBRARIES = 1

# 输出示例：
dyld[12345]: <45A3B2C1-...> /usr/lib/libSystem.B.dylib
dyld[12345]: <78D4E5F6-...> /path/to/MyApp.app/Frameworks/SomeFramework.framework/SomeFramework

# 查看启动闭包使用情况
DYLD_PRINT_LOADERS = 1

# 输出示例：
dyld[12345]: using PrebuiltLoaderSet for /path/to/MyApp
dyld[12345]: PrebuiltLoader 0x1234 used for libSystem.B.dylib

使用步骤：
1. Product → Profile → App Launch
2. 选择目标设备和App
3. 点击Record开始录制
4. 等待App启动完成后停止录制
5. 分析各阶段耗时

import MetricKit

class MetricsManager: NSObject, MXMetricManagerSubscriber {

    static let shared = MetricsManager()

    func startCollecting() {
        MXMetricManager.shared.add(self)
    }

    func didReceive(_ payloads: [MXMetricPayload]) {
        for payload in payloads {
            if let launchMetrics = payload.applicationLaunchMetrics {
                // 首次绘制时间直方图
                let firstDrawTime = launchMetrics.histogrammedTimeToFirstDraw
                // App恢复时间直方图
                let resumeTime = launchMetrics.histogrammedApplicationResumeTime

                // 上报到自己的监控平台
                reportMetrics(firstDraw: firstDrawTime, resume: resumeTime)
            }
        }
    }

    private func reportMetrics(firstDraw: MXHistogram<UnitDuration>,
                               resume: MXHistogram<UnitDuration>) {
        // 解析直方图数据并上报
    }
}

import Foundation

// MARK: - 启动时间追踪器
class LaunchTimeTracker {
    static let shared = LaunchTimeTracker()
    
    /// 进程创建时间
    private(set) var processStartTime: TimeInterval = 0
    /// +load方法执行时间（ObjC Runtime初始化完成）
    private(set) var loadMethodTime: TimeInterval = 0
    /// 高优先级 constructor 时间（优先级101）
    private(set) var earlyConstructorTime: TimeInterval = 0
    /// 低优先级 constructor 时间（优先级65535）
    private(set) var lateConstructorTime: TimeInterval = 0
    /// main函数开始时间
    private(set) var mainStartTime: TimeInterval = 0
    /// willFinishLaunching 开始时间
    private(set) var willFinishLaunchingTime: TimeInterval = 0
    /// didFinishLaunching 开始时间
    private(set) var didFinishLaunchingTime: TimeInterval = 0
    /// didFinishLaunching 结束时间
    private(set) var didFinishLaunchingEndTime: TimeInterval = 0
    /// 首帧渲染完成时间
    private(set) var firstFrameTime: TimeInterval = 0
    /// 是否为预热启动
    private(set) var isPrewarmedLaunch: Bool = false
    
    private init() {
        processStartTime = Self.getProcessStartTime()
    }
    
    /// 通过sysctl获取进程创建时间
    private static func getProcessStartTime() -> TimeInterval {
        var kinfo = kinfo_proc()
        var size = MemoryLayout<kinfo_proc>.stride
        var mib: [Int32] = [CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()]
        
        guard sysctl(&mib, u_int(mib.count), &kinfo, &size, nil, 0) == 0 else {
            return 0
        }
        
        let startTimeSec = kinfo.kp_proc.p_starttime.tv_sec
        let startTimeUsec = kinfo.kp_proc.p_starttime.tv_usec
        return TimeInterval(startTimeSec) + TimeInterval(startTimeUsec) / 1_000_000.0
    }
    
    /// 标记+load方法执行时间
    @objc static func markLoadMethod() {
        shared.loadMethodTime = Date().timeIntervalSince1970
    }
    
    /// 标记预热启动状态
    @objc static func markPrewarmStatus(_ isPrewarmed: Bool) {
        shared.isPrewarmedLaunch = isPrewarmed
    }
    
    /// 标记高优先级 constructor 时间
    @objc static func markEarlyConstructor() {
        shared.earlyConstructorTime = Date().timeIntervalSince1970
    }
    
    /// 标记低优先级 constructor 时间
    @objc static func markLateConstructor() {
        shared.lateConstructorTime = Date().timeIntervalSince1970
    }
    
    /// 标记main函数开始
    @objc static func markMainStart() {
        shared.mainStartTime = Date().timeIntervalSince1970
    }
    
    /// 标记 willFinishLaunching 开始
    func markWillFinishLaunching() {
        willFinishLaunchingTime = Date().timeIntervalSince1970
    }
    
    /// 标记 didFinishLaunching 开始
    func markDidFinishLaunching() {
        didFinishLaunchingTime = Date().timeIntervalSince1970
    }
    
    /// 标记 didFinishLaunching 结束
    func markDidFinishLaunchingEnd() {
        didFinishLaunchingEndTime = Date().timeIntervalSince1970
    }
    
    /// 标记首帧渲染完成
    func markFirstFrame() {
        firstFrameTime = Date().timeIntervalSince1970
    }
    
    /// 获取启动时间起点（考虑预热启动）
    private func getLaunchStartTime() -> TimeInterval {
        // 预热启动时，进程创建时间不准确，使用 +load 时间作为起点
        if isPrewarmedLaunch {
            return loadMethodTime
        }
        return processStartTime
    }
    
    /// 获取各阶段耗时报告
    func generateReport() -> LaunchTimeReport {
        let startTime = getLaunchStartTime()
        
        // Pre-main 阶段
        let dyldLoadingTime = (loadMethodTime - startTime) * 1000
        let loadMethodDuration = (earlyConstructorTime - loadMethodTime) * 1000
        let initializersDuration = (lateConstructorTime - earlyConstructorTime) * 1000
        let lateToMainDuration = (mainStartTime - lateConstructorTime) * 1000
        let preMainTime = (mainStartTime - startTime) * 1000
        
        // main 阶段
        let mainToWillFinish = (willFinishLaunchingTime - mainStartTime) * 1000
        let willFinishDuration = (didFinishLaunchingTime - willFinishLaunchingTime) * 1000
        let didFinishDuration = (didFinishLaunchingEndTime - didFinishLaunchingTime) * 1000
        let didFinishToFirstFrame = (firstFrameTime - didFinishLaunchingEndTime) * 1000
        let mainTime = (firstFrameTime - mainStartTime) * 1000
        
        let totalTime = (firstFrameTime - startTime) * 1000
        
        return LaunchTimeReport(
            isPrewarmedLaunch: isPrewarmedLaunch,
            dylibLoadingTime: dyldLoadingTime,
            loadMethodDuration: loadMethodDuration,
            initializersDuration: initializersDuration,
            lateToMainDuration: lateToMainDuration,
            preMainTime: preMainTime,
            mainToWillFinish: mainToWillFinish,
            willFinishDuration: willFinishDuration,
            didFinishDuration: didFinishDuration,
            didFinishToFirstFrame: didFinishToFirstFrame,
            mainTime: mainTime,
            totalLaunchTime: totalTime
        )
    }
}

struct LaunchTimeReport {
    let isPrewarmedLaunch: Bool
    // Pre-main 阶段
    let dylibLoadingTime: Double       // dylib加载+Rebase/Bind+Runtime初始化
    let loadMethodDuration: Double     // +load方法执行耗时
    let initializersDuration: Double   // Initializers执行耗时（constructor + C++静态构造）
    let lateToMainDuration: Double     // 低优先级constructor到main的耗时
    let preMainTime: Double            // Pre-main总耗时
    // main 阶段
    let mainToWillFinish: Double       // main到willFinishLaunching的耗时
    let willFinishDuration: Double     // willFinishLaunching执行耗时
    let didFinishDuration: Double      // didFinishLaunching执行耗时
    let didFinishToFirstFrame: Double  // didFinishLaunching结束到首帧的耗时
    let mainTime: Double               // main阶段总耗时
    // 总计
    let totalLaunchTime: Double        // 总启动时间
    
    func printReport() {
        print("============ 启动时间报告 ============")
        if isPrewarmedLaunch {
            print("【预热启动】以 +load 时间为起点")
        }
        print("【Pre-main阶段明细】")
        print("  dylib加载/Rebase/Bind: \(String(format: "%.2f", dylibLoadingTime)) ms")
        print("  +load方法执行:         \(String(format: "%.2f", loadMethodDuration)) ms")
        print("  Initializers执行:      \(String(format: "%.2f", initializersDuration)) ms")
        print("  其他初始化:            \(String(format: "%.2f", lateToMainDuration)) ms")
        print("  Pre-main总计:          \(String(format: "%.2f", preMainTime)) ms")
        print("--------------------------------------")
        print("【main阶段明细】")
        print("  main→willFinish:       \(String(format: "%.2f", mainToWillFinish)) ms")
        print("  willFinishLaunching:   \(String(format: "%.2f", willFinishDuration)) ms")
        print("  didFinishLaunching:    \(String(format: "%.2f", didFinishDuration)) ms")
        print("  didFinish→首帧:        \(String(format: "%.2f", didFinishToFirstFrame)) ms")
        print("  main阶段总计:          \(String(format: "%.2f", mainTime)) ms")
        print("--------------------------------------")
        print("总启动时间:              \(String(format: "%.2f", totalLaunchTime)) ms")
        print("======================================")
    }
}

// LaunchTimeHook.m
#import <Foundation/Foundation.h>
#import <mach-o/dyld.h>

// 声明Swift类的方法
@interface LaunchTimeTracker : NSObject
+ (void)markLoadMethod;
+ (void)markPrewarmStatus:(BOOL)isPrewarmed;
+ (void)markEarlyConstructor;
+ (void)markLateConstructor;
@end

#pragma mark - +load 方法埋点

@interface LaunchTimeLoadHook : NSObject
@end

@implementation LaunchTimeLoadHook

+ (void)load {
    // 检测预热启动状态
    BOOL isPrewarmed = [NSProcessInfo.processInfo.environment[@"ActivePrewarm"] isEqualToString:@"1"];
    [LaunchTimeTracker markPrewarmStatus:isPrewarmed];
    
    // 记录 +load 执行时间
    [LaunchTimeTracker markLoadMethod];
}

@end

#pragma mark - constructor 埋点（不同优先级）

// 高优先级 constructor（优先级101，用户可用的最高优先级）
// 在同一编译单元内，会在更低优先级的 constructor 之前执行
// 注意：跨编译单元/库的执行顺序由链接顺序决定，优先级仅在同一编译单元内有效
__attribute__((constructor(101)))
static void EarlyConstructorInit(void) {
    [LaunchTimeTracker markEarlyConstructor];
}

// 低优先级 constructor（优先级65535，默认优先级）
// 在同一编译单元内，会在更高优先级的 constructor 之后执行
__attribute__((constructor(65535)))
static void LateConstructorInit(void) {
    [LaunchTimeTracker markLateConstructor];
}

// 同一编译单元内，优先级生效
__attribute__((constructor(101)))
static void HighPriority(void) { /* 先执行 */ }

__attribute__((constructor(65535)))
static void LowPriority(void) { /* 后执行 */ }

1. 动态库（framework）的 +load 先于静态库和主工程执行
2. 静态库的 +load 先于主工程执行
3. 同一镜像内按编译顺序执行

post_install do |installer|
  # 需要优先链接的 framework 名称
  priority_framework = 'LaunchTimeTracker'
  
  installer.pods_project.targets.each do |target|
    target.build_configurations.each do |config|
      ldflags = config.build_settings['OTHER_LDFLAGS']
      next unless ldflags.is_a?(Array)
      
      # 找到目标 framework 的链接标志
      framework_flag = ldflags.find { |flag| flag.include?(priority_framework) }
      next unless framework_flag
      
      # 移除后插入到最前面（$(inherited) 之后）
      ldflags.delete(framework_flag)
      inherited_index = ldflags.index('$(inherited)') || -1
      ldflags.insert(inherited_index + 1, framework_flag)
      
      config.build_settings['OTHER_LDFLAGS'] = ldflags
    end
  end
end

// main.swift
import UIKit

// 标记main函数开始
LaunchTimeTracker.markMainStart()

UIApplicationMain(
    CommandLine.argc,
    CommandLine.unsafeArgv,
    nil,
    NSStringFromClass(AppDelegate.self)
)

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, 
                     willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // 标记 willFinishLaunching 开始
        LaunchTimeTracker.shared.markWillFinishLaunching()
        
        // ... 早期初始化逻辑
        
        return true
    }

    func application(_ application: UIApplication, 
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // 标记 didFinishLaunching 开始
        LaunchTimeTracker.shared.markDidFinishLaunching()
        
        // ... 主要初始化逻辑
        
        // 标记 didFinishLaunching 结束（在 return 前）
        LaunchTimeTracker.shared.markDidFinishLaunchingEnd()
        return true
    }
}

class HomeViewController: UIViewController {
    
    private static var hasTrackedFirstFrame = false
    
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        
        guard !Self.hasTrackedFirstFrame else { return }
        Self.hasTrackedFirstFrame = true
        
        DispatchQueue.main.async {
            LaunchTimeTracker.shared.markFirstFrame()
            LaunchTimeTracker.shared.generateReport().printReport()
        }
    }
}

============ 启动时间报告 ============
【Pre-main阶段明细】
  dylib加载/Rebase/Bind: 285.30 ms
  +load方法执行:         62.15 ms
  Initializers执行:      32.80 ms
  其他初始化:            0.00 ms
  Pre-main总计:          380.25 ms
--------------------------------------
【main阶段明细】
  main→willFinish:       12.30 ms
  willFinishLaunching:   45.20 ms
  didFinishLaunching:    298.50 ms
  didFinish→首帧:        58.55 ms
  main阶段总计:          414.55 ms
--------------------------------------
总启动时间:              794.80 ms
======================================