ProgramWgpu.cpp

Show log
Commit

Hash : 91deaea3
Author :
Date : 2025-02-13T13:57:37

Roll third_party/dawn/ 1eca38fa5..8119dbd27 (1982 commits; 30 trivial rolls)

https://dawn.googlesource.com/dawn.git/+log/1eca38fa5236..8119dbd27471

$ git log 1eca38fa5..8119dbd27 --date=short --no-merges --format='%ad %ae %s'
2025-02-12 zhuangxu Set MacOS deployment target to 11.0 when building with CMake
2025-02-12 dsinclair Revert "Remove stale WebGPU Compat CTS expectations"
2025-02-12 rharrison [tint][ir][fuzz] Add missing capability to tint::hlsl::writer::IRFuzzer
2025-02-11 shrekshao [Compat] Remove gles min31 end2end suppressions
2025-02-11 shrekshao [Compat] Fix toggle string for UseBlitForRG11B10UfloatTextureCopy
2025-02-11 rharrison [tint][ir][val] Add operand and result checks for MemberBuiltinCall
2025-02-11 rharrison [tint][ir][val] Check InstructionResult->Instruction is inst
2025-02-11 jrprice [node] Support subgroupMatrixConfigs query in dawn.node
2025-02-11 jrprice [vulkan] Enable subgroup matrix feature
2025-02-11 ynovikov Remove stale WebGPU Compat CTS expectations
2025-02-11 ynovikov Remove stale WebGPU CTS expectations
2025-02-11 dawn-autoroll Roll ANGLE from e746fb068fd3 to 19c5293e1347 (5 revisions)
2025-02-11 jrprice [metal] Enable subgroup matrix feature
2025-02-11 jrprice [dawn] Add SubgroupMatrixConfigs to adapter info
2025-02-11 kylechar Skip setting Vulkan object labels
2025-02-11 dsinclair [spirv-reader][ir] Add derivative operations.
2025-02-11 lehoangquyen D3D11: skip waiting on the fence that is owned by the same queue.
2025-02-11 dawn-autoroll Roll vulkan-deps from cd5e835851d1 to a88fd25a6a0d (8 revisions)
2025-02-11 dsinclair [spirv-reader][ir] Cleanup duplicate argument code.
2025-02-11 jrprice [dawn] Add feature for subgroup matrix extension
2025-02-11 dsinclair [spirv-reader][ir] Add support for `OpAny`.
2025-02-11 dsinclair [spirv-reader][ir] Add support for `OpAll`
2025-02-11 dsinclair [spirv-reader][ir] Add support for `OpBitReverse`.
2025-02-11 cwallez [tint] Make type::BindingArray use ArrayCount
2025-02-11 rharrison [tint][ir][val] Add additional checking to builtin calls
2025-02-11 dsinclair [spirv-reader][ir] Support `OpBitFieldUExtract`.
2025-02-11 lehoangquyen D3D11: return error if D3D feature level < 11.0
2025-02-11 shaoboyan Dawn Native: Setup ClampFragDepth offset in Vulkan Backend
2025-02-10 dawn-autoroll Roll ANGLE from c4caed5f649d to e746fb068fd3 (8 revisions)
2025-02-10 gman Compat: Fixup Device Limits
2025-02-10 dsinclair [spirv-reader][ir] Support `OpBitFieldSExtract`.
2025-02-10 dsinclair [spirv-reader][ir] Support `OpBitFieldInsert`.
2025-02-10 brandon1.jones Add Missing Synchronization For D3D12 Shared Buffers
2025-02-10 ynovikov Skip more textureSample tests on WebGPU CTS compat Android
2025-02-10 cwallez [dawn][frontend] Fix error message when @group > maxBindGroups
2025-02-10 dawn-autoroll Roll SwiftShader from 5017ce3c800e to 720189cae847 (1 revision)
2025-02-10 titouan Include tint fuzzers in high-end fuzzer build.
2025-02-10 dsinclair [spirv-reader][ir] Support `OpBitCount`.
2025-02-10 dawn-autoroll Roll ANGLE from 38aa0780bb36 to c4caed5f649d (28 revisions)
2025-02-10 jrprice [spirv] Require Vulkan Memory Model when fuzzing subgroup matrices
2025-02-10 jwata infra: Add project property to $build/siso
2025-02-10 dawn-autoroll Roll vulkan-deps from b4c8dd090b72 to cd5e835851d1 (1 revision)
2025-02-09 ynovikov Skip textureSample tests on WebGPU CTS compat Android
2025-02-09 dawn-autoroll Roll vulkan-deps from dbe0a14ab512 to b4c8dd090b72 (1 revision)
2025-02-08 ynovikov Remove stale WebGPU Compat CTS expectations
2025-02-08 ynovikov Remove stale WebGPU CTS expectations
2025-02-08 ynovikov Generalize Linux NVIDIA WebGPU CTS expectation
2025-02-07 dawn-autoroll Roll vulkan-deps from c32804ca5a39 to dbe0a14ab512 (9 revisions)
2025-02-07 shrekshao [Compat] fix glsl name collisions between stages for handle
2025-02-07 shrekshao Compat suppress min es31 failure tests
(...)
2024-08-15 rharrison [tint][ir][val] Improve checks on Returns
2024-08-15 petermcneeley [tint] Minor follow-up fix for insert before
2024-08-15 dawn-autoroll Roll ANGLE from 2003e06230b1 to 83ca89e58cef (6 revisions)
2024-08-15 dsinclair Allow marking expectations as INVALID.
2024-08-15 bsheedy Suppress additional Linux/NVIDIA failures
2024-08-15 chouinard Generate missing hlsl e2e tests
2024-08-15 petermcneeley [tint] MSL texture array negative integer clamp
2024-08-15 dsinclair Remove the CTS cache code
2024-08-15 amaiorano Generated missing tint e2e tests for ir.dxc.hlsl
2024-08-15 jiawei.shao Tint: Add validations on the type of `clip_distances`
2024-08-15 dawn-autoroll Roll ANGLE from 6fddb18d77a3 to 2003e06230b1 (6 revisions)
2024-08-15 jiawei.shao Tint: Add WGSL extension and built-in variable `clip_distances`
2024-08-15 jiawei.shao Remove `DeviceBase::ForceSetToggleForTesting`
2024-08-15 jiawei.shao Rename `BufferBase::GetUsage` and `BufferBase::GetUsageExternalOnly`
2024-08-15 bsheedy Suppress 16" Macbook failures
2024-08-14 rharrison [tint][ir][val] Check swizzles are well formed
2024-08-14 chouinard [tint] Implement quadSwapX, Y and Diagonal
2024-08-14 amaiorano [hlsl] Emit mip level 0 for storage textures
2024-08-14 amaiorano Regen ir.fxc.hlsl files
2024-08-14 jrprice [benchmark] Add --check-stale option
2024-08-14 dawn-autoroll Roll vulkan-deps from c297ee8a1d20 to 7660e21e64db (3 revisions)
2024-08-14 amaiorano Fix DXC roll
2024-08-14 dawn-autoroll Roll ANGLE from 5967afe70699 to 6fddb18d77a3 (3 revisions)
2024-08-14 dneto [tint] validate clamp const low <= const high when first arg is runtime-eval
2024-08-14 chouinard [tint] Implement quadBroadcast
2024-08-14 dawn-autoroll Roll ANGLE from fdd26da99a12 to 5967afe70699 (6 revisions)
2024-08-14 jrprice [benchmark][msl] Flatten bindings
2024-08-14 jrprice [benchmark] Split generated shaders into multiple lines
2024-08-14 jiawei.shao Don't check adapter nullability in the constructor of DeviceBase
2024-08-14 jrprice [benchmark] Generate map directly
2024-08-14 jrprice [benchmark] Convert SPIR-V when generating header
2024-08-14 jrprice [benchmark] Check in the generated header
2024-08-14 jrprice [benchmark] Remove spv_reader and wgsl_writer deps
2024-08-13 enga Add DeviceGetAdapter and AdapterGetInstance to client_side_commands
2024-08-13 jrprice [benchmark] Don't convert SPIR-V to WGSL at init
2024-08-13 rharrison [tint][ir][val] Check disards in validator
2024-08-13 chouinard [tint] Implement subgroupShuffleXor, Up and Down
2024-08-13 senorblanco Fix texture-only arg in combine samplers transform.
2024-08-13 jrprice [spirv] Remove ast_generate_bindings
2024-08-13 dawn-autoroll Roll vulkan-deps from 77d583f37170 to c297ee8a1d20 (3 revisions)
2024-08-13 jrprice [tint] Remove the quantizeToF16 AST polyfill
2024-08-13 jrprice [spirv] Remove AST backend
2024-08-13 jrprice [loopy] Switch to IR version of SPIR-V backend
2024-08-13 shrekshao [Compat] Use @size attribute for glsl pad struct
2024-08-13 jrprice Reland "[tint][benchmark] Generate depfile for inputs"
2024-08-13 jrprice [spirv] Move E2E expectations to default paths
2024-08-13 jrprice [spirv] Remove AST E2E expectations
2024-08-13 jrprice [tint] Only allow --use-ir with WIP IR backends
2024-08-13 dawn-autoroll Roll ANGLE from f8fc8ac36280 to fdd26da99a12 (4 revisions)
2024-08-13 dawn-autoroll Manual roll vulkan-deps from a5d4d42457c3 to 77d583f37170 (8 revisions)

