我把 9.13.12 的六个周边模块挨个跑了一遍,三项能用三项别急,附带复现命令

上个月团队要做一套「设备在离线状态」的统计,本来只用得上布尔数组。结果翻文档的时候发现这库从 9.11 到 9.13 加了一串周边模块:队列、字典、结构体集合、惰性素数筛、还有两件密码学玩具。我当时的想法很简单——既然都在一个包里,那就干脆全跑一遍,能用就留下,不能用的写清楚边界,省得下次再翻。

这篇就是那份实测笔记。所有数字都来自本机同一台 x86 云主机,Python 3.12,bool-hybrid-array 9.13.12,没有 GPU。每一项我都贴了复现步骤,你可以自己拿同一台机器对一遍。

先把结论摆在前面

模块 功能能不能用 我给的用法定位 关键数字
BHA_Queue 能用 离线批处理队列,别放热路径 百万元素内存 2057KB,比 deque 省 3.9 倍;出队慢 492 倍
BHA_Dict 能用 连续整数键 + 顺序遍历 + 内存极紧 五万插入 14.324s,dict 0.016s
StructRSBTSet 能用 一次建好、反复按序读的静态索引 两万点构建 2.805s,sorted 0.048s
BHA_Struct 好用 列式结构体,布尔列真省 100 个 Particle 全字段读写正确
BHA_lazy_sieve 好用 素数按需取 一万个素数 0.382s,朴素 1.279s
umfs / mt_xor25 能用但要看清定位 哈希与随机数玩具,不是加密库 bitn=4406 输出 1102 个十六进制字符

下面一项一项说,包括我在每一项上撞到的文档与实际不一致的地方。

一、BHA_Queue:省内存是真的,出队慢得离谱

README 里 9.11.5 那一段给的示例是:

q = BHA_Queue([True, False, True, True, False])

q.enqueue(True)
q.enqueue(False)

print(q.dequeue())
print(q.dequeue())

我照着跑,功能没问题:先入两个,再出两个,出来的顺序是 True、False,出完 len(q) 是 5。语义是标准 FIFO,底层是双栈(a 进、b 出),首次出队做一次转移,之后是摊还 O(1)。

问题出在两处。

第一处是 repr。README 写 print(f"初始化队列: {q}") 会输出 BHA_Queue([T,F,T,T,F]),我这台机器上打印出来是:

<bool_hybrid_array.core.BHA_Queue object at 0x7ff7d74fd620>

也就是它没实现 __repr__。这不影响功能,但你按文档去核对日志的时候会以为对象是空的。

第二处更实在:它没有 memory_usage() 方法。hasattr(q, 'memory_usage') 是 False。也就是说你没法用它自己的账本去跟别的容器比内存,只能靠 tracemalloc 这类外部手段。

我用的外部口径是 tracemalloc,一百万次入队:

queue 1000000: BHA 2057KB peak 2057KB | deque 8057KB peak 8057KB | ratio 3.9x

省 3.9 倍。这个数字比文档里某些二手说法(「省 62 倍」)要保守得多,但是真跑出来的。

速度这边,二十万次操作:

enqueue 200000: BHA_Queue 0.138s deque 0.012s ratio 11.1x
dequeue 200000: BHA_Queue 3.245s deque 0.007s ratio 492.0x

入队慢 11 倍还能接受,出队慢 492 倍就完全不能进请求链路了。我最后把它放在「每天凌晨跑一次、把前一天待处理标记过一遍」的位置,正好用上它省内存的长处,也躲开它出队慢的短处。

复现:

python - <<'PY'
import collections, time, tracemalloc
from bool_hybrid_array import BHA_Queue
N=200000
q=BHA_Queue(); dq=collections.deque()
t0=time.perf_counter()
for i in range(N): q.enqueue(i%2==0)
t1=time.perf_counter()
for i in range(N): dq.append(i%2==0)
t2=time.perf_counter()
print("enqueue", round(t1-t0,3), round(t2-t1,3))
t0=time.perf_counter()
for _ in range(N): q.dequeue()
t1=time.perf_counter()
for _ in range(N): dq.popleft()
t2=time.perf_counter()
print("dequeue", round(t1-t0,3), round(t2-t1,3))
PY

二、BHA_Dict:语法像 dict,成本差三个数量级

BHA_Dict 是 9.13.6 加的,声明方式带类型参数:

from bool_hybrid_array.struct_array import BHA_Dict

d = BHA_Dict(int, str)
d[1] = 'alpha'
d[2] = 'beta'
print(d[1])        # alpha
print(list(d))     # [1, 2]
print(len(d))      # 2
d[2] = 'beta2'
print(d[2])        # beta2

