Module plasticine_report 

The Plasticine report — P4 of the Plasticine lane: the artifact an RDU engineer reads, generated from the model so no number in it is typed by hand.

One row per (workload, target): PCU/PMU used vs total, FU utilization, the initiation interval of every metapipeline stage with the critical stage flagged, the pipeline II, N-buffer depths and PMU counts, hop counts and static-routing occupancy against the Spade link budget, iterations, fill + steady-state cycles, the DRAM roofline (bytes moved, channel bandwidth, the bound), throughput at the II, and for GEMM GFLOPS and % of the published fp32 peak. A counted-loop row also carries its VM anchor (the VM’s answer == the fabric’s == the cycle-timed pipelined run at the modeled II, hazards one cycle below) and, for an ALU-only body, the re-checkable SAT certificate of its routed datapath.

Provenance is modeled on every row: the numbers are the paper-parameterized descriptors’ (PlasticineTarget) under Spatial’s II definition (super::metapipeline), the PMU banking model (super::pmu) and the checkerboard placer (super::plasticine_place). Nothing here ran on a Plasticine simulator or silicon; a Tungsten run lands beside these rows under its own provenance (P5).

benchmarks/silicon/plasticine_report.json is written ONLY by the private place-and-route engine’s report emitter (emit_plasticine_report), which installs the engine’s certified negotiated router before placing anything, and pinned byte-equal by plasticine_report_lock.

Structs

BufferRow

CertificateRow

ChannelRow

One channel’s control plane: the credit solve beside Spatial’s N-buffer rule, and which one binds.

ControlRow

The control plane as a whole: two nets per channel, budgeted on the scalar network.

GemmRow

OperandRow

One operand of a GEMM and how the compiler decided to feed the unrolled instances.

PlasticineArtifact

The placed, certified artifact of one counted loop on a Plasticine target — what largo emit plasticine writes and crate::compile::compile_to_plasticine returns.

StageRow

VmAnchor

Workload

WorkloadRow

One (workload, target) row of the report.

Enums

WorkloadKind

What a workload is.

Constants

CALIBRATION_PATH

The calibration file joining each toolchain row with our MODELED counterpart (generated with the report).

CALIBRATION_TOLERANCE_PCT

The per-cent difference the calibration lock allows between modeled and simulated cycles.

CERTIFICATE_WIDTH

The bit width the routed-datapath certificate is proven at (the bounded fragment).

PROVENANCE_MODELED

The provenance every row carries: a paper-parameterized model, never a simulation or silicon.

PROVENANCE_SIMULATED

The provenance of a toolchain-simulated row.

REPORT_PATH

Where the generated report lives (repo-relative).

TOOLCHAIN_LEDGER_PATH

The public toolchain’s ledger (written only by scripts/accel/plasticine-gate-ledger.py): Tungsten simulations.

UNMODELED_KINDS

The kinds of toolchain row the model has no counterpart for, each with the reason — listed in the calibration as uncalibrated, never dropped and never joined with a model that does not describe them.

Functions

blackscholes_query

The option price of Spatial’s BlackScholes regression app (pir/regression/BlackScholes.scala, BlkSchlsEqEuroNoDiv, with the Taylor approximations of spatial.lang.api.MathAPI its CNDF and the pricing call), transcribed: over the columns prices, strikes, rates, vols, times (Real) and types (Int), read in that order. Spatial’s -x is LOGOS’s 0 - x.

calibration

The calibration document: every toolchain row on a mesh we model, joined with the model, and every row of a kind the model does not describe, or whose routed run did not finish clean, listed as uncalibrated with the reason.

calibration_row

One toolchain row joined with our model: the same app shape, tile (ts) and a single instance (its loop pars are 1), on the same mesh — modeled cycles vs Tungsten’s, the per-cent difference, and the unit counts side by side (PIR’s PCU count includes the control/address units its partitioner splits off; our row counts compute PCUs and perimeter address-generator stages separately — printed, not conflated). A dot product is the 1 × 1 × N GEMM: its ts the K-chunk, its ip the reduce’s lanes, and its op (how many tiles are reduced at once) the GEMM’s loop_kk. Rows of kind: "dot" are modeled as that GEMM.

canonical_targets

The two published configurations.

canonical_workloads

