for range map在CGO调用中崩溃？，C函数持有Go map迭代器引发的跨语言内存生命周期灾难（含pprof火焰图）

第一章：for range map在CGO调用中崩溃？——一场跨语言内存生命周期灾难的引子

当 Go 代码通过 CGO 调用 C 函数时，一个看似无害的 for range m（其中 m 是 map）可能在特定条件下触发 SIGSEGV —— 尤其当该 map 在 C 侧被并发修改、或其底层哈希表在 GC 周期中被回收，而 C 回调又试图访问 Go 传入的指针时。

根本原因在于：Go 的 map 是引用类型，但其底层 hmap 结构体不保证内存稳定。GC 可能移动、复用或释放 map 的桶数组（h.buckets），而 CGO 传递给 C 的指针若直接指向桶内元素（如通过 unsafe.Pointer(&m[key]) 或遍历时取地址），C 侧缓存该地址后，一旦 map 触发扩容或 GC 清理，该地址即成悬垂指针。

典型危险模式如下：

// ❌ 危险：将 map 元素地址传入 C，且 map 可能被修改
func crashProne() {
    data := map[string]int{"a": 1, "b": 2}
    for k, v := range data {
        // 若此处将 &v 或 &k 传给 C，并在 C 中长期持有，
        // 同时 Go 侧继续写入 data（触发扩容），则 C 访问将崩溃
        C.process_value((*C.int)(unsafe.Pointer(&v)))
    }
}

安全实践必须切断 C 对 Go 堆内存的直接依赖：

• ✅ 使用 C.CString/C.CBytes 显式复制数据到 C 堆，并由 C 侧负责释放
• ✅ 在 Go 侧将 map 序列化为 []byte 或 C.struct 后传入，避免裸指针
• ✅ 若需回调，通过 runtime.SetFinalizer 确保 C 资源释放早于 Go 对象回收

常见误判场景对比：

场景	是否安全	原因
C.foo(C.CString("hello"))	✅	字符串常量拷贝至 C 堆，生命周期独立
C.bar((*C.int)(unsafe.Pointer(&x)))，x 是局部变量	✅（短期）	x 栈上生命周期可控
C.bar((*C.int)(unsafe.Pointer(&data["key"])))，data 是全局 map	❌	map 元素地址不可靠，扩容即失效

真正的陷阱不在语法，而在隐式假设：C 与 Go 共享同一套内存稳定性契约 —— 而事实是，它们各自遵循完全不同的内存管理哲学。

第二章：Go map迭代器的底层机制与内存语义

2.1 map结构体与hmap的内存布局解析（理论）与gdb动态观测hmap字段实践

Go 运行时中 map 是语法糖，底层始终指向运行时结构体 hmap。其核心字段包括 count（元素总数）、B（bucket 数量的对数）、buckets（主桶数组指针）、oldbuckets（扩容中旧桶）等。

hmap 关键字段语义

• count: 原子可读的实时键值对数量
• B: len(buckets) == 1 << B，决定哈希位宽
• flags: 低比特位标记 iterator、oldIterator、growing 等状态

gdb 动态观测示例

(gdb) p *(runtime.hmap*)$map_ptr
# 输出含 buckets@0x..., B=4, count=12, flags=0x2 (hashWriting)

hmap 内存布局简表

字段	类型	说明
count	uint64	当前有效 key-value 对数
B	uint8	桶数组长度 = 2^B
buckets	*bmap	主哈希桶数组首地址

// runtime/map.go 中 hmap 定义节选（简化）
type hmap struct {
    count     int
    flags     uint8
    B         uint8          // log_2 of #buckets
    buckets   unsafe.Pointer // array of 2^B bmap structs
    oldbuckets unsafe.Pointer // during growth: old bucket array
}

该结构体无导出字段，禁止用户直接访问；buckets 指向连续内存块，每个 bmap 包含 8 个槽位（tophash + keys + values + overflow 链）。扩容时 oldbuckets 指向旧数组，实现渐进式迁移。

2.2 for range map生成的迭代器（hiter）生命周期模型（理论）与逃逸分析验证实践

Go 编译器为 for range map 自动生成一个隐藏的 hiter 结构体，其生命周期严格绑定于循环作用域——不逃逸。

hiter 的典型布局

