HelloSun commited on
Commit
ae9bb4c
·
verified ·
1 Parent(s): 39d0d4d

新增 HARDWARE.md(每個環境數字附量測指令、區分硬限制與 pager budget)與 results/upstream_hardware_audit.md(上游 sddqwen35a3b_v01 硬體/環境/容量敘述的審查與勘誤)

Browse files
Files changed (3) hide show
  1. HARDWARE.md +139 -0
  2. README.md +35 -7
  3. results/upstream_hardware_audit.md +371 -0
HARDWARE.md ADDED
@@ -0,0 +1,139 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # 硬體與執行環境(實測)
2
+
3
+ 這個 repo 的所有數字都是在下面這台機器上量的。這裡把「量到什麼」與
4
+ 「怎麼重量」都寫出來,避免出現別處那種「16 threads 是核心數嗎 / GB 還是 GiB /
5
+ RAM 預算是不是硬性上限」的歧義。
6
+
7
+ ## 0. 一句話版本
8
+
9
+ | | |
10
+ |---|---|
11
+ | CPU | Intel Xeon Platinum 8559C,2 socket × 48 core × 2 thread = **192 logical CPU 可見** |
12
+ | **實際算力配額** | cgroup v2 `cpu.max = 1600000 100000` → **16.0 CPU** |
13
+ | 實體 RAM | **2,000.0 GiB = 1.953 TiB**(`MemTotal` 2,097,117,272 kB) |
14
+ | Swap | **1,600.0 GiB = 1.5625 TiB**(`SwapTotal` 1,677,721,504 kB) |
15
+ | cgroup v2 記憶體上限 | `memory.max = 104,000,000,000 B` = **96.86 GiB / 104.0 GB** |
16
+ | **實際綁住本專案的上限** | `/root/memkill.py 80 2 64` → **單一子行程 64 GiB**、opencode 及其全部子行程合計 **80 GiB**、取樣間隔 2 s |
17
+ | 儲存 | `/` 是 **overlayfs**,底層是 `nvme0n1` = **Amazon Elastic Block Store**(**網路區塊裝置**,不是本地 NVMe SSD)7.8 TB |
18
+ | 磁碟單流(`dd bs=4M oflag=direct` / `iflag=direct`) | 寫 **1.1 GB/s**、讀 **2.0 GB/s** |
19
+ | cgroup 檔案系統 | **唯讀**(`/sys/fs/cgroup` 寫入失敗,`cgroup.subtree_control` 為空) |
20
+ | ISA | avx2 / fma / f16c / avx512f,dq,bw,vl,vbmi,ifma,bf16 / **avx512_vnni** / **amx_int8, amx_bf16, amx_tile** |
21
+
22
+ ## 1. CPU:三個數字不要搞混
23
+
24
+ 這台機器上「16」這個數字有三個完全不同的來源,混用會得到錯的結論:
25
+
26
+ | 量測指令 | 結果 | 意義 |
27
+ |---|---:|---|
28
+ | `lscpu \| grep ^CPU(s)` | **192** | 實體 logical CPU 數(2×48×2) |
29
+ | `python3 -c "len(os.sched_getaffinity(0))"` | **192** | cgroup 沒有縮 CPU set |
30
+ | `cat /sys/fs/cgroup/cpu.max` | `1600000 100000` | **配額 = 16.0 CPU**(這才是真正限制你的東西) |
31
+ | `nproc` | **16** | ⚠️ **不是**因為配額或 affinity,是因為環境變數 `OMP_NUM_THREADS=16` |
32
+
33
+ `nproc` 會尊重 `OMP_NUM_THREADS`,所以在這台機器上 `nproc` 剛好等於配額是
34
+ **巧合**,不是因果。`hardware_concurrency()` 回的是 192(實體數),
35
+ `sched_getaffinity()` 回的也是 192(沒有縮)—— 所以「容器裡
36
+ `hardware_concurrency()` 會回宿主核心數」這句話在這台機器上**無法用觀察區分**
37
+ 「回實體數」和「回 affinity 數」,因為兩者剛好都是 192。
38
+
39
+ **本專案的實驗一律用 `-t 16`**(= 配額),`n_threads_batch` 相同。
40
+ `-t` 超過 16 只會讓執行緒排程互相搶時間,不會變快。
41
+
42
+ ## 2. 記憶體:三個不同的上限
43
+
44
+ | 機制 | 值 | 是硬限制嗎 | 誰在用 |
45
+ |---|---|---|---|
46
+ | cgroup v2 `memory.max` | 96.86 GiB / 104.0 GB | 是(`OOM kill`) | 整個容器 |
47
+ | `memkill.py` 單一子行程 | **64 GiB** | 是(`SIGKILL`,連同子樹) | 每個 `sdq-chat` |
48
+ | `memkill.py` 合計(opencode + 全部子行程) | **80 GiB** | 是(`SIGKILL` 最大的那個子樹) | 整個工作階段 |
49
+ | `--ram-budget-mb`(SDQ pager budget) | 4/8/16/32 GiB | **不是**,只是算 arena 大小用的輸入 | 見下 |
50
+
51
+ `memkill.py` 的實際行為(讀 `/root/memkill.py` 確認):
52
+ 每 2 秒掃一次 `/proc`,把 `comm` 以 `opencode` 開頭的行程當 root,
53
+ 把 root 的所有後代加總 RSS;超過 80 GiB 就挑**記憶體最大的那個直接子行程**
54
+ 連同它的子樹 `SIGKILL`;任何單一行程超過 64 GiB 也直接殺。
55
+ **`opencode` 本體永遠不會被殺。**
56
+
57
+ > ⚠️ 這意味著 `peak RSS` 的天花板是 **64 GiB,不是 cgroup 的 96.86 GiB**。
58
+ > 這也是為什麼這個 repo 沒有做「原生路徑 vs 分頁路徑」的端到端 A/B:
59
+ > 原生路徑要把 127.27 GiB 的權重載入 RSS,一定會被這支守衛砍掉。
60
+
61
+ ### 為什麼 RAM 實驗只能是「pager budget」
62
+
63
+ `/sys/fs/cgroup` 是**唯讀**(`echo 0 > memory.high` 直接 `Read-only file system`),
64
+ `cgroup.subtree_control` 是空的,所以**沒辦法在這個容器裡為 4/8/16/32 GiB
65
+ 各建一個獨立的 cgroup 限額**。
66
+
67
+ 因此 `results/memory_levels_dsv4-4-8-16-32g.md` 的四列是「把 RAM 預算交給
68
+ pager 去算 arena 大小」再量 peak RSS,**不是**四個各自受限的容器。
69
+ 各列的實際 peak RSS 都如實列出(2233 / 6325 / 14508 / 30894 MB),可以直接
70
+ 對照 `memory.max`,四列都沒有接近任何上限。
71
+
72
+ ## 3. 儲存:這不是「SSD」
73
+
74
+ ```
75
+ $ stat -fc %T /root → overlayfs
76
+ $ lsblk -o NAME,SIZE,ROTA,MODEL
77
+ nvme0n1 7.8T 0 Amazon Elastic Block Store ← / 在這上面
78
+ nvme1n1 3.5T 0 Amazon EC2 NVMe Instance Storage
79
+ nvme3n1 3.5T 0 Amazon EC2 NVMe Instance Storage
80
+ ```
81
+
82
+ `/` 是 **overlayfs**,底層是 **Amazon Elastic Block Store**(EBS)——
83
+ 那是**網路-attached 區塊裝置**,不是本地 NVMe SSD。
84
+ 把指標命名為 `SSD MiB/token` 在這個環境下是有誤導性的:
85
+ 它量到的是「這個容器讀檔案的速率」,不是 SSD 控制器速率。
86
+
87
+ 本機實測單流(`bs=4M`):
88
+
89
+ ```
90
+ 寫 dd if=/dev/zero of=.ddtest bs=4M count=512 oflag=direct → 1.1 GB/s
91
+ 讀 dd if=.ddtest of=/dev/null bs=4M iflag=direct → 2.0 GB/s
92
+ ```
93
+
94
+ pager 用的是 `O_DIRECT`(`SDQ_FADV_DONTNEED=1` + 每個 shard 各開一組 `O_DIRECT`
95
+ fd),所以實測的 2.0 GB/s 是它真正能吃到的上限。`--stats-file` 報的
96
+ `SSD MiB/tok` 要拿這個數字去對照,不是拿消費級 SSD 的 7 GB/s 去對照。
97
+
98
+ ## 4. ISA 與編譯
99
+
100
+ CPU 有 `amx_int8` / `amx_bf16` / `amx_tile` / `avx512_vnni`,但**這個專案刻意
101
+ 不使用 AMX**,原因見 README 第 5 節 (e)(會讓 deepseek4 的 `attn_wo_a` 撞
102
+ sched assert)。所以:
103
+
104
+ * `-march=native` 會定義 `__AMX_INT8__` → llama.cpp 註冊 AMX extra buffer type
105
+ → 踩到那個 assert。**不要用 `-march=native`。**
106
+ * 正確做法是明確列 ISA(README 4.2),AMX 的 CMake 選項維持預設 OFF。
107
+ * 三個 x86 基線(AVX2 / AVX512+VNNI+BF16 / native+`-mno-amx-*`)的 decode tok/s
108
+ 在同一台機器上量不出差異(各自 3 輪落在 1.03–1.71 這個區間裡)。
109
+
110
+ K-quant / IQ3_S / MXFP4 的點積走的是 `ggml_vec_dot_*` 的 **AVX2 / AVX-512-VNNI**
111
+ 路徑,**不是 AMX**。
112
+
113
+ ## 5. 重現這些量測
114
+
115
+ ```bash
116
+ # CPU / 配額
117
+ lscpu | grep -E '^CPU\(s\)|^Model name|^Thread|^Core|^Socket'
118
+ python3 -c "import os; print('affinity', len(os.sched_getaffinity(0)), 'cpu_count', os.cpu_count())"
119
+ nproc; echo "OMP_NUM_THREADS=$OMP_NUM_THREADS"
120
+ cat /sys/fs/cgroup/cpu.max
121
+
122
+ # 記憶體 / cgroup
123
+ grep -E 'MemTotal|SwapTotal' /proc/meminfo
124
+ for f in memory.max memory.high memory.swap.max; do printf '%s = %s\n' "$f" "$(cat /sys/fs/cgroup/$f)"; done
125
+ stat -fc %T /sys/fs/cgroup; cat /sys/fs/cgroup/cgroup.subtree_control
126
+ ( echo 0 > /sys/fs/cgroup/memory.high ) 2>&1 | head -1 # 預期 Read-only
127
+
128
+ # 守衛
129
+ tr '\0' ' ' < /proc/$(pgrep -f memkill.py | head -1)/cmdline; echo
130
+ head -25 /root/memkill.py
131
+
132
+ # 儲存
133
+ stat -fc %T /root ; lsblk -o NAME,TYPE,SIZE,ROTA,MODEL
134
+ dd if=/dev/zero of=/tmp/.ddtest bs=4M count=512 oflag=direct 2>&1 | tail -1
135
+ dd if=/tmp/.ddtest of=/dev/null bs=4M iflag=direct 2>&1 | tail -1; rm -f /tmp/.ddtest
136
+
137
+ # ISA
138
+ lscpu | grep -oE '\b(avx512_vnni|amx_int8|amx_bf16|amx_tile|avx512f|avx2)\b' | sort -u
139
+ ```
README.md CHANGED
@@ -16,10 +16,14 @@ tags:
16
  這個 repo **不含權重**。權重在 [`unsloth/DeepSeek-V4-Flash-0731-GGUF`](https://huggingface.co/unsloth/DeepSeek-V4-Flash-0731-GGUF)
17
  的 `UD-IQ4_NL/` 目錄(4 個 shard,136,662,446,656 bytes ≈ 127.27 GiB)。
18
 
19
- 這個 repo 放的兩樣東西:
20
 
21
  1. **`sdq-dsv4/`** — 改寫後的推論平台(SDQ expert pager 適配 `deepseek4`)
22
  2. **`results/`** — 多組 RAM 預算實驗的完整結果與驗證證據
 
 
 
 
23
 
24
  上游是 [`HelloSun/Qwen3.8-Flash-Next-GGUF`](https://huggingface.co/HelloSun/Qwen3.8-Flash-Next-GGUF)
25
  的 `sdq-qwen38/`(同一套 SDQ 架構,目標模型是 `qwen4exp`)。本 repo 是把同一套架構
@@ -73,12 +77,32 @@ expert pager)的原始設計。
73
 
74
  ## 3. 實驗結果
75
 
76
- 測試機:Intel Xeon Platinum 8559C(16 vCPU 配額)、overlay filesystem
77
- (單流 `dd oflag=direct` 讀 2.0 GB/s)、實體 2 TiB RAM
78
- (實驗以 pager RAM 預算限制,見下方說明)。
79
- 設定:ctx=2048、ubatch=128、threads=16、temp=0、每級 2 輪。
 
 
 
 
 
 
 
 
 
 
 
80
  編譯:`GGML_NATIVE=OFF` + 明確列 AVX512/VNNI/BF16,**AMX 關閉**(見第 5 節 (e))。
81
 
 
 
 
 
 
 
 
 
 
82
  | RAM 預算 | arena (GiB) | slots | decode tok/s | prefill tok/s | hot % | cold % | SSD MiB/tok | 全程 SSD 讀取 | peak RSS (MB) | swap | 每層命中率 min..max |
83
  |---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
84
  | 4 GiB | 1.79 | 164 | 0.69 | 1.65 | 0.0 | 100.0 | 2944.4 | 161.8 GB | 2233 | 0 MB | 0.0..0.0 |
@@ -92,9 +116,11 @@ expert pager)的原始設計。
92
  * 4 GiB 那一級 `hot = 0%` 不是 bug:一個 token 在 43 層各用 6 個 expert,
