xref: /third_party/openGLES/extensions/INTEL/INTEL_shader_integer_functions2.txt

Name

    INTEL_shader_integer_functions2

Name Strings

    GL_INTEL_shader_integer_functions2

Contact

    Ian Romanick <ian.d.romanick@intel.com>

Contributors


Status

    In progress

Version

    Last Modification Date: 11/25/2019
    Revision: 5

Number

    OpenGL Extension #547
    OpenGL ES Extension #323

Dependencies

    This extension is written against the OpenGL 4.6 (Core Profile)
    Specification.

    This extension is written against Version 4.60 (Revision 03) of the OpenGL
    Shading Language Specification.

    GLSL 1.30 (OpenGL), GLSL ES 3.00 (OpenGL ES), or EXT_gpu_shader4 (OpenGL)
    is required.

    This extension interacts with ARB_gpu_shader_int64.

    This extension interacts with AMD_gpu_shader_int16.

    This extension interacts with OpenGL 4.6 and ARB_gl_spirv.

    This extension interacts with EXT_shader_explicit_arithmetic_types.

Overview

    OpenCL and other GPU programming environments provides a number of useful
    functions operating on integer data.  Many of these functions are
    supported by specialized instructions various GPUs.  Correct GLSL
    implementations for some of these functions are non-trivial.  Recognizing
    open-coded versions of these functions is often impractical.  As a result,
    potential performance improvements go unrealized.

    This extension makes available a number of functions that have specialized
    instruction support on Intel GPUs.

New Procedures and Functions

    None

New Tokens

    None

IP Status

    No known IP claims.

Modifications to the OpenGL Shading Language Specification, Version 4.60

    Including the following line in a shader can be used to control the
    language features described in this extension:

      #extension GL_INTEL_shader_integer_functions2 : <behavior>

    where <behavior> is as specified in section 3.3.

    New preprocessor #defines are added to the OpenGL Shading Language:

      #define GL_INTEL_shader_integer_functions2        1

Additions to Chapter 8 of the OpenGL Shading Language Specification
(Built-in Functions)

    Modify Section 8.8, Integer Functions

    (add a new rows after the existing "findMSB" table row, p. 161)

    genUType countLeadingZeros(genUType value)

    Returns the number of leading 0-bits, stating at the most significant bit,
    in the binary representation of value.  If value is zero, the size in bits
    of the type of value or component type of value, if value is a vector will
    be returned.


    genUType countTrailingZeros(genUType value)

    Returns the number of trailing 0-bits, stating at the least significant bit,
    in the binary representation of value.  If value is zero, the size in bits
    of the type of value or component type of value (if value is a vector) will
    be returned.


    genUType absoluteDifference(genUType x, genUType y)
    genUType absoluteDifference(genIType x, genIType y)
    genU64Type absoluteDifference(genU64Type x, genU64Type y)
    genU64Type absoluteDifference(genI64Type x, genI64Type y)
    genU16Type absoluteDifference(genU16Type x, genU16Type y)
    genU16Type absoluteDifference(genI16Type x, genI16Type y)

    Returns |x - y| clamped to the range of the return type (instead of modulo
    overflowing).  Note: the return type of each of these functions is an
    unsigned type of the same bit-size and vector element count.


    genUType addSaturate(genUType x, genUType y)
    genIType addSaturate(genIType x, genIType y)
    genU64Type addSaturate(genU64Type x, genU64Type y)
    genI64Type addSaturate(genI64Type x, genI64Type y)
    genU16Type addSaturate(genU16Type x, genU16Type y)
    genI16Type addSaturate(genI16Type x, genI16Type y)

    Returns x + y clamped to the range of the type of x (instead of modulo
    overflowing).


    genUType average(genUType x, genUType y)
    genIType average(genIType x, genIType y)
    genU64Type average(genU64Type x, genU64Type y)
    genI64Type average(genI64Type x, genI64Type y)
    genU16Type average(genU16Type x, genU16Type y)
    genI16Type average(genI16Type x, genI16Type y)

    Returns (x+y) >> 1.  The intermediate sum does not modulo overflow.


    genUType averageRounded(genUType x, genUType y)
    genIType averageRounded(genIType x, genIType y)
    genU64Type averageRounded(genU64Type x, genU64Type y)
    genI64Type averageRounded(genI64Type x, genI64Type y)
    genU16Type averageRounded(genU16Type x, genU16Type y)
    genI16Type averageRounded(genI16Type x, genI16Type y)

    Returns (x+y+1) >> 1.  The intermediate sum does not modulo overflow.


    genUType subtractSaturate(genUType x, genUType y)
    genIType subtractSaturate(genIType x, genIType y)
    genU64Type subtractSaturate(genU64Type x, genU64Type y)
    genI64Type subtractSaturate(genI64Type x, genI64Type y)
    genU16Type subtractSaturate(genU16Type x, genU16Type y)
    genI16Type subtractSaturate(genI16Type x, genI16Type y)

    Returns x - y clamped to the range of the type of x (instead of modulo
    overflowing).


    genUType multiply32x16(genUType x_32_bits, genUType y_16_bits)
    genIType multiply32x16(genIType x_32_bits, genIType y_16_bits)
    genUType multiply32x16(genUType x_32_bits, genU16Type y_16_bits)
    genIType multiply32x16(genIType x_32_bits, genI16Type y_16_bits)

    Returns x * y, where only the (possibly sign-extended) low 16-bits of y
    are used.  In cases where one of the signed operands is known to be in the
    range [-2^15, (2^15)-1] or unsigned operands is known to be in the range
    [0, (2^16)-1], this may provide a higher performance multiply.

