File size: 10,736 Bytes
42db578 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 | # BitState / HSDR PoC Technical Brief — v0.5
Status: experimental engineering proposal, not a performance claim.
Primary target: low-bit / ternary LLM GEMV, batch-1 decode first.
Suggested first integration target: PrismML llama.cpp fork / Bonsai 2, CPU first.
## 1. Core hypothesis: move reduction into the state domain
BitState/HSDR v0.5 centers the PoC on one implementation question:
> **Move the reduction into the state domain to break the serial arithmetic reduction dependency.**
A conventional accumulator lets every new add depend on the previous partial sum. BitState instead:
1. represents activation/weight products as final LNS8-like `S1|E4|L3` states using integer ADD/XOR;
2. routes each product by `L3` toward one of eight phase aggregates;
3. uses `±(1<<E4)` as the exact dyadic payload for the direct baseline;
4. optionally constructs wide state-set masks / POPCOUNT histograms to reduce many lanes in parallel;
5. reduces only the resulting eight dyadic accumulators or compressed non-zero state set;
6. optionally keeps the population path entirely in fractional-LNS form.
The performance question is now split cleanly: **can K product states be reduced to eight phase aggregates cheaply enough on ordinary CPU/GPU integer/bit hardware?** POPCOUNT is one candidate mechanism, not a mandatory primitive for the direct eight-accumulator path.
## 2. Why Bonsai 2 is a useful first target
Bonsai 2 provides a clean ternary test case:
- weights are ternary: `{-1,0,+1}`;
- PQ2_0 and PTQ1_0 use 128-weight groups with a shared scale;
- the runtime already has a model-specific Hadamard/sign-transform contract;
- one activation tile is reused across many output rows in GEMV;
- the PoC does not require a new GGUF / ggml type.
PQ2_0 or pre-decoded ternary masks are preferred for the first CPU microbenchmark so the BitState cost can be separated from PTQ1_0 dense base-3 unpacking.
References:
- https://github.com/PrismML-Eng/Bonsai-demo
- https://github.com/PrismML-Eng/Bonsai-demo/blob/main/MODEL-FORMATS.md
- https://github.com/PrismML-Eng/llama.cpp
## 3. LNS8 state used by the PoC
```text
code 0 = exact zero
code 1..127 = non-zero magnitude
sign = separate
|x| = 2^((code - 74)/8)
8 codes = exactly x2
code 74 = 1.0
```
For non-zero `k`:
```text
phase = k & 7 // 0..7
band = k >> 3 // 0..15
```
and
```text
|x| = 2^-9 * 2^band * F[phase]
F[p] = 2^((p - 2)/8)
```
The exact power-of-two band axis is what permits cheap relative positioning; only eight phase states remain inside one octave.
## 3.1 Preferred dyadic correctness baseline: direct eight-phase accumulation
After all log-domain terms belonging to a product have been applied, interpret the final product as:
```text
S1 | E4 | L3
```
and reduce each lane as:
```text
phase = L3
payload = sign * (1 << E4)
A[phase] += payload
```
For one GEMV/GEMM output dot, all `K` products (including realistic `K=4096` / `5120`) reduce to only eight signed integer accumulators. Final materialization is:
```text
S = 2^-9 * sum_p A[p] * F[p]
F[p] = 2^((p-2)/8)
```
This is algebraically identical to building `H[phase][band]` first and then computing `A[p] = sum_b H[p][b] << b`.
The correctness reference is the procedure used in `LNS8_base74_8step_zone8_popcount_demo_JA_v0.8_bitslice128_validation.xlsx`: `Inputs_128` is treated as two Tile64 blocks, `L3` creates phase selector masks, `E4` supplies the power-of-two payload, and S1 supplies the sign. Phase masks are intermediate routing values, not final populations.
POPCOUNT is therefore **optional** for the direct dyadic path. It remains a separate implementation candidate when explicit state populations provide a cheaper dependency-breaking reduction.
## 4. Ternary state-domain population reduction
For a 128-weight group:
```text
w_i = d * t_i
t_i in {-1,0,+1}
```
For the factorized ternary variant, the shared scale `d` may remain outside the population reduction. In the generic product-state reference, any scale/log offset that is intended to change the routed product code must be applied before `L3/E4` decomposition. These are separate variants and must not be mixed. Represent each ternary row with:
```text
W_nonzero
W_negative
```
For activation magnitude state `s`:
```text
A_s = lanes with activation magnitude state s
M = A_s & W_nonzero
PNEG = activation_sign XOR W_negative
N = popcount(M)
Nneg = popcount(M & PNEG)
C_s = N - 2*Nneg
```
`C_s` is the signed population of state `s` after ternary selection. The wide masks and POPCOUNTs are independent across active states, which is the dependency-breaking step.
## 5. Two post-POPCOUNT paths
### 5.1 Dyadic reference path
Keep the existing exact/algebraically simple baseline:
```text
signed state histogram
-> per-phase integer shift/add
-> wide fixed-point
-> optional Q9.6
-> scale
-> optional LNS8 re-encode
```
This path is essential for correctness comparison and may itself be competitive.
### 5.2 Pure fractional-LNS candidate
A stronger v0.5 candidate is to avoid a linear accumulator entirely on the population path.
For signed state population `C[k] != 0`, fold repeated identical states first:
```text
bucket_sign = sign(C[k])
bucket_lambda = k + 8*log2(abs(C[k]))
```
For Tile128, `abs(C[k])` is only `1..128`, so the population correction can be a tiny LUT.
The eight phase tables may be normalized around anchor codes `120..127`; code 122 is the exact value 64. The identity
```text
k = 8*band + phase
= (120 + phase) + 8*(band - 15)
```
means band movement is only an integer code offset. The internal coordinate retains fractional code bits; it is not forced back to 8-bit LNS after each add.
Pairwise same-sign add for `a >= b`, `diff=a-b`:
```text
out = a + kappa_plus(diff)
kappa_plus(diff) = 8*log2(1 + 2^(-diff/8))
```
Opposite sign, `diff > 0`:
```text
out = a + kappa_minus(diff)
kappa_minus(diff) = 8*log2(1 - 2^(-diff/8))
```
Equal opposite magnitudes cancel to exact zero. Runtime uses small correction LUTs rather than general log/pow functions.
After each phase is compressed, reduce the eight phase aggregates as a balanced tree:
```text
8 -> 4 -> 2 -> 1
```
This gives only three dependent LNS-add stages for the final eight-state reduction. The same balanced primitive can be used within a phase when multiple octave buckets remain.
A positive shared scale can remain in the log domain:
```text
lambda_scaled = lambda_sum + 8*log2(d)
```
so the pure path can stay logarithmic until the final LNS8 boundary.
## 6. Critical implementation rule: reuse activation state sets
For batch-1 GEMV, the activation tile is common to many weight rows. Separate fixed and repeated costs:
```text
activation encode / state-set construction // once per activation tile
weight-row mask intersection + POPCOUNT // repeated per row
compressed-state reduction // repeated per row/group
```
Useful reuse sweep:
```text
N = 1, 8, 32, 128, 512, 2048+
```
Report the crossover instead of assuming it.
## 7. Minimal PoC sequence
### Phase A — standalone correctness
Implement:
- FP64 direct ternary dot;
- exact LNS8 decode reference;
- scalar direct eight-phase accumulation `A[L3] += ±(1<<E4)`;
- Tile64×2 reference matching the Excel v0.8 128-input procedure;
- signed POPCOUNT histogram;
- histogram-to-`A[0..7]` equivalence;
- dyadic final materialization;
- fractional-LNS pair add/sub reference;
- count-to-log folding for `n=1..128`;
- balanced pure-LNS reduction at several internal fractional precisions.
`direct decode == direct A[8] == histogram-derived A[8]` must be exact. Pure-LNS rounding error is a separate measurement.
### Phase B — synthetic CPU microbenchmark
Compare:
1. direct decoded ternary dot;
2. scalar/direct eight-phase routed accumulator;
3. Tile64 phase-mask + direct eight-accumulator reduction;
4. signed histogram + dyadic reconstruction;
5. signed histogram + pure fractional-LNS reduction.
Sweep state cardinality, ternary zero density, output-row reuse, `K`, and internal LNS precision.
### Phase C — fork integration
First integrated target:
- CPU;
- batch 1;
- one ternary vec-dot / GEMV path;
- post-Hadamard activation domain;
- PQ2_0 first if implementation simplicity matters.
### Phase D — end to end
Measure TG128, decode latency, state-set build cost, POPCOUNT cost, dependent reduction depth, memory traffic, cycles/output, and quality delta from activation LNS8 encoding.
## 8. State-set implementation candidates
- direct eight-phase selector masks from `L2,L1,L0`;
- sparse `(state_id, lane_mask)` pairs for only active states;
- phase-local masks;
- SWAR / AVX2 byte-lane extraction + scalar POPCNT;
- AVX-512 mask/VPOPCNT where available;
- GPU ballot / match-any rather than literal CPU bit transpose.
Record unique states per tile for histogram variants, but also report the direct-path cost separately: product-state generation, phase-mask construction, K→8 weighted reduction, and final eight-phase materialization.
## 9. Metrics that matter
CPU:
- ns / 128-weight group;
- cycles / output row and / weight;
- uops / IPC;
- state-set build cycles;
- POPCNT throughput;
- non-zero state buckets;
- fractional-LNS LUT accesses;
- dependent reduction depth / critical-path LNS stages;
- L1/L2 misses and memory bandwidth;
- reuse crossover vs baseline.
Correctness/quality:
- state histogram exactness;
- pure-LNS error vs FP64 by internal fractional precision;
- cancellation cases;
- LNS8 saturation / underflow;
- model quality / perplexity or task checks.
## 10. Falsification criteria
The PoC should be allowed to fail cleanly. Redesign or stop if:
- state-set construction cannot be amortized;
- real activations have too many unique states;
- mask/POPCOUNT work exceeds the existing ternary path;
- pure-LNS LUT/add stages recreate a long critical path;
- required fractional precision makes the path too expensive;
- activation LNS8 quality loss is unacceptable;
- conversion/scale handling cancels the compute saving.
A negative result is useful if the limiting term is isolated.
## 11. What this PoC is not claiming
- not a new GGUF type;
- not a replacement for all GEMM/GEMV kernels;
- not a claim that POPCOUNT always beats SIMD/Tensor Core MAC;
- not a claim of research novelty;
- not a requirement to use Q9.6 internally;
- not a claim that pure-LNS will necessarily beat the dyadic reference path.
The narrow question is whether **state-domain dependency breaking plus population reduction** has a competitive region in real low-bit / ternary decode workloads, and whether a pure fractional-LNS final reduction improves that region.
|