Vulkan Render Pass and Attachments

Topic Overview

Render Passes Describe the Full Frame

Vulkan is explicit: the application describes rendering upfront instead of relying on implicit OpenGL state. A render pass defines attachments, subpasses, and dependencies so the driver can optimize memory bandwidth before any draw call runs.

Core components:

• Attachments: color, depth, stencil images
• Subpasses: individual rendering steps reading/writing attachments
• Dependencies: synchronization between subpasses

Forward vs Deferred Layout

A forward pass typically has one color attachment, one depth attachment, and one subpass drawing geometry.

A deferred pass has multiple color attachments (G-buffer: position, normal, albedo), one depth attachment, subpass 0 filling the G-buffer, and subpass 1 reading it for lighting.

Each attachment specifies:

cCopy
Loading…

For example, marking a G-buffer attachment DONT_CARE on store tells tile-based mobile GPUs they need not write intermediate data back to VRAM. CLEAR avoids reading uninitialized memory; DONT_CARE enables tile compression on ARM Mali and PowerVR.

For This Exercise

You will model a Vulkan render pass with two subpasses for deferred rendering and print its configuration. This task asks you to define attachments with load/store ops and wire subpass dependencies. Explicit render passes are why deferred rendering is affordable on phones, not just desktop GPUs.

Your Task

Model a Vulkan render pass the way a driver for a tile-based GPU sees it. You get:

• attachments, with formats and load/store ops;
• subpasses, which write color/depth attachments and read earlier results as input attachments;
• subpass dependencies.

Validate the structure. For a valid pass, compute the per-pixel on-chip tile memory and the DRAM traffic the load/store ops imply, compared with running each subpass as its own render pass. That comparison is the reason deferred renderers use subpasses on mobile.

Input

# starts a comment.

cCopy
Loading…

Formats (bytes per pixel): RGBA8, BGRA8, RGB10A2 and R32F are 4; RGBA16F is 8; RGBA32F is 16. Depth formats: D32 and D24S8 are 4, D16 is 2. There are at most 8 attachments and 6 subpasses, and names must be unique.

Validation (at analyze, in this order)

1. For each attachment:
   • error: NAME is transient but its contents are loaded or stored (transient requires load ≠ LOAD and store = DONT_CARE);
   • warning: NAME is never used (neither read nor written by any subpass).
2. For each subpass, in order:
   • error: subpass S: A has depth format F but is a color attachment;
   • error: subpass S: A has color format F but is the depth attachment;
   • for each input A: error: subpass S reads and writes A (feedback loop) if S also writes A.
     • Otherwise, find the last earlier subpass W that writes A.
     • With no writer: error: subpass S reads A before any subpass writes it (and it is not loaded), unless A has load=LOAD.
     • With a writer but no dependency W → S: error: missing dependency W -> S for A.
3. Result: if there were errors, print invalid: N error(s) and stop.

Analysis (valid passes)

• Subpass lines: subpass S: reads A B; writes C D (depth). Omit the reads part without inputs, and print writes nothing if nothing is written.
• Tile memory: on-chip tile memory: N bytes per pixel sums every attachment's bytes per pixel.
• Traffic with P = W × H:
  • load = P·bpp if load=LOAD, else 0;
  • store = P·bpp if store=STORE, else 0;
  • transient attachments print (transient: no memory allocated);
  • separate render passes add 2·P·bpp (a store plus a reload) for every subpass that reads the attachment as an input.
• Totals: total: T bytes (X.Y MB) vs S bytes (X.Y MB) as separate render passes, with MB = 10⁶ bytes to 1 decimal, rounded half up.

Output

cCopy
Loading…

Command errors:

• attachment: NAME FORMAT load=CLEAR|LOAD|DONT_CARE store=STORE|DONT_CARE [transient] (also for a duplicate name or a 9th attachment; the same goes for subpasses)
• attachment X: unknown format F
• subpass: NAME [color=A,B] [input=C] [depth=D], subpass S: unknown attachment X
• dependency: SRC DST (subpass names or EXTERNAL), dependency A -> B: must go from an earlier subpass to a later one
• analyze: WIDTH HEIGHT (1-16384), analyze: no subpasses
• unknown command X

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Treat input attachments as reads of earlier subpasses' output. Those reads require a dependency, just as in VkSubpassDependency.
2. Derive the traffic from load/store ops alone. They are exactly what a tiler turns into DRAM reads and writes.

Hidden tests cover transient misuse, depth/color format mix-ups, a missing dependency, a feedback loop, an input that is never written, an input with load=LOAD, an unused attachment, and command errors.