1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 实测：同一个求和程序，四种等级的产物大小
swiftc -Onone      opt.swift -o sw_Onone      # 52584 字节（默认，便于调试）
swiftc -O          opt.swift -o sw_O          # 50760 字节
swiftc -Osize      opt.swift -o sw_Osize      # 50776 字节（体积优先）
swiftc -Ounchecked opt.swift -o sw_Ounchecked # 50720 字节（关掉溢出与前置条件检查）
./sw_Onone; ./sw_O; ./sw_Osize; ./sw_Ounchecked
# 四者都输出 333332833333500000

swiftc -O -whole-module-optimization opt.swift -o sw_wmo   # 50696 字节，整模块一起优化
swiftc -O -Xlinker -dead_strip opt.swift -o sw_ds          # 50776 字节，链接期删死代码
swiftc -O -static-stdlib opt.swift -o sw_static
# error: -static-stdlib is no longer supported for Apple platforms
# Apple 平台已移除该开关，静态链接标准库只在 Linux 等平台可用
swiftc -print-target-info | head -12
# "triple": "arm64-apple-macosx26.0"   ← 交叉编译时的 -target 就写这个形状

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

go build -o go_def opt.go && stat -f%z go_def       # 2413186 字节，默认即优化
go build -gcflags="all=-N -l" -o go_noopt opt.go    # 2309218 字节，关内联与优化
go build -trimpath -ldflags="-s -w" -o go_strip opt.go   # 1571186 字节，去符号与调试信息
./go_def   # 333332833333500000，三种构建输出一致

go build -gcflags="-m=1" opt.go
# ./opt.go:10:13: inlining call to fmt.Println
# ./opt.go:10:13: ... argument does not escape
# ./opt.go:10:14: s escapes to heap        ← 逃逸分析诊断，不是优化开关

go build -gcflags="-d=ssa/check_bce/debug=1" opt.go   # 打印边界检查消除的 SSA 结果
go build -gcflags="-S" opt.go 2>&1 | head -20          # 打印汇编
go test -gcflags="all=-N -l" ./...                     # 关闭优化跑测试（调试用）

 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

python3 -c "import sys; print(sys.flags.optimize)"       # 0   默认
python3 -O -c "import sys; print(sys.flags.optimize)"    # 1   去掉 assert 与 __debug__ 分支
python3 -OO -c "import sys; print(sys.flags.optimize)"   # 2   再去掉 docstring

python3    doc.py    # 'docstring'   函数仍能读到 __doc__
python3 -O doc.py    # 'docstring'   -O 不删 docstring
python3 -OO doc.py   # None          -OO 才删

python3 -c "assert False, 'boom'"; echo "exit=$?"
# AssertionError: boom   exit=1
python3 -O -c "assert False, 'boom'; print('asserts removed')"   # asserts removed

python3 -m py_compile doc.py && ls __pycache__/
# doc.cpython-314.pyc          ← 默认缓存
python3 -O -m py_compile doc.py && ls __pycache__/
# doc.cpython-314.opt-1.pyc    ← PEP 488：优化级别写进文件名后缀
python3 -OO -m py_compile doc.py && ls __pycache__/
# doc.cpython-314.opt-2.pyc
python3 -m compileall -q -o 2 .                 # 递归预编译，-o 指定级别
PYTHONDONTWRITEBYTECODE=1 python3 doc.py        # 完全不写缓存

# ---- JIT 与 free-threading ----
python3 -c "import sys; print(sys._jit.is_available(), sys._jit.is_enabled(), sys._jit.is_active())"
# False False False   ← 本机 3.14.7 官方二进制未编入 JIT
PYTHON_JIT=1 python3 -c "import sys; print(sys._jit.is_enabled())"
# False               ← 唯一官方启用方式是环境变量 PYTHON_JIT=1
python3 -c "import sysconfig; print(sysconfig.get_config_var('Py_GIL_DISABLED'))"   # 0
python3 -c "import sys; print(sys._is_gil_enabled())"       # True
python3 -VV
# Python 3.14.7 (main, Aug  5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]    ← free-threading 构建这里会多出 "free-threading build"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 编译到 JVM 字节码；没有 -O，只有目标与语义开关
kotlinc Main.kt -include-runtime -d app.jar
kotlinc Main.kt -jvm-target 21 -d app.jar          # 字节码版本，不是优化等级
kotlinc Main.kt -Xjvm-default=all -d app.jar       # 接口默认方法生成真实 default 方法
kotlinc Main.kt -progressive -d app.jar            # 渐进式语义（可能改变行为，慎用）
kotlinc -X | grep -i -E "jvm-default|inline|lambda" | head -10   # 高级 -X 选项清单

