Approaching zero driver overhead

Approaching Zero
Driver Overhead
Cass Everitt
NVIDIA
Tim Foley
Intel
Graham Sellers
AMD
John McDonald
NVIDIA

Assertion
● OpenGL already has paths with very low
driver overhead
● You just need to know
● What they are, and
● How to use them

But first, who are we?
● Graham Sellers @GrahamSellers
● AMD OpenGL driver manager, OpenGL SuperBible author
● Tim Foley @TangentVector
● Graphics researcher, GPU language/compiler nerd
● John McDonald @basisspace
● Graphics engineer, chip architect, game developer
● Cass Everitt @casseveritt
● GL zealot, chip architect, mobile enthusiast

Many kinds of bottlenecks
● Focus here is ―driver limited‖
● App could render more, and
● GPU could render more, but
● Driver is at its limit…
● Because of expensive API calls

Some causes of driver overhead
● The CPU cost of fulfilling the
API contract
● Validation
● Hazard avoidance

Costs that add up…
● Major Categories:
● synchronization, allocation,
validation, and compilation
● Buffer updates (synchronization, allocation)
● Mapping, in-band updates
● Binding objects (validation, compilation)
● FBOs, programs, textures, buffers

Remedy? – Efficient APIs!
● Buffer storage
● Texture arrays
● Multi-Draw Indirect
● Texture arrays, bindless,
sparse, indirect parameters
}Tim Foley
Graham Sellers}

Results
● apitest
● Framework for testing
different ―solutions‖
● Source on github
}John McDonald

Remember, these OpenGL APIs
● Exist TODAY – already on your PC
● Are at least multi-vendor (EXT), and
mostly core (GL 4.2+)
● Coexist with existing
OpenGL

● Are at least multi-vendor (EXT), and mostly core
(GL 4.2+)
OpenGL

● Are at least multi-vendor (EXT), and mostly
core (GL 4.2+)
OpenGL

On with the show…
next speaker

Challenge: More Stuff per Frame
● Varied
● Not 1000s of same instanced mesh
● Unique geometry, textures, etc.
● Dynamic
● Not just pretty skinned meshes
● Generate new geometry each frame

Want an Order of Magnitude
● Increase in unique objects per frame
● Can over-simplify as draws per frame, but
● Misses importance of variety
● Do we need a new API to achieve this?
● How far can we get with what we have today?

Three Techniques in This Talk
● Persistent-mapped buffers
● Faster streaming of dynamic geometry
● MultiDrawIndirect (MDI)
● Faster submission of many draw calls
● Packing 2D textures into arrays
● Texture changes no longer break batches

Naïve Draw Loop
foreach( object )
{
// bind framebuffer
// set depth, blending, etc. states
// bind shaders
// bind textures
// bind vertex/index buffers
WriteUniformData( object );
glDrawElements(
GL_TRIANGLES,
object->indexCount,
GL_UNSIGNED_SHORT,
0 );
}

Typical Draw Loop
// sort or bucket visible objects
foreach( render target ) // framebuffer
foreach( pass ) // depth, blending, etc. states
foreach( material ) // shaders
foreach( material instance ) // textures
foreach( vertex format ) // vertex buffers
foreach( object )
{
glDrawElementsBaseVertex(
GL_TRIANGLES,
object->indexCount,
GL_UNSIGNED_SHORT,
object->indexDataOffset,
object->baseVertex );
}

Two Ways to Improve Overhead
foreach( object )
{
GL_TRIANGLES,
object->indexCount,
GL_UNSIGNED_SHORT,
}
submit each batch faster
fewer, bigger batches

Pack Multiple Objects per Buffer
foreach( object )
{
GL_TRIANGLES,
object->indexCount,
GL_UNSIGNED_SHORT,
}
pack multiple objects into the same
(dynamic or static) vertex/index buffer
take advantage of glDraw*() params to
index into buffer without changing
bindings

Dynamic Streaming of Geometry
● Typical dynamic vertex ring buffer
void* data = glMapBuffer(GL_ARRAY_BUFFER,
ringOffset,
dataSize,
GL_MAP_UNSYNCHRONIZED_BIT
| GL_MAP_WRITE_BIT );
WriteGeometry( data, ... );
glUnmapBuffer(GL_ARRAY_BUFFER);
ringOffset += dataSize;
// deal with wrap-around in ring, etc.
frequent mapping = overhead
no sync with GPU, but forces
sync in multi-threaded drivers