93
  工作集下限就是 43 × 6 = 258 個 expert ≈ 2.8 GiB,而這一級的 arena 只有 1.79 GiB
94
  → 任何一次請求都必然是 miss。
95
- * **RAM 預算是 pager budget,不是 OS 硬性限額**:本機 `/sys/fs/cgroup` 唯讀,
 
96
  沒辦法為每一級建立獨立的 cgroup 限額,所以 4/8/16/32 GiB 是「把預算交給 pager
97
- 去算 arena 大小」,不是四個各自受限的容器。各級的實際 peak RSS 都如實列出。
 
98
  * swap 全程 0 MB:SDQ 不用 swap,權重資料只存在 arena(實體 RAM)與檔案(SSD)兩處。
99
  * tok/s 與 RAM/SSD/CPUs 綁定,不可跨機器移植。
100
 
@@ -436,7 +462,9 @@ sdq-dsv4/
436
  determinism_probe.sh 決定性探針(同一設定重跑 N 次比對輸出)
437
  0001-sdq-llama-glue.patch llama.cpp 側的掛鉤(build_moe_ffn / init_mappings / CMake)
438
  optional-sched-debug.patch 選用:sched assert 前印出沒被接走的節點
 
439
  results/
 
440
  memory_levels_dsv4-4-8-16-32g.json / .md 記憶體實驗(原始逐輪資料 + 表格)
