iOS 微信编译速度优化分享

前言

岁月真是个养猪场，这几年，人胖了，微信代码也翻了。记得 14 年转岗来微信时，用自己笔记本编译微信工程才十来分钟。如今用公司配的 17 年款 27-inch iMac 编译要接近半小时；偶然间更新完代码，又莫名其妙需要全新编译。在这么低的编译效率下，开发心情受到严重影响。于是年初我向上头请示，优化微信编译效率，上头也同意了。

现有方案

在动手之前，先搜索目前已有方案，大概有这几个优化点：

一、优化工程配置

1、将 Debug Information Format 改为 DWARF

Debug 时是不需要生成符号表，可以检查一下子工程（尤其开源库）有没有设置正确。

2、将 Build Active Architecture Only 改为 Yes

Debug 时是不需要生成全架构，可以检查一下子工程（尤其开源库）有没有设置正确。

3、优化头文件搜索路径

避免工程 Header Search Paths 设置了路径递归引用：

Xcode 编译源文件时，会根据 Header Search Paths 自动添加 -I 参数，如果递归引用的路径下子目录越多，-I 参数也越多，编译器预处理头文件效率就越低，所以不能简单的设置路径递归引用。同样 Framework Search Paths 也类似处理。

二、使用 CocoaPods 管理第三方库

这是业界常用的做法，利用 cocoapods 插件 cocoapods-packager 将任意的 pod 打包成 Static Library，省去重复编译的时间；但缺点是不方便调试源码，如果库代码反复修改，需要重新生成二进制并上传到内部服务器，等等。

三、CCache

CCache 是一个能够把编译的中间产物缓存起来的工具，不需要过多修改项目配置，也不需要修改开发工具链。Xcode 9 有个很偶然的 bug，在源码没有任何修改的情况下经常触发全新编译，用 CCache 很好的解决这一问题。但随着 Xcode 10 修复全量编译问题，这一方案逐步弃用了。

四、distcc

distcc 是一个分布式编译工具，它原理是把本地多个编译任务分发到网络中多个机器，其他机器编译完成后，再把产物返回给本机上执行链接，最终得到编译结果。

五、硬件解决

如把 Derived Data 目录放到由内存创建的虚拟磁盘，或者购买最新款的 iMac Pro...

实践过程

一、优化编译选项

1、优化头文件搜索路径

把一些递归引用路径去了后，整体编译速度快了 20s。

2、关闭 Enable Index-While-Building Functionality

这选项无意中找到的（Xcode 9 的新特性？），默认打开，作用是 Xcode 编译时会顺带建立代码索引，但影响编译速度。关闭后整体编译速度快 80s（Xcode 会换回以前的方式，在空闲时间建立代码索引）。

二、优化 kinda

kinda 是今年引入支付跨平台框架（C ），但编译速度奇慢，一个源文件编译都要 30s。另外生成的二进制大小在 App 占比较高，感觉有不少冗余代码，理论上减少冗余代码也能加快编译速度。经过分析 LinkMap 文件和使用 Xcode Preprocess 某些源文件，发现有以下问题：

• proto 文件生成的代码较多
• 某个基类/宏使用了大量模版

对于问题一，可以设置 proto 文件选项为 optimize_for=CODE_SIZE 来让 protobuf 编译器生成精简版代码。但我是用自己的工具生成（具体原理可看这里），代码更少。

对于问题二，由于模版是编译期间的多态（增加代码膨胀和编译时间），所以可以把模版基类改成虚基类这种运行时的多态；另外推荐使用 hyper_function 取代 std::function，使得基类用通用函数指针，就能存储任意 lambda 回调函数，从而避免基类模板化。例如：

代码语言：javascript复制

template <typename Request, typename Response>
class BaseCgi {
public:
    BaseCgi(Request request, std::function<void(Response &)> &callback) {
        _request = request;
        _callback = callback;
    }

    void onRequest(std::vector<uint8_t> &outData) {
        _request.toData(outData);
    }

    void onResponse(std::vector<uint8_t> &inData) {
        Response response;
        response.fromData(inData);
        callback(response);
    }

public:
    Request _request;
    std::function<void(Response &)> _callback;
};

