layers/gpuav/shaders/validation_cmd/memcmp.comp

// Copyright (c) 2022-2026 The Khronos Group Inc.
// Copyright (c) 2022-2026 Valve Corporation
// Copyright (c) 2022-2026 LunarG, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#version 460
#extension GL_GOOGLE_include_directive : enable
#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require
#extension GL_EXT_shader_explicit_arithmetic_types_int16 : require
#extension GL_EXT_debug_printf : enable

#include "common.h"
#include "memcmp.h"

layout(push_constant, scalar)
uniform PushConstants {
    MemShaderPushData pc;
};

// CPU will try to dispatch `primitive_count` threads
layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;

layout(buffer_reference, scalar) buffer ArrayUVec4 { uvec4 array[]; };
layout(buffer_reference, scalar) buffer ArrayU32 { uint array[]; };
layout(buffer_reference, scalar) buffer ArrayU16 { uint16_t array[]; };
layout(buffer_reference, scalar) buffer ArrayU8 { uint8_t array[]; };

const uint sizeof_u32 = 4;
const uint sizeof_u16 = 2;
const uint sizeof_uvec4 = 4 * sizeof_u32;

void main() {
    const uint gid = gl_GlobalInvocationID.x;

    // First work on as many uvec4 as possible
    if (gid < pc.uvec4_count) {
        ArrayUVec4 update_time_indices_uvec4_addr = ArrayUVec4(pc.update_time_indices_addr);
        ArrayUVec4 build_time_indices_uvec4_addr = ArrayUVec4(pc.build_time_indices_addr);
        const uvec4 update_time_indices_uvec4 = update_time_indices_uvec4_addr.array[gid];
        const uvec4 build_time_indices_uvec4 = build_time_indices_uvec4_addr.array[gid];
        if (update_time_indices_uvec4 != build_time_indices_uvec4) {
            uint update_time_indices_diff = 0;
            uint build_time_indices_diff = 0;
            uint uint_diff_i = 0;
            for (uint i = 0; i < 4; ++i) {
                if (update_time_indices_uvec4[i] != build_time_indices_uvec4[i]) {
                    update_time_indices_diff = update_time_indices_uvec4[i];
                    build_time_indices_diff = build_time_indices_uvec4[i];
                    uint_diff_i = i;
                }
            }

            GpuavLogError5(kErrorGroup_GpuPreBuildAccelerationStructures,
                           kErrorSubCode_PreBuildAccelerationStructures_IndexBufferUpdated,
                           pc.error_info_i,
                           gid * sizeof_uvec4 + uint_diff_i * sizeof_u32,
                           kMemcmp_uvec4_diff,
                           update_time_indices_diff,
                           build_time_indices_diff);
        }
        return;
    }

    // Then look at trailing u32(s)
    if (gid < (pc.u32_count + pc.uvec4_count)) {
        const uint u32_i = gid - pc.uvec4_count;
        const uint u32_start_byte_offset = pc.uvec4_count * sizeof_uvec4;
        ArrayU32 update_time_indices_uint_addr = ArrayU32(pc.update_time_indices_addr + u32_start_byte_offset);
        ArrayU32 build_time_indices_uint_addr = ArrayU32(pc.build_time_indices_addr + u32_start_byte_offset);
        const uint update_time_indices_u32 = update_time_indices_uint_addr.array[u32_i];
        const uint build_time_indices_u32 = build_time_indices_uint_addr.array[u32_i];

        if (update_time_indices_u32 != build_time_indices_u32) {
            GpuavLogError5(kErrorGroup_GpuPreBuildAccelerationStructures,
                           kErrorSubCode_PreBuildAccelerationStructures_IndexBufferUpdated,
                           pc.error_info_i,
                           u32_start_byte_offset + u32_i * sizeof_u32,
                           kMemcmp_u32_diff,
                           update_time_indices_u32,
                           build_time_indices_u32);
        }
        return;
    }

    // Then look at trailing u16
    if (gid < (pc.u32_count + pc.uvec4_count + pc.u16_count)) {
        const uint u16_i = gid - pc.uvec4_count - pc.u32_count;
        const uint u16_start_byte_offset = pc.uvec4_count * sizeof_uvec4 + pc.u32_count * sizeof_u32;
        ArrayU16 update_time_indices_u16_addr = ArrayU16(pc.update_time_indices_addr + u16_start_byte_offset);
        ArrayU16 build_time_indices_u16_addr = ArrayU16(pc.build_time_indices_addr + u16_start_byte_offset);
        const uint16_t update_time_indices_u16 = update_time_indices_u16_addr.array[u16_i];
        const uint16_t build_time_indices_u16 = build_time_indices_u16_addr.array[u16_i];
        if (update_time_indices_u16 != build_time_indices_u16) {
            GpuavLogError5(kErrorGroup_GpuPreBuildAccelerationStructures,
                           kErrorSubCode_PreBuildAccelerationStructures_IndexBufferUpdated,
                           pc.error_info_i,
                           u16_start_byte_offset + u16_i * sizeof_u16,
                           kMemcmp_u16_diff,
                           uint(update_time_indices_u16),
                           uint(build_time_indices_u16));
        }
        return;
    }

    if (gid >= (pc.u32_count + pc.uvec4_count + pc.u16_count)) {
        return;
    }
}