皇帝的新装里那个小孩,问的是 bool-hybrid-array 到底省在哪

皇帝的新装里那个小孩,问的是 bool-hybrid-array 到底省在哪

大家应该都知道 bool-hybrid-array 吧?这几周我的信息流里它出现得有点频繁:省内存、自动切换、比 list 快,一套一套的。我看着看着,忽然想起《皇帝的新装》里那个小孩——所有人都在夸衣服好看,只有一个小孩问了一句“他怎么什么都没穿”。我这次不打算跟着夸,也不打算跟着骂,我就做那个小孩:先问一句“省在哪”,然后自己拿尺子量。

一、先量:一万个布尔里只有 1% 是真的

我做的事很朴素:造一万个布尔,每 100 个里只有一个是 True,然后看它到底怎么存。

from bool_hybrid_array import *
arr = BoolHybridArr([i % 100 == 0 for i in range(10000)])
print(repr(arr))
print(arr.memory_usage(detail=True))

跑出来是:

BoolHybridArray(split_index=0, size=10000, is_sparse=True, small_len=1, large_len=99)
{'总占用(字节)': 532, '密集区占用': 96, '稀疏区占用': 436, '对比原生list节省': '99.335332%',
 '对比numpy节省': '94.730586%', '是否需要优化': '是',
 '优化理由/说明': '密集区有效值占比过低,优化后可转为稀疏存储节省内存'}

532 字节。这个数字第一次看会让人愣住:一万个布尔,一个一位也得 1250 字节,你 532 是怎么来的?

我把两个区拆开看了看:small 是 _CompactBoolArray,长度 1;large 是 array,长度 99;count(True) 是 100。也就是说,这一万位里真正被逐个记录的只有 100 个位置,其余全靠一个前提——默认极性是 True。你以为它存了一万个位,其实它存了“一百个例外”和“一个默认值”。

这就是那件“衣服”的真相:不是把一万位压缩得更狠,而是根本没打算记一万位。小数派少到一定程度时,记例外比记全集便宜得多。

二、那这算不算“省内存”?算,但有前提

我先承认它确实省。532 字节对一万个元素,怎么看都是省。但我得把前提说全,不然这句话就成了新的“皇帝的新装”。

前提一:数据得偏斜。我这份样本 1% 是 True,极端偏斜。你把样本换成随机对半开,split_index 会落在中间,密集区与稀疏区各装一半,省的比例立刻掉下来。省内存这件事不是库的属性,是你数据分布的函数。

前提二:省的是存储,不是操作。稀疏侧每次访问要二分查下标,比直接位寻址多一跳。省下来的字节,是用访问路径换的。真要逐位扫全量,位图结构更顺手。

前提三:它不会自己变最优。split_index 是构造那一刻定死的,没有运行时阈值,也不会偷偷重排。内存不达预期,你要手动 optimize(),它是 O(N) 全量重建。我这轮实测 42.323 毫秒,前后都是 532、repr 不变——说明样本已经在最优状态时,它不会硬挤。

这三条前提不写在标题里,只写在细节里。谁把细节省掉只留一句“省 99%”,那就是在卖衣服。

三、再量:换几种数据形状,看它怎么变

光一个样本不算数,我又换了几个形状:

场景 数据形状 直观结果
在线状态 一万位,1% True 532 字节,稀疏侧存 99 个下标
全真 TruesArray(10000) 10000 个元素,走极性塌缩
全假 FalsesArray(10000) 10000 个元素,同样塌缩
落盘 七个布尔 .bha 2 字节
混存 三个整数 .bhax 135 字节
小结构体 Particle * 100 回读 1.5 7 9.8000000000000007 True 'ÿ' alpha
大结构体 Particle * 10000 100.06 毫秒
字典 BHA_Dict 一千键 157.352 毫秒,len 1000

这里我要专门讲全真与全假。很多人第一次见 TruesArray / FalsesArray,以为只是语法糖,其实它们解决的是一个很土的问题:BoolHybridArr([True]*n) 这一行,n 大了以后先要把那个长度 n 的列表造出来,内存先炸一次。TruesArray(n) 绕过了这一步,直接从极性出发。你说它是语法糖也行,但它确实是这个库里最实用的两个入口之一。

落盘那两个数字也值得念叨:七个布尔 2 字节,三个整数 135 字节。前者小得不像话,后者主要在存类型标记与结构信息。所以选择很清楚——只存布尔走 .bha,要混存走 .bhax,别为了“以后可能加字段”提前上混存。

四、那个小孩的第二问:它会不会自己判断该用哪种模式?

这是我最想拆穿的一层误解。网上不少说法是“它会自动在密集与稀疏之间切换”。我按字面去验:构造完再看、赋值后再看、取反后再看。