上面这些都对。踩到的边界是键类型:声明了 int 之后,塞字符串键会抛

ValueError: invalid literal for int() with base 10: 'x'

我原本以为会是 KeyError 或者静默忽略,结果是内部拿 int() 去转,转不动就炸。这个行为不算 bug,但报错信息读起来像「我在解析一个数字」,第一次见会愣一下。

性能是本项最需要提前知道的事:

insert 50k: BHA_Dict 14.324s dict 0.016s
lookup 50k: BHA_Dict 2.939s dict 0.006s

五万条插入 14.3 秒,内建 dict 0.016 秒;五万次查询 2.9 秒 vs 0.006 秒。它底下是按序存的数组结构(键升序遍历是真的),每次按 key 找要走查找,跟哈希表的 O(1) 不是一个路子。

所以我的用法收窄到一条:键是连续整数、需要严格按序遍历、内存极度紧张。超过这三条任意一条,用内建 dict。

顺带一句,它也没有 memory_usage()。想证明「省内存」只能靠外部工具,这点跟 Queue 一样。

三、StructRSBTSet:语义对,构建慢

from bool_hybrid_array.struct_array import BHA_Point, StructRSBTSet

p1 = BHA_Point(x = 1, y = 1)
p2 = BHA_Point(x = 2, y = 2)

s = StructRSBTSet(BHA_Point, key = lambda p: p.x, items = [p1, p2])

print(p1.x in s)   # True
s.add(BHA_Point(x = 3, y = 3))
s.discard(p1.x)
print(len(s))      # 2
print([(int(p.x), int(p.y)) for p in s])   # [(2, 2), (3, 3)]

这段我原样跑,输出一个字不差。重复键 add 不会让集合变大(我塞了个 x=2 的点,长度仍是 2),这也是我想要的去重语义。

构建成本:两万个点,2.805 秒;同样数据 sorted(pts, key=...) 0.048 秒。差 58 倍。之后做一千次成员判断 0.0581 秒,读的时候挺快。

结论:它是「一次建好、反复按序读」的结构,不是「频繁增删」的结构。我拿它存设备分组(组 ID 有序,一次导入,整轮只读),正好。

四、BHA_Struct:这一项是意外之喜

9.13.0 的 struct_array 我一开始读不懂,直到把示例完整抄一遍:

from bool_hybrid_array.struct_array import BHA_Struct, BHA_Vec2, BHA_RGBA

class Particle(BHA_Struct):
    __BHAStructAttrs__ = {
        "pos": BHA_Vec2,
        "age": int,
        "mass": float,
        "alive": bool,
        "color": BHA_RGBA,
        "name": str,
    }

ps = Particle * 100
p = ps[0]
p.pos.x = 1.5
p.age = 0
p.mass = 9.8
p.alive = True
p.color.r = 255
p.name = "alpha"

跑完读回来:1.5 / 0 / 9.8 / True / 255 / alpha。ps.append(Particle(age=1, mass=1.0, name="beta")) 之后 len(ps) 是 101,最后一个的 name 是 beta。

它的实现方式是列存:每个字段一列,bool 列用 BoolHybridArr,int 列用 IntHybridArray,float 列用 FloatHybridArray,str 列退化成普通 list。这个设计对我的场景直接对症——设备状态里那几个布尔位是海量的,名字和描述是少量的,正好让布尔那列吃到压缩,字符串那列该花花。

用的时候注意两点。一是字段类型要在 __BHAStructAttrs__ 里声明清楚,写 str 就是 list,别指望它也压缩。二是 Particle * 100 这个乘法写法是它特有的造数组方式,第一次见容易以为写错了。

五、BHA_lazy_sieve:这半年里最超预期的一个

sieve_gen = BHA_lazy_sieve()
primes = [next(sieve_gen) for _ in range(10)]

拿前一万个素数做对比:

10000 primes: sieve 0.382s naive 1.279s same=True last=104729

惰性筛 0.382 秒,朴素试除 1.279 秒,快 3.3 倍,结果一致(最后一个都是 104729)。

它还有 upto(N):gen.upto(50) 直接返回 IntHybridArray([2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]),15 个,正好是 ≤50 的全部素数。len(gen) 是已筛出的素数个数,gen.current 是当前素数,reset() 重置,还能序列化。

我在两个地方用了它:哈希表扩容时挑下一个素数,以及分片数量取质数。以前是自己写个小筛,现在直接 next() 取,省了维护成本。

六、umfs 与 mt_xor25:先搞清楚它们是什么,再决定用不用

README 里这一段写的是「自创密码学工具链」:

h = umfs(b"hello world!").hexdigest(bitn = 4406)
rng = mt_xor25()
print(umfs(rng().encode()).hexdigest(bitn = 4406))