Created with:
  roll-dep third_party/dawn

Bug: angleproject:396213611
Change-Id: I124bbd59dccd14d8609c37ef62ccdd4455897b2c
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6270256
Auto-Submit: Yuly Novikov <ynovikov@chromium.org>
Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
Commit-Queue: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>

Download

src/libANGLE/renderer/wgpu/ProgramWgpu.cpp

//
// Copyright 2024 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// ProgramWgpu.cpp:
//    Implements the class methods for ProgramWgpu.
//

#include "libANGLE/renderer/wgpu/ProgramWgpu.h"

#include "GLES2/gl2.h"
#include "common/PackedEnums.h"
#include "common/PackedGLEnums_autogen.h"
#include "common/debug.h"
#include "common/log_utils.h"
#include "libANGLE/Error.h"
#include "libANGLE/ProgramExecutable.h"
#include "libANGLE/renderer/wgpu/ProgramExecutableWgpu.h"
#include "libANGLE/renderer/wgpu/wgpu_utils.h"
#include "libANGLE/renderer/wgpu/wgpu_wgsl_util.h"
#include "libANGLE/trace.h"

#include <dawn/webgpu_cpp.h>

namespace rx
{
namespace
{
const bool kOutputFinalSource = false;

// Identical to Std140 encoder in all aspects, except it ignores opaque uniform types.
class WgpuDefaultBlockEncoder : public sh::Std140BlockEncoder
{
  public:
    void advanceOffset(GLenum type,
                       const std::vector<unsigned int> &arraySizes,
                       bool isRowMajorMatrix,
                       int arrayStride,
                       int matrixStride) override
    {
        if (gl::IsOpaqueType(type))
        {
            return;
        }

        sh::Std140BlockEncoder::advanceOffset(type, arraySizes, isRowMajorMatrix, arrayStride,
                                              matrixStride);
    }
};

void InitDefaultUniformBlock(const std::vector<sh::ShaderVariable> &uniforms,
                             sh::BlockLayoutMap *blockLayoutMapOut,
                             size_t *blockSizeOut)
{
    if (uniforms.empty())
    {
        *blockSizeOut = 0;
        return;
    }

    WgpuDefaultBlockEncoder blockEncoder;
    sh::GetActiveUniformBlockInfo(uniforms, "", &blockEncoder, blockLayoutMapOut);

    *blockSizeOut = blockEncoder.getCurrentOffset();
    return;
}

class CreateWGPUShaderModuleTask : public LinkSubTask
{
  public:
    CreateWGPUShaderModuleTask(wgpu::Instance instance,
                               wgpu::Device device,
                               const gl::SharedCompiledShaderState &compiledShaderState,
                               const gl::ProgramExecutable &executable,
                               gl::ProgramMergedVaryings mergedVaryings,
                               TranslatedWGPUShaderModule &resultShaderModule)
        : mInstance(instance),
          mDevice(device),
          mCompiledShaderState(compiledShaderState),
          mExecutable(executable),
          mMergedVaryings(std::move(mergedVaryings)),
          mShaderModule(resultShaderModule)
    {}

