mirror of
https://gitcode.com/JianFeeeee/HomeAgent.git
synced 2026-09-26 20:33:15 +00:00
7799ca4559
上一提交的基准结论是错的："C 比 Go 慢" 不成立 —— 那是我把自己的
malloc/拷贝开销误当成了 cgo 的固有成本。本提交先拆解成本、再逐项消灭。
## 成本拆解（同机、百万次 benchtime）
| 场景 | ns/op |
|---|---:|
| cgo 边界（零拷贝传指针 + 空函数体）| 31.9 ← cgo 真实固有成本 |
| + 一次 C.CString + C 侧 strlen | 105-111（多出 ~75ns）|
| 初版 ModelContextWindow（另加 lower_dup malloc + 16×strstr）| 175 |
即 82% 开销是自找的。而初版还违反了自己写在设计文档 §四 的原则第 1 条
「C 接口只吃 const char* + 长度」——它没传长度，让 C 侧 strlen 再扫一遍。
## 逐项修复
1. C.CString（malloc+整串拷贝）→ unsafe.StringData 传指针+长度，零拷贝
2. C 侧 strlen 再扫一遍 → 长度由调用方传入，不扫
3. truncate 的 malloc 输出缓冲 + GoStringN 拷回 → C 只返回**字节数**
（结果必然是输入前缀），Go 侧 s[:n] 完成切片，全程零分配
4. lower_dup 每次 malloc 模型名 → 栈缓冲折叠，超长走零分配回退
5. 逐字节 utf8_next 函数调用 → 字级（8 字节）ASCII 检测
6. truncate 扫完整串才判断 → 数满 keep 个 rune 立即返回（提前短路）
7. 纯 Go 侧 len([]rune(s))/[]rune(s)（1KB 分配 4KB）→
utf8.RuneCountInString / DecodeRuneInString 游走，零分配
## 结果
| 基准 | 初版 C | 优化后 C | 纯 Go | 提升 |
|---|---:|---:|---:|---:|
| ModelContextWindow | 175 | 76.5 | 46.8 | 2.3× |
| EstimateTokens / 1KB ASCII | 2318 | 80.8 | 326 | 28.7× |
| TruncateByTokens / 1KB ASCII | 2594 | 71.7 | 411 | 36× |
| TruncateByTokens / 1KB 中文 | 3923 | 70.1 | 3097 | 56× |
## 完全 C 化（jianf 裁定）
撤掉我一度加的「短串 <32B 走回 Go」按长度分派：那会同时存在两份语义
可能分叉的实现。C 是唯一实现。
代价如实记录：EstimateTokens("qq") 这类极短串上 C 约 47ns（几乎全是
31ns 边界成本）vs 纯 Go 约 3ns，慢约一个数量级；绝对值纳秒级
（0.000047ms），单次请求尺度可忽略。若某循环对极短串高频调用，
正确应对是**把该循环 C 化（批量传一次）**，而不是按长度分派回 Go。
## 顺带补的正确性缺口（初版是真错的）
初版 C 的 UTF-8 解码只按首字节推断长度、**不校验后续字节**，
因此对畸形序列会与 Go 分叉：例 "\xE4\x41\x41"，Go 判 3 rune，
初版判 1 rune ⇒ rune 计数偏差 ⇒ token 预算与截断点偏移。
这类偏差**只影响计数、不会崩**，不测发现不了。
现在 C 侧做与 utf8.DecodeRuneInString 等价的完整校验（含过长编码、
代理对、超 U+10FFFF、截断序列），语义边界逐条注释。
代价：中文密集输入比初版慢（1467 vs 840）—— 这是刻意的正确性代价，
且仍比纯 Go 快 2×。
新增测试：
- TestGolden_InvalidUTF8：3000 组**任意字节**（含畸形序列）对拍，
覆盖初版会分叉的输入类别
- TestGolden_TruncateAlwaysPrefix：截断结果必为原串前缀且不超长
- C 契约测试从 21 项扩到 40 项（含非 NUL 结尾、超长名、畸形 UTF-8）
## 包现在要求 cgo 才能编译
删除 codec_nocgo.go：CGO_ENABLED=0 下整包构建失败（错误直指缺失符号）。
不保留回退的理由：只验证过一条路，就不该存在第二条。
实测这不影响任何构建 —— go list -deps 证明只有 cmd/homed 依赖本包，
而 waiter/initconfig/memgc/mock-server 均不依赖（逐个验过），
且 homed 本就强制 cgo（sqlite3 + gojieba）。仓库无 CI。
Makefile 把「不许有第二条路」变成可执行断言：check-codec-cgo-only
（断言 cgo 下全绿 **且** CGO_ENABLED=0 下必须失败）。
## 验证
- C 契约测试 40/40（gcc -Wall -Wextra 零警告）
- 黄金对照 6 个测试全绿（含 2000 组随机 + 3000 组畸形字节对拍）
- 变异测试：改 C 侧返回值后 go test 立即 FAIL（确认真的走 C）
- make check-codec-cgo-only 两项断言通过
- go vet ./... 干净；全量 go test -count=1 ./... → 38 ok / 0 FAIL
## 已知既有 flaky（与本改动无关，单独记录）
internal/plugins 在全量并发下偶发一次 SIGSEGV，栈在
internal/plugin/proc/{unified.go:234,arena.go:197}（arena 的 getU32）。
该两文件最后修改于 09-10，本提交 0 处触及；随后连跑 5 次单包 +
2 次全量均通过。初步判断是 arena/shared-region 的既有竞态，需单独排查。
49 lines
2.3 KiB
Go
49 lines
2.3 KiB
Go
package api
|
||
|
||
// codec.go —— 编解码层的**统一出口**（无论 CGO 开关如何，调用方只认这里）。
|
||
//
|
||
// 分层：
|
||
// codec_cgo.go —— C 实现绑定（要求 cgo；CGO_ENABLED=0 下整包构建失败）
|
||
// codec_pure.go —— 纯 Go **参考实现**：只作黄金对照的规格基准，
|
||
// 不是生产路径（不带 build tag，永远参与编译）
|
||
// codec.go —— 本文件：对外的稳定 API，含兜底与日志
|
||
//
|
||
// 这样调用方（provider.go / core）不需要写任何 build tag 分支。
|
||
//
|
||
// ★ 编解码层已「完全 C 化」：C 是唯一实现，不存在 CGO_ENABLED=0 回退。
|
||
// 理由（防两条语义分叉的实现同时跑）见 codec_cgo.go 顶部。
|
||
|
||
import (
|
||
"log"
|
||
"strings"
|
||
)
|
||
|
||
// ModelContextWindow 返回模型的最大上下文窗口（token 数）。
|
||
//
|
||
// 推断不出时（如 model="AUTO"）记一行日志并回退 defaultInferredContextWindow：
|
||
// 窗口被低估必须可见，部署方用 per-source
|
||
// core.llm.sources.<name>.context_window 显式声明真实值即可覆盖。
|
||
//
|
||
// 标称窗口 ≠ 有效窗口：接近满时注意力涣散，调用方应取 70-80% 为目标利用率。
|
||
func ModelContextWindow(model string) int {
|
||
if w := modelContextWindowC(model); w != contextWindowUnknown {
|
||
return w
|
||
}
|
||
log.Printf("[provider] 模型 %q 无法推断上下文窗口，回退 %d；"+
|
||
"若真实窗口更大，请设置 core.llm.sources.<name>.context_window",
|
||
strings.ToLower(model), defaultInferredContextWindow)
|
||
return defaultInferredContextWindow
|
||
}
|
||
|
||
// EstimateTokens 粗略估算 token 数。
|
||
//
|
||
// 注意：这是**高频热路径**（上下文裁剪对每个事件都调）。已完全 C 化，
|
||
// 但 cgo 边界固有成本约 30ns ⇒ 极短串上比直调纯 Go 慢（纳秒级，见
|
||
// codec_bench_test.go 的实测与 docs/zh/c-core/llm-orchestration-c.md §7.1）。
|
||
// 若某循环对极短串高频调用，正确应对是**把该循环 C 化（批量传一次）**，
|
||
// 而不是按长度分派回 Go —— 那会引入第二条可能分叉的实现。
|
||
func EstimateTokens(text string) int { return estimateTokensC(text) }
|
||
|
||
// TruncateByTokens 截断字符串至不超过 maxTokens 估计值。
|
||
func TruncateByTokens(s string, maxTokens int) string { return truncateByTokensC(s, maxTokens) }
|