blob: 1c5d20d6a4f3010dae682f76ed95454d88328ce9 [file] [log] [blame]
/*
* Copyright 2022 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "tools/graphite/dawn/GraphiteDawnTestContext.h"
#include "include/gpu/graphite/Context.h"
#include "include/gpu/graphite/ContextOptions.h"
#include "include/gpu/graphite/dawn/DawnTypes.h"
#include "include/gpu/graphite/dawn/DawnUtils.h"
#include "include/private/base/SkOnce.h"
#include "src/gpu/graphite/ContextOptionsPriv.h"
#include "tools/gpu/ContextType.h"
#include "tools/graphite/TestOptions.h"
#include "dawn/dawn_proc.h"
#define LOG_ADAPTER 0
namespace skiatest::graphite {
// TODO: http://crbug.com/dawn/2450 - Currently manually setting the device to null and calling
// tick/process events one last time to ensure that the device is lost accordingly at
// destruction. Once device lost is, by default, a spontaneous event, remove this.
DawnTestContext::~DawnTestContext() {
fBackendContext.fDevice = nullptr;
tick();
}
std::unique_ptr<GraphiteTestContext> DawnTestContext::Make(wgpu::BackendType backend,
bool useTintIR) {
static std::unique_ptr<dawn::native::Instance> sInstance;
static SkOnce sOnce;
static constexpr const char* kToggles[] = {
"allow_unsafe_apis", // Needed for dual-source blending.
"use_user_defined_labels_in_backend",
// Robustness impacts performance and is always disabled when running Graphite in Chrome,
// so this keeps Skia's tests operating closer to real-use behavior.
"disable_robustness",
// Must be last to correctly respond to `useTintIR` parameter.
"use_tint_ir",
};
wgpu::DawnTogglesDescriptor togglesDesc;
togglesDesc.enabledToggleCount = std::size(kToggles) - (useTintIR ? 0 : 1);
togglesDesc.enabledToggles = kToggles;
// Creation of Instance is cheap but calling EnumerateAdapters can be expensive the first time,
// but then the results are cached on the Instance object. So save the Instance here so we can
// avoid the overhead of EnumerateAdapters on every test.
sOnce([&]{
DawnProcTable backendProcs = dawn::native::GetProcs();
dawnProcSetProcs(&backendProcs);
WGPUInstanceDescriptor desc{};
// need for WaitAny with timeout > 0
desc.features.timedWaitAnyEnable = true;
sInstance = std::make_unique<dawn::native::Instance>(&desc);
});
dawn::native::Adapter matchedAdaptor;
wgpu::RequestAdapterOptions options;
options.compatibilityMode =
backend == wgpu::BackendType::OpenGL || backend == wgpu::BackendType::OpenGLES;
options.nextInChain = &togglesDesc;
std::vector<dawn::native::Adapter> adapters = sInstance->EnumerateAdapters(&options);
SkASSERT(!adapters.empty());
// Sort adapters by adapterType(DiscreteGPU, IntegratedGPU, CPU) and
// backendType(WebGPU, D3D11, D3D12, Metal, Vulkan, OpenGL, OpenGLES).
std::sort(
adapters.begin(), adapters.end(), [](dawn::native::Adapter a, dawn::native::Adapter b) {
wgpu::Adapter wgpuA = a.Get();
wgpu::Adapter wgpuB = b.Get();
wgpu::AdapterInfo infoA;
wgpu::AdapterInfo infoB;
wgpuA.GetInfo(&infoA);
wgpuB.GetInfo(&infoB);
return std::tuple(infoA.adapterType, infoA.backendType) <
std::tuple(infoB.adapterType, infoB.backendType);
});
for (const auto& adapter : adapters) {
wgpu::Adapter wgpuAdapter = adapter.Get();
wgpu::AdapterInfo props;
wgpuAdapter.GetInfo(&props);
if (backend == props.backendType) {
matchedAdaptor = adapter;
break;
}
}
if (!matchedAdaptor) {
return nullptr;
}
#if LOG_ADAPTER
wgpu::AdapterInfo info;
sAdapter.GetInfo(&info);
SkDebugf("GPU: %s\nDriver: %s\n", info.device, info.description);
#endif
std::vector<wgpu::FeatureName> features;
wgpu::Adapter adapter = matchedAdaptor.Get();
if (adapter.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled)) {
features.push_back(wgpu::FeatureName::MSAARenderToSingleSampled);
}
if (adapter.HasFeature(wgpu::FeatureName::TransientAttachments)) {
features.push_back(wgpu::FeatureName::TransientAttachments);
}
if (adapter.HasFeature(wgpu::FeatureName::Unorm16TextureFormats)) {
features.push_back(wgpu::FeatureName::Unorm16TextureFormats);
}
if (adapter.HasFeature(wgpu::FeatureName::DualSourceBlending)) {
features.push_back(wgpu::FeatureName::DualSourceBlending);
}
if (adapter.HasFeature(wgpu::FeatureName::FramebufferFetch)) {
features.push_back(wgpu::FeatureName::FramebufferFetch);
}
if (adapter.HasFeature(wgpu::FeatureName::BufferMapExtendedUsages)) {
features.push_back(wgpu::FeatureName::BufferMapExtendedUsages);
}
if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionETC2)) {
features.push_back(wgpu::FeatureName::TextureCompressionETC2);
}
if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionBC)) {
features.push_back(wgpu::FeatureName::TextureCompressionBC);
}
if (adapter.HasFeature(wgpu::FeatureName::R8UnormStorage)) {
features.push_back(wgpu::FeatureName::R8UnormStorage);
}
if (adapter.HasFeature(wgpu::FeatureName::DawnLoadResolveTexture)) {
features.push_back(wgpu::FeatureName::DawnLoadResolveTexture);
}
if (adapter.HasFeature(wgpu::FeatureName::DawnPartialLoadResolveTexture)) {
features.push_back(wgpu::FeatureName::DawnPartialLoadResolveTexture);
}
if (adapter.HasFeature(wgpu::FeatureName::TimestampQuery)) {
features.push_back(wgpu::FeatureName::TimestampQuery);
}
if (adapter.HasFeature(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment)) {
features.push_back(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment);
}
wgpu::DeviceDescriptor desc;
desc.requiredFeatureCount = features.size();
desc.requiredFeatures = features.data();
desc.nextInChain = &togglesDesc;
desc.SetDeviceLostCallback(
wgpu::CallbackMode::AllowSpontaneous,
[](const wgpu::Device&, wgpu::DeviceLostReason reason, const char* message) {
if (reason != wgpu::DeviceLostReason::Destroyed) {
SK_ABORT("Device lost: %s\n", message);
}
});
desc.SetUncapturedErrorCallback([](const wgpu::Device&, wgpu::ErrorType, const char* message) {
SkDebugf("Device error: %s\n", message);
});
wgpu::Device device = wgpu::Device::Acquire(matchedAdaptor.CreateDevice(&desc));
SkASSERT(device);
skgpu::graphite::DawnBackendContext backendContext;
backendContext.fInstance = wgpu::Instance(sInstance->Get());
backendContext.fDevice = device;
backendContext.fQueue = device.GetQueue();
return std::unique_ptr<GraphiteTestContext>(new DawnTestContext(backendContext));
}
skgpu::ContextType DawnTestContext::contextType() {
wgpu::AdapterInfo info;
fBackendContext.fDevice.GetAdapter().GetInfo(&info);
switch (info.backendType) {
case wgpu::BackendType::D3D11:
return skgpu::ContextType::kDawn_D3D11;
case wgpu::BackendType::D3D12:
return skgpu::ContextType::kDawn_D3D12;
case wgpu::BackendType::Metal:
return skgpu::ContextType::kDawn_Metal;
case wgpu::BackendType::Vulkan:
return skgpu::ContextType::kDawn_Vulkan;
case wgpu::BackendType::OpenGL:
return skgpu::ContextType::kDawn_OpenGL;
case wgpu::BackendType::OpenGLES:
return skgpu::ContextType::kDawn_OpenGLES;
default:
SK_ABORT("unexpected Dawn backend");
return skgpu::ContextType::kMock;
}
}
std::unique_ptr<skgpu::graphite::Context> DawnTestContext::makeContext(const TestOptions& options) {
skgpu::graphite::ContextOptions revisedContextOptions(options.fContextOptions);
skgpu::graphite::ContextOptionsPriv contextOptionsPriv;
if (!options.fContextOptions.fOptionsPriv) {
revisedContextOptions.fOptionsPriv = &contextOptionsPriv;
}
// Needed to make synchronous readPixels work
revisedContextOptions.fOptionsPriv->fStoreContextRefInRecorder = true;
auto backendContext = fBackendContext;
if (options.fNeverYieldToWebGPU) {
backendContext.fTick = nullptr;
}
return skgpu::graphite::ContextFactory::MakeDawn(backendContext, revisedContextOptions);
}
void DawnTestContext::tick() { fBackendContext.fTick(fBackendContext.fInstance); }
} // namespace skiatest::graphite