最近在 WorkBuddy 里帮老板管一批"版本化二进制文件"——固件包、带占位符的模板资源包、历史积累的导出数据,每个文件都有一个旧版和一个改过几处的新版。同步到备份盘或内网另一台机器时,问题来了:每次改动其实只有几百 KB,但同步工具按"文件变了"处理,整个文件重传一遍。48 组文件合计 18.66 MB,实际变化量只有插入 209 KB + 删除 219 KB + 局部改写 58 KB,不到 3%。
直觉上有两种省流量的做法,都不靠谱:
做法一:按字节偏移对账。 记录旧版哪些字节段没变,只传变化段。可行——前提是变化全是"原地改写"。只要有一处插入或删除,后面所有字节整体位移,偏移全对不上。
做法二:定长分块 + 哈希对账。 这是很多同步工具的实现:把文件切成固定大小(比如 4KB)的块,新旧版本按哈希匹配,没匹配上的块才传。听起来很美,实测直接被打穿——下文有数据。
定长分块的块边界由偏移量决定:第 i 块是 [i*4096, (i+1)*4096)。在新版中间插入 2KB 后,插入点之后的所有内容都向后挪了 2KB,但块的切法还是老位置——于是每一块的起点都错开 2KB,块内容和旧版任何一块都对不上,哈希全部失配,整块重传。失配不是局部的,是级联到文件尾的。
内容定义分块(Content-Defined Chunking,CDC)换了一个思路:块的边界不看偏移,看内容。用一个滚动哈希(本文用 Gear 哈希)逐字节扫描,当哈希值满足某个特征(比如低 k 位全 0)就在这里切一刀。内容不变,刀口位置就不变——中间插入 2KB 只会让插入点附近的两块重新切割,后面的块边界自动"归位",哈希照样命中。这正是 rsync、restic 等工具增量同步的核心。
Gear 滚动哈希:预生成 256 项随机表 G,扫描时
h = ((h << 1) + G[byte]) & 0xFFFFFFFF,窗口滑过即可 O(1) 更新;当h & (2^k - 1) == 0时切刀,平均块长约 2^k 字节。再配合最小/最大块长夹逼,避免碎块和巨块。

用 Python 写了一版可复现实验(合成语料,48 组"固件式"二进制文件:头部结构 + 10% 重复纹理 + 尾部校验区;每文件做 1~3 处 0.5~8KB 的插入/删除 + 3~6 个 32~512 字节的局部改写区域)。语料与实验代码全部本地真实跑通,数字如下。
档位 | 策略 | 传输字节 | 占新版比例 | 对账耗时 |
|---|---|---|---|---|
A | 全量重传 | 18,657,757 | 100.00% | — |
B | 定长 4KB 分块哈希对账 | 12,587,485 | 67.47% | 0.09 s |
C | CDC 滚动哈希(均值块 1KB) | 1,015,853 | 5.44% | 6.18 s |
三个结论:
B 档只省了 32.54%。语料里每文件只有 1~3 处插入/删除,理论上受影响的字节不到 5%,但位移级联让大部分定长块失配——"理论上很小的改动"在定长分块眼里是"几乎整个文件都变了"。 C 档把传输量压到 5.44%,比全量省 94.56%,比定长分块再省 91.93%。变化量约 486 KB(插入+删除+改写),传输 1,015 KB,多出来的部分是插入点附近被重新切开的块和块边界碎屑,符合预期。 正确性不是看字节数,是逐字节对拍:按"命中块从旧版取、失配块从补丁取"真实重建,6 组抽样重建结果的 SHA-256 与新版文件完全一致(6/6)。