// 模拟 runtime.mapiterinit 生成的 hiter（简化）
type hiter struct {
    key   unsafe.Pointer // 指向当前 key 的栈地址
    value unsafe.Pointer // 指向当前 value 的栈地址
    t     *maptype
    h     *hmap
    buckets unsafe.Pointer
    bptr    *bmap
    overflow **bmap
}

该结构体所有字段均为指针或标量，自身分配在栈上；key/value 指针指向 map 元素的原地地址（非拷贝），故无需堆分配。

逃逸分析实证

运行 go build -gcflags="-m -l" 可见：

• hiter 实例无 moved to heap 提示；
• 循环内对 k, v 的读取不触发分配。

场景	是否逃逸	原因
for k, v := range m	否	hiter 栈分配，指针不越界
return &k	是	局部变量地址被外部持有

graph TD
    A[for range m] --> B[调用 mapiterinit]
    B --> C[在栈上构造 hiter]
    C --> D[通过 bucket 链表遍历]
    D --> E[每次迭代更新 key/value 指针]
    E --> F[循环结束，hiter 自动销毁]

2.3 迭代器与map底层数组（buckets）的强引用关系（理论）与unsafe.Sizeof+reflect.Value对比实验

Go 语言中，map 迭代器（hiter）在遍历时持有对底层 buckets 数组的直接指针引用，而非拷贝。这导致即使 map 变量被回收，只要迭代器存活，buckets 就无法被 GC 回收——构成典型的强引用生命周期绑定。

内存布局关键字段

// 源码精简示意（src/runtime/map.go）
type hiter struct {
    buckets unsafe.Pointer // ← 强引用：指向 *bmap，阻止其释放
    bucket  uintptr        // 当前桶索引
    overflow *[]*bmap      // 溢出链表引用
}

buckets 字段为 unsafe.Pointer 类型，无 GC 扫描标记，但 runtime 在迭代器活跃期间将整个 buckets 视为根对象，强制保留。

unsafe.Sizeof vs reflect.Value.Size()

方法	返回值（map[int]int）	是否含 buckets 引用	说明
unsafe.Sizeof(m)	8 字节	❌	仅结构体头大小（指针+计数等）
reflect.ValueOf(m).Size()	8 字节	❌	同上，不反映运行时分配的桶内存

m := make(map[int]int, 1000)
fmt.Println(unsafe.Sizeof(m))           // 8
fmt.Println(reflect.ValueOf(m).Size())  // 8

二者均不体现 buckets 实际堆内存（如 1KB/桶 × 16 桶 = ~16KB），印证“引用关系不改变头部尺寸”。

引用强度验证逻辑

graph TD
    A[map m 创建] --> B[分配 buckets 数组]
    B --> C[迭代器 hiter 初始化]
    C --> D[buckets 字段赋值为指针]
    D --> E[GC 扫描：hiter.buckets 作为根]
    E --> F[buckets 不回收，直至 hiter 离开作用域]

2.4 GC触发时机对活跃迭代器的回收约束（理论）与GC trace日志+runtime.ReadMemStats交叉验证实践

活跃迭代器的GC屏障语义

Go 的 GC 在标记阶段会扫描栈和全局变量，但不会中断正在执行的 range 循环或 map 迭代器。只要迭代器变量仍位于栈帧中（即使已进入 for range 的后续轮次），其底层 hiter 结构体及其引用的 hmap 就被视作活跃对象，无法被回收。

GC trace 与内存统计交叉验证

启用 GODEBUG=gctrace=1 后，可观察到：

• 每次 GC 前若存在未完成的 mapiter，heap_alloc 下降缓慢，next_gc 推迟；
• 调用 runtime.ReadMemStats(&m) 可捕获 m.Mallocs 与 m.Frees 差值，该差值持续增长即暗示迭代器泄漏。

// 模拟长生命周期迭代器（避免逃逸至堆）
func leakyIterator(m map[int]string) {
    for k, v := range m { // 迭代器 hiter 在栈上，但持有 hmap 引用
        if k > 100 {
            break
        }
        _ = v
    }
    runtime.GC() // 此时 GC 无法回收 m，因栈帧中 hiter 仍活跃
}

逻辑分析：range 编译为 mapiterinit → mapiternext 循环，hiter 结构体含 hmap* 和 buckets 指针。只要函数未返回，栈帧存活，GC 标记器必将其视为根对象。参数 m 若为局部 map，其本身也因被 hiter 引用而延迟回收。

