xref: /aosp_15_r20/external/deqp/external/vulkancts/modules/vulkan/mesh_shader/vktMeshShaderSyncTestsEXT.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2021 The Khronos Group Inc.
 * Copyright (c) 2021 Valve Corporation.
 *
 * 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.
 *
 *//*!
 * \file
 * \brief Mesh Shader Synchronization Tests for VK_EXT_mesh_shader
 *//*--------------------------------------------------------------------*/

#include "vktMeshShaderSyncTestsEXT.hpp"
#include "vktMeshShaderUtil.hpp"
#include "vktTestCase.hpp"

#include "vkDefs.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBufferWithMemory.hpp"
#include "vkObjUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkBarrierUtil.hpp"
#include "vkImageUtil.hpp"

#include "deUniquePtr.hpp"

#include <iostream>
#include <sstream>
#include <vector>
#include <set>

namespace vkt
{
namespace MeshShader
{

namespace
{

using GroupPtr = de::MovePtr<tcu::TestCaseGroup>;

using namespace vk;

// Stages that will be used in these tests. Shader stages sorted in pipeline order.
enum class Stage
{
    HOST = 0,
    TRANSFER,
    TASK,
    MESH,
    FRAG,
};

std::ostream &operator<<(std::ostream &stream, Stage stage)
{
    switch (stage)
    {
    case Stage::HOST:
        stream << "host";
        break;
    case Stage::TRANSFER:
        stream << "transfer";
        break;
    case Stage::TASK:
        stream << "task";
        break;
    case Stage::MESH:
        stream << "mesh";
        break;
    case Stage::FRAG:
        stream << "frag";
        break;
    default:
        DE_ASSERT(false);
        break;
    }

    return stream;
}

bool isShaderStage(Stage stage)
{
    return (stage == Stage::TASK || stage == Stage::MESH || stage == Stage::FRAG);
}

VkPipelineStageFlags stageToFlags(Stage stage)
{
    switch (stage)
    {
    case Stage::HOST:
        return VK_PIPELINE_STAGE_HOST_BIT;
    case Stage::TRANSFER:
        return VK_PIPELINE_STAGE_TRANSFER_BIT;
    case Stage::TASK:
        return VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT;
    case Stage::MESH:
        return VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
    case Stage::FRAG:
        return VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    default:
        DE_ASSERT(false);
        break;
    }

    // Unreachable.
    DE_ASSERT(false);
    return 0u;
}

VkFormat getImageFormat()
{
    return VK_FORMAT_R32_UINT;
}

VkExtent3D getImageExtent()
{
    return makeExtent3D(1u, 1u, 1u);
}

// Types of resources we will use.
enum class ResourceType
{
    UNIFORM_BUFFER = 0,
    STORAGE_BUFFER,
    STORAGE_IMAGE,
    SAMPLED_IMAGE,
};

VkDescriptorType resourceTypeToDescriptor(ResourceType resType)
{
    switch (resType)
    {
    case ResourceType::UNIFORM_BUFFER:
        return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    case ResourceType::STORAGE_BUFFER:
        return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
    case ResourceType::STORAGE_IMAGE:
        return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
    case ResourceType::SAMPLED_IMAGE:
        return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
    default:
        DE_ASSERT(false);
        break;
    }

    // Unreachable.
    DE_ASSERT(false);
    return VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
}

// Will the test use a specific barrier or a general memory barrier?
enum class BarrierType
{
    GENERAL = 0,
    SPECIFIC,
    DEPENDENCY,
};

// Types of writes we will use.
enum class WriteAccess
{
    HOST_WRITE = 0,
    TRANSFER_WRITE,
    SHADER_WRITE,
};

VkAccessFlags writeAccessToFlags(WriteAccess access)
{
    switch (access)
    {
    case WriteAccess::HOST_WRITE:
        return VK_ACCESS_HOST_WRITE_BIT;
    case WriteAccess::TRANSFER_WRITE:
        return VK_ACCESS_TRANSFER_WRITE_BIT;
    case WriteAccess::SHADER_WRITE:
        return VK_ACCESS_SHADER_WRITE_BIT;
    default:
        DE_ASSERT(false);
        break;
    }

    // Unreachable.
    DE_ASSERT(false);
    return 0u;
}

// Types of reads we will use.
enum class ReadAccess
{
    HOST_READ = 0,
    TRANSFER_READ,
    SHADER_READ,
    UNIFORM_READ,
};

VkAccessFlags readAccessToFlags(ReadAccess access)
{
    switch (access)
    {
    case ReadAccess::HOST_READ:
        return VK_ACCESS_HOST_READ_BIT;
    case ReadAccess::TRANSFER_READ:
        return VK_ACCESS_TRANSFER_READ_BIT;
    case ReadAccess::SHADER_READ:
        return VK_ACCESS_SHADER_READ_BIT;
    case ReadAccess::UNIFORM_READ:
        return VK_ACCESS_UNIFORM_READ_BIT;
    default:
        DE_ASSERT(false);
        break;
    }

    // Unreachable.
    DE_ASSERT(false);
    return 0u;
}

// Auxiliary functions to verify certain combinations are possible.

// Check if the writing stage can use the specified write access.
bool canWriteFromStageAsAccess(Stage writeStage, WriteAccess access)
{
    switch (writeStage)
    {
    case Stage::HOST:
        return (access == WriteAccess::HOST_WRITE);
    case Stage::TRANSFER:
        return (access == WriteAccess::TRANSFER_WRITE);
    case Stage::TASK: // fallthrough
    case Stage::MESH: // fallthrough
    case Stage::FRAG:
        return (access == WriteAccess::SHADER_WRITE);
    default:
        DE_ASSERT(false);
        break;
    }

    return false;
}

// Check if the reading stage can use the specified read access.
bool canReadFromStageAsAccess(Stage readStage, ReadAccess access)
{
    switch (readStage)
    {
    case Stage::HOST:
        return (access == ReadAccess::HOST_READ);
    case Stage::TRANSFER:
        return (access == ReadAccess::TRANSFER_READ);
    case Stage::TASK: // fallthrough
    case Stage::MESH: // fallthrough
    case Stage::FRAG:
        return (access == ReadAccess::SHADER_READ || access == ReadAccess::UNIFORM_READ);
    default:
        DE_ASSERT(false);
        break;
    }

    return false;
}

// Check if reading the given resource type is possible with the given type of read access.
bool canReadResourceAsAccess(ResourceType resType, ReadAccess access)
{
    if (access == ReadAccess::UNIFORM_READ)
        return (resType == ResourceType::UNIFORM_BUFFER);
    return true;
}

// Check if writing to the given resource type is possible with the given type of write access.
bool canWriteResourceAsAccess(ResourceType resType, WriteAccess access)
{
    if (resType == ResourceType::UNIFORM_BUFFER)
        return (access != WriteAccess::SHADER_WRITE);
    return true;
}

// Check if the given stage can write to the given resource type.
bool canWriteTo(Stage stage, ResourceType resType)
{
    switch (stage)
    {
    case Stage::HOST:
        return (resType == ResourceType::UNIFORM_BUFFER || resType == ResourceType::STORAGE_BUFFER);
    case Stage::TRANSFER:
        return true;
    case Stage::TASK: // fallthrough
    case Stage::MESH: // fallthrough
    case Stage::FRAG:
        return (resType == ResourceType::STORAGE_BUFFER || resType == ResourceType::STORAGE_IMAGE);
    default:
        DE_ASSERT(false);
        break;
    }

    return false;
}

// Check if the given stage can read from the given resource type.
bool canReadFrom(Stage stage, ResourceType resType)
{
    switch (stage)
    {
    case Stage::HOST:
        return (resType == ResourceType::UNIFORM_BUFFER || resType == ResourceType::STORAGE_BUFFER);
    case Stage::TRANSFER: // fallthrough
    case Stage::TASK:     // fallthrough
    case Stage::MESH:     // fallthrough
    case Stage::FRAG:
        return true;
    default:
        DE_ASSERT(false);
        break;
    }

    return false;
}

// Will we need to store the test value in an auxiliar buffer to be read?
bool needsAuxiliarSourceBuffer(Stage fromStage, Stage toStage)
{
    DE_UNREF(toStage);
    return (fromStage == Stage::TRANSFER);
}

// Will we need to store the read operation result into an auxiliar buffer to be checked?
bool needsAuxiliarDestBuffer(Stage fromStage, Stage toStage)
{
    DE_UNREF(fromStage);
    return (toStage == Stage::TRANSFER);
}

// Needs any auxiliar buffer for any case?
bool needsAuxiliarBuffer(Stage fromStage, Stage toStage)
{
    return (needsAuxiliarSourceBuffer(fromStage, toStage) || needsAuxiliarDestBuffer(fromStage, toStage));
}

// Will the final value be stored in the auxiliar destination buffer?
bool valueInAuxiliarDestBuffer(Stage toStage)
{
    return (toStage == Stage::TRANSFER);
}

// Will the final value be stored in the resource buffer itself?
bool valueInResourceBuffer(Stage toStage)
{
    return (toStage == Stage::HOST);
}

// Will the final value be stored in the color buffer?
bool valueInColorBuffer(Stage toStage)
{
    return (!valueInAuxiliarDestBuffer(toStage) && !valueInResourceBuffer(toStage));
}

// Image usage flags for the image resource.
VkImageUsageFlags resourceImageUsageFlags(ResourceType resourceType)
{
    VkImageUsageFlags flags = (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);

    switch (resourceType)
    {
    case ResourceType::STORAGE_IMAGE:
        flags |= VK_IMAGE_USAGE_STORAGE_BIT;
        break;
    case ResourceType::SAMPLED_IMAGE:
        flags |= VK_IMAGE_USAGE_SAMPLED_BIT;
        break;
    default:
        DE_ASSERT(false);
        break;
    }

    return flags;
}

// Buffer usage flags for the buffer resource.
VkBufferUsageFlags resourceBufferUsageFlags(ResourceType resourceType)
{
    VkBufferUsageFlags flags = (VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);

    switch (resourceType)
    {
    case ResourceType::UNIFORM_BUFFER:
        flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
        break;
    case ResourceType::STORAGE_BUFFER:
        flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
        break;
    default:
        DE_ASSERT(false);
        break;
    }

    return flags;
}

// Returns true if both the write and read stages are shader stages.
bool fromShaderToShader(Stage fromStage, Stage toStage)
{
    return (isShaderStage(fromStage) && isShaderStage(toStage));
}

// Supposing we'll use two subpasses, decide the stages of a subpass based on the mandatory stages and the one we're interested in.
std::vector<Stage> subpassStages(Stage wantedStage, bool lastSubpass)
{
    std::set<Stage> stages;
    stages.insert(wantedStage);
    stages.insert(Stage::MESH); // This one is mandatory.
    if (lastSubpass)
        stages.insert(Stage::FRAG); // In the last subpass we always need a fragment shader (passthrough).
    return std::vector<Stage>(begin(stages), end(stages));
}

// Is the task shader in the list?
bool hasTask(const std::vector<Stage> &stages)
{
    return de::contains(begin(stages), end(stages), Stage::TASK);
}

// Is the frag shader in the list?
bool hasFrag(const std::vector<Stage> &stages)
{
    return de::contains(begin(stages), end(stages), Stage::FRAG);
}

struct TestParams
{
    Stage fromStage;
    Stage toStage;
    ResourceType resourceType;
    BarrierType barrierType;
    WriteAccess writeAccess;
    ReadAccess readAccess;
    uint32_t testValue;

protected:
    bool readsOrWritesIn(Stage stage) const
    {
        DE_ASSERT(fromStage != toStage);
        return (fromStage == stage || toStage == stage);
    }

public:
    bool needsTask() const
    {
        return readsOrWritesIn(Stage::TASK);
    }