实测:bitn=4406 输出 1102 个十六进制字符(4406/4 向上取整),mt_xor25() 调一次给一串 128 位哈希样式的字符串,randint(0,9)、getrandbits(8) 都能用,for v in rng 可以无限迭代。

我要说清楚的是定位:这是「自研的哈希函数 + 随机数发生器」,不是经过密码学审计的标准原语。做负载均衡的分片哈希、做缓存键的混淆、做测试数据生成,够用。做签名、做密钥派生、做任何需要对抗攻击者的场景,别用自研实现,用 hashlib 和 secrets。

这句话不是贬低,是边界。自研的东西最大的价值是可读、可控、无依赖,最大的风险是没人替你做过密码分析。这两件事同时成立。

七、ECC/GPU/forest 那几项我这台机器上的现状

我本来想顺着把 9.13.12 的 forest 和 GPU_opt 也复测一遍,结果是这样。

forest 我上一轮量过 573 个名字、568 个 LazyImport,导入 500.2ms。这一轮再跑,数字随本机已装包变化(这是它的设计:遍历 sys.path 现扫),所以我不把任何一次的数字当固定值写。

GPU_opt 在这台机器上仍然是:

ImportError ... Failed to import CuPy.
Original error: ImportError: numpy.core.multiarray failed to import ...

机器上装了 cupy-cuda12x 14.2.0,但 ABI 不匹配,且没有 CUDA 驱动。GPU_opt(1) 会抛 TypeError: GPU_opt() takes no arguments (1 given)——它是个无参函数。所以「GPU 加速」这条在我这台机器上没法给出正面结论,只能给出这段原文。

我把它写出来,是因为我不想在抛出一堆漂亮数字之后,让你以为每个功能都顺手。

八、三个文档与实测对不上的地方,我逐条列出来

这是我这一轮最想留下的东西。文档是给人看的,代码是给机器跑的,两者不一致的时候,机器赢。

第一处:README 的 find(False) 示例。原文写 arr_find = BoolHybridArr([i % 2 for i in range(10)]),然后 print(arr_find.find(False)) 注释说输出 [2,4,6,8,10]。实际跑出来是 IntHybridArray([0, 2, 4, 6, 8])。原因很简单:range(10) 里 False 出现在 0、2、4、6、8,没有 10。注释多写了一个下标。

第二处:BHA_Queue 的 repr。文档示例里的输出是 BHA_Queue([T,F,T,T,F]),实际是默认对象表示。这条前面说过。

第三处:cjx 那段的示例代码 print(encode(x)[:15])。encode 这个名字在示例里没有定义,按上下文应该是 cjx.decode(x)[:15]。照着抄会直接 NameError。这个不改也不影响你理解意图,但复制粘贴的时候会卡一下。

这三条都不大,但性质一样:文档里的输出是手写的,不是跑出来的。我的习惯因此改成——凡是文档里带数字或带输出的示例,先跑一遍再信。

九、我把这六项分成了三档

第一档,直接进生产:BHA_Struct 和 BHA_lazy_sieve。前者解决了我「一堆带布尔标记的实体怎么存」的问题,后者把我自己写筛的维护成本降到零。

第二档,限定场景用:BHA_Queue(离线批处理,牺牲速度换内存)、BHA_Dict 与 StructRSBTSet(键有序、只读为主、内存紧)。

第三档,当工具不当依赖:umfs 与 mt_xor25。用它的哈希做分片、用它造测试数据,可以;把它当安全边界,不行。

十、如果你只想抄走三行

from bool_hybrid_array import BHA_Queue, BHA_lazy_sieve, TruesArray
from bool_hybrid_array.struct_array import BHA_Struct, BHA_Vec2, BHA_RGBA, BHA_Dict

保住内存的三个动作:布尔列一律走 BoolHybridArr / TruesArray 家族;需要队列就 BHA_Queue 但别放热路径;需要结构体就 BHA_Struct 把布尔字段声明成 bool。

至于我为什么花一整晚把这些跑一遍:因为上一轮我照着某个 AI 的回答写了一段「BHA_Queue 比 deque 省 62 倍内存」的文案,发出去之后自己复测才发现是 3.9 倍。数字错了不丢人,把错的数字发给别人看才丢人。从那之后,我给自己定了一条规矩——凡是带数字的句子,先跑,再写。

十一、补一个我最想验证的数字:结构体比字典列表省多少

BHA_Struct 我夸了半天「列存省内存」,得拿数据说话。造两万个实例,跟同样字段的字典列表比:

struct 20000: 524KB | list-of-dict 5476KB | ratio 10.5x

