Update on "[ET-VK] Clean up shader library and introduce some new conventions"

## Context

This changeset introduces some fairly mechnical improvements to the Vulkan compute graph shader library in order to introduce some new conventions.

**Note that backwards compatibility with existing shader authoring methods is preserved**.

### Only List `VALUE` in the `.yaml` files

Previously, to generate variants for a combination of vales, the YAML file will contain

```
    PACKING:
      - VALUE: CHANNELS_PACKED
        SUFFIX: C_packed
      - VALUE: WIDTH_PACKED
        SUFFIX: W_packed
      - VALUE: HEIGHT_PACKED
        SUFFIX: H_packed
```

however, the shader code generation script will use the `VALUE` as the `SUFFIX` if no `SUFFIX` is provided.

Therefore, only the below is needed:

```
    PACKING:
      - VALUE: C_packed
      - VALUE: W_packed
      - VALUE: H_packed
```

### Change indexing utility macros to lowercase

Indexing utility macros have been changed to lowercase, and the packing identifiers have been changed due to the change in YAML files.

The change to lowercase is to make calls to the macro read more like functions (and indeed they are typically used as functions) in order to help make the code more readable.

```
POS_TO_COORD_${PACKING} -> pos_to_coord_${PACKING}
```

### Use convention of defining macros in order to reduce Python code blocks usage

Previously python code blocks were used in the GLSL code itself in order to vary the shader between different settings. However, usage of Python code blocks negatively impact code readability. Therefore, this diff seeks to introduce a convention of defining macros near the top of the shader to reduce the usage of Python code blocks, i.e.

```
#define pos_to_coord pos_to_coord_${PACKING}
#define get_packed_dim get_packed_dim_${PACKING}
#define get_packed_stride get_packed_stride_${PACKING}
```

### Improve GLSL type definitions

Previously, the following Python code blocks were used to determine appropriate vectorized and scalar types:

```
${VEC4_T[DTYPE}} texel = ...
${T[DTYPE]} scalar = ...
```

This changeset replaces that with:

```

#define BUF_T ${buffer_scalar_type(DTYPE)}
#define VEC4_T ${texel_type(DTYPE)}
#define SCALAR_T ${texel_component_type(DTYPE)}

layout(set = 0, binding = 1) buffer  PRECISION restrict readonly Buffer {
  BUF_T data[];
}

buffer_in;
VEC4_T texel = ...
SCALAR_T scalar = ...
```

The main differences are as such:

* `buffer_scalar_type()` produces the same result as `T[DTYPE]`
* `texel_type()` is not determined from a mapping with `DTYPE`, but is determined indirectly based on the image format that is associated with the `DTYPE`.
* `texel_component_type()` is based on the result of `texel_type(DTYPE)`

Essentially, the mapping is more in-line with what happens in code.

The reason for this change is to enable FP16 support and is a bit complicated. Basically, we need a way to distinguish the scalar type used for buffer storage, vs the scalar type used to store a component of a vec4 type (hence `BUF_T` vs `SCALAR_T`). The reason this is required is that to support half-precision tensors, the buffer representation will use a 16-bit float type but textures will still extract to `vec4` (i.e. 4x34bit floats).

Differential Revision: [D56082461](https://our.internmc.facebook.com/intern/diff/D56082461/)

[ghstack-poisoned]

Author: SS-JIA

backends/vulkan/runtime/api/gen_vulkan_spv.py

@@ -77,24 +77,6 @@
         "int8": "rgba8i",
         "uint8": "rgba8ui",
     },
-    # Kept for backwards compatibility
-    # TODO(ssjia): remove when no more shaders use these
-    "VEC4_T": {
-        "float": "vec4",
-        "half": "vec4",
-        "int": "ivec4",
-        "uint": "uvec4",
-        "int8": "vec4",
-        "uint8": "uvec4",
-    },
-    "T": {
-        "float": "float",
-        "half": "float",
-        "int": "int",
-        "uint": "uint",
-        "int8": "int",
-        "uint8": "uint8",
-    },
 }
 
 