class CgiA : public BaseCgi<RequestA, ResponseA> {
public:
    CgiA(RequestA &request, std::function<void(ResponseA &)> &callback) :
        BaseCgi(request, callback) {}
};

可改成：

代码语言：javascript复制

class BaseRequest {
public:
    virtual void toData(std::vector<uint8_t> &outData) = 0;
};

class BaseResponse {
public:
    virtual void fromData(std::vector<uint8_t> &outData) = 0;
};

class BaseCgi {
public:
    template <typename Request, typename Response>
    BaseCgi(Request &request, hyper_function<void(Response &)> callback) {
        _request = new Request(request);
        _response = new Response;
        _callback = callback;
    }
    
    void onRequest(std::vector<uint8_t> &outData) {
        _request->toData(outData);
    }
    
    void onResponse(std::vector<uint8_t> &inData) {
        _response->fromData(inData);
        _callback(*_response);
    }
    
public:
    BaseRequest *_request;
    BaseResponse *_response;
    hyper_function<void(BaseResponse &)> _callback;
};

class RequestA : public BaseRequest { ... };

class ResponseA : public BaseResponse { ... };

class CgiA : public BaseCgi {
public:
    CgiA(RequestA &request, hyper_function<void(ResponseA &)> &callback) :
        BaseCgi(request, callback) {}
};

BaseCgi 由模版基类变成只有构造函数是模板的基类，onRequest 和 onResponse 逻辑代码并不因为基类模版实例化而被“复制黏贴”。经过上述优化，整体编译速度快了 70s，而 kinda 二进制也减少了 60%，效果特别明显。

三、使用 PCH 预编译头文件

PCH（Precompile Prefix Header File）文件，也就是预编译头文件，其文件里的内容能被项目中的其他所有源文件访问。通常放一些通用的宏和头文件，方便编写代码，提高效率。另外 PCH 文件预编译完成后，后面用到 PCH 文件的源文件编译速度也会加快。缺点是 PCH 文件和 PCH 引用到的头文件内容一旦发生变化，引用到 PCH 的所有源文件都要重新编译。所以使用时要谨慎。在 Xcode 里设置 Prefix Header 和 Precompile Prefix Header 即可使用 PCH 文件并对它进行预编译：

微信使用 PCH 预编译后，编译速度提升非常可观，快了接近 280s。

终极优化

通过上述优化，微信工程的编译时间由原来的 1,626.4s 下降到 1,182.8s，快了将近 450s，但仍然需要 20 分钟，令人不满意。如果继续优化，得从编译器下手。正如我们平常做的客户端性能优化，在优化之前，先分析原理，输出每个地方的耗时，针对耗时做相对应的优化。

一、编译原理

编译器，是把一种语言（通常是高级语言）转换为另一种语言（通常是低级语言）的程序。大多数编译器由三部分组成：

• 前端（Frontend）：负责解析源码，检查错误，生成抽象语法树（AST），并把 AST 转化成类汇编中间代码
• 优化器（Optimizer）：对中间代码进行架构无关的优化，提高运行效率，减少代码体积，例如删除 if (0) 无效分支
• 后端（Backend）：把中间代码转换成目标平台的机器码

LLVM 实现了更通用的编译框架，它提供了一系列模块化的编译器组件和工具链。首先它定义了一种 LLVM IR（Intermediate Representation，中间表达码）。Frontend 把原始语言转换成 LLVM IR；LLVM Optimizer 优化 LLVM IR；Backend 把 LLVM IR 转换为目标平台的机器语言。这样一来，不管是新的语言，还是新的平台，只要实现对应的 Frontend 和 Backend，新的编译器就出来了。

在 Xcode，C/C /ObjC 的编译器是 Clang（前端） LLVM（后端），简称 Clang。Clang 的编译过程有这几个阶段：

代码语言：javascript复制

➜  clang -ccc-print-phases main.m
0: input, "main.m", objective-c
1: preprocessor, {0}, objective-c-cpp-output
2: compiler, {1}, ir
3: backend, {2}, assembler
4: assembler, {3}, object
5: linker, {4}, image
6: bind-arch, "x86_64", {5}, image