BufferStorage and Persistent Map
● Allocate buffer with glBufferStorage()
● Use flags to enable persistent mapping
glBufferStorage(GL_ARRAY_BUFFER, ringSize, NULL, flags);
GLbitfield flags = GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_COHERENT_BIT;
keep mapped while drawing
writes automatically visible to GPU

Dynamic Streaming of Geometry
● Map once at creation time
● No more Map/Unmap in your draw loop
● But need to do synchronization yourself
data = glMapBufferRange(ARRAY_BUFFER, 0, ringSize, flags);
WriteGeometry( data, ... );
data += dataSize;
upcoming talks will cover
glFenceSync() and glClientWaitSync()

Performance
● BufferSubData vs Map(UNSYNCHRONIZED)
● Intel: avoid frequent BufferSubData()
● NV: Map(UNSYNCH) bad for threaded drivers
● Persistent mapping best where supported
● Overhead 2-20x better than next best option

That Inner Loop Again
foreach( object )
{
WriteUniformData( object, &uniformData );
GL_TRIANGLES,
object->indexCount,
GL_UNSIGNED_SHORT,
}

Using an Indirect Draw
DrawElementsIndirectCommand command;
foreach( object )
{
WriteUniformData( object, &uniformData );
WriteDrawCommand( object, &command );
glDrawElementsIndirect(
GL_TRIANGLES,
GL_UNSIGNED_SHORT,
&command );
}
typedef struct {
uint count;
uint instanceCount;
uint firstIndex;
uint baseVertex;
uint baseInstance;
} DrawElementsIndirectCommand;
per-object parameters are
now sourced from memory

One Multi-Draw Submits it All
DrawElementsIndirectCommand* commands = ...;
foreach( object )
{
WriteUniformData( object, &uniformData[i] );
WriteDrawCommand( object, &commands[i] );
}
glMultiDrawElementsIndirect(
GL_TRIANGLES,
GL_UNSIGNED_SHORT,
commands,
commandCount,
0 );
fill in per-object data
(use parallelism, GPU compute if you like)
kick buffered-up objects to be rendered

What if I don‘t know the count?
● Doing GPU culling, etc.
● Use ARB_indirect_parameters
● Caveat: not all HW/drivers support it
glBindBuffer( GL_DRAW_INDIRECT_BUFFER, commandBuffer );
glBindBuffer( GL_PARAMETER_BUFFER, countBuffer );
// …
glMultiDrawElementsIndirectCount(
GL_TRIANGLES, GL_UNSIGNED_SHORT,
commandOffset,
countOffset,
maxCommandCount,
0 );

Per-Draw Parameters/Data
● If shader used to take struct of uniforms
● Now take an array of such structs
● Or use SSBO to go bigger
uniform ShaderParams params;
(Shader Storage Buffer Object)
uniform ShaderParams params[MAX_BATCH_SIZE];
buffer AllTheParams { ShaderParams params[]; };

How to find your draw‘s data?
● Ideally, just index it using gl_DrawID
● Provided by ARB_shader_draw_parameters
● Not supported everywhere
● But relatively simple to implement your own
mat4 mvp = params[gl_DrawIDARB].mvp;

Implement Your Own Draw ID
● Use baseInstance field of draw struct
● Increment base instance for each command
● Shader can‘t see base instance
● gl_InstanceID always counts from zero
http://www.g-truc.net/post-0518.html
cmd->baseInstance = drawCounter++;

Implement Your Own Draw ID
● Use a vertex attribute
● Set as per-instance with glVertexAttribDivisor
● Fill buffer with your own IDs
● Or arbitrary other per-draw parameters
● On some HW, faster than using gl_DrawID

More MultiDrawIndirect Caveats
● If generating draws on GPU
● Use a GL buffer (obviously)
● If generating on CPU
● Intel: (Compat) faster to use ordinary host pointer
● NV: persistent-mapped buffer slightly faster
● GPU or CPU
● AMD: Array must be tightly packed for best perf

Can Be 6-10x Less Overhead
0%
100%
200%
300%
400%
500%
600%
700%
Dynamic Buffer Persistent-Mapped Multi-Draw
Normalized Objects per Second

Batching Across Texture Changes
● Bindless, sparse can help
● As you will hear
● Not all hardware supports these
● Works on all current hardware/drivers

Packing Textures Into Arrays
● Array groups textures with same shape
● Dimensions, format, mips, MSAA
● Texture views may allow further grouping
● Put some same-size formats together

