encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Don't rely on null::Queue::Submit resolving mapping operations. 

In the validation tests, we relied on Queue.Submit(0, nullptr) to
resolve mapping operations. This is fragile so we replace it with a
FlushMappingOperations() function that uses device.Tick() instead.

This allows removing the mapSerial argument from
Buffer::MapRead/WriteAsyncImpl (which was the actual goal of this CL).

Bug: dawn:445
Change-Id: Id98822287370c371bebb83afb8e290e17f3c1b55
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24381
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Corentin Wallez 2020-07-09 06:12:04 +00:00 committed by Commit Bot service account
parent d761d5a575
commit 1318c603d9
17 changed files with 92 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/dawn_native/Buffer.cpp
View File

@ -64,11 +64,11 @@ namespace dawn_native {
return {};
}
MaybeError MapReadAsyncImpl(uint32_t serial) override {
MaybeError MapReadAsyncImpl() override {
UNREACHABLE();
return {};
}
MaybeError MapWriteAsyncImpl(uint32_t serial) override {
MaybeError MapWriteAsyncImpl() override {
UNREACHABLE();
return {};
}
@ -272,7 +272,7 @@ namespace dawn_native {
mMapUserdata = userdata;
mState = BufferState::Mapped;
if (GetDevice()->ConsumedError(MapReadAsyncImpl(mMapSerial))) {
if (GetDevice()->ConsumedError(MapReadAsyncImpl())) {
CallMapReadCallback(mMapSerial, WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0);
return;
}
@ -297,7 +297,7 @@ namespace dawn_native {
mMapUserdata = userdata;
mState = BufferState::Mapped;
if (GetDevice()->ConsumedError(MapWriteAsyncImpl(mMapSerial))) {
if (GetDevice()->ConsumedError(MapWriteAsyncImpl())) {
CallMapWriteCallback(mMapSerial, WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0);
return;
}

4
src/dawn_native/Buffer.h
View File

@ -77,8 +77,8 @@ namespace dawn_native {
private:
virtual MaybeError MapAtCreationImpl() = 0;
virtual MaybeError MapReadAsyncImpl(uint32_t serial) = 0;
virtual MaybeError MapWriteAsyncImpl(uint32_t serial) = 0;
virtual MaybeError MapReadAsyncImpl() = 0;
virtual MaybeError MapWriteAsyncImpl() = 0;
virtual void UnmapImpl() = 0;
virtual void DestroyImpl() = 0;
virtual void* GetMappedPointerImpl() = 0;

2
src/dawn_native/MapRequestTracker.h
View File

@ -41,4 +41,4 @@ namespace dawn_native {
} // namespace dawn_native
#endif // DAWNNATIVE_MAPREQUESTTRACKER_H
#endif // DAWNNATIVE_MAPREQUESTTRACKER_H

4
src/dawn_native/d3d12/BufferD3D12.cpp
View File

@ -269,11 +269,11 @@ namespace dawn_native { namespace d3d12 {
return {};
}
MaybeError Buffer::MapReadAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapReadAsyncImpl() {
return MapInternal(false, "D3D12 map read async");
}
MaybeError Buffer::MapWriteAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapWriteAsyncImpl() {
return MapInternal(true, "D3D12 map write async");
}

4
src/dawn_native/d3d12/BufferD3D12.h
View File

@ -49,8 +49,8 @@ namespace dawn_native { namespace d3d12 {
private:
~Buffer() override;
// Dawn API
MaybeError MapReadAsyncImpl(uint32_t serial) override;
MaybeError MapWriteAsyncImpl(uint32_t serial) override;
MaybeError MapReadAsyncImpl() override;
MaybeError MapWriteAsyncImpl() override;
void UnmapImpl() override;
void DestroyImpl() override;

4
src/dawn_native/metal/BufferMTL.h
View File

@ -38,8 +38,8 @@ namespace dawn_native { namespace metal {
MaybeError Initialize();
~Buffer() override;
// Dawn API
MaybeError MapReadAsyncImpl(uint32_t serial) override;
MaybeError MapWriteAsyncImpl(uint32_t serial) override;
MaybeError MapReadAsyncImpl() override;
MaybeError MapWriteAsyncImpl() override;
void UnmapImpl() override;
void DestroyImpl() override;
void* GetMappedPointerImpl() override;

4
src/dawn_native/metal/BufferMTL.mm
View File

@ -113,11 +113,11 @@ namespace dawn_native { namespace metal {
return {};
}
MaybeError Buffer::MapReadAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapReadAsyncImpl() {
return {};
}
MaybeError Buffer::MapWriteAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapWriteAsyncImpl() {
return {};
}

29
src/dawn_native/null/DeviceNull.cpp
View File

@ -270,17 +270,6 @@ namespace dawn_native { namespace null {
// Buffer
struct BufferMapOperation : PendingOperation {
virtual void Execute() {
buffer->OnMapCommandSerialFinished(serial, isWrite);
}
Ref<Buffer> buffer;
void* ptr;
uint32_t serial;
bool isWrite;
};
Buffer::Buffer(Device* device, const BufferDescriptor* descriptor)
: BufferBase(device, descriptor) {
mBackingData = std::unique_ptr<uint8_t[]>(new uint8_t[GetSize()]);
@ -315,28 +304,14 @@ namespace dawn_native { namespace null {
memcpy(mBackingData.get() + bufferOffset, data, size);
}
MaybeError Buffer::MapReadAsyncImpl(uint32_t serial) {
MapAsyncImplCommon(serial, false);
MaybeError Buffer::MapReadAsyncImpl() {
return {};
}
MaybeError Buffer::MapWriteAsyncImpl(uint32_t serial) {
MapAsyncImplCommon(serial, true);
MaybeError Buffer::MapWriteAsyncImpl() {
return {};
}
void Buffer::MapAsyncImplCommon(uint32_t serial, bool isWrite) {
ASSERT(mBackingData);
auto operation = std::make_unique<BufferMapOperation>();
operation->buffer = this;
operation->ptr = mBackingData.get();
operation->serial = serial;
operation->isWrite = isWrite;
ToBackend(GetDevice())->AddPendingOperation(std::move(operation));
}
void* Buffer::GetMappedPointerImpl() {
return mBackingData.get();
}

5
src/dawn_native/null/DeviceNull.h
View File

@ -199,14 +199,13 @@ namespace dawn_native { namespace null {
~Buffer() override;
// Dawn API
MaybeError MapReadAsyncImpl(uint32_t serial) override;
MaybeError MapWriteAsyncImpl(uint32_t serial) override;
MaybeError MapReadAsyncImpl() override;
MaybeError MapWriteAsyncImpl() override;
void UnmapImpl() override;
void DestroyImpl() override;
bool IsMapWritable() const override;
MaybeError MapAtCreationImpl() override;
void MapAsyncImplCommon(uint32_t serial, bool isWrite);
void* GetMappedPointerImpl() override;
std::unique_ptr<uint8_t[]> mBackingData;

4
src/dawn_native/opengl/BufferGL.cpp
View File

@ -79,7 +79,7 @@ namespace dawn_native { namespace opengl {
return {};
}
MaybeError Buffer::MapReadAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapReadAsyncImpl() {
const OpenGLFunctions& gl = ToBackend(GetDevice())->gl;
// TODO(cwallez@chromium.org): this does GPU->CPU synchronization, we could require a high
@ -89,7 +89,7 @@ namespace dawn_native { namespace opengl {
return {};
}
MaybeError Buffer::MapWriteAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapWriteAsyncImpl() {
const OpenGLFunctions& gl = ToBackend(GetDevice())->gl;
// TODO(cwallez@chromium.org): this does GPU->CPU synchronization, we could require a high

4
src/dawn_native/opengl/BufferGL.h
View File

@ -34,8 +34,8 @@ namespace dawn_native { namespace opengl {
private:
~Buffer() override;
// Dawn API
MaybeError MapReadAsyncImpl(uint32_t serial) override;
MaybeError MapWriteAsyncImpl(uint32_t serial) override;
MaybeError MapReadAsyncImpl() override;
MaybeError MapWriteAsyncImpl() override;
void UnmapImpl() override;
void DestroyImpl() override;

4
src/dawn_native/vulkan/BufferVk.cpp
View File

@ -243,7 +243,7 @@ namespace dawn_native { namespace vulkan {
return {};
}
MaybeError Buffer::MapReadAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapReadAsyncImpl() {
Device* device = ToBackend(GetDevice());
CommandRecordingContext* recordingContext = device->GetPendingRecordingContext();
@ -251,7 +251,7 @@ namespace dawn_native { namespace vulkan {
return {};
}
MaybeError Buffer::MapWriteAsyncImpl(uint32_t serial) {
MaybeError Buffer::MapWriteAsyncImpl() {
Device* device = ToBackend(GetDevice());
CommandRecordingContext* recordingContext = device->GetPendingRecordingContext();

4
src/dawn_native/vulkan/BufferVk.h
View File

@ -52,8 +52,8 @@ namespace dawn_native { namespace vulkan {
void ClearBuffer(CommandRecordingContext* recordingContext, uint32_t clearValue);
// Dawn API
MaybeError MapReadAsyncImpl(uint32_t serial) override;
MaybeError MapWriteAsyncImpl(uint32_t serial) override;
MaybeError MapReadAsyncImpl() override;
MaybeError MapWriteAsyncImpl() override;
void UnmapImpl() override;
void DestroyImpl() override;

82
src/tests/unittests/validation/BufferValidationTests.cpp
View File

@ -172,7 +172,7 @@ TEST_F(BufferValidationTest, MapReadSuccess) {
EXPECT_CALL(*mockBufferMapReadCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
buf.Unmap();
}
@ -186,7 +186,7 @@ TEST_F(BufferValidationTest, MapWriteSuccess) {
EXPECT_CALL(*mockBufferMapWriteCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
buf.Unmap();
}
@ -264,7 +264,7 @@ TEST_F(BufferValidationTest, MapReadAlreadyMapped) {
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, this + 1));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// Test map writing a buffer that is already mapped
@ -281,7 +281,7 @@ TEST_F(BufferValidationTest, MapWriteAlreadyMapped) {
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, this + 1));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// TODO(cwallez@chromium.org) Test a MapWrite and already MapRead and vice-versa
@ -295,9 +295,8 @@ TEST_F(BufferValidationTest, MapReadUnmapBeforeResult) {
.Times(1);
buf.Unmap();
// Submitting the queue makes the null backend process map request, but the callback shouldn't
// be called again
queue.Submit(0, nullptr);
// The callback shouldn't be called again.
WaitForAllOperations(device);
}
// Test unmapping before having the result gives UNKNOWN - for writing
@ -310,9 +309,8 @@ TEST_F(BufferValidationTest, MapWriteUnmapBeforeResult) {
.Times(1);
buf.Unmap();
// Submitting the queue makes the null backend process map request, but the callback shouldn't
// be called again
queue.Submit(0, nullptr);
// The callback shouldn't be called again.
WaitForAllOperations(device);
}
// Test destroying the buffer before having the result gives UNKNOWN - for reading
@ -329,9 +327,8 @@ TEST_F(BufferValidationTest, DISABLED_MapReadDestroyBeforeResult) {
.Times(1);
}
// Submitting the queue makes the null backend process map request, but the callback shouldn't
// be called again
queue.Submit(0, nullptr);
// The callback shouldn't be called again.
WaitForAllOperations(device);
}
// Test destroying the buffer before having the result gives UNKNOWN - for writing
@ -348,9 +345,8 @@ TEST_F(BufferValidationTest, DISABLED_MapWriteDestroyBeforeResult) {
.Times(1);
}
// Submitting the queue makes the null backend process map request, but the callback shouldn't
// be called again
queue.Submit(0, nullptr);
// The callback shouldn't be called again.
WaitForAllOperations(device);
}
// When a MapRead is cancelled with Unmap it might still be in flight, test doing a new request
@ -370,7 +366,7 @@ TEST_F(BufferValidationTest, MapReadUnmapBeforeResultThenMapAgain) {
EXPECT_CALL(*mockBufferMapReadCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, this + 1))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// TODO(cwallez@chromium.org) Test a MapWrite and already MapRead and vice-versa
@ -391,7 +387,7 @@ TEST_F(BufferValidationTest, MapWriteUnmapBeforeResultThenMapAgain) {
EXPECT_CALL(*mockBufferMapWriteCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, this + 1))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// Test that the MapReadCallback isn't fired twice when unmap() is called inside the callback
@ -404,7 +400,7 @@ TEST_F(BufferValidationTest, UnmapInsideMapReadCallback) {
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.WillOnce(InvokeWithoutArgs([&]() { buf.Unmap(); }));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// Test that the MapWriteCallback isn't fired twice when unmap() is called inside the callback
@ -417,7 +413,7 @@ TEST_F(BufferValidationTest, UnmapInsideMapWriteCallback) {
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.WillOnce(InvokeWithoutArgs([&]() { buf.Unmap(); }));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the callback
@ -430,7 +426,7 @@ TEST_F(BufferValidationTest, DestroyInsideMapReadCallback) {
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.WillOnce(InvokeWithoutArgs([&]() { buf = wgpu::Buffer(); }));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the callback
@ -443,7 +439,7 @@ TEST_F(BufferValidationTest, DestroyInsideMapWriteCallback) {
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.WillOnce(InvokeWithoutArgs([&]() { buf = wgpu::Buffer(); }));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
// Test that it is valid to destroy an unmapped buffer
@ -482,7 +478,7 @@ TEST_F(BufferValidationTest, DestroyMappedBufferCausesImplicitUnmap) {
Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, this + 0))
.Times(1);
buf.Destroy();
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::Buffer buf = CreateMapWriteBuffer(4);
@ -492,7 +488,7 @@ TEST_F(BufferValidationTest, DestroyMappedBufferCausesImplicitUnmap) {
Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, this + 1))
.Times(1);
buf.Destroy();
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
}
@ -537,13 +533,13 @@ TEST_F(BufferValidationTest, MapMappedBuffer) {
wgpu::Buffer buf = CreateMapReadBuffer(4);
buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr);
ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::Buffer buf = CreateMapWriteBuffer(4);
buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr);
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
}
@ -552,12 +548,12 @@ TEST_F(BufferValidationTest, MapCreateBufferMappedBuffer) {
{
wgpu::Buffer buf = CreateBufferMapped(4, wgpu::BufferUsage::MapRead).buffer;
ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::Buffer buf = CreateBufferMapped(4, wgpu::BufferUsage::MapWrite).buffer;
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
}
@ -566,12 +562,12 @@ TEST_F(BufferValidationTest, MapBufferMappedAtCreation) {
{
wgpu::Buffer buf = BufferMappedAtCreation(4, wgpu::BufferUsage::MapRead);
ASSERT_DEVICE_ERROR(buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::Buffer buf = BufferMappedAtCreation(4, wgpu::BufferUsage::MapWrite);
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
}
@ -613,7 +609,7 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) {
encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4);
wgpu::CommandBuffer commands = encoder.Finish();
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::Buffer bufA = device.CreateBuffer(&descriptorA);
@ -625,7 +621,7 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) {
encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4);
wgpu::CommandBuffer commands = encoder.Finish();
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::Buffer bufA = device.CreateBufferMapped(&descriptorA).buffer;
@ -635,7 +631,7 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) {
encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4);
wgpu::CommandBuffer commands = encoder.Finish();
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::Buffer bufA = device.CreateBuffer(&descriptorA);
@ -645,7 +641,7 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) {
encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4);
wgpu::CommandBuffer commands = encoder.Finish();
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::BufferDescriptor mappedBufferDesc = descriptorA;
@ -657,7 +653,7 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) {
encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4);
wgpu::CommandBuffer commands = encoder.Finish();
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
{
wgpu::BufferDescriptor mappedBufferDesc = descriptorB;
@ -669,7 +665,7 @@ TEST_F(BufferValidationTest, SubmitMappedBuffer) {
encoder.CopyBufferToBuffer(bufA, 0, bufB, 0, 4);
wgpu::CommandBuffer commands = encoder.Finish();
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
}
}
@ -764,7 +760,7 @@ TEST_F(BufferValidationTest, GetMappedRangeOnUnmappedBuffer) {
EXPECT_CALL(*mockBufferMapReadCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
buf.Unmap();
ASSERT_EQ(nullptr, buf.GetMappedRange());
@ -778,7 +774,7 @@ TEST_F(BufferValidationTest, GetMappedRangeOnUnmappedBuffer) {
EXPECT_CALL(*mockBufferMapWriteCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
buf.Unmap();
ASSERT_EQ(nullptr, buf.GetMappedRange());
@ -826,7 +822,7 @@ TEST_F(BufferValidationTest, GetMappedRangeOnDestroyedBuffer) {
EXPECT_CALL(*mockBufferMapReadCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
buf.Destroy();
ASSERT_EQ(nullptr, buf.GetMappedRange());
@ -840,7 +836,7 @@ TEST_F(BufferValidationTest, GetMappedRangeOnDestroyedBuffer) {
EXPECT_CALL(*mockBufferMapWriteCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
buf.Destroy();
ASSERT_EQ(nullptr, buf.GetMappedRange());
@ -856,7 +852,7 @@ TEST_F(BufferValidationTest, GetMappedRangeOnMappedForReading) {
EXPECT_CALL(*mockBufferMapReadCallback,
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.Times(1);
queue.Submit(0, nullptr);
WaitForAllOperations(device);
ASSERT_EQ(nullptr, buf.GetMappedRange());
}
@ -889,7 +885,7 @@ TEST_F(BufferValidationTest, GetMappedRangeValidCases) {
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.WillOnce(SaveArg<1>(&mappedPointer));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
ASSERT_NE(buf.GetConstMappedRange(), nullptr);
ASSERT_EQ(buf.GetConstMappedRange(), mappedPointer);
@ -905,7 +901,7 @@ TEST_F(BufferValidationTest, GetMappedRangeValidCases) {
Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
.WillOnce(SaveArg<1>(&mappedPointer));
queue.Submit(0, nullptr);
WaitForAllOperations(device);
ASSERT_NE(buf.GetConstMappedRange(), nullptr);
ASSERT_EQ(buf.GetConstMappedRange(), buf.GetMappedRange());

22
src/tests/unittests/validation/QueueSubmitValidationTests.cpp
View File

@ -21,13 +21,6 @@ namespace {
class QueueSubmitValidationTest : public ValidationTest {
};
static void StoreTrueMapWriteCallback(WGPUBufferMapAsyncStatus status,
void*,
uint64_t,
void* userdata) {
*static_cast<bool*>(userdata) = true;
}
// Test submitting with a mapped buffer is disallowed
TEST_F(QueueSubmitValidationTest, SubmitWithMappedBuffer) {
// Create a map-write buffer.
@ -54,11 +47,14 @@ TEST_F(QueueSubmitValidationTest, SubmitWithMappedBuffer) {
queue.Submit(1, &commands);
// Map the buffer, submitting when the buffer is mapped should fail
bool mapWriteFinished = false;
buffer.MapWriteAsync(StoreTrueMapWriteCallback, &mapWriteFinished);
queue.Submit(0, nullptr);
ASSERT_TRUE(mapWriteFinished);
buffer.MapWriteAsync(nullptr, nullptr);
// Try submitting before the callback is fired.
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
WaitForAllOperations(device);
// Try submitting after the callback is fired.
ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
// Unmap the buffer, queue submit should succeed
@ -190,10 +186,10 @@ TEST_F(QueueWriteBufferValidationTest, MappedBuffer) {
{
wgpu::BufferDescriptor descriptor;
descriptor.size = 4;
descriptor.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead;
descriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::MapWrite;
wgpu::Buffer buf = device.CreateBuffer(&descriptor);
buf.MapReadAsync(nullptr, nullptr);
buf.MapWriteAsync(nullptr, nullptr);
uint32_t value = 0;
ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
}

15
src/tests/unittests/validation/ValidationTest.cpp
View File

@ -87,6 +87,21 @@ std::string ValidationTest::GetLastDeviceErrorMessage() const {
return mDeviceErrorMessage;
}
void ValidationTest::WaitForAllOperations(const wgpu::Device& device) const {
wgpu::Queue queue = device.GetDefaultQueue();
wgpu::Fence fence = queue.CreateFence();
// Force the currently submitted operations to completed.
queue.Signal(fence, 1);
while (fence.GetCompletedValue() < 1) {
device.Tick();
}
// TODO(cwallez@chromium.org): It's not clear why we need this additional tick. Investigate it
// once WebGPU has defined the ordering of callbacks firing.
device.Tick();
}
// static
void ValidationTest::OnDeviceError(WGPUErrorType type, const char* message, void* userdata) {
ASSERT(type != WGPUErrorType_NoError);

2
src/tests/unittests/validation/ValidationTest.h
View File

@ -42,6 +42,8 @@ class ValidationTest : public testing::Test {
bool EndExpectDeviceError();
std::string GetLastDeviceErrorMessage() const;
void WaitForAllOperations(const wgpu::Device& device) const;
// Helper functions to create objects to test validation.
struct DummyRenderPass : public wgpu::RenderPassDescriptor {