    angle::Result getResult(const gl::Context *context, gl::InfoLog &infoLog) override
    {
        infoLog << mLog.str();
        return mResult;
    }

    void operator()() override
    {
        ANGLE_TRACE_EVENT0("gpu.angle", "CreateWGPUShaderModuleTask");

        gl::ShaderType shaderType = mCompiledShaderState->shaderType;

        ASSERT((mExecutable.getLinkedShaderStages() &
                ~gl::ShaderBitSet({gl::ShaderType::Vertex, gl::ShaderType::Fragment}))
                   .none());
        std::string finalShaderSource;
        if (shaderType == gl::ShaderType::Vertex)
        {
            finalShaderSource = webgpu::WgslAssignLocations(mCompiledShaderState->translatedSource,
                                                            mExecutable.getProgramInputs(),
                                                            mMergedVaryings, shaderType);
        }
        else if (shaderType == gl::ShaderType::Fragment)
        {
            finalShaderSource = webgpu::WgslAssignLocations(mCompiledShaderState->translatedSource,
                                                            mExecutable.getOutputVariables(),
                                                            mMergedVaryings, shaderType);
        }
        else
        {
            UNIMPLEMENTED();
        }
        if (kOutputFinalSource)
        {
            std::cout << finalShaderSource;
        }

        wgpu::ShaderModuleWGSLDescriptor shaderModuleWGSLDescriptor;
        shaderModuleWGSLDescriptor.code = finalShaderSource.c_str();

        wgpu::ShaderModuleDescriptor shaderModuleDescriptor;
        shaderModuleDescriptor.nextInChain = &shaderModuleWGSLDescriptor;

        mShaderModule.module = mDevice.CreateShaderModule(&shaderModuleDescriptor);

        wgpu::CompilationInfoCallback<CreateWGPUShaderModuleTask *> *getCompilationInfoCallback =
            [](wgpu::CompilationInfoRequestStatus status,
               wgpu::CompilationInfo const *compilationInfo, CreateWGPUShaderModuleTask *task) {
                if (status != wgpu::CompilationInfoRequestStatus::Success)
                {
                    task->mResult = angle::Result::Stop;
                }

                for (size_t msgIdx = 0; msgIdx < compilationInfo->messageCount; ++msgIdx)
                {
                    const wgpu::CompilationMessage &message = compilationInfo->messages[msgIdx];
                    switch (message.type)
                    {
                        case wgpu::CompilationMessageType::Error:
                            task->mLog << "Error: ";
                            break;
                        case wgpu::CompilationMessageType::Warning:
                            task->mLog << "Warning: ";
                            break;
                        case wgpu::CompilationMessageType::Info:
                            task->mLog << "Info: ";
                            break;
                        default:
                            task->mLog << "Unknown: ";
                            break;
                    }
                    task->mLog << message.lineNum << ":" << message.linePos << ": "
                               << std::string(message.message) << std::endl;
                }
            };
        wgpu::FutureWaitInfo waitInfo;
        waitInfo.future = mShaderModule.module.GetCompilationInfo(wgpu::CallbackMode::WaitAnyOnly,
                                                                  getCompilationInfoCallback, this);

        wgpu::WaitStatus waitStatus = mInstance.WaitAny(1, &waitInfo, -1);
        if (waitStatus != wgpu::WaitStatus::Success)
        {
            mResult = angle::Result::Stop;
        }
    }