java -jar app.jar
# hello from kotlin

# Gradle 侧（build.gradle.kts）：优化与瘦身都写在这里
# kotlin { compilerOptions { jvmTarget = JvmTarget.JVM_21 } }
# android { buildTypes { release { isMinifyEnabled = true } } }   ← R8 做 shrink/obfuscate
./gradlew assembleRelease        # Android 发布构建，R8 介入
./gradlew build --configuration-cache   # 构建缓存，缩短编译时间
# Kotlin/Native：优化在 Gradle 的 binaries 配置里
# kotlin { linuxX64 { binaries { executable { entryPoint = "main"; optimize() } } } }

 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
31

# ---- javac：没有优化等级，只有调试信息与目标版本 ----
javac Main.java                    # 无 -O 之类的选项
javac -g Main.java                 # 生成全部调试信息（行号、源文件、局部变量）
javac -g:none Main.java            # 不带调试信息，class 文件最小
javac -g:lines,vars Main.java      # 只带行号与局部变量
javac --release 25 Main.java       # 指定 API 与 class 版本，不是优化
javac -Xlint:all Main.java         # 静态诊断，不改变产物
javap -c -p Main.class | head -20  # 反汇编字节码，看 javac 有多「老实」

# ---- 分层编译：真正的优化旋钮 ----
java -XX:+PrintCompilation Main    # 打印每个方法的编译层级（1/2/3 = C1，4 = C2）
java -XX:TieredStopAtLevel=1 Main  # 只用 C1：启动快、峰值低，适合 CLI 与短命进程
java -XX:TieredStopAtLevel=4 Main  # 允许 C2，默认就是分层到底
java -Xint Main                    # 纯解释执行，等价于关掉所有 JIT
java -Xmixed Main                  # 默认模式：解释 + 分层编译
java -XX:CompileThresholdScaling=0.5 Main  # 缩放热度阈值：小于 1.0 更早编译，大于 1.0 更晚
java -XX:+UnlockDiagnosticVMOptions -XX:+DebugNonSafepoints Main   # 诊断级开关，栈信息更准

# ---- AOT 与启动加速 ----
java -XX:ArchiveClassesAtExit=app.jsa -cp app.jar com.example.App   # AppCDS 生成归档
java -XX:SharedArchiveFile=app.jsa -cp app.jar com.example.App      # 复用归档启动
java -XX:AOTMode=record -XX:AOTConfiguration=app.aotconf -cp app.jar com.example.App
java -XX:AOTMode=create -XX:AOTConfiguration=app.aotconf -XX:AOTCache=app.aot
java -XX:AOTCacheOutput=app.aot -cp app.jar com.example.App   # JDK 25 一步完成（JEP 514）
java -XX:AOTCache=app.aot -cp app.jar com.example.App         # 生产运行只给缓存

# ---- 裁剪运行时 ----
jlink --add-modules java.base --strip-debug --no-header-files --no-man-pages \
      --compress=zip-6 --output myjre
jpackage --type app-image --input target --main-class com.example.App --name myapp
native-image -O2 -cp app.jar com.example.App app-native   # GraalVM，默认 -O2，另有 -O0/-O1/-O3/-Ob/-Os

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 实测（clang 21 / Apple Silicon，fib(38)）
clang++ -std=c++23 -O0 bench.cpp -o cpp_0 && ./cpp_0        # 39088169，real 0.13s
clang++ -std=c++23 -O2 bench.cpp -o cpp_2 && ./cpp_2        # 39088169，real 0.07s
clang++ -std=c++23 -O3 bench.cpp -o cpp_3 && ./cpp_3        # 39088169，real 0.06s
clang++ -std=c++23 -Os bench.cpp -o cpp_s                   # 体积优先
clang++ -std=c++23 -Oz bench.cpp -o cpp_z                   # 体积优先（clang 更激进）
clang++ -std=c++23 -Og bench.cpp -o cpp_g                   # 面向调试的轻度优化
clang++ -std=c++23 -Ofast bench.cpp -o cpp_fast
# clang++: warning: argument '-Ofast' is deprecated; use '-O3 -ffast-math'
#   for the same behavior, or '-O3' to enable only conforming optimizations
#   [-Wdeprecated-ofast]        ← clang 21 起 -Ofast 已弃用