441
  verify_dequant.txt NumPy dequant vs ggml dequant 的逐筆輸出(21/21 bit-exact)
442
  verify_moe_forward.txt expert 前向 vs 純 NumPy 的逐筆輸出(10/10 PASS)
 
16
  這個 repo **不含權重**。權重在 [`unsloth/DeepSeek-V4-Flash-0731-GGUF`](https://huggingface.co/unsloth/DeepSeek-V4-Flash-0731-GGUF)
17
  的 `UD-IQ4_NL/` 目錄(4 個 shard,136,662,446,656 bytes ≈ 127.27 GiB)。
18
 
19
+ 這個 repo 放的東西:
20
 
21
  1. **`sdq-dsv4/`** — 改寫後的推論平台(SDQ expert pager 適配 `deepseek4`)
22
  2. **`results/`** — 多組 RAM 預算實驗的完整結果與驗證證據
23
+ 3. **`HARDWARE.md`** — 硬體與執行環境(每個數字附量測指令;哪些是硬限制、哪些只是預算)
24
+ 4. **`results/upstream_hardware_audit.md`** — 對上游
25
+ [`HelloSun/sddqwen35a3b_v01`](https://huggingface.co/HelloSun/sddqwen35a3b_v01)
26
+ 硬體/環境/容量敘述的審查與勘誤(含 9 條硬性錯誤、6 條內部矛盾、6 條不清晰敘述)
27
 
28
  上游是 [`HelloSun/Qwen3.8-Flash-Next-GGUF`](https://huggingface.co/HelloSun/Qwen3.8-Flash-Next-GGUF)
29
  的 `sdq-qwen38/`(同一套 SDQ 架構,目標模型是 `qwen4exp`)。本 repo 是把同一套架構
 
77
 
78
  ## 3. 實驗結果
79
 
80
+ 完整規格、每個數字的量測指令、以及「哪些是硬限制、哪些只是預算」的說明,
81
+ 全部在 **[`HARDWARE.md`](HARDWARE.md)**。摘要:
82
+
83
+ | | |
84
+ |---|---|
85
+ | CPU | Intel Xeon Platinum 8559C,2 socket × 48 core × 2 thread = **192 logical CPU 可見** |
86
+ | **實際算力配額** | cgroup v2 `cpu.max = 1600000 100000` → **16.0 CPU**(實驗用 `-t 16`) |
87
+ | 實體 RAM | **2,000.0 GiB = 1.953 TiB**(`MemTotal` 2,097,117,272 kB) |
88
+ | cgroup v2 `memory.max` | 104,000,000,000 B = **96.86 GiB** |
89
+ | **實際綁住本專案的上限** | `/root/memkill.py 80 2 64` → **單一子行程 64 GiB**、全部子行程合計 **80 GiB**、每 2 秒取樣、`SIGKILL` |
90
+ | 儲存 | `/` = **overlayfs**,底層 `nvme0n1` = **Amazon Elastic Block Store**(**網路區塊裝置,不是本地 SSD**)7.8 TB |
91
+ | 磁碟單流 `dd oflag=direct` | 寫 1.1 GB/s、讀 **2.0 GB/s** |
92
+ | cgroup 檔案系統 | **唯讀** → 無法為每一級建立獨立限額 |
93
+
94
+ 設定:ctx=2048、ubatch=128、`-t 16`、temp=0、每級 2 輪。
95
  編譯:`GGML_NATIVE=OFF` + 明確列 AVX512/VNNI/BF16,**AMX 關閉**(見第 5 節 (e))。
96
 
97
+ > 三個容易搞混的地方,這裡先講清楚:
98
+ > 1. `nproc` 在這台機器上回 16,是因為環境變數 `OMP_NUM_THREADS=16`,
99
+ > **不是**因為配額或 affinity(`sched_getaffinity` 回 192)。
100
+ > 2. 指標名稱沿用 SDQ 原版的 `SSD MiB/tok`,但這裡的「SSD」是 overlayfs 底下的
101
+ > EBS 網路裝置,量到的是**這個容器讀檔案的速率**(單流上限 2.0 GB/s)。
102
+ > 3. `--ram-budget-mb` 是 **pager budget,不是 OS 限額**;真正會殺行程的是
103
+ > `memkill.py` 的 64 GiB 單行程上限。這也是本 repo 沒做「原生路徑 vs 分頁路徑」
104
+ > 端到端 A/B 的原因(原生路徑要 127.27 GiB 進 RSS,一定被殺)。
105
+
106
  | RAM 預算 | arena (GiB) | slots | decode tok/s | prefill tok/s | hot % | cold % | SSD MiB/tok | 全程 SSD 讀取 | peak RSS (MB) | swap | 每層命中率 min..max |
107
  |---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
108
  | 4 GiB | 1.79 | 164 | 0.69 | 1.65 | 0.0 | 100.0 | 2944.4 | 161.8 GB | 2233 | 0 MB | 0.0..0.0 |
 
116
  * 4 GiB 那一級 `hot = 0%` 不是 bug:一個 token 在 43 層各用 6 個 expert,
117
  工作集下限就是 43 × 6 = 258 個 expert ≈ 2.8 GiB,而這一級的 arena 只有 1.79 GiB
118
  → 任何一次請求都必然是 miss。
119
+ * **RAM 預算是 pager budget,不是 OS 硬性限額**:本機 `/sys/fs/cgroup` 唯讀
120
+ (`echo 0 > memory.high` 直接 Read-only),`cgroup.subtree_control` 為空,
121
  沒辦法為每一級建立獨立的 cgroup 限額,所以 4/8/16/32 GiB 是「把預算交給 pager
122
+ 去算 arena 大小」,不是四個各自受限的容器。各級的實際 peak RSS 都如實列出,
123
+ 全部遠低於 `memory.max` 的 96.86 GiB 與 memkill 的 64 GiB 單行程上限。
124
  * swap 全程 0 MB:SDQ 不用 swap,權重資料只存在 arena(實體 RAM)與檔案(SSD)兩處。
125
  * tok/s 與 RAM/SSD/CPUs 綁定,不可跨機器移植。
126
 
 
462
  determinism_probe.sh 決定性探針(同一設定重跑 N 次比對輸出)
463
  0001-sdq-llama-glue.patch llama.cpp 側的掛鉤(build_moe_ffn / init_mappings / CMake)
464
  optional-sched-debug.patch 選用:sched assert 前印出沒被接走的節點
465
+ HARDWARE.md 硬體與執行環境(每個數字附量測指令)
466
  results/
467
+ upstream_hardware_audit.md 對上游 sddqwen35a3b_v01 的硬體/環境敘述審查與勘誤
468
  memory_levels_dsv4-4-8-16-32g.json / .md 記憶體實驗(原始逐輪資料 + 表格)
469
  verify_dequant.txt NumPy dequant vs ggml dequant 的逐筆輸出(21/21 bit-exact)
470
  verify_moe_forward.txt expert 前向 vs 純 NumPy 的逐筆輸出(10/10 PASS)
results/upstream_hardware_audit.md ADDED
@@ -0,0 +1,371 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # `HelloSun/sddqwen35a3b_v01` 硬體/環境敘述的勘誤與合理化
2
+
3
+ 這份文件是對上游 repo 的**審查結果**,不是它的一部分。目的是把「硬體與環境」
4
+ 相關的敘述改成**可驗證、單位明確、彼此一致**的版本。
5
+
6
+ 審查對象:該 repo 的 `README.md`、`docs/01`–`docs/10`、
7
+ `performance_report_2026-10-06.md`、`hot_expert_lossless_compression_2026-10-06.md`、
8
+ `llama_server.sh`、`bench/results/*.json`。
9
+
10
+ 審查方法:逐行讀 + 用 python 重算所有算式 + 在本機(規格見
11
+ [`HARDWARE.md`](HARDWARE.md))實測對照。
12
+
13
+ > **下面每一条都標了「已驗證 / 待驗證」。** 「已驗證」表示我在本機用指令或
14
+ > 算式確認過;「待驗證」表示引用的檔案在 repo 裡數字對不上,但缺原始資料無法判定。
15
+
16
+ ---
17
+
18
+ ## A. 硬性錯誤(算式或指令本身錯了)
19
+
20
+ ### A1. `ulimit -d 8192` 是 **8 MiB**,不是 8 GB —— 差 1024 倍
21
+
22
+ `docs/02_design.md:99`
23
+
24
+ ```
25
+ 1. `ulimit -d 8192`(RLIMIT_DATA):核心層級限制**匿名記憶體**上限 8 GB。
26
+ ```
27
+
28
+ bash 的 `ulimit -d` 單位是 **1024-byte block**。實測:
29
+
30
+ ```
31
+ $ bash -c 'ulimit -d 8192; ulimit -d'
32
+ 8192 # KiB = 8 MiB = 0.0078 GiB
33
+ $ bash -c 'ulimit -d 8388608; ulimit -d'
34
+ 8388608 # KiB = 8 GiB
35
+ ```
36
+
37
+ 同一份 repo 的 `docs/03_results.md:4` 寫的是正確值(`ulimit -d 8388608`),
38
+ 所以兩份文件描述的是**不同的東西**,卻用同樣的措辭。
39
+
40
+ **修正**:`docs/02:99` 應為 `ulimit -d 8388608`(8 GiB),
41
+ 並註明 bash 的 `-d` 單位是 KiB。
42
+
43
+ ### A2. Q6_K 的 per-expert 尺寸是 **840 KiB**,不是 820 KiB
44
+
45
+ `docs/01_moe_path_analysis.md:29`
46
+
47
+ ```
48
+ 每個 expert ≈ 1.86 MiB(Q4_K 576 KiB + Q4_K 576 KiB + Q5_K/Q6_K 704/820 KiB)
49
+ ```
50
+
51
+ 用 repo 自己量到的槽位大小反推(`docs/06_slots.md:32-33`:小槽 1,900,544 B、
52
+ 大槽 2,039,808 B):
53
+
54
+ | 段 | 實際 bytes | KiB |
55
+ |---|---:|---:|
56
+ | gate Q4_K | 589,824 | 576 ✓ |
57
+ | up Q4_K | 589,824 | 576 ✓ |
58
+ | down Q5_K(小槽) | 1,900,544 − 2×589,824 = **720,896** | **704** ✓ |
59
+ | down Q6_K(大槽) | 2,039,808 − 2×589,824 = **860,160** | **840** ✗ 文件寫 820 |
60
+
61
+ 獨立驗算:Q6_K = 6.5625 bpw,2048 列 × 512 = 1,048,576 元素
62
+ → 1,048,576 × 6.5625 / 8 = 860,160 B = 840 KiB。**820 KiB 是錯的。**
63
+
64
+ 誤差量級:3 層 × 256 expert × 20 KiB = 15.0 MiB。
65
+
66
+ ### A3. 單一 expert 是 **1.8125 / 1.9453 MiB**,不是「1.86 MiB」或「1.86–1.97 MiB」
67
+
68
+ `docs/01:29`、`docs/02:21`、`docs/02:26`
69
+
70
+ ```
71
+ docs/01:29 每個 expert ≈ 1.86 MiB
72
+ docs/02:21 約 1.86 MiB
73
+ docs/02:26 所有 expert 大小幾乎相同(1.86–1.97 MiB)→ 固定 2 MiB slot
74
+ ```
75
+
76
+ 實際(由 A2 的 bytes 推導):小槽 **1,856 KiB = 1.8125 MiB**、
77
+ 大槽 **1,992 KiB = 1.9453 MiB**。加權平均(37 小 + 3 大)= **1.8225 MiB**。
78
+
79
+ `docs/06:59-60` 自己印的是 `小 1.81 MiB × 1912 + 大 1.95 MiB × 155(平均 1.82 MiB)`
80
+ 與 `slot=1.95 MiB (2039808 B)`——和 `docs/02` 的「1.86–1.97」對不上。
81
+
82
+ **修正**:統一寫成「小槽 1.8125 MiB / 大槽 1.9453 MiB / 加權平均 1.8225 MiB」。
83
+
84
+ ### A4. 每 token 工作集被寫成四個不同的數字,正確答案是 **583.2 MiB**
85
+
86
+ | 位置 | 寫法 | 用該寫法的公式算出來 |
87
+ |---|---|---|
88
+ | `docs/01:30` | **583 MiB** | 8 × 40 × 1.86 = 595.2 ✗ |
89
+ | `docs/02`(承襲 1.86) | 595 MiB | 595.2 ✓(但 1.86 本身錯,見 A3) |
90
+ | `docs/03:72` | **610 MiB** | 40 × 8 × 1.95 = 624 ✗,且 1.95 是大槽、不該套全部 40 層 |
91
+ | `docs/03:72` 隱含 | 624 MiB | 624 ✓(但結論錯) |
92
+
93
+ 用實際槽位大小算:
94
+
95
+ ```
96
+ 8 experts × (37 × 1,900,544 + 3 × 2,039,808) B = 76,439,552 B = 583.2 MiB
97
+ ```
98
+
99
+ **583.2 MiB 才是對的**,`docs/01:30` 的答案對、但它寫的算式錯;
100
+ `docs/03:72` 的答案錯(多算了 4.5%)。
101
+
102
+ ### A5. `arena 3.88 GiB ≈ 6.3 個 token 的工作集` → **6.8**
103
+
104
+ `docs/03_results.md:73`
105
+
106
+ ```
107
+ 而 arena 只有 3.88 GiB ≈ 6.3 個 token 的完整工作集。
108
+ ```
109
+
110
+ 3.88 GiB = 3,973 MiB。
111
+
112
+ * ÷ 583.2 MiB(正確工作集)= **6.81**
113
+ * ÷ 624 MiB(文件自己寫的)= 6.37 ≈ 「6.3」
114
+
115
+ 也就是說這個 6.3 是「用錯工作集」換來的。**修正為 6.8。**
116
+
117
+ ### A6. `整層 456 MiB` → **466.6 MiB**,而且那句話本身是未整理的草稿
118
+
119
+ `docs/01_moe_path_analysis.md:84`
120
+
121
+ ```
122
+ (b) 把模型切成 shard、逐層載入/卸載 | 每層 456 MiB(8 個 expert 的權重是 583 MiB
123
+ 但整層是 18.2GB/40 = 456MB…實際上整層含 256 experts ≈ 456 MiB)
124
+ ```
125
+
126
+ * 18.2246 GiB / 40 = **466.6 MiB**,不是 456。
127
+ * 括號裡有 `18.2GB/40`、`456MB`、`…實際上` 三種混寫,單位(GB/GiB)與數字都不一致,
128
+ 看起來是thinking-out-loud沒刪乾淨。
129
+
130
+ **修正**:刪掉括號內的自我修正過程,只留
131
+ `每層 466.6 MiB(40 層 × 256 experts × 加權平均 1.8225 MiB)`,
132
+ 並註明 8 個 expert 只佔整層的 583.2/466.6 = 1.25 倍,不是 8 倍——所以逐層載入
133
+ 並沒有比只讀 8 個 expert 省,理由要重寫。
134
+
135
+ ### A7. `SSD(模型檔 22.1 GiB)` → **20.61 GiB**
136
+
137
+ `docs/02_design.md:7`(架構圖裡)
138
+
139
+ ```
140
+ │ SSD(模型檔 22.1 GiB) │
141
+ ```
142
+
143
+ 同一個檔案的 `README.md:67` 寫 `22,134,528,992 bytes`:
144
+
145
+ ```
146
+ 22,134,528,992 B = 22.13 GB = 20.61 GiB
147
+ ```
148
+
149
+ 所以 22.1 是 **GB(十進位)**,不是 GiB。`docs/10:45` 寫 `20.6 GiB` 是對的。
150
+ **修正**:`docs/02:7` 改成 `20.61 GiB`,並全 repo 統一標明 GB(10⁹) / GiB(2³⁰)。
151
+
152
+ ### A8. `202 MB/token ÷ 6.28 tok/s = 1.27 GB/s` —— 應該是**乘**
153
+
154
+ `docs/10_phase0_measurement.md:67-68`
155
+
156
+ 速率 = 流量 ÷ 時間,方向反了。正確是 `202 MB/token × 6.28 tok/s ≈ 1.27 GB/s`。
157
+
158
+ ### A9. `約 45% 的餘裕` —— 45% 是**使用率**,不是餘裕
159
+
160
+ `docs/10_phase0_measurement.md:68` 附近。若裝置 1.27 GB/s 中用了 45%,
161
+ 餘裕是 **55%**。
162
+
163
+ ---
164
+
165
+ ## B. 內部矛盾(同一份 repo 說法不一致)
166
+
167
+ ### B1. 記憶體帳目在兩個時代互相矛盾
168
+
169
+ | 來源 | `peak RSS − arena` | 推論出的非 expert 常駐量 |
170
+ |---|---:|---|
171
+ | `docs/03_results.md:14-20`(Q6_K/Q5_K 時代) | 7.44–7.81 GB − 3.88 GiB ≈ **3.5 GiB** | ≈ 3.5 GiB |
172
+ | `performance_report:49-51, 66-68`(2026-10-06) | **256 MiB(每一列都剛好 256)** | ≈ 0 |
173
+
174
+ 「每一列都剛好 256 MiB」本身就可疑——那看起來像
175
+ `RSS − arena` 只是把 arena 減掉、其餘被歸到別的欄位,而不是真的量到。
176
+ 而 `docs/03:14` 明確說 `常駐 RAM 的非專家權重 2.38 GiB`。
177
+ **這兩種帳目沒有任何地方對帳。**
178
+
179
+ ### B2. 「檔案對映 RSS = 0 MB」與「2.38 GiB 非專家權重常駐」不能同時成立
180
+
181
+ `docs/03_results.md:24`
182
+
183
+ ```
184
+ `/proc/self/smaps_rollup` 也證實「檔案對映 RSS = 0 MB」,代表完全沒靠 mmap 偷記憶體。
185
+ ```
186
+
187
+ 同檔 `docs/03:14` 說非專家權重 2.38 GiB **常駐 RAM**;`README:68` 與
188
+ `docs/01:83` 又說 `永遠只做 SSD 上的 file-backed mmap`。
189
+
190
+ 如果 2.38 GiB 權重常駐,file-backed RSS 就不可能是 0。兩者必有一個錯。
191
+ (`docs/10:122-125` 其實也把這件事標成未解,但 `docs/03` 把它講成了已證實。)
192
+
193
+ ### B3. 模型檔的存取方式有兩套互斥說法
194
+
195
+ | 位置 | 說法 |
196
+ |---|---|
197
+ | `README:68`、`docs/01:83`、`docs/02:100` | **file-backed mmap** |
198
+ | `docs/03:22` | **O_DIRECT pread,不佔 page cache** |
199
+
200
+ 這不是措辭差異,是兩種完全不同的 I/O 路徑。而且 `docs/02:100` 說
201
+ 「file-backed mmap 不計入 RLIMIT_DATA」在**機制上正確**、但結論錯:
202
+ RLIMIT_DATA 確實不管 file-backed page,但那些 page **仍然是實體 RAM**,
203
+ 仍然算進 cgroup `memory.max`、也仍然算進 RSS。所以「不計入」不能推出
204
+ 「不佔記憶體」,而 B2 的矛盾正好卡在這裡。
205
+
206
+ ### B4. `llama_server.sh` 的註解與程式碼互相矛盾
207
+
208
+ | 行 | 內容 | 問題 |
209
+ |---|---|---|
210
+ | `llama_server.sh:22-23` | 「3. **不打開 swap。** RLIMIT_DATA 會被壓在偵測到的 RAM 預算上…」 | 宣稱有 RLIMIT |
211
+ | `llama_server.sh:421-422` | 「不使用 RLIMIT_DATA 對整個 process 設限:它會錯誤限制模型外的匿名用量」 | 程式碼**明確不設** |
212
+ | `llama_server.sh:295` | 「不開 `-march=native`:編譯機與執行機不一定同一台,native 會在別的機器 SIGILL」 | 政策是不要 native |
213
+ | `llama_server.sh:297` | `-DGGML_NATIVE=ON \` | **這就是 native**,二進位不可攜,與政策相反 |
214
+
215
+ 另外 `llama_server.sh:437` 的 `SDQ_IO_THREADS` 48 上限是**死碼**——
216
+ `THREADS ≤ 8` ⇒ I/O 執行緒最多 24,永遠碰不到 48。
217
+
218
+ ### B5. README 的範例輸出與現行腳本對不上
219
+
220
+ `README:39-41` 寫 `ram_budget=7946 / reserve=900 / arena≈3546 / 2017 experts`,
221
+ 但 `llama_server.sh:180-190` 現在算出的會是 `6144 / 608 / 5536 / 3149`,
222
+ 而 `docs/06:60` 實測是 `arena=3.68 GiB / 2067 slots`。
223
+ 三個數字互不相同,而且 README 沒有標示那是哪個版本的腳本產生的。
224
+
225
+ ### B6. `583 MiB` 在兩個 repo 裡是兩個完全不同的量
226
+
227
+ * `docs/01:30`:**每 token 的專家工作集** 583 MiB(正確值,見 A4)
228
+ * `performance_report:49,51,79`:A/B 之間 **多用的 arena / RSS** 583 MiB
229
+
230
+ 數字巧合相同,但意義完全無關,而且出現在同一份 repo 裡。
231
+ 建議把後者改寫成「+0.57 GiB」或明確標註「與工作集無關」。
232
+
233
+ ---
234
+
235
+ ## C. 硬體描述不清晰(不是錯,但會誤導)
236
+
237
+ ### C1. 「16 threads / 8 threads / 配額 無」到底是什麼
238
+
239
+ | 出處 | 寫法 | 實際是什麼 |
240
+ |---|---|---|
241
+ | `README:40` | `[sdq] CPU 8 threads(配額 無/可用核心 8)` | 印出的是**已經被 cap 過的執行緒數**,卻標成「CPU N threads」,讀起來像核心數 |
242
+ | `README:96` | 「給 2 個 vCPU 卻開 16 執行緒」 | 16 是容器的 affinity/可見核心數,不是實體核心數 |
243
+ | `10_phase0:193` | 「配額 2 執行緒、affinity 回 16……於是『2 個 vCPU 開 24 條 I/O 執行緒』」 | 同樣的 bug 被寫成 24,與 README 的 16 不一致 |
244
+
245
+ 實體核心數在整個 repo 裡**從未被記錄**。
246
+
247
+ ### C2. 「8 GB」有三個意思
248
+
249
+ | 用法 | 出處 | 實際意義 |
250
+ |---|---|---|
251
+ | (a) 某台機器的實體 RAM | `README:3` | 從未被實測(見 D1) |
252
+ | (b) `RLIMIT_DATA` 的值 | `docs/03:4` | `ulimit -d 8388608` = **8 GiB** = 8.59 GB,不是 8 GB |
253
+ | (c) 餵給 pager 的 RAM budget | 全 repo 的 `8 GB 預算` | `hot:60` 顯示實際餵的是 **6144 MB** |
254
+
255
+ 同一句 `README:3` 裡還同時寫了 `22.1 GB`(十進位),
256
+ 於是「8 GB RAM 的機器跑 22.1 GB 的模型」這句話的兩個單位不一致。
257
+
258
+ **建議**:全 repo 統一寫 `GiB`,並把 (a)(b)(c) 分別命名為
259
+ 「實體 RAM」「RLIMIT_DATA 限額」「pager RAM budget」,不要都叫「8 GB」。
260
+
261
+ ### C3. 「SSD」在這個環境裡是網路檔案系統
262
+
263
+ `docs/03_results.md:87` 自己寫了 `本機的「SSD」其實是網路檔案系統`,
264
+ 但所有指標名稱仍然叫 `SSD I/O/token`(`README:230`)、
265
+ `ssb_*`(`SDQ-SSD-Budget)。指標名稱比說明更早被讀到。
266
+
267
+ (對照:本 repo 的 `HARDWARE.md` 說明 `/` 是 overlayfs 底層 Amazon EBS,
268
+ 並把指標保留原名但加上解讀。)
269
+
270
+ ### C4. I/O probe 表的 MB/s 與 median batch ms 對不上
271
+
272
+ `docs/10:44-56`。用 `QD × 1800 KiB ÷ batch ms` 反推每列的隱含 MiB/s:
273
+
274
+ | QD | 1 | 2 | 4 | 8 | 16 | 24 | buf 1 | buf 24 |
275
+ |---|---|---|---|---|---|---|---|---|
276
+ | 隱含 MiB/s | 998.8 | 947.6 | 930.1 | 949.5 | 862.2 | 927.4 | 266.3 | 332.5 |
277
+ | 文件寫的 MB/s | 920.5 | 939.0 | 916.3 | 951.9 | 836.4 | 927.3 | 309.9 | 332.5 |
278
+
279
+ O_DIRECT 幾列差 1–8%,**buffered QD1 差 16%(方向相反)**。
280
+ 另外 `1,800 KiB` 不是一個 expert 的大小(實際 1,856 / 1,992 KiB,見 A3),
281
+ 而 1,843,200 這個常數也出現在 `llama_server.sh:185,212`。
282
+
283
+ ### C5. ISA 只寫「有 AMX」,沒寫實際走哪條路
284
+
285
+ `docs/03:3` 寫 `AVX-512 / AMX`,但整個 repo 沒有任何地方寫
286
+ runtime 實際派發到哪個 kernel。K-quant 的點積走
287
+ `ggml_vec_dot_q4_K_q8_K` 等的 **AVX2 / AVX-512-VNNI** 路徑,**不用 AMX**;
288
+ 寫成「AVX512 / AMX」會讓人以為 AMX 有參與。
289
+
290
+ ### C6. `nproc` 在這個 repo 的環境裡不是核心數
291
+
292
+ 見本 repo 的 `HARDWARE.md` §1。`nproc` 尊重 `OMP_NUM_THREADS`。
293
+ `llama_server.sh:131` 用 `nproc` 決定執行緒數,在有 `OMP_NUM_THREADS` 的環境裡
294
+ 會得到和配額無關的答案。`llama_server.sh:117` 對 `cpu.max` 做整數除法,
295
+ 2.5 vCPU 的配額會被無聲地變成 2 執行緒。
296
+
297
+ ---
298
+
299
+ ## D. 最大的問題:headline 數字沒有在它宣稱的機器上量過
300
+
301
+ ### D1. 「在 8 GB RAM 的機器上真的跑得動」——從未在 8 GB 機器上量過
302
+
303
+ `README:3`
304
+
305
+ ```
306
+ 在 **8 GB RAM 的 Intel 機器**上真的跑得動 Qwen3.6-35B-A3B(22.1 GB / Q4_K_M)
307
+ ```
308
+
309
+ 實際上:
310
+
311
+ * `docs/03:4` 說那個 8 GB 上限是**在 2 TiB 的機器上用 `RLIMIT_DATA` 做出來的**;
312
+ * `performance_report:89-91` 說「正常測試**不設** RLIMIT_DATA」;
313
+ * `llama_server.sh:421-422` 說啟動器**不再**設 RLIMIT_DATA;
314
+ * `docs/03:94` 自己寫 `尚未在真實 8 GB 實體機复驗`。
315
+
316
+ 所以正確的寫法應該是:**「用 RLIMIT_DATA 在一台上模擬 8 GiB 的匿名記憶體上限,
317
+ 在 2 TiB 實體 RAM 的機器上量到 X tok/s;尚未在真實 8 GB 機器上驗證。」**
318
+ 現在的寫法讓讀者以為已經在 8 GB 硬體上跑過,這是整份 repo 裡
319
+ 最需要修正的一句。
320
+
321
+ ### D2. 記憶體守衛(memkill)在 repo 裡完全沒被揭露
322
+
323
+ `/root/memkill.py 80 2 64` 是這個環境的一部分:每 2 秒取樣、
324
+ opencode 及其全部子行程合計 80 GiB、單一子行程 64 GiB、超了就 `SIGKILL`。
325
+ repo 裡所有的 `peak RSS` / `swap 0` 都是在這隻守衛**還活著**的情況下量的,
326
+ 但沒有任何一份文件提到它。
327
+
328
+ 這件事對可重現性很重要:換一台沒有這隻守衛的機器,
329
+ `docs/03` 裡那種「設成 1 GB 會 insufficient memory」的失敗模式可能就不一樣了
330
+ (`docs/02:101` 與 `performance_report:89-90` 對 RLIMIT 的行為就有兩種說法)。
331
+
332
+ ### D3. `docs/05` 的結論被另一台機器推翻,但被寫成「與機器無關」
333
+
334
+ `docs/10:62-63`
335
+
336
+ ```
337
+ docs/05 當時量到相反結論,是因為那台機器的單流只有 275 MB/s …
338
+ **這一項與機器無關,值得記成「直接讀」是對的**
339
+ ```
340
+
341
+ 「單流只有 275 MB/s 所以結論相反」本身就說明結論**與機器有關**。
342
+ 可以支持的說法是:「在 overlay 容器上 O_DIRECT 比 buffered 快 3×;
343
+ 在單流 275 MB/s 的裝置上 buffered 也有競爭力。兩者都需要在目標機器上重測。」
344
+
345
+ ---
346
+
347
+ ## E. 建議的修正優先順序
348
+
349
+ | # | 項目 | 為什麼優先 |
350
+ |---|---|---|
351
+ | 1 | **D1**(headline 沒有在 8 GB 硬體上驗證) | 這是唯一會讓人對專案能力產生錯誤期待的句子 |
352
+ | 2 | **A1**(`ulimit -d 8192` = 8 MiB) | 照抄這行的人會得到一個 8 MiB 的行程 |
353
+ | 3 | **B1 / B2 / B3**(記憶體帳目、file-backed RSS、mmap vs O_DIRECT) | 這三條互相咬合,是「8 GB 到底夠不夠」的核心論證 |
354
+ | 4 | **A4 / A5**(工作集 583.2 MiB、6.8 個 token) | 決定設計取捨的兩個數字,錯了會誤導後續優化方向 |
355
+ | 5 | **C1 / C2**(執行緒數與 8 GB 的三種意思) | 硬體闡述不清晰的根源 |
356
+ | 6 | **A2 / A3 / A6 / A7**(KiB/MiB/GiB 換算) | 機械式可修 |
357
+ | 7 | **B4 / B5**(`llama_server.sh` 註解與程式碼矛盾) | 會讓人照著註解去重建,得到行為不同的二進位 |
358
+ | 8 | **D2**(揭露 memkill) | 可重現性 |
359
+
360
+ ## F. 一個可以直接抄的硬體段落模板
361
+
362
+ 見本 repo 的 [`HARDWARE.md`](HARDWARE.md)。原則:
363
+
364
+ 1. **每個數字標明量測指令**,讓別人可以重現。
365
+ 2. **GB 一律寫 `GB (10⁹)`、GiB 一律寫 `GiB (2³⁰)`**,不要混用。
366
+ 3. **「硬限制」和「預算」分開寫**:cgroup `memory.max`、memkill 單行程上限、
367
+ `--ram-budget-mb` 是三件不同的事,必須各自有名稱。
368
+ 4. **「量到的是這個容器的行為」和「裝置的能力」分開寫**:
369
+ overlayfs + EBS 上量到的 2.0 GB/s 是前者。
370
+ 5. **看不到的東西不要推論**:CPU 有 AMX ≠ 推論用到了 AMX;
371
+ 192 個 logical CPU 可見 ≠ 192 個 CPU 的算力。