benchmark: matmul/quicksort 改用 compact 形式，移除 _compact 目录

benchmark/cases/matmul/matmul.kv

@@ -1,31 +1,30 @@
-// matrix multiplication benchmark — 稠密方阵乘（浮点运算 + 三重循环）
-// A/B 元素取 0.25 倍数（二进制精确），C 校验和 × 1e6 恒为精确整数、跨语言逐字节一致
+// matrix multiplication benchmark（compact 形式）— 同 matmul 算法，矩阵落**单个 compact XValue**
+// （`[N,N]float64`，storetype=ARRAYND，元素连续打包），而非散 key 的 `[int64]·float64` map。
+// 对比点：同一算法的两种 kv 物理形态——map 每次元素访问一次 KV 往返，compact 一次 xv·at/set。
 // 方阵阶 N 由 __SCALE__ 占位（O(N^3)，勿改逻辑）
 // 期望输出（N=6 时）:
-//   matmul: check = 82750000
+//   matmul_compact: check = 82750000
 rwfunc test() -> () {
 	__SCALE__ -> n
-	A:[int64]·float64 = {}
-	B:[int64]·float64 = {}
+	A:[__SCALE__,__SCALE__]float64 = []
+	B:[__SCALE__,__SCALE__]float64 = []
 	0 -> i
 	while (i < n) {
 		0 -> j
 		while (j < n) {
-			i × n -> base
-			base + j -> idx
 			i + j -> ta
 			ta % 4 -> qa
 			float64(qa) -> qaf
 			qaf × 0.25 -> pa
 			pa + 0.25 -> av
-			av -> A·*idx
+			av -> A[i, j]
 			i × 2 -> i2
 			i2 + j -> tb
 			tb % 4 -> qb
 			float64(qb) -> qbf
 			qbf × 0.25 -> pb
 			pb + 0.25 -> bv
-			bv -> B·*idx
+			bv -> B[i, j]
 			j + 1 -> j
 		}
 		i + 1 -> i
@@ -39,12 +38,8 @@ rwfunc test() -> () {
 			0.0 -> acc
 			0 -> k
 			while (k < n) {
-				i × n -> ba
-				ba + k -> ia
-				kv·get(A, ia) -> av
-				k × n -> bb
-				bb + j -> ib
-				kv·get(B, ib) -> bv
+				A[i, k] -> av
+				B[k, j] -> bv
 				av × bv -> pr
 				acc + pr -> acc
 				k + 1 -> k
@@ -57,7 +52,7 @@ rwfunc test() -> () {
 	t1 = time·now()
 	checksum × 1000000.0 -> scaled
 	int64(scaled) -> out
-	println("matmul: check =", out)
+	println("matmul_compact: check =", out)
 	delta = time·sub(t1, t0)
 	ns = time/duration·as_nanos(delta)
 	println("__bench_ns:", ns)

benchmark/cases/quicksort/quicksort.kv

@@ -1,64 +1,67 @@
-// quicksort benchmark — 迭代 Lomuto 分区就地排序（数组访问 + 显式栈递归）
+// quicksort benchmark（compact 形式）— 同 quicksort 算法，待排数组与显式栈都落**单个 compact
+// XValue**（`[N]int64`，storetype=ARRAYND），而非散 key 的 `[int64]·int64` map。
+// 对比点：同一算法的两种 kv 物理形态。
 // 数据由 LCG 确定生成，规模 N 由 __SCALE__ 占位，run.py 按扫描点替换（勿改逻辑）
 // 期望输出（N=64 时）:
-//   qsort: a0 = 1 amid = 52 alast = 99
+//   qsort_compact: a0 = 1 amid = 52 alast = 99
 rwfunc test() -> () {
 	__SCALE__ -> n
-	arr:[int64]·int64 = {}
+	arr:[__SCALE__]int64 = []
 	1 -> seed
 	0 -> i
 	while (i < n) {
 		seed × 1103515245 -> s1
 		s1 + 12345 -> s2
 		s2 % 2147483648 -> seed
 		seed % 100 -> v
-		v -> arr·*i
+		v -> arr[i]
 		i + 1 -> i
 	}
 	t0 = time·now()
-	st_lo:[int64]·int64 = {}
-	st_hi:[int64]·int64 = {}
+	// 显式栈也用 compact：与待排数组一样落单个 ARRAYND XValue，全程只在 compact 数组里直接交换。
+	st_lo:[__SCALE__]int64 = []
+	st_hi:[__SCALE__]int64 = []
 	0 -> top
-	0 -> st_lo·*top
-	n - 1 -> st_hi·*top
+	0 -> st_lo[top]
+	n - 1 -> st_hi[top]
 	top + 1 -> top
 	while (top > 0) {
 		top - 1 -> top
-		kv·get(st_lo, top) -> lo
-		kv·get(st_hi, top) -> hi
+		st_lo[top] -> lo
+		st_hi[top] -> hi
 		if (lo < hi) {
-			kv·get(arr, hi) -> pivot
+			arr[hi] -> pivot
 			lo - 1 -> ii
 			lo -> jj
 			while (jj < hi) {
-				kv·get(arr, jj) -> aj
+				arr[jj] -> aj
 				if (aj <= pivot) {
 					ii + 1 -> ii
-					kv·get(arr, ii) -> ai
-					aj -> arr·*ii
-					ai -> arr·*jj
+					arr[ii] -> ai
+					aj -> arr[ii]
+					ai -> arr[jj]
 				}
 				jj + 1 -> jj
 			}
 			ii + 1 -> pp
-			kv·get(arr, pp) -> app
-			pivot -> arr·*pp
-			app -> arr·*hi
-			lo -> st_lo·*top
-			pp - 1 -> st_hi·*top
+			arr[pp] -> app
+			pivot -> arr[pp]
+			app -> arr[hi]
+			lo -> st_lo[top]
+			pp - 1 -> st_hi[top]
 			top + 1 -> top
-			pp + 1 -> st_lo·*top
-			hi -> st_hi·*top
+			pp + 1 -> st_lo[top]
+			hi -> st_hi[top]
 			top + 1 -> top
 		}
 	}
 	t1 = time·now()
 	n ÷ 2 -> mid
 	n - 1 -> last
-	kv·get(arr, 0) -> a0
-	kv·get(arr, mid) -> am
-	kv·get(arr, last) -> al
-	println("qsort: a0 =", a0, "amid =", am, "alast =", al)
+	arr[0] -> a0
+	arr[mid] -> am
+	arr[last] -> al
+	println("qsort_compact: a0 =", a0, "amid =", am, "alast =", al)
 	delta = time·sub(t1, t0)
 	ns = time/duration·as_nanos(delta)
 	println("__bench_ns:", ns)