  private:
    wgpu::Instance mInstance;
    wgpu::Device mDevice;
    gl::SharedCompiledShaderState mCompiledShaderState;
    const gl::ProgramExecutable &mExecutable;
    gl::ProgramMergedVaryings mMergedVaryings;

    TranslatedWGPUShaderModule &mShaderModule;

    std::ostringstream mLog;
    angle::Result mResult = angle::Result::Continue;
};

class LinkTaskWgpu : public LinkTask
{
  public:
    LinkTaskWgpu(wgpu::Instance instance, wgpu::Device device, ProgramWgpu *program)
        : mInstance(instance),
          mDevice(device),
          mProgram(program),
          mExecutable(&mProgram->getState().getExecutable())
    {}
    ~LinkTaskWgpu() override = default;

    void link(const gl::ProgramLinkedResources &resources,
              const gl::ProgramMergedVaryings &mergedVaryings,
              std::vector<std::shared_ptr<LinkSubTask>> *linkSubTasksOut,
              std::vector<std::shared_ptr<LinkSubTask>> *postLinkSubTasksOut) override
    {
        ASSERT(linkSubTasksOut && linkSubTasksOut->empty());
        ASSERT(postLinkSubTasksOut && postLinkSubTasksOut->empty());

        ProgramExecutableWgpu *executable =
            GetImplAs<ProgramExecutableWgpu>(&mProgram->getState().getExecutable());

        const gl::ShaderMap<gl::SharedCompiledShaderState> &shaders =
            mProgram->getState().getAttachedShaders();
        for (gl::ShaderType shaderType : gl::AllShaderTypes())
        {
            if (shaders[shaderType])
            {
                auto task = std::make_shared<CreateWGPUShaderModuleTask>(
                    mInstance, mDevice, shaders[shaderType], *executable->getExecutable(),
                    mergedVaryings, executable->getShaderModule(shaderType));
                linkSubTasksOut->push_back(task);
            }
        }

        // The default uniform block's CPU buffer needs to be allocated and the layout calculated,
        // now that the list of uniforms is known.
        angle::Result initUniformBlocksResult = initDefaultUniformBlocks();
        if (IsError(initUniformBlocksResult))
        {
            mLinkResult = initUniformBlocksResult;
            return;
        }

        mLinkResult = angle::Result::Continue;
    }

    angle::Result getResult(const gl::Context *context, gl::InfoLog &infoLog) override
    {
        return mLinkResult;
    }