backends/vulkan/runtime/graph/ops/glsl/binary_op.glsl

@@ -10,13 +10,13 @@
 
 #define PRECISION ${PRECISION}
 
-#define op(X, Y, A) ${OPERATOR}
-
 #define VEC4_T ${texel_type(DTYPE)}
 
 #define to_tensor_idx to_tensor_idx_${PACKING}
 #define to_texture_pos to_texture_pos_${PACKING}
 
+#define op(X, Y, A) ${OPERATOR}
+
 #include "broadcasting_utils.h"
 #include "indexing_utils.h"
 

backends/vulkan/runtime/graph/ops/glsl/conv2d.glsl

@@ -9,6 +9,7 @@
 #version 450 core
 
 #define PRECISION ${PRECISION}
+
 #define VEC4_T ${texel_type(DTYPE)}
 
 #include "indexing_utils.h"

backends/vulkan/runtime/graph/ops/glsl/conv2d_dw.glsl

@@ -9,6 +9,7 @@
 #version 450 core
 
 #define PRECISION ${PRECISION}
+
 #define VEC4_T ${texel_type(DTYPE)}
 
 #include "indexing_utils.h"

backends/vulkan/runtime/graph/ops/glsl/conv2d_dw_output_tile.glsl

@@ -9,6 +9,7 @@
 #version 450 core
 
 #define PRECISION ${PRECISION}
+
 #define VEC4_T ${texel_type(DTYPE)}
 
 #include "indexing_utils.h"

backends/vulkan/runtime/graph/ops/glsl/conv2d_pw.glsl

@@ -9,6 +9,7 @@
 #version 450 core
 
 #define PRECISION ${PRECISION}
+
 #define VEC4_T ${texel_type(DTYPE)}
 
 #include "indexing_utils.h"

backends/vulkan/runtime/graph/ops/glsl/conv_transpose2d.glsl

@@ -9,6 +9,7 @@
 #version 450 core
 
 #define PRECISION ${PRECISION}
+
 #define VEC4_T ${texel_type(DTYPE)}
 
 layout(std430) buffer;

backends/vulkan/runtime/graph/ops/glsl/indexing_utils.h

@@ -48,45 +48,3 @@
       plane *                                                  \
           ((1 - y) * ((cur % (x * y * plane)) / (y * plane)) + \
            (x - 1) * ((cur % (y * plane)) / plane))
-
-// Kept for backwards compatibility
-// TODO(ssjia): remove once there are no shaders that use these macros
-
-#define DIVUP4(x) ((x + 3) / 4)
-
-#define PACKED_DIM_CHANNELS_PACKED(vec) vec.z
-
-#define PACKED_DIM_WIDTH_PACKED(vec) vec.x
-
-#define PACKED_DIM_HEIGHT_PACKED(vec) vec.y
-
-#define POS_TO_COORD_CHANNELS_PACKED(pos, sizes) \
-  ivec4(pos.x, pos.y, (pos.z * 4) % sizes.z, (pos.z * 4) / sizes.z)
-
-#define POS_TO_COORD_WIDTH_PACKED(pos, sizes) \
-  ivec4((pos.x * 4), pos.y, pos.z % sizes.z, pos.z / sizes.z)
-
-#define POS_TO_COORD_HEIGHT_PACKED(pos, sizes) \
-  ivec4(pos.x, (pos.y * 4), pos.z % sizes.z, pos.z / sizes.z)
-
-#define COORD_TO_POS_CHANNELS_PACKED(idx, sizes) \
-  ivec3(idx.x, idx.y, (idx.z + idx.w * sizes.z) / 4)
-
-#define COORD_TO_POS_WIDTH_PACKED(idx, sizes) \
-  ivec3(idx.x / 4, idx.y, (idx.z + idx.w * sizes.z))
-
-#define COORD_TO_POS_HEIGHT_PACKED(idx, sizes) \
-  ivec3(idx.x, idx.y / 4, (idx.z + idx.w * sizes.z))
-
-#define COORD_TO_POS_CHANNELS_PACKED(idx, sizes) \
-  ivec3(idx.x, idx.y, (idx.z + idx.w * sizes.z) / 4)
-
-#define COORD_TO_BUFFER_IDX(idx, sizes)              \
-  idx.x + idx.y* sizes.x + idx.z* sizes.y* sizes.x + \
-      idx.w* sizes.z* sizes.y* sizes.x;
-
-#define STRIDE_CHANNELS_PACKED(vec) (vec.x * vec.y)
-
-#define STRIDE_WIDTH_PACKED(vec) (1)
-
-#define STRIDE_HEIGHT_PACKED(vec) (vec.x)

