Obsvra

Performance · verified 2026-09-05

Real numbers, on real hardware.

Every number below came from a real run — Grind on real hardware, JDK 25, nothing extrapolated. The model is downloadable from the Free tier, so you don’t have to take our word for any of it.

1.38Brows / hour

Fastest measured — c7i-flex.large, Linux. Your number depends on your model and your hardware; see the full table.

Baseline model
SixStatsdnd-ability-scores.xml
Nodes
6
Tier
Free
Machines tested
10AWS + local

1,000,000 observations per run, timed end-to-end, real seed logged per run. No caching, no batching tricks — --out /dev/null so disk I/O never enters the number.

01

Throughput by instance

The same SixStats model — six ability scores, rolled the old-school way (3d6, no rerolls) — run to completion a million times on each of six real EC2 instance types, on both Linux and Windows where Windows exists for that architecture.

InstanceArchLinux rows/hrWindows rows/hr
t4g.microARM510,350,400—
t4g.smallARM544,053,600—
t3.microx86628,272,000431,604,000
t3.smallx86705,189,600526,082,400
c7i-flex.largex861,381,957,200987,926,400
m7i-flex.largex861,381,957,2001,127,466,000

c7i-flex.large and m7i-flex.large reported the same Linux rows per hour. That may look suspicious, but it’s due to how the results were rounded to the nearest millisecond before calculating rows per hour. Running 10M rows instead of 1M showed an actual separation (1,795,063,575 for c7i-flex.large and 1,801,531,302 for m7i-flex.large) and shows that performance continues to improve over larger data sets as the initial startup overhead attenuates and the JVM optimizations take over. The two blank cells aren’t missing data — AWS doesn’t offer a Windows AMI for ARM at all. Windows ran ~25–30% slower than Linux on identical hardware in every apples-to-apples pair above; we don’t have a tidy explanation beyond “it’s Windows.”

02

Not every model runs at this speed

SixStats is a small model — six nodes, no custom components. A model’s real cost tracks its complexity score (a structural estimate SpiceGrinder computes from your model file), but not perfectly linearly. These are six real models, actually run — not a fitted line.

Throughput against model complexityLog-log scatter of rows per hour against complexity score for six models on three EC2 instance types. Throughput falls roughly ten to twelve times across an eighteen-fold rise in complexity. The same figures are in the table below.50100200400700100K300K1M3MComplexity scoreRows per hour
  • t4g.micro (ARM)
  • t3.micro (x86)
  • c7i-flex.large (x86)
Rows per hour by complexity score and instance type
Complexity scoret4g.micro (ARM)t3.micro (x86)c7i-flex.large (x86)
361,420,0001,670,0003,060,000
38939,000909,0001,930,000
164370,000441,000827,000
380162,000200,000378,000
447148,000221,000465,000
698110,000119,000196,000

Both axes are log-scaled — an 18x jump in complexity score (36 to 698) costs roughly 10-12x the throughput, not 18x, and not a flat multiple either: notice small-5node (score 38) sitting closer to the expensive end than its score alone would suggest. We continue to evolve our formula for computing complexity, so we are researching why — a shallow, wide model apparently isn’t “cheap” in quite the way the complexity formula currently models.

03

How this was measured

Method

Real Grind --performance CLI runs, JDK 25, wall-clock timed. Same tool you’d run yourself.

Sample size

1,000,000 observations per data point — long enough that JVM warm-up and millisecond-rounding noise wash out. Verified directly before trusting any of these numbers.

Hardware

6 AWS EC2 instance types (ARM/Graviton + x86, burstable + compute-flex families), plus a MacBook Pro and a Ryzen desktop for the complexity-score calibration behind section 02. A range of moderate hardware.

Reproduce it

The exact model file is below. Free tier, no signup — grind --count 1000000 dnd-ability-scores.xml and you can time it yourself on your own system.

04

The actual model

This is the whole file — nothing trimmed. Six built-in Free-tier components, no custom code: a die roll, floored to an integer, bundled three at a time, summed, and bundled again into six ability scores. (Complexity notes: while the model only has six nodes, all six are hit on each row produced [no branching], which increases its complexity beyond what a simple node count would imply; however, most of the nodes are relatively cheap in individual cost [Calculate is the outlier], which drives the overall complexity score lower.)

dnd-ability-scores.xmlFree tierDownload
<!-- Uniform[1,7) -> ToInteger(floor) -> d6. Redimension(3) bundles three rolls,
     Calculate sums them, Drop keeps just the sum, Redimension(6) bundles
     six stat-sums into one character's ability scores. -->
<dataset>
	<root node="SixStats"/>
	<nodes>
		<Uniform name="Die" min="1" max="7"/>

		<ToInteger name="D6" mode="floor">
			<input name="Die"/>
		</ToInteger>

		<Redimension name="ThreeDice" dimension="3">
			<input name="D6"/>
		</Redimension>

		<Calculate name="Sum" expression="y[0] = x[0] + x[1] + x[2]">
			<input name="ThreeDice"/>
		</Calculate>

		<Drop name="DropCopies" excludes="1,2">
			<input name="Sum"/>
		</Drop>

		<Redimension name="SixStats" dimension="6">
			<input name="DropCopies"/>
		</Redimension>
	</nodes>
</dataset>

SpiceGrinder benchmarks

Run your own numbers

Free tier is unlimited generation, forever, on your own hardware. No signup, no time limit.

Get SpiceGrinder Free