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 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 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 , 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 , 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 , 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 , 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 , 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 , 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 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 , 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.