backends/vulkan/runtime/graph/ops/glsl/unary_op.glsl

@@ -9,10 +9,11 @@
 #version 450 core
 
 #define PRECISION ${PRECISION}
-#define op(X, A, B) ${OPERATOR}
 
 #define VEC4_T ${texel_type(DTYPE)}
 
+#define op(X, A, B) ${OPERATOR}
+
 layout(std430) buffer;
 
 layout(set = 0, binding = 0, ${IMAGE_FORMAT[DTYPE]}) uniform PRECISION restrict writeonly ${IMAGE_T[NDIM][DTYPE]} image_out;

backends/vulkan/test/glsl/binary_op_nobroadcast__test.glsl

@@ -7,11 +7,10 @@
  */
 
 #version 450 core
-// clang-format off
+
 #define PRECISION ${PRECISION}
 
-#define OP(X, Y) ${OPERATOR}
-// clang-format on
+#define op(X, Y) ${OPERATOR}
 
 layout(std430) buffer;
 
@@ -38,5 +37,5 @@ void main() {
   vec4 in_texel = texelFetch(image_in, pos, 0);
   vec4 other_texel = texelFetch(image_other, pos, 0);
 
-  imageStore(image_out, pos, OP(in_texel, other_texel));
+  imageStore(image_out, pos, op(in_texel, other_texel));
 }

backends/vulkan/test/glsl/fill_texture__test.glsl

@@ -7,15 +7,12 @@
  */
 
 #version 450 core
+
 #define PRECISION ${PRECISION}
 
 layout(std430) buffer;
 
-/* Qualifiers: layout - storage - precision - memory */
-
-// clang-format off
 layout(set = 0, binding = 0, ${IMAGE_FORMAT[DTYPE]}) uniform PRECISION restrict writeonly ${IMAGE_T[NDIM][DTYPE]} uOutput;
-// clang-format on
 layout(set = 0, binding = 1) uniform PRECISION restrict Block {
   ivec3 size;
   int fill;

backends/vulkan/test/glsl/idx_fill_texture.glsl

@@ -10,12 +10,12 @@
 
 #define PRECISION ${PRECISION}
 
+#define VEC4_T ${texel_type(DTYPE)}
+
 #include "indexing_utils.h"
 
 layout(std430) buffer;
 
-#define VEC4_T ${texel_type(DTYPE)}
-
 layout(set = 0, binding = 0, ${IMAGE_FORMAT[DTYPE]}) uniform PRECISION restrict writeonly ${IMAGE_T[NDIM][DTYPE]} image_out;
 
 layout(set = 0, binding = 1) uniform PRECISION restrict GpuSizes {

backends/vulkan/test/glsl/test_shader.glsl

@@ -7,12 +7,11 @@
  */
 
 #version 450 core
+
 #define PRECISION ${PRECISION}
 
 layout(std430) buffer;
 
-/* Qualifiers: layout - storage - precision - memory */
-
 layout(set = 0, binding = 0, rgba32f) uniform PRECISION restrict writeonly image3D   uOutput;
 layout(set = 0, binding = 1) uniform PRECISION sampler3D uInput;
 layout(set = 0, binding = 2) uniform PRECISION restrict Block {