核心就三个函数:切块、建索引、对账。完整可跑,语料换成你自己的新旧文件对即可。
import hashlib, random
def make_gear(seed=7): # 固定 seed,保证可复现
rng = random.Random(seed)
return [rng.getrandbits(32) for _ in range(256)]
GEAR = make_gear()
def cdc_chunks(data, mask_bits=10, min_s=256, max_s=8192):
"""内容定义分块:返回 [(offset, length), ...],均值块长约 2^mask_bits 字节"""
chunks, n, i = [], len(data), 0
mask = (1 << mask_bits) - 1
while i < n:
j = min(i + min_s, n) # 最小块长:先滑过,不判刀
end = min(i + max_s, n) # 最大块长:兜底强制切
h = 0
while j < end:
h = ((h << 1) + GEAR[data[j]]) & 0xFFFFFFFF
if (h & mask) == 0: # 哈希低 k 位全 0 → 切一刀
j += 1
break
j += 1
chunks.append((i, j - i))
i = j
return chunks
def build_index(old_data, **kw):
"""旧版切块 → 哈希表,key=块哈希,value=(offset, length)"""
index = {}
for off, ln in cdc_chunks(old_data, **kw):
blk = old_data[off:off + ln]
index.setdefault(hashlib.blake2b(blk, digest_size=16).digest(),
(off, ln))
return index
def delta(old_data, new_data, **kw):
"""对账:命中块标记复用,失配块计入传输量,并真实重建对拍"""
index = build_index(old_data, **kw)
need, out = 0, bytearray()
for off, ln in cdc_chunks(new_data, **kw):
blk = new_data[off:off + ln]
h = hashlib.blake2b(blk, digest_size=16).digest()
if h in index:
o, l = index[h]
out += old_data[o:o + l] # 命中:从旧版取
else:
need += ln
out += blk # 失配:走补丁
assert hashlib.sha256(out).digest() == hashlib.sha256(new_data).digest()
return need块大小的选择不是拍脑袋,实测消融数据(同一份语料):
均值块长 | 传输比 | 新版块数 | 对账耗时 |
|---|---|---|---|
256 B | 2.69% | 35,424 | 5.76 s |
512 B | 3.53% | 22,931 | 7.87 s |
1 KB | 5.44% | 13,230 | 9.31 s |
2 KB | 8.73% | 7,527 | 10.08 s |
4 KB | 11.84% | 4,708 | 10.53 s |
块越小,刀口越密,插入点污染的块越少,传输量越低;代价是块清单(哈希索引)变大、扫描变慢。内网带宽紧张、索引放内存的选 256B;索引要落库、走查询的选 1~2KB 折中。

坑 1:语料不真实,结论全废。 第一版语料把"改写"做成全文 4% 均匀散点翻转,结果每个分块都含翻转字节,CDC 传输比 99.92%——实验完全失效。真实的文件修改是局部化的(改配置段、换资源段、更新版本号),语料必须贴合真实修改分布。同样的教训适用于任何"对比实验":先想清楚真实场景里变化长什么样,再造数据。
坑 2:min/max 块长不能省。 只按哈希切刀、不设最小块长,低熵区域(大片重复纹理、全零段)会切出海量碎块,索引爆炸;不设最大块长,遇到长段哈希永不命中特征的区域会切出巨块,一处小改就污染整块。256B~8KB 的夹逼区间在本实验里刚好。
坑 3:随机表必须固定 seed。 Gear 表如果用全局
random生成,每次运行刀口位置不同,实验不可复现;更隐蔽的是,若新旧两版用了不同的表,块边界直接错位,命中率归零。本文用random.Random(seed)独立实例,新旧版本共用同一张表。坑 4(顺带):正确性校验别只比长度。 重建函数最容易出"长度对但内容错"的 bug(比如命中块取错了偏移)。本文重建后直接
sha256与新版对拍,断言失败立刻暴露。字节级校验是这类"拼接重建"代码唯一可信的验收标准。
把这套思路沉淀成一句话指令,下次在 WorkBuddy 里直接用:
# 粘贴到 WorkBuddy 对话框即可复用(把路径换成你的目录)
prompt = """
我在 <目录> 下有一批成对的版本化二进制文件(*_v1.bin / *_v2.bin)。
请写一个 Python 增量同步方案:
1. 用 Gear 滚动哈希做内容定义分块(均值块 1KB,min 256B / max 8KB);
2. 旧版建哈希索引,新版对账,输出需传输字节与占比;
3. 按"命中块从旧版取、失配块从补丁取"真实重建,SHA-256 逐字节对拍;
4. 附消融:块长 256B/512B/1KB/2KB/4KB 的传输比与耗时对比表。
所有数字必须真实跑出来,禁止编造;跑完给一份可直接复制的报告。
"""18.66 MB 的"文件级变更",被定长分块压到 67.47% 就撞了墙,被 CDC 压到 5.44%。差距不在算法复杂度——核心代码 60 行——而在块边界由谁决定:偏移量决定,位移就是天敌;内容决定,位移就只是局部扰动。这个思想同样适用于日志轮转、数据库 binlog 同步、容器镜像分层这些"大文件 + 小改动"的场景。
下一篇文章见。所有实验脚本与语料生成器均在本文可复制代码中,欢迎实际跑一遍验证。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。