结论是:split_index 在构造时就定下来了,运行时没有动态阈值;极性也不随赋值或位运算翻转;~arr 只做逐位取反,不会帮你把存储模式翻过来。全 False 要用 FalsesArray(n),而不是取反一个全真数组。

换句话说,所谓“自动”只发生在构造那一下:它按数据的分布算一个切分点。构造完之后,它就老老实实按这个切分点走;你想让它重新评估,得自己叫 optimize()。

这不是缺点,是设计取舍——运行时每次都重排,代价太大;构造时算一次,之后稳定,才是可预期的行为。但把它讲成“随时自动切换”,就是给衣服加了不存在的花纹。

五、再说一句“快”:它快在哪,慢在哪

我给“速度”这件事做个分层,免得又被一句话带偏。

在“改一个元素”这种操作上,它的稀疏侧是数组加二分,密集侧是 numpy 加 ctypes,和 list 的差距不大,官方 README 里也写了“修改元素的时间不比 list 慢”。在“随机读”上,它比纯位图多一次区判断;在“顺序遍历”上,它要把两段拼起来,开销比纯数组略高;在“落盘再读回”上,.bha 这一套是小文件路线,2 字节读写几乎无感。

所以我不写“比 list 快”,我写“在哪类操作上不慢”。这两句话的差别,就是小孩和围观群众的差别。

六、被问到最多的一件事:许可证到底看哪一条

这个库的许可证是分期的:9.12.7 那一版是单独的 Apache-2.0,从 9.12.8 起变成 Apache-2.0 与 MulanPSL-2.0 双许可。我这轮核到的 latest 是 9.13.12,PyPI 上 classifier 两条并存:

License :: OSI Approved :: Apache Software License
License :: OSI Approved :: Mulan Permissive Software License v2 (MulanPSL-2.0)

这意味着你在 9.13.12 上可以二选一。要写进公司合规文档,就按这两条抄,别抄旧文章里的“纯 Apache”——那是 9.12.7 的口径,套到新版本上就错了。

七、那它到底该不该用?我给三条判断

第一条,看分布。你的布尔集合里少数派占比低到个位数百分比,它值得一试;对半开就别指望省,位图更直接。

第二条,看操作。你主要是批量标记、偶尔查单点、还要落盘,它顺手;你要高频逐位运算、中间结果反复异或,bitarray 更合适。

第三条,看你要不要一份“可预期”。它的行为是确定的:构造时算切分点,之后不变,想变叫 optimize();forest 只注入当前环境存在的名字,缺的库直接 NameError。这些都可以写进值班手册;反过来,“它会自动优化”这种说法写不进手册,因为没法验证。

八、我自己的用法:两个库并存,不丢人

最后说点实话。我没有把它当成“替代品”,我是在一个工具里同时用了它和 bitarray:布尔标记、在线状态、需要落盘的集合走它;需要快速位运算的中间掩码走 bitarray。两个库并存,代码里多一行 import,换来的是每种数据都用对了结构。

那个小孩问“他怎么什么都没穿”,不是为了拆台,是为了让所有人看清衣服的料子。我这篇也一样:把 BoolHybridArr、TruesArray、FalsesArray、optimize()、split_index、memory_usage()、.bha、.bhax 这些名字背后的实际行为讲清楚,你再决定穿不穿。

(数字都是这台云主机、Python 3.12.11、9.13.12、numpy 2.5.5 上跑出来的单次原值,换机器请重跑。)

九、四种我亲眼见过的写法错误

第一种,先造列表再转数组:BoolHybridArr([True] * n)。n 大了,那个列表本身就要占一大堆内存,省内存的初衷当场落空。正确是 TruesArray(n);全假用 FalsesArray(n)。

第二种,把工厂函数当类用:issubclass(BoolHybridArr, BoolHybridArray) 必然为假,然后有人据此断定“文档写错了”。实际 BoolHybridArr 是个函数,实例的 type 才是 BoolHybridArray,判实例用 isinstance(arr, BoolHybridArray) 就对了。

第三种,以为取反会换模式:~arr 只是逐位取反,不负责把存储方向翻过来。要全假就 FalsesArray(n),别指望 ~TruesArray(n) 变成最优形态。

第四种,把稀疏方向记反:稀疏侧存的是偏离当前极性的少数派。1% True 的样本存的是 True 的下标,99% True 的样本存的才是 False 的下标。默认极性是 True,这句话很多人读完就忘。

这四类错误的共同点,是先动手、后看文档。README 里 BoolHybridArr([...])、TruesArray(n)、FalsesArray(n)、Create_BHA、Ask_BHA、BHAX_Descriptor 这几行写法就是官方入口名,照抄比自创省事得多。

十、五个常被问的问题

问:532 字节这个数字,能直接当成“一万布尔的内存”写进方案吗?

