深海游弋的鱼 – 第 33 页 – 智障儿童欢乐多

贝壳跨端之路——从 0 到 1 接入 Flutter 实战

一门新技术的兴起，必定是为了要解决现有技术解决不了的难题。跨端技术也遵循这一规律。传统的纯原生开发已经满足不了日益增长的业务需求，而跨端技术的产生就是为了要解决这一难题，具体表现在动态化内容需求增大和业务需求变化快、开发成本变大这两大方面。

跨端技术的变革

跨端最开始起源于浏览器。在 App 内使用 Native 的 Webview 来加载 Html5 页面，这是移动端最开始的跨端实践。接着，为了使 Html5 页面能够更多地使用底层 SDK 或者补充性功能，Hybird 开始流行起来。此后，各种各样的跨端框架也随之流行而来，例如 PhoneGap、AppCan。

2015 年 4 月，Facebook 发布了 React Native，主张“Learn once, write everywhere”，采用 Javascript 开发 + 原生渲染技术，类似的还有 Weex 和快应用。同年 Flutter 也发布了，不过当时关注的人较少，直到 2018 年的 1.0 版本发布，关注和使用的人才多了起来。

贝壳决定建设跨端能力

2018 年，由于贝壳公司内部业务发展较快、需求较多，贝壳开始做平台化能力建设，但因缺乏跨端能力，贝壳开始考虑跨端能力方面的建设。综合了团队构成、业务特点、团队经验以及业界的动态等因素，贝壳成立了 Flutter 架构小组（以下统称小组）。

之后，赵宏伟带着小组成员开启了贝壳跨端探索之旅。那么在这场旅途中，贝壳在接入 Flutter 的过程中都进行了哪些探索呢？为此，InfoQ 邀请到了 Flutter 架构小组负责人赵宏伟以及小组成员肖鹏、裴伟来跟大家一起聊聊贝壳的 Flutter 接入实践。

相比其他跨端框架，Flutter 虽有一定的优势，但刚开始，贝壳并没有直接就选用 Flutter。

“当时组内准备考虑一些跨平台的方案做一些小的尝试和调研。后来，到 2018 年底，Flutter1.0 发布，小组开始对跨端方案进行了深度调研。起初，组内是对 RN 和 Flutter 做调研，FE 团队（贝壳前端团队）负责 Weex 的调研和使用。”赵宏伟回忆到。

经过调研之后，Flutter 架构小组首先放弃了 RN。原因如下：

1.渲染通信路径长。React Native 的逻辑层和 UI 的描述层都在 js；

2.React Native 跨端技术的实现思路是适配，两个移动端（iOS 和 Android）仍然存在很多组件差异；

3.React Native 的页面层级问题；

4.动态化需求不多；

5.有一些公司宣布放弃 React Native，以及 React 许可的一些问题，不确定性较多。

对于 Weex，贝壳前端同学在某些业务上做了部分实验，得到的结论是「效果一般」，没有对他们整个前端的行为有多大改变，因此也放弃了 Weex。而对于 Flutter，首先 Flutter 主打的自渲染，UI 到逻辑都是自身一套；其次 Flutter 基于对应平台独立编译，更适合对应平台的运行，并且支持多平台；最后，Flutter 支持 JIT 和 UT 模式，既能兼顾开发效率，也能兼顾运营效率。

基于以上调研与考虑，贝壳最终选择了 Flutter。

选定跨端框架，接下来就是为接入做准备了。我们了解到贝壳在接入 Flutter 的过程中，整个项目经历了 3 个阶段。

正式开启跨端之旅

据赵宏伟透露，第一个阶段他们的目标是快速落地验证。在此阶段中，他们也遇到了两个难题。第一是如何保证既能进行 Flutter 开发，又不影响非 Flutter 开发人员，并且官方的既有工程集成方案对他们的工程侵入性较大，如果按照最原始的方式打包效率也比较低，因此他们设计了自己的集成方案；第二是 Flutter 层面需要组件化，小组内部也设计了组件化方案来解决快速落地问题。

在以上问题得到解决之后，他们在部分业务进行快速实验，“当时的业务场景下反馈还不错。”赵宏伟说。接下来就来到第二阶段。在这一阶段中，他们更全面注重开发和用户体验。因此，他们将建设分为了三部分。

第一部分是 Flutter 在持续集成方面建设；

第二部分是业务开发核心基础库能力建设(标准化)；

第三部分是容灾降级及稳定性方面的建设。

完成了以上三部分的建设，项目就到了第三阶段，贝壳 Flutter 架构组开始进行多端一体化能力建设。2020 年，小组针对 Flutter for web 做了一些研究，并做出了贝壳 Flutter For web 的容灾降级系统。

“今年（2021 年）我们一直在研究 Flutter 多端一体化方案，官方也在 2.0 中主推了 web 方向的应用，目前主要是在优化 Flutter For web 的应用体验，包括加载和部署优化，内存优化，三端一体化的核心基础补充以及监控埋点能力补充。我们内部的监控系统一部分 Web 页面也是使用 Flutter 来开发的。”赵宏伟说。

截止到采访时，贝壳 80%（24 款）的 App 已经接入了 Flutter。

当提到这么多 App 接入 Flutter 之后带给贝壳的收益时，赵宏伟兴奋地说：“效率，这个是我们最直观的感觉，整个 2020 年贝壳所有业务线都参与过 Flutter，一致的感受都是效率，以前两个人开发，现在一个人就可以完成。”

除了最直观的效率上的提升，贝壳还做了一整套的标准化 UI 组件（UI 组件 160+，业务组件 30+），这是属于他们的技术创新。并且参与此项目的成员在 Flutter 容器、Aop 编译、监控、UI 自动化和动态化等相关研究中还积累了大量的技术经验，进一步提升了个人技术能力。此外，据小组成员萧鹏描述，他们还将这些 UI 自动化的创新技术整理成文章进行了输出，把创新技术分享给更多有需要的开发者们。

Flutter 的成功接入，虽然让贝壳在跨端能力方面的建设得到了很大的提升，但有些问题，目前小组仍没有较好的解决方案，首先就是内存问题。当提到内存时，赵宏伟略显苦恼。“除了容器自身的内存，还有图片的一些边界场景和释放，以及一些三方图片库存在图片释放和图片过大的 Crash 问题。”赵宏伟说。

针对这一问题，贝壳采用了共享引擎和图片纹理方案来管理 Flutter 图片缓存，虽然得到了很大的改善，但当业务场景中出现多容器时，容器消耗内存仍然不小。再者是 Platform View 和渲染问题，Flutter 在 Platform View 上有一部分内存和适配问题。据了解，这些问题需要深入到引擎内部，更改成本较高，贝壳便没有过多的干预，而是选择了积极适配新版。最后是动态化问题，在 iOS 侧，小组内部没有比较好的动态化方案，目前只保证维护好性能和低成本。

除了以上的一些问题，据赵宏伟透露，贝壳在引入 Flutter 之后，还产生了一些新问题。主要体现在以下几点：

一、集成问题

首先是在第一阶段的集成方案不够完善，RD 反馈调试较为困难，QA 反馈打包时间长，错误率高。其次是配置问题，因小组内部在 Flutter SDK 上做了定制，所以配置起来就比较困难；再加上多个项目的 Flutter SDK 版本不一致，开发人员需要手动组合 Flutter tools 和 Flutter SDK，这一过程增加了成本；还有在打包的时候，需要先将项目在制定打包机上打包，再在主包上打包，这个时间就比较长。于是，他们就重新做了一版集成方案，并开发了 Flutter SDK 自动化集成更新方案，目前在 Flutter、Dart 编译部分就如同一个 target 任务，和其他代码一起进行并发编译，大大提高了效率。

二、包大小问题

在 C 端落地时候，贝壳更加关注包大小。贝壳当时接入的 Flutter1.12.13，其包大小一度达到 30MB，业务方紧急要求瘦身，因此 Flutter 架构小组通过改造 Flutter 编译器以及 Flutter Engine 对 Flutter 产物数据段做了分离压缩，可以内置，可以远程下发，并去掉符号表和无用文件，将包体积从 30MB 缩小到 17MB。在后续的规划中，赵宏伟说：“我们会结合 Flutter for Web 方案，在远程下发失败后动态转到 for Web 页面，提高页面打开成功率，保证业务正常流转。”

当在使用 Flutter for Web 时，Flutter 会将所有的业务打包成一个整包，但对于单独访问一个页面的场景，加载就会比较慢，为解决这一问题，小组对整个包进行了拆分，并把资源上传到 CDN 来解决加载问题。

三、异常监控问题

在做异常监控时，在瘦身模式下，获取的堆栈是没有办法被解析的，很多都是系统堆栈问题，没有办法进一步解决，并且很多都是没用的堆栈，无法将问题细致化。针对这一问题，贝壳做了一套后端的分流解析服务。这套服务首先是将 Flutter Exception 进行符号化，然后对堆栈进行分析，去掉无用和白名单内的堆栈行后进行归因，如果归不到业务方，再采取页面分流的方式，来达到异常监控的效果。

四、图片导致的内存问题

Flutter 本身内存方面消耗比较严重，而自己又是一套独立的图片缓存，因此，在大图片场景下，加上 Native 的图片内存占用，整体图片导致的内存问题比较多。面对这一问题，贝壳采用了外接纹理方案，让 Flutter 和 Native 共享一份图片缓存，以及在大图场景下使用外接纹理方案进行边界处理，这对内存都做了比较好的优化。

除了以上的一些问题，还有一个比较大的挑战。“在引入 Flutter 之后，当面对产品经理的提出的一些交互效果，Flutter 本身技术能力又无法支持时，就需要小组内部去找其他的解决方案来解决，可能会考虑原生，或同时使用原生安卓来做。”小组成员裴伟补充道。

虽然产生了以上这些新问题，但好在小组内部也提出了相应的解决方案。同时，贝壳也一直在寻找更优的解决方法。

贝壳 Flutter 的成功接入也让贝壳开发团队的开发效率得到了跨级别的提升。但在此过程中，贝壳也遭遇到过一个“灵魂拷问”—— 效率 or 体验？

一个永恒的话题—— 要效率，还是要体验？

一款产品，一个 App 被生产出来，就一定是为了满足用户的某种需求，被人们使用的，因此用户体验要好。而对一个公司而言，一个高效率的组织形式也非常重要，高效的开发可为公司解决人力、财力等各方面的问题。当问到在接入 Flutter 的过程中，贝壳是如何权衡效率和体验的问题时，赵宏伟的回答是比较明确的。

“像直播、视频、地图这一类的，不建议使用 Flutter，其他的在使用 Flutter 时，该提效的就提效，该注重体验就注重体验。当然每个 App 也有自己的着重方向，要根据自己的场景去舍弃效率或者体验。”赵宏伟表示。

在面对贝壳的业务场景时，贝壳引入 Flutter 的关键目标就是要解决开发效率问题。因此，为了进一步提高开发效率，贝壳也做了接下来的打算。首先是研究多端一体化，即将 Flutter 能够应用到 web 上，包括加载、部署优化、内存优化，以及三端一体化的核心基础补充和监控埋点能力补充。目前也在研究中。

其次是在应用上，贝壳内部会有一些 Native 和 Html5 的业务要做。Html5 主要面向站外，贝壳希望能够用一套代码解决三端需求，这样提效会更进一步。赵宏伟接着说：“我们可能会考虑 Flutter 在 VR 渲染上的一些应用，不过目前还在设想阶段。”

除此之外，贝壳对新的 OS，比如鸿蒙，在兼容模式下也做了适配，并开始着手做了一些准备。“当然也要配合公司的产品策略，是否大范围的适配跟进。”赵宏伟补充到。

写在最后

本次的 Flutter 接入实战，不仅解决了贝壳的“效率提升”问题，还见证了贝壳从 0 到 1 的跨端能力建设。从最初不够完善的基础建设，到引入 Flutter 过程中所遇到的各种困难，贝壳都在实践过程中努力寻找解决方案并构建了一些属于贝壳的创新技术。

参考链接

Apple Store审核规则&应用动态化规定

苹果应用商店应用上架规则地址：https://developer.apple.com/app-store/review/guidelines/

其中，涉及到应用动态化的规定内容如下：

苹果应用开发者许可协议地址：https://developer.apple.com/cn/support/terms/

其中，涉及到应用动态化的规定内容如下：

参考链接

贝壳Flutter瘦身实践

开源地址

瘦身引擎开源地址：https://github.com/LianjiaTech/flutter_beike_engine
fluter for web 开源地址https://github.com/LianjiaTech/BKFlutterWebNativeBridge
贝壳 aop 库开源地址：https://github.com/LianjiaTech/Beike_AspectD

背景

贝壳找房内部大部分的 App 都已经接入了 Flutter,而且公司在跨端方案的选择上在大力发展 Flutter 生态体系，越来越多的团队也在使用 Flutter,Flutter 虽然能带来高人效和高性能的体验,同时也导致包体积增加，包体积的增加会给我们的推广增大难度，所以我们迫切需要一套针对 Flutter 的通用瘦身方案。

现状：

以一个空工程为例，Flutter 产物主要包含两部分，App.framework 和 Flutter.framework 这两个库，这两个库达到了 16M，对我们的包体积优化会带来不小的压力，所以我们立项了 Thin-Flutter 项目，主要是为了所有 App 提供一套 Flutter 通用的瘦身方案。（由于安卓侧有比较多的手段来实现瘦身，所以本篇文章主要针对 iOS）

对于包大小问题，Flutter 官方也在持续跟进优化：

Flutter V1.2 开始支持Android App Bundles，支持 Dynamic Module 下发。
Flutter V1.12 优化了2.6% Android 平台 Hello World App 大小（3.8M -> 3.7M）。
Flutter V1.17 通过优化Dart PC Offset存储以减少 StackMap 大小等多个手段，再次优化了产物大小，实现18.5%的缩减。
Flutter V1.20 通过Icon font tree shaking移除未用到的 icon fonts，进一步优化了应用大小。
Flutter V2.2.2 并没有明显的措施

我们以贝壳 flutter 产物为例（Flutter SDK : 1.22.4）

App.framework 总大小 20.8M

Flutter.framework 总大小 7.7M

我们先来分析 Flutter 的产物构成，通过对编译命令优化后，产物如下（Release 模式）：

App.framework：其中两个文件占比较大，一个是 App 可执行文件，另一个是 flutter_assets. App 可执行文件是 Dart 侧业务代码 AOT 编译的产物，会随着业务量的增多而变大，flutter_assets 包含图片、字体等资源文件。

Flutter.framework: 引擎产物，大小是固定的，但是初始占比比较大。这部分能优化的空间很小，主要是通过裁剪引擎不需要的功能，减少体积。编译引擎时可以选择性编译 skia 和 boringssl，收益大概只有几百 K。

经过对比，iOS 和 Flutter 代码量增长对于包体积的影响是有很大区别的，由于 Flutter 的 Tree Shaking 机制，未被引用的代码都会被裁剪掉，这个机制 iOS 里是没有的，那么这个机制所造成的影响就是 Flutter 包体积在初期会极速增加，到一个临界点包体积的增加会趋于平缓。