1、预处理

这阶段的工作主要是头文件导入，宏展开/替换，预编译指令处理，以及注释的去除。

2、编译

这阶段做的事情比较多，主要有：

• 词法分析（Lexical Analysis）：将代码转换成一系列 token，如大中小括号 paren'()' square'[]' brace'{}'、标识符 identifier、字符串 string_literal、数字常量 numeric_constant 等等
• 语法分析（Semantic Analysis）：将 token 流组成抽象语法树 AST
• 静态分析（Static Analysis）：检查代码错误，例如参数类型是否错误，调用对象方法是否有实现
• 中间代码生成（Code Generation）：将语法树自顶向下遍历逐步翻译成 LLVM IR

3、生成汇编代码

LLVM 将 LLVM IR 生成当前平台的汇编代码，期间 LLVM 根据编译设置的优化级别 Optimization Level 做对应的优化（Optimize），例如 Debug 的 -O0 不需要优化，而 Release 的 -Os 是尽可能优化代码效率并减少体积。

4、生成目标文件

汇编器（Assembler）将汇编代码转换为机器代码，它会创建一个目标对象文件，以 .o 结尾。

5、链接

链接器（Linker）把若干个目标文件链接在一起，生成可执行文件。

二、分析耗时

Clang/LLVM 编译器是开源的，我们可以从官网下载其源码，根据上述编译过程，在每个编译阶段埋点输出耗时，生成定制化的编译器。在自己准备动手的前一周，国外大神 Aras Pranckevičius 已经在 LLVM 项目提交了 rL357340 修改：clang 增加 -ftime-trace 选项，编译时生成 Chrome（chrome://tracing） JSON 格式的耗时报告，列出所有阶段的耗时。效果如下：

• 整体编译（ExecuteCompiler）耗时 8,423.8ms
• 其中前端（Frontend）耗时 5,307.9ms，后端（Backend）耗时 3,009.6ms
• 而前端编译里头文件 SourceA 耗时 xx ms，B 耗时 xx ms，...
• 头文件处理里 Parse ClassA 耗时 xx ms，B 耗时 xx ms，...
• 等等

这就是我想要的耗时报告！接下来修改工程 CC={YOUR PATH}/clang，让 Xcode 编译时使用自己的编译器；同时编译选项 OTHER_CFLAGS 后面增加 -ftime-trace，每个源文件编译后输出耗时报告。最终把所有报告汇聚起来，形成整体的编译耗时：

由整体耗时可以看出，编译器前端处理（Frontend）耗时 7,659.2s，占整体 87%；而前端处理下头文件处理（Source）耗时 7,146.2s，占整体 71.9%！猜测头文件嵌套严重，每个源文件都要引入几十个甚至几百个头文件，每个头文件源码要做预处理、词法分析、语法分析等等。实际上源文件不需要使用某些头文件里的定义（如 class、function），所以编译时间才那么长。

于是又写了个工具，统计所有头文件被引用次数、总处理时间、头文件分组（指一个耗时顶部的头文件所引用到的所有子头文件的集合），列出一份表格（截取 Top10）：

Header1 处理时间 1187.7s，被引用 2,304 次；Header2 处理时间 1,124.9s，被引用 3,831 次；后面 Header3～10 都是被 Header1 引用。所以可以尝试优化 TopN 头文件里的头文件引用，尽量不包含其他头文件。

三、解决耗时

通常我们写代码时，如果用到某个类，就直接 include 该类声明所在头文件，但在头文件，我们可以用前置声明解决。因此优化头文件思路很简单，就是能用前置声明，就用前置声明替代 include。实际上改动量非常大，我跟组内另外的同事 vakeee 分工优化 Header1 和 Header2，花了整整 5 个工作日，才改完。效果还是有，整体编译时间减少 80s。

但需要优化的头文件还有几十个，我们不可能继续做这种体力活。因此我们可以做这样的工具，通过 AST 找到代码里出现的标识符（包括类型、函数、宏），以及标识符定义所在文件，然后分析是否需要 include 它定义所在文件。