Packing Textures Into Arrays
● Bind all arrays to pipeline at once
● Need to allocate carefully
● Based on your content requirements
● Don‘t allocate more than fits in GPU memory
uniform sampler2Darray allSamplers[MAX_ARRAY_TEXTURES];

Options for Sampler Parameters
● Pair array with different sampler objs
● Create views of array with different state
● Be careful about max texture limits
● Each combination needs a new binding slot

Accessing Packed 2D Textures
● Texture ―handle‖ is pair of indices
● Index into array of sampler2Darray
● Slice index into particular array texture
● Can store as 64 bits {int;float;}
● Or pack into 32 bits (hi/lo) no int→float convert in shader
fewer bytes to read, but more math

Texture Array ~5x Less Overhead
0%
100%
200%
300%
400%
500%
600%
glBindTexture per Object Texture Arrays No Texture
Normalized Objects per Second

Dramatically Reduced Overhead
● Possible with current GL API and HW
● Persistent-mapped buffers
● Indirect and Multi-Draws
● Overhead is priority for all of us on GL

Section Overview
● Bindless textures
● Recap of traditional texture binding
● Remove texture units with bindless
● Sparse textures
● Manage virtual and physical memory
● Streaming, sparse data sets, etc.

Texture Units - Recap
● Traditional texture binding
● Create textures
● Bind to texture units
● Declare samplers in shaders
● Draw

● Textures bound to numbered units
● Limited number of texture units
● State changes between draws
● Driver controls residency

● Binding textures - API
● Very hard to coalesce draws
glGenTextures(10, &tex[0]);
glBindTexture(GL_TEXTURE_2D, tex[n]);
glTexStorage2D(GL_TEXTURE_2D, ...);
foreach (draw in draws) {
foreach (texture in draw->textures) {
glBindTexture(GL_TEXTURE_2D, tex[texture]);
}
// Other stuff
glDrawElements(...);
}

● Binding textures - shader
● Limited textures per shader
● All declared at global scope
layout (binding = 0) uniform sampler2D uTexture1;
layout (binding = 1) uniform sampler3D uTexture2;
out vec4 oColor;
void main(void){
oColor = texture(uTexture1, ...) +
texture(uTexture2, ...);
}

Bindless Textures
● Remove texture bindings!
● Unlimited* virtual texture bindings
● Application controls residency
● Shader accesses textures by handle
* Virtually unlimited

Bindless Textures
● Bindless textures - API
● No texture binds between draws
// Create textures as normal, get handles from textures
GLuint64 handle = glGetTextureHandleARB(tex);
// Make resident
glMakeTextureHandleResidentARB(handle);
// Communicate ‘handle’ to shader... somehow
foreach (draw) {
glDrawElements(...);
}

Bindless Textures
● Bindless textures - shader
● Shader accesses textures by handle
● Must communicate handles to shader
uniform Samplers {
sampler2D tex[500]; // Limited only by storage
};
out vec4 oColor;
void main(void) {
oColor = texture(tex[123], ...) + texture(tex[456], ...);
}

Bindless Textures
● Handles are 64-bit integers
● Stick them in uniform buffers
● Switch set of textures – glBindBufferRange
● Number of accessible textures limited by buffer size
● Put them in structures (AoS)
● Index with gl_DrawIDARB, gl_InstanceID

Bindless Textures – DANGER!!!
● Some caveats with bindless textures
● Divergence rules apply
● Just like indexing arrays of textures
● Bindless handle must be constant across instance
● Divergence might work
● On some implementations, it Just Works
● On others, it Just Doesn‘t
● Even when it works, it could be expensive

Sparse Textures
● Very large virtual textures
● Separate virtual and physical allocation
● Partially populated arrays, mips, cubes, etc.
● Stream data on demand

Sparse Textures
● Textures arranged as tiles
● Each tile may be resident or not

Sparse Textures
● Sparse textures – API
● That‘s it – now you have a virtual texture
// Tell OpenGL you want a sparse texture
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SPARSE_ARB, GL_TRUE);
// Allocate storage
glTexStorage2D(GL_TEXTURE_2D, 10, GL_RGBA8, 1024, 1024);