    bool readsOrWritesInMesh() const
    {
        return readsOrWritesIn(Stage::MESH);
    }

    std::string getResourceDecl() const
    {
        const auto imgFormat     = ((resourceType == ResourceType::STORAGE_IMAGE) ? ", r32ui" : "");
        const auto storagePrefix = ((writeAccess == WriteAccess::SHADER_WRITE) ? "" : "readonly ");
        std::ostringstream decl;

        decl << "layout (set=0, binding=0" << imgFormat << ") ";
        switch (resourceType)
        {
        case ResourceType::UNIFORM_BUFFER:
            decl << "uniform UniformBuffer { uint value; } ub;";
            break;
        case ResourceType::STORAGE_BUFFER:
            decl << storagePrefix << "buffer StorageBuffer { uint value; } sb;";
            break;
        case ResourceType::STORAGE_IMAGE:
            decl << storagePrefix << "uniform uimage2D si;";
            break;
        case ResourceType::SAMPLED_IMAGE:
            decl << "uniform usampler2D sampled;";
            break;
        default:
            DE_ASSERT(false);
            break;
        }

        decl << "\n";
        return decl.str();
    }

    struct PushConstantStruct
    {
        uint32_t writeVal;
        uint32_t readVal;
    };

    // Get declaration for the "pc" push constant block. Must match the structure above.
    std::string getPushConstantDecl() const
    {
        std::ostringstream pc;
        pc << "layout (push_constant, std430) uniform PushConstantBlock {\n"
           << "    uint writeVal;\n"
           << "    uint readVal;\n"
           << "} pc;\n";
        return pc.str();
    }

    std::string getReadStatement(const std::string &outName) const
    {
        std::ostringstream statement;
        statement << "    if (pc.readVal > 0u) { " << outName << " = ";

        switch (resourceType)
        {
        case ResourceType::UNIFORM_BUFFER:
            statement << "ub.value";
            break;
        case ResourceType::STORAGE_BUFFER:
            statement << "sb.value";
            break;
        case ResourceType::STORAGE_IMAGE:
            statement << "imageLoad(si, ivec2(0, 0)).x";
            break;
        case ResourceType::SAMPLED_IMAGE:
            statement << "texture(sampled, vec2(0.5, 0.5)).x";
            break;
        default:
            DE_ASSERT(false);
            break;
        }

        statement << "; }\n";
        return statement.str();
    }

    std::string getWriteStatement(const std::string &valueName) const
    {
        std::ostringstream statement;
        statement << "    if (pc.writeVal > 0u) { ";

        switch (resourceType)
        {
        case ResourceType::STORAGE_BUFFER:
            statement << "sb.value = " << valueName;
            break;
        case ResourceType::STORAGE_IMAGE:
            statement << "imageStore(si, ivec2(0, 0), uvec4(" << valueName << ", 0, 0, 0))";
            break;
        case ResourceType::UNIFORM_BUFFER: // fallthrough
        case ResourceType::SAMPLED_IMAGE:  // fallthrough
        default:
            DE_ASSERT(false);
            break;
        }

        statement << "; }\n";
        return statement.str();
    }

    VkShaderStageFlags getResourceShaderStages() const
    {
        VkShaderStageFlags flags = 0u;

        if (fromStage == Stage::TASK || toStage == Stage::TASK)
            flags |= VK_SHADER_STAGE_TASK_BIT_EXT;
        if (fromStage == Stage::MESH || toStage == Stage::MESH)
            flags |= VK_SHADER_STAGE_MESH_BIT_EXT;
        if (fromStage == Stage::FRAG || toStage == Stage::FRAG)
            flags |= VK_SHADER_STAGE_FRAGMENT_BIT;

        // We assume at least something must be done either on the task or mesh shaders for the tests to be interesting.
        DE_ASSERT((flags & (VK_SHADER_STAGE_TASK_BIT_EXT | VK_SHADER_STAGE_MESH_BIT_EXT)) != 0u);
        return flags;
    }

    // We'll prefer to keep the image in the general layout if it will be written to from a shader stage or if the barrier is going to be a generic memory barrier.
    bool preferGeneralLayout() const
    {
        return (isShaderStage(fromStage) || (barrierType == BarrierType::GENERAL) ||
                (resourceType == ResourceType::STORAGE_IMAGE));
    }

    // We need two pipelines if both the writing and reading stage are shaders, and either:
    // - The writing stage comes after the reading stage in the pipeline.
    // - The barrier to use is not a dependency.
    bool needsTwoPipelines() const
    {
        return (fromShaderToShader(fromStage, toStage) &&
                (static_cast<int>(fromStage) >= static_cast<int>(toStage) || barrierType != BarrierType::DEPENDENCY));
    }

    // We need to use generic barriers when using subpass self-dependencies (single subpass and pipeline).
    // Note: barrierType == BarrierType::DEPENDENCY is technically redundant with !needsTwoPipelines().
    bool subpassSelfDependency() const
    {
        return (fromShaderToShader(fromStage, toStage) && barrierType == BarrierType::DEPENDENCY &&
                !needsTwoPipelines());
    }
};

class MeshShaderSyncCase : public vkt::TestCase
{
public:
    MeshShaderSyncCase(tcu::TestContext &testCtx, const std::string &name, const TestParams &params)
        : vkt::TestCase(testCtx, name)
        , m_params(params)
    {
    }

    virtual ~MeshShaderSyncCase(void)
    {
    }

    void checkSupport(Context &context) const override;
    void initPrograms(vk::SourceCollections &programCollection) const override;
    TestInstance *createInstance(Context &context) const override;

protected:
    TestParams m_params;
};

class MeshShaderSyncInstance : public vkt::TestInstance
{
public:
    MeshShaderSyncInstance(Context &context, const TestParams &params) : vkt::TestInstance(context), m_params(params)
    {
    }
    virtual ~MeshShaderSyncInstance(void)
    {
    }

