Name NV_shader_atomic_counters Name Strings GL_NV_shader_atomic_counters Contact Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com) Status Complete Version Last Modified Date: June 23, 2011 NVIDIA Revision: 1 Number 423 Dependencies ARB_shader_atomic_counters and NV_gpu_program5 are required. This extension is written against the NV_gpu_program4 specification, as extended by NV_gpu_program5. Overview This extension builds upon the ARB_shader_atomic_counters and NV_gpu_program5 extensions to provide assembly language support for incrementing, decrementing, and querying the values of atomic counters stored in buffer object memory. The extension uses the same set of atomic counter buffer binding points as the ARB_shader_atomic_counters extension; applications using this extension should use the APIs specified there to bind buffers. New Procedures and Functions None. New Tokens None. Additions to Chapter 2 of the OpenGL 2.0 Specification (OpenGL Operation) (All modifications are relative to Section 2.X, GPU Programs, from the NV_gpu_program4 specification.) Modify Section 2.X.2, Program Grammar (add after the long list of grammar rules) If a program specifies the NV_shader_atomic_counters program option, the following rules are added to the NV_gpu_program4 base program grammar: ::= ::= ::= "," ::= "ATOMCTR" ::= "INCR" | "DECR" | "GET" ::= ::= "COUNTER" ::= "COUNTER" ::= ::= "{" "}" ::= ::= "," ::= ::= ::= ::= ::= ::= "program" "." "counter" Add New Section 2.X.3.Y, Atomic Counter Buffers, after Section 2.X.3.6, Program Parameter Buffers Atomic counter buffers are arrays consisting of single-component unsigned integer values stored in a buffer object. The GL provides an implementation-dependent number of atomic counter buffer object binding points to which buffer objects can be attached. Atomic counter variables can be changed either by updating the contents of bound buffer objects, by changing the buffer object attached to a binding point, or by using the ATOMCTR instruction in a shader to increment or decrement the current value. Atomic counter buffer bindings are established by calling BindBufferBase, BindBufferOffsetEXT, or BindBufferRange with a target of ATOMIC_COUNTER_BUFFER, as documented in the ARB_shader_atomic_counters extension. The number of atomic counter buffer object binding points is given by the value of the constant MAX_ATOMIC_COUNTER_BUFFER_BINDINGS. There is a limit on the maximum number of words of a buffer object that can be accessed using any single parameter buffer binding point, given by the implementation-dependent constant MAX_ATOMIC_COUNTER_BUFFER_SIZE. Buffer objects larger than this size may be used, but the results of accessing portions of the buffer object beyond the limit are undefined. Atomic counter variables may only be used as operands in the ATOMCTR instruction; they may not be used by used as results or operands in general instructions. Atomic counter variables must be declared explicitly via the grammar rule. Atomic counter buffer bindings can not be used directly in executable instructions. Atomic counter variables may be declared as arrays, but all bindings assigned to the array must use the same binding point and must increase consecutively. Binding Components Underlying State ----------------------------- ---------- ----------------------------- program.counter[a][b] (x,x,x,x) atomic counter buffer a, element b program.counter[a][b..c] (x,x,x,x) atomic counter buffer a, elements b through c program.counter[a] (x,x,x,x) atomic counter buffer a, all elements Table X.Y: Atomic Counter Buffer Bindings. indicates a buffer number, and indicate individual elements. If an atomic counter buffer binding matches "program.counter[a][b]", the atomic counter variable is associated with element of the buffer object bound to binding point . If no buffer object is bound to binding point , or the bound buffer object is not large enough to hold an element , reads from the binding return zero and writes to the binding have no effect. The binding point must be a nonnegative integer constant. For atomic counter array declarations, "program.counter[a][b..c]" is equivalent to specifying elements through of the buffer object bound to binding point in order. For atomic counter array declarations, "program.counter[a]" is equivalent to specifying the entire buffer -- elements 0 through -1, where is either the size of the array (if declared) or the implementation-dependent maximum atomic counter buffer object size limit (if no size is declared). Modify Section 2.X.4, Program Execution Environment (Add to the set of opcodes in Table X.13) Modifiers Instruction F I C S H D Out Inputs Description ----------- - - - - - - --- -------- -------------------------------- ATOMCTR - X X - - U s - atomic counter operation Modify Section 2.X.4.1, Program Instruction Modifiers (Add to Table X.14, Instruction Modifiers, and to the corresponding description following the table) Modifier Description -------- ----------------------------------------------- INCR Increment an atomic counter variable DECR Decrement an atomic counter variable GET Query the value of an atomic counter variable For atomic counter instructions, the "INCR", "DECR", and "GET" atomic counter instruction modifiers specify an operation to perform on an atomic counter variable. Atomic counter instruction modifiers are supported by the ATOMCTR instruction and are covered in more detail in the description of that instruction. Modify Section 2.X.6, Program Options + Atomic Counter Support (NV_shader_atomic_counters) If a program specifies the "NV_shader_atomic_counters" option, it may use the COUNTER statement to declare atomic counter variables and the ATOMCTR instruction to increment, decrement, or query the values of atomic counter variables. Modify Section 2.X.8, Program Instruction Set Section 2.X.8.Z, ATOMCTR: Atomic Counter Operation The ATOMCTR instruction performs an atomic global counter operation by reading from memory corresponding to the atomic counter variable specified in the instruction, optionally modifying that memory, and then returning an scalar unsigned integer result. The memory transaction is atomic, guaranteeing that no other write to the memory accessed will occur between the time it is read and written by the ATOMCTR instruction. The ATOMCTR instruction requires an atomic counter instruction modifier, as enumerated in Table X.Y. The instruction modifier specifies the type of operation to perform. atomic modifier operation -------- ------------------------------------------------- INCR increment counter (returns non-incremented value) DECR decrement counter (returns decremented value) GET query counter Table X.Y, Supported atomic and storage modifiers for the ATOM instruction. ATOMCTR performs a scalar atomic operation and returns an atomic counter value in the component of the result vector. The , , and components of the result vector are undefined. address = AtomicCounterAddress(op0); result = BufferMemoryLoad(address, U32); switch (atomicModifier) { case INCR: writeval = result + 1; break; case DECR: writeval = result - 1; result = writeval; // return decremented value break; case GET: return result; // no memory store BufferMemoryStore(address, writeval, U32); If an incremented or decremented counter value overflows the representable range of counter values, it will wrap. ATOMCTR supports only signed and unsigned integer data type modifiers, but no storage modifers. The memory holding the atomic counter and the result vector are treated as scalar signed or unsigned integers, according to the data type modifier. Additions to Chapter 3 of the OpenGL 2.0 Specification (Rasterization) None. Additions to Chapter 4 of the OpenGL 2.0 Specification (Per-Fragment Operations and the Frame Buffer) None. Additions to Chapter 5 of the OpenGL 2.0 Specification (Special Functions) None. Additions to Chapter 6 of the OpenGL 2.0 Specification (State and State Requests) None. Additions to Appendix A of the OpenGL 2.0 Specification (Invariance) None. Additions to the AGL/GLX/WGL Specifications None. Errors None. New State None. New Implementation Dependent State None. Issues (1) Should this extension have its own extension string entry, or should its existence be implied by the presence of the ARB_shader_atomic_counters and NV_gpu_program5 extensions? RESOLVED: Provide a separate extension string entry. Revision History Rev. Date Author Changes ---- --------- -------- -------------------------------------------- 1 20-Jun-11 pbrown Internal spec development.