Software Rasterization on GPUs. NVIDIA Research

Transcription

1 Software Rasterization on GPUs Samuli Laine Jacopo Pantaleoni NVIDIA Research

2 Outline Rasterization Laine, Karras: High-Performance Software Rasterization on GPUs. Proceedings of High-Performance Graphics Voxelization Pantaleoni: VoxelPipe: A Programmable Pipeline for 3D Voxelization. Proceedings of High-Performance Graphics 2011.

3 Rationale Build a research platform Elbow space for game developers Enable new algorithms Programmable ROP Stochastic rasterization Non-linear rasterization Non-quad derivatives Quad merging Decoupled sampling Compact after discard etc. Provoke hardware architects Flexibility of software, performance of fixed-function hardware

4 Building a Pipeline We implemented a full pixel pipeline using CUDA From triangle setup to ROP Obey fundamental requirements of gfx pipe Maintain input order Hole-free rasterizer with correct rasterization rules Make it as fast as possible!

5 Design Considerations Run everything in parallel We need a lot of threads to fill the machine Minimize amount of synchronization Avoid excessive use of atomics Focus on load balancing Graphics workloads are wild Programmable Shading

6 Pipeline Structure Chunker-style pipeline with four stages Triangle setup Bin raster Coarse raster Fine raster Run data in large batches Separate kernel launch for each stage Keep data in input order all the time No need to sort

7 Chunking to Bins and Tiles Frame buffer Bin 16x16 tiles 128x128 px Tile 8x8 px Pixel

8 Triangle Setup Vertex buffer positions, attributes Index buffer... Triangle Setup edge eqs. u/v pleqs zmin etc. Triangle data buffer...

9 Bin Raster Triangle data buffer... Bin Raster SM 0 Bin Raster SM 1... Bin Raster SM 14 IDs of triangles that overlap bin

10 Coarse Raster... Coarse Raster SM n One coarse raster SM has exclusive access to the bin it s processing IDs of triangles that overlap tile

11 Fine Raster IDs of triangles that overlap tile Fine Raster warp n One fine raster warp has exclusive access to the tile it s processing Read tile once from DRAM to shared Write tile once to DRAM Pixel data in FB

12 Tidbit 1: Coverage Calculation Step along edge (Bresenham-like) Use look-up tables to generate coverage masks ~50 instructions for 8x8 stamp, one edge

13 Tidbit 2: Fragment Distribution Input Phase Shading Phase In input phase, calculate coverage and store in list In shading phase, detect triangle changes and calculate triangle index and fragment in triangle

14 Test Scenes Call of Juarez scene courtesy of Techland S.T.A.L.K.E.R.: Call of Pripyat scene courtesy of GSC Game World

15 Performance Results Frame rendering time in ms (depth test + color, no MSAA, no blending)

16 Comparison to Hardware (1/3) Resolution Cannot match hardware in raster, z kill + compact Currently support max 2K x 2K frame buffer, 4 subpixel bits Attributes Fetched when used bad latency hiding Expensive interpolation Antialiasing Hardware nearly oblivious to MSAA, we much less so

17 Comparison to Hardware (2/3) Memory usage, buffering through DRAM Performance implications of reduced buffering unknown Streaming through on-chip memory would be much better + Shader complexity Shader performance theoretically the same as in graphics pipe + Frame buffer bandwidth Each pixel touched only once in DRAM

18 Comparison to Hardware (3/3) + Extensibility Need one stage to do something extra? Need a new stage altogether? You can actually implement it + Specialization to individual applications Rip out what you don t need, hard-code what you can

19 Exploration Potential Shader performance boosters Compact after discard, quad merging, decoupled sampling, Things to do with programmable ROP A-buffering, order-independent transparency, Stochastic rasterization Non-linear rasterization (Your idea here)

20 The Code is Out There The entire codebase is open-sourced and released

21 VoxelPipe: A Programmable Pipeline for 3D Voxelization

22 What is Voxelization? Voxelization = Finding all voxels overlapped by each triangle in a mesh

23 Why shall we care? Why is it useful? Shape Matching Collision Detection Fluid / Soft-body Sim Stress Analysis Level of Detail Ray Tracing

24 Why shall we care? Interactive Indirect Illumination and Ambient Occlusion using Voxel Cone Tracing Cyril Crassin (I3D 2011)

25 Rationale building a full-featured pipeline for voxelization, analogous to OpenGL for 2d rasterization fully conservative and thin* rasterization arbitrary frame-buffer types many blending modes (additive,max,min,and,or...) multiple render targets vertex shaders fragment shaders

26 Rationale Extended support for rendering modes: conventional blending-based rasterization A-buffer / bucketing

27 Challenges Previous research mostly concerned with binary output => no Shading, no ROP State-of-the-Art had poor load balancing => Huge performance hit for mixed triangle sizes

28 What is Rasterization?

29 What is Rasterization? Highly Variable Expansion Rate source of most load balancing problems Vertex Shading Fragment Shading

30 Observations (1) Rasterization = Sorting of Compressed Batches of Elements triangles: n fragments: f1,1 f2,1 f3,1 f4,1 fn,1 f1,2 f3,2 F4,2 fn,2 f1,3 f3,3 highly variable decompression rate f3,

31 Observations (2) Decompression and Sorting can be done Hierarchically emit per-tile fragments sort by tile emit per-voxel fragments sort by voxel blend

32 Observations (2) Decompression and Sorting can be done Hierarchically triangles: n fragments: f1,1 f2,1 f3,1 f4,1 fn,1 f1,2 f3,2 f4,2 fn,2 f1,3 f3,3 decompression rate is more regular f3,

33 Pipeline Overview coarse rasterizer (tile,tri) fragments by tri id tile sorting tile queues fine rasterizer FB tiles one tri per thread persist. threads radix sort tri 1 tri 2 tri 1 tri 2 1 CTA per tile one tri per thread 2 tri 3 persist. threads 3 tri 1

34 Programmable Shading simple C++ classes: struct MyShader { T eval(const Fragment frag) const; private:... }; can be any of the supported types!

35 Performance Results

36 Performance Results M tris/s

37 Example Application: Real-Time GI

38 Future Work Sparse Octrees Tessellation / Geometry Shaders Programmable ROP

39 Future Work The entire codebase will be open-sourced

40 Thank You Questions Further information: Laine, Karras: High-Performance Software Rasterization on GPUs. Proceedings of High-Performance Graphics Pantaleoni: VoxelPipe: A Programmable Pipeline for 3D Voxelization. Proceedings of High-Performance Graphics 2011.