Vulkan Descriptor Sets and Bindings

Topic Overview

Indirect Resource Binding in Vulkan

Vulkan shaders do not access textures or buffers by name. Resources bind through descriptor sets: collections of descriptors, each specifying a type (uniform buffer, combined image sampler, storage buffer) and a GPU memory handle.

A descriptor set layout defines the schema: which bindings exist, their types, and array sizes. Multiple sets bind simultaneously, typically split by update frequency.

The Three-Set Model

cCopy
Loading…

For example, set 0 updates once per frame, set 1 changes on material switch, set 2 changes every draw call. This split minimizes expensive rebinding. Unreal's Vulkan RHI and id Tech 7 use this pattern verbatim.

• Descriptor pools: pre-allocate counts per type; overflow causes VK_ERROR_OUT_OF_POOL_MEMORY
• Pipeline layouts: combine set layouts + push constant ranges
• Types: UNIFORM_BUFFER, COMBINED_IMAGE_SAMPLER, STORAGE_BUFFER

Descriptor pools require upfront sizing because the driver allocates from a fixed pool. Pipeline layouts must match shader-declared bindings exactly.

For This Exercise

You will model a descriptor set layout and calculate pool requirements for a multi-material renderer. This task asks you to count descriptors per type and print total pool allocation. Descriptor set design is one of the most expensive CPU-side operations in a Vulkan frame.

Your Task

Model Vulkan's resource binding model:

• descriptor set layouts: typed, counted bindings per shader stage;
• descriptor pools: a budget of sets and of descriptors per type;
• set allocation, which fails with VK_ERROR_OUT_OF_POOL_MEMORY when either budget runs out;
• descriptor writes, type- and range-checked;
• pipeline layouts and binding, which requires compatible set layouts;
• the draw-time check that every descriptor the pipeline can see has been written.

Input

# starts a comment.

cCopy
Loading…

Types: UNIFORM_BUFFER, STORAGE_BUFFER, COMBINED_IMAGE_SAMPLER, SAMPLED_IMAGE, SAMPLER, STORAGE_IMAGE. STAGES is free text (e.g. VERTEX|FRAGMENT), but it matters for compatibility.

Rules

• Layouts: end prints layout L: N binding(s). A repeated binding number gives layout L: binding N already defined, and a malformed line gives binding: N TYPE COUNT(1-8) STAGES.
• alloc: a set needs the sum of its layout's counts per type.
  • If the pool already holds MAXSETS sets: alloc S: VK_ERROR_OUT_OF_POOL_MEMORY (pool P is at maxSets M).
  • If any type lacks room (checked in the type order above): alloc S: VK_ERROR_OUT_OF_POOL_MEMORY (needs N TYPE, pool P has K left).
  • On success: allocated S (layout L) from P: U of M sets used.
• write:
  • errors: write S: layout L has no binding B, write S: binding B is T, not U, write S: element E out of range (binding B has C);
  • otherwise the element records the resource.
• free: needs a pool created with free (free S: pool P was not created with FREE_DESCRIPTOR_SET). It prints freed S and returns the budget. reset frees every set of the pool: reset P: freed N set(s).
• stats: pool P: U/M sets, then , TYPE used/cap for each type the pool has.
• Compatibility: two layouts are compatible if they are the same layout, or their bindings match one for one (number, type, count and stages, in declaration order). bind otherwise prints bind S: layout L is incompatible with set I of P (L2).
• draw: for each set index in order:
  • draw P: set I is not bound, with (it was freed) if the bound set has since been freed;
  • otherwise, for each binding in order and each element, draw P: set I (S) binding B element E was never written;
  • with no problems: draw P: ok set 0 = S0, set 1 = S1.

Output

cCopy
Loading…

Command errors:

• layout: NAME (unique)
• pool: NAME MAXSETS TYPE=COUNT... [free]
• alloc: SET POOL LAYOUT, alloc S: name in use
• write: SET BINDING ELEMENT TYPE RESOURCE
• free: SET, reset: POOL, stats: POOL
• pipeline: NAME LAYOUT... (1-4 sets), pipeline P: unknown set layout
• bind: PIPELINE SET_INDEX SET, draw: PIPELINE
• unknown command X
• layout L: missing end (at the end of input)

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Account pool budgets per descriptor type, exactly as the counts in the layouts add up. That is how real drivers carve up descriptor pools.
2. A draw must validate what the pipeline expects, set by set, against what is actually bound and written.

Hidden tests cover the maxSets limit, a free-able versus a fixed pool, pool reset, type/element/binding write errors, compatibility between identical layouts with different names, an incompatible bind, a freed set still bound, and command errors.