    tcu::TestStatus iterate(void) override;

protected:
    TestParams m_params;
};

void MeshShaderSyncCase::checkSupport(Context &context) const
{
    checkTaskMeshShaderSupportEXT(context, m_params.needsTask(), true);

    if (m_params.writeAccess == WriteAccess::SHADER_WRITE)
    {
        context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS);
    }
}

void MeshShaderSyncCase::initPrograms(vk::SourceCollections &programCollection) const
{
    const auto buildOptions    = getMinMeshEXTBuildOptions(programCollection.usedVulkanVersion);
    const bool needsTaskShader = m_params.needsTask();
    const auto valueStr        = de::toString(m_params.testValue);
    const auto resourceDecl    = m_params.getResourceDecl();
    const auto pcDecl          = m_params.getPushConstantDecl();
    const std::string tdDecl   = "struct TaskData { uint value; }; taskPayloadSharedEXT TaskData td;\n";

    if (needsTaskShader)
    {
        std::ostringstream task;
        task << "#version 450\n"
             << "#extension GL_EXT_mesh_shader : enable\n"
             << "\n"
             << "layout(local_size_x=1) in;\n"
             << "\n"
             << tdDecl << "\n"
             << resourceDecl << pcDecl << "\n"
             << "void main ()\n"
             << "{\n"
             << "    td.value = 0u;\n"
             << ((m_params.fromStage == Stage::TASK) ? m_params.getWriteStatement(valueStr) : "")
             << ((m_params.toStage == Stage::TASK) ? m_params.getReadStatement("td.value") : "")
             << "    EmitMeshTasksEXT(1u, 1u, 1u);\n"
             << "}\n";
        programCollection.glslSources.add("task") << glu::TaskSource(task.str()) << buildOptions;
    }

    {
        // In the mesh-to-task case, we need non-passthrough mesh and task shaders but the mesh shader doesn't have a previous task shader.
        // In the task-to-mesh case, the second pipeline will have the main mesh shader but no previous task shader either.
        const bool prevTaskInMainMesh =
            (needsTaskShader && !(m_params.fromStage == Stage::MESH && m_params.toStage == Stage::TASK) &&
             !(m_params.fromStage == Stage::TASK && m_params.toStage == Stage::MESH));
        const bool rwInMeshStage = m_params.readsOrWritesInMesh();

        std::ostringstream mesh;
        mesh << "#version 450\n"
             << "#extension GL_EXT_mesh_shader : enable\n"
             << "\n"
             << "layout(local_size_x=1) in;\n"
             << "layout(triangles) out;\n"
             << "layout(max_vertices=3, max_primitives=1) out;\n"
             << "\n"
             << (prevTaskInMainMesh ? tdDecl : "") << "layout (location=0) out perprimitiveEXT uint primitiveValue[];\n"
             << "\n"
             << (rwInMeshStage ? resourceDecl : "") << (rwInMeshStage ? pcDecl : "") << "\n"
             << "void main ()\n"
             << "{\n"
             << "    SetMeshOutputsEXT(3u, 1u);\n"
             << (prevTaskInMainMesh ? "    primitiveValue[0] = td.value;\n" : "")
             << ((m_params.fromStage == Stage::MESH) ? m_params.getWriteStatement(valueStr) : "")
             << ((m_params.toStage == Stage::MESH) ? m_params.getReadStatement("primitiveValue[0]") : "") << "\n"
             << "    gl_MeshVerticesEXT[0].gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
             << "    gl_MeshVerticesEXT[1].gl_Position = vec4(-1.0,  3.0, 0.0, 1.0);\n"
             << "    gl_MeshVerticesEXT[2].gl_Position = vec4( 3.0, -1.0, 0.0, 1.0);\n"
             << "    gl_PrimitiveTriangleIndicesEXT[0] = uvec3(0, 1, 2);\n"
             << "}\n";
        programCollection.glslSources.add("mesh") << glu::MeshSource(mesh.str()) << buildOptions;
    }

    {
        const bool readFromFrag  = (m_params.toStage == Stage::FRAG);
        const bool writeFromFrag = (m_params.fromStage == Stage::FRAG);
        const bool rwInFragStage = (readFromFrag || writeFromFrag);
        std::ostringstream frag;

        frag << "#version 450\n"
             << "#extension GL_EXT_mesh_shader : enable\n"
             << "\n"
             << "layout (location=0) in perprimitiveEXT flat uint primitiveValue;\n"
             << "layout (location=0) out uvec4 outColor;\n"
             << "\n"
             << (rwInFragStage ? resourceDecl : "") << (rwInFragStage ? pcDecl : "") << "\n"
             << "void main ()\n"
             << "{\n"
             << "    outColor = uvec4(primitiveValue, 0, 0, 0);\n"
             << "    uint readVal = 0u;\n"
             << (readFromFrag ? m_params.getReadStatement("readVal") : "")
             << (readFromFrag ? "    outColor = uvec4(readVal, 0, 0, 0);\n" : "")
             << (writeFromFrag ? m_params.getWriteStatement(valueStr) : "") << "}\n";
        programCollection.glslSources.add("frag") << glu::FragmentSource(frag.str()) << buildOptions;
    }

    // Passthrough shaders.
    {
        const std::string task = "#version 450\n"
                                 "#extension GL_EXT_mesh_shader : enable\n"
                                 "\n"
                                 "layout(local_size_x=1) in;\n"
                                 "\n" +
                                 tdDecl +
                                 "\n"
                                 "void main ()\n"
                                 "{\n"
                                 "    td.value = 0u;\n"
                                 "    EmitMeshTasksEXT(1u, 1u, 1u);\n"
                                 "}\n";
        programCollection.glslSources.add("taskPassthrough") << glu::TaskSource(task) << buildOptions;

        const std::string frag = "#version 450\n"
                                 "#extension GL_EXT_mesh_shader : enable\n"
                                 "\n"
                                 "layout (location=0) in perprimitiveEXT flat uint primitiveValue;\n"
                                 "layout (location=0) out uvec4 outColor;\n"
                                 "\n"
                                 "void main ()\n"
                                 "{\n"
                                 "    outColor = uvec4(primitiveValue, 0, 0, 0);\n"
                                 "}\n";
        programCollection.glslSources.add("fragPassthrough") << glu::FragmentSource(frag) << buildOptions;

        for (int i = 0; i < 2; ++i)
        {
            const bool prevTask          = (i > 0);
            const std::string nameSuffix = (prevTask ? "WithTask" : "");
            const std::string mesh       = "#version 450\n"
                                           "#extension GL_EXT_mesh_shader : enable\n"
                                           "\n"
                                           "layout(local_size_x=1) in;\n"
                                           "layout(triangles) out;\n"
                                           "layout(max_vertices=3, max_primitives=1) out;\n"
                                           "\n" +
                                     (prevTask ? tdDecl : "") +
                                     "layout (location=0) out perprimitiveEXT uint primitiveValue[];\n"
                                     "\n"
                                     "void main ()\n"
                                     "{\n"
                                     "    SetMeshOutputsEXT(3u, 1u);\n"
                                     "    " +
                                     (prevTask ? "primitiveValue[0] = td.value;" : "primitiveValue[0] = 0u;") +
                                     "\n"
                                     "\n"
                                     "    gl_MeshVerticesEXT[0].gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
                                     "    gl_MeshVerticesEXT[1].gl_Position = vec4(-1.0,  3.0, 0.0, 1.0);\n"
                                     "    gl_MeshVerticesEXT[2].gl_Position = vec4( 3.0, -1.0, 0.0, 1.0);\n"
                                     "    gl_PrimitiveTriangleIndicesEXT[0] = uvec3(0, 1, 2);\n"
                                     "}\n";
            programCollection.glslSources.add("meshPassthrough" + nameSuffix) << glu::MeshSource(mesh) << buildOptions;
        }
    }
}

TestInstance *MeshShaderSyncCase::createInstance(Context &context) const
{
    return new MeshShaderSyncInstance(context, m_params);
}

// General description behind these tests.
//
//    From                To
// ==============================
//    HOST                TASK            Prepare buffer from host. Only valid for uniform and storage buffers. Read value from task into td.value. Verify color buffer.
//    HOST                MESH            Same situation. Read value from mesh into primitiveValue[0]. Verify color buffer.
//    TRANSFER            TASK            Prepare auxiliary host-coherent source buffer from host. Copy buffer to buffer or buffer to image. Read from task into td.value. Verify color buffer.
//    TRANSFER            MESH            Same initial steps. Read from mesh into primitiveValue[0]. Verify color buffer.
//    TASK                MESH            Write value to buffer or image from task shader. Only valid for storage buffers and images. Read from mesh into primitiveValue[0]. Verify color buffer.
//    TASK                FRAG            Same write procedure and restrictions. Read from frag into outColor. Verify color buffer.
//    TASK                TRANSFER        Same write procedure and restrictions. Prepare auxiliary host-coherent read buffer and copy buffer to buffer or image to buffer. Verify auxiliary buffer.
//    TASK                HOST            Due to From/To restrictions, only valid for storage buffers. Same write procedure. Read and verify buffer directly.
//    MESH                FRAG            Same as task to frag but the write instructions need to be in the mesh shader.
//    MESH                TRANSFER        Same as task to transfer but the write instructions need to be in the mesh shader.
//    MESH                HOST            Same as task to host but the write instructions need to be in the mesh shader.
//
//    The following cases require two pipelines
// =========================================
//    MESH                TASK            Write value to buffer or image from mesh shader. Only valid for storage buffers and images. Read from task into td.value. Verify color buffer.
//        Sequence: mesh, task, mesh*, frag*.
//    FRAG                TASK            Same as mesh to task, but writing from the first fragment shader.
//        Sequence: mesh*, frag, task, mesh*, frag*.
//    FRAG                MESH            Similar to frag to task, but reading from mesh into primitiveValue[0]. Verify color buffer after second fragment shader.
//        Sequence: mesh*, frag, mesh, frag*.
//

// Create one or two render passes with the right dependencies depending on the test parameters.
std::vector<Move<VkRenderPass>> createCustomRenderPasses(const DeviceInterface &vkd, VkDevice device,
                                                         VkFormat colorFormat, const TestParams &params)
{
    std::vector<Move<VkRenderPass>> renderPasses;
    const bool useDependencies     = (params.barrierType == BarrierType::DEPENDENCY);
    const bool twoPipelines        = params.needsTwoPipelines();
    const bool twoSubpasses        = (twoPipelines && useDependencies);
    const uint32_t pipelineCount   = (twoPipelines ? 2u : 1u);
    const uint32_t subpassCount    = (twoSubpasses ? 2u : 1u);
    const uint32_t renderPassCount = ((twoPipelines && !twoSubpasses) ? 2u : 1u);

    const std::vector<VkAttachmentDescription> attachmentDescs = {{
        0u,                                       // VkAttachmentDescriptionFlags flags;
        colorFormat,                              // VkFormat format;
        VK_SAMPLE_COUNT_1_BIT,                    // VkSampleCountFlagBits samples;
        VK_ATTACHMENT_LOAD_OP_CLEAR,              // VkAttachmentLoadOp loadOp;
        VK_ATTACHMENT_STORE_OP_STORE,             // VkAttachmentStoreOp storeOp;
        VK_ATTACHMENT_LOAD_OP_DONT_CARE,          // VkAttachmentLoadOp stencilLoadOp;
        VK_ATTACHMENT_STORE_OP_DONT_CARE,         // VkAttachmentStoreOp stencilStoreOp;
        VK_IMAGE_LAYOUT_UNDEFINED,                // VkImageLayout initialLayout;
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
    }};

    const std::vector<VkAttachmentReference> attachmentRefs = {{0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}};

    // One or two identical subpasses.
    const VkSubpassDescription subpassDesc = {
        0u,                                           // VkSubpassDescriptionFlags flags;
        VK_PIPELINE_BIND_POINT_GRAPHICS,              // VkPipelineBindPoint pipelineBindPoint;
        0u,                                           // uint32_t inputAttachmentCount;
        nullptr,                                      // const VkAttachmentReference* pInputAttachments;
        static_cast<uint32_t>(attachmentRefs.size()), // uint32_t colorAttachmentCount;
        de::dataOrNull(attachmentRefs),               // const VkAttachmentReference* pColorAttachments;
        nullptr,                                      // const VkAttachmentReference* pResolveAttachments;
        nullptr,                                      // const VkAttachmentReference* pDepthStencilAttachment;
        0u,                                           // uint32_t preserveAttachmentCount;
        nullptr,                                      // const uint32_t* pPreserveAttachments;
    };

    const std::vector<VkSubpassDescription> subpassDescs(subpassCount, subpassDesc);

    std::vector<VkSubpassDependency> dependencies;
    if (fromShaderToShader(params.fromStage, params.toStage) && useDependencies)
    {
        const VkSubpassDependency dependency = {
            0u,                                     // uint32_t srcSubpass;
            pipelineCount - 1u,                     // uint32_t dstSubpass;
            stageToFlags(params.fromStage),         // VkPipelineStageFlags srcStageMask;
            stageToFlags(params.toStage),           // VkPipelineStageFlags dstStageMask;
            writeAccessToFlags(params.writeAccess), // VkAccessFlags srcAccessMask;
            readAccessToFlags(params.readAccess),   // VkAccessFlags dstAccessMask;
            0u,                                     // VkDependencyFlags dependencyFlags;
        };
        dependencies.push_back(dependency);
    }

    const VkRenderPassCreateInfo createInfo = {
        VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,     // VkStructureType sType;
        nullptr,                                       // const void* pNext;
        0u,                                            // VkRenderPassCreateFlags flags;
        static_cast<uint32_t>(attachmentDescs.size()), // uint32_t attachmentCount;
        de::dataOrNull(attachmentDescs),               // const VkAttachmentDescription* pAttachments;
        static_cast<uint32_t>(subpassDescs.size()),    // uint32_t subpassCount;
        de::dataOrNull(subpassDescs),                  // const VkSubpassDescription* pSubpasses;
        static_cast<uint32_t>(dependencies.size()),    // uint32_t dependencyCount;
        de::dataOrNull(dependencies),                  // const VkSubpassDependency* pDependencies;
    };

    for (uint32_t renderPassIdx = 0u; renderPassIdx < renderPassCount; ++renderPassIdx)
        renderPasses.push_back(createRenderPass(vkd, device, &createInfo));

    return renderPasses;
}

void hostToTransferMemoryBarrier(const DeviceInterface &vkd, VkCommandBuffer cmdBuffer)
{
    const auto barrier = makeMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
    cmdPipelineMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &barrier);
}

void transferToHostMemoryBarrier(const DeviceInterface &vkd, VkCommandBuffer cmdBuffer)
{
    const auto barrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);
    cmdPipelineMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, &barrier);
}