关键约束对比表

触发条件	是否阻塞 GC 回收 map	原因
迭代器在栈上运行	✅ 是	hiter 是 GC root
迭代器已 return	❌ 否	栈帧销毁，hiter 失效
迭代器逃逸到堆	✅ 是（更隐蔽）	*hiter 成为全局指针

graph TD
    A[GC Mark Phase Start] --> B{Scan Goroutine Stack}
    B --> C[发现 active hiter]
    C --> D[将 hiter.hmap 标记为 live]
    D --> E[跳过该 hmap 的回收]
    E --> F[下次 GC 再检查 hiter 状态]

2.5 迭代器失效的典型场景归纳（理论）与构造panic复现case并捕获runtime.errorString实践

常见失效场景

• 在遍历 map 时并发写入（非同步访问）
• 对切片执行 append 导致底层数组扩容，原迭代引用失效
• for range 中修改被遍历容器的长度或结构

构造 panic 复现场景

m := map[string]int{"a": 1}
for k := range m {
    delete(m, k) // 安全：仅删除当前键
    m["new"] = 2 // ⚠️ 触发迭代器失效 panic（运行时检测）
}

此代码在 Go 1.22+ 启用 -gcflags="-d=itercheck" 时静态报错；默认运行时在哈希表重哈希阶段触发 runtime.throw("concurrent map iteration and map write")，其底层为 *runtime.errorString 类型。

捕获 errorString 实践

func catchIterPanic() {
    defer func() {
        if r := recover(); r != nil {
            if err, ok := r.(error); ok && strings.Contains(err.Error(), "concurrent map"); true {
                fmt.Printf("caught: %T → %v\n", r, r)
            }
        }
    }()
    // ... 触发 panic 的代码
}

r 实际类型为 *runtime.errorString，其 Error() 方法返回只读字符串。该类型不可直接 import，但可通过接口断言安全识别。

第三章：CGO调用链中Go对象生命周期的断裂点

3.1 CGO调用栈中goroutine栈与C栈的隔离模型（理论）与cgo call trace符号化反向追踪实践

Go 运行时强制隔离 goroutine 栈（堆分配、可增长）与 C 栈（固定大小、不可迁移），避免栈指针混淆与 GC 干扰。

栈边界与切换机制

• runtime.cgocall 触发栈切换：保存 Go 栈寄存器，切换至系统线程的 C 栈；
• C 函数返回后，runtime.cgoreturn 恢复 Go 栈并重新调度。

符号化反向追踪关键步骤

# 从 runtime.Stack() 或 SIGPROF 采样获取原始 cgo trace
addr2line -e mybinary -f -C 0x000000000045a1b2 0x000000000045a2c8

addr2line 依赖 -gcflags="-l" 禁用内联 + -ldflags="-linkmode=external" 保留 DWARF；否则 C 帧无法映射到源码行。

组件	作用	是否参与符号化
libgcc	提供 _Unwind_Backtrace	是
libc	dladdr() 解析符号名	是
Go runtime	runtime.cgoCallers 提取帧地址	是

graph TD
    A[Go goroutine栈] -->|cgocall| B[线程TLS切换]
    B --> C[C栈执行]
    C -->|cgoreturn| D[恢复goroutine栈]
    D --> E[GC安全点检查]

3.2 Go map指针跨CGO边界传递的隐式语义陷阱（理论）与C函数中强制解引用panic复现实验

Go 的 map 类型本质是*头指针（`hmap）**，但其 Go 运行时禁止直接取地址或传递&m给 C —— 因为map变量本身已是间接类型，&m实际指向的是一个仅含*hmap字段的栈结构，而非hmap` 本体。

为何 &m 跨 CGO 后解引用必 panic？

// cgo_test.c
void crash_on_map_ptr(void* p) {
    // p 指向 Go 栈上的 map header（24B struct），非 hmap 地址
    struct hmap* h = (struct hmap*)p; // ❌ 未定义行为
    int n = h->count; // 触发非法内存访问 → SIGSEGV
}

逻辑分析：Go 编译器对 map 变量做“透明指针封装”，&m 得到的是 runtime._mapheader 的地址（栈帧内），而 C 侧误将其当 hmap* 解引用。h->count 访问偏移 8 字节处，实际读取栈垃圾数据，常导致段错误。