Sparse Textures
● Sparse textures – page sizes
// Query number of available page sizes
glGetInternalformativ(GL_TEXTURE_2D, GL_NUM_VIRTUAL_PAGE_SIZES_ARB,
GL_RGBA8, sizeof(GLint), &num_sizes);
// Get actual page sizes
glGetInternalformativ(GL_TEXTURE_2D, GL_VIRTUAL_PAGE_SIZE_X_ARB,
GL_RGBA8, sizeof(page_sizes_x),
&page_sizes_x[0]);
glGetInternalformativ(GL_TEXTURE_2D, GL_VIRTUAL_PAGE_SIZE_Y_ARB,
GL_RGBA8, sizeof(page_sizes_y),
&page_sizes_y[0]);
// Choose a page size
glTexParameteri(GL_TEXTURE_2D, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, n);

Sparse Textures
● Reserve and commit
● In ‗Operating System‘ terms
● Reserve – virtual allocation without physical store
● Commit – back virtual allocation with real memory

Sparse Textures
● Sparse textures – commitment
● Commitment is controlled by a single function
● Uncommitted pages use no memory
● Committed pages may contain data
void glTexPageCommitmentARB(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLint zoffset, GLsizei width,
GLsizei height, GLsizei depth,
GLboolean commit);

Sparse Textures
● Sparse textures – data storage
● Put data into sparse textures as normal
● glTexSubImage, glCopyTextureImage, etc.
● Use a (persistent mapped) PBO for this!
● Attach to framebuffer object + draw
● Read from sparse textures
● glReadPixels, glGetTexImage*, etc.

Sparse Textures
● Sparse textures – in-shader use
● No changes to shaders
● Reads from committed regions behave normally
● Reads from uncommitted regions return junk
● Probably not junk – most likely zeros
● The spec doesn‘t mandate this, however

Sparse Texture Arrays
● Combine sparse textures and arrays
● Create very long (sparse) array textures
● Some layers are resident, some are not
● Allocate new layers on demand
● New layer = glTexPageCommitmentARB

Sparse Texture Arrays
● Manage your own texture memory
● Create a huge virtual array texture
● Need a new texture?
● Allocate a new layer
● Don‘t need it any more?
● Recycle or make non-resident

Sparse Bindless Texture Arrays
● Use all the features!
● Create a sparse array per texture size
● As textures become needed, commit pages
● Run out of pages? Make another texture...
● Get texture bindless handles
● Use as many handles as you like

Sparse Bindless Texture Arrays
● Indexing sparse bindless arrays requires:
● 64-bit texture handle
● N-bit layer index
● Remember...
● Index can diverge, handle cannot
● Need one array per-size

Building Data Structures
● Okay, so how do we use these things?
● Option 1 – Build on the CPU
● It‘s just memory writes
● Use a bunch of threads
● Persistent maps
● Option 2 – Use the GPU
● Much fun. Wow.

● Using the GPU to set the scene (1)
● Create SSBO with AoS for draw parameters
struct DrawParams {
uint count;
uint instanceCount;
uint firstIndex;
uint baseIndex;
uint baseInstance;
};
layout (binding = 0) {
DrawParams draw_params[];
};

● Create another SSBO for draw metadata
struct DrawMeta {
uint material_index;
// More per-draw meta-stuff goes here...
};
layout (binding = 0) {
DrawMeta draw_meta[];
};

● Use atomic counter to append to buffers
layout (binding = 0, offset = 0) atomic_uint draw_count;
void append_draw(DrawParams params, DrawMeta meta)
{
uint index = atomicCounterIncrement(draw_count);
draw_params[index] = params;
draw_meta[index] = meta;
}

● Dump counter, do MultiDraw*IndirectCount
glCopyBufferSubData(GL_ATOMIC_COUNTER_BUFFER,
GL_PARAMETER_BUFFER_ARB,
0, 0, sizeof(GLuint));
glMultiDrawElementsIndirectCountARB(GL_TRIANLGES,
GL_UNSIGNED_SHORT,
nullptr,
MAX_DRAWS,
0);

● In draw, use meta with gl_DrawIDARB
struct Material {
sampler2D tex1;
};
layout (binding = 0) uniform MaterialData {
Material material[];
};
...
oColor = texture(material[draw_meta[gl_DrawIDARB].material_index],
...);

Putting it all into practice
● Introducing apitest
● Results
● Code review

apitest
● https://github.com/nvMcJohn/apitest
● Extensible OSS Framework (Public Domain)
● Uses SDL 2.0 (Thanks SDL!)
● Initially developed by Patrick Doane
OS OpenGL D3D11
Windows Yes Yes
Linux Yes No
OSX Sorta No

The Framework
● Code is segmented into Problems and
Solutions
● A Problem is a dataset to render
● A Solution is one targeted approach to
rendering that dataset (Problem)
● Support code to create shaders, load
textures, etc.

