- Add alloc.double_free detection to the .mq.md free-list allocator and a fixture assertion for a second free returning a recoverable Result. - Add table group fixture 69 (table.row -> Map of value lists). - Add Int matrix-multiply fixture 70 for C12 layout/iteration. - Update counts and P2 evidence/status docs. Gate: fmt, clippy -D warnings, 407 tests passed.
5.9 KiB
写32
(内存, 基址, 值)
字节3 = 值 % 256
字节2 = 值 // 256 % 256
字节1 = 值 // 65536 % 256
字节0 = 值 // 16777216 % 256
内存[基址] = 字节0
内存[基址 + 1] = 字节1
内存[基址 + 2] = 字节2
内存[基址 + 3] = 字节3
None
读32
(内存, 基址)
内存[基址] * 16777216 + 内存[基址 + 1] * 65536 + 内存[基址 + 2] * 256 + 内存[基址 + 3]
成功
(值)
{ok: true, value: 值}
失败
(代码, 消息)
{ok: false, code: 代码, message: 消息}
初始化
(内存)
区域头:偏移 0 是空闲链表头,偏移 4 是 bump 指针;首个块从 8 开始。
写32(内存, 0, 0)
写32(内存, 4, 8)
成功(None)
查找
(内存, 需求)
返回 [前一个空闲块, 当前空闲块, 当前块大小];没有合适块时返回零值。
前一个 = 0
当前 = 读32(内存, 0)
-
当前 != 0块大小 = 读32(内存, 当前)
-
块大小 >= 需求[前一个, 当前, 块大小]
前一个 = 当前
当前 = 读32(内存, 当前 + 4)
-
[0, 0, 0]
分配
(内存, 容量, 请求大小)
first-fit:先查空闲链表,必要时切分;否则从 bump 指针处取新块。 块头 8 字节:偏移 0 是总块大小,偏移 4 是空闲链表 next。返回 payload 偏移。
需求 = (请求大小 + 8 + 7) // 8 * 8
位置 = 查找(内存, 需求)
前一个 = 位置[0]
当前 = 位置[1]
块大小 = 位置[2]
-
当前 != 0余量 = 块大小 - 需求
下一个 = 读32(内存, 当前 + 4)
-
余量 >= 16余块 = 当前 + 需求
写32(内存, 余块, 余量)
写32(内存, 余块 + 4, 下一个)
-
前一个 == 0写32(内存, 0, 余块)
-
true写32(内存, 前一个 + 4, 余块)
写32(内存, 当前, 需求)
成功(当前 + 8)
-
-
true-
前一个 == 0写32(内存, 0, 下一个)
-
true写32(内存, 前一个 + 4, 下一个)
成功(当前 + 8)
-
-
-
true下一个空位 = 读32(内存, 4)
-
下一个空位 + 需求 <= 容量写32(内存, 下一个空位, 需求)
写32(内存, 4, 下一个空位 + 需求)
成功(下一个空位 + 8)
-
true失败("alloc.no_space", "没有足够的空闲空间")
-
插入空闲
(内存, 块)
空闲链表按地址升序;插入后先与后继合并,再与前去合并。
前一个 = 0
当前 = 读32(内存, 0)
-
当前 != 0 and 当前 < 块前一个 = 当前
当前 = 读32(内存, 当前 + 4)
写32(内存, 块 + 4, 当前)
-
前一个 == 0写32(内存, 0, 块)
-
true写32(内存, 前一个 + 4, 块)
合并(内存, 前一个, 块, 当前)
成功(None)
合并
(内存, 前一个, 块, 当前)
相邻块只有在地址连续时才合并,避免产生虚假的大块。
块大小 = 读32(内存, 块)
-
当前 != 0 and 块 + 块大小 == 当前合并大小 = 块大小 + 读32(内存, 当前)
写32(内存, 块, 合并大小)
写32(内存, 块 + 4, 读32(内存, 当前 + 4))
-
true忽略后继合并 = 0
前一个大小 = 0
-
前一个 != 0前一个大小 = 读32(内存, 前一个)
-
true忽略前去读取 = 0
后继合并完成后再处理前驱;两个判断必须分开执行。
-
前一个 != 0 and 前一个 + 前一个大小 == 块前一个新大小 = 前一个大小 + 读32(内存, 块)
写32(内存, 前一个, 前一个新大小)
写32(内存, 前一个 + 4, 读32(内存, 块 + 4))
-
true忽略前去合并 = 0
成功(None)
已在空闲表
(内存, 块)
线性扫描空闲链表,检测重复释放。
当前 = 读32(内存, 0)
结果 = false
-
当前 != 0 and not 结果-
当前 == 块结果 = true
-
true当前 = 读32(内存, 当前 + 4)
-
结果
释放
(内存, 地址)
把 payload 偏移换算回块头;重复释放返回可恢复错误,正常释放按地址插入并由“合并”处理相邻块。
块 = 地址 - 8
-
已在空闲表(内存, 块)失败("alloc.double_free", "块已在空闲链表")
插入空闲(内存, 块)
成功(None)
main
内存 = memory.new(1, 1)
初始化(内存)
甲 = 分配(内存, 65536, 8)
乙 = 分配(内存, 65536, 16)
内存[甲.value] = 11
内存[乙.value] = 22
释放(内存, 甲.value)
丙 = 分配(内存, 65536, 8)
内存[丙.value] = 33
释放(内存, 乙.value)
释放(内存, 丙.value)
丁 = 分配(内存, 65536, 4)
戊 = 分配(内存, 65536, 16)
己 = 分配(内存, 65536, 64)
释放(内存, 己.value)
庚 = 分配(内存, 65536, 8)
辛 = 分配(内存, 65536, 16)
壬 = 分配(内存, 65536, 8)
癸 = 分配(内存, 65536, 8)
内存[庚.value] = 44
内存[辛.value] = 55
内存[壬.value] = 66
内存[癸.value] = 77
失败结果 = 分配(内存, 65536, 100000)
内存2 = memory.new(1, 1)
初始化(内存2)
甲2 = 分配(内存2, 65536, 8)
乙2 = 分配(内存2, 65536, 8)
丙2 = 分配(内存2, 65536, 8)
分配(内存2, 65536, 65472)
释放(内存2, 甲2.value)
释放(内存2, 乙2.value)
释放(内存2, 丙2.value)
丁2 = 分配(内存2, 65536, 40)
戊2 = 分配(内存2, 65536, 8)
释放一次 = 释放(内存2, 丁2.value)
重复释放 = 释放(内存2, 丁2.value)
[甲, 乙, 丙, 丁, 戊, 己, 庚, 辛, 壬, 癸, 失败结果, 甲2, 乙2, 丙2, 丁2, 戊2, 释放一次, 重复释放, 内存[甲.value], 内存[乙.value], 内存[丙.value], 内存[丁.value], 内存[戊.value], 内存[庚.value], 内存[辛.value], 内存[壬.value], 内存[癸.value]]