tcu::TestStatus MeshShaderSyncInstance::iterate(void)
{
    const auto &vkd       = m_context.getDeviceInterface();
    const auto device     = m_context.getDevice();
    auto &alloc           = m_context.getDefaultAllocator();
    const auto queueIndex = m_context.getUniversalQueueFamilyIndex();
    const auto queue      = m_context.getUniversalQueue();

    const auto imageFormat         = getImageFormat();
    const auto imageExtent         = getImageExtent();
    const auto colorBufferUsage    = (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
    const auto colorSRR            = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
    const auto colorSRL            = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
    const auto bufferSize          = static_cast<VkDeviceSize>(sizeof(m_params.testValue));
    const auto descriptorType      = resourceTypeToDescriptor(m_params.resourceType);
    const auto resourceStages      = m_params.getResourceShaderStages();
    const auto auxiliarBufferUsage = (VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
    const auto useGeneralLayout    = m_params.preferGeneralLayout();

    const auto writeAccessFlags = writeAccessToFlags(m_params.writeAccess);
    const auto readAccessFlags  = readAccessToFlags(m_params.readAccess);
    const auto fromStageFlags   = stageToFlags(m_params.fromStage);
    const auto toStageFlags     = stageToFlags(m_params.toStage);

    // Prepare color buffer.
    const VkImageCreateInfo colorBufferCreateInfo = {
        VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
        nullptr,                             // const void* pNext;
        0u,                                  // VkImageCreateFlags flags;
        VK_IMAGE_TYPE_2D,                    // VkImageType imageType;
        imageFormat,                         // VkFormat format;
        imageExtent,                         // VkExtent3D extent;
        1u,                                  // uint32_t mipLevels;
        1u,                                  // uint32_t arrayLayers;
        VK_SAMPLE_COUNT_1_BIT,               // VkSampleCountFlagBits samples;
        VK_IMAGE_TILING_OPTIMAL,             // VkImageTiling tiling;
        colorBufferUsage,                    // VkImageUsageFlags usage;
        VK_SHARING_MODE_EXCLUSIVE,           // VkSharingMode sharingMode;
        0u,                                  // uint32_t queueFamilyIndexCount;
        nullptr,                             // const uint32_t* pQueueFamilyIndices;
        VK_IMAGE_LAYOUT_UNDEFINED,           // VkImageLayout initialLayout;
    };
    ImageWithMemory colorBuffer(vkd, device, alloc, colorBufferCreateInfo, MemoryRequirement::Any);
    const auto colorBufferView =
        makeImageView(vkd, device, colorBuffer.get(), VK_IMAGE_VIEW_TYPE_2D, imageFormat, colorSRR);

    // Main resource.
    using ImageWithMemoryPtr  = de::MovePtr<ImageWithMemory>;
    using BufferWithMemoryPtr = de::MovePtr<BufferWithMemory>;

    ImageWithMemoryPtr imageResource;
    Move<VkImageView> imageResourceView;
    VkImageLayout imageDescriptorLayout =
        (useGeneralLayout ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
    VkImageLayout currentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    BufferWithMemoryPtr bufferResource;

    bool useImageResource  = false;
    bool useBufferResource = false;

    switch (m_params.resourceType)
    {
    case ResourceType::UNIFORM_BUFFER:
    case ResourceType::STORAGE_BUFFER:
        useBufferResource = true;
        break;
    case ResourceType::STORAGE_IMAGE:
    case ResourceType::SAMPLED_IMAGE:
        useImageResource = true;
        break;
    default:
        DE_ASSERT(false);
        break;
    }

    // One resource needed.
    DE_ASSERT(useImageResource != useBufferResource);

    if (useImageResource)
    {
        const auto resourceImageUsage = resourceImageUsageFlags(m_params.resourceType);

        const VkImageCreateInfo resourceCreateInfo = {
            VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
            nullptr,                             // const void* pNext;
            0u,                                  // VkImageCreateFlags flags;
            VK_IMAGE_TYPE_2D,                    // VkImageType imageType;
            imageFormat,                         // VkFormat format;
            imageExtent,                         // VkExtent3D extent;
            1u,                                  // uint32_t mipLevels;
            1u,                                  // uint32_t arrayLayers;
            VK_SAMPLE_COUNT_1_BIT,               // VkSampleCountFlagBits samples;
            VK_IMAGE_TILING_OPTIMAL,             // VkImageTiling tiling;
            resourceImageUsage,                  // VkImageUsageFlags usage;
            VK_SHARING_MODE_EXCLUSIVE,           // VkSharingMode sharingMode;
            0u,                                  // uint32_t queueFamilyIndexCount;
            nullptr,                             // const uint32_t* pQueueFamilyIndices;
            VK_IMAGE_LAYOUT_UNDEFINED,           // VkImageLayout initialLayout;
        };
        imageResource =
            ImageWithMemoryPtr(new ImageWithMemory(vkd, device, alloc, resourceCreateInfo, MemoryRequirement::Any));
        imageResourceView =
            makeImageView(vkd, device, imageResource->get(), VK_IMAGE_VIEW_TYPE_2D, imageFormat, colorSRR);
    }
    else
    {
        const auto resourceBufferUsage      = resourceBufferUsageFlags(m_params.resourceType);
        const auto resourceBufferCreateInfo = makeBufferCreateInfo(bufferSize, resourceBufferUsage);
        bufferResource                      = BufferWithMemoryPtr(
            new BufferWithMemory(vkd, device, alloc, resourceBufferCreateInfo, MemoryRequirement::HostVisible));
    }

    Move<VkSampler> sampler;
    if (descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
    {
        const VkSamplerCreateInfo samplerCreateInfo = {
            VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
            nullptr,                               // const void* pNext;
            0u,                                    // VkSamplerCreateFlags flags;
            VK_FILTER_NEAREST,                     // VkFilter magFilter;
            VK_FILTER_NEAREST,                     // VkFilter minFilter;
            VK_SAMPLER_MIPMAP_MODE_NEAREST,        // VkSamplerMipmapMode mipmapMode;
            VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU;
            VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV;
            VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW;
            0.0f,                                  // float mipLodBias;
            VK_FALSE,                              // VkBool32 anisotropyEnable;
            1.0f,                                  // float maxAnisotropy;
            VK_FALSE,                              // VkBool32 compareEnable;
            VK_COMPARE_OP_NEVER,                   // VkCompareOp compareOp;
            0.0f,                                  // float minLod;
            0.0f,                                  // float maxLod;
            VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, // VkBorderColor borderColor;
            VK_FALSE,                              // VkBool32 unnormalizedCoordinates;
        };
        sampler = createSampler(vkd, device, &samplerCreateInfo);
    }

    // Auxiliary host-coherent buffer for some cases. Being host-coherent lets us avoid extra barriers that would "pollute" synchronization tests.
    BufferWithMemoryPtr hostCoherentBuffer;
    void *hostCoherentDataPtr = nullptr;
    if (needsAuxiliarBuffer(m_params.fromStage, m_params.toStage))
    {
        const auto auxiliarBufferCreateInfo = makeBufferCreateInfo(bufferSize, auxiliarBufferUsage);
        hostCoherentBuffer =
            BufferWithMemoryPtr(new BufferWithMemory(vkd, device, alloc, auxiliarBufferCreateInfo,
                                                     (MemoryRequirement::HostVisible | MemoryRequirement::Coherent)));
        hostCoherentDataPtr = hostCoherentBuffer->getAllocation().getHostPtr();
    }

    // Descriptor pool.
    Move<VkDescriptorPool> descriptorPool;
    {
        DescriptorPoolBuilder poolBuilder;
        poolBuilder.addType(descriptorType);
        descriptorPool = poolBuilder.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
    }

    // Descriptor set layout.
    Move<VkDescriptorSetLayout> setLayout;
    {
        DescriptorSetLayoutBuilder layoutBuilder;
        layoutBuilder.addSingleBinding(descriptorType, resourceStages);
        setLayout = layoutBuilder.build(vkd, device);
    }

    // Descriptor set.
    const auto descriptorSet = makeDescriptorSet(vkd, device, descriptorPool.get(), setLayout.get());

    // Update descriptor set.
    {
        DescriptorSetUpdateBuilder updateBuilder;
        const auto location = DescriptorSetUpdateBuilder::Location::binding(0u);

        switch (descriptorType)
        {
        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
        {
            const auto bufferInfo = makeDescriptorBufferInfo(bufferResource->get(), 0ull, bufferSize);
            updateBuilder.writeSingle(descriptorSet.get(), location, descriptorType, &bufferInfo);
        }
        break;
        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
        {
            auto descriptorImageInfo =
                makeDescriptorImageInfo(sampler.get(), imageResourceView.get(), imageDescriptorLayout);
            updateBuilder.writeSingle(descriptorSet.get(), location, descriptorType, &descriptorImageInfo);
        }
        break;
        default:
            DE_ASSERT(false);
            break;
        }

        updateBuilder.update(vkd, device);
    }

    // Render passes and framebuffers.
    const auto renderPasses    = createCustomRenderPasses(vkd, device, imageFormat, m_params);
    const bool multiRenderPass = (renderPasses.size() > 1u);
    DE_ASSERT(renderPasses.size() > 0u);

    std::vector<Move<VkFramebuffer>> framebuffers;
    framebuffers.reserve(renderPasses.size());

    for (const auto &renderPass : renderPasses)
        framebuffers.push_back(makeFramebuffer(vkd, device, renderPass.get(), colorBufferView.get(), imageExtent.width,
                                               imageExtent.height));

    // Viewports and scissors.
    std::vector<VkViewport> viewports(1u, makeViewport(imageExtent));
    std::vector<VkRect2D> scissors(1u, makeRect2D(imageExtent));

    using PushConstantStruct = TestParams::PushConstantStruct;

    // Pipeline layout.
    const auto pcSize         = static_cast<uint32_t>(sizeof(PushConstantStruct));
    const auto pcRange        = makePushConstantRange(resourceStages, 0u, pcSize);
    const auto pipelineLayout = makePipelineLayout(vkd, device, setLayout.get(), &pcRange);

    // Shader modules, pipelines and pipeline layouts.
    const auto twoPipelines = m_params.needsTwoPipelines();
    const auto selfDeps     = m_params.subpassSelfDependency();

    // Both at the same time does not make sense.
    DE_ASSERT(!(twoPipelines && selfDeps));

    const auto pipelineCount  = (twoPipelines ? 2u : 1u);
    const auto drawCount      = (selfDeps ? 2u : 1u);
    const auto iterationCount = std::max(pipelineCount, drawCount);

    std::vector<Move<VkPipeline>> pipelines;
    pipelines.reserve(pipelineCount);

    // Shader modules.
    const auto &binaries = m_context.getBinaryCollection();

    Move<VkShaderModule> taskShader;
    if (m_params.needsTask())
        taskShader = createShaderModule(vkd, device, binaries.get("task"));

    const auto meshShader                    = createShaderModule(vkd, device, binaries.get("mesh"));
    const auto fragShader                    = createShaderModule(vkd, device, binaries.get("frag"));
    const auto taskPassthroughShader         = createShaderModule(vkd, device, binaries.get("taskPassthrough"));
    const auto fragPassthroughShader         = createShaderModule(vkd, device, binaries.get("fragPassthrough"));
    const auto meshPassthroughShader         = createShaderModule(vkd, device, binaries.get("meshPassthrough"));
    const auto meshPassthroughWithTaskShader = createShaderModule(vkd, device, binaries.get("meshPassthroughWithTask"));

    if (pipelineCount == 1u)
    {
        // Pipeline.
        pipelines.push_back(makeGraphicsPipeline(vkd, device, pipelineLayout.get(), taskShader.get(), meshShader.get(),
                                                 fragShader.get(), renderPasses.at(0u).get(), viewports, scissors));
    }
    else if (pipelineCount == 2u)
    {
        // Mandatory stages in each pipeline: the first pipeline will contain the "from" stage (write) and the second one the "to" stage (read).
        const std::vector<Stage> mandatoryStages{m_params.fromStage, m_params.toStage};

        // One pipeline per mandatory stage.
        for (uint32_t pipelineIdx = 0u; pipelineIdx < pipelineCount; ++pipelineIdx)
        {
            const auto &stage = mandatoryStages.at(pipelineIdx);

            VkShaderModule taskModule = DE_NULL;
            VkShaderModule meshModule = DE_NULL;
            VkShaderModule fragModule = DE_NULL;

            const bool lastSubpass    = (pipelineIdx == pipelineCount - 1u);
            const auto pipelineStages = subpassStages(stage, lastSubpass);
            const bool hasTaskShader  = hasTask(pipelineStages);
            const bool hasFragShader  = hasFrag(pipelineStages);

            // Decide which shaders to use for this one.
            if (hasTaskShader)
                taskModule = ((stage == Stage::TASK) ? taskShader.get() : taskPassthroughShader.get());

            if (stage == Stage::MESH)
                meshModule = meshShader.get();
            else
            {
                meshModule = (hasTaskShader ? meshPassthroughWithTaskShader.get() : meshPassthroughShader.get());
            }

            if (hasFragShader)
                fragModule = ((stage == Stage::FRAG) ? fragShader.get() : fragPassthroughShader.get());

            // Create pipeline. When using multiple render passes, the subpass is always zero. When using a single render pass, each pipeline is prepared for one subpass.
            const auto renderPass = (multiRenderPass ? renderPasses.at(pipelineIdx).get() : renderPasses[0].get());
            const auto subpass    = (multiRenderPass ? 0u : pipelineIdx);

            pipelines.push_back(makeGraphicsPipeline(vkd, device, pipelineLayout.get(), taskModule, meshModule,
                                                     fragModule, renderPass, viewports, scissors, subpass));
        }
    }
    else
    {
        DE_ASSERT(false);
    }

    // Command pool and buffer.
    const auto cmdPool      = makeCommandPool(vkd, device, queueIndex);
    const auto cmdBufferPtr = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
    const auto cmdBuffer    = cmdBufferPtr.get();

    beginCommandBuffer(vkd, cmdBuffer);

    if (m_params.fromStage == Stage::HOST)
    {
        // Prepare buffer from host when the source stage is the host.
        DE_ASSERT(useBufferResource);

        auto &resourceBufferAlloc   = bufferResource->getAllocation();
        void *resourceBufferDataPtr = resourceBufferAlloc.getHostPtr();

        deMemcpy(resourceBufferDataPtr, &m_params.testValue, sizeof(m_params.testValue));
        flushAlloc(vkd, device, resourceBufferAlloc);
    }
    else if (m_params.fromStage == Stage::TRANSFER)
    {
        // Put value in host-coherent buffer and transfer it to the resource buffer or image.
        deMemcpy(hostCoherentDataPtr, &m_params.testValue, sizeof(m_params.testValue));
        hostToTransferMemoryBarrier(vkd, cmdBuffer);

        if (useBufferResource)
        {
            const auto copyRegion = makeBufferCopy(0ull, 0ull, bufferSize);
            vkd.cmdCopyBuffer(cmdBuffer, hostCoherentBuffer->get(), bufferResource->get(), 1u, &copyRegion);
        }
        else
        {
            // Move image to the right layout for transfer.
            const auto newLayout = (useGeneralLayout ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
            if (newLayout != currentLayout)
            {
                const auto preCopyBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, currentLayout,
                                                                   newLayout, imageResource->get(), colorSRR);
                cmdPipelineImageMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                              VK_PIPELINE_STAGE_TRANSFER_BIT, &preCopyBarrier);
                currentLayout = newLayout;
            }
            const auto copyRegion = makeBufferImageCopy(imageExtent, colorSRL);
            vkd.cmdCopyBufferToImage(cmdBuffer, hostCoherentBuffer->get(), imageResource->get(), currentLayout, 1u,
                                     &copyRegion);
        }
    }
    else if (isShaderStage(m_params.fromStage))
    {
        // The image or buffer will be written to from shaders. Images need to be in the right layout.
        if (useImageResource)
        {
            const auto newLayout = VK_IMAGE_LAYOUT_GENERAL;
            if (newLayout != currentLayout)
            {
                const auto preWriteBarrier =
                    makeImageMemoryBarrier(0u, (VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT), currentLayout,
                                           newLayout, imageResource->get(), colorSRR);
                cmdPipelineImageMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, fromStageFlags,
                                              &preWriteBarrier);
                currentLayout = newLayout;
            }
        }
    }
    else
    {
        DE_ASSERT(false);
    }

    // If the resource is going to be read from shaders and written from a non-shader stage, we'll insert the main barrier before running the pipeline.
    if (isShaderStage(m_params.toStage) && !isShaderStage(m_params.fromStage))
    {
        if (m_params.barrierType == BarrierType::GENERAL)
        {
            const auto memoryBarrier = makeMemoryBarrier(writeAccessFlags, readAccessFlags);
            cmdPipelineMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &memoryBarrier);
        }
        else if (m_params.barrierType == BarrierType::SPECIFIC)
        {
            if (useBufferResource)
            {
                const auto bufferBarrier =
                    makeBufferMemoryBarrier(writeAccessFlags, readAccessFlags, bufferResource->get(), 0ull, bufferSize);
                cmdPipelineBufferMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &bufferBarrier);
            }
            else
            {
                const auto newLayout =
                    (useGeneralLayout ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
                const auto imageBarrier = makeImageMemoryBarrier(writeAccessFlags, readAccessFlags, currentLayout,
                                                                 newLayout, imageResource->get(), colorSRR);

                cmdPipelineImageMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &imageBarrier);
                currentLayout = newLayout;
            }
        }
        // For subpass dependencies, they have already been included in the render pass or loop below.
    }

    // Run the pipeline.
    if (!multiRenderPass)
        beginRenderPass(vkd, cmdBuffer, renderPasses[0].get(), framebuffers[0].get(), scissors.at(0), tcu::UVec4(0u));

    vkd.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout.get(), 0u, 1u,
                              &descriptorSet.get(), 0u, nullptr);

    for (uint32_t iterationIdx = 0u; iterationIdx < iterationCount; ++iterationIdx)
    {
        if (iterationIdx > 0u && !multiRenderPass && twoPipelines)
            vkd.cmdNextSubpass(cmdBuffer, VK_SUBPASS_CONTENTS_INLINE);

        if (multiRenderPass)
            beginRenderPass(vkd, cmdBuffer, renderPasses.at(iterationIdx).get(), framebuffers.at(iterationIdx).get(),
                            scissors.at(0), tcu::UVec4(0u));

        if (twoPipelines || iterationIdx == 0u)
            vkd.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.at(iterationIdx).get());

        PushConstantStruct pcData;
        if (selfDeps)
        {
            // First draw writes, second draw reads.
            pcData.writeVal = 1u - iterationIdx;
            pcData.readVal  = iterationIdx;
        }
        else
        {
            // Otherwise reads and writes freely according to the pipeline shaders.
            pcData.writeVal = 1u;
            pcData.readVal  = 1u;
        }
        vkd.cmdPushConstants(cmdBuffer, pipelineLayout.get(), resourceStages, 0u, pcSize, &pcData);
        vkd.cmdDrawMeshTasksEXT(cmdBuffer, 1u, 1u, 1u);

        if (multiRenderPass)
            endRenderPass(vkd, cmdBuffer);

        // If there are self-dependencies or multiple render passes, synchronize resource between draw calls.
        if ((multiRenderPass || selfDeps) && iterationIdx == 0u)
        {
            // In the case of self-dependencies, the barrier type is BarrierType::DEPENDENCY and we'll insert a general barrier because:
            //    * VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178 forbids using buffer barriers inside render passes.
            //    * VUID-vkCmdPipelineBarrier-image-04073 forbids using image memory barriers inside render passes with resources that are not attachments.
            if (m_params.barrierType == BarrierType::GENERAL || m_params.barrierType == BarrierType::DEPENDENCY)
            {
                const auto memoryBarrier = makeMemoryBarrier(writeAccessFlags, readAccessFlags);
                cmdPipelineMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &memoryBarrier);
            }
            else if (m_params.barrierType == BarrierType::SPECIFIC)
            {
                if (useBufferResource)
                {
                    const auto bufferBarrier = makeBufferMemoryBarrier(writeAccessFlags, readAccessFlags,
                                                                       bufferResource->get(), 0ull, bufferSize);
                    cmdPipelineBufferMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &bufferBarrier);
                }
                else
                {
                    // Note: the image will only be read from shader stages or from the transfer stage.
                    DE_ASSERT(useGeneralLayout);
                    const auto newLayout    = VK_IMAGE_LAYOUT_GENERAL;
                    const auto imageBarrier = makeImageMemoryBarrier(writeAccessFlags, readAccessFlags, currentLayout,
                                                                     newLayout, imageResource->get(), colorSRR);

                    cmdPipelineImageMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &imageBarrier);
                    currentLayout = newLayout;
                }
            }
            else
            {
                DE_ASSERT(false);
            }

            if (multiRenderPass)
            {
                // Sync color attachment writes.
                const auto colorWritesBarrier =
                    makeMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
                cmdPipelineMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, &colorWritesBarrier);
            }
        }
    }

    if (!multiRenderPass)
        endRenderPass(vkd, cmdBuffer);

    // If the resource was written to from shaders and will be read from a non-shader stage, insert the main barrier after running the pipeline.
    if (isShaderStage(m_params.fromStage) && !isShaderStage(m_params.toStage))
    {
        if (m_params.barrierType == BarrierType::GENERAL)
        {
            const auto memoryBarrier = makeMemoryBarrier(writeAccessFlags, readAccessFlags);
            cmdPipelineMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &memoryBarrier);
        }
        else if (m_params.barrierType == BarrierType::SPECIFIC)
        {
            if (useBufferResource)
            {
                const auto bufferBarrier =
                    makeBufferMemoryBarrier(writeAccessFlags, readAccessFlags, bufferResource->get(), 0ull, bufferSize);
                cmdPipelineBufferMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &bufferBarrier);
            }
            else
            {
                // Note: the image will only be read from shader stages or from the transfer stage.
                const auto newLayout =
                    (useGeneralLayout ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
                const auto imageBarrier = makeImageMemoryBarrier(writeAccessFlags, readAccessFlags, currentLayout,
                                                                 newLayout, imageResource->get(), colorSRR);

                cmdPipelineImageMemoryBarrier(vkd, cmdBuffer, fromStageFlags, toStageFlags, &imageBarrier);
                currentLayout = newLayout;
            }
        }
        // For subpass dependencies, they have already been included in the render pass and loop.
    }

    // Read resource from the destination stage if needed.
    if (m_params.toStage == Stage::HOST)
    {
        // Nothing to do. The test value should be in the resource buffer already, which is host-visible.
    }
    else if (m_params.toStage == Stage::TRANSFER)
    {
        // Copy value from resource to host-coherent buffer to be verified later.
        if (useBufferResource)
        {
            const auto copyRegion = makeBufferCopy(0ull, 0ull, bufferSize);
            vkd.cmdCopyBuffer(cmdBuffer, bufferResource->get(), hostCoherentBuffer->get(), 1u, &copyRegion);
        }
        else
        {
            const auto copyRegion = makeBufferImageCopy(imageExtent, colorSRL);
            vkd.cmdCopyImageToBuffer(cmdBuffer, imageResource->get(), currentLayout, hostCoherentBuffer->get(), 1u,
                                     &copyRegion);
        }

        transferToHostMemoryBarrier(vkd, cmdBuffer);
    }

    // If the output value will be available in the color buffer, take the chance to transfer its contents to a host-coherent buffer.
    BufferWithMemoryPtr colorVerificationBuffer;
    void *colorVerificationDataPtr = nullptr;

    if (valueInColorBuffer(m_params.toStage))
    {
        const auto auxiliarBufferCreateInfo = makeBufferCreateInfo(bufferSize, auxiliarBufferUsage);
        colorVerificationBuffer =
            BufferWithMemoryPtr(new BufferWithMemory(vkd, device, alloc, auxiliarBufferCreateInfo,
                                                     (MemoryRequirement::HostVisible | MemoryRequirement::Coherent)));
        colorVerificationDataPtr = colorVerificationBuffer->getAllocation().getHostPtr();

        const auto srcAccess = (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
        const auto dstAccess = VK_ACCESS_TRANSFER_READ_BIT;
        const auto colorBarrier =
            makeImageMemoryBarrier(srcAccess, dstAccess, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                                   VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, colorBuffer.get(), colorSRR);
        cmdPipelineImageMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                                      VK_PIPELINE_STAGE_TRANSFER_BIT, &colorBarrier);

        const auto copyRegion = makeBufferImageCopy(imageExtent, colorSRL);
        vkd.cmdCopyImageToBuffer(cmdBuffer, colorBuffer.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                 colorVerificationBuffer->get(), 1u, &copyRegion);

        transferToHostMemoryBarrier(vkd, cmdBuffer);
    }

    endCommandBuffer(vkd, cmdBuffer);
    submitCommandsAndWait(vkd, device, queue, cmdBuffer);

    // Verify output resources as needed.

    if (valueInAuxiliarDestBuffer(m_params.toStage))
    {
        uint32_t bufferValue;
        deMemcpy(&bufferValue, hostCoherentDataPtr, sizeof(bufferValue));

        if (bufferValue != m_params.testValue)
        {
            std::ostringstream msg;
            msg << "Unexpected value in auxiliar host-coherent buffer: found " << bufferValue << " and expected "
                << m_params.testValue;
            TCU_FAIL(msg.str());
        }
    }

    if (valueInResourceBuffer(m_params.toStage))
    {
        auto &resourceBufferAlloc   = bufferResource->getAllocation();
        void *resourceBufferDataPtr = resourceBufferAlloc.getHostPtr();
        uint32_t bufferValue;

        invalidateAlloc(vkd, device, resourceBufferAlloc);
        deMemcpy(&bufferValue, resourceBufferDataPtr, sizeof(bufferValue));

        if (bufferValue != m_params.testValue)
        {
            std::ostringstream msg;
            msg << "Unexpected value in resource buffer: found " << bufferValue << " and expected "
                << m_params.testValue;
            TCU_FAIL(msg.str());
        }
    }

    if (valueInColorBuffer(m_params.toStage))
    {
        uint32_t bufferValue;
        deMemcpy(&bufferValue, colorVerificationDataPtr, sizeof(bufferValue));

        if (bufferValue != m_params.testValue)
        {
            std::ostringstream msg;
            msg << "Unexpected value in color verification buffer: found " << bufferValue << " and expected "
                << m_params.testValue;
            TCU_FAIL(msg.str());
        }
    }

    return tcu::TestStatus::pass("Pass");
}