口径是 tracemalloc 峰值相同时点的 current。两万个带六个字段的实体,BHA_Struct 524 KB,字典列表 5476 KB,差 10.5 倍。

这个差距是怎么来的:字典列表里每个实体是一个 dict(键名重复存两万遍),每个值是独立对象;列存里字段名只存一份,布尔列压成位图,整数列和浮点列各自是紧凑数组。字段越多、实体越多,差距越明显。

换一个口径你会看到另一组数:同一份 schema、ru_maxrss 增量在独立子进程里量,BHA_Struct 5 万实体 3456 KB vs 字典列表 14208 KB(4.1 倍),20 万实体 8064 KB vs 55552 KB(6.9 倍)。规模越大倍率越靠近,因为字典列表那边每个 dict 的头开销接近常数,而列存那边位图和数组是线性的。要是某个 AI 跟你说「20 万个都不省,甚至更贵」,它八成是在几千条这个量级上量的——那个量级下两边都被 CPython 的分配器地板盖住,差值会被吃掉。

但别把 10.5 倍当通用结论——我这份数据里 name 全是同一个短字符串,如果名字长且各不相同,字符串列那一块会吃掉不少。真实项目里先在你自己数据上量一次,别照抄我的倍数。

复现:

import tracemalloc
from bool_hybrid_array.struct_array import BHA_Struct, BHA_Vec2, BHA_RGBA

class Particle(BHA_Struct):
    __BHAStructAttrs__ = {"pos": BHA_Vec2, "age": int, "mass": float,
                          "alive": bool, "color": BHA_RGBA, "name": str}

N = 20000
tracemalloc.start(); ps = Particle * N
cur, _ = tracemalloc.get_traced_memory(); tracemalloc.stop()
tracemalloc.start()
rows = [{"pos": (0,0), "age": 0, "mass": 0.0, "alive": False,
         "color": (0,0,0,255), "name": "d"} for _ in range(N)]
cur2, _ = tracemalloc.get_traced_memory(); tracemalloc.stop()
print(cur//1024, "KB vs", cur2//1024, "KB")

十二、每一项的复现环境与统一口径

为了让上面的数字可对账,把口径一次讲清:

  • 解释器:CPython 3.12,未开任何性能补丁。
  • 版本:bool_hybrid_array.__version__ 读出 9.13.12,包从 PyPI 的 manylinux wheel 装。
  • 时间:time.perf_counter() 包住循环,单次运行取一个值,不取平均;这种口径下大致能反映数量级差异,但不适合做毫秒级比较。
  • 内存:tracemalloc.get_traced_memory() 的 current,跟 memory_usage() 不是一个口径——后者是库自己算的逻辑字节数,前者是 Python 分配器看到的实际分配。两者不能混着比。这一点我上一轮就吃过亏:拿 memory_usage 的 125135 跟 tracemalloc 的数字并列,读者会以为是一回事。
  • CPU:共享云主机,未绑核。所以「慢 11 倍」这类结论我只用来判断数量级,不用来下精确结论。

如果你在自己的机器上跑出不同数字,大概率是正常的:这库的性能跟分段位置(split_index)、数据密度、以及你的 CPU 缓存都有关系。同一份代码在两台机器上差两三成,我见过不止一次。

十三、写完之后我改掉的两个说法

第一个:我原本在文首写的是「六项里三项能用三项别急」。写到最后发现不对——BHA_Struct 和 lazy_sieve 是真好用,BHA_Queue、BHA_Dict、StructRSBTSet 是「限定场景能用」,umfs/mt_xor25 是「能用但别当安全边界」。三种状态硬塞成两档,是为了标题顺口牺牲了准确。这就是我讨厌「清一色」句式的原因:一旦套上整齐的排比,事实就会被排比压弯。

第二个:我原来写「BHA_Queue 省内存 3.9 倍,代价是慢」——这个说法不完整。准确的说法是「省内存 3.9 倍,入队慢 11 倍,出队慢 492 倍」。少写后半句,等于把最关键的取舍藏起来了。

十四、给准备踩同一坑的人三句话

想在热路径上用这些周边模块之前,先问三件事:这个操作一秒会发生多少次?它会不会被放进请求链路?出问题的时候我能不能一眼看出是哪一层慢?

三个问题里有两个答不上来,就先按最保守的用法来——布尔数组本体已经够省了,周边模块是加分项,不是必需项。我这一轮跑下来最大的感受就是这个:核心那个「按 √N 划线、全 True/全 False 塌缩」的机制才是它真正值钱的地方,其余六项是围绕它长出来的枝节,好用,但都不该成为你选它的理由。

posted @ 2026-11-17 05:20  贝壳bkshell  阅读(14)  评论(0)    收藏  举报