mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-12-16 08:27:05 +00:00
Implement timeline fences in Dawn
This change implements timeline fences in Dawn. It includes methods and descriptor members to eventually support multi-queue, but does not implement them. Bug: dawn:26 Change-Id: I81d5fee6acef402fe099227a034d9669a89ab6c3 Reviewed-on: https://dawn-review.googlesource.com/c/2460 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
This commit is contained in:
Austin Eng
committed by
Commit Bot service account
Commit Bot service account
parent
d758e32610
commit
f0b761f116
227
src/tests/end2end/FenceTests.cpp
Normal file
227
src/tests/end2end/FenceTests.cpp
Normal file
@@ -0,0 +1,227 @@
|
||||
// Copyright 2018 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 <gmock/gmock.h>
|
||||
#include "tests/DawnTest.h"
|
||||
|
||||
#include <array>
|
||||
#include <cstring>
|
||||
|
||||
class MockFenceOnCompletionCallback {
|
||||
public:
|
||||
MOCK_METHOD2(Call, void(dawnFenceCompletionStatus status, dawnCallbackUserdata userdata));
|
||||
};
|
||||
|
||||
static std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
|
||||
static void ToMockFenceOnCompletionCallback(dawnFenceCompletionStatus status,
|
||||
dawnCallbackUserdata userdata) {
|
||||
mockFenceOnCompletionCallback->Call(status, userdata);
|
||||
}
|
||||
class FenceTests : public DawnTest {
|
||||
private:
|
||||
struct CallbackInfo {
|
||||
FenceTests* test;
|
||||
uint64_t value;
|
||||
dawnFenceCompletionStatus status;
|
||||
int32_t callIndex = -1; // If this is -1, the callback was not called
|
||||
|
||||
void Update(dawnFenceCompletionStatus status) {
|
||||
this->callIndex = test->mCallIndex++;
|
||||
this->status = status;
|
||||
}
|
||||
};
|
||||
|
||||
int32_t mCallIndex;
|
||||
|
||||
protected:
|
||||
FenceTests() : mCallIndex(0) {
|
||||
}
|
||||
|
||||
void SetUp() override {
|
||||
DawnTest::SetUp();
|
||||
mockFenceOnCompletionCallback = std::make_unique<MockFenceOnCompletionCallback>();
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
mockFenceOnCompletionCallback = nullptr;
|
||||
DawnTest::TearDown();
|
||||
}
|
||||
|
||||
void WaitForCompletedValue(dawn::Fence fence, uint64_t completedValue) {
|
||||
while (fence.GetCompletedValue() < completedValue) {
|
||||
WaitABit();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Test that signaling a fence updates the completed value
|
||||
TEST_P(FenceTests, SimpleSignal) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1u;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
// Completed value starts at initial value
|
||||
EXPECT_EQ(fence.GetCompletedValue(), 1u);
|
||||
|
||||
queue.Signal(fence, 2);
|
||||
WaitForCompletedValue(fence, 2);
|
||||
|
||||
// Completed value updates to signaled value
|
||||
EXPECT_EQ(fence.GetCompletedValue(), 2u);
|
||||
}
|
||||
|
||||
// Test callbacks are called in increasing order of fence completion value
|
||||
TEST_P(FenceTests, OnCompletionOrdering) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 0u;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
queue.Signal(fence, 4);
|
||||
|
||||
dawnCallbackUserdata userdata0 = 1282;
|
||||
dawnCallbackUserdata userdata1 = 4382;
|
||||
dawnCallbackUserdata userdata2 = 1211;
|
||||
dawnCallbackUserdata userdata3 = 1882;
|
||||
|
||||
{
|
||||
testing::InSequence s;
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata0))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata1))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata2))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata3))
|
||||
.Times(1);
|
||||
}
|
||||
|
||||
fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, userdata2);
|
||||
fence.OnCompletion(0u, ToMockFenceOnCompletionCallback, userdata0);
|
||||
fence.OnCompletion(3u, ToMockFenceOnCompletionCallback, userdata3);
|
||||
fence.OnCompletion(1u, ToMockFenceOnCompletionCallback, userdata1);
|
||||
|
||||
WaitForCompletedValue(fence, 4);
|
||||
}
|
||||
|
||||
// Test callbacks still occur if Queue::Signal happens multiple times
|
||||
TEST_P(FenceTests, MultipleSignalOnCompletion) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 0u;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
queue.Signal(fence, 2);
|
||||
queue.Signal(fence, 4);
|
||||
|
||||
dawnCallbackUserdata userdata = 1234;
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata))
|
||||
.Times(1);
|
||||
fence.OnCompletion(3u, ToMockFenceOnCompletionCallback, userdata);
|
||||
|
||||
WaitForCompletedValue(fence, 4);
|
||||
}
|
||||
|
||||
// Test all callbacks are called if they are added for the same fence value
|
||||
TEST_P(FenceTests, OnCompletionMultipleCallbacks) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 0u;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
queue.Signal(fence, 4);
|
||||
|
||||
dawnCallbackUserdata userdata0 = 2341;
|
||||
dawnCallbackUserdata userdata1 = 4598;
|
||||
dawnCallbackUserdata userdata2 = 5690;
|
||||
dawnCallbackUserdata userdata3 = 2783;
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata0))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata1))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata2))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata3))
|
||||
.Times(1);
|
||||
|
||||
fence.OnCompletion(4u, ToMockFenceOnCompletionCallback, userdata0);
|
||||
fence.OnCompletion(4u, ToMockFenceOnCompletionCallback, userdata1);
|
||||
fence.OnCompletion(4u, ToMockFenceOnCompletionCallback, userdata2);
|
||||
fence.OnCompletion(4u, ToMockFenceOnCompletionCallback, userdata3);
|
||||
|
||||
WaitForCompletedValue(fence, 4u);
|
||||
}
|
||||
|
||||
// TODO(enga): Enable when fence is removed from fence signal tracker
|
||||
// Currently it holds a reference and is not destructed
|
||||
TEST_P(FenceTests, DISABLED_DestroyBeforeOnCompletionEnd) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 0u;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
// The fence in this block will be deleted when it goes out of scope
|
||||
{
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 0u;
|
||||
dawn::Fence testFence = device.CreateFence(&descriptor);
|
||||
|
||||
queue.Signal(testFence, 4);
|
||||
|
||||
dawnCallbackUserdata userdata0 = 1341;
|
||||
dawnCallbackUserdata userdata1 = 1598;
|
||||
dawnCallbackUserdata userdata2 = 1690;
|
||||
dawnCallbackUserdata userdata3 = 1783;
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, userdata0))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, userdata1))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, userdata2))
|
||||
.Times(1);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, userdata3))
|
||||
.Times(1);
|
||||
|
||||
testFence.OnCompletion(1u, ToMockFenceOnCompletionCallback, userdata0);
|
||||
testFence.OnCompletion(2u, ToMockFenceOnCompletionCallback, userdata1);
|
||||
testFence.OnCompletion(2u, ToMockFenceOnCompletionCallback, userdata2);
|
||||
testFence.OnCompletion(3u, ToMockFenceOnCompletionCallback, userdata3);
|
||||
}
|
||||
|
||||
// Wait for another fence to be sure all callbacks have cleared
|
||||
queue.Signal(fence, 1);
|
||||
WaitForCompletedValue(fence, 1);
|
||||
}
|
||||
|
||||
DAWN_INSTANTIATE_TEST(FenceTests, D3D12Backend, MetalBackend, OpenGLBackend, VulkanBackend)
|
||||
@@ -117,6 +117,17 @@ static void ToMockBufferMapWriteCallback(dawnBufferMapAsyncStatus status, void*
|
||||
mockBufferMapWriteCallback->Call(status, lastMapWritePointer, userdata);
|
||||
}
|
||||
|
||||
class MockFenceOnCompletionCallback {
|
||||
public:
|
||||
MOCK_METHOD2(Call, void(dawnFenceCompletionStatus status, dawnCallbackUserdata userdata));
|
||||
};
|
||||
|
||||
static std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
|
||||
static void ToMockFenceOnCompletionCallback(dawnFenceCompletionStatus status,
|
||||
dawnCallbackUserdata userdata) {
|
||||
mockFenceOnCompletionCallback->Call(status, userdata);
|
||||
}
|
||||
|
||||
class WireTestsBase : public Test {
|
||||
protected:
|
||||
WireTestsBase(bool ignoreSetCallbackCalls)
|
||||
@@ -128,6 +139,7 @@ class WireTestsBase : public Test {
|
||||
mockBuilderErrorCallback = std::make_unique<MockBuilderErrorCallback>();
|
||||
mockBufferMapReadCallback = std::make_unique<MockBufferMapReadCallback>();
|
||||
mockBufferMapWriteCallback = std::make_unique<MockBufferMapWriteCallback>();
|
||||
mockFenceOnCompletionCallback = std::make_unique<MockFenceOnCompletionCallback>();
|
||||
|
||||
dawnProcTable mockProcs;
|
||||
dawnDevice mockDevice;
|
||||
@@ -162,6 +174,7 @@ class WireTestsBase : public Test {
|
||||
mockBuilderErrorCallback = nullptr;
|
||||
mockBufferMapReadCallback = nullptr;
|
||||
mockBufferMapWriteCallback = nullptr;
|
||||
mockFenceOnCompletionCallback = nullptr;
|
||||
}
|
||||
|
||||
void FlushClient() {
|
||||
@@ -791,7 +804,7 @@ class WireBufferMappingTests : public WireTestsBase {
|
||||
TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
|
||||
dawnCallbackUserdata userdata = 8653;
|
||||
dawnBufferMapReadAsync(buffer, 40, sizeof(uint32_t), ToMockBufferMapReadCallback, userdata);
|
||||
|
||||
|
||||
uint32_t bufferContent = 31337;
|
||||
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, 40, sizeof(uint32_t), _, _))
|
||||
.WillOnce(InvokeWithoutArgs([&]() {
|
||||
@@ -816,7 +829,7 @@ TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
|
||||
TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) {
|
||||
dawnCallbackUserdata userdata = 8654;
|
||||
dawnBufferMapReadAsync(buffer, 40, sizeof(uint32_t), ToMockBufferMapReadCallback, userdata);
|
||||
|
||||
|
||||
EXPECT_CALL(api, OnBufferMapReadAsyncCallback(apiBuffer, 40, sizeof(uint32_t), _, _))
|
||||
.WillOnce(InvokeWithoutArgs([&]() {
|
||||
api.CallMapReadCallback(apiBuffer, DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr);
|
||||
@@ -1163,3 +1176,211 @@ TEST_F(WireBufferMappingTests, DestroyInsideMapWriteCallback) {
|
||||
|
||||
FlushClient();
|
||||
}
|
||||
|
||||
class WireFenceTests : public WireTestsBase {
|
||||
public:
|
||||
WireFenceTests() : WireTestsBase(true) {
|
||||
}
|
||||
|
||||
void SetUp() override {
|
||||
WireTestsBase::SetUp();
|
||||
|
||||
{
|
||||
dawnFenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
descriptor.nextInChain = nullptr;
|
||||
|
||||
apiFence = api.GetNewFence();
|
||||
fence = dawnDeviceCreateFence(device, &descriptor);
|
||||
|
||||
EXPECT_CALL(api, DeviceCreateFence(apiDevice, _)).WillOnce(Return(apiFence));
|
||||
FlushClient();
|
||||
}
|
||||
{
|
||||
queue = dawnDeviceCreateQueue(device);
|
||||
apiQueue = api.GetNewQueue();
|
||||
EXPECT_CALL(api, DeviceCreateQueue(apiDevice)).WillOnce(Return(apiQueue));
|
||||
FlushClient();
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
void DoQueueSignal(uint64_t signalValue) {
|
||||
dawnQueueSignal(queue, fence, signalValue);
|
||||
EXPECT_CALL(api, QueueSignal(apiQueue, apiFence, signalValue)).Times(1);
|
||||
|
||||
// This callback is generated to update the completedValue of the fence
|
||||
// on the client
|
||||
EXPECT_CALL(api, OnFenceOnCompletionCallback(apiFence, signalValue, _, _))
|
||||
.WillOnce(InvokeWithoutArgs([&]() {
|
||||
api.CallFenceOnCompletionCallback(apiFence, DAWN_FENCE_COMPLETION_STATUS_SUCCESS);
|
||||
}));
|
||||
}
|
||||
|
||||
// A successfully created fence
|
||||
dawnFence fence;
|
||||
dawnFence apiFence;
|
||||
|
||||
dawnQueue queue;
|
||||
dawnQueue apiQueue;
|
||||
};
|
||||
|
||||
// Check that signaling a fence succeeds
|
||||
TEST_F(WireFenceTests, QueueSignalSuccess) {
|
||||
DoQueueSignal(2u);
|
||||
DoQueueSignal(3u);
|
||||
FlushClient();
|
||||
FlushServer();
|
||||
}
|
||||
|
||||
// Without any flushes, it is valid to signal a value greater than the current
|
||||
// signaled value
|
||||
TEST_F(WireFenceTests, QueueSignalSynchronousValidationSuccess) {
|
||||
dawnCallbackUserdata userdata = 9157;
|
||||
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata);
|
||||
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(0);
|
||||
|
||||
dawnQueueSignal(queue, fence, 2u);
|
||||
dawnQueueSignal(queue, fence, 4u);
|
||||
dawnQueueSignal(queue, fence, 5u);
|
||||
}
|
||||
|
||||
// Without any flushes, errors should be generated when signaling a value less
|
||||
// than or equal to the current signaled value
|
||||
TEST_F(WireFenceTests, QueueSignalSynchronousValidationError) {
|
||||
dawnCallbackUserdata userdata = 3157;
|
||||
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata);
|
||||
|
||||
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(1);
|
||||
dawnQueueSignal(queue, fence, 0u); // Error
|
||||
EXPECT_TRUE(Mock::VerifyAndClear(mockDeviceErrorCallback.get()));
|
||||
|
||||
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(1);
|
||||
dawnQueueSignal(queue, fence, 1u); // Error
|
||||
EXPECT_TRUE(Mock::VerifyAndClear(mockDeviceErrorCallback.get()));
|
||||
|
||||
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(0);
|
||||
dawnQueueSignal(queue, fence, 4u); // Success
|
||||
EXPECT_TRUE(Mock::VerifyAndClear(mockDeviceErrorCallback.get()));
|
||||
|
||||
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata)).Times(1);
|
||||
dawnQueueSignal(queue, fence, 3u); // Error
|
||||
EXPECT_TRUE(Mock::VerifyAndClear(mockDeviceErrorCallback.get()));
|
||||
}
|
||||
|
||||
// Check that callbacks are immediately called if the fence is already finished
|
||||
TEST_F(WireFenceTests, OnCompletionImmediate) {
|
||||
// Can call on value < (initial) signaled value happens immediately
|
||||
{
|
||||
dawnCallbackUserdata userdata = 9847;
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata))
|
||||
.Times(1);
|
||||
dawnFenceOnCompletion(fence, 0, ToMockFenceOnCompletionCallback, userdata);
|
||||
}
|
||||
|
||||
// Can call on value == (initial) signaled value happens immediately
|
||||
{
|
||||
dawnCallbackUserdata userdata = 4347;
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata))
|
||||
.Times(1);
|
||||
dawnFenceOnCompletion(fence, 1, ToMockFenceOnCompletionCallback, userdata);
|
||||
}
|
||||
}
|
||||
|
||||
// Check that all passed client completion callbacks are called
|
||||
TEST_F(WireFenceTests, OnCompletionMultiple) {
|
||||
DoQueueSignal(3u);
|
||||
DoQueueSignal(6u);
|
||||
|
||||
dawnCallbackUserdata userdata0 = 2134;
|
||||
dawnCallbackUserdata userdata1 = 7134;
|
||||
dawnCallbackUserdata userdata2 = 3144;
|
||||
dawnCallbackUserdata userdata3 = 1130;
|
||||
|
||||
// Add callbacks in a non-monotonic order. They should still be called
|
||||
// in order of increasing fence value.
|
||||
// Add multiple callbacks for the same value.
|
||||
dawnFenceOnCompletion(fence, 6, ToMockFenceOnCompletionCallback, userdata0);
|
||||
dawnFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, userdata1);
|
||||
dawnFenceOnCompletion(fence, 3, ToMockFenceOnCompletionCallback, userdata2);
|
||||
dawnFenceOnCompletion(fence, 2, ToMockFenceOnCompletionCallback, userdata3);
|
||||
|
||||
Sequence s1, s2;
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata1))
|
||||
.Times(1)
|
||||
.InSequence(s1);
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata3))
|
||||
.Times(1)
|
||||
.InSequence(s2);
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata2))
|
||||
.Times(1)
|
||||
.InSequence(s1, s2);
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata0))
|
||||
.Times(1)
|
||||
.InSequence(s1, s2);
|
||||
|
||||
FlushClient();
|
||||
FlushServer();
|
||||
}
|
||||
|
||||
// Without any flushes, it is valid to wait on a value less than or equal to
|
||||
// the last signaled value
|
||||
TEST_F(WireFenceTests, OnCompletionSynchronousValidationSuccess) {
|
||||
dawnQueueSignal(queue, fence, 4u);
|
||||
dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, 0);
|
||||
dawnFenceOnCompletion(fence, 3u, ToMockFenceOnCompletionCallback, 0);
|
||||
dawnFenceOnCompletion(fence, 4u, ToMockFenceOnCompletionCallback, 0);
|
||||
}
|
||||
|
||||
// Without any flushes, errors should be generated when waiting on a value greater
|
||||
// than the last signaled value
|
||||
TEST_F(WireFenceTests, OnCompletionSynchronousValidationError) {
|
||||
dawnCallbackUserdata userdata1 = 3817;
|
||||
dawnCallbackUserdata userdata2 = 3857;
|
||||
dawnDeviceSetErrorCallback(device, ToMockDeviceErrorCallback, userdata2);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_ERROR, userdata1))
|
||||
.Times(1);
|
||||
EXPECT_CALL(*mockDeviceErrorCallback, Call(_, userdata2)).Times(1);
|
||||
|
||||
dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, userdata1);
|
||||
}
|
||||
|
||||
// Check that the fence completed value is initialized
|
||||
TEST_F(WireFenceTests, GetCompletedValueInitialization) {
|
||||
EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u);
|
||||
}
|
||||
|
||||
// Check that the fence completed value updates after signaling the fence
|
||||
TEST_F(WireFenceTests, GetCompletedValueUpdate) {
|
||||
DoQueueSignal(3u);
|
||||
FlushClient();
|
||||
FlushServer();
|
||||
|
||||
EXPECT_EQ(dawnFenceGetCompletedValue(fence), 3u);
|
||||
}
|
||||
|
||||
// Check that the fence completed value does not update without a flush
|
||||
TEST_F(WireFenceTests, GetCompletedValueNoUpdate) {
|
||||
dawnQueueSignal(queue, fence, 3u);
|
||||
EXPECT_EQ(dawnFenceGetCompletedValue(fence), 1u);
|
||||
}
|
||||
|
||||
// Check that the callback is called with UNKNOWN when the fence is destroyed
|
||||
// before the completed value is updated
|
||||
TEST_F(WireFenceTests, DestroyBeforeOnCompletionEnd) {
|
||||
dawnCallbackUserdata userdata = 8616;
|
||||
dawnQueueSignal(queue, fence, 3u);
|
||||
dawnFenceOnCompletion(fence, 2u, ToMockFenceOnCompletionCallback, userdata);
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback,
|
||||
Call(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, userdata))
|
||||
.Times(1);
|
||||
|
||||
dawnFenceRelease(fence);
|
||||
}
|
||||
|
||||
185
src/tests/unittests/validation/FenceValidationTests.cpp
Normal file
185
src/tests/unittests/validation/FenceValidationTests.cpp
Normal file
@@ -0,0 +1,185 @@
|
||||
// Copyright 2018 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 "tests/unittests/validation/ValidationTest.h"
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
|
||||
using namespace testing;
|
||||
|
||||
class MockFenceOnCompletionCallback {
|
||||
public:
|
||||
MOCK_METHOD2(Call, void(dawnFenceCompletionStatus status, dawnCallbackUserdata userdata));
|
||||
};
|
||||
|
||||
struct FenceOnCompletionExpectation {
|
||||
dawn::Fence fence;
|
||||
uint64_t value;
|
||||
dawnFenceCompletionStatus status;
|
||||
};
|
||||
|
||||
static std::unique_ptr<MockFenceOnCompletionCallback> mockFenceOnCompletionCallback;
|
||||
static void ToMockFenceOnCompletionCallback(dawnFenceCompletionStatus status,
|
||||
dawnCallbackUserdata userdata) {
|
||||
mockFenceOnCompletionCallback->Call(status, userdata);
|
||||
}
|
||||
|
||||
class FenceValidationTest : public ValidationTest {
|
||||
protected:
|
||||
void TestOnCompletion(dawn::Fence fence, uint64_t value, dawnFenceCompletionStatus status) {
|
||||
FenceOnCompletionExpectation* expectation = new FenceOnCompletionExpectation;
|
||||
expectation->fence = fence;
|
||||
expectation->value = value;
|
||||
expectation->status = status;
|
||||
dawnCallbackUserdata userdata =
|
||||
static_cast<dawnCallbackUserdata>(reinterpret_cast<uintptr_t>(expectation));
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(status, userdata)).Times(1);
|
||||
fence.OnCompletion(value, ToMockFenceOnCompletionCallback, userdata);
|
||||
}
|
||||
|
||||
void Flush() {
|
||||
device.Tick();
|
||||
}
|
||||
|
||||
dawn::Queue queue;
|
||||
|
||||
private:
|
||||
void SetUp() override {
|
||||
ValidationTest::SetUp();
|
||||
|
||||
mockFenceOnCompletionCallback = std::make_unique<MockFenceOnCompletionCallback>();
|
||||
queue = device.CreateQueue();
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
// Delete mocks so that expectations are checked
|
||||
mockFenceOnCompletionCallback = nullptr;
|
||||
|
||||
ValidationTest::TearDown();
|
||||
}
|
||||
};
|
||||
|
||||
// Test cases where creation should succeed
|
||||
TEST_F(FenceValidationTest, CreationSuccess) {
|
||||
// Success
|
||||
{
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 0;
|
||||
device.CreateFence(&descriptor);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(FenceValidationTest, GetCompletedValue) {
|
||||
// Starts at initial value
|
||||
{
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
EXPECT_EQ(fence.GetCompletedValue(), 1u);
|
||||
}
|
||||
}
|
||||
|
||||
// Test that OnCompletion handlers are called immediately for
|
||||
// already completed fence values
|
||||
TEST_F(FenceValidationTest, OnCompletionImmediate) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, 0))
|
||||
.Times(1);
|
||||
fence.OnCompletion(0u, ToMockFenceOnCompletionCallback, 0);
|
||||
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, 1))
|
||||
.Times(1);
|
||||
fence.OnCompletion(1u, ToMockFenceOnCompletionCallback, 1);
|
||||
}
|
||||
|
||||
// Test setting OnCompletion handlers for values > signaled value
|
||||
TEST_F(FenceValidationTest, OnCompletionLargerThanSignaled) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
// Cannot signal for values > signaled value
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_ERROR, 0))
|
||||
.Times(1);
|
||||
ASSERT_DEVICE_ERROR(fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, 0));
|
||||
|
||||
// Can set handler after signaling
|
||||
queue.Signal(fence, 2);
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, 0))
|
||||
.Times(1);
|
||||
fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, 0);
|
||||
|
||||
Flush();
|
||||
}
|
||||
|
||||
TEST_F(FenceValidationTest, GetCompletedValueInsideCallback) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
queue.Signal(fence, 3);
|
||||
fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, 0);
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, 0))
|
||||
.WillOnce(Invoke([&](dawnFenceCompletionStatus status, dawnCallbackUserdata userdata) {
|
||||
EXPECT_EQ(fence.GetCompletedValue(), 3u);
|
||||
}));
|
||||
|
||||
Flush();
|
||||
}
|
||||
|
||||
TEST_F(FenceValidationTest, GetCompletedValueAfterCallback) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
queue.Signal(fence, 2);
|
||||
fence.OnCompletion(2u, ToMockFenceOnCompletionCallback, 0);
|
||||
EXPECT_CALL(*mockFenceOnCompletionCallback, Call(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, 0))
|
||||
.Times(1);
|
||||
|
||||
Flush();
|
||||
EXPECT_EQ(fence.GetCompletedValue(), 2u);
|
||||
}
|
||||
|
||||
TEST_F(FenceValidationTest, SignalError) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
// value < fence signaled value
|
||||
ASSERT_DEVICE_ERROR(queue.Signal(fence, 0));
|
||||
|
||||
// value == fence signaled value
|
||||
ASSERT_DEVICE_ERROR(queue.Signal(fence, 1));
|
||||
}
|
||||
|
||||
TEST_F(FenceValidationTest, SignalSuccess) {
|
||||
dawn::FenceDescriptor descriptor;
|
||||
descriptor.initialValue = 1;
|
||||
dawn::Fence fence = device.CreateFence(&descriptor);
|
||||
|
||||
// Success
|
||||
queue.Signal(fence, 2);
|
||||
Flush();
|
||||
EXPECT_EQ(fence.GetCompletedValue(), 2u);
|
||||
|
||||
// Success increasing fence value by more than 1
|
||||
queue.Signal(fence, 6);
|
||||
Flush();
|
||||
EXPECT_EQ(fence.GetCompletedValue(), 6u);
|
||||
}
|
||||
Reference in New Issue
Block a user