clang++ -std=c++23 -O2 -march=native -mtune=native bench.cpp -o cpp_native && ./cpp_native
clang++ -std=c++23 -O2 -march=armv8.4-a bench.cpp -o cpp_mar  # 显式指定微架构
clang++ -std=c++23 -O2 -flto bench.cpp -o cpp_lto            # 链接时优化
clang++ -std=c++23 -O2 -flto -fuse-ld=lld bench.cpp -o cpp_lld
# clang++: error: invalid linker name in argument '-fuse-ld=lld'   ← 未安装 lld 时如此
clang++ -std=c++23 -O2 -fvisibility=hidden -c bench.cpp -o b.o    # 隐藏符号，利于 DCE
g++ -std=c++23 -O3 -march=native -flto -fuse-linker-plugin bench.cpp -o cpp_gcc

 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

# 实测（clang 21，fib(38)）
clang -O0 fib.c -o f0 && ./f0        # 39088169，real 0.13s
clang -O2 fib.c -o f2 && ./f2        # 39088169，real 0.06s
clang -O3 fib.c -o f3                # 更激进的向量化与内联
clang -Os fib.c -o fs                # 体积优先
clang -Oz fib.c -o fz && ./fz        # 39088169
clang -Og fib.c -o fg                # 调试友好的轻度优化，仍可用 gdb
clang -O2 -march=native -mtune=native fib.c -o fn
clang -O2 -flto -ffunction-sections -fdata-sections fib.c -Wl,-dead_strip -o flto_s
clang -O1 -fsanitize=undefined -fno-sanitize-recover=all fib.c -o fub   # 见「调试与分析开关」

# 优化等级导致的 UB 差异（经典例子）
clang -O0 -xc - <<'EOF' -o ub0 && ./ub0; echo "O0 exit=$?"
#include <stdio.h>
int main(void){ int x = 2147483647; x += 1; printf("%d\n", x); return 0; }
EOF
clang -O2 -xc - <<'EOF' -o ub2 && ./ub2; echo "O2 exit=$?"
#include <stdio.h>
int main(void){ int x = 2147483647; x += 1; printf("%d\n", x); return 0; }
EOF
# clang -fsanitize=undefined 下会明确报：
# runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'

gcc -O2 -march=x86-64-v3 -mtune=generic fib.c -o fx    # 交叉分发的做法：写死基线
gcc -O2 -flto=auto -fuse-linker-plugin fib.c -o fglto
size ./f0 ./f2 2>/dev/null || stat -f%z f0 f2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# ---- 命令行（julia 1.13）----
julia -O0 script.jl      # 关掉大部分 LLVM 优化，最快出结果，最慢运行
julia -O2 script.jl      # 默认
julia -O3 script.jl      # 更激进
julia -O script.jl       # 单独给 -O 等价于 -O3
julia --min-optlevel=2 script.jl     # 设定全局最低优化等级（影响依赖包）
julia --check-bounds=yes script.jl   # 强制保留边界检查
julia --check-bounds=no  script.jl   # 关掉边界检查，最快也最危险
julia --compile=min script.jl        # 最少编译：只解释，启动最快
julia --compile=all script.jl        # 预编译所有方法
julia --math-mode=ieee script.jl     # 严格 IEEE 浮点（@fastmath 也无效）
julia --math-mode=user script.jl     # 默认：@fastmath 区块放宽
julia --strip-metadata --strip-ir    # 打包时去掉文档与 IR

# ---- 代码内观察 ----
julia -e '@time sum(i*i for i in 1:10^7)'
#   0.012345 seconds (1 allocation: ...)   ← 编译时间会算进第一次调用
julia -e '@allocated sum(i*i for i in 1:10^7)'   # 看分配字节数，0 才是好代码
julia -e 'using InteractiveUtils; @code_warntype (x -> x + 1)(1)'
julia -e 'using Pkg; Pkg.precompile()'           # 预编译所有依赖，缩短首次加载
ls ~/.julia/compiled/v1.13/                      # 编译缓存落在 .ji 文件里

 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