Interactions with OpenGL 4.6 and ARB_gl_spirv

    If OpenGL 4.6 or ARB_gl_spirv is supported, then
    SPV_INTEL_shader_integer_functions2 must also be supported.

    The IntegerFunctions2INTEL capability is available whenever the
    implementation supports INTEL_shader_integer_functions2.

Interactions with ARB_gpu_shader_int64 and EXT_shader_explicit_arithmetic_types_int64

    If the shader enables only INTEL_shader_integer_functions2 but not
    ARB_gpu_shader_int64 or EXT_shader_explicit_arithmetic_types_int64,
    remove all function overloads that have either genU64Type or genI64Type
    parameters.

Interactions with AMD_gpu_shader_int16 and EXT_shader_explicit_arithmetic_types_int16

    If the shader enables only INTEL_shader_integer_functions2 but not
    AMD_gpu_shader_int16 or EXT_shader_explicit_arithmetic_types_int16,
    remove all function overloads that have either genU16Type or genI16Type
    parameters.

Issues

    1) What should this extension be called?

    RESOLVED.  There already exists a MESA_shader_integer_functions extension,
    so this is called INTEL_shader_integer_functions2 to prevent confusion.

    2) How does countLeadingZeros differ from findMSB?

    RESOLVED: countLeadingZeros is only defined for unsigned types, and it is
    equivalent to 32-(findMSB(x)+1).  This corresponds the clz() function in
    OpenCL and the LZD (leading zero detection) instruction on Intel GPUs.

    3) How does countTrailingZeros differ from findLSB?

    RESOLVED: countTrailingZeros is equivalent to min(genUType(findLSB(x)),
    32).  This corresponds to the ctz() function in OpenCL.

    4) Should 64-bit versions of countLeadingZeros and countTrailingZeros be
    provided?

    RESOLVED: NO.  OpenCL has 64-bit versions of clz() and ctz(), but OpenGL
    does not have 64-bit versions of findMSB() or findLSB() even when
    ARB_gpu_shader_int64 is supported.  The instructions used to implement
    countLeadingZeros and countTrailingZeros do not natively support 64-bit
    operands.

    The implementation of 64-bit countLeadingZeros() would be 5 instructions,
    and the implementation of 64-bit countTrailingZeros() would be 7
    instructions.  Neither of these is better than an application developer
    could achieve in GLSL:

        uint countLeadingZeros(uint64_t value)
        {
            uvec2 v = unpackUint2x32(value);

            return v.y == 0
                ? 32 + countLeadingZeros(v.x) : countLeadingZeros(v.y);
        }

        uint countTrailingZeros(uint64_t value)
        {
            uvec2 v = unpackUint2x32(value);

            return v.x == 0
                ? 32 + countTrailingZeros(v.y) : countTrailingZeros(v.x);
        }

    5) Should 64-bit versions of the arithmetic functions be provided?

    RESOLVED: NO.  Since recent generations of Intel GPUs have removed
    hardware support for 64-bit integer arithmetic, there doesn't seem to be
    much value in providing 64-bit arithmetic functions.

    6) Should this extension include average()?

    RESOLVED: YES.  average() corresponds to hadd() in OpenCL, and
    averageRounded() corresponds to rhadd() in OpenCL.

    averageRounded() corresponds to the AVG instruction on Intel GPUs.
    average(), on the other hand, does not correspond to a single instruction.
    The signed and unsigned versions may have slightly different
    implementations depending on the specific GPU.  In the worst case, the
    implementation is 4 instructions (e.g., averageRounded(x, y) - ((x ^ y) &
    1)), and in the best case it is 3 instructions.

Revision History

    Rev  Date         Author    Changes
    ---  -----------  --------  ---------------------------------------------
      1  04-Sep-2018  idr       Initial version.
      2  19-Sep-2018  idr       Add interactions with AMD_gpu_shader_int16.
      3  22-Jan-2019  idr       Add interactions with EXT_shader_explicit_arithmetic_types.
      4  14-Nov-2019  idr       Resolve issue #1 and issue #5.
      5  25-Nov-2019  idr       Fix a bunch of typos noticed by @cmarcelo.