DirectX 12 vs DirectX 11: Draw Calls Per Second

This article explores the substantial difference in draw call throughput between DirectX 11 and DirectX 12. While DirectX 11 suffers from architectural bottlenecks that limit CPU-to-GPU command generation to a single thread, DirectX 12 re-engineers this pipeline to allow parallel command list generation across multiple CPU cores. By comparing their maximum dispatch capacities, this guide illustrates how API-level design changes directly impact the volume of draw calls a modern engine can achieve.

In a well-optimized DirectX 11 pipeline, the application is fundamentally constrained by a single-threaded immediate context. Even on high-end hardware, a standard DirectX 11 implementation tops out between 5,000 and 10,000 draw calls per frame at 60 frames per second, which equates to roughly 300,000 to 600,000 draw calls per second. Highly tuned synthetic microbenchmarks can occasionally push this number toward 1,000,000 to 2,000,000 draw calls per second, but the single-core CPU driver bottleneck prevents scaling beyond that ceiling regardless of available processor cores.

In contrast, a well-optimized DirectX 12 engine can dispatch between 20,000,000 and over 50,000,000 draw calls per second on modern multi-core processors. In synthetic environments such as the 3DMark API Overhead Feature Test, multi-threaded DirectX 12 implementations routinely achieve 30,000,000 to 60,000,000 draw calls per second on contemporary 8-core and 16-core CPUs.

The primary factors enabling this 10x to 50x increase include:

• Multi-Threaded Command Recording: Unlike DirectX 11's deferred contexts, which had significant driver-side overhead, DirectX 12 allows multiple CPU threads to record graphics commands into independent command lists simultaneously with virtually zero lock contention.
• Pre-Baked Pipeline State Objects (PSOs): DirectX 11 compiles shaders and state states dynamically at runtime, causing driver stalls. DirectX 12 moves PSO compilation to initialization time, reducing the per-draw CPU overhead down to simple memory address binding.
• Direct Hardware Queues: DirectX 12 bypasses the operating system's heavy driver validation layer during the draw execution phase, submitting large bundles of pre-recorded command lists directly to the GPU's command processor.

While synthetic tests demonstrate throughput exceeding 50 million calls per second, production game engines rarely consume this full theoretical limit. In real-world gaming scenarios, CPU budgets must also account for physics, artificial intelligence, and scene traversal. Consequently, modern DirectX 12 games typically target 30,000 to 100,000 draw calls per frame (equivalent to 1,800,000 to 6,000,000 per second at 60 FPS), enabling complex, dense environments that would instantly bottleneck a DirectX 11 renderer.