The canonical workloads: the metapipeline corpus, the MoE argmax round, a dot product, and the two GEMM shapes the Tenstorrent ledger measures.

counted_loop_fabric

The counted-loop shape the single-stage metapipeline model takes — the FIRST gate of lower_counted_loop, on its own so a lane can ask the question without placing: fn_name of source as a LoopFabric (a numeric Repeat for i from lo to hi over scalar carried state), or the typed reason it is not one.

gda_query

The covariance step of Spatial’s GDA regression app (pir/regression/GDA.scala), transcribed: over the arrays y (at the row), x (row-major), mu1 and mu0 (at the column), read in that order, the row term x(rr, cc) - mux(y(rr) == 1, mu1(cc), mu0(cc)), each row’s outer product with itself summed into sigma.

gemm_metapipeline

The per-tile GEMM metapipeline on t: load (perimeter AGs: A row-panel + B column-panel, DRAM → PMU) → mac-reduce (a PCU: lanes-wide multiply, the log2(lanes)+1-stage reduction tree, the accumulator fused into its last stage — ISCA’17 §3.1) → store (AG: the C tile). Returns the metapipeline, the words on each edge ([A+B panel, C tile]) and the AG-hosted stage indices.

gemm_row

The GEMM row: the tile (or the PMU-fitting default), the unroll (or the widest that fits AND routes statically; par_capacity records the capacity bound), the placement, and the roofline — compute cycles at the pipeline II vs the DRAM channel bandwidth over the bytes the tiling moves (B column-panels once, A re-streamed per column panel, C once). A GEMM row with mesh replication only — the intra-tile loops run one pass each.

gemm_row_unrolled

intra is the product of the unrolls INSIDE one tile’s chunk (the emitted nest’s row and column loops) and kk the reduction chunks run side by side (loop_kk, a dot product’s op): both divide the work per tile, where par divides the number of column panels — different axes, and the model needs each to reproduce an unrolled program. k_tile is the reduction chunk the operands stream in (Spatial’s ts along K; None streams a tile’s panels whole).

gemm_tile_for

The largest square tile (a multiple of 8, at least 1) whose double-buffered A row-panel + B column-panel (2 · tile · k words) fits ONE PMU on t.

kmeans_distance_query

The distance a feature adds in Spatial’s Kmeans regression app (pir/regression/Kmeans.scala), transcribed: (pts(pt,d) - cts(ct,d)) ** 2 over the point’s feature and the centroid’s, read in that order.

logos_blackscholes_program

Black-Scholes in LOGOS over n options, as Spatial’s BlackScholes app prices them — its Taylor approximations written as LOGOS functions, the six columns declared in the app’s order and filled with residues (types p % 2, the prices, strikes, rates, volatilities and times scaled into ranges the approximations are taken over), every option priced by one counted loop. It shows Σ (t + 1)·out[t], a checksum a permuted or partial result does not reproduce.

logos_dot_program

A canonical LOGOS dot product Σ_{t<n} a[t]·b[t] as the counted loop the tensor recognizer reads.

logos_gda_program

Gaussian discriminant analysis’s covariance in LOGOS over rows samples of cols features — the data filled as Spatial’s GDA app fills it (x row-major i % 256, y i % 256, both means i % 2), each row centred on the mean its label picks and added to sigma as a rank-1 update. It shows Σ (t + 1)·sigma[t], a checksum a transposed or partial covariance does not reproduce.

logos_gemm_program

A canonical LOGOS matmul C[m×n] = A[m×k] · B[k×n] as the triple loop the tensor recognizer reads (the same program the Tenstorrent lane lowers).

logos_kmeans_program

K-means clustering in LOGOS — Lloyd’s algorithm as Spatial’s Kmeans app runs it: n points of f features (row-major, filled q % 97 over the flat index), k centroids starting as the first k points, iters epochs each assigning every point to its nearest centroid by the squared distance (the last of equally near ones, as the app’s accelerator), summing and counting each centroid’s points, and setting every centroid to the integer mean of its points (0 for one with none). It shows Σ (t + 1)·centroids[t], a checksum a permuted or partial result does not reproduce.

logos_outer_program

A canonical LOGOS outer product c[i·cols + j] = a[i]·b[j] (rows × cols) as the nest the tensor recognizer reads; it shows Σ (t + 1)·c[t], a checksum a transposed store does not reproduce.

