blob: a81d5d786529ca5e5b8ff553ef3131a35c305852 [file] [log] [blame]
Name
ARB_shader_atomic_counter_ops
Name Strings
GL_ARB_shader_atomic_counter_ops
Contact
Daniel Rakos (daniel.rakos 'at' amd.com)
Contributors
Daniel Rakos, AMD
Graham Sellers, AMD
Piers Daniell, NVIDIA
Notice
Copyright (c) 2015 The Khronos Group Inc. Copyright terms at
http://www.khronos.org/registry/speccopyright.html
Specification Update Policy
Khronos-approved extension specifications are updated in response to
issues and bugs prioritized by the Khronos OpenGL Working Group. For
extensions which have been promoted to a core Specification, fixes will
first appear in the latest version of that core Specification, and will
eventually be backported to the extension document. This policy is
described in more detail at
https://www.khronos.org/registry/OpenGL/docs/update_policy.php
Status
Complete. Approved by the ARB on June 26, 2015.
Ratified by the Khronos Board of Promoters on August 7, 2015.
Version
Last Modified Date: 06/11/2015
Author Revision: 6
Number
ARB Extension #182
Dependencies
This extension is written against version 4.50 of the OpenGL Shading
Language Specification.
OpenGL 4.2 or ARB_shader_atomic_counters is required.
Overview
The ARB_shader_atomic_counters extension introduced atomic counters, but
it limits list of potential operations that can be performed on them to
increment, decrement, and query. This extension extends the list of GLSL
built-in functions that can operate on atomic counters. The list of new
operations include:
* Addition and subtraction
* Minimum and maximum
* Bitwise operators (AND, OR, XOR, etc.)
* Exchange, and compare and exchange operators
New Procedures and Functions
None.
New Tokens
None.
Modifications to the OpenGL Shading Language Specification, Version 4.50
Additions to Chapter 8 of the OpenGL Shading Language Specification
(Built-in Functions)
Modify Section 8.10, Atomic-Counter Functions
(remove second paragraph on p. 173 starting with "The value returned...")
(modify third paragraph on p. 173)
The underlying counter is a 32-bit unsigned integer. The result of
operations will wrap to [0, 2^32-1].
(add to the table of atomic counter built-in functions on p. 173)
+-------------------------------------+------------------------------------------------------------------+
| Syntax | Description |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterAddARB( | Atomically |
| atomic_uint c, | 1. adds the value of <data> to the counter for c, and |
| uint data) | 2. returns its value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterSubtractARB( | Atomically |
| atomic_uint c, | 1. subtracts the value of <data> from the counter for c, and |
| uint data) | 2. returns its value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterMinARB( | Atomically |
| atomic_uint c, | 1. sets the counter for c to the minimum of the value of the |
| uint data) | counter and the value of <data>, and |
| | 2. returns the value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterMaxARB( | Atomically |
| atomic_uint c, | 1. sets the counter for c to the maximum of the value of the |
| uint data) | counter and the value of <data>, and |
| | 2. returns the value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterAndARB( | Atomically |
| atomic_uint c, | 1. sets the counter for c to the result of the bitwise AND of |
| uint data) | the value of the counter and the value of <data>, and |
| | 2. returns the value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterOrARB( | Atomically |
| atomic_uint c, | 1. sets the counter for c to the result of the bitwise OR of |
| uint data) | the value of the counter and the value of <data>, and |
| | 2. returns the value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterXorARB( | Atomically |
| atomic_uint c, | 1. sets the counter for c to the result of the bitwise XOR of |
| uint data) | the value of the counter and the value of <data>, and |
| | 2. returns the value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterExchangeARB( | Atomically |
| atomic_uint c, | 1. sets the counter value for c to the value of <data>, and |
| uint data) | 2. returns its value prior to the operation. |
| | These two steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
| uint atomicCounterCompSwapARB( | Atomically |
| atomic_uint c, | 1. compares the value of <compare> and the counter value for c,|
| uint compare, | 2. if the values are equal, sets the counter value for c to |
| uint data) | the value of <data>, and |
| | 3. returns its value prior to the operation. |
| | These three steps are done atomically with respect to the atomic |
| | counter functions in this table. |
+-------------------------------------+------------------------------------------------------------------+
Errors
None.
New State
None.
New Implementation Dependent State
None.
Usage Examples
Example 1: Appending variable length records to a buffer using a compute shader
// Here we use atomicCounterAdd to ensure that we "allocate" a contiguous list of
// elements in the buffer.
// Using atomicCounterIncrement cannot mimic this behavior as there is no guarantee
// that subsequent calls to atomicCounterIncrement return subsequent counter values.
layout(binding=0, offset=0) uniform atomic_uint vlrCounter;
layout(binding=0, r32ui) uniform imageBuffer vlrBuffer;
void main()
{
uint data[...] = ...;
uint recordLength = ...;
uint recordStart = atomicCounterAddARB(vlrCounter, recordLength);
for (uint i = 0; i < recordLength; ++i)
{
imageStore(vlrBuffer, recordStart + i, data[i]);
}
}
Issues
(1) What additional operations should this extension introduce?
RESOLVED: The following new operations are generally supported by
target hardware:
* Addition and subtraction
* Minimum and maximum
* Bitwise operators (AND, OR, XOR, etc.)
* Exchange, and compare and exchange operators
(2) How the functionality in this extension is different than that
introduced by AMD_shader_atomic_counter_ops?
RESOLVED: In addition to the operations introduced by this extension
AMD_shader_atomic_counter_ops also adds support for wrapped increment,
wrapped decrement, reverse subtract, and a special masked-or operation.
Also, the semantics of the subtract operation is different between this
and the AMD extension.
(3) Should the new decrement with wrap and subtract operators match the
behavior of the existing decrement operator and return the post-
operation value of the counter?
RESOLVED: Yes, for consistency with the existing functionality.
(4) Most of the new operations introduced by this extension are already
supported on load/store images and shader storage buffers. What benefit
the application developer could get from using this extension?
DISCUSSION: Atomic counter operations can have different performance
characteristics than load/store images or shader storage buffers. It is
expected that implementations can do atomic counter operations faster.
RESOLVED: It enables existing operations for atomic counters and also
adds completely new operations that are not available for load/store
images and shader storage buffers.
(5) Should the new subtract operator match the behavior of the existing
decrement operator and return the post-operation value of the counter?
RESOLVED: No, it returns the value of the counter prior to the operation,
just like other atomic counter operations except decrement.
Revision History
Rev. Date Author Changes
---- -------- -------- -------------------------------------------------
6 06/11/15 drakos Updated resolution of issue (2) and (5) based on
the previous change.
5 05/28/15 pdaniell Modify the return semantics of
atomicCounterSubtractARB to return the result
prior to the operation.
4 05/08/15 drakos Added ARB suffixes to the built-in functions.
3 03/18/15 drakos Removed reverse subtract.
2 03/17/15 drakos Removed wrapped increment, wrapped decrement, and
masked-or operations. Also resolved outstanding
issues.
1 02/03/15 drakos Draft based on AMD_shader_atomic_counter_ops.
Rebased language for GLSL 4.50.