Corerope

Invention 2

Wired-weight ternary silicon

The design / Invention 2

In wired-weight silicon a weight is not a number in memory but a connection: each input wire feeds an adder tree's plus input, its minus input, or nothing. No weight is ever fetched, and no multiplier exists. A synthesis test found wired ternary needs ~30 gates per weight against ~75 for wired 4-bit, and sharing partial sums cuts that a further 1.6x at 256 output rows.

The test generated hardwired matrix-vector layers with random weights as Verilog and synthesized them with Yosys 0.71 into generic gates:

Design (8-bit activations unless noted)Gates per weight
Stored-weight 4-bit MAC, the GPU-style unit, per operation435, plus the weight fetch
Wired 4-bit weights, 32 x 32 layer75.0
Wired ternary, 32 x 32 layer (40% zeros)30.8
Wired ternary, 4-bit activations20.0
Wired ternary, 48 x 256, direct26.1
Wired ternary, 48 x 256, shared partial sums (groups of 4)16.1

Gate counts are a proxy for switching energy, not a measurement of it. They exclude wire capacitance, which dominates in fully spatial designs, and they come from Yosys without ABC logic optimization (the WebAssembly build's ABC step did not run), so absolute numbers are high but the ratios are like for like.

Wired ternary needs about 30 gates per weight; wired 4-bit about 75, a stored-weight MAC 435

Generic gates per weight after synthesis, for hardwired matrix-vector layers with random weights (8-bit activations unless noted). Fewer gates means less switching.

Stored-weight 4-bit MAC, the GPU-style unit, per operationplus the weight fetch
435
Wired 4-bit weights, 32 x 32 layer
75.0
Wired ternary, 32 x 32 layer (40% zeros)
30.8
Wired ternary, 4-bit activations
20.0
Wired ternary, 48 x 256, direct
26.1
Wired ternary, 48 x 256, shared partial sums (groups of 4)
16.1
  • Stored weights (GPU-style)
  • Wired 4-bit weights
  • Wired ternary weights

A proxy for switching energy, not a measurement of it: wire capacitance is left out, and Yosys ran without ABC optimization, so absolute counts are high but the ratios are like for like. Re-run for this site with Yosys 0.71: 15 of 15 cell counts match the recorded ones.

Show the numbers
Every synthesized design
DesignLayerActivation bitsGroupCells (re-run)Cells (recorded)Gates per weight
Wired ternary, direct48 x 25681320,496320,49626.1
Wired ternary, direct48 x 648186,17786,17728.1
Wired 4-bit weights32 x 32450,07150,07148.9
Wired 4-bit weights32 x 32876,77676,77675.0
Stored-weight 4-bit MAC, per operation1 x 14315315315.0
Stored-weight 4-bit MAC, per operation1 x 18435435435.0
Wired ternary, shared partial sums48 x 25683217,214217,21417.7
Wired ternary, shared partial sums48 x 25684198,169198,16916.1
Wired ternary, shared partial sums48 x 25686224,306224,30618.3
Wired ternary, shared partial sums48 x 648361,81661,81620.1
Wired ternary, shared partial sums48 x 648461,71561,71520.1
Wired ternary, shared partial sums48 x 648673,89573,89524.1
Wired ternary32 x 32420,47720,47720.0
Wired ternary32 x 32831,53531,53530.8
Wired ternary64 x 648120,218120,21829.4

Shared partial-sum wiring (SPW) is the new trick. With fixed weights, every signed combination of a small input group, such as x1 minus x3 plus x4, can be built once and tapped by every output row that needs it. An add-count model puts the saving at 2.4x for groups of 4 and 2.8x for groups of 5 to 6 at a 4096 x 4096 layer, rising with layer width. CPU kernels already exploit lookup tables of this kind (T-MAC style); building it as fixed wiring is the new part.

Sharing partial sums saves more as layers get wider: up to 2.9x fewer adds

Adds for a hardwired ternary layer when every signed combination of a group of g inputs is built once and shared by every output row, against adding each row's inputs directly.

  • 48 x 64 layer
  • 48 x 256 layer
  • 1,024 x 1,024 layer
  • 4,096 x 4,096 layer

An add-count model, not a synthesis: random ternary weights with 40% zeros. Re-run for this site: every ratio matches the recorded output.

Show the numbers
Saving by layer and group size
Layerg = 1g = 3g = 4g = 5g = 6g = 7g = 8
48 x 641.00x1.60x1.42x1.24x1.06x1.19x1.01x
48 x 2561.00x1.86x2.02x1.71x1.27x1.24x1.03x
1,024 x 1,0241.00x1.90x2.31x2.38x1.86x1.35x1.12x
4,096 x 4,0961.00x1.92x2.42x2.84x2.85x2.19xnot run

Three more pieces complete the chip.

  • Event-driven sparsity. A zero activation holds its wires still, so nothing downstream switches. On GPUs, activation sparsity barely helps at serving batch; here dynamic energy falls with every zero. The model credits 2x centrally (TurboSparse-style training reaches ~90% sparsity).
  • Multi-stream pipelining. Every layer has its own silicon, so tokens from thousands of users flow through layer by layer. Throughput is set by power and by per-user state bandwidth, not by weight bandwidth: about 1M tokens per second per 1 kW set in the central case.
  • A via-programmed fabric. The precomputed group sums are generic: at full width almost every combination is used, so the sum wiring is fixed. Each row input then chooses one sum wire with a single via. A new model becomes one via mask (structured-ASIC style, and Taalas already respins only two masks per model), cutting per-model NRE from ~$40M to an assumed ~$3M.

The energy assumption to test. The model assumes 0.1 pJ per weight-operation including wiring (range 0.03 to 0.3). For comparison, Taalas HC1 implies roughly 2 pJ per parameter per token for Llama-3.1-8B at 4 bits (250 W at ~16,000 tok/s, derived). The 20x gap rests on ternary (2.4x), shared sums (~2.5x), event-driven sparsity (~2x) and lower static power; it must be shown in post-layout simulation before anyone believes it. Area is the cost: 12B weights at ~12 gates each is ~1.5 x 1011 gates, several reticle-size dies or a wafer-scale part.

What one weight costs per token, from fetching it to wiring it

Energy per weight per token. The hollow dot is an assumption, not a measurement: experiment 1 tests it.

H100: read one 8-bit weight from HBMmeasured coefficient
H100: the 2 FLOPs that weight feedsmeasured coefficient
Taalas HC1: hardwired 4-bit, per parameterderived from vendor and EE Times figures
Corerope: wired ternary, shared sums (assumed)assumption to test (experiment 1)
Picojoules per weight per token (log scale)
Show the numbers
Energy per weight per token
StepPicojoulesWhat it is
H100: read one 8-bit weight from HBM93.4measured coefficient
H100: the 2 FLOPs that weight feeds1.04measured coefficient
Taalas HC1: hardwired 4-bit, per parameter1.95derived from vendor and EE Times figures
Corerope: wired ternary, shared sums (assumed)0.1 (0.03 to 0.3)assumption to test (experiment 1)

The experiment that would falsify it

Experiment 1

Post-layout energy of a 1024 x 1024 wired ternary tile with shared sums, driven by real activation traces, in a 5nm-class flow

Tests
Invention 2's 0.1 pJ per weight-operation
Pass bar
At most 0.15 pJ including wiring and leakage
If it fails
Above 0.5 pJ, wired silicon is only a speed play, as Taalas's cost figures suggest; drop to stored-weight ASICs

Experiment 4

Native ternary training at 3 to 8B with dReLU-style activation sparsity

Tests
Event-driven gain and the precision penalty
Pass bar
Within 1.5% loss of FP8 at equal compute, at least 70% zero activations, under 1.2x longer reasoning
If it fails
Fall back to 2 to 3-bit wired weights at ~2x the gates

Experiment 7

Via-programmed fabric: foundry quote and a routing study for choosing 1 of ~40 sum wires per input with one via layer

Tests
The $3M NRE assumption
Pass bar
One-layer customization at under 2x area
If it fails
NRE returns to ~$40M; dollars fall back to ~90x per task