The Problems So Far
● DynamicStreaming
● Render 160,000 ―particles‖ that are
dynamically generated each frame
● UntexturedObjects
● Render 643 different, untextured objects
● Different matrices per object
● No instancing allowed!

The Problems So Far - Continued
● Textured Quads
● 10,000 quads using different textures
● Texture is changed between every object
● Null
● Clear and SwapBuffer
● Not going to discuss today—included as a
sanity startup.

Result discussion
● Results gathered on a GTX 680, using
public driver 335.23.
● But are shown normalized.
● AMD and Intel have very similar
performance ratios between solutions.

Decoder Ring
● SBTA = Sparse Bindless Texture Array
● SDP = Shader Draw Parameters

DynamicStreaming
● Demo!
● Problem: Render 160,000 ―particles‖ that
are dynamically generated each frame

Approaching zero driver overhead

0% 50% 100% 150% 200% 250%
GLMapPersistent
D3D11MapNoOverwrite
GLBufferSubData
D3D11UpdateSubresource
GLMapUnsynchronized
DynamicStreaming - Normalized Obj/s

GLMapPersistent
● Map the buffer at the beginning of time
● Keep it mapped forever.
● You are responsible for safety (proper
fencing)
● Do not stomp on data in flight
● src/solutions/dynamicstreaming/gl/mappersistent.*

Required Extensions
● ARB_buffer_storage
● ARB_map_buffer_range
● ARB_sync

Buffer Creation
GLbitfield mapFlags = GL_MAP_WRITE_BIT
GLbitfield createFlags = mapFlags | GL_MAP_DYNAMIC_STORAGE_BIT;
mDestHead = 0;
mBuffSize = 3 * maxVerts * kVertexSizeBytes;
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
glBufferStorage(GL_ARRAY_BUFFER, mBuffSize, nullptr, createFlags);
mVertexDataPtr = glMapBufferRange(GL_ARRAY_BUFFER, 0,
mBuffSize, mapFlags);

Dem Flags
mDestHead = 0;

Set circular buffer head
mDestHead = 0;

Triple Buffering ftw
mDestHead = 0;

Buffer Create
mDestHead = 0;

Map me… forever.
mDestHead = 0;

Buffer Update / Render
mBufferLockManager.WaitForLockedRange(mDstHead, vertSizeBytes);
for (int i = 0; i < particleCount; ++i) {
const int vertexOffset = i * kVertsPerParticle;
const int thisDstOffset = mDstHead + (i * kParticleSizeBytes);
void* dst = (unsigned char*) mVertexDataPtr + thisDstOffset;
memcpy(dst, &_vertices[vertexOffset], kParticleSizeBytes);
DrawArrays(TRIANGLES, kStartIndex + vertexOffset, kVertsPerParticle);
}
mBufferLockManager.LockRange(mDstHead, vertSizeBytes);
mDstHead = (mDstHead + vertSizeBytes) % mBuffSize;

Safety Third!
}

Write those particles
}

Now draw (inefficiently)
}

Update circular buffer head
}

UntexturedObjects
● Demo!
● Problem: Render 643 unique, untextured
objects

0% 100% 200% 300% 400% 500% 600% 700% 800% 900%
GLBufferStorage-NoSDP
GLMultiDrawBuffer-NoSDP
GLMultiDraw-NoSDP
GLBufferStorage-SDP
GLMultiDrawBuffer-SDP
GLMultiDraw-SDP
GLMapPersistent
GLDrawLoop
GLBindlessIndirect
GLTexCoord
GLUniform
D3D11Naive
GLBindless
GLDynamicBuffer
GLBufferRange
GLMapUnsynchronized
Untextured Object - Normalized Obj/s

GLBufferStorage-(ε|No)SDP
● Set up a giant uniform or storage buffer
with data for all objects for a frame.
● Use MDI to render many objects at once
● And PMB for dynamic data (matrix
transforms, MDI entries)
● Need a way to index data in shader (SDP)

Required Extensions
● ARB_buffer_storage
● ARB_map_buffer_range
● ARB_multi_draw_indirect
● ARB_shader_draw_parameters
● ARB_shader_storage_buffer_object
● ARB_sync

NoSDP
● Can be used when instancing isn‘t needed
● Very simple improvement to SDP
approach
● Not going to cover today
● So check the source code!

DrawElementsIndirectCommand
struct DrawElementsIndirectCommand
{
uint count;
uint instanceCount;
uint firstIndex;
uint baseVertex;
uint baseInstance;
};
typedef DrawElementsIndirectCommand DEICmd;

