A rotating cube is small enough to understand and demanding enough to reveal the shape of a graphics driver. It crosses the shader compiler, buffer management, command submission, rendering and presentation. Once poulscube could make that trip through poulsback on the Dell Inspiron 1210, the next question was where each frame spent its time.
Move the vertices onto SGX535
Earlier development used Mesa’s CPU vertex path while the SGX535 handled rasterization and fragment work. That made it possible to build and inspect the rest of the pipeline. It also left the Atom doing transformations and lighting that belonged on the GPU.
The GPU vertex backend translates Mesa’s NIR shader representation into USSE instructions, the SGX535’s shader instruction set. Vertex and index buffers are read from GPU-accessible buffer objects. A small PDS program supplies the shader inputs, and the geometry hardware handles the viewport and clipping.
For poulscube, profiling after this change showed no samples in Mesa’s vertex interpreter or draw module. Client CPU work was about 1.7 milliseconds per frame in the 300 × 300 test. The saved windowed comparison frames matched the earlier rendering path byte for byte. That result covers these tested programs and captures; the wider vertex feature set still had work ahead.
Follow a frame all the way to X11
Before overlap, the GPU vertex path sent three pieces of work through the GPU in sequence:
| Work | Median time · 300 × 300 cube · November 2, 2026 |
|---|---|
| Vertex processing and tiling | 0.32 ms |
| 3D rasterization | 1.80 ms |
| X11’s 2D copy into the visible front buffer | 1.22 ms |
With the gaps between those stages, the traced schedule accounted for about 3.59 milliseconds. The client and Xorg could already prepare work while the GPU ran. Inside the GPU, the raster stage and the presentation copy were still serialized.
The next change let X11’s 2D copy run during another frame’s 3D raster pass. The kernel keeps separate 2D and 3D scheduler queues, with the ordering rules in one execution engine. Tiling and 2D work still take turns because their address-space requirements share a hardware requester. Raster work can continue while a 2D job uses its own address-space slot.
Two engines share a memory system
The straightforward estimate was optimistic: hide the copy inside the 1.80-millisecond raster stage and most of its cost disappears.
The hardware supplied a more useful answer. With overlap enabled, about 96 percent of the 2D jobs began during raster work. The saved comparison frames still matched. But raster time rose to 2.27 milliseconds, and the copy took 1.79 milliseconds. The two engines compete for shared resources.
Even with that contention, the traced frame period fell to about 2.71 milliseconds. The next frame’s tiling began roughly 0.10 milliseconds after the preceding 3D job finished. Overlap improved throughput and exposed the next limit at the same time.
Repeating the experiment with the ondemand CPU governor used for the
legacy reference measurements gave a result close to the earlier
schedutil run. These workloads were limited by the GPU schedule rather
than a slower CPU frequency decision.
Keep the result attached to the experiment
The poulscube and glxgears entries keep the hardware captures and measurement conditions beside their selected results. Captures read the real GPU back buffer with a deterministic clock; timed samples advance normally, with vertical synchronization disabled.
A high swap rate describes how quickly this workload advances; the panel’s refresh rate still limits how many complete frames it can show. Correctness checks and broader API coverage answer other questions.
The next work is to extend that coverage and improve throughput while preserving the images. This experiment already established something useful: looking beyond shader speed to the complete render-and-present schedule can find substantial progress on a very small GPU.
The later mipmap development note follows another dependency chain: one GPU pass produces the texture level that the next pass must sample, while preserving the application’s state.