贝壳瘦身方案

一、方案调研：

包体积瘦身方法论，大概就三种，要么删减，要么压缩，要么挪走，对于删减 Flutter 自带有 tree-sharking 机制，也就是没有用到的代码会自动裁剪，所以删减不会有太明显的效果，对于压缩，各个团队都会不定时压缩图片，所以不能作为主方案，那么想要有明显的瘦身效果，最好的方面很明显是挪了。下面是一些常用的瘦身方案：

通过打包命令删减

—split-debug-info 可以分离出 debug info

—strip 去除无用符号

—dwarf_stack_trace 表示在生成的动态库文件中，不使用堆栈跟踪符号

—obfuscate 表示混淆，通过减少变量名/方法名的方式减小代码体积

减少显示类型转换操作

as String/Bool 等等，这类操作会导致 App.framework 体积显著增加，主要是他会增加类型检测及抛出异常的处理逻辑。

Flutter 引擎删减及符号化分离

Flutter 引擎中包括了 Dart、skia、boringssl、icu、libpng 等多个模块，其中 Dart 和 skia 是必须的，其他模块如果用不到倒是可以考虑裁掉，能够带来几百 k 的瘦身收益。业务方可以根据业务诉求自定义裁剪。

无用代码及无用资源删除

这个不用过多解释，这种直接删代码删资源的方案是最常见的，但投入回报比并不高。

除了给各个业务线分配瘦身指标之外，通过其他方式达到了非常不错的瘦身效果，主要包括以下几方面：

去除符号化文件
Flutter 产物数据段及资源文件动态下发
其他方式：包括去除无用文件、无用资源等

二、具体实现：

贝壳希望有一套长期有效的瘦身方案，以及监控体系，所以贝壳的瘦身方案包括两方面，一是包大小分析及监控，二是通用的，对业务同学无感知的瘦身方案。

1.监控

为了让 Flutter 包大小结构更加一目了然，我们将 Flutter 包大小进行了线上可视化。

首先，我们对 flutter_tools 了修改，在打包过程中我们会收集各个 Flutter 组件中二进制和资源的大小并写入文件（这里的实现我们参考了 flutter_tools 中 analyze_size.dart 的代码），打包完成后会将包大小分析文件上传至服务器；然后，我们在后端对上传的包大小文件进行分析，并将各个组件对应到相应的业务线；最终，我们将分析过后的包大小文件在前端进行展示。除了展示各组件和业务线的大小之外，我们还提供了 Flutter 包大小的对比功能，这样就可以更清晰的看到各个组件和业务线的前后大小变化。

有了包大小的分析，我们就可以根据各业务线和组件的不同情况制定不同的瘦身目标。

与此同时，我们可以对包大小的变化有一个长期的监控，可以及时发觉增量大的组件或者业务方，及时做出调整。

2.瘦身方案

2.1.去除符号化文件

贝壳通过 podspec 注入命令的方式，将 debug 符号信息剥离到指定目录，但这样会产生一个新的问题，Flutter 侧 error 无法解析，因此，我们在编译的同时将符号文件和 uuid 唯一标识绑定上传后端归档，在 App 的 Flutter 页面发生异常时，动态获取当前运行 app App.framework 组件的 uuid 标识，连同异常堆栈上报，后端根据 uuid 匹配符号文件，并解析异常堆栈，这部分可以瘦身 1.3M 左右。

以下是 Flutter error 的解析流程图：

由各个业务方梳理无用页面及无用资源文件、图片压缩等等，其中无用代码及无用资源删减有 2M 的收益，图片压缩有 800k 的收益。

    if File.exist?("./pubspec.yaml")
        com_script_phase = { :name=>'build dart', :script => <<-DESC
            #更换SOURCE_ROOT
          O_SOURCE_ROOT=$SOURCE_ROOT
          export SOURCE_ROOT=$FLUTTER_APPLICATION_PATH/ios
          export TREE_SHAKE_ICONS=true
          export SPLIT_DEBUG_INFO="$FLUTTER_APPLICATION_PATH/ios/Flutter"
          if [[ $ACTION == "install" ]]; then
              export CONFIGURATION='Release'
          fi
          /bin/sh "$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh" build
          if [ $? -ne 0 ];then
            exit -1
          fi
          /bin/sh "$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh" thin
          if [ $? -ne 0 ];then
             exit -1
          fi
          DESC
        }

if File.exist?("./pubspec.yaml")

com_script_phase = { :name=>'build dart', :script => <<-DESC

#更换SOURCE_ROOT

O_SOURCE_ROOT=$SOURCE_ROOT

export SOURCE_ROOT=$FLUTTER_APPLICATION_PATH/ios

export TREE_SHAKE_ICONS=true

export SPLIT_DEBUG_INFO="$FLUTTER_APPLICATION_PATH/ios/Flutter"

if [[ $ACTION == "install" ]]; then

export CONFIGURATION='Release'

/bin/sh "$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh" build

if [ $? -ne 0 ];then

exit -1

/bin/sh "$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh" thin

if [ $? -ne 0 ];then

exit -1

DESC

}

我们完成剪裁以后，还需要进一步研究其他瘦身手段，比如动态下发。

2.2Flutter 产物数据段及资源的动态下发

是否可以将两个动态库 App.framework 和 Flutter.framework 全部动态下发？答案是不行的，原因是由于 iOS 系统的限制，可执行文件是不可以动态下发的。

那我们进一步分析，哪些东西是可以动态下发的，哪些东西是不可以动态下发的。参考图 1，首先 flutter_assets 和 icudtl.dat 是资源文件，不存在权限的问题，所以可以动态下发，那么除了这些资源文件，其他部分是否可以动态下发呢？我们接着看。

实现环境：Flutter SDK 2.2.2（目前 Flutter 官方已经发布了 Flutter 2 版本，贝壳也已经适配了 Flutter2.2.2 版本,因此后面基于 Flutter2.2.2 版本进行分析）首先我们看下 Flutter 是如何编译出产物的。

App.framework 的可执行文件经过编译命令优化后，主要由以下四部分构成：

kDartIsolateSnapshotData //代表 Dart 堆的初始状态，并包含 isolate 专属的信息。

kDartVmSnapshotData //代表 isolate 之间共享的 Dart 堆 (heap) 的初始状态。有助于更快地启动 Dart isolate，但不包含任何 isolate 专属的信息。

kDartIsolateSnapshotInstructions //包含由 Dart isolate 执行的 AOT 代码。

kDartVmSnapshotInstructions //包含 VM 中所有 Dart isolate 之间共享的通用例程的 AOT 指令。这种快照的体积通常非常小，并且大多会包含程序桩 (stub)。

首先了解下什么是 isolate,DartVM 采用了所谓快照的方式，即 JIT 运行时编译后的基本结构与 AOT 编译的基本结构相同。将类信息、全局变量、函数指令直接以序列化的方式存在磁盘中，称为 Snapshot（快照）。同一个进程里可以有很多 isolate,但两个 isolate 的堆区是不能共享的，所以官方设计了 VM isolate，也就是 kDartVmSnapshot，用来多个 isolate 之间的交互。kDartVmSnapshot 分为指令段和数据段，对应上面的 kDartVmSnapshotData 和 kDartVmSnapshotInstructions，内置在 App.framework 里。具体关系如图：

而 isolate 对应的就是 kDartIsolateSnapshot，同样也分为指令段和数据段，对应上面的 kDartIsolateSnapshotData 和 kDartIsolateSnapshotInstructions。

官方文档解释 From the VM's perspective, this just needs to be loaded in memory with READ permissions and does not need WRITE or EXECUTE permissions. Practically this means it should end up in rodata when putting the snapshot in a shared library.

iOS 系统是不允许动态下发可执行二进制代码的，但 kDartIsolateSnapshotData 和 kDartVmSnapshotData 两个数据段的加载是不受系统限制的，所以我们要针对这两部分（上图黄色部分），制定具体的分离方案以及加载方案。

2.2.1、如何分离数据段并回写到磁盘

从上图可以看出 gen_snapshot 为 Dart 编译器，编译后的产物 snapshot_assembly.S 文件再根据不同的平台，编译出不通平台的产物。

分离数据段分为两部分：

将数据段回写到磁盘上，放入云端服务器动态下发。
将数据段从 App.framework 中剔除，达到瘦身效果

我们从 gen_snapshot 入手，将数据段产物剥离出来。具体实现如下：

  MaybeLoadCode();
//根据不同模式，编译不同的产物
  switch (snapshot_kind) {
    case kCore:
      CreateAndWriteCoreSnapshot();
      break;
    case kCoreJIT:
      CreateAndWriteCoreJITSnapshot();
      break;
    case kApp:
      CreateAndWriteAppSnapshot();
      break;
    case kAppJIT:
      //JIT模式也就是平时的debug模式编译流程
      CreateAndWriteAppJITSnapshot();
      break;
    case kAppAOTAssembly:
    case kAppAOTElf:
      //经过验证release模式下的编译流程
      CreateAndWritePrecompiledSnapshot();
      break;
    case kVMAOTAssembly: {
      File* file = OpenFile(assembly_filename);
      RefCntReleaseScope<File> rs(file);
      result = Dart_CreateVMAOTSnapshotAsAssembly(StreamingWriteCallback, file);
      CHECK_RESULT(result);
      break;
    }
    default:
      UNREACHABLE();
  }

MaybeLoadCode();

//根据不同模式，编译不同的产物

switch (snapshot_kind) {

case kCore:

CreateAndWriteCoreSnapshot();

break;

case kCoreJIT:

CreateAndWriteCoreJITSnapshot();

break;

case kApp:

CreateAndWriteAppSnapshot();

break;

case kAppJIT:

//JIT模式也就是平时的debug模式编译流程

CreateAndWriteAppJITSnapshot();

break;

case kAppAOTAssembly:

case kAppAOTElf:

//经过验证release模式下的编译流程

CreateAndWritePrecompiledSnapshot();

break;

case kVMAOTAssembly: {

File* file = OpenFile(assembly_filename);

RefCntReleaseScope<File> rs(file);

result = Dart_CreateVMAOTSnapshotAsAssembly(StreamingWriteCallback, file);

CHECK_RESULT(result);

break;

}

default:

UNREACHABLE();

}

经过验证，release 模式下走的是 CreateAndWritePrecompiledSnapshot 编译流程，因此我们将其改造，将数据段回写到磁盘，需要重写 CreateAppAOTSnapshotAsAssembly 方法。至于回写文件，我们发现 debug 模式下会使用 WriteFile 方法写入文件，这里仿照 debug 模式，将回传的数据段写入./ios/Flutter/Resource/路径下。