// Specific test to check a barrier that crosses secondary command buffers and goes from compute to task.
class BarrierAcrossSecondaryCase : public vkt::TestCase
{
public:
    BarrierAcrossSecondaryCase(tcu::TestContext &testCtx, const std::string &name) : vkt::TestCase(testCtx, name)
    {
    }
    virtual ~BarrierAcrossSecondaryCase(void)
    {
    }

    void checkSupport(Context &context) const override;
    TestInstance *createInstance(Context &context) const override;
    void initPrograms(vk::SourceCollections &programCollection) const override;

    static constexpr uint32_t kLocalSize     = 128u;
    static constexpr uint32_t kNumWorkGroups = 16384u;
};

class BarrierAcrossSecondaryInstance : public vkt::TestInstance
{
public:
    BarrierAcrossSecondaryInstance(Context &context) : vkt::TestInstance(context)
    {
    }
    virtual ~BarrierAcrossSecondaryInstance(void)
    {
    }

    tcu::TestStatus iterate(void) override;
};

void BarrierAcrossSecondaryCase::checkSupport(Context &context) const
{
    checkTaskMeshShaderSupportEXT(context, true, true);
    context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS);
}

TestInstance *BarrierAcrossSecondaryCase::createInstance(Context &context) const
{
    return new BarrierAcrossSecondaryInstance(context);
}