# ---- 编译期：Debug/Release 只是属性组合 ----
dotnet build -c Debug          # <Optimize>false</Optimize>
dotnet build -c Release        # <Optimize>true</Optimize>
csc /optimize+ Program.cs      # 等价的 csc 命令行写法
csc /debug:portable Program.cs # DebugType 的 csc 写法，portable 是默认值

# .csproj 里显式控制
# <PropertyGroup Condition="'$(Configuration)' == 'Release'">
#   <Optimize>true</Optimize>
#   <DebugType>none</DebugType>   <!-- full, pdbonly, portable, embedded, none -->
# </PropertyGroup>
# <DebugType>portable</DebugType> 是 Debug 与 Release 的共同默认值，都会生成 PDB

# ---- 运行期：分层编译与动态 PGO ----
DOTNET_TieredCompilation=1 dotnet bin/Release/net10.0/app.dll   # 默认即开启
DOTNET_TieredCompilation=0 dotnet bin/Release/net10.0/app.dll   # 关掉分层，直接上优化 JIT
DOTNET_TieredPGO=1 dotnet bin/Release/net10.0/app.dll           # 动态 PGO（.NET 6+）
DOTNET_TC_QuickJit=0 dotnet bin/Release/net10.0/app.dll         # 跳过 quick JIT
dotnet bin/Release/net10.0/app.dll                              # 也可以在 runtimeconfig.json 里覆盖

# ---- 提前编译 ----
dotnet publish -c Release -r linux-x64 -p:PublishReadyToRun=true
dotnet publish -c Release -r linux-x64 -p:PublishReadyToRun=true -p:PublishReadyToRunComposite=true
dotnet publish -c Release -r linux-x64 -p:PublishAot=true
dotnet publish -c Release -r linux-x64 -p:PublishAot=true -p:OptimizationPreference=Size
# OptimizationPreference 取 Size 或 Speed；不写就由 Native AOT 自行权衡

 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

# ---- 开发期：JIT ----
dart run bin/myapp.dart
dart run --enable-asserts bin/myapp.dart      # 打开断言
dart run --observe bin/myapp.dart             # 启动 VM service，供 DevTools 连接

# ---- 发布期：AOT，没有 -O 等级 ----
dart compile exe bin/myapp.dart -o /tmp/myapp
# Generated: /tmp/myapp
dart compile exe bin/myapp.dart -o /tmp/myapp --target-os=linux --target-arch=arm64
dart compile aot-snapshot bin/myapp.dart      # 只出 .aot 模块，不打包运行时
dartaotruntime bin/myapp.aot                  # 用 dartaotruntime 运行
dart compile jit-snapshot bin/myapp.dart      # 带训练数据的 JIT 快照
dart compile kernel bin/myapp.dart            # 平台无关的 Kernel IR（.dill）

# ---- Web：-O0 到 -O4 只在这里 ----
dart compile js -O0 -o out/main.js web/main.dart   # 关掉大量优化，便于阅读产物
dart compile js -O1 -o out/main.js web/main.dart   # 默认优化
dart compile js -O2 -o out/main.js web/main.dart   # 增加压缩等对语义安全的优化
dart compile js -O3 -o out/main.js web/main.dart   # 再省掉隐式类型检查
dart compile js -O4 -o out/main.js web/main.dart   # 比 -O3 更激进，对输入分布敏感
dart compile js --no-source-maps -o out/main.js web/main.dart
dart compile wasm -O2 --minify --strip-wasm -o out/main.wasm web/main.dart

# 混淆与调试符号分离是 flutter build 的选项（dart compile exe 的文档里没有）
# flutter build apk --obfuscate --split-debug-info=build/app/outputs/symbols

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# ---- JIT 级别 ----
R --vanilla -q -e 'compiler::enableJIT(-1)'      # 3   负值表示查询当前级别
R --vanilla -q -e 'compiler::enableJIT(0)'       # 全部解释执行
R_ENABLE_JIT=0 Rscript opt.R                     # 用环境变量在同一进程启动前关掉
R_ENABLE_JIT=3 Rscript opt.R                     # 环境变量也能指定级别