logos_tpchq6_program

TPC-H Q6 in LOGOS over n records — the four columns filled as Spatial’s TPCHQ6 app fills them (i % 256) and the revenue summed under the query’s predicate.

lower_blackscholes_source

A LOGOS Black-Scholes — the zip map whose term is blackscholes_query — emitted as Spatial’s BlackScholes regression app at the knobs p, with the variant’s PIR arguments (pir_args, what its pirArgs override appends): (n, class name, Spatial source), or a typed reason. The columns are loaded in the order the program declares them, as the app loads its own. The class name carries the length and every knob in Spatial’s parameter order.

lower_counted_loop

Lower the counted loop fn_name of source onto t: one metapipeline stage under the ideal pipelined PCU model, placed on the checkerboard, VM-anchored at params, certified when its body is ALU-only, with Spatial source — or a typed reason it cannot be.

lower_dot_source

A LOGOS dot product, recognized (tensor_recognize::recognize_dot) and emitted as Spatial’s DotProduct regression app at the knobs p: (n, class name, Spatial source), or a typed reason (not a dot product; a tile that does not divide the length; a sum the app’s 32-bit Int would wrap).

lower_gda_source

A LOGOS GDA covariance — the scatter accumulation whose row term and reading axes are gda_query — emitted as Spatial’s GDA regression app at the knobs p: (rows, cols, class name, Spatial source), or a typed reason. The class name carries the shape and every knob in Spatial’s parameter order.

lower_gemm_source

A LOGOS matmul, recognized (tensor_recognize::recognize_matmul) and emitted as Spatial’s GEMM regression app with tiles ts/its and an ip-lane reduce: (m, n, k, class name, Spatial source), or a typed reason (not a matmul; tiles that do not divide the shape).

lower_kmeans_source

A LOGOS k-means clustering — whose distance is kmeans_distance_query — emitted as Spatial’s Kmeans regression app at the knobs p: (n, k, features + 1, epochs, class name, Spatial source) (the app’s N, K, D and runtime I), or a typed reason. The class name carries the shape, the epochs and every knob in Spatial’s parameter order.

lower_outer_source

A LOGOS outer product, recognized (tensor_recognize::recognize_outer) and emitted as Spatial’s OuterProduct regression app at the knobs p: (m, n, class name, Spatial source), or a typed reason. The class name carries the shape and every knob in Spatial’s parameter order (ts1 x ts2, ip x ip1 x ip2, op1 x op2).

lower_tpchq6_source

A LOGOS TPC-H Q6 — the zip sum whose term is tpchq6_query — emitted as Spatial’s TPCHQ6 regression app at the knobs p: (n, class name, Spatial source), or a typed reason.

not_modeled

What the model does NOT cover yet, named with the reason — the honest boundary printed in the report.

plasticine_report

The whole report as JSON — deterministic in the workloads’ and targets’ order. Every workload must lower (a canonical workload the model cannot take is a bug, not a silent omission).

render_report

Pretty JSON with a trailing newline — the exact bytes of REPORT_PATH.

routed_failure

Why row has no modeled counterpart, if its kind is one the model does not describe. Why a toolchain row’s routed (hybrid) simulation is no calibration point: what it came to when it did not finish clean (the recorder’s why: deadlocked, threw, failed its gold check). The model is calibrated against routed cycles, and a routed run that did not finish has none to compare.

target_for_mesh

The descriptor a toolchain row’s rows × cols mesh calibrates against: the 20x20 mesh is PIR’s default in front of Tungsten’s DDR4 memory (PlasticineTarget::tungsten_20x20_ddr4, the system the chain simulates); the 16x8 mesh is the ISCA’17 preset.

tpchq6_query

The query of Spatial’s TPCHQ6 regression app (pir/regression/TPCHQ6.scala), transcribed: over the columns dates, discts, quants, prices (read in that order), the revenue term date > MIN_DATE && date < MAX_DATE && disct >= MIN_DISC && disct <= MAX_DISC && quant < 24 ? price·disct : 0 with its MIN_DATE = 0, MAX_DATE = 9999, MIN_DISC = 0, MAX_DISC = 9999.

unmodeled

workload_row

The row for any workload on t.