void BarrierAcrossSecondaryCase::initPrograms(vk::SourceCollections &programCollection) const
{
    const auto buildOptions = getMinMeshEXTBuildOptions(programCollection.usedVulkanVersion);

    const std::string descriptorDecl = "layout (set=0, binding=0, std430) buffer OutputBlock {\n"
                                       "    uint values[];\n"
                                       "} outBuffer;\n"
                                       "layout (set=0, binding=1, std430) buffer VerificationBlock {\n"
                                       "    uint values[];\n"
                                       "} verificationBuffer;\n";

    // The compute shader will fill the output buffer.
    std::ostringstream comp;
    comp << "#version 450\n"
         << "layout(local_size_x=" << kLocalSize << ") in;\n"
         << descriptorDecl << "void main ()\n"
         << "{\n"
         << "    outBuffer.values[gl_GlobalInvocationID.x] = gl_GlobalInvocationID.x;\n"
         << "}\n";
    programCollection.glslSources.add("comp") << glu::ComputeSource(comp.str());

    // The task shader will read it, verify its contents and write the verification buffer.
    std::ostringstream task;
    task << "#version 450\n"
         << "#extension GL_EXT_mesh_shader : enable\n"
         << "layout(local_size_x=" << kLocalSize << ") in;\n"
         << descriptorDecl << "void main ()\n"
         << "{\n"
         << "    const uint verifResult = ((outBuffer.values[gl_GlobalInvocationID.x] == gl_GlobalInvocationID.x) ? 1u "
            ": 0u);\n"
         << "    verificationBuffer.values[gl_GlobalInvocationID.x] = verifResult;\n"
         << "    EmitMeshTasksEXT(0u, 0u, 0u);\n"
         << "}\n";
    programCollection.glslSources.add("task") << glu::TaskSource(task.str()) << buildOptions;

    std::ostringstream mesh;
    mesh << "#version 450\n"
         << "#extension GL_EXT_mesh_shader : enable\n"
         << "\n"
         << "layout(local_size_x=1) in;\n"
         << "layout(triangles) out;\n"
         << "layout(max_vertices=3, max_primitives=1) out;\n"
         << "\n"
         << "void main ()\n"
         << "{\n"
         << "    SetMeshOutputsEXT(0u, 0u);\n"
         << "}\n";
    programCollection.glslSources.add("mesh") << glu::MeshSource(mesh.str()) << buildOptions;
}