# 级别含义：0 关闭；1 较大的闭包在首次使用前编译；
# 2 一些小的闭包也在第二次使用前编译；3 额外把所有顶层循环在执行前编译
# 级别 3 要求编译器选项 optimize 为 2 或 3

# ---- 手工编译与观察 ----
Rscript -e 'f <- function(n) sum((1:n)^2); g <- compiler::cmpfun(f); print(g(1000))'
# [1] 333833500
Rscript -e 'print(compiler::disassemble(compiler::cmpfun(function(x) x + 1)))'
# 打印字节码：list(...) 形式的指令序列
Rscript -e 'print(compiler::getCompilerOption("optimize"))'   # 2 或 3
Rscript -e 'print(compiler::enableJIT(-1))'                   # 3

# ---- 包安装时的编译 ----
# DESCRIPTION 里：ByteCompile: yes      ← 默认就是字节编译
R CMD INSTALL --no-byte-compile mypkg   # 显式关掉
R CMD INSTALL --preclean mypkg          # 先清理再编译
_R_CHECK_CONSTANTS_=1 R_JIT_STRATEGY=3 R CMD check mypkg   # 更严格的常量检查
Rscript -e 'print(.Platform$OS.type)'   # "unix"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 实测可用的四种模式（zig 0.15）
zig build-exe main.zig -O Debug          # 默认：优化关、安全检查开、编译最快
zig build-exe main.zig -O ReleaseSafe    # 安全检查开 + 完整优化
zig build-exe main.zig -O ReleaseFast    # 安全检查关 + 最快运行
zig build-exe main.zig -O ReleaseSmall   # 安全检查关 + 体积最小
zig build-exe main.zig -OReleaseFast     # 紧贴写法同样被接受
zig build -Doptimize=ReleaseFast         # zig build 用 -Doptimize
zig build --release=fast                 # zig build 专用简写：fast, safe, small

zig build-exe main.zig -O ReleaseFast -fstrip      # 去调试符号（没有 --strip）
zig build-exe main.zig -O ReleaseSmall -target x86_64-linux
zig build-exe main.zig -O ReleaseSafe -fsanitize-c # C 代码的 UBSan 检查
zig build-exe main.zig -O ReleaseSafe -fsanitize-c=trap   # 0.15 新增：越界即 trap
zig test main.zig -O Debug --verbose-air           # 打印 AIR，观察优化前后差异
zig cc -target aarch64-linux-gnu -O2 hello.c -o hello   # 拿 zig 当交叉编译器
zig targets | head -20                             # 列出支持的目标三元组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

lua main.lua                       # 解释执行，没有优化等级
luac -v                            # Lua 5.5.x
luac -p main.lua                   # 只做语法检查，不产出文件
luac -o main.luac main.lua         # 预编译成字节码
luac -l main.luac                  # 列出字节码
luac -l -l main.luac               # 完整列出（含常量表）
luac -s -o main.luac main.lua      # 剥离调试信息，这是 luac 唯一的体积开关
lua main.luac                      # 直接运行字节码
lua -e 'local x <const> = 2 ^ 10; print(x)'
# 1024          ← 常量折叠在编译期完成
lua -e 'local t <const> = {1,2,3}; print(#t)'
# 3             ← <const> 让编译期可以做更强的常量传播
lua -e 'local i = 0; for k = 1, 3 do i = i + k end; print(i)'
# 6
luac -l -l -e 2>/dev/null; echo "(luac 没有 -O 选项，见 Lua 5.5 手册与 luac 手册页)"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

npm install -D typescript
npx tsc --version                 # Version 7.x（Go 原生实现）
npx tsc                           # 按 tsconfig.json 编译整个项目
npx tsc --noEmit                  # 只做类型检查，不产出文件
npx tsc --target es2023 --module nodenext --moduleResolution nodenext
npx tsc --lib es2023,dom                        # 选定可用的标准库接口
npx tsc --incremental --tsBuildInfoFile .tsbuildinfo   # 增量编译
npx tsc --build                   # 项目引用模式的增量构建
npx tsc --checkers 4              # TS 7 新增：并行类型检查器数量
npx tsc --builders 4              # TS 7 新增：并行项目构建器数量
npx tsc --singleThreaded          # TS 7 新增：单线程，便于复现与排查
npx tsc --isolatedModules --verbatimModuleSyntax   # 保证逐文件转译语义一致
npx tsc --removeComments --declaration false
cat tsconfig.json
# { "compilerOptions": { "target": "es2023", "module": "nodenext",
#     "moduleResolution": "nodenext", "incremental": true, "strict": true } }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