先看看代码如何转换 AST，如以下代码：

代码语言：javascript复制

// HeaderA.h
struct StructA {
    int val;
};

// HeaderB.h
struct StructB {
    int val;
};

// main.c
#include "HeaderA.h"
#include "HeaderB.h"

int testAndReturn(struct StructA *a, struct StructB *b) {
    return a->val;
}

控制台输入：

代码语言：javascript复制

➜  TestContainer clang -Xclang -ast-dump -fsyntax-only main.c
TranslationUnitDecl 0x7f8f36834208 <<invalid sloc>> <invalid sloc>
|-RecordDecl 0x7faa62831d78 <./HeaderA.h:12:1, line:14:1> line:12:8 struct StructA definition
| `-FieldDecl 0x7faa6383da38 <line:13:2, col:6> col:6 referenced val 'int'
|-RecordDecl 0x7faa6383da80 <./HeaderB.h:12:1, line:14:1> line:12:8 struct StructB definition
| `-FieldDecl 0x7faa6383db38 <line:13:2, col:6> col:6 val 'int'
`-FunctionDecl 0x7faa6383de50 <main.c:35:1, line:37:1> line:35:5 testAndReturn 'int (struct StructA *, struct StructB *)'
  |-ParmVarDecl 0x7faa6383dc30 <col:19, col:35> col:35 used a 'struct StructA *'
  |-ParmVarDecl 0x7faa6383dd40 <col:38, col:54> col:54 b 'struct StructB *'
  `-CompoundStmt 0x7faa6383dfc8 <col:57, line:37:1>
    `-ReturnStmt 0x7faa6383dfb8 <line:36:2, col:12>
      `-ImplicitCastExpr 0x7faa6383dfa0 <col:9, col:12> 'int' <LValueToRValue>
        `-MemberExpr 0x7faa6383df70 <col:9, col:12> 'int' lvalue ->val 0x7faa6383da38
          `-ImplicitCastExpr 0x7faa6383df58 <col:9> 'struct StructA *' <LValueToRValue>
            `-DeclRefExpr 0x7faa6383df38 <col:9> 'struct StructA *' lvalue ParmVar 0x7faa6383dc30 'a' 'struct StructA *'

从上可以看出，每一行包括 AST Node 的类型、所在位置（文件名，行号，列号）和结点描述信息。头文件定义的类也包含进 AST 中。AST Node 常见类型有 Decl（如 RecordDecl 结构体定义，FunctionDecl 函数定义）、Stmt（如 CompoundStmt 函数体括号内实现）。

Clang AST 有三个重要的基类：ASTFrontendAction、ASTConsumer 以及 RecursiveASTVisitor。ClangTool 类读入命令行配置项后初始化 CompilerInstance；CompilerInstance 成员函数 ExcutionAction 会调用 ASTFrontendAction 3 个成员函数 BeginSourceFile（准备遍历 AST）、Execute（解析 AST）、EndSourceFileAction（结束遍历）。ASTFrontendAction 有个重要的纯虚函数 CreateASTConsumer（会被自己 BeginSourceFile 调用），用于返回读取 AST 的 ASTConsumer 对象：

代码语言：javascript复制

class MyFrontendAction : public clang::ASTFrontendAction {
public:
    virtual std::unique_ptr<clang::ASTConsumer> CreateASTConsumer(clang::CompilerInstance &CI, llvm::StringRef file) override {
        TheRewriter.setSourceMgr(CI.getASTContext().getSourceManager(), CI.getASTContext().getLangOpts());
        return llvm::make_unique<MyASTConsumer>(&CI);
    }
};

int main(int argc, const char **argv) {
    clang::tooling::CommonOptionsParser op(argc, argv, OptsCategory);
    clang::tooling::ClangTool Tool(op.getCompilations(), op.getSourcePathList());
    int result = Tool.run(clang::tooling::newFrontendActionFactory<MyFrontendAction>().get());

    return result;
}

ASTConsumer 有若干个可以 override 的方法，用来接收 AST 解析过程中的回调，其中之一是工具用到的 HandleTranslationUnit 方法。当编译单元 TranslationUnit 的 AST 完整解析后，HandleTranslationUnit 会被回调。我们在 HandleTranslationUnit 使用 RecursiveASTVisitor 对象以深度优先的方式遍历 AST 所有结点：

代码语言：javascript复制

class MyASTVisitor
: public clang::RecursiveASTVisitor<MyASTVisitor> {
public:
    explicit MyASTVisitor(clang::ASTContext *Ctx) {}
    
    bool VisitFunctionDecl(clang::FunctionDecl* decl) {
        // FunctionDecl 下的所有参数声明允许前置声明取代 include
        // 如上面 Demo 代码里 StructA、StructB
        return true;
    }
    
    bool VisitMemberExpr(clang::MemberExpr* expr) {
        // 被引用的成员所在的类，需要 include 它定义所在文件
        // 如 StructA
        return true;
    }

    bool VisitXXX(XXX) {
        return true;
    }
    
    // 同一个类型，可能出现若干次判定结果
    // 如果其中一个判断的结果需要 include，则 include
    // 否则使用前置声明代替 include
    // 例如 StructA 只能 include，StructB 可以前置声明
};

class MyASTConsumer : public clang::ASTConsumer {
private:
    MyASTVisitor Visitor;
public:
    explicit MyASTConsumer(clang::CompilerInstance *aCI)
    : Visitor(&(aCI->getASTContext())) {}
    
    void HandleTranslationUnit(clang::ASTContext &context) override {
        clang::TranslationUnitDecl *decl = context.getTranslationUnitDecl();
        Visitor.TraverseTranslationUnitDecl(decl);
    }
};

工具框架大致如上所示。不过早在 2011 年 Google 内部做了个基于 Clang libTooling 的工具 include-what-you-use，用来整理 C/C 头文件，效果如下：

代码语言：javascript复制

➜  include-what-you-use main.c
HeaderA.h has correct #includes/fwd-decls)

HeaderB.h has correct #includes/fwd-decls)

main.c should add these lines:
struct StructB;

main.c should remove these lines:
- #include "HeaderB.h"  // lines 2-2

The full include-list for main.c:
#include "HeaderA.h"  // for StructA
struct StructB;

我们在 IWYU 基础上，增加了 ObjC 语言的支持，并增强它的逻辑，让结果更好看（通常 IWYU 处理完后，会引入很多头文件和前置声明，我们做剪枝处理，进一步去掉多余的头文件和前置声明，篇幅限制就不多做解释了）。

微信源码通过工具优化头文件引入后，整体编译时间降到了 710s。另外头文件依赖的减少，也能降低因修改头文件引起大规模源码重编的可能性。我们再用编译耗时分析工具分析当前瓶颈：

WCDB 头文件处理时间太长了，业务代码（如 Model 类）没有很好的隔离 WCDB 代码，把 WINQ 暴露出去，外面被动 include WCDB 头文件。解决方法有很多，例如 WCDB 相关放 category 头文件（XXModel WCDB.h）里引入，或者跟其他库一样，把 <WCDB/WCDB.h> 放 PCH。

最终编译时间优化到 540s 以下，是原来的三分之一，编译效率得到巨大的提升。

优化总结

总结微信的编译优化方案：

• A、优化头文件搜索路径
• B、关闭 Enable Index-While-Building Functionality
• C、优化 PB/模版，减少冗余代码
• D、使用 PCH 预编译
• E、使用工具优化头文件引入；尽量避免头文件里包含 C 标准库

未来展望

期待公司的蓝盾分布式编译 for ObjC；另外可以把业务代码模块化，项目文件按模块加载，目前 kinda/小程序/mars 在很好的实践中。

参考文献

• 如何将 iOS 项目的编译速度提高5倍
• 深入剖析 iOS 编译 Clang / LLVM
• Clang之语法抽象语法树AST
• time-trace: timeline / flame chart profiler for Clang
• Introduction to the Clang AST

打包 ide xcode 微信 html

0 人点赞