关键事实对比

项目	Go 中 m 变量	&m 的真实语义	C 中 (struct hmap*)p 行为
类型	map[K]V（头指针）	*struct { data *hmap }	强制 reinterpret_cast，越界访问

安全传递方案（仅理论可行）

• ✅ 使用 unsafe.Pointer(&m) + Go 层显式 (*hmap)(unsafe.Pointer(...)) 提取 hmap*
• ❌ 禁止将 &m 直接传入 C 函数并解引用

graph TD
    A[Go: map m] -->|m is *hmap| B[Go 栈：map header]
    B -->|&m yields addr of header| C[C receives void* p]
    C -->|cast to hmap*| D[Reads garbage at offset 8]
    D --> E[SIGSEGV panic]

3.3 runtime·cgoCheckPointer机制的绕过路径与失效条件（理论）与禁用check后pprof定位非法访问实践

cgoCheckPointer 的典型绕过路径

以下代码可绕过 cgoCheckPointer 检查：

// #include <stdlib.h>
import "C"
import "unsafe"

func unsafePtrLeak() {
    p := C.CString("hello")
    // 直接转为 uintptr，逃逸检查器无法追踪
    uptr := uintptr(unsafe.Pointer(p))
    // 后续通过 uptr + offset 间接访问 —— cgoCheckPointer 不校验 uintptr 算术
    _ = *(*byte)(unsafe.Pointer(uintptr(uptr) + 1))
}

逻辑分析：cgoCheckPointer 仅在 unsafe.Pointer 被显式传递给 Go 函数或存储于 Go 变量时触发；uintptr 是纯整数类型，不携带指针语义，故所有基于 uintptr 的算术、存储、跨 goroutine 传递均被跳过检查。参数 uptr 是 uintptr 类型，非 unsafe.Pointer，因此不进入 runtime/cgocall.go 中的 cgoCheckPointer 校验链。

失效条件归纳

• CGO_ENABLED=0 时整个 cgo 机制被禁用（自然无检查）
• //go:cgo_unsafe_import 注释标记的包（如 unsafe 本身）
• 指针未“逃逸”至 Go 堆（如纯栈分配且未被闭包捕获）

禁用 check 后的 pprof 实践

启用 GODEBUG=cgocheck=0 后，非法内存访问不再 panic，但可通过 pprof 定位：

工具	作用
go tool pprof -http=:8080 mem.pprof	可视化堆分配热点（含 C.CString 泄漏）
go tool pprof -alloc_space cpu.pprof	追踪 C.malloc 分配上下文

graph TD
    A[非法 C 内存访问] --> B{GODEBUG=cgocheck=0}
    B -->|静默执行| C[触发 SIGSEGV 或脏数据]
    C --> D[go tool pprof -trace=trace.out]
    D --> E[定位 last Go frame → C call site]

第四章：pprof火焰图驱动的崩溃根因定位与修复范式

4.1 生成含symbol信息的cgo二进制与pprof profile采集全流程（理论）与go tool pprof -http=:8080实操

关键编译标志：保留符号与调试信息

启用 cgo 时需显式传递 -gcflags="-l"（禁用内联以保函数边界）和 -ldflags="-s -w" 必须省略——否则剥离符号表。正确做法：

CGO_ENABLED=1 go build -gcflags="all=-N -l" -ldflags="-extldflags '-Wl,--no-as-needed'" -o app_with_symbols main.go

all=-N -l 强制关闭优化与内联，确保函数名、行号完整嵌入；-extldflags 防止链接器丢弃 cgo 动态符号依赖。

pprof 采集三要素

• 启动时注册 net/http/pprof
• 通过 /debug/pprof/profile?seconds=30 触发 CPU profile
• 使用 go tool pprof -http=:8080 启动交互式可视化服务

典型工作流（mermaid）

