xref: /third_party/openGLES/extensions/NV/NV_gpu_program5_mem_extended.txt

Name

    NV_gpu_program5_mem_extended

Name Strings

    GL_NV_gpu_program5_mem_extended

Contact

    Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com)

Status

    Shipping.

Version

    Last Modified Date:         October 30, 2012
    NVIDIA Revision:            1

Number

    OpenGL Extension #434

Dependencies

    NV_gpu_program5 is required.

    This extension is written against the NV_gpu_program5 extension
    specification, which itself is written against the NV_gpu_program4 and
    OpenGL 2.0 Specifications.

    This extension interacts trivially with EXT_shader_image_load_store,
    NV_shader_storage_buffer_object, and NV_compute_program5.

Overview

    This extension provides a new set of storage modifiers that can be used by
    NV_gpu_program5 assembly program instructions loading from or storing to
    various forms of GPU memory.  In particular, we provide support for loads
    and stores using the storage modifiers:

        .F16X2  .F16X4  .F16    (for 16-bit floating-point scalars/vectors)
        .S8X2   .S8X4           (for 8-bit signed integer vectors)
        .S16X2  .S16X4          (for 16-bit signed integer vectors)
        .U8X2   .U8X4           (for 8-bit unsigned integer vectors)
        .U16X2  .U16X4          (for 16-bit unsigned integer vectors)

    These modifiers are allowed for the following load/store instructions:

        LDC             Load from constant buffer

        LOAD            Global load
        STORE           Global store

        LOADIM          Image load (via EXT_shader_image_load_store)
        STOREIM         Image store (via EXT_shader_image_load_store)

        LDB             Load from storage buffer (via 
                          NV_shader_storage_buffer_object) 
        STB             Store to storage buffer (via 
                          NV_shader_storage_buffer_object) 

        LDS             Load from shared memory (via NV_compute_program5)
        STS             Store to shared memory (via NV_compute_program5)

    For assembly programs prior to this extension, it was necessary to access
    memory using packed types and then unpack with additional shader
    instructions.

    Similar capabilities have already been provided in the OpenGL Shading
    Language (GLSL) via the NV_gpu_shader5 extension, using the extended data
    types provided there (e.g., "float16_t", "u8vec4", "s16vec2").

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_gpu_program5_mem_extended program option, the following rules are added
    to the NV_gpu_program5 base program grammar:

    <opModifier>            ::= "F16X2"
                              | "F16X4"
                              | "S8X2"
                              | "S8X4"
                              | "S16X2"
                              | "S16X4"
                              | "U8X2"
                              | "U8X4"
                              | "U16X2"
                              | "U16X4"

    (Note:  This extension also provides new capabilities for the "F16"
     modifier.  Since it was already supported in NV_gpu_program5, it isn't
     being added to the grammar here.)


    Modify Section 2.X.4.1, Program Instruction Modifiers

    (add to Table X.14 of the NV_gpu_program4 specification.)

      Modifier  Description
      --------  ---------------------------------------------------
      F16       Convert to or from one 16-bit floating-point value, 
                or access one 16-bit floating-point value

      F16X2     Access two 16-bit floating-point values
      F16X4     Access four 16-bit floating-point values
      S8X2      Access two 8-bit signed integer values
      S8X4      Access four 8-bit signed integer values
      S16X2     Access two 16-bit signed integer values
      S16X4     Access four 16-bit signed integer values
      U8X2      Access two 8-bit unsigned integer values
      U8X4      Access four 8-bit unsigned integer values
      U16X2     Access two 16-bit unsigned integer values
      U16X4     Access four 16-bit unsigned integer values

    (modify discussion of storage modifiers for load and store operations,
     adding the entries added to the table above)

    For load and store operations, the "F32", "F32X2", "F32X4", "F64",
    "F64X2", "F64X4", "S8", "S8X2", "S8X4", "S16", "S16X2", "S16X4", "S32",
    "S32X2", "S32X4", "S64", "S64X2", "S64X4", "U8", "U8X2", "U8X4", "U16",
    "U16X2", "U16X4", "U32", "U32X2", "U32X4", "U64", "U64X2", "U64X4", "F16",
    "F16X2", and "F16X4" storage modifiers control how data are loaded from or
    stored to memory. ...


    Modify Section 2.X.4.5, Program Memory Access, from NV_gpu_program5

    (update pseudocode for BufferMemoryLoad)

      result_t_vec BufferMemoryLoad(char *address, OpModifier modifier)
      {
        result_t_vec result = { 0, 0, 0, 0 };
        switch (modifier) {
        
        /* Existing cases and code from NV_gpu_program5 unchanged. */

        case F16:
            result.x = ((float16_t *)address)[0];
            break;
        case F16X2:
            result.x = ((float16_t *)address)[0];
            result.y = ((float16_t *)address)[1];
            break;
        case S8X2:
            result.x = ((int8_t *)address)[0];
            result.y = ((int8_t *)address)[1];
            break;
        case S8X4:
            result.x = ((int8_t *)address)[0];
            result.y = ((int8_t *)address)[1];
            result.z = ((int8_t *)address)[2];
            result.w = ((int8_t *)address)[3];
            break;
        case S16X2:
            result.x = ((int16_t *)address)[0];
            result.y = ((int16_t *)address)[1];
            break;
        case S16X4:
            result.x = ((int16_t *)address)[0];
            result.y = ((int16_t *)address)[1];
            result.z = ((int16_t *)address)[2];
            result.w = ((int16_t *)address)[3];
            break;
        case U8X2:
            result.x = ((uint8_t *)address)[0];
            result.y = ((uint8_t *)address)[1];
            break;
        case U8X4:
            result.x = ((uint8_t *)address)[0];
            result.y = ((uint8_t *)address)[1];
            result.z = ((uint8_t *)address)[2];
            result.w = ((uint8_t *)address)[3];
            break;
        case U16X2:
            result.x = ((uint16_t *)address)[0];
            result.y = ((uint16_t *)address)[1];
            break;
        case U16X4:
            result.x = ((uint16_t *)address)[0];
            result.y = ((uint16_t *)address)[1];
            result.z = ((uint16_t *)address)[2];
            result.w = ((uint16_t *)address)[3];
            break;
        }
        return result;
      }

    (update pseudocode for BufferMemoryStore)

      void BufferMemoryStore(char *address, operand_t_vec operand, 
                             OpModifier modifier)
      {
        switch (modifier) {

        /* Existing cases and code from NV_gpu_program5 unchanged. */

        case F16:
            ((float16_t *)address)[0] = operand.x;
            break;
        case F16X2:
            ((float16_t *)address)[0] = operand.x;
            ((float16_t *)address)[1] = operand.y;
            break;
        case S8X2:
            ((int8_t *)address)[0] = operand.x;
            ((int8_t *)address)[1] = operand.y;
            break;
        case S8X4:
            ((int8_t *)address)[0] = operand.x;
            ((int8_t *)address)[1] = operand.y;
            ((int8_t *)address)[2] = operand.z;
            ((int8_t *)address)[3] = operand.w;
            break;
        case S16X2:
            ((int16_t *)address)[0] = operand.x;
            ((int16_t *)address)[1] = operand.y;
            break;
        case S16X4:
            ((int16_t *)address)[0] = operand.x;
            ((int16_t *)address)[1] = operand.y;
            ((int16_t *)address)[2] = operand.z;
            ((int16_t *)address)[3] = operand.w;
            break;
        case U8X2:
            ((uint8_t *)address)[0] = operand.x;
            ((uint8_t *)address)[1] = operand.y;
            break;
        case U8X4:
            ((uint8_t *)address)[0] = operand.x;
            ((uint8_t *)address)[1] = operand.y;
            ((uint8_t *)address)[2] = operand.z;
            ((uint8_t *)address)[3] = operand.w;
            break;
        case U16X2:
            ((uint16_t *)address)[0] = operand.x;
            ((uint16_t *)address)[1] = operand.y;
            break;
        case U16X4:
            ((uint16_t *)address)[0] = operand.x;
            ((uint16_t *)address)[1] = operand.y;
            ((uint16_t *)address)[2] = operand.z;
            ((uint16_t *)address)[3] = operand.w;
            break;
        }
      }

    (modify paragraph to indicate the alignment requirement for new storage
    modifiers) The address used for global memory loads or stores or offset
    used for constant buffer loads must be aligned to the fetch size
    corresponding to the storage opcode modifier.  For S8 and U8, the offset
    has no alignment requirements.  For F16, S8X2, S16, U8X2, and U16, the
    offset must be a multiple of two basic machine units.  For F32, S32, and
    U32, F16X2, S16X2, U16X2, S8X4, and U8X4, the offset must be a multiple of
    four.  For F32X2, F64, S32X2, S64, U32X2, U64, S16X4, and U16X4, the
    offset must be a multiple of eight.  ...  If an offset is not correctly
    aligned, the values returned by a buffer memory load will be undefined,
    and the effects of a buffer memory store will also be undefined.


    Modify Section 2.X.6, Program Options

    + Extended Memory Format Support (NV_gpu_program5_mem_extended)

    If a program specifies the "NV_gpu_program5_mem_extended" option, it may
    use the "F16", "F16X2", "F16X4", "S8X2", "S8X4", "S16X2", "S16X4", "U8X2",
    "U8X4", "U16X2", and "U16X4" storage modifiers on instructions loading
    values from memory or storing values to memory (LDC, LOAD, STORE, LOADIM,
    STOREIM, LDB, STB, LDS, STS).


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.

Dependencies on EXT_shader_image_load_store, NV_shader_storage_buffer_object,
and NV_compute_program5

    If EXT_shader_image_load_store is not supported, references to the LOADIM
    and STOREIM opcodes should be removed.

    If NV_shader_storage_buffer_object is not supported, references to the LDB
    and STB opcodes should be removed.

    If NV_compute_program5 is not supported, references to the LDS and STS
    opcodes should be removed.

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 inferred from the NV_gpu_program5 extension or some
        other extension?

      RESOLVED:  Provide a separate extension string entry, since this
      functionality was added after NV_gpu_program5 was published and may not
      be available on older drivers supporting NV_gpu_program5.

Revision History

    Revision 1, October 30, 2012 (pbrown):  Initial revision.