Add compute pipeline cache key generation for Vulkan.

- Adds dependency to vulkan-tools for pNext chain helpers.
- Adds extra caching to vulkan shaders to keep the spirv in the in-memory cache as well.
- Adds pNext chain serializer infra for Vulkan.

Change-Id: Ibe73183fbff15f7310eaaeae92fbd622be1ac096
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/85022
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Loko Kung <lokokung@google.com>
This commit is contained in:
Loko Kung 2022-04-09 00:10:08 +00:00 committed by Dawn LUCI CQ
parent 30353998c1
commit 23d09c6114
16 changed files with 340 additions and 52 deletions

View File

@ -142,7 +142,8 @@ set_if_not_defined(DAWN_JINJA2_DIR "${DAWN_THIRD_PARTY_DIR}/jinja2" "Directory i
set_if_not_defined(DAWN_SPIRV_HEADERS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps/spirv-headers/src" "Directory in which to find SPIRV-Headers")
set_if_not_defined(DAWN_SPIRV_TOOLS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps/spirv-tools/src" "Directory in which to find SPIRV-Tools")
set_if_not_defined(DAWN_TINT_DIR "${Dawn_SOURCE_DIR}" "Directory in which to find Tint")
set_if_not_defined(DAWN_VULKAN_HEADERS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps/vulkan-headers/src" "Directory in which to find Vulkan-Headers")
set_if_not_defined(DAWN_VULKAN_DEPS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps" "Directory in which to find vulkan-deps")
set_if_not_defined(DAWN_VULKAN_HEADERS_DIR "${DAWN_VULKAN_DEPS_DIR}/vulkan-headers/src" "Directory in which to find Vulkan-Headers")
# Dependencies for DAWN_BUILD_NODE_BINDINGS
set_if_not_defined(NODE_ADDON_API_DIR "${DAWN_THIRD_PARTY_DIR}/node-addon-api" "Directory in which to find node-addon-api")

View File

@ -54,14 +54,17 @@ if (!defined(dawn_swiftshader_dir)) {
dawn_swiftshader_dir = ""
}
if (!defined(dawn_vulkan_headers_dir)) {
dawn_vulkan_headers_dir = "//third_party/vulkan-deps/vulkan-headers/src"
if (!defined(dawn_vulkan_deps_dir)) {
dawn_vulkan_deps_dir = "//third_party/vulkan-deps"
if (dawn_standalone) {
dawn_vulkan_headers_dir =
"${dawn_root}/third_party/vulkan-deps/vulkan-headers/src"
dawn_vulkan_deps_dir = "${dawn_root}/third_party/vulkan-deps"
}
}
if (!defined(dawn_vulkan_headers_dir)) {
dawn_vulkan_headers_dir = "${dawn_vulkan_deps_dir}/vulkan-headers/src"
}
if (!defined(dawn_vulkan_loader_dir)) {
# Default to the Vulkan loader not being available except in standalone.
dawn_vulkan_loader_dir = ""
@ -70,6 +73,10 @@ if (!defined(dawn_vulkan_loader_dir)) {
}
}
if (!defined(dawn_vulkan_tools_dir)) {
dawn_vulkan_tools_dir = "${dawn_vulkan_deps_dir}/vulkan-tools/src"
}
if (!defined(dawn_vulkan_validation_layers_dir)) {
# Default to VVLs not being available.
dawn_vulkan_validation_layers_dir = ""

View File

@ -99,6 +99,11 @@ config("vulkan_rpath") {
}
}
# Config that adds include directory for vulkan-deps, specifically for Vulkan-Tools.
config("vulkan_deps_include") {
include_dirs = [ "${dawn_vulkan_deps_dir}" ]
}
dawn_json_generator("utils_gen") {
target = "native_utils"
outputs = [
@ -571,6 +576,8 @@ source_set("sources") {
}
if (dawn_enable_vulkan) {
configs += [ ":vulkan_deps_include" ]
deps += [ "${dawn_vulkan_tools_dir}:vulkan_tools_headers" ]
public_deps += [ "${dawn_vulkan_headers_dir}:vulkan_headers" ]
sources += [
"vulkan/AdapterVk.cpp",
@ -583,6 +590,8 @@ source_set("sources") {
"vulkan/BindGroupVk.h",
"vulkan/BufferVk.cpp",
"vulkan/BufferVk.h",
"vulkan/CacheKeyVk.cpp",
"vulkan/CacheKeyVk.h",
"vulkan/CommandBufferVk.cpp",
"vulkan/CommandBufferVk.h",
"vulkan/CommandRecordingContext.h",

View File

@ -455,6 +455,8 @@ if (DAWN_ENABLE_VULKAN)
"vulkan/BindGroupVk.h"
"vulkan/BufferVk.cpp"
"vulkan/BufferVk.h"
"vulkan/CacheKeyVk.cpp"
"vulkan/CacheKeyVk.h"
"vulkan/CommandBufferVk.cpp"
"vulkan/CommandBufferVk.h"
"vulkan/CommandRecordingContext.h"
@ -510,6 +512,7 @@ if (DAWN_ENABLE_VULKAN)
)
target_link_libraries(dawn_native PUBLIC Vulkan-Headers)
target_include_directories(dawn_native PRIVATE ${DAWN_VULKAN_DEPS_DIR})
if (UNIX AND NOT APPLE)
target_sources(dawn_native PRIVATE

View File

@ -14,8 +14,19 @@
#include "dawn/native/CacheKey.h"
#include <iomanip>
namespace dawn::native {
std::ostream& operator<<(std::ostream& os, const CacheKey& key) {
os << std::hex;
for (const int b : key) {
os << std::setfill('0') << std::setw(2) << b << " ";
}
os << std::dec;
return os;
}
template <>
void CacheKeySerializer<std::string>::Serialize(CacheKey* key, const std::string& t) {
key->Record(static_cast<size_t>(t.length()));

View File

@ -15,17 +15,20 @@
#ifndef DAWNNATIVE_CACHE_KEY_H_
#define DAWNNATIVE_CACHE_KEY_H_
#include <iostream>
#include <limits>
#include <string>
#include <type_traits>
#include <vector>
#include "dawn/common/Assert.h"
namespace dawn::native {
// Forward declare CacheKey class because of co-dependency.
// Forward declare classes because of co-dependency.
class CacheKey;
class CachedObject;
// Stream operator for CacheKey for debugging.
std::ostream& operator<<(std::ostream& os, const CacheKey& key);
// Overridable serializer struct that should be implemented for cache key serializable
// types/classes.
@ -82,7 +85,31 @@ namespace dawn::native {
}
};
// Specialized overload for string literals. Note we drop the null-terminator.
// Specialized overload for enums.
template <typename T>
class CacheKeySerializer<T, std::enable_if_t<std::is_enum_v<T>>> {
public:
static void Serialize(CacheKey* key, const T t) {
CacheKeySerializer<std::underlying_type_t<T>>::Serialize(
key, static_cast<std::underlying_type_t<T>>(t));
}
};
// Specialized overload for pointers. Since we are serializing for a cache key, we always
// serialize via value, not by pointer. To handle nullptr scenarios, we always serialize whether
// the pointer was nullptr followed by the contents if applicable.
template <typename T>
class CacheKeySerializer<T, std::enable_if_t<std::is_pointer_v<T>>> {
public:
static void Serialize(CacheKey* key, const T t) {
key->Record(t == nullptr);
if (t != nullptr) {
CacheKeySerializer<std::remove_cv_t<std::remove_pointer_t<T>>>::Serialize(key, *t);
}
}
};
// Specialized overload for string literals.
template <size_t N>
class CacheKeySerializer<char[N]> {
public:
@ -93,6 +120,15 @@ namespace dawn::native {
}
};
// Specialized overload for CachedObjects.
template <typename T>
class CacheKeySerializer<T, std::enable_if_t<std::is_base_of_v<CachedObject, T>>> {
public:
static void Serialize(CacheKey* key, const T& t) {
key->Record(t.GetCacheKey());
}
};
} // namespace dawn::native
#endif // DAWNNATIVE_CACHE_KEY_H_

View File

@ -16,6 +16,7 @@
#include "dawn/common/BitSetIterator.h"
#include "dawn/common/ityp_vector.h"
#include "dawn/native/CacheKey.h"
#include "dawn/native/vulkan/BindGroupVk.h"
#include "dawn/native/vulkan/DescriptorSetAllocator.h"
#include "dawn/native/vulkan/DeviceVk.h"
@ -115,6 +116,9 @@ namespace dawn::native::vulkan {
createInfo.bindingCount = static_cast<uint32_t>(bindings.size());
createInfo.pBindings = bindings.data();
// Record cache key information now since the createInfo is not stored.
GetCacheKey()->Record(createInfo);
Device* device = ToBackend(GetDevice());
DAWN_TRY(CheckVkSuccess(device->fn.CreateDescriptorSetLayout(
device->GetVkDevice(), &createInfo, nullptr, &*mHandle),

View File

@ -22,6 +22,10 @@
#include <vector>
namespace dawn::native {
class CacheKey;
} // namespace dawn::native
namespace dawn::native::vulkan {
class BindGroup;

View File

@ -0,0 +1,97 @@
// Copyright 2022 The Dawn Authors
//
// 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.
#include "dawn/native/vulkan/CacheKeyVk.h"
#include <cstring>
namespace dawn::native {
template <>
void CacheKeySerializer<VkDescriptorSetLayoutBinding>::Serialize(
CacheKey* key,
const VkDescriptorSetLayoutBinding& t) {
key->Record(t.binding, t.descriptorType, t.descriptorCount, t.stageFlags);
}
template <>
void CacheKeySerializer<VkDescriptorSetLayoutCreateInfo>::Serialize(
CacheKey* key,
const VkDescriptorSetLayoutCreateInfo& t) {
key->Record(t.flags).RecordIterable(t.pBindings, t.bindingCount);
vulkan::SerializePnext<>(key, reinterpret_cast<const VkBaseOutStructure*>(&t));
}
template <>
void CacheKeySerializer<VkPushConstantRange>::Serialize(CacheKey* key,
const VkPushConstantRange& t) {
key->Record(t.stageFlags, t.offset, t.size);
}
template <>
void CacheKeySerializer<VkPipelineLayoutCreateInfo>::Serialize(
CacheKey* key,
const VkPipelineLayoutCreateInfo& t) {
// The set layouts are not serialized here because they are pointers to backend objects.
// They need to be cross-referenced with the frontend objects and serialized from there.
key->Record(t.flags).RecordIterable(t.pPushConstantRanges, t.pushConstantRangeCount);
vulkan::SerializePnext<>(key, reinterpret_cast<const VkBaseOutStructure*>(&t));
}
template <>
void CacheKeySerializer<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>::Serialize(
CacheKey* key,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& t) {
key->Record(t.requiredSubgroupSize);
}
template <>
void CacheKeySerializer<VkSpecializationMapEntry>::Serialize(
CacheKey* key,
const VkSpecializationMapEntry& t) {
key->Record(t.constantID, t.offset, t.size);
}
template <>
void CacheKeySerializer<VkSpecializationInfo>::Serialize(CacheKey* key,
const VkSpecializationInfo& t) {
key->RecordIterable(t.pMapEntries, t.mapEntryCount)
.RecordIterable(static_cast<const uint8_t*>(t.pData), t.dataSize);
}
template <>
void CacheKeySerializer<VkPipelineShaderStageCreateInfo>::Serialize(
CacheKey* key,
const VkPipelineShaderStageCreateInfo& t) {
// The shader module is not serialized here because it is a pointer to a backend object.
key->Record(t.flags, t.stage)
.RecordIterable(t.pName, strlen(t.pName))
.Record(t.pSpecializationInfo);
vulkan::SerializePnext<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>(
key, reinterpret_cast<const VkBaseOutStructure*>(&t));
}
template <>
void CacheKeySerializer<VkComputePipelineCreateInfo>::Serialize(
CacheKey* key,
const VkComputePipelineCreateInfo& t) {
// The pipeline layout is not serialized here because it is a pointer to a backend object.
// It needs to be cross-referenced with the frontend objects and serialized from there. The
// base pipeline information is also currently not recorded since we do not use them in our
// backend implementation. If we decide to use them later on, they also need to be
// cross-referenced from the frontend.
key->Record(t.flags, t.stage);
}
} // namespace dawn::native

View File

@ -0,0 +1,85 @@
// Copyright 2022 The Dawn Authors
//
// 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.
#include "dawn/common/Assert.h"
#include "dawn/common/vulkan_platform.h"
#include "dawn/native/CacheKey.h"
#include "vulkan-tools/src/icd/generated/vk_typemap_helper.h"
#include <map>
namespace dawn::native::vulkan {
namespace detail {
template <typename... VK_STRUCT_TYPES>
void ValidatePnextImpl(const VkBaseOutStructure* root) {
const VkBaseOutStructure* next =
reinterpret_cast<const VkBaseOutStructure*>(root->pNext);
while (next != nullptr) {
// Assert that the type of each pNext struct is exactly one of the specified
// templates.
ASSERT(((LvlTypeMap<VK_STRUCT_TYPES>::kSType == next->sType ? 1 : 0) + ... + 0) ==
1);
next = reinterpret_cast<const VkBaseOutStructure*>(next->pNext);
}
}
template <typename VK_STRUCT_TYPE>
void SerializePnextImpl(CacheKey* key, const VkBaseOutStructure* root) {
const VkBaseOutStructure* next =
reinterpret_cast<const VkBaseOutStructure*>(root->pNext);
const VK_STRUCT_TYPE* found = nullptr;
while (next != nullptr) {
if (LvlTypeMap<VK_STRUCT_TYPE>::kSType == next->sType) {
if (found == nullptr) {
found = reinterpret_cast<const VK_STRUCT_TYPE*>(next);
} else {
// Fail an assert here since that means that the chain had more than one of
// the same typed chained object.
ASSERT(false);
}
}
next = reinterpret_cast<const VkBaseOutStructure*>(next->pNext);
}
if (found != nullptr) {
key->Record(found);
}
}
template <typename VK_STRUCT_TYPE,
typename... VK_STRUCT_TYPES,
typename = std::enable_if_t<(sizeof...(VK_STRUCT_TYPES) > 0)>>
void SerializePnextImpl(CacheKey* key, const VkBaseOutStructure* root) {
SerializePnextImpl<VK_STRUCT_TYPE>(key, root);
SerializePnextImpl<VK_STRUCT_TYPES...>(key, root);
}
} // namespace detail
template <typename... VK_STRUCT_TYPES>
void SerializePnext(CacheKey* key, const VkBaseOutStructure* root) {
detail::ValidatePnextImpl<VK_STRUCT_TYPES...>(root);
detail::SerializePnextImpl<VK_STRUCT_TYPES...>(key, root);
}
// Empty template specialization so that we can put this in to ensure failures occur if new
// extensions are added without updating serialization.
template <>
void SerializePnext(CacheKey* key, const VkBaseOutStructure* root) {
detail::ValidatePnextImpl<>(root);
}
} // namespace dawn::native::vulkan

View File

@ -22,6 +22,8 @@
#include "dawn/native/vulkan/UtilsVulkan.h"
#include "dawn/native/vulkan/VulkanError.h"
#include <utility>
namespace dawn::native::vulkan {
// static
@ -46,10 +48,11 @@ namespace dawn::native::vulkan {
createInfo.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
// Generate a new VkShaderModule with BindingRemapper tint transform for each pipeline
const ProgrammableStage& computeStage = GetStage(SingleShaderStage::Compute);
DAWN_TRY_ASSIGN(createInfo.stage.module,
ToBackend(computeStage.module.Get())
->GetTransformedModuleHandle(computeStage.entryPoint.c_str(),
ToBackend(GetLayout())));
ShaderModule* module = ToBackend(computeStage.module.Get());
PipelineLayout* layout = ToBackend(GetLayout());
const ShaderModule::Spirv* spirv;
DAWN_TRY_ASSIGN((std::tie(createInfo.stage.module, spirv)),
module->GetHandleAndSpirv(computeStage.entryPoint.c_str(), layout));
createInfo.stage.pName = computeStage.entryPoint.c_str();
@ -74,6 +77,11 @@ namespace dawn::native::vulkan {
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT);
}
// Record cache key information now since the createInfo is not stored.
GetCacheKey()
->Record(createInfo, static_cast<const ComputePipeline*>(this)->GetLayout())
.RecordIterable(*spirv);
DAWN_TRY(CheckVkSuccess(
device->fn.CreateComputePipelines(device->GetVkDevice(), ::VK_NULL_HANDLE, 1,
&createInfo, nullptr, &*mHandle),

View File

@ -38,8 +38,11 @@ namespace dawn::native::vulkan {
// this constraints at the Dawn level?
uint32_t numSetLayouts = 0;
std::array<VkDescriptorSetLayout, kMaxBindGroups> setLayouts;
std::array<const CachedObject*, kMaxBindGroups> cachedObjects;
for (BindGroupIndex setIndex : IterateBitSet(GetBindGroupLayoutsMask())) {
setLayouts[numSetLayouts] = ToBackend(GetBindGroupLayout(setIndex))->GetHandle();
const BindGroupLayoutBase* bindGroupLayout = GetBindGroupLayout(setIndex);
setLayouts[numSetLayouts] = ToBackend(bindGroupLayout)->GetHandle();
cachedObjects[numSetLayouts] = bindGroupLayout;
numSetLayouts++;
}
@ -52,6 +55,9 @@ namespace dawn::native::vulkan {
createInfo.pushConstantRangeCount = 0;
createInfo.pPushConstantRanges = nullptr;
// Record cache key information now since the createInfo is not stored.
GetCacheKey()->RecordIterable(cachedObjects.data(), numSetLayouts).Record(createInfo);
Device* device = ToBackend(GetDevice());
DAWN_TRY(CheckVkSuccess(
device->fn.CreatePipelineLayout(device->GetVkDevice(), &createInfo, nullptr, &*mHandle),

View File

@ -332,6 +332,7 @@ namespace dawn::native::vulkan {
MaybeError RenderPipeline::Initialize() {
Device* device = ToBackend(GetDevice());
PipelineLayout* layout = ToBackend(GetLayout());
// There are at most 2 shader stages in render pipeline, i.e. vertex and fragment
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
@ -344,10 +345,11 @@ namespace dawn::native::vulkan {
VkPipelineShaderStageCreateInfo shaderStage;
const ProgrammableStage& programmableStage = GetStage(stage);
DAWN_TRY_ASSIGN(shaderStage.module,
ToBackend(programmableStage.module)
->GetTransformedModuleHandle(programmableStage.entryPoint.c_str(),
ToBackend(GetLayout())));
ShaderModule* module = ToBackend(programmableStage.module.Get());
const ShaderModule::Spirv* spirv;
DAWN_TRY_ASSIGN(
std::tie(shaderStage.module, spirv),
module->GetHandleAndSpirv(programmableStage.entryPoint.c_str(), layout));
shaderStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
shaderStage.pNext = nullptr;

View File

@ -38,35 +38,38 @@ namespace dawn::native::vulkan {
ShaderModule::ConcurrentTransformedShaderModuleCache::
~ConcurrentTransformedShaderModuleCache() {
std::lock_guard<std::mutex> lock(mMutex);
for (const auto& [_, module] : mTransformedShaderModuleCache) {
mDevice->GetFencedDeleter()->DeleteWhenUnused(module);
for (const auto& [_, moduleAndSpirv] : mTransformedShaderModuleCache) {
mDevice->GetFencedDeleter()->DeleteWhenUnused(moduleAndSpirv.first);
}
}
VkShaderModule ShaderModule::ConcurrentTransformedShaderModuleCache::FindShaderModule(
std::optional<ShaderModule::ModuleAndSpirv>
ShaderModule::ConcurrentTransformedShaderModuleCache::Find(
const PipelineLayoutEntryPointPair& key) {
std::lock_guard<std::mutex> lock(mMutex);
auto iter = mTransformedShaderModuleCache.find(key);
if (iter != mTransformedShaderModuleCache.end()) {
auto cached = iter->second;
return cached;
return std::make_pair(iter->second.first, iter->second.second.get());
}
return VK_NULL_HANDLE;
return {};
}
VkShaderModule ShaderModule::ConcurrentTransformedShaderModuleCache::AddOrGetCachedShaderModule(
ShaderModule::ModuleAndSpirv ShaderModule::ConcurrentTransformedShaderModuleCache::AddOrGet(
const PipelineLayoutEntryPointPair& key,
VkShaderModule value) {
ASSERT(value != VK_NULL_HANDLE);
VkShaderModule module,
std::vector<uint32_t>&& spirv) {
ASSERT(module != VK_NULL_HANDLE);
std::lock_guard<std::mutex> lock(mMutex);
auto iter = mTransformedShaderModuleCache.find(key);
if (iter == mTransformedShaderModuleCache.end()) {
mTransformedShaderModuleCache.emplace(key, value);
return value;
mTransformedShaderModuleCache.emplace(
key, std::make_pair(module, std::unique_ptr<Spirv>(new Spirv(spirv))));
} else {
mDevice->GetFencedDeleter()->DeleteWhenUnused(value);
return iter->second;
mDevice->GetFencedDeleter()->DeleteWhenUnused(module);
}
// Now the key should exist in the map, so find it again and return it.
iter = mTransformedShaderModuleCache.find(key);
return std::make_pair(iter->second.first, iter->second.second.get());
}
// static
@ -109,25 +112,24 @@ namespace dawn::native::vulkan {
ShaderModule::~ShaderModule() = default;
ResultOrError<VkShaderModule> ShaderModule::GetTransformedModuleHandle(
ResultOrError<ShaderModule::ModuleAndSpirv> ShaderModule::GetHandleAndSpirv(
const char* entryPointName,
PipelineLayout* layout) {
TRACE_EVENT0(GetDevice()->GetPlatform(), General,
"ShaderModuleVk::GetTransformedModuleHandle");
TRACE_EVENT0(GetDevice()->GetPlatform(), General, "ShaderModuleVk::GetHandleAndSpirv");
// If the shader was destroyed, we should never call this function.
ASSERT(IsAlive());
ScopedTintICEHandler scopedICEHandler(GetDevice());
// Check to see if we have the handle and spirv cached already.
auto cacheKey = std::make_pair(layout, entryPointName);
VkShaderModule cachedShaderModule =
mTransformedShaderModuleCache->FindShaderModule(cacheKey);
if (cachedShaderModule != VK_NULL_HANDLE) {
return cachedShaderModule;
auto handleAndSpirv = mTransformedShaderModuleCache->Find(cacheKey);
if (handleAndSpirv.has_value()) {
return std::move(*handleAndSpirv);
}
// Creation of VkShaderModule is deferred to this point when using tint generator
// Creation of module and spirv is deferred to this point when using tint generator
// Remap BindingNumber to BindingIndex in WGSL shader
using BindingRemapper = tint::transform::BindingRemapper;
@ -207,7 +209,7 @@ namespace dawn::native::vulkan {
options.use_zero_initialize_workgroup_memory_extension =
GetDevice()->IsToggleEnabled(Toggle::VulkanUseZeroInitializeWorkgroupMemoryExtension);
std::vector<uint32_t> spirv;
Spirv spirv;
{
TRACE_EVENT0(GetDevice()->GetPlatform(), General, "tint::writer::spirv::Generate()");
auto result = tint::writer::spirv::Generate(&program, options);
@ -236,15 +238,17 @@ namespace dawn::native::vulkan {
device->GetVkDevice(), &createInfo, nullptr, &*newHandle),
"CreateShaderModule"));
}
ModuleAndSpirv moduleAndSpirv;
if (newHandle != VK_NULL_HANDLE) {
newHandle =
mTransformedShaderModuleCache->AddOrGetCachedShaderModule(cacheKey, newHandle);
moduleAndSpirv =
mTransformedShaderModuleCache->AddOrGet(cacheKey, newHandle, std::move(spirv));
}
SetDebugName(ToBackend(GetDevice()), VK_OBJECT_TYPE_SHADER_MODULE,
reinterpret_cast<uint64_t&>(newHandle), "Dawn_ShaderModule", GetLabel());
reinterpret_cast<uint64_t&>(moduleAndSpirv.first), "Dawn_ShaderModule",
GetLabel());
return newHandle;
return std::move(moduleAndSpirv);
}
} // namespace dawn::native::vulkan

View File

@ -20,7 +20,11 @@
#include "dawn/common/vulkan_platform.h"
#include "dawn/native/Error.h"
#include <memory>
#include <mutex>
#include <optional>
#include <utility>
#include <vector>
namespace dawn::native::vulkan {
@ -29,12 +33,15 @@ namespace dawn::native::vulkan {
class ShaderModule final : public ShaderModuleBase {
public:
using Spirv = std::vector<uint32_t>;
using ModuleAndSpirv = std::pair<VkShaderModule, const Spirv*>;
static ResultOrError<Ref<ShaderModule>> Create(Device* device,
const ShaderModuleDescriptor* descriptor,
ShaderModuleParseResult* parseResult);
ResultOrError<VkShaderModule> GetTransformedModuleHandle(const char* entryPointName,
PipelineLayout* layout);
ResultOrError<ModuleAndSpirv> GetHandleAndSpirv(const char* entryPointName,
PipelineLayout* layout);
private:
ShaderModule(Device* device, const ShaderModuleDescriptor* descriptor);
@ -42,20 +49,24 @@ namespace dawn::native::vulkan {
MaybeError Initialize(ShaderModuleParseResult* parseResult);
void DestroyImpl() override;
// New handles created by GetTransformedModuleHandle at pipeline creation time
// New handles created by GetHandleAndSpirv at pipeline creation time.
class ConcurrentTransformedShaderModuleCache {
public:
explicit ConcurrentTransformedShaderModuleCache(Device* device);
~ConcurrentTransformedShaderModuleCache();
VkShaderModule FindShaderModule(const PipelineLayoutEntryPointPair& key);
VkShaderModule AddOrGetCachedShaderModule(const PipelineLayoutEntryPointPair& key,
VkShaderModule value);
std::optional<ModuleAndSpirv> Find(const PipelineLayoutEntryPointPair& key);
ModuleAndSpirv AddOrGet(const PipelineLayoutEntryPointPair& key,
VkShaderModule module,
std::vector<uint32_t>&& spirv);
private:
using Entry = std::pair<VkShaderModule, std::unique_ptr<Spirv>>;
Device* mDevice;
std::mutex mMutex;
std::unordered_map<PipelineLayoutEntryPointPair,
VkShaderModule,
Entry,
PipelineLayoutEntryPointPairHashFunc>
mTransformedShaderModuleCache;
};

View File

@ -51,7 +51,7 @@ namespace dawn::native {
// Matcher to compare CacheKeys for easier testing.
MATCHER_P(CacheKeyEq, key, PrintToString(key)) {
return memcmp(arg.data(), key.data(), arg.size()) == 0;
return arg.size() == key.size() && memcmp(arg.data(), key.data(), key.size()) == 0;
}
TEST(CacheKeyTests, RecordSingleMember) {