graph TD
    A[编译含symbol二进制] --> B[运行并暴露/pprof端点]
    B --> C[curl CPU profile]
    C --> D[pprof -http=:8080 profile.pb]
    D --> E[浏览器访问 http://localhost:8080]

环境变量	必需性	说明
CGO_ENABLED=1	强制	启用 cgo 支持
GODEBUG=cgocheck=0	可选	跳过 cgo 指针检查（调试用）

4.2 火焰图中识别mapiternext调用栈异常下沉（理论）与zoom-in定位C函数内循环调用迭代器实践

火焰图中的调用栈异常模式

当 mapiternext 在 CPython 解释器中频繁出现在火焰图底部宽幅区域，且上方无明显 Python 层调用上下文时，表明其被底层循环（如 dictiter_next）高频驱动，而非用户代码显式触发——这是迭代器内联优化失效或哈希表重散列引发的典型下沉现象。

zoom-in 定位 C 函数内循环

使用 perf script -F +pid,+comm 提取原始采样后，结合 flamegraph.pl --hash --color=java 生成可交互 SVG，点击 mapiternext 底部帧 → 右键 “Zoom in” → 观察其父帧 dict_iterate 中的 for (i = 0; i < mp->ma_used; i++) 循环热点。

// Objects/dictobject.c: dictiter_next()
static PyObject *
dictiter_next(dictiterobject *di) {
    Py_ssize_t i;
    PyObject *key, *value, *item;
    PyDictObject *mp = di->di_dict;
    // ↓ 关键：此处 i 未做 bounds check，若 ma_used 被并发修改，
    // 则导致 mapiternext 持续重试并压低调用栈深度
    for (i = di->di_used; i < mp->ma_used; i++) { 
        if (mp->ma_keys->dk_entries[i].me_key != NULL) {
            // ...
        }
    }
}

逻辑分析：di_used 是迭代器当前游标，mp->ma_used 是字典实际元素数。若在迭代过程中发生 PyDict_SetItem 并触发 resize，则 ma_used 可能突增，导致循环范围扩大、mapiternext 单次执行耗时陡增，在火焰图中表现为“下沉+展宽”。

常见诱因对比

诱因	火焰图特征	触发条件
字典并发写入	mapiternext 底部孤立宽峰	多线程/信号处理中修改同一 dict
迭代中 del d[k]	dict_dealloc 与 mapiternext 交替出现	Python 层显式删除
__hash__ 不稳定	PyObject_Hash 高频调用嵌套	自定义对象 hash 返回随机值

4.3 基于runtime.SetFinalizer的迭代器生命周期监护方案（理论）与finalizer触发日志+GC强制触发验证实践

finalizer 的核心契约

runtime.SetFinalizer(obj, f) 为 obj 关联一个终结函数 f，仅当 obj 成为垃圾且被 GC 回收时，f 才可能被调用——不保证立即性、不保证调用次数、不保证执行顺序。

验证用例：带日志的迭代器监护

type Iterator struct {
    data []int
    id   int
}

func NewIterator(data []int, id int) *Iterator {
    it := &Iterator{data: data, id: id}
    // 关联终结器：记录回收时机
    runtime.SetFinalizer(it, func(i *Iterator) {
        log.Printf("FINALIZER: Iterator #%d collected", i.id)
    })
    return it
}

逻辑分析：SetFinalizer 要求 obj 和 f 类型匹配（此处均为 *Iterator）；f 必须是无参函数，且不能引用外部变量（避免延长 obj 生命周期）。it 若逃逸到堆上，才可能被最终回收并触发 f。

强制触发验证流程

graph TD
    A[创建Iterator实例] --> B[显式置nil]
    B --> C[runtime.GC()]
    C --> D[观察log输出]

步骤	操作	目的
1	it = nil	解除强引用，使对象可达性归零
2	runtime.GC()	主动触发一轮完整GC，加速finalizer调度
3	time.Sleep(10ms)	留出finalizer执行窗口（异步协程执行）

• finalizer 在独立 goroutine 中运行，不阻塞主 GC 流程
• 多次调用 runtime.GC() 可提升触发概率，但非 100% 保证

4.4 安全跨语言数据传递的替代模式：C可序列化结构体封装（理论）与msgpack+unsafe.Slice零拷贝导出实践

核心矛盾：内存安全 vs 零拷贝效率

C ABI 兼容结构体需满足：#pragma pack(1)、无指针、固定大小字段；而 Go 的 unsafe.Slice 要求底层内存连续且生命周期可控。

msgpack + unsafe.Slice 实践要点

type Event struct {
    ID     uint64 `msgpack:"id"`
    TS     int64  `msgpack:"ts"`
    Status uint8  `msgpack:"status"`
}

func ExportEvent(e *Event) []byte {
    b := msgpack.MustEncode(e)
    return unsafe.Slice(&b[0], len(b)) // ⚠️ 调用方须保证 b 不被 GC 回收
}

unsafe.Slice 绕过复制但移交内存所有权；b 必须由调用方显式管理生命周期（如 C.malloc 分配 + C.free 释放），否则触发 use-after-free。

安全性权衡对比

方案	内存安全	跨语言兼容性	序列化开销
C struct + memcpy	✅（纯值类型）	✅（ABI 稳定）	❌（零拷贝）
msgpack + unsafe.Slice	⚠️（需手动内存管理）	✅（msgpack-C 解析器广泛）	✅（紧凑二进制）

graph TD
    A[Go Event struct] --> B[msgpack.Marshal]
    B --> C[unsafe.Slice over []byte]
    C --> D[C-callable byte*]
    D --> E{C端解析}
    E --> F[msgpack-c library]

第五章：从本次事故看Go与C互操作的长期治理原则

本次线上服务因 Cgo 调用 OpenSSL 的 SSL_read 导致 goroutine 永久阻塞，最终引发连接池耗尽与级联超时。根本原因并非 API 使用错误，而是缺乏对跨语言调用生命周期、资源归属与错误传播路径的系统性约束。以下为基于该事故提炼出的四项可落地的长期治理原则。

建立 C 函数调用白名单与封装层契约

所有 C 函数调用必须经由统一的 Go 封装层（如 crypto/cgo/openssl.go），禁止直接裸调 C.SSL_read。白名单通过 go:generate 自动生成校验代码：

//go:generate go run ./tools/cgo-whitelist -config whitelist.yaml

白名单 YAML 示例：

- name: SSL_read
  timeout_ms: 5000
  may_block: true
  requires_lock: ssl_mutex

强制执行 C 资源的 RAII 式生命周期管理

C 分配的内存、SSL_CTX、BIO 等资源必须绑定到 Go struct，并实现 Close() 方法。严禁在 finalizer 中释放 C 资源——本次事故中 SSL_free 被延迟触发，导致 SSL 对象被复用时状态错乱。正确模式如下：

type TLSConn struct {
    ssl *C.SSL
    bio *C.BIO
}

func (c *TLSConn) Close() error {
    if c.ssl != nil {
        C.SSL_shutdown(c.ssl)
        C.SSL_free(c.ssl) // 立即释放
        c.ssl = nil
    }
    if c.bio != nil {
        C.BIO_free_all(c.bio)
        c.bio = nil
    }
    return nil
}

实施跨语言错误语义对齐机制

Go 的 error 与 C 的 SSL_get_error() 返回值存在语义鸿沟。本次事故中 SSL_ERROR_WANT_READ 被误判为 fatal error，导致连接被丢弃而非重试。治理方案要求每个 C 封装函数必须返回标准化错误码映射表：

C 返回值	Go error 类型	处理策略
SSL_ERROR_WANT_READ	ErrCgoWantRead	进入 epoll wait 循环
SSL_ERROR_SYSCALL	&CgoSyscallError{errno}	记录 errno 并关闭连接
SSL_ERROR_SSL	&OpenSSLError{code}	触发 metrics 上报并告警

构建 Cgo 调用链路可观测性基线

在所有 C 函数入口插入轻量级 trace hook，采集调用耗时、线程 ID、GMP 状态及 errno。使用 eBPF 辅助验证 goroutine 是否在 runtime.entersyscall 后未及时返回：

flowchart LR
    A[Go 调用 C.SSL_read] --> B{进入 syscalld?}
    B -->|是| C[记录 enter timestamp]
    B -->|否| D[标记为非阻塞调用]
    C --> E[等待 C 返回]
    E --> F{是否超时？}
    F -->|是| G[强制 runtime.exitsyscall]
    F -->|否| H[记录 exit timestamp & errno]

所有 Cgo 封装函数需在 init() 中注册至全局监控器，自动上报 P99 耗时、阻塞率、errno 分布直方图。生产环境已部署该机制，过去 72 小时捕获 3 类异常模式：SSL_ERROR_WANT_READ 在高负载下平均等待时间上升 400%，SSL_ERROR_SYSCALL 中 EAGAIN 占比达 89%，SSL_free 调用延迟中位数为 12.7ms（远超预期的