node -v                                   # 本机 v24.20.0（文档按 Node 26 书写）
node main.js
node --max-old-space-size=512 main.js     # 限制老生代；实测默认上限约 4288 MB
node -e 'console.log((require("v8").getHeapStatistics().heap_size_limit/1048576).toFixed(1))'
# 4288.0
node --max-old-space-size=64 -e 'console.log(require("v8").getHeapStatistics().heap_size_limit/1048576)'
# 256                     ← 下限被钳到 256 MB
node --jitless main.js                    # 关掉 JIT，只解释执行
node --v8-options | grep -E "maglev|turbofan" | head -5
# --maglev (enable the maglev optimizing compiler)
# --maglev-inlining (enable inlining in the maglev optimizing compiler)
node --trace-deopt main.js                # 打印反优化事件，找出「优化又退回」的函数
node --allow-natives-syntax -e 'function f(x){return x+1}; %OptimizeFunctionOnNextCall(f); f(1)'
node --cpu-prof --cpu-prof-dir=./prof main.js && ls prof/
# CPU.20260919.181846.29993.0.001.cpuprofile
node --prof main.js && ls isolate-*.log
# isolate-0x8a540c000-30010-v8.log        ← 用 node --prof-process 解析
node --build-snapshot --snapshot-blob snapshot.blob main.js   # 生成启动快照
node --snapshot-blob snapshot.blob main.js                    # 用快照启动
node --experimental-sea-config sea-config.json                # 单文件可执行（SEA）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

php -v
php -l main.php                          # 只做语法检查
php --ini                                # 显示实际加载的 ini 文件
php --ini=diff                           # 8.5 新增：只打印与内置默认值不同的项

php -d opcache.enable_cli=1 main.php     # 命令行下也要显式开启 OPcache
php -d zend_extension=opcache \
    -d opcache.enable_cli=1 \
    -d opcache.jit=tracing \
    -d opcache.jit_buffer_size=64M \
    main.php
php -i | grep -i -E "opcache.jit|opcache.enable" | head
# opcache.enable => On
# opcache.jit => disable          ← 默认值，必须手动改成 tracing 或 function
# opcache.jit_buffer_size => 64M

php -d opcache.preload=preload.php main.php     # 预加载，把框架代码提前编译进共享内存
php -r 'var_dump(opcache_compile_file("lib.php"));'   # 手工预热单个文件
php -d opcache.jit=1254 main.php                # 整数 CRTO 形式：tracing 等价于 1254
php -d opcache.jit=function main.php            # 函数级 JIT，等价于 1205
php -d opcache.jit=off main.php                 # 只缓存 opcode，不做 JIT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

ruby opt.rb                       # 默认：纯解释执行
ruby --yjit opt.rb                # 启用 YJIT
ruby --jit opt.rb                 # 等价于 --yjit
ruby --zjit opt.rb                # ZJIT（4.0 起，实验性）
ruby --yjit --yjit-stats opt.rb   # 打印 YJIT 统计
ruby --yjit --yjit-mem-size=256 --yjit-call-threshold=10 opt.rb
ruby --zjit --zjit-mem-size=128 --zjit-call-threshold=30 opt.rb
ruby --rjit opt.rb
# ruby: invalid option --rjit  (-h will show valid options) (RuntimeError)   ← 4.0 已移除
ruby -e 'puts RubyVM::YJIT.enabled?'            # false   未开 JIT
ruby --yjit -e 'puts RubyVM::YJIT.enabled?'     # true
ruby --zjit -e 'puts defined?(RubyVM::ZJIT) ? "ZJIT 常量存在" : "无"'
# ZJIT 常量存在
ruby --yjit --yjit-stats -e 's=0; 1_000_000.times{|i| s+=i*i}; puts s' 2>&1 | tail -6
# yjit_insns_count:         11,999,652
# side_exit_count:                   0
# total_exit_count:            999,971
# code_region_size:             16,384
ruby --disable-gems -e 'puts "gems off"'        # 不加载 RubyGems，启动更快
ruby -e 'puts RUBY_DESCRIPTION'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 实测（Swift 6.4 / Apple Silicon）
swiftc -O opt.swift -o sw_O                        # 50760 字节
swiftc -Osize opt.swift -o sw_Osize                # 50776 字节
swiftc -O -Xlinker -dead_strip opt.swift -o sw_ds  # 50776 字节（链接期删死代码）
swiftc -O -whole-module-optimization opt.swift -o sw_wmo        # 50696 字节
cp sw_O sw_strip && strip sw_strip                 # 事后剥离符号
swiftc -O -static-stdlib opt.swift -o sw_static
# error: -static-stdlib is no longer supported for Apple platforms
# Linux 上等价写法：swift build -c release --static-swift-stdlib