tcu::TestStatus BarrierAcrossSecondaryInstance::iterate(void)
{
    const auto &vkd           = m_context.getDeviceInterface();
    const auto device         = m_context.getDevice();
    auto &alloc               = m_context.getDefaultAllocator();
    const auto queueIndex     = m_context.getUniversalQueueFamilyIndex();
    const auto queue          = m_context.getUniversalQueue();
    const auto kLocalSize     = BarrierAcrossSecondaryCase::kLocalSize;
    const auto kNumWorkGroups = BarrierAcrossSecondaryCase::kNumWorkGroups;
    const auto bindingStages  = (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_TASK_BIT_EXT);
    const auto extent         = makeExtent3D(1u, 1u, 1u);

    // Output buffer.
    const auto outputBufferSize = static_cast<VkDeviceSize>(kLocalSize * kNumWorkGroups * sizeof(uint32_t));
    const auto outputBufferInfo = makeBufferCreateInfo(outputBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
    BufferWithMemory outputBuffer(vkd, device, alloc, outputBufferInfo, MemoryRequirement::HostVisible);
    auto &outputBufferAlloc = outputBuffer.getAllocation();
    void *outputBufferData  = outputBufferAlloc.getHostPtr();

    // Verification buffer.
    const auto verificationBufferSize = outputBufferSize;
    const auto verificationBufferInfo = outputBufferInfo;
    BufferWithMemory verificationBuffer(vkd, device, alloc, verificationBufferInfo, MemoryRequirement::HostVisible);
    auto &verificationBufferAlloc = verificationBuffer.getAllocation();
    void *verificationBufferData  = verificationBufferAlloc.getHostPtr();

    // Prepare buffer data.
    deMemset(outputBufferData, 0, static_cast<size_t>(outputBufferSize));
    deMemset(verificationBufferData, 0, static_cast<size_t>(verificationBufferSize));
    flushAlloc(vkd, device, outputBufferAlloc);
    flushAlloc(vkd, device, verificationBufferAlloc);

    // Descriptor set layout.
    DescriptorSetLayoutBuilder setLayoutBuilder;
    setLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, bindingStages);
    setLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, bindingStages);
    const auto setLayout = setLayoutBuilder.build(vkd, device);

    // Pipeline layout.
    const auto pipelineLayout = makePipelineLayout(vkd, device, setLayout.get());

    // Descriptor pool and set.
    DescriptorPoolBuilder poolBuilder;
    poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2u);
    const auto descriptorPool = poolBuilder.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
    const auto descriptorSet  = makeDescriptorSet(vkd, device, descriptorPool.get(), setLayout.get());

    // Update descriptor set.
    DescriptorSetUpdateBuilder updateBuilder;
    const auto outputBufferDescInfo = makeDescriptorBufferInfo(outputBuffer.get(), 0ull, outputBufferSize);
    const auto verificationBufferDescInfo =
        makeDescriptorBufferInfo(verificationBuffer.get(), 0ull, verificationBufferSize);
    updateBuilder.writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(0u),
                              VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &outputBufferDescInfo);
    updateBuilder.writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(1u),
                              VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &verificationBufferDescInfo);
    updateBuilder.update(vkd, device);

    // Graphics pipeline auxiliary data.
    const auto renderPass  = makeRenderPass(vkd, device);
    const auto framebuffer = makeFramebuffer(vkd, device, renderPass.get(), 0u, nullptr, extent.width, extent.height);
    const std::vector<VkViewport> viewports(1u, makeViewport(extent));
    const std::vector<VkRect2D> scissors(1u, makeRect2D(extent));

    // Create pipelines.
    const auto &binaries  = m_context.getBinaryCollection();
    const auto compModule = createShaderModule(vkd, device, binaries.get("comp"));
    const auto taskModule = createShaderModule(vkd, device, binaries.get("task"));
    const auto meshModule = createShaderModule(vkd, device, binaries.get("mesh"));

    const auto computePipeline = makeComputePipeline(vkd, device, pipelineLayout.get(), compModule.get());
    const auto meshPipeline    = makeGraphicsPipeline(vkd, device, pipelineLayout.get(), taskModule.get(),
                                                      meshModule.get(), DE_NULL, renderPass.get(), viewports, scissors);

    // Command pool and command buffers.
    const auto cmdPool          = makeCommandPool(vkd, device, queueIndex);
    const auto primaryCmdBuffer = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
    const auto compCmdBuffer    = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_SECONDARY);
    const auto meshCmdBuffer    = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_SECONDARY);

    // Use compute pipeline and record barrier to task shader.
    {
        const auto cmdBuffer        = compCmdBuffer.get();
        const auto comp2TaskBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT);

        beginSecondaryCommandBuffer(vkd, cmdBuffer);
        vkd.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout.get(), 0u, 1u,
                                  &descriptorSet.get(), 0u, nullptr);
        vkd.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipeline.get());
        vkd.cmdDispatch(cmdBuffer, kNumWorkGroups, 1u, 1u);
        cmdPipelineMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                                 VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, &comp2TaskBarrier);
        endCommandBuffer(vkd, cmdBuffer);
    }

    // Use mesh pipeline and record barrier to host.
    {
        const auto cmdBuffer = meshCmdBuffer.get();

        beginSecondaryCommandBuffer(vkd, cmdBuffer, renderPass.get(), framebuffer.get());
        vkd.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout.get(), 0u, 1u,
                                  &descriptorSet.get(), 0u, nullptr);
        vkd.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, meshPipeline.get());
        vkd.cmdDrawMeshTasksEXT(cmdBuffer, kNumWorkGroups, 1u, 1u);
        endCommandBuffer(vkd, cmdBuffer);
    }

    // Use both secondary command buffers.
    {
        const auto cmdBuffer        = primaryCmdBuffer.get();
        const auto task2HostBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);

        beginCommandBuffer(vkd, cmdBuffer);
        vkd.cmdExecuteCommands(cmdBuffer, 1u, &compCmdBuffer.get());
        beginRenderPass(vkd, cmdBuffer, renderPass.get(), framebuffer.get(), scissors.at(0u),
                        VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
        vkd.cmdExecuteCommands(cmdBuffer, 1u, &meshCmdBuffer.get());
        endRenderPass(vkd, cmdBuffer);
        cmdPipelineMemoryBarrier(vkd, cmdBuffer, VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, VK_PIPELINE_STAGE_HOST_BIT,
                                 &task2HostBarrier);
        endCommandBuffer(vkd, cmdBuffer);
        submitCommandsAndWait(vkd, device, queue, cmdBuffer);
    }

    // Verify buffer contents.
    invalidateAlloc(vkd, device, verificationBufferAlloc);
    const std::vector<uint32_t> expectedResult(kNumWorkGroups * kLocalSize, 1u);

    if (deMemCmp(expectedResult.data(), verificationBufferData, de::dataSize(expectedResult)) != 0)
        TCU_FAIL("Unexpected values found in verification buffer");

    return tcu::TestStatus::pass("Pass");
}

} // namespace

