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.
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.
Tap a corner to add or remove it.
| Organisation | Elements | Energy per operation | Area 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.
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.
| Stage | Character | Time slot | Work | Sends output to |
|---|
| Element | Serves | Features in disagreement | Area share |
|---|
| Condition | Instance | Holds | Because |
|---|
| Grouping | Elements | Speed |
|---|
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.
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.
| GPU | Peak at this format | Time | Limited by | Of peak |
|---|
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.
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.
| Format | Bits | Worst-case error | Verdict |
|---|
| GPU | Peak at chosen format | Times 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.