答:不行,要带上分布。它是“一万位里 1% 为 True”的结果,不是“一万布尔”的通用值。换分布就要重测,我上面那张表就是这么来的。

问:memory_usage() 里那句“对比 numpy 节省 94.73%”可信吗?

答:它是库自己按规模算的比例,不是同进程两个对象的实测对减。要写进汇报,自己造一份 numpy 数组、一份 BoolHybridArr,各自估内存再做差,把两个绝对数摆出来更稳。

问:optimize() 多久调一次?

答:它是 O(N) 全量重建,我这轮 42.323 毫秒。放启动阶段调一次足够;不要塞进热循环,也不要指望它替你做增量整理。

问:.bhax 为什么比 .bha 大那么多?

答:因为 .bhax 要带类型标记与结构信息,BHAX_Descriptor 才认得出读回来的是整数还是浮点、是单值还是嵌套。.bha 只有布尔,2 字节就够。别拿两者的大小直接类比。

问:forest 能不能替代 import?

答:它省 import,但不替代显式依赖。只注入当前环境存在的名字,缺的库访问时报 NameError 而不是提醒你装。生产代码里关键依赖还是写 import 更稳。

十一、装一遍要几步

我这轮是在云主机上装的,四步:

python3 -m venv /tmp/bha_check
/tmp/bha_check/bin/pip install "bool-hybrid-array==9.13.12" numpy
/tmp/bha_check/bin/python -c "import bool_hybrid_array as b; print(b.__file__)"
/tmp/bha_check/bin/python -c "from bool_hybrid_array import *; print(BoolHybridArr([True,False]))"

第三步是确认装到了哪个路径,第四步是确认入口名对不对。官方 README 推荐用 uv 装(python -m uv pip install bool-hybrid-array),比 pip 快一些,我这台机器图省事还是用了 pip,结果一样。

如果你要试 GPU 那套,先看机器有没有可用 CUDA:没有驱动时,装上 cupy-cuda12x 之后 GPU_opt() 调用会成功返回 None,但随后任何构造都会抛 cudaErrorInsufficientDriver。这不是库坏了,是环境缺驱动,我把完整报错抄下来,就是为了让后来人少走一遍。

十二、验收清单:五条自查

我给自己定了五条,每次用之前过一遍:

一,数据偏不偏?多数派占比多少,先算出来,再决定要不要用它。

二,切分点在哪?打印 repr 看 split_index,别猜。

三,内存符不符合预期?memory_usage(detail=True) 打出来看两个区各占多少。

四,要不要落盘?只存布尔走 .bha,混存走 .bhax。

五,需不需要重排?要就调 optimize(),别指望它自己变。

五条都过了,再谈“省不省”。这条顺序比任何一句宣传语都值钱。

十三、一个端到端的小场景:在线状态面板

我把这套东西塞进了一个很小的在线状态面板:一百万个用户,只有百分之一在线,每五秒刷新一次,面板要显示“在线人数”和“最近上线的一批人”。

数据的存法:一百万个布尔用 BoolHybridArr 存,构造前先想清楚切分点——这份数据极度偏斜,所以构造出来的稀疏侧装的是那一万个 True 的下标,count(True) 直接拿到在线人数,不用遍历。

刷新时只增量改变化的那些位置,改完不每个周期都 optimize(),只在每天凌晨做一次全量重建。落盘用 .bha,进程重启时 Ask_BHA 读回,七个布尔的量级是 2 字节,一百万位也不会夸张。

这套做法下来,最明显的收益不是“省了多少内存”这种抽象说法,而是内存曲线从锯齿变成了平线——原来每个周期新建一份列表替掉旧的,GC 抖得厉害;换成数组加增量改之后,曲线稳了,人也踏实了。

这里我没有引用任何“提速多少倍”的数字,因为提速依赖你的机器和你的刷新策略,我没在同一台机器上做前后对照,就不编这个百分比。我只有存储侧的几个实测:532 字节、2 字节、135 字节、42.323 毫秒、100.06 毫秒。够用了。

最后我把这篇文章的立场再说一遍:我不是来推荐一个库,我是来把“省内存”这三个字拆成可以验证的动作。你按第十二节那五条自查走一遍,得到的结论可能和我一样,也可能完全相反——如果你的数据对半开、又要高频逐位运算,你大概率会觉得这东西不值,那也是正确答案。小孩问那句话的价值,不在于他揭穿了谁,而在于他让所有人开始自己量。

(补一句口径:这篇里所有字节数与毫秒数都来自同一台云主机、Python 3.12.11、bool-hybrid-array 9.13.12、numpy 2.5.5,单次原值、未取平均;时间只记了 perf_counter 前后差值,没有做多轮统计,所以它们只表示“这一次跑成这样”,不代表任何性能承诺。)

posted @ 2026-11-19 14:12  贝壳bkshell  阅读(2)  评论(0)    收藏  举报