GLbitfield createFlags = mapFlags | GL_DYNAMIC_STORAGE_BIT;
mCmdHead = 0;
mCmdSize = 3 * objCount * sizeof(DEICmd);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, mCmdBuffer);
glBufferStorage(GL_DRAW_INDIRECT_BUFFER, mCmdSize, 0, createFlags);
mCmdPtr = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER, 0,
mCmdSize, mapFlags);
Cmd Buffer Creation

Obj Buffer Creation
GLbitfield createFlags = mapFlags | GL_DYNAMIC_STORAGE_BIT;
mObjHead = 0;
mObjSize = 3 * objCount * sizeof(Matrix);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mObjBuffer);
glBufferStorage(GL_SHADER_STORAGE_BUFFER, mObjSize, 0, createFlags);
mObjPtr = glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0,
mObjSize, mapFlags);

Cmd Buffer Update
mCmdLock.WaitForLockedRange(mCmdHead, sizeof(DEICmd) * objCount);
for (size_t u = 0; u < objCount; ++u) {
DEICmd *cmd = (mCmdPtr + mCmdHead) + u;
cmd->count = mIndexCount;
cmd->instanceCount = 1;
cmd->firstIndex = 0;
cmd->baseVertex = 0;
cmd->baseInstance = 0;
}
oldCmdHead = mCmdHead;
mCmdHead = (mCmdHead + sizeof(DEICmd) * objCount) % mCmdSize;
// Next, update the per-Object Data

Fencing for fun and profit
}

Someone Set Up Us The Draws
}

Manage the Head
}

Obj Buffer Update

Obj Buffer Update / Render
mObjLock.WaitForLockedRange(mObjHead, sizeof(Matrix) * objCount);
Matrix *obj = (mObjPtr + mObjHead) + u;
(*obj) = (inObjParameters)[u];
}
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
0, objCount, 0);
mCmdLock.LockRange(oldCmdHead, sizeof(DEICmd) * objCount);
mObjLock.LockRange(mObjHead, sizeof(Matrix) * objCount);
mObjHead = (mObjHead + sizeof(Matrix) * objCount) % mObjSize;

Seriously though, be safe
}
0, objCount, 0);

Updates to object parameters
}
0, objCount, 0);

Draw all the things
}
0, objCount, 0);

Head management
}
0, objCount, 0);

TexturedQuads
● Demo!
● 10,000 quads using different textures
● Texture is changed between every object

0% 200% 400% 600% 800% 1000% 1200% 1400% 1600% 1800% 2000%
GLSBTAMultiDraw-NoSDP
GLTextureArrayMultiDraw-NoSDP
GLBindlessMultiDraw
GLSBTAMultiDraw-SDP
GLTextureArrayMultiDraw-SDP
GLNoTex
GLTextureArray
GLNoTexUniform
GLTextureArrayUniform
GLSBTA
GLBindless
GLNaive
GLNaiveUniform
D3D11Naive
TexturedQuads – Normalized Obj/s

TexturedQuads notes
● SBTA was covered at Steam Dev Days
● Non-Sparse, Non-Bindless TextureArray is
the fallback
● Should use BufferStorage improvements
● SBTA = Sparse Bindless Texture Array

GLTextureArrayMultiDraw-(ε|No)SDP
● Instead of loose textures, use arrays of Texture
Arrays
● Container contains <=2048 same-shape textures
● Shape is height, width, mipmapcount, format
● Use MDI for kickoffs
● Address is passed as {int; float} pair

struct Tex2DAddress {
uint Container;
float Page;
};
layout (std140, binding=1) readonly buffer CB1 {
Tex2DAddress texAddress[];
};
uniform sampler2DArray TexContainer[16];
// Elsewhere (in a func, whatever)
int drawID = int(In.iDrawID);
Tex2DAddress addr = texAddress[drawID];
vec3 texCoord = vec3(In.v2TexCoord.xy, addr.Page);
vec4 texel = texture(TexContainer[addr.Container], texCoord);

Questions?
● graham dot sellers at amd dot com
@GrahamSellers
● tim dot foley at intel dot com
@TangentVector
● cass at nvidia dot com
@casseveritt
● jmcdonald at nvidia dot com
@basisspace

Approaching zero driver overhead

More Related Content

What's hot (20)

Similar to Approaching zero driver overhead (20)

Approaching zero driver overhead

Editor's Notes