swift build -c release -Xswiftc -cross-module-optimization      # SwiftPM 跨模块优化
swift build -c release -Xswiftc -Osize -Xlinker -dead_strip
swiftc -O -emit-library -o libx.dylib lib.swift    # 动态库
install_name_tool -id @rpath/libx.dylib libx.dylib # macOS 上设置安装名
otool -L sw_O                                      # 查看动态依赖
nm -u sw_O | head                                  # 查看未定义符号

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

go build -o app .
stat -f%z app                                  # 2413186 字节
go build -trimpath -ldflags="-s -w" -o app-strip .
stat -f%z app-strip                            # 1571186 字节
go build -ldflags="-s -w -X main.version=1.2.3" -o app-ver .
go tool nm app | wc -l                         # 符号条数
go version -m app                              # 查看嵌入的模块与构建信息

# 交叉编译纯静态二进制（不含 cgo）
CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -o app-linux-arm64 .
file app-linux-arm64
# ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked

# 其他产物形态
go build -buildmode=pie -o app-pie .
go build -buildmode=c-shared -o libapp.so .
go build -buildmode=c-archive -o libapp.a .
go build -buildmode=plugin -o plug.so .        # 平台支持有限
go build -gcflags="all=-l" -ldflags="-s -w" -o app-nol .
# -l 关闭内联往往能让体积再降一点，但会牺牲性能
go list -deps . | wc -l                        # 依赖包数量，体积的主要来源

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

python3 -m zipapp myapp -o myapp.pyz -p "/usr/bin/env python3"   # 标准库打包
python3 myapp.pyz                                                 # 直接运行
python3 -m zipapp myapp -o myapp.pyz -c                           # 顺带压缩
unzip -l myapp.pyz | head                                         # 就是个 zip

python3 -OO -m compileall -q myapp     # 去掉 docstring 的 .pyc
python3 -c "import sys; print(sys.flags.optimize)"      # 0
python3 -OO -c "import sys; print(sys.flags.optimize)"  # 2
du -sh myapp/__pycache__/

# 第三方：做成免安装可执行文件
pip install pyinstaller
pyinstaller --onefile --strip main.py       # 产物在 dist/main
pip install nuitka
python -m nuitka --standalone --onefile --follow-imports main.py
pip install mypyc
mypyc main.py                               # 编译成 C 扩展，需自己打包
pip install shiv && shiv -o myapp.pyz -e myapp:main .   # 带依赖的 zipapp
python3 -m venv --without-pip .venv         # 体积最小的隔离环境
python3 -c "import sys; print(sys.base_prefix)"   # 运行时本体所在，无法用 -OO 缩小

 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

kotlinc Main.kt -include-runtime -d app.jar    # 自带 kotlin-stdlib 的 fat jar
ls -lh app.jar
java -jar app.jar
# hello from kotlin

# Gradle 侧：R8 做裁剪与混淆（Android 官方，JVM 服务端用 ProGuard）
# android { buildTypes { release { isMinifyEnabled = true; isShrinkResources = true } } }
# R8 规则写进 proguard-rules.pro，反射用到的类要 -keep
./gradlew assembleRelease
./gradlew shadowJar                             # 第三方插件打 fat jar（等价 -include-runtime）

# 运行时裁剪：与 Java 共用 jlink / jpackage
jlink --add-modules java.base --strip-debug --no-header-files --no-man-pages \
      --compress=zip-6 --output myjre
jpackage --type app-image --input build/libs --main-jar app.jar --name myapp
du -sh myjre

