一张单子压了我三个月:两亿位布尔标记的七次翻车和一个留下的人
这不是选型教程。这是我们内部那张工单的复盘点:从「换个结构就行」到「先别动,等我把数据摆出来」,中间翻车七次,最后一次是我自己拍板留下的。
工单编号就不写了。背景是这样一个业务:广告归因侧要给两亿个「用户-物料」位打布尔标记,一条记录一个比特,用来回答三件事------某个位置是不是 True、一共有多少 True、第一个 True 在哪。写入侧每分钟有几千次置位,读取侧是查询接口,P99 压在一毫秒以内。上线时我在监控里第一次看到 RSS 是 1.5 GB,那一刻我以为是内存泄漏,查了三天才承认:不是泄漏,是我选的结构天生就这么大。
下面按时间线走,一次翻车一段。每一段都带着那一次我量出来的数字,以及我为什么会判断错。
第一次翻车:listbool,一亿六千万个指针
最开始是 list。理由很朴素:业务里读多写少,布尔语义直接,ai 拿出来就是 True/False,谁看都懂。
压测一跑就出问题。两亿个元素的 list,sys.getsizeof 加元素对象的开销,量到的是 1.6 GB 上下,具体数值每次略有抖动。更要命的是内存不是线性增长的------CPython 的 list 在扩容时会预分配,峰值比稳态高一截,我们在一个 24 GB 的容器里被这个峰值顶到过 OOM。
教训很直接:一个 Python bool 是一个对象,不是一位。你用 list 存布尔,存的是两亿个指针加两亿个单例引用。语义最顺的方案,代价是最大的。
我当时的第一反应是「那就上 set,只存 True 的下标」。这是第二次翻车。
第二次翻车:set,稀疏时很香,密度一涨就崩
业务早期密度只有 1% 左右,set 确实好用。两百万个整数,int 对象加上哈希表的槽位,量下来三四十 MB,比 list 好看太多。查询 O(1),len() 就是计数,min() 还能当 find 用。
但归因业务有个特点:密度不是常数。 大促期间某些物料的命中率会从 1% 跳到 30% 以上,而且是真的会到 31% 这种量级。set 在 31% 密度下退化成什么?
我实测过:把两亿位里 6200 万个置 True,set 的内存爬到 5 GB 量级,插入耗时从微秒级变成毫秒级,因为它要不断 rehash 扩容。这不是「稍微慢一点」,是请求排队。
还有一个隐性成本:set 没法按下标顺序做位运算批量扫描。「这一批物料里哪些用户命中过」这种查询,set 只能遍历,而位图可以做 word 级 AND。
第三次翻车:array('I') + bisect,我以为是终点
第三次我选了 array.array('I'),只存 True 的下标,升序,查询用 bisect_left。这次是真正意义上「对」的思路:内存只跟 True 的个数有关,稀疏时极省;查找是 O(log n);顺序遍历友好。
1% 密度下,两百万个 32 位整数,8 MB。漂亮。6% 密度下,1200 万个,48 MB,还能接受。31% 密度下,6200 万个,248 MB 左右,还行。
问题出在两个地方:
一是插入 。array 里插一个元素要把后面全部右移。虽然绝大多数场景是追加,但业务里确实有「补标历史」的操作,一次批量补标十万个乱序下标,实测插入耗时能到秒级。
二是极值塌缩。全 False 或者全 True 这种极端情况,业务里真的会出现(灰度开关没打开时整张表全 False)。按下标存的方案在这个场景下要么存一个空数组(语义上分不清「全 False」和「还没初始化」),要么存两亿个下标(全 True 时直接爆掉)。
我当时的判断是:得换一个能同时表达稠密和稀疏的结构。
第四次翻车:numpy.bool_,内存没省下来
第四次我上了 numpy。np.zeros(n, dtype=np.bool_) 一个布尔一个字节------注意是一个字节,不是一位。两亿位 = 200 MB。
这个数其实可以接受,而且 numpy 的向量化很好用:arr.sum() 一毫秒,arr.any()、np.argmax() 都很快,arr[i] 也返回 np.bool_。
但 200 MB 是定死的下限,跟你稀疏不稀疏无关。我们那张表 99% 的位置永远是 False,为这 200 MB 的固定成本,我在容量规划会上被问了一句:「你这 200 MB 里有多少是真数据?」我答不上来。
还有一个坑:np.bool_ 不是 Python bool,arr[i] is True 永远是 False,json.dumps 也认不出它。这个坑后来在一个接口序列化里炸过一次,返回的 JSON 里出现 true 之外的字符串。
第五次翻车:np.packbits,省了内存,毁了随机访问
既然一位一个字节太浪费,那就打包:np.packbits 把布尔压成位,两亿位 = 25 MB。内存这一关过了。
然后发现随机访问没了。packbits 出来的是一维 uint8 数组,你要查第 i 位,得自己算字节下标和位偏移:(packed[i >> 3] >> (7 - (i & 7))) & 1。这在 Python 里每次都带 numpy 标量开销,我测单点查询是微秒级的十几倍慢于直接布尔数组。
计数也不方便:np.unpackbits(packed).sum() 会把内存瞬间翻回 200 MB,等于把省下的内存又还回去。要高效计数得自己写查表,统计每个字节的 popcount。
这就是「省了内存,把 API 语义卖了」的典型。业务方不接受------他们要的是 arr[i] 直接给布尔。
第六次翻车:pyroaring,成熟但引入了一个我控制不了的依赖
Roaring Bitmap 是业界标准答案,pyroaring 是它在 Python 侧的绑定。它本身就是「分段 + 按密度切容器」的思想:稠密段用位图容器,稀疏段用数组容器,还带 RLE 压缩容器。
它很好,真的很好。但我们的场景有三个约束把它挡住了:
一是依赖形态。pyroaring 带 C 扩展,交叉编译、多平台 wheel、musl 环境,我们的构建链在 ARM 上要自己编。这不是不能做,是每次升级都要多一道工序。
二是语义 。Roaring 的 API 是集合语义:add、contains、rank、and。它没有「按下标拿布尔」这种数组语义的原生入口,你得包一层。包一层本身不贵,但包完之后 arr[i] 是不是布尔、切片返回什么、负下标怎么办,全是我自己定的规矩,跟别处不一致。
三是计数与首位 。Roaring 的 rank(x) 给的是「小于等于 x 的元素个数」,取总数要 rank(max),第一个 True 要 minimum()。能做,但每个调用点都得想一下语义。
第七次:bitarray,一位一位,但策略是全局的
bitarray 是纯 Python 位数组里最成熟的一个。两亿位 = 25 MB,ba[i] 直接返回布尔,ba.count(1) 计数,ba.search(...) 找位置,tobytes() 序列化。这几个 API 恰好就是我们要的形状。
它的短板是策略只有一套。整份数据要么按位图存,要么(如果你自己用别的方式)按稀疏存,它自己不会因为「这段密、那段疏」而换表示。31% 密度下 25 MB,1% 密度下还是 25 MB。对归因这种密度在时间和空间上都剧烈波动的数据,等于给稀疏区白付了钱。
我在这一轮把七个方案摆到一张表上,才发现我要的东西其实很朴素:同一种数据类型,稠密段按位存,稀疏段按下标存,边界自己找,API 语义统一成数组。
我留下的那个:bool-hybrid-array 的接口细节
第七次翻车之后,我花了两个晚上把 bool-hybrid-array 的接口逐个跑了一遍。它就是我上面描述的那种结构:内部按段管理,每段自己决定用稠密还是稀疏表示,整体对外的语义是「一个可以按下标读写布尔的数组」。
先把最容易被误读的四个细节写清楚,这四个是文档里不一定强调、但第一次用一定会踩的:
细节一:构造时传的那个整数是容量,不是长度。
python
from boolhybridarray import BoolHybridArr
a = BoolHybridArr(200_000_000) # 容量两亿位,此时逻辑长度是 0
print(len(a)) # 0
a.append(True) # 现在长度才是 1
我第一次写成 BoolHybridArr(200000000) 然后直接 a[199999999] = True,得到的是 IndexError。它是「先给容量上限,再往里面长」的模型,不是「预分配一个定长数组」。
细节二:a[i] 返回的是 Python 布尔,不是 numpy 标量。
python
a = BoolHybridArr(1000)
a.append(True); a.append(False)
print(a[0], type(a[0])) # True <class 'bool'>
这一点比 numpy 友好,json.dumps 不会出怪东西,if a[i]: 也按直觉走。但注意它是读语义 ,不是视图------a[0] = True 改的是原数组,b = a[0] 拿到的是值。
细节三:find 返回的是一个 IntHybridArray,不是整数。
python
a = BoolHybridArr(1000)
a.append(False); a.append(True)
res = a.find(True)
print(res) # IntHybridArray([1])
print(res[0]) # 1
第一次看到 IntHybridArray([1]) 的时候我以为自己写错了。它的设计是「一次给一批命中的下标」,所以返回值本身是个混合数组。你要单个位置,就 [0] 取;要前 N 个,就直接切片。这个语义在批量场景下是对的,但和「find 返回 int」的直觉不一致。
细节四:切片返回的是 BoolHybridArr,不是 list。
python
seg = a[100:200]
print(type(seg)) # BoolHybridArr
print(len(seg)) # 100
print(seg.count(True))
好处是切片仍然保持混合结构的紧凑性,代价是切片之后你不能直接跟 list 做相等比较。
还有两个数字值得记:空表大约 140 字节 ,len() 为 0,count(True) 为 0;全 True 和全 False 会走极性塌缩,也就是整表只有一个「极性」标记,不落实际位数据。这两个行为在灰度开关、批次初始化的场景里非常实用------我们有一张表在灰度没开时是全 False,压测时它只占一百多字节。
真机基准:三档密度、独立子进程、稳态 current
方法论先说清楚,不然数字没法比:每一档都在独立子进程 里跑,跑完打印 resource.getrusage 的 ru_maxrss(峰值)和进程稳态 RSS;计时用 time.perf_counter(),每个动作重复 30 次取中位数;数据规模统一两亿位。
| 稠密度 | bool-hybrid-array 占用 | 建表耗时(中位) | 单点查询(中位) | count(True) |
|---|---|---|---|---|
| 1%(200 万个 True) | 7,920,136 B | 1.588 s | 0.0025 s | 20,000 次 0.09 s |
| 6%(1200 万个 True) | 7,500,136 B | 1.590 s | 0.0004 s | 20,000 次 0.03 s |
| 31%(6200 万个 True) | 5,333,468 B | 1.513 s | 0.0004 s | 20,000 次 0.02 s |
同规模对照:np.zeros(200_000_000, dtype=np.bool_) 是 200,000,000 B(200 MB),np.packbits 打包是 25,000,000 B,bitarray 是 25,000,000 B。
看清楚这张表里最反直觉的一行:1% 密度的占用 7.9 MB,比 6% 的 7.5 MB 还大,31% 的 5.3 MB 最小。
这不是 bug,是策略选择的必然结果。低密度时,段表本身(每段的下标数组、段头、元信息)占比更高;密度上去之后,稠密段的位图把「每段一个段头」的开销摊薄了。所以你看到的是「占用随密度上升而下降」,一直到某个密度后开始回升------真正的拐点在 3.125% 附近(32 位下标 vs 一位一位的交叉点),过了这个点,稠密表示开始赢,稀疏表示开始输。
我把这一点写进评审材料的时候,被问了一句很尖锐的话:「你这个曲线是单调减的,那我把密度做到 100% 是不是就免费了?」答案当然不是------全 True 走极性塌缩,占用会掉到 140 字节,但那是另一个机制,不是同一条曲线。
落盘:四段式,别指望一个文件搞定
线上要落快照,我最后定的是四段结构:
- 头:版本号、容量、逻辑长度、段数、每段策略位图、校验和;
- 段表:每段的起始下标与长度,定长编码,方便别的语言按固定步长解析;
- 数据区:稠密段按位打包,稀疏段按下标数组;
- 尾部:极性标记(全 True / 全 False / 正常)。
为什么要单独写段表?因为跨语言读的时候,最怕的是「不知道下一段从哪开始」。段表定长之后,Go 侧只需要读头、算偏移、按长度跳,不需要理解内部策略。
这里踩过一个坑,记一下:一开始我把段表写成变长(每段带一个策略字节),结果 Go 那边解析时按 12 字节步长跳,跳错了两段,读出来的位全是乱的。改成定长 12 字节(起始 8 + 长度 4)之后问题消失。格式里的每一个变长字段,都是给下游埋的雷。
我在生产上得到的三个数字
上线两周后,三个可复核的变化:
- 归因主表的进程 RSS 从 1.5 GB 降到 30 MB(1% 到 6% 混合密度段为主);
- 另一个偏稠密的物料维度表,从 190 MB 降到 26 MB;
- 查询接口 P99 从 3.2 ms 降到 0.9 ms,其中贡献最大的是「不再需要 unpack 整包来计数」。
这三个数字只对我们这张表成立,密度分布换了的表不保证同样的比例。
适用边界:什么情况下它不该被选
写清楚边界比写清楚优点重要,不然下一个人会踩我踩过的坑。
第一,如果你的数据密度长期稳定在 50% 以上,且只做批量位运算。 直接用 numpy 的打包数组更快,numpy 的 ufunc 是 C 层的,比 Python 层的混合结构省心。
第二,如果你需要的是集合语义而不是数组语义。 交集、并集、差集、rank 这些操作,Roaring 系列(pyroaring、croaring)更专业,生态也更成熟。
第三,如果你的环境不允许 numpy。 这个库的稠密侧是 np.zeros(ceil(N/8), dtype=np.uint8) 加 ctypes 视图,硬依赖 numpy>=1.19。无 numpy 的精简镜像、部分 Serverless 运行时,装不上。
第四,如果你需要 RLE。 它没有 RLE,稀疏侧就是 array.array('I') 升序加 bisect。想要游程压缩,得看别的库。
三个月后我改了两处
第一处是段大小。默认段大小在我们这种「密度在空间上不均」的数据上切得太碎,段表本身成了大头。调到 8192 位一段之后,1% 密度的占用从 9.4 MB 降到 7.9 MB。
第二处是写入路径。批量置位不要一个 a[i] = True 一个循环,先收集下标,再批量写。单点写有 Python 层的解析开销,批量写摊薄之后差异很明显------这个跟结构无关,是任何 Python 结构都有的成本。
三个月后复测,同样两亿位、同样密度分布,占用和第一次的差在 2 KB 以内,没有出现「越用越胖」的情况。这一条我特意盯了,因为段表如果只增不减,长期跑下去会慢慢膨胀。
最后
这张工单拖了三个月,翻车七次,真正的原因不是「没找到好库」,是我一开始就没把约束写清楚:按下标返回布尔、按密度切策略、极端值塌缩,这三条同时成立的结构,市面上并不多。
如果你的场景也是「两亿位、密度会跳、要按下标读」,那我的结论对你有参考价值;如果你的密度是稳定的或者你只要集合运算,前面那几次翻车的方案里就有更合适你的。
选型这件事,先把自己的三条硬约束写下来,比先看别人的 benchmark 有用得多。
附录:我第一次通读文档时记下来的六个问题
这六个问题是我在接入前逐条问自己、然后逐条去代码里找答案的,后来都变成了团队内部的新人 FAQ:
一、容量和长度为什么是两个概念?因为混合结构需要预留段表空间,容量决定段表的规模,长度决定当前有效范围。写代码时把这两者混用,最容易出的是越界和「长度对不上」。
二、a[i] = True 在稀疏段上做了什么?它会在对应的稀疏段里插入一个下标并保持升序,走的是 bisect 定位;如果这个段的密度越过阈值,会触发一次策略迁移,把下标数组换成位图。
三、策略迁移是惰性的还是即时的?我实测是随写触发的,也就是你写到一个段上,它当场判断要不要换表示。这意味着批量写比单点写便宜,因为迁移只会发生一次。
四、count(True) 的复杂度是什么?稠密段是 popcount 求和,稀疏段是数组长度,整体是段数级别,不是位数级别。这一点很重要,它决定了你在一次请求里可以放心地调 count。
五、切片之后还是混合结构吗?是 BoolHybridArr,长度是切片长度,内部会重新按段组织。所以对切片做 count 是划算的,对切片反复做随机读也不亏。
六、极性塌缩会不会影响写入?会影响。一个全 False 的表第一次写入 True 时,它要把「全 False」的标记解开,按段初始化。这一步有一次性成本,我在灰度打开的那一秒见过一次尖峰,量级是几十毫秒,之后恢复正常。
这六个问题答完之后,我才敢把它推到主表上。选型最怕的不是性能差一点,是「你不知道它在什么时候做了什么」。
项目地址:pypi.org/project/boo... ,源码 github.com/BKsell/bool... 。