blob: 7602d111635ed3b9ba56358a7988820cd9c18144 [file]
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gpu/command_buffer/tests/webgpu_test.h"
#include <dawn/dawn_proc.h>
#include <dawn/webgpu.h>
#include "base/command_line.h"
#include "base/test/bind.h"
#include "base/test/test_simple_task_runner.h"
#include "base/test/test_timeouts.h"
#include "base/threading/platform_thread.h"
#include "build/build_config.h"
#include "components/viz/test/test_gpu_service_holder.h"
#include "gpu/command_buffer/client/webgpu_cmd_helper.h"
#include "gpu/command_buffer/client/webgpu_implementation.h"
#include "gpu/command_buffer/service/service_utils.h"
#include "gpu/command_buffer/service/webgpu_decoder.h"
#include "gpu/config/gpu_test_config.h"
#include "gpu/ipc/host/gpu_memory_buffer_support.h"
#include "gpu/ipc/in_process_command_buffer.h"
#include "gpu/ipc/webgpu_in_process_context.h"
#include "gpu/webgpu/callback.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gtest/include/gtest/gtest.h"
#if BUILDFLAG(IS_MAC)
#include "gpu/command_buffer/tests/gl_manager.h"
#include "ui/gl/gl_context.h"
#endif
namespace gpu {
namespace {
void CountCallback(int* count) {
(*count)++;
}
} // anonymous namespace
WebGPUTest::Options::Options() = default;
WebGPUTest::WebGPUTest() = default;
WebGPUTest::~WebGPUTest() = default;
bool WebGPUTest::WebGPUSupported() const {
// TODO(crbug.com/1172447): Re-enable on AMD when the RX 5500 XT issues are
// resolved.
// Win7 does not support WebGPU
if (GPUTestBotConfig::CurrentConfigMatches("Linux AMD") ||
GPUTestBotConfig::CurrentConfigMatches("Win7")) {
return false;
}
return true;
}
bool WebGPUTest::WebGPUSharedImageSupported() const {
// Currently WebGPUSharedImage is only implemented on Mac, Linux, Windows
// and ChromeOS.
#if (BUILDFLAG(IS_MAC) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
BUILDFLAG(IS_WIN)) && \
BUILDFLAG(USE_DAWN)
return true;
#else
return false;
#endif
}
void WebGPUTest::SetUp() {
if (!WebGPUSupported()) {
return;
}
}
void WebGPUTest::TearDown() {
adapter_ = nullptr;
instance_ = nullptr;
context_ = nullptr;
}
void WebGPUTest::Initialize(const Options& options) {
if (!WebGPUSupported()) {
return;
}
gpu::GpuPreferences gpu_preferences;
gpu_preferences.enable_webgpu = true;
gpu_preferences.use_passthrough_cmd_decoder =
gles2::UsePassthroughCommandDecoder(
base::CommandLine::ForCurrentProcess());
#if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && BUILDFLAG(USE_DAWN)
gpu_preferences.use_vulkan = gpu::VulkanImplementationName::kNative;
gpu_preferences.gr_context_type = gpu::GrContextType::kVulkan;
#endif
gpu_preferences.enable_unsafe_webgpu = options.enable_unsafe_webgpu;
gpu_preferences.texture_target_exception_list =
gpu::CreateBufferUsageAndFormatExceptionList();
gpu_service_holder_ =
std::make_unique<viz::TestGpuServiceHolder>(gpu_preferences);
ContextCreationAttribs attributes;
attributes.bind_generates_resource = false;
attributes.enable_gles2_interface = false;
attributes.context_type = CONTEXT_TYPE_WEBGPU;
#if BUILDFLAG(IS_MAC)
ImageFactory* image_factory = &image_factory_;
#else
static constexpr ImageFactory* image_factory = nullptr;
#endif
context_ = std::make_unique<WebGPUInProcessContext>();
ContextResult result =
context_->Initialize(gpu_service_holder_->task_executor(), attributes,
options.shared_memory_limits, image_factory);
ASSERT_EQ(result, ContextResult::kSuccess);
cmd_helper_ = std::make_unique<webgpu::WebGPUCmdHelper>(
context_->GetCommandBufferForTest());
DawnProcTable procs = webgpu()->GetAPIChannel()->GetProcs();
dawnProcSetProcs(&procs);
instance_ = wgpu::Instance(webgpu()->GetAPIChannel()->GetWGPUInstance());
wgpu::RequestAdapterOptions ra_options = {};
ra_options.forceFallbackAdapter = options.force_fallback_adapter;
bool done = false;
auto* callback = webgpu::BindWGPUOnceCallback(
[](WebGPUTest* test, bool force_fallback_adapter, bool* done,
WGPURequestAdapterStatus status, WGPUAdapter adapter,
const char* message) {
if (!force_fallback_adapter) {
// If we don't force a particular adapter, we should always find
// one.
EXPECT_EQ(status, WGPURequestAdapterStatus_Success);
EXPECT_NE(adapter, nullptr);
}
test->adapter_ = wgpu::Adapter::Acquire(adapter);
*done = true;
},
this, options.force_fallback_adapter, &done);
instance_.RequestAdapter(&ra_options, callback->UnboundCallback(),
callback->AsUserdata());
webgpu()->FlushCommands();
while (!done) {
RunPendingTasks();
}
}
webgpu::WebGPUImplementation* WebGPUTest::webgpu() const {
return context_->GetImplementation();
}
webgpu::WebGPUCmdHelper* WebGPUTest::webgpu_cmds() const {
return cmd_helper_.get();
}
SharedImageInterface* WebGPUTest::GetSharedImageInterface() const {
return context_->GetCommandBufferForTest()->GetSharedImageInterface();
}
webgpu::WebGPUDecoder* WebGPUTest::GetDecoder() const {
return context_->GetCommandBufferForTest()->GetWebGPUDecoderForTest();
}
void WebGPUTest::RunPendingTasks() {
context_->GetTaskRunner()->RunPendingTasks();
gpu_service_holder_->ScheduleGpuTask(base::BindOnce(
[](webgpu::WebGPUDecoder* decoder) {
if (decoder->HasPollingWork()) {
decoder->PerformPollingWork();
}
},
GetDecoder()));
}
void WebGPUTest::WaitForCompletion(wgpu::Device device) {
// Wait for any work submitted to the queue to be finished. The guarantees of
// Dawn are that all previous operations will have been completed and more
// importantly the callbacks will have been called.
wgpu::Queue queue = device.GetQueue();
bool done = false;
queue.OnSubmittedWorkDone(
0u,
[](WGPUQueueWorkDoneStatus, void* userdata) {
*static_cast<bool*>(userdata) = true;
},
&done);
while (!done) {
device.Tick();
webgpu()->FlushCommands();
RunPendingTasks();
}
}
void WebGPUTest::PollUntilIdle() {
webgpu()->FlushCommands();
base::WaitableEvent wait;
gpu_service_holder_->ScheduleGpuTask(
base::BindLambdaForTesting([&wait, decoder = GetDecoder()]() {
while (decoder->HasPollingWork()) {
base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
decoder->PerformPollingWork();
}
wait.Signal();
}));
wait.Wait();
context_->GetTaskRunner()->RunPendingTasks();
}
wgpu::Device WebGPUTest::GetNewDevice() {
wgpu::Device device;
bool done = false;
auto* callback = webgpu::BindWGPUOnceCallback(
[](wgpu::Device* device_out, bool* done, WGPURequestDeviceStatus status,
WGPUDevice device, const char* message) {
*device_out = wgpu::Device::Acquire(device);
*done = true;
},
&device, &done);
DCHECK(adapter_);
wgpu::DeviceDescriptor device_desc = {};
adapter_.RequestDevice(&device_desc, callback->UnboundCallback(),
callback->AsUserdata());
webgpu()->FlushCommands();
while (!done) {
base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
RunPendingTasks();
}
EXPECT_NE(device, nullptr);
device.SetDeviceLostCallback(
[](WGPUDeviceLostReason reason, const char* message, void*) {
if (reason == WGPUDeviceLostReason_Destroyed) {
return;
}
GTEST_FAIL() << "Unexpected device lost (" << reason
<< "): " << message;
},
nullptr);
device.SetUncapturedErrorCallback(
[](WGPUErrorType type, const char* message, void*) {
GTEST_FAIL() << "Unexpected error (" << type << "): " << message;
},
nullptr);
return device;
}
TEST_F(WebGPUTest, FlushNoCommands) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
Initialize(WebGPUTest::Options());
webgpu()->FlushCommands();
}
// Referred from GLES2ImplementationTest/ReportLoss
TEST_F(WebGPUTest, ReportLoss) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
Initialize(WebGPUTest::Options());
GpuControlClient* webgpu_as_client = webgpu();
int lost_count = 0;
webgpu()->SetLostContextCallback(base::BindOnce(&CountCallback, &lost_count));
EXPECT_EQ(0, lost_count);
webgpu_as_client->OnGpuControlLostContext();
// The lost context callback should be run when WebGPUImplementation is
// notified of the loss.
EXPECT_EQ(1, lost_count);
}
// Referred from GLES2ImplementationTest/ReportLossReentrant
TEST_F(WebGPUTest, ReportLossReentrant) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
Initialize(WebGPUTest::Options());
GpuControlClient* webgpu_as_client = webgpu();
int lost_count = 0;
webgpu()->SetLostContextCallback(base::BindOnce(&CountCallback, &lost_count));
EXPECT_EQ(0, lost_count);
webgpu_as_client->OnGpuControlLostContextMaybeReentrant();
// The lost context callback should not be run yet to avoid calling back into
// clients re-entrantly, and having them re-enter WebGPUImplementation.
EXPECT_EQ(0, lost_count);
}
TEST_F(WebGPUTest, RequestAdapterAfterContextLost) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
Initialize(WebGPUTest::Options());
webgpu()->OnGpuControlLostContext();
bool called = false;
wgpu::RequestAdapterOptions ra_options = {};
instance_.RequestAdapter(
&ra_options,
[](WGPURequestAdapterStatus status, WGPUAdapter adapter,
const char* message, void* userdata) {
EXPECT_EQ(adapter, nullptr);
*static_cast<bool*>(userdata) = true;
},
&called);
webgpu()->FlushCommands();
RunPendingTasks();
EXPECT_TRUE(called);
}
TEST_F(WebGPUTest, RequestDeviceAfterContextLost) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
Initialize(WebGPUTest::Options());
webgpu()->OnGpuControlLostContext();
bool called = false;
DCHECK(adapter_);
wgpu::DeviceDescriptor device_desc = {};
adapter_.RequestDevice(
&device_desc,
[](WGPURequestDeviceStatus status, WGPUDevice device, const char* message,
void* userdata) {
EXPECT_EQ(device, nullptr);
*static_cast<bool*>(userdata) = true;
},
&called);
webgpu()->FlushCommands();
RunPendingTasks();
EXPECT_TRUE(called);
}
TEST_F(WebGPUTest, RequestDeviceWitUnsupportedFeature) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
#if BUILDFLAG(IS_MAC)
// Crashing on Mac M1. Currently missing stack trace. crbug.com/1271926
// This must be checked before WebGPUTest::Initialize otherwise context
// switched is locked and we cannot temporarily have this GLContext.
GLManager gl_manager;
gl_manager.Initialize(GLManager::Options());
std::string renderer(gl_manager.context()->GetGLRenderer());
if (renderer.find("Apple M1") != std::string::npos) {
gl_manager.Destroy();
return;
}
gl_manager.Destroy();
#endif
Initialize(WebGPUTest::Options());
// Create device with unsupported features, expect to fail to create and
// return nullptr
wgpu::FeatureName invalid_feature = static_cast<wgpu::FeatureName>(-2);
wgpu::Device device;
bool done = false;
auto* callback = webgpu::BindWGPUOnceCallback(
[](wgpu::Device* device_out, bool* done, WGPURequestDeviceStatus status,
WGPUDevice device, const char* message) {
*device_out = wgpu::Device::Acquire(device);
*done = true;
},
&device, &done);
DCHECK(adapter_);
wgpu::DeviceDescriptor device_desc = {};
device_desc.requiredFeaturesCount = 1;
device_desc.requiredFeatures = &invalid_feature;
adapter_.RequestDevice(&device_desc, callback->UnboundCallback(),
callback->AsUserdata());
webgpu()->FlushCommands();
while (!done) {
RunPendingTasks();
}
EXPECT_EQ(device, nullptr);
// Create device again with supported features, expect success and not
// blocked by the last failure
GetNewDevice();
}
TEST_F(WebGPUTest, SPIRVIsDisallowed) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
auto ExpectSPIRVDisallowedError = [](WGPUErrorType type, const char* message,
void* userdata) {
// We match on this string to make sure the shader module creation fails
// because SPIR-V is disallowed and not because codeSize=0.
EXPECT_THAT(message, testing::HasSubstr("SPIR-V is disallowed"));
EXPECT_EQ(type, WGPUErrorType_Validation);
*static_cast<bool*>(userdata) = true;
};
auto options = WebGPUTest::Options();
options.enable_unsafe_webgpu = false;
Initialize(options);
wgpu::Device device = GetNewDevice();
// Make a invalid ShaderModuleDescriptor because it contains SPIR-V.
wgpu::ShaderModuleSPIRVDescriptor spirvDesc;
spirvDesc.codeSize = 0;
spirvDesc.code = nullptr;
wgpu::ShaderModuleDescriptor desc;
desc.nextInChain = &spirvDesc;
// Make sure creation fails, and for the correct reason.
device.PushErrorScope(wgpu::ErrorFilter::Validation);
device.CreateShaderModule(&desc);
bool got_error = false;
device.PopErrorScope(ExpectSPIRVDisallowedError, &got_error);
WaitForCompletion(device);
EXPECT_TRUE(got_error);
}
TEST_F(WebGPUTest, ExplicitFallbackAdapterIsDisallowed) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
auto options = WebGPUTest::Options();
options.force_fallback_adapter = true;
options.enable_unsafe_webgpu = false;
// Initialize attempts to create an adapter.
Initialize(options);
// No fallback adapter should be available.
EXPECT_EQ(adapter_, nullptr);
}
TEST_F(WebGPUTest, ImplicitFallbackAdapterIsDisallowed) {
if (!WebGPUSupported()) {
LOG(ERROR) << "Test skipped because WebGPU isn't supported";
return;
}
auto options = WebGPUTest::Options();
options.enable_unsafe_webgpu = false;
// Initialize attempts to create an adapter.
Initialize(options);
if (adapter_) {
wgpu::AdapterProperties properties;
adapter_.GetProperties(&properties);
// If we got an Adapter, it must not be a CPU adapter.
EXPECT_NE(properties.adapterType, wgpu::AdapterType::CPU);
}
}
} // namespace gpu