tcu::TestCaseGroup *createMeshShaderSyncTestsEXT(tcu::TestContext &testCtx)
{
    const struct
    {
        Stage fromStage;
        Stage toStage;
    } stageCombinations[] = {
        // Combinations where the source and destination stages involve mesh shaders.
        // Note: this could be tested procedurally.
        {Stage::HOST, Stage::TASK},
        {Stage::HOST, Stage::MESH},
        {Stage::TRANSFER, Stage::TASK},
        {Stage::TRANSFER, Stage::MESH},
        {Stage::TASK, Stage::MESH},
        {Stage::TASK, Stage::FRAG},
        {Stage::TASK, Stage::TRANSFER},
        {Stage::TASK, Stage::HOST},
        {Stage::MESH, Stage::FRAG},
        {Stage::MESH, Stage::TRANSFER},
        {Stage::MESH, Stage::HOST},

        // These require two pipelines.
        {Stage::MESH, Stage::TASK},
        {Stage::FRAG, Stage::TASK},
        {Stage::FRAG, Stage::MESH},
    };

    const struct
    {
        ResourceType resourceType;
        const char *name;
    } resourceTypes[] = {
        {ResourceType::UNIFORM_BUFFER, "uniform_buffer"},
        {ResourceType::STORAGE_BUFFER, "storage_buffer"},
        {ResourceType::STORAGE_IMAGE, "storage_image"},
        {ResourceType::SAMPLED_IMAGE, "sampled_image"},
    };

    const struct
    {
        BarrierType barrierType;
        const char *name;
    } barrierTypes[] = {
        {BarrierType::GENERAL, "memory_barrier"},
        {BarrierType::SPECIFIC, "specific_barrier"},
        {BarrierType::DEPENDENCY, "subpass_dependency"},
    };

    const struct
    {
        WriteAccess writeAccess;
        const char *name;
    } writeAccesses[] = {
        {WriteAccess::HOST_WRITE, "host_write"},
        {WriteAccess::TRANSFER_WRITE, "transfer_write"},
        {WriteAccess::SHADER_WRITE, "shader_write"},
    };

    const struct
    {
        ReadAccess readAccess;
        const char *name;
    } readAccesses[] = {
        {ReadAccess::HOST_READ, "host_read"},
        {ReadAccess::TRANSFER_READ, "transfer_read"},
        {ReadAccess::SHADER_READ, "shader_read"},
        {ReadAccess::UNIFORM_READ, "uniform_read"},
    };

    uint32_t testValue = 1628510124u;

    GroupPtr mainGroup(new tcu::TestCaseGroup(testCtx, "synchronization"));

    for (const auto &stageCombination : stageCombinations)
    {
        const std::string combinationName =
            de::toString(stageCombination.fromStage) + "_to_" + de::toString(stageCombination.toStage);
        GroupPtr combinationGroup(new tcu::TestCaseGroup(testCtx, combinationName.c_str()));

        for (const auto &resourceCase : resourceTypes)
        {
            if (!canWriteTo(stageCombination.fromStage, resourceCase.resourceType))
                continue;

            if (!canReadFrom(stageCombination.toStage, resourceCase.resourceType))
                continue;

            GroupPtr resourceGroup(new tcu::TestCaseGroup(testCtx, resourceCase.name));

            for (const auto &barrierCase : barrierTypes)
            {
                const auto shaderToShader = fromShaderToShader(stageCombination.fromStage, stageCombination.toStage);
                const auto barrierIsDependency = (barrierCase.barrierType == BarrierType::DEPENDENCY);

                // Subpass dependencies can only be used in shader to shader situations.
                if (barrierIsDependency && !shaderToShader)
                    continue;

                GroupPtr barrierGroup(new tcu::TestCaseGroup(testCtx, barrierCase.name));

                for (const auto &writeCase : writeAccesses)
                    for (const auto &readCase : readAccesses)
                    {
                        if (!canReadResourceAsAccess(resourceCase.resourceType, readCase.readAccess))
                            continue;
                        if (!canWriteResourceAsAccess(resourceCase.resourceType, writeCase.writeAccess))
                            continue;
                        if (!canReadFromStageAsAccess(stageCombination.toStage, readCase.readAccess))
                            continue;
                        if (!canWriteFromStageAsAccess(stageCombination.fromStage, writeCase.writeAccess))
                            continue;

                        const std::string accessCaseName = writeCase.name + std::string("_") + readCase.name;

                        const TestParams testParams = {
                            stageCombination.fromStage, // Stage fromStage;
                            stageCombination.toStage,   // Stage toStage;
                            resourceCase.resourceType,  // ResourceType resourceType;
                            barrierCase.barrierType,    // BarrierType barrierType;
                            writeCase.writeAccess,      // WriteAccess writeAccess;
                            readCase.readAccess,        // ReadAccess readAccess;
                            testValue++,                // uint32_t testValue;
                        };

                        barrierGroup->addChild(new MeshShaderSyncCase(testCtx, accessCaseName, testParams));
                    }

                resourceGroup->addChild(barrierGroup.release());
            }

            combinationGroup->addChild(resourceGroup.release());
        }

        mainGroup->addChild(combinationGroup.release());
    }

    {
        // Additional synchronization tests
        GroupPtr otherGroup(new tcu::TestCaseGroup(testCtx, "other"));

        // Check synchronizing compute to task across secondary command buffer boundaries
        otherGroup->addChild(new BarrierAcrossSecondaryCase(testCtx, "barrier_across_secondary"));

        mainGroup->addChild(otherGroup.release());
    }

    return mainGroup.release();
}

} // namespace MeshShader
} // namespace vkt