Files
marqdo-cli/tests/conformance/semantics/55-first-fit-free-list-allocator.mq.md
T
cflmy 5d3a5fb13b test(rfc-cm): close P2 evidence gaps for C01/C06/C12
- 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.
2026-11-20 21:22:44 +08:00

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(内存, 当前)

    1. 块大小 >= 需求

      [前一个, 当前, 块大小]

    前一个 = 当前

    当前 = 读32(内存, 当前 + 4)

[0, 0, 0]

分配

(内存, 容量, 请求大小)

first-fit:先查空闲链表,必要时切分;否则从 bump 指针处取新块。 块头 8 字节:偏移 0 是总块大小,偏移 4 是空闲链表 next。返回 payload 偏移。

需求 = (请求大小 + 8 + 7) // 8 * 8

位置 = 查找(内存, 需求)

前一个 = 位置[0]

当前 = 位置[1]

块大小 = 位置[2]

  1. 当前 != 0

    余量 = 块大小 - 需求

    下一个 = 读32(内存, 当前 + 4)

    1. 余量 >= 16

      余块 = 当前 + 需求

      写32(内存, 余块, 余量)

      写32(内存, 余块 + 4, 下一个)

      1. 前一个 == 0

        写32(内存, 0, 余块)

      2. true

        写32(内存, 前一个 + 4, 余块)

      写32(内存, 当前, 需求)

      成功(当前 + 8)

    2. true

      1. 前一个 == 0

        写32(内存, 0, 下一个)

      2. true

        写32(内存, 前一个 + 4, 下一个)

      成功(当前 + 8)

  2. true

    下一个空位 = 读32(内存, 4)

    1. 下一个空位 + 需求 <= 容量

      写32(内存, 下一个空位, 需求)

      写32(内存, 4, 下一个空位 + 需求)

      成功(下一个空位 + 8)

    2. true

      失败("alloc.no_space", "没有足够的空闲空间")

插入空闲

(内存, 块)

空闲链表按地址升序;插入后先与后继合并,再与前去合并。

前一个 = 0

当前 = 读32(内存, 0)

  • 当前 != 0 and 当前 < 块

    前一个 = 当前

    当前 = 读32(内存, 当前 + 4)

写32(内存, 块 + 4, 当前)

  1. 前一个 == 0

    写32(内存, 0, 块)

  2. true

    写32(内存, 前一个 + 4, 块)

合并(内存, 前一个, 块, 当前)

成功(None)

合并

(内存, 前一个, 块, 当前)

相邻块只有在地址连续时才合并,避免产生虚假的大块。

块大小 = 读32(内存, 块)

  1. 当前 != 0 and 块 + 块大小 == 当前

    合并大小 = 块大小 + 读32(内存, 当前)

    写32(内存, 块, 合并大小)

    写32(内存, 块 + 4, 读32(内存, 当前 + 4))

  2. true

    忽略后继合并 = 0

前一个大小 = 0

  1. 前一个 != 0

    前一个大小 = 读32(内存, 前一个)

  2. true

    忽略前去读取 = 0

后继合并完成后再处理前驱;两个判断必须分开执行。

  1. 前一个 != 0 and 前一个 + 前一个大小 == 块

    前一个新大小 = 前一个大小 + 读32(内存, 块)

    写32(内存, 前一个, 前一个新大小)

    写32(内存, 前一个 + 4, 读32(内存, 块 + 4))

  2. true

    忽略前去合并 = 0

成功(None)

已在空闲表

(内存, 块)

线性扫描空闲链表,检测重复释放。

当前 = 读32(内存, 0)

结果 = false

  • 当前 != 0 and not 结果

    1. 当前 == 块

      结果 = true

    2. true

      当前 = 读32(内存, 当前 + 4)

结果

释放

(内存, 地址)

把 payload 偏移换算回块头;重复释放返回可恢复错误,正常释放按地址插入并由“合并”处理相邻块。

块 = 地址 - 8

  1. 已在空闲表(内存, 块)

    失败("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]]