static void CreateAndWritePrecompiledSnapshot() {
  ASSERT(IsSnapshottingForPrecompilation());
  Dart_Handle result;

  // Precompile with specified embedder entry points
  result = Dart_Precompile();
  CHECK_RESULT(result);

  // Create a precompiled snapshot.
  if (snapshot_kind == kAppAOTAssembly) {
    if (strip && (debugging_info_filename == nullptr)) {
      Syslog::PrintErr(
          "Warning: Generating assembly code without DWARF debugging"
          " information.\n");
    }
    if (loading_unit_manifest_filename == nullptr) {
      File* file = OpenFile(assembly_filename);
      RefCntReleaseScope<File> rs(file);
      File* debug_file = nullptr;
      if (debugging_info_filename != nullptr) {
        debug_file = OpenFile(debugging_info_filename);
      }
      //在flutter编译目录下创建Resource目录，用于存放数据段产物
       FILE *fp = NULL;
       fp = fopen("./ios/Flutter/Resource/", "w");
      
       if (!fp) {
          mkdir("./ios/Flutter/Resource/", 0775);
       }
       else
       {
            fclose(fp);
       }
       //创建data_buffer对象用于回写数据段
        uint8_t* vm_snapshot_data_buffer = NULL;
        intptr_t vm_snapshot_data_size = 0;
        uint8_t* isolate_snapshot_data_buffer = NULL;
        intptr_t isolate_snapshot_data_size = 0;
        
        //对Dart_CreateAppAOTSnapshotAsAssembly方法改造，将数据        
        段回写到磁盘上
        result = Dart_CreateAppAOTSnapshotAsAssembly(
        &vm_snapshot_data_buffer, 
        &vm_snapshot_data_size,
        &isolate_snapshot_data_buffer, 
        &isolate_snapshot_data_size,
        StreamingWriteCallback, file,
        strip, 
        debug_file);
        //写入isolate_snapshot_data数据段
        WriteFile("./ios/Flutter/Resource/isolate_snapshot_data",                                 
                   isolate_snapshot_data_buffer,                                                                
                   isolate_snapshot_data_size);
        //写入vm_snapshot_data数据段             
        WriteFile("./ios/Flutter/Resource/vm_snapshot_data",     
                                    vm_snapshot_data_buffer,                                                                           
                                    vm_snapshot_data_size);                                                                                       
                     
                                                              
                                                                                 
       if (debug_file != nullptr) debug_file->Release();
       CHECK_RESULT(result);
    } else {
    }
..... 此处省略无关代码 .......    
}

static void CreateAndWritePrecompiledSnapshot() {

ASSERT(IsSnapshottingForPrecompilation());

Dart_Handle result;

// Precompile with specified embedder entry points

result = Dart_Precompile();

CHECK_RESULT(result);

// Create a precompiled snapshot.

if (snapshot_kind == kAppAOTAssembly) {

if (strip && (debugging_info_filename == nullptr)) {

Syslog::PrintErr(

"Warning: Generating assembly code without DWARF debugging"

" information.\n");

}

if (loading_unit_manifest_filename == nullptr) {

File* file = OpenFile(assembly_filename);

RefCntReleaseScope<File> rs(file);

File* debug_file = nullptr;

if (debugging_info_filename != nullptr) {

debug_file = OpenFile(debugging_info_filename);

}

//在flutter编译目录下创建Resource目录，用于存放数据段产物

FILE *fp = NULL;

fp = fopen("./ios/Flutter/Resource/", "w");

if (!fp) {

mkdir("./ios/Flutter/Resource/", 0775);

}

else

{

fclose(fp);

}

//创建data_buffer对象用于回写数据段

uint8_t* vm_snapshot_data_buffer = NULL;

intptr_t vm_snapshot_data_size = 0;

uint8_t* isolate_snapshot_data_buffer = NULL;

intptr_t isolate_snapshot_data_size = 0;

//对Dart_CreateAppAOTSnapshotAsAssembly方法改造，将数据

段回写到磁盘上

result = Dart_CreateAppAOTSnapshotAsAssembly(

&vm_snapshot_data_buffer,

&vm_snapshot_data_size,

&isolate_snapshot_data_buffer,

&isolate_snapshot_data_size,

StreamingWriteCallback, file,

strip,

debug_file);

//写入isolate_snapshot_data数据段

WriteFile("./ios/Flutter/Resource/isolate_snapshot_data",

isolate_snapshot_data_buffer,

isolate_snapshot_data_size);

//写入vm_snapshot_data数据段

WriteFile("./ios/Flutter/Resource/vm_snapshot_data",

vm_snapshot_data_buffer,

vm_snapshot_data_size);

if (debug_file != nullptr) debug_file->Release();

CHECK_RESULT(result);

} else {

}

..... 此处省略无关代码 .......

}

Dart_CreateAppAOTSnapshotAsAssembly 具体实现为在 dart_api_impl.cc 文件，gen_snapshot 编译器会将 dart 代码编译为 snapshot_assembly.S 文件，而 snapshot_assembly.S 文件实际上就包含了

kDartIsolateSnapshotData //数据段

kDartVmSnapshotData //数据段

kDartIsolateSnapshotInstructions //代码段

kDartVmSnapshotInstructions //代码段

这几部分。那么我们找到如何将数据段和代码段写入 snapshot_assembly.S 文件，把数据段分离出来不就可以了吗？我们在 FullSnapshotWriter 里发现了整个 snapshot_assembly.S 的写入过程。

DART_EXPORT Dart_Handle
//增加四个参数用于回写数据段
Dart_CreateAppAOTSnapshotAsAssembly(uint8_t** vm_snapshot_data_buffer,
                                    intptr_t* vm_snapshot_data_size,
                                    uint8_t** isolate_snapshot_data_buffer,
                                    intptr_t* isolate_snapshot_data_size,
                                    Dart_StreamingWriteCallback callback,
                                    void* callback_data,
                                    bool strip,
                                    void* debug_callback_data)  {
#if defined(TARGET_ARCH_IA32)
  return Api::NewError("AOT compilation is not supported on IA32.");
#elif defined(TARGET_OS_WINDOWS)
  return Api::NewError("Assembly generation is not implemented for Windows.");
#elif !defined(DART_PRECOMPILER)
  return Api::NewError(
      "This VM was built without support for AOT compilation.");
#else
  DARTSCOPE(Thread::Current());
  API_TIMELINE_DURATION(T);
  CHECK_NULL(callback);

  // Mark as not split.
  T->isolate_group()->object_store()->set_loading_units(Object::null_array());
    
    GrowableArray<LoadingUnitSerializationData*>* units = nullptr;
    LoadingUnitSerializationData* unit = nullptr;
    uint32_t program_hash = 0;
    
    const bool generate_debug = debug_callback_data != nullptr;

    ZoneWriteStream vm_snapshot_data(T->zone(), FullSnapshotWriter::kInitialSize);
    ZoneWriteStream vm_snapshot_instructions(T->zone(), kInitialSize);
    ZoneWriteStream isolate_snapshot_data(T->zone(),
                                          FullSnapshotWriter::kInitialSize);
    ZoneWriteStream isolate_snapshot_instructions(T->zone(), kInitialSize);

    StreamingWriteStream assembly_stream(kAssemblyInitialSize, callback,
                                         callback_data);
    StreamingWriteStream debug_stream(generate_debug ? kInitialDebugSize : 0,
                                      callback, debug_callback_data);

    auto const elf = generate_debug
                         ? new (Z) Elf(Z, &debug_stream, Elf::Type::DebugInfo,
                                       new (Z) Dwarf(Z))
                         : nullptr;

    AssemblyImageWriter image_writer(T, &assembly_stream, strip, elf);
    FullSnapshotWriter writer(Snapshot::kFullAOT, &vm_snapshot_data,
                              &isolate_snapshot_data, &image_writer,
                              &image_writer);

    if (unit == nullptr || unit->id() == LoadingUnit::kRootId) {
      writer.WriteFullSnapshot(units);
    } else {
      writer.WriteUnitSnapshot(units, unit, program_hash);
    }
      
    image_writer.Finalize();
    //数据段大小与buffer
    *vm_snapshot_data_buffer = vm_snapshot_data.buffer();
    *vm_snapshot_data_size = vm_snapshot_data.bytes_written();
    *isolate_snapshot_data_buffer = isolate_snapshot_data.buffer();
    *isolate_snapshot_data_size = isolate_snapshot_data.bytes_written();

  return Api::Success();
#endif
}

DART_EXPORT Dart_Handle

//增加四个参数用于回写数据段

Dart_CreateAppAOTSnapshotAsAssembly(uint8_t** vm_snapshot_data_buffer,

intptr_t* vm_snapshot_data_size,

uint8_t** isolate_snapshot_data_buffer,

intptr_t* isolate_snapshot_data_size,

Dart_StreamingWriteCallback callback,

void* callback_data,

bool strip,

void* debug_callback_data) {

#if defined(TARGET_ARCH_IA32)

return Api::NewError("AOT compilation is not supported on IA32.");

#elif defined(TARGET_OS_WINDOWS)

return Api::NewError("Assembly generation is not implemented for Windows.");

#elif !defined(DART_PRECOMPILER)

return Api::NewError(

"This VM was built without support for AOT compilation.");

#else

DARTSCOPE(Thread::Current());

API_TIMELINE_DURATION(T);

CHECK_NULL(callback);

// Mark as not split.

T->isolate_group()->object_store()->set_loading_units(Object::null_array());

GrowableArray<LoadingUnitSerializationData*>* units = nullptr;

LoadingUnitSerializationData* unit = nullptr;

uint32_t program_hash = 0;

const bool generate_debug = debug_callback_data != nullptr;

ZoneWriteStream vm_snapshot_data(T->zone(), FullSnapshotWriter::kInitialSize);

ZoneWriteStream vm_snapshot_instructions(T->zone(), kInitialSize);

ZoneWriteStream isolate_snapshot_data(T->zone(),

FullSnapshotWriter::kInitialSize);

ZoneWriteStream isolate_snapshot_instructions(T->zone(), kInitialSize);

StreamingWriteStream assembly_stream(kAssemblyInitialSize, callback,

callback_data);

StreamingWriteStream debug_stream(generate_debug ? kInitialDebugSize : 0,

callback, debug_callback_data);

auto const elf = generate_debug

? new (Z) Elf(Z, &debug_stream, Elf::Type::DebugInfo,

new (Z) Dwarf(Z))

: nullptr;

AssemblyImageWriter image_writer(T, &assembly_stream, strip, elf);

FullSnapshotWriter writer(Snapshot::kFullAOT, &vm_snapshot_data,

&isolate_snapshot_data, &image_writer,

&image_writer);

if (unit == nullptr || unit->id() == LoadingUnit::kRootId) {

writer.WriteFullSnapshot(units);

} else {

writer.WriteUnitSnapshot(units, unit, program_hash);

}

image_writer.Finalize();

//数据段大小与buffer

*vm_snapshot_data_buffer = vm_snapshot_data.buffer();

*vm_snapshot_data_size = vm_snapshot_data.bytes_written();

*isolate_snapshot_data_buffer = isolate_snapshot_data.buffer();

*isolate_snapshot_data_size = isolate_snapshot_data.bytes_written();

return Api::Success();

#endif

}

到这一步我们已经将数据段回写到磁盘上了,Resource 下成功写入了两个数据段产物，如下图：

2.2.2、将数据段从可执行文件中剔除

同理，找到写入数据段的位置，将其剔除，我们本着改动量最小的原则，分析原有写入逻辑，发现源码里已经将不同符号类型的数据归类，那么顺着原有逻辑，在写入符号的时候，将数据段类型剔除即可。具体源码如下：

//判断符号类型
const char* ImageWriter::SectionSymbol(ProgramSection section, bool vm) const {
  switch (section) {
    case ProgramSection::Text:
      return vm ? kVmSnapshotInstructionsAsmSymbol
                : kIsolateSnapshotInstructionsAsmSymbol;
    case ProgramSection::Data:
      return vm ? kVmSnapshotDataAsmSymbol : kIsolateSnapshotDataAsmSymbol;
    case ProgramSection::Bss:
      return vm ? kVmSnapshotBssAsmSymbol : kIsolateSnapshotBssAsmSymbol;
    case ProgramSection::BuildId:
      return kSnapshotBuildIdAsmSymbol;
  }
  return nullptr;
}

//
void AssemblyImageWriter::WriteROData(NonStreamingWriteStream* clustered_stream,
                                      bool vm) {
  ImageWriter::WriteROData(clustered_stream, vm);
  if (!EnterSection(ProgramSection::Data, vm, ImageWriter::kRODataAlignment)) {
    return;
  }
  WriteBytes(clustered_stream->buffer(), clustered_stream->bytes_written());
  ExitSection(ProgramSection::Data, vm, clustered_stream->bytes_written());
}

bool AssemblyImageWriter::EnterSection(ProgramSection section,
                                       bool vm,
                                       intptr_t alignment) {
  ASSERT(FLAG_precompiled_mode);
  ASSERT(current_section_symbol_ == nullptr);
  bool global_symbol = false;
  switch (section) {
    case ProgramSection::Text:
      assembly_stream_->WriteString(".text\n");
      global_symbol = true;
      break;
    case ProgramSection::Data:
#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_ANDROID) ||                  \
    defined(TARGET_OS_FUCHSIA)
      assembly_stream_->WriteString(".section .rodata\n");
#elif defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)
      assembly_stream_->WriteString(".const\n");
#else
      UNIMPLEMENTED();
#endif
      global_symbol = true;
      break;
    case ProgramSection::Bss:
      assembly_stream_->WriteString(".bss\n");
      break;
    case ProgramSection::BuildId:
      break;
  }
  current_section_symbol_ = SectionSymbol(section, vm);
  ASSERT(current_section_symbol_ != nullptr);
  //SectionSymbol方法返回current_section_symbol对象是否是数据段类型，若为true，则返回false不写入。注：strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。  
  if (strcmp(current_section_symbol_, kVmSnapshotDataAsmSymbol) == 0 || strcmp(current_section_symbol_, kIsolateSnapshotDataAsmSymbol) == 0) {
    return false;
  }
  if (global_symbol) {
    assembly_stream_->Printf(".globl %s\n", current_section_symbol_);
  }
  Align(alignment);
  assembly_stream_->Printf("%s:\n", current_section_symbol_);
  return true;
}

//判断符号类型

const char* ImageWriter::SectionSymbol(ProgramSection section, bool vm) const {

switch (section) {

case ProgramSection::Text:

return vm ? kVmSnapshotInstructionsAsmSymbol

: kIsolateSnapshotInstructionsAsmSymbol;

case ProgramSection::Data:

return vm ? kVmSnapshotDataAsmSymbol : kIsolateSnapshotDataAsmSymbol;

case ProgramSection::Bss:

return vm ? kVmSnapshotBssAsmSymbol : kIsolateSnapshotBssAsmSymbol;

case ProgramSection::BuildId:

return kSnapshotBuildIdAsmSymbol;

}

return nullptr;

}

void AssemblyImageWriter::WriteROData(NonStreamingWriteStream* clustered_stream,

bool vm) {

ImageWriter::WriteROData(clustered_stream, vm);

if (!EnterSection(ProgramSection::Data, vm, ImageWriter::kRODataAlignment)) {

return;

}

WriteBytes(clustered_stream->buffer(), clustered_stream->bytes_written());

ExitSection(ProgramSection::Data, vm, clustered_stream->bytes_written());

}

bool AssemblyImageWriter::EnterSection(ProgramSection section,

bool vm,

intptr_t alignment) {

ASSERT(FLAG_precompiled_mode);

ASSERT(current_section_symbol_ == nullptr);

bool global_symbol = false;

switch (section) {

case ProgramSection::Text:

assembly_stream_->WriteString(".text\n");

global_symbol = true;

break;

case ProgramSection::Data:

#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_ANDROID) || \

defined(TARGET_OS_FUCHSIA)

assembly_stream_->WriteString(".section .rodata\n");

#elif defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)

assembly_stream_->WriteString(".const\n");

#else

UNIMPLEMENTED();

#endif

global_symbol = true;

break;

case ProgramSection::Bss:

assembly_stream_->WriteString(".bss\n");

break;

case ProgramSection::BuildId:

break;

}

current_section_symbol_ = SectionSymbol(section, vm);

ASSERT(current_section_symbol_ != nullptr);

//SectionSymbol方法返回current_section_symbol对象是否是数据段类型，若为true，则返回false不写入。注：strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

if (strcmp(current_section_symbol_, kVmSnapshotDataAsmSymbol) == 0 || strcmp(current_section_symbol_, kIsolateSnapshotDataAsmSymbol) == 0) {

return false;

}

if (global_symbol) {

assembly_stream_->Printf(".globl %s\n", current_section_symbol_);

}

Align(alignment);

assembly_stream_->Printf("%s:\n", current_section_symbol_);

return true;

}

通过 nm 命令验证 App 文件中是否只剩下代码段：

对比剥离之前：

数据段剥离之后，也就完成了我们瘦身的目的，但是 App 运行时，没有数据段是不行的，会造成 App 崩溃，因此我们还需要一套完善的方案，来保证数据段从远端下发之后，安全的被加载。

2.2.3、如何加载分离后的数据段

我们来看下加载流程

Flutter 引擎启动的时候，会创建 DartVM，同时加载可执行文件中的代码段和数据段。具体方法可追溯到 ResolveVMData、ResolveVMInstructions、ResolveIsolateData、ResolveIsolateInstructions 等四个方法，分别加载了数据段与代码段，而这四个方法都指向了同一个方法，也就是 SearchMapping 方法，如下：

static std::shared_ptr<const fml::Mapping> ResolveVMData(
    const Settings& settings) {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(kDartVmSnapshotData, 0);
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.vm_snapshot_data,          // embedder_mapping_callback
      settings.vm_snapshot_data_path,     // file_path
      settings.application_library_path,  // native_library_path
      DartSnapshot::kVMDataSymbol,        // native_library_symbol_name
      false                               // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

static std::shared_ptr<const fml::Mapping> ResolveVMInstructions(
    const Settings& settings) {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(kDartVmSnapshotInstructions, 0);
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.vm_snapshot_instr,           // embedder_mapping_callback
      settings.vm_snapshot_instr_path,      // file_path
      settings.application_library_path,    // native_library_path
      DartSnapshot::kVMInstructionsSymbol,  // native_library_symbol_name
      true                                  // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

static std::shared_ptr<const fml::Mapping> ResolveIsolateData(
    const Settings& settings) {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(kDartIsolateSnapshotData, 0);
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.isolate_snapshot_data,       // embedder_mapping_callback
      settings.isolate_snapshot_data_path,  // file_path
      settings.application_library_path,    // native_library_path
      DartSnapshot::kIsolateDataSymbol,     // native_library_symbol_name
      false                                 // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

static std::shared_ptr<const fml::Mapping> ResolveIsolateInstructions(
    const Settings& settings) {
#if DART_SNAPSHOT_STATIC_LINK
  return std::make_unique<fml::NonOwnedMapping>(
      kDartIsolateSnapshotInstructions, 0);
#else   // DART_SNAPSHOT_STATIC_LINK
  return SearchMapping(
      settings.isolate_snapshot_instr,           // embedder_mapping_callback
      settings.isolate_snapshot_instr_path,      // file_path
      settings.application_library_path,         // native_library_path
      DartSnapshot::kIsolateInstructionsSymbol,  // native_library_symbol_name
      true                                       // is_executable
  );
#endif  // DART_SNAPSHOT_STATIC_LINK
}

static std::shared_ptr<const fml::Mapping> ResolveVMData(

const Settings& settings) {

#if DART_SNAPSHOT_STATIC_LINK

return std::make_unique<fml::NonOwnedMapping>(kDartVmSnapshotData, 0);

#else // DART_SNAPSHOT_STATIC_LINK

return SearchMapping(

settings.vm_snapshot_data, // embedder_mapping_callback

settings.vm_snapshot_data_path, // file_path

settings.application_library_path, // native_library_path

DartSnapshot::kVMDataSymbol, // native_library_symbol_name

false // is_executable

);

#endif // DART_SNAPSHOT_STATIC_LINK

}

static std::shared_ptr<const fml::Mapping> ResolveVMInstructions(

const Settings& settings) {

#if DART_SNAPSHOT_STATIC_LINK

return std::make_unique<fml::NonOwnedMapping>(kDartVmSnapshotInstructions, 0);

#else // DART_SNAPSHOT_STATIC_LINK

return SearchMapping(

settings.vm_snapshot_instr, // embedder_mapping_callback

settings.vm_snapshot_instr_path, // file_path

settings.application_library_path, // native_library_path

DartSnapshot::kVMInstructionsSymbol, // native_library_symbol_name

true // is_executable

);

#endif // DART_SNAPSHOT_STATIC_LINK

}

static std::shared_ptr<const fml::Mapping> ResolveIsolateData(

const Settings& settings) {

#if DART_SNAPSHOT_STATIC_LINK

return std::make_unique<fml::NonOwnedMapping>(kDartIsolateSnapshotData, 0);

#else // DART_SNAPSHOT_STATIC_LINK

return SearchMapping(

settings.isolate_snapshot_data, // embedder_mapping_callback

settings.isolate_snapshot_data_path, // file_path

settings.application_library_path, // native_library_path

DartSnapshot::kIsolateDataSymbol, // native_library_symbol_name

false // is_executable

);

#endif // DART_SNAPSHOT_STATIC_LINK

}

static std::shared_ptr<const fml::Mapping> ResolveIsolateInstructions(

const Settings& settings) {

#if DART_SNAPSHOT_STATIC_LINK

return std::make_unique<fml::NonOwnedMapping>(

kDartIsolateSnapshotInstructions, 0);

#else // DART_SNAPSHOT_STATIC_LINK

return SearchMapping(

settings.isolate_snapshot_instr, // embedder_mapping_callback

settings.isolate_snapshot_instr_path, // file_path

settings.application_library_path, // native_library_path

DartSnapshot::kIsolateInstructionsSymbol, // native_library_symbol_name

true // is_executable

);

#endif // DART_SNAPSHOT_STATIC_LINK

}

static std::shared_ptr<const fml::Mapping> SearchMapping(
    MappingCallback embedder_mapping_callback,
    const std::string& file_path,
    const std::vector<std::string>& native_library_path,
    const char* native_library_symbol_name,
    bool is_executable) {
  // Ask the embedder. There is no fallback as we expect the embedders (via
  // their embedding APIs) to just specify the mappings directly.
  
  if (embedder_mapping_callback) {
    return embedder_mapping_callback();
  }
  //从settings.vm_snapshot_data_path或settings.isolate_snapshot_data_path加载
  // Attempt to open file at path specified.
  if (file_path.size() > 0) {
    if (auto file_mapping = GetFileMapping(file_path, is_executable)) {
      return file_mapping;
    }
  }
// 从 settings.application_library_path 中加载
  // Look in application specified native library if specified.
  for (const std::string& path : native_library_path) {
    auto native_library = fml::NativeLibrary::Create(path.c_str());
    auto symbol_mapping = std::make_unique<const fml::SymbolMapping>(
        native_library, native_library_symbol_name);
    if (symbol_mapping->GetMapping() != nullptr) {
      return symbol_mapping;
    }
  }

  // 从native_library_symbol_name加载
  {
    auto loaded_process = fml::NativeLibrary::CreateForCurrentProcess();
    auto symbol_mapping = std::make_unique<const fml::SymbolMapping>(
        loaded_process, native_library_symbol_name);
    if (symbol_mapping->GetMapping() != nullptr) {
      return symbol_mapping;
    }
  }

  return nullptr;
}

static std::shared_ptr<const fml::Mapping> SearchMapping(

MappingCallback embedder_mapping_callback,

const std::string& file_path,

const std::vector<std::string>& native_library_path,

const char* native_library_symbol_name,

bool is_executable) {

// Ask the embedder. There is no fallback as we expect the embedders (via

// their embedding APIs) to just specify the mappings directly.

if (embedder_mapping_callback) {

return embedder_mapping_callback();

}

//从settings.vm_snapshot_data_path或settings.isolate_snapshot_data_path加载

// Attempt to open file at path specified.

if (file_path.size() > 0) {

if (auto file_mapping = GetFileMapping(file_path, is_executable)) {

return file_mapping;

}

// 从 settings.application_library_path 中加载

// Look in application specified native library if specified.

for (const std::string& path : native_library_path) {

auto native_library = fml::NativeLibrary::Create(path.c_str());

auto symbol_mapping = std::make_unique<const fml::SymbolMapping>(

native_library, native_library_symbol_name);

if (symbol_mapping->GetMapping() != nullptr) {

return symbol_mapping;

}

// 从native_library_symbol_name加载

{

auto loaded_process = fml::NativeLibrary::CreateForCurrentProcess();

auto symbol_mapping = std::make_unique<const fml::SymbolMapping>(

loaded_process, native_library_symbol_name);

if (symbol_mapping->GetMapping() != nullptr) {

return symbol_mapping;

}

return nullptr;

}

从 SearchMapping 方法中可以判断，加载顺序为，先从 settings.vm_snapshot_data 或 settings.isolate_snapshot_data 加载，若不存在则从 settings.vm_snapshot_data_path 或 settings.isolate_snapshot_data_path 读取，再然后从 settings.application_library_path 中加载。

那么如果我们篡改 settings.vm_snapshot_data_path 和 settings.isolate_snapshot_data_path 的指向，是否可以将我们本地的数据段正确加载呢？答案是肯定的。

struct Settings {
  Settings();

  Settings(const Settings& other);

  ~Settings();

  // VM settings
  std::string vm_snapshot_data_path;  // deprecated
  MappingCallback vm_snapshot_data;
  std::string vm_snapshot_instr_path;  // deprecated
  MappingCallback vm_snapshot_instr;

  std::string isolate_snapshot_data_path;  // deprecated
  MappingCallback isolate_snapshot_data;
  std::string isolate_snapshot_instr_path;  // deprecated
  MappingCallback isolate_snapshot_instr;
  std::string assets_path;  //flutter_assets路径
  std::string icu_data_path;  //icu_data国际化路径
  .... 此部分省略 ....  
}

struct Settings {

Settings();

Settings(const Settings& other);

~Settings();

// VM settings

std::string vm_snapshot_data_path; // deprecated

MappingCallback vm_snapshot_data;

std::string vm_snapshot_instr_path; // deprecated

MappingCallback vm_snapshot_instr;

std::string isolate_snapshot_data_path; // deprecated

MappingCallback isolate_snapshot_data;

std::string isolate_snapshot_instr_path; // deprecated

MappingCallback isolate_snapshot_instr;

std::string assets_path; //flutter_assets路径

std::string icu_data_path; //icu_data国际化路径

.... 此部分省略 ....

}

从上面的加载流程图里可以看出来 Setting 类的初始化是在 FlutterDartProject 类里。我们在 FlutterDartProject 重设数据段路径、flutter_assets 路径和 icu_data 国际化文件路径。

首先我们在 App 启动时将分离产物下载到沙盒内的指定路径下：Document/flutter_resource/Resource/*

然后将 setting 类中 path 指定到此路径下。

NSLog(@"开始设置路径");
    //设置沙盒路径
    NSArray * documentPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString * documentDirectory = [documentPaths objectAtIndex:0];
    //设置vm_snapshot_data路径
    NSString *vm_snapshot_data_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/vm_snapshot_data",documentDirectory];
    if ([[NSFileManager defaultManager] fileExistsAtPath:vm_snapshot_data_path]) {
        settings.vm_snapshot_data_path = vm_snapshot_data_path.UTF8String;
    }
    
    //设置isolate_snapshot_data路径
    NSString *isolate_snapshot_data_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/isolate_snapshot_data",documentDirectory];
    if ([[NSFileManager defaultManager] fileExistsAtPath:isolate_snapshot_data_path]) {
        settings.isolate_snapshot_data_path = isolate_snapshot_data_path.UTF8String;
    }
    
    //设置资源路径
    NSString *assets_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/flutter_assets",documentDirectory];
    
    if ([[NSFileManager defaultManager] fileExistsAtPath:assets_path]) {
        settings.assets_path = assets_path.UTF8String;
    }
    else {
        NSString* assetsName = [FlutterDartProject flutterAssetsName:bundle];
        NSString* assetsPath = [bundle pathForResource:assetsName ofType:@""];
        
        if (assetsPath.length == 0) {
            assetsPath = [mainBundle pathForResource:assetsName ofType:@""];
        }
        
        if (assetsPath.length == 0) {
            NSLog(@"Failed to find assets path for \"%@\"", assetsName);
        } else {
            settings.assets_path = assetsPath.UTF8String;
        }
    }
    //设置icu_data_path
    NSString *icu_data_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/icudtl.dat",documentDirectory];
    if ([[NSFileManager defaultManager] fileExistsAtPath:icu_data_path]) {
        settings.icu_data_path = icu_data_path.UTF8String;
    }
    else {
        NSString* icuDataPath = [engineBundle pathForResource:@"icudtl" ofType:@"dat"];
        if (icuDataPath.length > 0) {
            settings.icu_data_path = icuDataPath.UTF8String;
        }
    }
    
    if ([[NSFileManager defaultManager] fileExistsAtPath:vm_snapshot_data_path] && [[NSFileManager defaultManager] fileExistsAtPath:isolate_snapshot_data_path] ) {
        NSLog(@"data存在");
    }
    else {
        NSLog(@"data不存在");
    }
    
    NSLog(@"路径设置完毕");

NSLog(@"开始设置路径");

//设置沙盒路径

NSArray * documentPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);

NSString * documentDirectory = [documentPaths objectAtIndex:0];

//设置vm_snapshot_data路径

NSString *vm_snapshot_data_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/vm_snapshot_data",documentDirectory];

if ([[NSFileManager defaultManager] fileExistsAtPath:vm_snapshot_data_path]) {

settings.vm_snapshot_data_path = vm_snapshot_data_path.UTF8String;

}

//设置isolate_snapshot_data路径

NSString *isolate_snapshot_data_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/isolate_snapshot_data",documentDirectory];

if ([[NSFileManager defaultManager] fileExistsAtPath:isolate_snapshot_data_path]) {

settings.isolate_snapshot_data_path = isolate_snapshot_data_path.UTF8String;

}

//设置资源路径

NSString *assets_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/flutter_assets",documentDirectory];

if ([[NSFileManager defaultManager] fileExistsAtPath:assets_path]) {

settings.assets_path = assets_path.UTF8String;

}

else {

NSString* assetsName = [FlutterDartProject flutterAssetsName:bundle];

NSString* assetsPath = [bundle pathForResource:assetsName ofType:@""];

if (assetsPath.length == 0) {

assetsPath = [mainBundle pathForResource:assetsName ofType:@""];

}

if (assetsPath.length == 0) {

NSLog(@"Failed to find assets path for \"%@\"", assetsName);

} else {

settings.assets_path = assetsPath.UTF8String;

}

//设置icu_data_path

NSString *icu_data_path = [NSString stringWithFormat:@"%@/flutter_resource/Resource/icudtl.dat",documentDirectory];

if ([[NSFileManager defaultManager] fileExistsAtPath:icu_data_path]) {

settings.icu_data_path = icu_data_path.UTF8String;

}

else {

NSString* icuDataPath = [engineBundle pathForResource:@"icudtl" ofType:@"dat"];

if (icuDataPath.length > 0) {

settings.icu_data_path = icuDataPath.UTF8String;

}

if ([[NSFileManager defaultManager] fileExistsAtPath:vm_snapshot_data_path] && [[NSFileManager defaultManager] fileExistsAtPath:isolate_snapshot_data_path] ) {

NSLog(@"data存在");

}

else {

NSLog(@"data不存在");

}

NSLog(@"路径设置完毕");

设置完成以后，DartVM 启动所需要的各种资源与二进制就可以正常加载了。

工程化落地

有了初步的瘦身方案，具体落地还需要很多配套措施，比如持续集成，私有云及监控体系。

工程化落地主要包括三部分：

第一部分：定制 Flutter SDK

一、将 Flutter.framework 文件和 gen_snapshot 文件进行归档，同时需要制作 dSYM 符号表文件。

iOS 提供了两个工具，一个是用于 Flutter.framework 的规定及符号表导出，另一个是用于 gen_snapshot 文件的归档，他们位于 engine/src/flutter/sky/tools/create_ios_framework.py 和 engine/src/flutter/sky/tools/create_macos_gen_snapshots.py。

cd /path/to/engine/src

./flutter/sky/tools/create_ios_framework.py \
--arm64-out-dir /path/engine/src/out/ios_release \
--armv7-out-dir /path/engine/src/out/ios_release_arm  \
--simulator-out-dir /path/engine/src/out/ios_debug_sim  \
--dst /path/engine/src/out/flutter-engine/artifacts/ios-release \
--strip --dsym

./flutter/sky/tools/create_ios_framework.py \
--arm64-out-dir /path/engine/src/out/ios_profile \
--armv7-out-dir /path/engine/src/out/ios_profile_arm  \
--simulator-out-dir /path/engine/src/out/ios_debug_sim  \
--dst /path/engine/src/out/flutter-engine/artifacts/ios-profile \
--dsym

./flutter/sky/tools/create_ios_framework.py \
--arm64-out-dir /path/engine/src/out/ios_debug \
--armv7-out-dir /path/engine/src/out/ios_debug_arm  \
--simulator-out-dir /path/engine/src/out/ios_debug_sim  \
--dst /path/engine/src/out/flutter-engine/artifacts/ios \
--dsym

./flutter/sky/tools/create_macos_gen_snapshots.py \
--arm64-out-dir /path/engine/src/out/ios_release \
--armv7-out-dir /path/engine/src/out/ios_release_arm \
--dst /path/engine/src/out/flutter-engine/artifacts/ios-release

./flutter/sky/tools/create_macos_gen_snapshots.py \
--arm64-out-dir /path/engine/src/out/ios_profile \
--armv7-out-dir /path/engine/src/out/ios_profile_arm \
--dst /path/engine/src/out/flutter-engine/artifacts/ios-profile

./flutter/sky/tools/create_macos_gen_snapshots.py \
--arm64-out-dir /path/engine/src/out/ios_debug \
--armv7-out-dir /path/engine/src/out/ios_debug_arm \
--dst /path/engine/src/out/flutter-engine/artifacts/ios

cd /path/to/engine/src

./flutter/sky/tools/create_ios_framework.py \

--arm64-out-dir /path/engine/src/out/ios_release \

--armv7-out-dir /path/engine/src/out/ios_release_arm \

--simulator-out-dir /path/engine/src/out/ios_debug_sim \

--dst /path/engine/src/out/flutter-engine/artifacts/ios-release \

--strip --dsym

./flutter/sky/tools/create_ios_framework.py \

--arm64-out-dir /path/engine/src/out/ios_profile \

--armv7-out-dir /path/engine/src/out/ios_profile_arm \

--simulator-out-dir /path/engine/src/out/ios_debug_sim \

--dst /path/engine/src/out/flutter-engine/artifacts/ios-profile \

--dsym

./flutter/sky/tools/create_ios_framework.py \

--arm64-out-dir /path/engine/src/out/ios_debug \

--armv7-out-dir /path/engine/src/out/ios_debug_arm \

--simulator-out-dir /path/engine/src/out/ios_debug_sim \

--dst /path/engine/src/out/flutter-engine/artifacts/ios \

--dsym

./flutter/sky/tools/create_macos_gen_snapshots.py \

--arm64-out-dir /path/engine/src/out/ios_release \

--armv7-out-dir /path/engine/src/out/ios_release_arm \

--dst /path/engine/src/out/flutter-engine/artifacts/ios-release

./flutter/sky/tools/create_macos_gen_snapshots.py \

--arm64-out-dir /path/engine/src/out/ios_profile \

--armv7-out-dir /path/engine/src/out/ios_profile_arm \

--dst /path/engine/src/out/flutter-engine/artifacts/ios-profile

./flutter/sky/tools/create_macos_gen_snapshots.py \

--arm64-out-dir /path/engine/src/out/ios_debug \

--armv7-out-dir /path/engine/src/out/ios_debug_arm \

--dst /path/engine/src/out/flutter-engine/artifacts/ios

最终如图所示

ios-release 文件夹就是我们我最终改造完的产物，接下来就是定制 sdk 了。

实际上 Flutter sdk 里会根据不同的平台，不同的 build model 选择不同的编译器和 Flutter engine,如下图所示：

我们只需要把刚刚归档出来的 ios-release 替换 Flutter sdk 里的 ios-release 文件夹，之后 release 模式下打 iOS 产物，App.framework 就会是剥离出数据段的产物。

二、结合 flutterw 部署定制 sdk

由于目前公司 Flutter sdk 存在多个版本，比如 1.12.13、1.22.4 等，因此我们开发了 Flutter sdk 自动化管理工具 flutterw,可以根据项目的不同配置，切换不同的 Flutter sdk，包括官方 sdk，并且自动同步官方新版本。因此我们借助 flutterw 的能力，部署定制的 Flutter sdk,在有瘦身需求的项目里配置 sdk 版本即可。

首先发布定制 sdk:

$ flutterm upload -l /path/flutter -n 2.2.2 -c other -v 2.2.2 --platform macos

1	$ flutterm upload -l /path/flutter -n 2.2.2 -c other -v 2.2.2 --platform macos

结果如图：

接着在对应的项目中配置相应的 flutter sdk 版本，如下图：

三、改造 xcode_backend.sh 编译脚本，将数据段、资源包等压缩

ljEmbedFlutterFrameworks() {
  project_path=$1
  if [ ! -d "${project_path}/ios/Flutter" ]; then
    return 0
  fi
  local build_product_path="${project_path}/ios/Flutter"
  local app_framewok_path="${build_product_path}/App.framework"
  local thin_resource_zip="${app_framewok_path}/flutter_resource.zip"
  local thin_uuid_txt="${app_framewok_path}/uuid_app.txt"
  local flutter_framewok_path="${build_product_path}/Flutter.framework"

  RunCommand cp -rf "${BUILT_PRODUCTS_DIR}/App.framework" "${build_product_path}"
  RunCommand cp -rf "${BUILT_PRODUCTS_DIR}/Flutter.framework" "${build_product_path}"
  #当前编译uuid
  local uuid=`dwarfdump -u --arch=$ARCHS "${app_framewok_path}/App" | awk -F ' ' '{print $2}'`
  echo $uuid
  local old_uuid=""
  #判断上一步产物uuid是否一致
  if [ -f $thin_uuid_txt ];then
    old_uuid=$(cat $thin_uuid_txt);
  fi

  local tmep_assets_path="$app_framewok_path/flutter_assets"

  if [[ $uuid != "" && $uuid == $old_uuid ]];then

     if [ -f "${tmep_assets_path}/NOTICES" ];then
       RunCommand  rm -rf "${tmep_assets_path}/NOTICES"
     fi

     if [ -d "${tmep_assets_path}/fonts" ];then
       RunCommand rm -rf "${tmep_assets_path}/fonts"
     fi

    unzip -o $thin_resource_zip -d $build_product_path
    if [ -d $tmep_assets_path ];then
      if [ -d "$build_product_path/Resource/flutter_assets" ];then
        RunCommand rm -rf "$build_product_path/Resource/flutter_assets"
      fi
      RunCommand cp -rf $tmep_assets_path "$build_product_path/Resource"
    fi

    local temp_resource_zip="$build_product_path/flutter_resource.zip"
    RunCommand cd ${build_product_path} &&  zip -r flutter_resource.zip ./Resource
    RunCommand cd ${build_product_path} &&  zip -r $thin_resource_zip ./Resource
    RunCommand cp -rf $temp_resource_zip $app_framewok_path

    RunCommand rm -rf $tmep_assets_path
    RunCommand rm -rf $temp_resource_zip
    RunCommand rm -rf "$build_product_path/Resource"
    RunCommand rm -rf "$flutter_framewok_path/icudtl.dat"
  else
    if [[ ${thin_resource} != "" && -d ${thin_resource} ]];then
       if [ -f "${tmep_assets_path}/NOTICES" ];then
           RunCommand rm -rf "${tmep_assets_path}/NOTICES"
       fi

       if [ -d "${tmep_assets_path}/fonts" ];then
           RunCommand rm -rf "${tmep_assets_path}/fonts"
       fi

       RunCommand cp -rf ${tmep_assets_path} ${thin_resource}

       if [ -f "$flutter_framewok_path/icudtl.dat" ];then
          RunCommand cp -f "$flutter_framewok_path/icudtl.dat" ${thin_resource}
       fi
       uuid=`dwarfdump -u --arch=arm64 "${app_framewok_path}/App" | awk -F ' ' '{print $2}'`
       echo ${uuid}>"$thin_uuid_txt"

       local temp_resource_zip="$build_product_path/flutter_resource.zip"
       RunCommand cd ${build_product_path} &&  zip -r flutter_resource.zip ./Resource
       RunCommand cp -f $temp_resource_zip $app_framewok_path

       RunCommand rm -rf $tmep_assets_path
       RunCommand rm -rf $temp_resource_zip
       RunCommand rm -rf "$thin_resource"
       RunCommand rm -rf "$flutter_framewok_path/icudtl.dat"
    else
       if [ -f ${thin_resource_zip} ];then
          RunCommand rm -rf $thin_resource_zip
       fi

       if [ -f ${thin_uuid_txt} ];then
          RunCommand rm -rf $thin_uuid_txt
       fi
    fi
  fi
}

ljEmbedFlutterFrameworks() {

project_path=$1

if [ ! -d "${project_path}/ios/Flutter" ]; then

return 0

local build_product_path="${project_path}/ios/Flutter"

local app_framewok_path="${build_product_path}/App.framework"

local thin_resource_zip="${app_framewok_path}/flutter_resource.zip"

local thin_uuid_txt="${app_framewok_path}/uuid_app.txt"

local flutter_framewok_path="${build_product_path}/Flutter.framework"

RunCommand cp -rf "${BUILT_PRODUCTS_DIR}/App.framework" "${build_product_path}"

RunCommand cp -rf "${BUILT_PRODUCTS_DIR}/Flutter.framework" "${build_product_path}"

#当前编译uuid

local uuid=`dwarfdump -u --arch=$ARCHS "${app_framewok_path}/App" | awk -F ' ' '{print $2}'`

echo $uuid

local old_uuid=""

#判断上一步产物uuid是否一致

if [ -f $thin_uuid_txt ];then

old_uuid=$(cat $thin_uuid_txt);

local tmep_assets_path="$app_framewok_path/flutter_assets"

if [[ $uuid != "" && $uuid == $old_uuid ]];then

if [ -f "${tmep_assets_path}/NOTICES" ];then

RunCommand rm -rf "${tmep_assets_path}/NOTICES"

if [ -d "${tmep_assets_path}/fonts" ];then

RunCommand rm -rf "${tmep_assets_path}/fonts"

unzip -o $thin_resource_zip -d $build_product_path

if [ -d $tmep_assets_path ];then

if [ -d "$build_product_path/Resource/flutter_assets" ];then

RunCommand rm -rf "$build_product_path/Resource/flutter_assets"

RunCommand cp -rf $tmep_assets_path "$build_product_path/Resource"

local temp_resource_zip="$build_product_path/flutter_resource.zip"

RunCommand cd ${build_product_path} && zip -r flutter_resource.zip ./Resource

RunCommand cd ${build_product_path} && zip -r $thin_resource_zip ./Resource

RunCommand cp -rf $temp_resource_zip $app_framewok_path

RunCommand rm -rf $tmep_assets_path

RunCommand rm -rf $temp_resource_zip

RunCommand rm -rf "$build_product_path/Resource"

RunCommand rm -rf "$flutter_framewok_path/icudtl.dat"

else

if [[ ${thin_resource} != "" && -d ${thin_resource} ]];then

if [ -f "${tmep_assets_path}/NOTICES" ];then

RunCommand rm -rf "${tmep_assets_path}/NOTICES"

if [ -d "${tmep_assets_path}/fonts" ];then

RunCommand rm -rf "${tmep_assets_path}/fonts"

RunCommand cp -rf ${tmep_assets_path} ${thin_resource}

if [ -f "$flutter_framewok_path/icudtl.dat" ];then

RunCommand cp -f "$flutter_framewok_path/icudtl.dat" ${thin_resource}

uuid=`dwarfdump -u --arch=arm64 "${app_framewok_path}/App" | awk -F ' ' '{print $2}'`

echo ${uuid}>"$thin_uuid_txt"

local temp_resource_zip="$build_product_path/flutter_resource.zip"

RunCommand cd ${build_product_path} && zip -r flutter_resource.zip ./Resource

RunCommand cp -f $temp_resource_zip $app_framewok_path

RunCommand rm -rf $tmep_assets_path

RunCommand rm -rf $temp_resource_zip

RunCommand rm -rf "$thin_resource"

RunCommand rm -rf "$flutter_framewok_path/icudtl.dat"

else

if [ -f ${thin_resource_zip} ];then

RunCommand rm -rf $thin_resource_zip

if [ -f ${thin_uuid_txt} ];then

RunCommand rm -rf $thin_uuid_txt

}

编译之后产物被压缩成 flutter_resource.zip，同时为了标识产物的唯一性，将可执行文件的 uuid 作为唯一标识，每次下载完成之后需要先对比 uuid 是否一致。若不一致则更新产物。

第二部分：上传产物平台或内置压缩

到这一步我们准备了两种方案：

内置压缩方案：

也就是将数据段和资源包统一压缩内置在 App.framework 内，应用安装启动后自动解压放在指定位置。

动态下发方案：

对于其他小体量 App,可以采取远程下发的方案，也就是将 flutter_resource.zip 和 uuid_app.txt 上传到 s3 平台（资源服务器），同时在阿波罗平台(配置平台)增加新版本配置。应用启动后下载的方案。

方案对比：

两种方案对比之下，动态下发的瘦身效果最好，但成功率没有内置压缩高，内置压缩方案由于只增加了一个解压环节，因此成功率较高。不同的 APP 可以根据自己的需求采用不同的方案。

第三部分：产物管理

若使用远端下载方案，App 启动会首先拉取远端产物，并将版本信息生成缓存，校验 md5 通过后即可加载，当发现有新版本产物则拉取新版本产物并替换。至于内置压缩方案，则根据 App.framework 的 UUID 来判断是否是正确的产物。

内置压缩方案成功率达到了 99.99%,极小部分失败原因在于内存空间不足。

对于远程下发方案，App 启动后下载相关资源并解压，成功率会受到网络因素影响，增加了重试逻辑之后成功率如下：

尽管下载成功率达到了 99.4%但对于 C 端这种大体量的 app 来说，仍然会影响大量的用户，因此在 C 端使用的是成功率更高的内置压缩方案。

收益

通过动态下发这种方式，虽然可以显著的减小 Flutter 包体积，但是也会带来其他问题，比如由于网络原因导致产物下载失败。因此我们提供了更加安全可靠的方式，将这些文件压缩然后内置在 app 包内。

动态下发方案：

压缩内置方案：

优势：

1.通用的解决方案，任何接入 Flutter 的 APP 都可以用

2.只需集成一次，无需定时优化

3.随着 Flutter 业务的增多，瘦身效果也会更明显

劣势：

剥离出的产物需要通过网络下发，下载成功率取决于网络状况、内存空间等等因素制约。所以后续规划中，会结合 Flutter2web 来缓解由于下载失败，导致 Flutter 页面无法打开的情况。

符号化剥离及混淆：

注：Thin 模式就是数据段及资源动态下发或内置压缩的模式

总体瘦身：

经过上述方案的优化，Flutter 侧瘦身总大小达到了 7M 左右。

而经过各个业务方共同的努力，贝壳找房 app 包大小终于达标。以当时的 V2.47 版本为例：

“iPhone6-iPhoneX 系列”机型安装大小 149.2-149.8M，下载大小 110.5M

“iPhone11-12”机型安装大小 139.4M，下载大小仅 53M

Flutter engine 的改造源码目前已经开源，如果想尝试贝壳方案的同学可以按照开源文档接入。

开源地址：GitHub - LianjiaTech/flutter_beike_engine

后续规划

基于以上的优势劣势，贝壳致力于更加高标准的目标, 那么有没有其他办法在不影响成功率的情况下最大程度的增加瘦身比例呢？答案是有的，那就是结合 Flutter for web 来做兜底方案。具体方案如下：

我们知道，Flutter 在三端一体化做了大量的工作，Flutter 页面可以很好的被转换为 web 页面，我们可以借助这个特性，在编译发版包的时候，同时将 Flutter 工程编译为 Web 产物并部署在远端，当 App 启动后 Flutter 产物由于种种原因最终都无法下载成功的时候，自动打开对应的 web 页面。

关于 Fluttter for web 容灾降级更详细内容可参考：

https://mp.weixin.qq.com/s/zIeU0z-4P5Pd9THVybnDFQ

参考链接

mimalloc剖析

mimalloc是微软最近开源的一个malloc实现，其实验数据表明相比于jemalloc、tcmalloc等实现大约快了10%。其通过将空闲块列表(Free List)进行分片(Sharding)来保证分配的内存有更好的空间的局部性，从而提升性能。在mimalloc中一共进行了4次Free List的Sharding。接下来我们会分别介绍这4个Free List的Sharding的位置以及其为什么要进行Free List的Sharding。

在Mimalloc页中进行的Free List的Sharding

在其他的内存分配器的实现中，一般会为每一类大小的对象保留一个Free List，随着内存的不断分配与释放，这个列表中的对象可能散布在整个地址空间中，因此内存分配的局部性较差。而在mimalloc中，其通过将内存分页，每个页负责一个特定大小的内存的分配，每个页有一个Free List，因此内存分配的空间局部性较好。

Local Free List

mimalloc希望能够限制内存分配与内存释放在最差情况下的时间消耗，如果上层应用需要释放一个非常大的结构体，其可能需要递归的释放一些子结构体，因而可能带来非常大的时间消耗。因而在koka与lean语言中，其运行时系统使用引用计数来追踪各种数据，然后保留一个延迟释放的队列(deferred decrement list)，当每次释放的内存块超过一定数量后就将剩余需要释放的内存块加入该队列，在之后需要释放的时候再进行释放。那么下一个需要确定的问题是什么时候再去从该队列中释放内存。从延迟释放队列中继续进行释放的时机最好应当是内存分配器需要更多空间的时候，因此这需要内存分配器与上层应用的协作。

在mimalloc中，其提供一个回调函数，当进行了一定次数内存的分配与释放后会主动调用该回调函数来通知上层应用。mimalloc在实现时检测当前进行内存分配的页的Free List是否为空，如果为空则调用该回调，但是为了避免用于一直不断的分配与释放内存，导致Free List一直不为空，而导致回调函数一直得不到回调。因此mimalloc将Free List第二次进行Sharding，将其分为Free List与Local Free List。

当内存在进行分配时会从对应页的Free List中取得内存块，而释放时会将内存块加入Local Free List中，因而在进行一定次数的内存分配后，Free List必定为空，此时可以进行deferred free的回调函数的调用。

Thread Free List

在mimalloc中每个堆都是一个Thread Local的变量，而每次进行内存分配时，其均会从这个Thread Local的堆中进行内存的分配，而释放时即可能从该线程中释放也可能从其他线程中进行释放。如果进行内存释放的线程是该堆的拥有者，则其释放的内存会加入到对应页的Local Free List中，而由于还可能有其他的线程来释放这些内存，因此mimalloc第三次进行Free List的Sharding，将Local Free List分为Local Free List与Thread Free List。在进行内存的释放时，如果释放的线程为内存块对应堆的拥有着则将其加入Local Free List，否则利用CAS操作将其加入Thread Free List中。mimalloc通过这次分割来保证堆的所有者线程在自己的堆上进行内存的释放是无锁的，从而提升一些性能上的表现。

Full List

第四次的Free List的Sharding其实来自于mimalloc自身的实现，其内存分配的伪代码如下。由于在mimalloc中每个堆中都有一个数组pages，该数组中每个元素都是一个由相应大小的页组成的队列；同时还有一个pages_direct的数组，该数组中每个元素对应一个内存块的大小类型，每个元素均为指向负责对应大小内存块分配的页的指针。因此mimalloc在进行内存分配时会首先从该数组指向的页中尝试进行分配，如果分配失败则调用malloc_generic，在该函数中会遍历pages数组中对应大小的队列，此时如果对应的队列中有很多页均是满的，且队列很长那么每次分配的时候都会进行队列的遍历，导致性能的损失。

void* malloc_small( size_t n ) {
  heap_t* heap = tlb;
  page_t* page = heap->pages_direct[(n+7)>>3];
  block_t* block = page->free;
  if (block==NULL) return malloc_generic(heap,n);
  page->free = block->next;
  page->used++;
  return block;
}

void* malloc_small( size_t n ) {

heap_t* heap = tlb;

page_t* page = heap->pages_direct[(n+7)>>3];

block_t* block = page->free;

if (block==NULL) return malloc_generic(heap,n);

page->free = block->next;

page->used++;

return block;

}

因此mimalloc构建了一个Full List，将所有已经没有空闲空间的页放入该队列中，仅当该页中有一些空闲空间被释放后才会将其放回pages对应的队列中。而在由于内存的释放可能由对应堆的拥有者线程进行也可能由其他线程进行，因此需要一定的方式提醒对应的堆该页已经有空闲块了，同时为了避免使用锁导致的开销，mimalloc通过加入一个Thread Delayed Free List，如果一个页处于Full List中，那么在释放时会将内存块加入Thread Delayed Free List中，该队列会在调用malloc_generic时进行检测与清除(由于时Thread Local的堆，因此仅可能是拥有者来进行)，因此此时仅需通过原子操作即可完成。那么还有一个问题是当释放内存的时候，其他线程如何知道是将内存块加入Thread Free List中还是Thread Delayed Free List中。mimalloc通过设置NORMAL、DELAYED、DELAYING三种状态来完成该操作。

总结

mimalloc通过将Free List进行分割，保证分配的内存具有较好的局部性并避免了锁的使用，从而获得了更好的性能。

参考链接

mimalloc剖析

高性能 PyTorch 训练：性能瓶颈的调查与分析

PyTorch

在 2014 年之前，神经网络与深度学习还没有大规模地应用于工业界。研究者们开发了一些基本而有效的工具包，来搭建神经网络。其中的代表就是 Caffe、Torch 和 Theano。由于当时的研究主流方向是卷积神经网络 (CNN) 在计算机视觉 (CV) 中的应用，所以这些框架主要关注的是 layers。这种设计完全可以满足研究者们拼接不同卷积层、了解不同神经网络结构效果的目的。

而在之后，随着循环神经网络 (RNN) 和自然语言处理 (NLP) 的兴起，以 layers 为“first class citizen”的工具包们就开始力不从心了。而工业界也开始对模型构建、训练以及部署的效率提出了新的要求。随着以 Google、Microsoft、Facebook、Amazon 等巨头的加入，以数据流 (Data Flow) 为中心的体系被提出，TensorFlow、CNTK、MXNet、PyTorch 等新一代的深度学习框架应运而生。

PyTorch 是一个基于 Torch 库的开源机器学习库，用于计算机视觉和自然语言处理等应用，主要由 Facebook 的人工智能研究实验室 (FAIR) 开发。它是在修改后的 BSD 2.0 许可协议下发布的免费开源软件。

正如同它名字的前缀一般，PyTorch 主要采用 Python 语言接口。与 TensorFlow 1.x 相比，PyTorch 的编写方式更简单自然，API 更 pythonic，对 debug 也更加友好。因此，PyTorch 在学术界赢得了更多的拥趸，近年来顶级会议中，PyTorch 的代码提交量遥遥领先于第二名的 TensorFlow (Keras)。而在工业界，PyTorch 后来居上，已经逐渐和 TensorFlow 分庭抗礼。

很多学术界最新的成果都是以 PyTorch 构建的，并被作者开源在了 GitHub。但也有很多声音表示 PyTorch 在训练中比 TensorFlow 更慢。

高性能 PyTorch 的训练流程是什么样的？是产生最高准确率的模型？是最快的运行速度？是易于理解和扩展？还是容易并行化？

答案是，上述所有。

结合我自己给 PyTorch 提速的经历，本文将给出一些提升 PyTorch 性能的方向。当然，作为本文的读者，您需要对 Linux 操作系统和 PyTorch 足够熟悉。

了解瓶颈所在

首先，当感受到训练缓慢时，我们应当检查系统的状态来得知代码的性能被哪些因素限制了。计算，是一个由应用程序（代码）、存储设备（硬盘、内存）、运算设备（CPU、GPU）共同参与的过程，有着非常明显的木桶效应，即其中任意一个环节都有可能成为性能瓶颈的来源。

工具

此时，熟悉一些运维工具可以有效地帮助你了解当前整个计算机以及各个硬件设备的工作状态。只有将性能瓶颈定位到 CPU、GPU、I/O 或是代码中，才能开始解决问题。

htop

htop 是一个跨平台的交互式流程查看器。

htop 允许垂直和水平滚动进程列表，以查看它们的完整命令行以及内存和CPU消耗等相关信息。显示的信息可以通过图形设置进行配置，并且可以交互地进行排序和过滤。与进程相关的任务（例如终止和更新）可以在不输入其 PID 的情况下完成。

从 htop 顶部的信息集合中，可以监视 CPU 和内存的使用情况。

一个好的高性能程序，应当尽可能多地进行异步运算，来充分发挥多核 CPU 的能力。同时，尽量多地使用内存，能够大大提高数据的交流效率。当然，这并不意味着你可以把所有的 CPU 和内存资源耗尽，这将使系统不能够正常调度资源，反而拖累计算。

在所有的 Linux 发行版中，你都可以直接从软件仓库中安装 htop，例如：

$ sudo apt install htop # Ubuntu/Debian

$ sudo yum install htop # RHEL/CentOS

$ sudo zypper install htop # openSUSE

$ sudo pacman -Syyu htop # Archlinux/Manjaro

$ sudo apt install htop # Ubuntu/Debian

$ sudo yum install htop # RHEL/CentOS

$ sudo zypper install htop # openSUSE

$ sudo pacman -Syyu htop # Archlinux/Manjaro

iotop 和 iostat

iotop 是用来监视每个命令所占用的 I/O 情况的命令行应用程序。

iostat 则是属于 sysstat 工具包中的一个组件，可以监视外部存储设备（硬盘）当前的 I/O 情况。

安装命令分别为：

$ sudo apt install iotop 

$ sudo apt install syssat

$ sudo apt install iotop

$ sudo apt install syssat

需要注意的是，因为涉及到 I/O 情况的监视，所以以上两款程序均需要 root 权限才能正常运行。

nvidia-smi

NVIDIA System Management Interface 是基于 NVIDIA Management Library (NVML) 的命令行应用程序，旨在帮助管理和监视 NVIDIA GPU 设备。

一般来说，GPU 的流处理器使用率越高，就说明 GPU 是在以更高的效率运转的。设备的当前功率也能从侧面反映这个问题。换言之，如果你发现你的流处理器利用率低于 50%，则说明模型没能很好地利用 GPU 的并行能力。

在通过 sh 脚本安装 NVIDIA GPU 驱动后，nvidia-smi 会被自动安装。如果是从发行版的仓库中安装的驱动，可以尝试在软件源中搜索安装 nvidia-smi。

nvtop

nvtop 代表 NVIDIA top，由开发者 Maxime Schmitt 发布于 GitHub，是一款用于观察和记录 NVIDIA GPU 使用情况的 (h)top 任务监视器。你会发现 nvtop 有着与 htop 非常相似的 UI。

它可以用于 GPU，并以曲线图的形式输出在一段时间内 GPU 流处理器和显存使用情况的变化。

相比于 nvidia-smi，nvtop 会关注到更关键的设备信息，并给出其在时间序列上的变化情况。

你可以参考 Syllo/nvtop 中的描述自行编译安装 nvtop。

py-spy

py-spy 是一个针对 Python 程序的采样分析器。

它使您可以直观地看到 Python 程序正在花费时间，而无需重新启动程序或以任何方式修改代码。 py-spy 的开销非常低：为了提高速度，它是用 Rust 编写的，并且不会在所分析的 Python 程序相同的进程中运行。这意味着对生产 Python 代码使用 py-spy 是安全的。

py-spy 可以生成如下的 SVG 图像，来帮助你统计每一个 package、model 甚至每一个 function 在运行时所耗费的时间。

py-spy 同样能够以 top 的方式实时显示 Python 程序中哪些函数花费的时间最多。

只需要在 pypi 中安装即可：

$ pip install py-spy

1	$ pip install py-spy

问题分析与解决思路

有了以上工具所收集的信息，我们就可以开始分析限制程序性能发挥的原因了。

PyTorch Workflow

而首先，我们要了解 PyTorch 的工作流程。

因为 PyTorch 使用 Python 接口，同时在底层调用了相当多的 C 库，所以在使用 PyTorch 时，很多细节对用户是不暴露的。实际上，在常见的训练过程中，用户和 PyTorch 一起，大致完成了以下的步骤：

构建模型。将编写好的模型类实例化为 nn.Module 对象。
准备数据。将训练数据和测试数据进行预处理，然后组织为 Dataloader 的形式，并设置好数据增强方案。
定义 Loss Function 和 Optimizer。
主训练循环。

其中，主训练循环决定了网络经过多少次完整的数据集，即我们常说的 epoch：

从 Dataloader 中提取当前 batch 的数据。一般 Dataloader 中只记录了数据的 index 信息，所以每次训练循环时，对应的数据都会从硬盘被读取到内存，然后再从内存放入显存中，交由 GPU 进行后续步骤。
数据经过模型。
将得到的输出送到 Loss Function 中计算损失，随后进行 backward 求导。
Optimizer 执行梯度下降，更新参数。

一般来说，PyTorch 训练的过程的快慢决定于主训练循环。主循环中的每一步都将被执行上万次乃至几十万次，任何的效率提升都能够带来极大的收益。

CPU 瓶颈

CPU 和 GPU 的计算特点，决定了它们不同的功用：CPU 具有更高的主频和精度，适合于进行串行任务；GPU 拥有几千到上万个 Stream 核心，可以进行大规模的并行任务。

所以，对于数据增强等没有相互依赖的任务交给 CPU 来进行，很大程度上会拖慢训练的进程。在每次的数据导入时，都会产生一定时间的等待。这是一种非常普遍的 CPU 瓶颈，即将不适合 CPU 的任务交给它来处理。

GPU 瓶颈

如果你熟悉梯度下降 (Gradient Descent) 的原理，那么你一定能够理解 batch size 对训练速度的影响。梯度下降将一个 batch 中的平均梯度作为总体梯度方向的近似，进行一次参数更新。Batch size 越大，那么 GPU 内同时并行计算的数据也就越多，相应的训练速度会有很大的提升。

Batch size 的设定对最终的训练结果有一定的影响，但是在一定范围内的调整并不会产生非常大的扰动。

主流观点中，在不过分影响最终的模型性能的前提下，batch size 的选取以最大化利用显存和流处理器为佳。

I/O 瓶颈

I/O 瓶颈是最常见、最普遍的训练效率影响因素。

正如上文中所描述的，数据将会在硬盘、内存和显存中不断地转移和复制。不同存储设备的读写速度，可能有几个数量级上的差异。

出现 I/O 瓶颈的标志主要有：

系统 I/O 读写（尤其是硬盘读写）占用过高；
内存占用和 CPU 占用都普遍偏低；
显存占用较高的情况下，流处理器的利用率过低。

将数据预读入内存中、异步进行数据加载都是有效的解决方案。一个简单稳定的方式是直接使用 DALI 库。

NVIDIA Data Loading Library (DALI) 是一个可移植的开源库，用于解码和增强图像、视频和语音，以加速深度学习应用程序。DALI 通过重叠训练和预处理减少了延迟和训练时间，缓解了瓶颈。它为流行的深度学习框架中内置的数据加载器和数据迭代器提供了一个插件，便于集成或重定向到不同的框架。

用图像训练神经网络需要开发人员首先对这些图像进行归一化处理。此外，图像通常会被压缩以节省存储空间。因此，开发人员构建了多阶段数据处理流程，包括加载、解码、裁剪、调整大小和许多其他增强算子。这些目前在 CPU 上执行的数据处理流水线已经成为瓶颈，限制了整体吞吐量。

DALI 是内置数据加载器和数据迭代器的高性能替代品。开发人员现在可以在 GPU 上运行他们的数据处理工作。

参考链接

高性能 PyTorch 训练 (1)：性能瓶颈的调查与分析

nvidia-smi GPU性能状态(Performance State)含义

我正在使用Nvidia GTX Titan X进行深度学习实验。
我正在使用nvidia-smi来监视GPU的运行状态，但是提供的工具的性能(性能)状态没有意义。

我已经查看了nvidia-smi手册，它表示以下内容：

Performance State
The current performance state for the GPU. States range from P0 (maximum performance) to P12 (minimum performance).

如果不在GPU上运行任何进程(空闲状态)，则GPU性能状态为p0。
但是，当运行一些计算繁重的过程时，状态变为p2。

我的问题是，为什么我的GPU闲置时处于P0状态，但是在执行繁重的计算任务时切换到P2？不应该相反吗？

另外，有没有办法使我的GPU始终在P0状态下运行(最高性能)？

令人困惑。

但是，nvidia-smi手册是正确的。

当一个或一组GPU处于空闲状态时，在计算机上运行nvidia-smi的过程通常会使其中一个GPU退出空闲状态。这是由于该工具正在收集的信息-需要唤醒其中一个GPU。

此唤醒过程最初会将GPU置于P0状态(最高性能状态)，但如果GPU空闲或不是特别忙碌，GPU驱动程序将监控该GPU，并最终开始降低性能状态以节省功耗。

另一方面，当GPU在工作负载下处于活动状态时，GPU驱动程序将根据其自身的启发式方法不断调整性能状态以提供最佳性能，同时使性能状态与实际工作负载相匹配。如果没有达到热或功率限制，则对于最活跃和最重的连续工作负载，性能状态应达到最高水平(P0)。

周期性很重但不连续的工作负载可能会导致GPU功耗状态在P0-P2级别附近波动。由于热(温度)或电源问题而"受限制"的GPU也可能会看到P状态降低。这种限制是显而易见的，并在nvidia-smi中单独报告，但是可能并非所有GPU类型都启用这种报告。

如果要在GPU上查看P0状态，我可以提供的最佳建议是运行短暂，繁重且连续的工作负载(例如，执行大型sgemm操作的工作)，然后在该工作负载期间监视GPU。在这种情况下应该可以看到P0状态。

如果您使用的是正在使用cuDNN库的机器学习应用程序(例如Caffe)，并且正在训练大型网络，则应该可以不时看到P0，因为cuDNN会执行类似于sgemm的操作通常情况下。

但是对于零星的工作负载，最常见的状态很有可能是P2。

要始终"强制" P0电源状态，可以尝试通过nvidia-smi工具尝试持久性模式和应用程序时钟。使用nvidia-smi --help或nvidia-smi的手册页了解选项。

尽管我认为这通常不适用于Tesla GPU，但除非特别设置更高的应用时钟，否则某些NVIDIA GPU可能会在计算负载下将自身限制为P2功耗状态。使用nvidia-smi -a命令查看可用于GPU的当前应用程序时钟，默认应用程序时钟和最大时钟。 (某些GPU(包括较旧的GPU)可能会在其中某些字段中显示N / A。这通常表明应用程序时钟无法通过nvidia-smi进行修改。)如果在计算负载期间卡似乎以P2状态运行，则可能通过将应用程序时钟增加到最大可用时钟(即最大时钟)，可以将其增加到P0状态。使用nvidia-smi --help了解如何格式化命令以更改GPU上的应用程序时钟。修改应用程序时钟或启用可修改的应用程序时钟可能需要root / admin特权。设置GPU持久模式也可能是理想的或必要的。这将防止驱动程序在GPU活动期间"卸载"，这可能导致驱动程序重新加载时重置应用程序时钟。

对于这种情况下受影响的卡，此默认行为是在计算负载下限制为P2，这是由GPU驱动程序设计的。

参考链接

ubuntu 21.10(GeForce GTX 3060 12GB)编译StyleGAN3

安装驱动：

# 清理全部的其他版本的nvidia驱动
$ sudo apt-get purge nvidia-*

$ sudo reboot

# nvidia-smi
$ sudo apt install nvidia-utils-470

# 驱动
$ sudo apt install nvidia-driver-470

# cuda 11.3 
$ sudo apt install nvidia-cuda-toolkit

$ sudo apt-get update

# 部分驱动可能会更新，需要执行更新，否则可能依旧不正常
$ sudo apt-get dist-upgrade

$ sudo apt-get autoremove

# 重启，否则部分驱动可能工作不正常
$ sudo reboot

# 清理全部的其他版本的nvidia驱动

$ sudo apt-get purge nvidia-*

$ sudo reboot

# nvidia-smi

$ sudo apt install nvidia-utils-470

# 驱动

$ sudo apt install nvidia-driver-470

# cuda 11.3

$ sudo apt install nvidia-cuda-toolkit

$ sudo apt-get update

# 部分驱动可能会更新，需要执行更新，否则可能依旧不正常

$ sudo apt-get dist-upgrade

$ sudo apt-get autoremove

# 重启，否则部分驱动可能工作不正常

$ sudo reboot

在 Anaconda 上建立独立的编译环境，然后执行编译：

# wget https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh
# 国内镜像下载
$ wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2021.11-Linux-x86_64.sh

$ bash Anaconda3-*-Linux-x86_64.sh

# 更新到最新版本
$ conda update -n base -c defaults conda

# wget https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh

# 国内镜像下载

$ wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2021.11-Linux-x86_64.sh

$ bash Anaconda3-*-Linux-x86_64.sh

# 更新到最新版本

$ conda update -n base -c defaults conda

参考 Anaconda conda切换为国内源加速下载。

编译配置StyleGAN3

$ sudo apt-get install git

$ git clone git@github.com:NVlabs/stylegan3.git

$ cd stylegan3

$ conda env create -f environment.yml

$ conda activate stylegan3

$ pip install psutil

# cudnn加速
$ conda install cudnn

# 目前测试 RTX 3060 12GB的情况下，batch建议是2，更高会报告OOM
# 并且当batch低于4的时候，需要同时指定 --mbstd-group=2
$ python train.py --outdir=~/training-runs --cfg=stylegan3-t --data=~/datasets/metfaces-1024x1024.zip --gpus=1 --batch=2 --mbstd-group=2 --gamma=8.2 --mirror=1 --metrics=none

$ sudo apt-get install git

$ git clone git@github.com:NVlabs/stylegan3.git

$ cd stylegan3

$ conda env create -f environment.yml

$ conda activate stylegan3

$ pip install psutil

# cudnn加速

$ conda install cudnn

# 目前测试 RTX 3060 12GB的情况下，batch建议是2，更高会报告OOM

# 并且当batch低于4的时候，需要同时指定 --mbstd-group=2

$ python train.py --outdir=~/training-runs --cfg=stylegan3-t --data=~/datasets/metfaces-1024x1024.zip --gpus=1 --batch=2 --mbstd-group=2 --gamma=8.2 --mirror=1 --metrics=none

如果报错：

Constructing networks...
Setting up PyTorch plugin "bias_act_plugin"... Failed!
Traceback (most recent call last):
  File "~/source/stylegan3/train.py", line 286, in <module>
    main() # pylint: disable=no-value-for-parameter
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1128, in __call__
    return self.main(*args, **kwargs)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1053, in main
    rv = self.invoke(ctx)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1395, in invoke
    return ctx.invoke(self.callback, **ctx.params)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 754, in invoke
    return __callback(*args, **kwargs)
  File "~/source/stylegan3/train.py", line 281, in main
    launch_training(c=c, desc=desc, outdir=opts.outdir, dry_run=opts.dry_run)
  File "~/source/stylegan3/train.py", line 96, in launch_training
    subprocess_fn(rank=0, c=c, temp_dir=temp_dir)
  File "~/source/stylegan3/train.py", line 47, in subprocess_fn
    training_loop.training_loop(rank=rank, **c)
  File "~/source/stylegan3/training/training_loop.py", line 168, in training_loop
    img = misc.print_module_summary(G, [z, c])
  File "~/source/stylegan3/torch_utils/misc.py", line 216, in print_module_summary
    outputs = module(*inputs)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1071, in _call_impl
    result = forward_call(*input, **kwargs)
  File "~/source/stylegan3/training/networks_stylegan3.py", line 511, in forward
    ws = self.mapping(z, c, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff, update_emas=update_emas)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1071, in _call_impl
    result = forward_call(*input, **kwargs)
  File "~/source/stylegan3/training/networks_stylegan3.py", line 151, in forward
    x = getattr(self, f'fc{idx}')(x)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1071, in _call_impl
    result = forward_call(*input, **kwargs)
  File "~/source/stylegan3/training/networks_stylegan3.py", line 100, in forward
    x = bias_act.bias_act(x, b, act=self.activation)
  File "~/source/stylegan3/torch_utils/ops/bias_act.py", line 84, in bias_act
    if impl == 'cuda' and x.device.type == 'cuda' and _init():
  File "~/source/stylegan3/torch_utils/ops/bias_act.py", line 41, in _init
    _plugin = custom_ops.get_plugin(
  File "~/source/stylegan3/torch_utils/custom_ops.py", line 136, in get_plugin
    torch.utils.cpp_extension.load(name=module_name, build_directory=cached_build_dir,
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/utils/cpp_extension.py", line 1080, in load
    return _jit_compile(
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/utils/cpp_extension.py", line 1318, in _jit_compile
    return _import_module_from_library(name, build_directory, is_python_module)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/utils/cpp_extension.py", line 1701, in _import_module_from_library
    module = importlib.util.module_from_spec(spec)
  File "<frozen importlib._bootstrap>", line 565, in module_from_spec
  File "<frozen importlib._bootstrap_external>", line 1173, in create_module
  File "<frozen importlib._bootstrap>", line 228, in _call_with_frames_removed
ImportError: ~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/lib/../../../../libstdc++.so.6: version `GLIBCXX_3.4.29' not found (required by ~/.cache/torch_extensions/bias_act_plugin/3cb576a0039689487cfba59279dd6d46-nvidia-geforce-rtx-3060/bias_act_plugin.so)

Constructing networks...

Setting up PyTorch plugin "bias_act_plugin"... Failed!

Traceback (most recent call last):

File "~/source/stylegan3/train.py", line 286, in <module>

main() # pylint: disable=no-value-for-parameter

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1128, in __call__

return self.main(*args, **kwargs)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1053, in main

rv = self.invoke(ctx)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1395, in invoke

return ctx.invoke(self.callback, **ctx.params)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 754, in invoke

return __callback(*args, **kwargs)

File "~/source/stylegan3/train.py", line 281, in main

launch_training(c=c, desc=desc, outdir=opts.outdir, dry_run=opts.dry_run)

File "~/source/stylegan3/train.py", line 96, in launch_training

subprocess_fn(rank=0, c=c, temp_dir=temp_dir)

File "~/source/stylegan3/train.py", line 47, in subprocess_fn

training_loop.training_loop(rank=rank, **c)

File "~/source/stylegan3/training/training_loop.py", line 168, in training_loop

img = misc.print_module_summary(G, [z, c])

File "~/source/stylegan3/torch_utils/misc.py", line 216, in print_module_summary

outputs = module(*inputs)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1071, in _call_impl

result = forward_call(*input, **kwargs)

File "~/source/stylegan3/training/networks_stylegan3.py", line 511, in forward

ws = self.mapping(z, c, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff, update_emas=update_emas)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1071, in _call_impl

result = forward_call(*input, **kwargs)

File "~/source/stylegan3/training/networks_stylegan3.py", line 151, in forward

x = getattr(self, f'fc{idx}')(x)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1071, in _call_impl

result = forward_call(*input, **kwargs)

File "~/source/stylegan3/training/networks_stylegan3.py", line 100, in forward

x = bias_act.bias_act(x, b, act=self.activation)

File "~/source/stylegan3/torch_utils/ops/bias_act.py", line 84, in bias_act

if impl == 'cuda' and x.device.type == 'cuda' and _init():

File "~/source/stylegan3/torch_utils/ops/bias_act.py", line 41, in _init

_plugin = custom_ops.get_plugin(

File "~/source/stylegan3/torch_utils/custom_ops.py", line 136, in get_plugin

torch.utils.cpp_extension.load(name=module_name, build_directory=cached_build_dir,

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/utils/cpp_extension.py", line 1080, in load

return _jit_compile(

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/utils/cpp_extension.py", line 1318, in _jit_compile

return _import_module_from_library(name, build_directory, is_python_module)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/utils/cpp_extension.py", line 1701, in _import_module_from_library

module = importlib.util.module_from_spec(spec)

File "<frozen importlib._bootstrap>", line 565, in module_from_spec

File "<frozen importlib._bootstrap_external>", line 1173, in create_module

File "<frozen importlib._bootstrap>", line 228, in _call_with_frames_removed

ImportError: ~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/lib/../../../../libstdc++.so.6: version `GLIBCXX_3.4.29' not found (required by ~/.cache/torch_extensions/bias_act_plugin/3cb576a0039689487cfba59279dd6d46-nvidia-geforce-rtx-3060/bias_act_plugin.so)

上述报错产生的原因是在 Anaconda 下载的包，在进行编译的时候，使用了高版本的 libstdc++.so。而运行时却使用了Anaconda 环境里低版本的 libstdc++.so 导致报错。

了解了原因，解决方法就比较简单了，可以手工升级 Anaconda 环境下的 libstdc++.so 动态库。

如下：

$ conda activate stylegan3

$ conda install cmake

$ conda install make

# 关键升级命令,更新当前项目里面的 libstdc++.so
$ conda install -c conda-forge libstdcxx-ng

# 删除上次失败时候的编译缓存
$ rm -rf ~/.cache

# 目前测试 RTX 3060 12GB的情况下，batch建议是2，更高会报告OOM
# 当batch=4的时候会在第11天的时候报告OOM
# 并且当batch低于4的时候，需要同时指定 --mbstd-group=2
$ python train.py --outdir=~/training-runs --cfg=stylegan3-t --data=~/datasets/metfaces-1024x1024.zip --gpus=1 --batch=2 --mbstd-group=2 --gamma=8.2 --mirror=1 --metrics=none

$ conda activate stylegan3

$ conda install cmake

$ conda install make

# 关键升级命令,更新当前项目里面的 libstdc++.so

$ conda install -c conda-forge libstdcxx-ng

# 删除上次失败时候的编译缓存

$ rm -rf ~/.cache

# 目前测试 RTX 3060 12GB的情况下，batch建议是2，更高会报告OOM

# 当batch=4的时候会在第11天的时候报告OOM

# 并且当batch低于4的时候，需要同时指定 --mbstd-group=2

$ python train.py --outdir=~/training-runs --cfg=stylegan3-t --data=~/datasets/metfaces-1024x1024.zip --gpus=1 --batch=2 --mbstd-group=2 --gamma=8.2 --mirror=1 --metrics=none

目前测试发现，当batch=4的时候会在第11天的时候报告OOM，如下：

tick 444   kimg 1776.0   time 11d 17h 14m  sec/tick 2292.6  sec/kimg 573.16  maintenance 0.2    cpumem 5.40   gpumem 7.69   reserved 10.03  augment 0.344
Traceback (most recent call last):
  File "~/source/stylegan3/train.py", line 286, in <module>
    main() # pylint: disable=no-value-for-parameter
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1128, in __call__
    return self.main(*args, **kwargs)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1053, in main
    rv = self.invoke(ctx)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1395, in invoke
    return ctx.invoke(self.callback, **ctx.params)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 754, in invoke
    return __callback(*args, **kwargs)
  File "~/source/stylegan3/train.py", line 281, in main
    launch_training(c=c, desc=desc, outdir=opts.outdir, dry_run=opts.dry_run)
  File "~/source/stylegan3/train.py", line 96, in launch_training
    subprocess_fn(rank=0, c=c, temp_dir=temp_dir)
  File "~/source/stylegan3/train.py", line 47, in subprocess_fn
    training_loop.training_loop(rank=rank, **c)
  File "~/source/stylegan3/training/training_loop.py", line 278, in training_loop
    loss.accumulate_gradients(phase=phase.name, real_img=real_img, real_c=real_c, gen_z=gen_z, gen_c=gen_c, gain=phase.interval, cur_nimg=cur_nimg)
  File "~/source/stylegan3/training/loss.py", line 81, in accumulate_gradients
    loss_Gmain.mean().mul(gain).backward()
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/_tensor.py", line 255, in backward
    torch.autograd.backward(self, gradient, retain_graph, create_graph, inputs=inputs)
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/autograd/__init__.py", line 147, in backward
    Variable._execution_engine.run_backward(
  File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/autograd/function.py", line 87, in apply
    return self._forward_cls.backward(self, *args)  # type: ignore[attr-defined]
  File "~/source/stylegan3/torch_utils/ops/grid_sample_gradfix.py", line 50, in backward
    grad_input, grad_grid = _GridSample2dBackward.apply(grad_output, input, grid)
  File "~/source/stylegan3/torch_utils/ops/grid_sample_gradfix.py", line 59, in forward
    grad_input, grad_grid = op(grad_output, input, grid, 0, 0, False)
RuntimeError: CUDA out of memory. Tried to allocate 1.39 GiB (GPU 0; 11.76 GiB total capacity; 7.06 GiB already allocated; 443.88 MiB free; 10.02 GiB reserved in total by PyTorch)

tick 444 kimg 1776.0 time 11d 17h 14m sec/tick 2292.6 sec/kimg 573.16 maintenance 0.2 cpumem 5.40 gpumem 7.69 reserved 10.03 augment 0.344

Traceback (most recent call last):

File "~/source/stylegan3/train.py", line 286, in <module>

main() # pylint: disable=no-value-for-parameter

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1128, in __call__

return self.main(*args, **kwargs)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1053, in main

rv = self.invoke(ctx)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 1395, in invoke

return ctx.invoke(self.callback, **ctx.params)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/click/core.py", line 754, in invoke

return __callback(*args, **kwargs)

File "~/source/stylegan3/train.py", line 281, in main

launch_training(c=c, desc=desc, outdir=opts.outdir, dry_run=opts.dry_run)

File "~/source/stylegan3/train.py", line 96, in launch_training

subprocess_fn(rank=0, c=c, temp_dir=temp_dir)

File "~/source/stylegan3/train.py", line 47, in subprocess_fn

training_loop.training_loop(rank=rank, **c)

File "~/source/stylegan3/training/training_loop.py", line 278, in training_loop

loss.accumulate_gradients(phase=phase.name, real_img=real_img, real_c=real_c, gen_z=gen_z, gen_c=gen_c, gain=phase.interval, cur_nimg=cur_nimg)

File "~/source/stylegan3/training/loss.py", line 81, in accumulate_gradients

loss_Gmain.mean().mul(gain).backward()

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/_tensor.py", line 255, in backward

torch.autograd.backward(self, gradient, retain_graph, create_graph, inputs=inputs)

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/autograd/__init__.py", line 147, in backward

Variable._execution_engine.run_backward(

File "~/anaconda3/envs/stylegan3/lib/python3.9/site-packages/torch/autograd/function.py", line 87, in apply

return self._forward_cls.backward(self, *args) # type: ignore[attr-defined]

File "~/source/stylegan3/torch_utils/ops/grid_sample_gradfix.py", line 50, in backward

grad_input, grad_grid = _GridSample2dBackward.apply(grad_output, input, grid)

File "~/source/stylegan3/torch_utils/ops/grid_sample_gradfix.py", line 59, in forward

grad_input, grad_grid = op(grad_output, input, grid, 0, 0, False)

RuntimeError: CUDA out of memory. Tried to allocate 1.39 GiB (GPU 0; 11.76 GiB total capacity; 7.06 GiB already allocated; 443.88 MiB free; 10.02 GiB reserved in total by PyTorch)

参考链接

VNC还是RDP? 云上的远程桌面究竟该如何选

这里说的VNC是什么？

简单来说，所谓的 VNC（Virtual Network Computing）是一种图形化的桌面共享系统，它使用远程帧缓冲协议 (RFB) 来远程控制另一台计算机。它将键盘和鼠标事件从一台计算机传输到另一台计算机，通过网络向另一个方向转发图形屏幕更新。

类似这样的技术VNC不是绝无仅有，但VNC 的流行和普及却因为其具有的过人之处 –

VNC是平台无关的—— 有多种客户端和服务器的实现，几乎涵盖了所有的主流平台。甚至一些VNC的实现被称“无客户端”，这是因为不需要安装插件或客户端软件而，而是依靠HTML5技术，只需要一个浏览器就可以访问远程桌面了。
VNC是开源的—— VNC最初是在英国剑桥的Olivetti & Oracle研究实验室开发的。原始的VNC源代码和许多现代的衍生品在GNU通用公共许可证下是开放源码的。
VNC的协议是简单、普适的—— VNC使用的是 RFB(Remote Framebuffer) 协议。这是一个开放且简单的协议。因为它在framebuffer级别工作，协议是基于像素的所以适用于所有窗口系统和应用程序，包括Microsoft Windows、macOS和X Window系统。这个协议的性能表现是很出色的。

说起来满满的都是优点，那么

访问云上的实例，为什么不选择VNC呢？

VNC 的优点很多，很多场景下都能看到VNC。例如，访问树莓派的桌面，对 headless 服务器的管理等等。但是，对于云上实例的远程图形化的访问VNC却不是好的选择。考虑到我们的使用场景是通过互联网来访问云上的主机，这就引出了否定 VNC 最主要的原因– 安全性。

默认情况下，RFB并不是一个安全的协议。虽然这个协议下密码不以明文方式发送，但如果能从网络中嗅出加密密钥和已编码的密码，还是有可能破解成功的。因此，建议密码至少有8个字符。另一方面，VNC的一些版本也有8个字符的限制；如果发送的密码超过8个字符，则删除多余的字符，并将截断的字符串与密码进行比较。

在VNC生态系统中，”Big Four” 指的是LibVNC、UltraVNC、Tight VNC和TurboVNC 这四家提供VNC 产品的厂商。2019年，Kaspersky Lab 的研究人员对这四家公司进行了审计，以了解它们的安全性。他们的发现是令人失望的。总的来说，研究人员发现这四个程序的客户端和服务器部分共有37个严重缺陷。其中22个在 UltraVNC，另外10个在 LibVNC, 4个在 TightVNC，还有一个在 TurboVNC，但这是一个严重的漏洞，它会让攻击者在服务器端远程执行代码。

有人会建议通过 SSH 或 VPN 连接进行 VNC 的隧道化，通过这种方法增加一个具有更强加密功能的额外安全层。但是这种方法并不完美，除了增加了复杂性也容易引起其它的一些安全问题，例如中间人攻击等。

否定一个技术是简单的，但我们是否有替代技术呢？答案就是 Remote Desktop Protocol （RDP）。

那么，RDP又是什么？

有过 Windows 使用经验的人对于远程桌面（Remote Desktop Protocol ，RDP）一定不会陌生。RDP 是由微软公司开发的一种专有协议，它为用户提供了通过网络连接到另一台计算机的图形界面。在使用上，用户需要使用 RDP 客户端软件，而在远程另一台计算机则需要运行 RDP 服务器软件。

微软的Windows、Linux、macOS、iOS、Android等操作系统都有客户端。Windows操作系统内置RDP服务器；Linux与 macOS 可以安装一个 RDP 服务器。缺省配置下，服务器监听 TCP 端口 3389 和 UDP 端口 3389。

微软目前把他们的官方RDP客户端软件称为Remote Desktop Connection，以前叫做 “Terminal Services client”

与VNC 相比，RDP的安全性有很大的提升。主要的安全特性包括了：

128位加密，使用RC4加密算法（版本6加入）
提供了对TLS的支持（版本2加入）

此外，正如前面提到的VNC协议是基于像素的。尽管这带来了极大的灵活性，可以显示任何类型的桌面，但它的效率往往不如那些更好地理解底层图形布局(例如： X11)或桌面(例如：RDP )的解决方案。这些协议以更简单的形式(例如：打开窗口)发送图形原语或高级命令，而 VNC 的 RFB 协议尽管支持压缩但只能是发送原始像素数据。

如何使用RDP？

在 Windows 环境下使用RDP是再简单不过的事情。我想谈的是在 Linux 环境下RDP 的安装部署与使用。虽然微软公司没有为 Linux 提供 RDP 的软件，但是我们可以使用开源的xRDP，这是RDP协议在Linux平台的实现。

xRDP是一个开源的远程桌面协议服务器，它用来实现Linux接受来自 Windows、Mac 或者 Linux 远程桌面客户端或的连接。这意味着你不需要在我们所使用的 Windows 或 macOS 机器上安装额外的第三方应用程序。

Linux 安装 xRDP的方法如下。这里我以 Ubuntu 20.04 为例 –

安装Gnome

GNOME是一个Linux 操作系统下的桌面环境，完全由免费和开源软件组成。缺省情况下在EC2上安装的Linux 操作系统都不包含Gnome，需要额外安装。Ubuntu 缺省的桌面窗口管理器就是Gnome，用以下命令安装。

$ sudo apt update

$ sudo apt install ubuntu-desktop

$ sudo apt update

$ sudo apt install ubuntu-desktop

安装 xRDP除了Gnome 以外，我们还可以选择 LXDE、Xface 等等。相比之下，LXDE 是轻量级的窗口管理器，Xface 则具备类似 Windows 界面的风格。如果不在乎额外增加的大约 5GB 的磁盘存储的开销，我还是推荐使用Gnome。原因在于这与我们本地使用的 Ubuntu 具有一致性的体验。

$ sudo apt install -y xrdp

1	$ sudo apt install -y xrdp

$ sudo systemctl status xrdp

1	$ sudo systemctl status xrdp

输出结果如下：安装完成后，xRDP服务将自动启动。可以通过这个命令来检查其状态:

接下来，要为Linux的用户（ubuntu）设置登录密码

$ sudo passwd ubuntu 

$ sudo adduser ubuntu ssl-cert

$ sudo passwd ubuntu

$ sudo adduser ubuntu ssl-cert

此外，如果我们的 EC2 实例绑定了Elastics IP 并且拥有自己的域名，我推荐使用Let’s Encrypt 发出的免费SSL证书替换缺省的自签发的证书。需要注意的一点，Let’s Encrypt 证书的有效期是90天。可以考虑配置crontab 使用cerbot 自动更新证书。这里设置的密码将被用来登录到目标的 EC2 实例，出于安全的理由务必使其符合密码安全的策略。第二条命令是将用户ubuntu 加入到 ssl-cert 用户组中。这是因为默认情况下，xRDP 使用的是自签发的证书，这个证书保存在 /etc/ssl/private/ssl-cert-snakeoil目录下。证书的密钥文件只能由 “ssl-cert” 用户组的成员读取。

修改安全组 RDP 协议缺省使用3389端口。务必记得在EC2的安全组中打开TCP与UDP在这个端口上的访问许可。

在这里，username 输入ubuntu，password 输入刚刚修改过的用户密码。成功登录之后熟悉的Ubuntu 桌面就会立刻出现在眼前。

按照我的体验，网络延迟在35ms以内xRDP 的与本地Linux 桌面的操作体验几乎没有差别。实测之下，通过我所使用的100M联通宽带访问AWS 中国（北京）区域的EC2 实例，网络延迟大约在5ms左右。

单以鼠标、键盘的使用体验而论，本地桌面与远程桌面的差别已经微乎其微了，我终于可以放心的将许多工作移到云端。无论是通过我的笔记本电脑、iPad 甚至是一台树莓派都能够让我接入顺利的接入远程桌面。如此一来，开发在云端岂不是再简单不过的事情了。

参考链接

解决KiCAD(系统macOS Big Sur)关联封装(Footprint)报错“No PCB footprint libraries are listed in the current footprint library table.”

最近在把macOS Big Sur系统上的KiCAD从5.x升级到6.x之后，新建的项目在进行关联封装操作的时候，报错

No PCB footprint libraries are listed in the current footprint library table.

1	No PCB footprint libraries are listed in the current footprint library table.

具体如下图：

造成这个问题的原因是KiCAD 6.x版本的全局封装库默认存储位置发生了变动，从低版本升级上来，还是会从以前的配置文件中读取原来配置的路径信息，导致找不到新版本的全局封装库路径。

解决方法是删除低版本配置的封装库相关的配置信息即可（删除之前，先关闭KiCAD软件，否则删除无效）。

macOS系统：

$ rm -rf ~/Library/Preferences/kicad

1	$ rm -rf ~/Library/Preferences/kicad

Windows系统：

$ del C:\Users\ …\AppData\Roaming\kicad

1	$ del C:\Users\ …\AppData\Roaming\kicad

Linux系统：

$ rm -rf ~/.config/kicad

1	$ rm -rf ~/.config/kicad

完成后，重启KiCAD软件即可。

参考链接

[华硕主板] 支持ECC内存的AMD Ryzen™处理器列表

下表列出了支持带ECC功能内存模组的Ryzen™处理器的列表；它们的官方名称；以及是否支持B550和X570系列。

请注意，当涉及到APUs（Ryzen 3000/4000 G系列），只有PRO处理器（例如Ryzen 3 PRO 3200G）支持ECC内存。

官方名称	支持B550系列	支持X570系列	ECC功能	UDIMM ECC	REG ECC
AMD Ryzen™ 5000 Series Processors	V	V	支持	V
AMD Ryzen™ 4000 G-Series Processors	V	V	只有PRO支持	V
AMD Ryzen™ 3000 Series Processors	V	V	支持	V
AMD Ryzen™ 2000 Series Processors		V	支持	V
AMD Ryzen™ 3000 G-Series Processors		V	只有PRO支持	V

注意，Ryzen™处理器只支持二手UDIMM ECC，不支持更便宜的二手REG ECC。

这个问题简单解释一下，新的REG ECC从性能到价格都是远远高于UDIMM ECC的，但是REG ECC不能用在家用主板上，导致大量淘汰的二手内存需求量不高，因而价格偏便宜。

继续阅读[华硕主板] 支持ECC内存的AMD Ryzen™处理器列表

2025 年 6 月
一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30