# Kotlin/Native：真正的静态链接与体积选项
# kotlin { linuxX64 { binaries { executable {
#     entryPoint = "main"
#     optimize()                                  // 开启优化（release 模式）
#     binaryOption("bundle", "STATIC")            // 静态链接
#     freeCompilerArgs += "-Xbinary=stripDebugInfo=true"
# } } } }
./gradlew linkReleaseExecutableLinuxX64
file build/bin/linuxX64/releaseExecutable/app.kexe
# Kotlin/JS 的体积交给 webpack/terser，见 JavaScript 标签页

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

javac -d out src/Main.java
jar --create --file app.jar --main-class Main -C out .

# 1) 裁运行时：只保留 java.base
jlink --add-modules java.base --strip-debug --no-header-files --no-man-pages \
      --compress=zip-6 --output myjre
myjre/bin/java --list-modules          # 确认只剩需要的模块
du -sh myjre

# 2) 打平台安装包（默认已带 --strip-debug --no-header-files --no-man-pages）
jpackage --type app-image --input out --main-jar app.jar --main-class Main --name myapp
jpackage --type dmg --runtime-image myjre --input out --main-jar app.jar --main-class Main --name myapp

# 3) 裁应用：R8 或 ProGuard（都要写 keep 规则应对反射）
java -jar r8.jar --release --lib $JAVA_HOME/jars --output out-opt.jar app.jar
java -jar proguard.jar @proguard-rules.pro

# 4) 真提前编译：GraalVM Native Image
native-image -O2 -cp app.jar Main app-native
native-image -Os -cp app.jar Main app-native-small     # 体积优先
ldd myjre/lib/server/libjvm.so | head    # JVM 本身就是动态库，谈不上静态链接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 实测（clang 21 / Apple Silicon）
clang++ -std=c++23 -O2 -flto bench.cpp -o cpp_lto               # 33432 字节
clang++ -std=c++23 -O2 -flto -ffunction-sections -fdata-sections bench.cpp \
        -Wl,-dead_strip -o cpp_ds                               # 33432 字节（macOS 链接器）
clang++ -std=c++23 -O2 -flto -ffunction-sections -fdata-sections bench.cpp \
        -Wl,--gc-sections -o cpp_gc
# ld: unknown options: --gc-sections   ← macOS 的 ld64 不认 GNU 选项
cp cpp_ds cpp_strip && strip cpp_strip && stat -f%z cpp_strip   # 事后剥离

clang++ -std=c++23 -Oz -fvisibility=hidden -fvisibility-inlines-hidden -c bench.cpp -o b.o
clang++ -std=c++23 -O2 -flto -fuse-ld=lld bench.cpp -o cpp_lld
# clang++: error: invalid linker name in argument '-fuse-ld=lld'   ← 未安装 lld 时

# Linux 上的一条完整发布链
g++ -std=c++23 -O2 -flto -ffunction-sections -fdata-sections \
    -fvisibility=hidden -static-libgcc -static-libstdc++ \
    -Wl,--gc-sections -Wl,--as-needed app.cpp -o app
strip app
clang++ -static app.cpp -o app   # ld: library 'crt0.o' not found   ← macOS 不支持全静态
otool -L cpp_ds | head           # macOS：看动态依赖
nm -C --defined-only cpp_ds | head   # Linux：看导出符号
du -h cpp_ds

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 实测（clang 21 / Apple Silicon）
clang -O2 -flto -ffunction-sections -fdata-sections fib.c -Wl,-dead_strip -o f_ds
clang -O2 -fvisibility=hidden -fno-semantic-interposition -c fib.c -o fib.o
cp f_ds f_strip && strip f_strip && stat -f%z f_ds f_strip

clang -O2 -static fib.c -o f_static
# ld: library 'crt0.o' not found     ← macOS 不提供静态 libSystem
gcc -O2 -static -static-libgcc fib.c -o f_static_linux     # Linux 上可行
gcc -O2 -flto -ffunction-sections -fdata-sections -Wl,--gc-sections fib.c -o f_gc
musl-gcc -O2 -static fib.c -o f_musl       # 用 musl 做可移植的全静态二进制
file f_musl
# ELF 64-bit LSB executable, ... statically linked
du -h f_ds f_musl
ldd f_static_linux        # Linux 上应输出 "not a dynamic executable"
nm --defined-only f_ds | wc -l