  private:
    angle::Result initDefaultUniformBlocks()
    {
        ProgramExecutableWgpu *executableWgpu = webgpu::GetImpl(mExecutable);

        // Process vertex and fragment uniforms into std140 packing.
        gl::ShaderMap<sh::BlockLayoutMap> layoutMap;
        gl::ShaderMap<size_t> requiredBufferSize;
        requiredBufferSize.fill(0);

        generateUniformLayoutMapping(&layoutMap, &requiredBufferSize);
        initDefaultUniformLayoutMapping(&layoutMap);

        // All uniform initializations are complete, now resize the buffers accordingly and return
        ANGLE_TRY(executableWgpu->resizeUniformBlockMemory(requiredBufferSize));

        executableWgpu->markDefaultUniformsDirty();

        return angle::Result::Continue;
    }

    void generateUniformLayoutMapping(gl::ShaderMap<sh::BlockLayoutMap> *layoutMapOut,
                                      gl::ShaderMap<size_t> *requiredBufferSizeOut)
    {
        for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
        {
            const gl::SharedCompiledShaderState &shader =
                mProgram->getState().getAttachedShader(shaderType);

            if (shader)
            {
                const std::vector<sh::ShaderVariable> &uniforms = shader->uniforms;
                InitDefaultUniformBlock(uniforms, &(*layoutMapOut)[shaderType],
                                        &(*requiredBufferSizeOut)[shaderType]);
            }
        }
    }

    void initDefaultUniformLayoutMapping(gl::ShaderMap<sh::BlockLayoutMap> *layoutMapOut)
    {
        // Init the default block layout info.
        ProgramExecutableWgpu *executableWgpu = webgpu::GetImpl(mExecutable);
        const auto &uniforms                  = mExecutable->getUniforms();

        for (const gl::VariableLocation &location : mExecutable->getUniformLocations())
        {
            gl::ShaderMap<sh::BlockMemberInfo> layoutInfo;

            if (location.used() && !location.ignored)
            {
                const auto &uniform = uniforms[location.index];
                if (uniform.isInDefaultBlock() && !uniform.isSampler() && !uniform.isImage() &&
                    !uniform.isFragmentInOut())
                {
                    std::string uniformName = mExecutable->getUniformNameByIndex(location.index);
                    if (uniform.isArray())
                    {
                        // Gets the uniform name without the [0] at the end.
                        uniformName = gl::StripLastArrayIndex(uniformName);
                        ASSERT(uniformName.size() !=
                               mExecutable->getUniformNameByIndex(location.index).size());
                    }

                    bool found = false;

                    for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
                    {
                        auto it = (*layoutMapOut)[shaderType].find(uniformName);
                        if (it != (*layoutMapOut)[shaderType].end())
                        {
                            found                  = true;
                            layoutInfo[shaderType] = it->second;
                        }
                    }

                    ASSERT(found);
                }
            }

            for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
            {
                executableWgpu->getSharedDefaultUniformBlock(shaderType)
                    ->uniformLayout.push_back(layoutInfo[shaderType]);
            }
        }
    }

    wgpu::Instance mInstance;
    wgpu::Device mDevice;
    ProgramWgpu *mProgram = nullptr;
    const gl::ProgramExecutable *mExecutable;
    angle::Result mLinkResult = angle::Result::Stop;
};
}  // anonymous namespace

ProgramWgpu::ProgramWgpu(const gl::ProgramState &state) : ProgramImpl(state) {}

ProgramWgpu::~ProgramWgpu() {}

angle::Result ProgramWgpu::load(const gl::Context *context,
                                gl::BinaryInputStream *stream,
                                std::shared_ptr<LinkTask> *loadTaskOut,
                                egl::CacheGetResult *resultOut)
{
    *loadTaskOut = {};
    *resultOut   = egl::CacheGetResult::Success;
    return angle::Result::Continue;
}

void ProgramWgpu::save(const gl::Context *context, gl::BinaryOutputStream *stream) {}

void ProgramWgpu::setBinaryRetrievableHint(bool retrievable) {}

void ProgramWgpu::setSeparable(bool separable) {}

angle::Result ProgramWgpu::link(const gl::Context *context, std::shared_ptr<LinkTask> *linkTaskOut)
{
    wgpu::Device device     = webgpu::GetDevice(context);
    wgpu::Instance instance = webgpu::GetInstance(context);

    *linkTaskOut = std::shared_ptr<LinkTask>(new LinkTaskWgpu(instance, device, this));
    return angle::Result::Continue;
}

GLboolean ProgramWgpu::validate(const gl::Caps &caps)
{
    return GL_TRUE;
}

}  // namespace rx

Download