Faciens Technologies · Quester GX-1

Background to Quester GX-1

Three tools that explain the ideas behind the Quester GX-1 GPU architecture. The first shows Quester’s workload geometry and runs its design logic on a workload you build. The other two are standard calculations, with Quester’s targets alongside today’s GPUs. Everything runs in your browser.

Workload geometry

Quester describes every stage of a computation by four features. Each feature has two sides, so there are sixteen characters, the corners of a four-dimensional cube drawn below. Pick the work you want one piece of hardware to run and see what sharing it costs.

Add work

Common stages
Or describe your own
Selected

The character cube

selectedResist: opposed on 3 or 4 featuresneighbours differ in one feature

Tap a corner to add or remove it.

OrganisationElementsEnergy per operationArea per unit of throughput

Costs are averages over the selected characters, each relative to running on hardware built only for it (×1.00). They come from an independent component cost model at 45 nm, built separately from the geometry: an analytical model, about half of whose coefficients are estimates. Not a measurement of silicon.

Design an organisation with Quester’s logic

Build a small workload. Quester’s generator then tries every way of grouping its characters into hardware elements, checks each one against the OCL design conditions, and picks the fastest that passes.

StageCharacterTime slotWorkSends output to
Up to six stages. Stages in the same time slot run together. Work is in any consistent unit.

Chosen organisation
ElementServesFeatures in disagreementArea share
OCL checks on the chosen organisation
ConditionInstanceHoldsBecause
On the cube, coloured by element
Fastest organisations that pass
GroupingElementsSpeed

Speed is against one general-purpose element of the same total area.

Conditions follow the Quester specification: Service (every active stage is grounded in an element that holds its character) and Reach (a stage and the stage it feeds sit on one element or are joined by a link) are required; Exclusive is optional. Time uses the demonstrator’s compute model: each element gets a share of the area in proportion to its heaviest or its total work, and runs faster the narrower it is, by (1 + 4g) / (1 + g·j), where j counts its features in disagreement. The default g = 0.5 is the value fitted to the independent cost model’s area figures. Memory traffic is not modelled here; the full demonstrator models it.

GPU limit calculator

A task is limited either by arithmetic or by how fast data arrives from memory. Enter how much of each it needs and see which limit binds on each GPU, and how fast it runs.

Numbers accept forms like 1.1e12. Bytes are those that must come from the GPU’s main memory, not from on-chip caches.

Time on each GPU

GPUPeak at this formatTimeLimited byOf peak

Roofline

Each line is the most a GPU can deliver at a given ratio of arithmetic to memory traffic: rising while memory limits it, flat once arithmetic does. The dashed line is your task.

Number-format picker

Narrower numbers run much faster, but every operation rounds. Describe the calculation and the accuracy it needs, and see the narrowest format that is guaranteed to deliver it.

Guaranteed error by format

FormatBitsWorst-case errorVerdict

What the choice is worth

GPUPeak at chosen formatTimes its FP64 peak

Worst-case bound γk·κ, with γk = k·u / (1 − k·u), u the format’s unit roundoff and k the number of additions (or the depth of the tree plus one). It is a guarantee, so formats that often work in practice can fail it. FP8 here is E4M3; FP4 is NVFP4.