encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-14 23:56:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove Fences

Browse Source 
Fences are no longer part of the WebGPU spec, and have been removed from
Blink.

Bug: dawn:22
Change-Id: I240c4c4107acfaf9facec88a43a38b5ff327c7a6
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/50702
Commit-Queue: Brandon Jones <bajones@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Brandon Jones
2021-05-21 00:01:08 +00:00
committed by Dawn LUCI CQ
parent 36cb5a86de
commit a548578f67
28 changed files with 16 additions and 1707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/dawn_wire/BUILD.gn
View File

@@ -80,8 +80,6 @@ dawn_component("dawn_wire") {
"client/ClientInlineMemoryTransferService.cpp",
"client/Device.cpp",
"client/Device.h",
"client/Fence.cpp",
"client/Fence.h",
"client/ObjectAllocator.h",
"client/Queue.cpp",
"client/Queue.h",
@@ -92,7 +90,6 @@ dawn_component("dawn_wire") {
"server/Server.h",
"server/ServerBuffer.cpp",
"server/ServerDevice.cpp",
"server/ServerFence.cpp",
"server/ServerInlineMemoryTransferService.cpp",
"server/ServerQueue.cpp",
"server/ServerShaderModule.cpp",

3
src/dawn_wire/CMakeLists.txt
View File

@@ -52,8 +52,6 @@ target_sources(dawn_wire PRIVATE
"client/ClientInlineMemoryTransferService.cpp"
"client/Device.cpp"
"client/Device.h"
"client/Fence.cpp"
"client/Fence.h"
"client/ObjectAllocator.h"
"client/Queue.cpp"
"client/Queue.h"
@@ -64,7 +62,6 @@ target_sources(dawn_wire PRIVATE
"server/Server.h"
"server/ServerBuffer.cpp"
"server/ServerDevice.cpp"
"server/ServerFence.cpp"
"server/ServerInlineMemoryTransferService.cpp"
"server/ServerQueue.cpp"
"server/ServerShaderModule.cpp"

1
src/dawn_wire/client/ApiObjects.h
View File

@@ -19,7 +19,6 @@
#include "dawn_wire/client/Buffer.h"
#include "dawn_wire/client/Device.h"
#include "dawn_wire/client/Fence.h"
#include "dawn_wire/client/Queue.h"
#include "dawn_wire/client/ShaderModule.h"

20
src/dawn_wire/client/ClientDoers.cpp
View File

@@ -70,26 +70,6 @@ namespace dawn_wire { namespace client {
readInitialDataInfo);
}
bool Client::DoFenceUpdateCompletedValue(Fence* fence, uint64_t value) {
// The fence might have been deleted or recreated so this isn't an error.
if (fence == nullptr) {
return true;
}
fence->OnUpdateCompletedValueCallback(value);
return true;
}
bool Client::DoFenceOnCompletionCallback(Fence* fence,
uint64_t requestSerial,
WGPUFenceCompletionStatus status) {
// The fence might have been deleted or recreated so this isn't an error.
if (fence == nullptr) {
return true;
}
return fence->OnCompletionCallback(requestSerial, status);
}
bool Client::DoQueueWorkDoneCallback(Queue* queue,
uint64_t requestSerial,
WGPUQueueWorkDoneStatus status) {

89
src/dawn_wire/client/Fence.cpp
View File

@@ -1,89 +0,0 @@
// Copyright 2019 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_wire/client/Fence.h"
#include "dawn_wire/client/Client.h"
namespace dawn_wire { namespace client {
Fence::~Fence() {
// Callbacks need to be fired in all cases, as they can handle freeing resources
// so we call them with "Unknown" status.
for (auto& it : mOnCompletionRequests) {
if (it.second.callback) {
it.second.callback(WGPUFenceCompletionStatus_Unknown, it.second.userdata);
}
}
mOnCompletionRequests.clear();
}
void Fence::CancelCallbacksForDisconnect() {
for (auto& it : mOnCompletionRequests) {
if (it.second.callback) {
it.second.callback(WGPUFenceCompletionStatus_DeviceLost, it.second.userdata);
}
}
mOnCompletionRequests.clear();
}
void Fence::Initialize(const WGPUFenceDescriptor* descriptor) {
mCompletedValue = descriptor != nullptr ? descriptor->initialValue : 0u;
}
void Fence::OnCompletion(uint64_t value,
WGPUFenceOnCompletionCallback callback,
void* userdata) {
if (client->IsDisconnected()) {
callback(WGPUFenceCompletionStatus_DeviceLost, userdata);
return;
}
uint32_t serial = mOnCompletionRequestSerial++;
ASSERT(mOnCompletionRequests.find(serial) == mOnCompletionRequests.end());
FenceOnCompletionCmd cmd;
cmd.fenceId = this->id;
cmd.value = value;
cmd.requestSerial = serial;
mOnCompletionRequests[serial] = {callback, userdata};
client->SerializeCommand(cmd);
}
void Fence::OnUpdateCompletedValueCallback(uint64_t value) {
mCompletedValue = value;
}
bool Fence::OnCompletionCallback(uint64_t requestSerial, WGPUFenceCompletionStatus status) {
auto requestIt = mOnCompletionRequests.find(requestSerial);
if (requestIt == mOnCompletionRequests.end()) {
return false;
}
// Remove the request data so that the callback cannot be called again.
// ex.) inside the callback: if the fence is deleted, all callbacks reject.
OnCompletionData request = std::move(requestIt->second);
mOnCompletionRequests.erase(requestIt);
request.callback(status, request.userdata);
return true;
}
uint64_t Fence::GetCompletedValue() const {
return mCompletedValue;
}
}} // namespace dawn_wire::client

53
src/dawn_wire/client/Fence.h
View File

@@ -1,53 +0,0 @@
// Copyright 2019 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.
#ifndef DAWNWIRE_CLIENT_FENCE_H_
#define DAWNWIRE_CLIENT_FENCE_H_
#include <dawn/webgpu.h>
#include "common/SerialMap.h"
#include "dawn_wire/client/ObjectBase.h"
namespace dawn_wire { namespace client {
class Queue;
class Fence final : public ObjectBase {
public:
using ObjectBase::ObjectBase;
~Fence();
void Initialize(const WGPUFenceDescriptor* descriptor);
void CheckPassedFences();
void OnCompletion(uint64_t value, WGPUFenceOnCompletionCallback callback, void* userdata);
void OnUpdateCompletedValueCallback(uint64_t value);
bool OnCompletionCallback(uint64_t requestSerial, WGPUFenceCompletionStatus status);
uint64_t GetCompletedValue() const;
private:
void CancelCallbacksForDisconnect() override;
struct OnCompletionData {
WGPUFenceOnCompletionCallback callback = nullptr;
void* userdata = nullptr;
};
uint64_t mCompletedValue = 0;
uint64_t mOnCompletionRequestSerial = 0;
std::map<uint64_t, OnCompletionData> mOnCompletionRequests;
};
}} // namespace dawn_wire::client
#endif // DAWNWIRE_CLIENT_FENCE_H_

14
src/dawn_wire/client/Queue.cpp
View File

@@ -60,20 +60,6 @@ namespace dawn_wire { namespace client {
client->SerializeCommand(cmd);
}
WGPUFence Queue::CreateFence(WGPUFenceDescriptor const* descriptor) {
auto* allocation = client->FenceAllocator().New(client);
QueueCreateFenceCmd cmd;
cmd.self = ToAPI(this);
cmd.result = ObjectHandle{allocation->object->id, allocation->generation};
cmd.descriptor = descriptor;
client->SerializeCommand(cmd);
Fence* fence = allocation->object.get();
fence->Initialize(descriptor);
return ToAPI(fence);
}
void Queue::WriteBuffer(WGPUBuffer cBuffer,
uint64_t bufferOffset,
const void* data,

1
src/dawn_wire/client/Queue.h
View File

@@ -35,7 +35,6 @@ namespace dawn_wire { namespace client {
void OnSubmittedWorkDone(uint64_t signalValue,
WGPUQueueWorkDoneCallback callback,
void* userdata);
WGPUFence CreateFence(const WGPUFenceDescriptor* descriptor);
void WriteBuffer(WGPUBuffer cBuffer, uint64_t bufferOffset, const void* data, size_t size);
void WriteTexture(const WGPUImageCopyTexture* destination,
const void* data,

18
src/dawn_wire/server/Server.h
View File

@@ -127,20 +127,6 @@ namespace dawn_wire { namespace server {
uint64_t requestSerial;
};
struct FenceCompletionUserdata : CallbackUserdata {
using CallbackUserdata::CallbackUserdata;
ObjectHandle fence;
uint64_t value;
};
struct FenceOnCompletionUserdata : CallbackUserdata {
using CallbackUserdata::CallbackUserdata;
ObjectHandle fence;
uint64_t requestSerial;
};
struct ShaderModuleGetCompilationInfoUserdata : CallbackUserdata {
using CallbackUserdata::CallbackUserdata;
@@ -218,10 +204,6 @@ namespace dawn_wire { namespace server {
const char* message,
ErrorScopeUserdata* userdata);
void OnBufferMapAsyncCallback(WGPUBufferMapAsyncStatus status, MapUserdata* userdata);
void OnFenceCompletedValueUpdated(WGPUFenceCompletionStatus status,
FenceCompletionUserdata* userdata);
void OnFenceOnCompletion(WGPUFenceCompletionStatus status,
FenceOnCompletionUserdata* userdata);
void OnQueueWorkDone(WGPUQueueWorkDoneStatus status, QueueWorkDoneUserdata* userdata);
void OnCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
WGPUComputePipeline pipeline,

67
src/dawn_wire/server/ServerFence.cpp
View File

@@ -1,67 +0,0 @@
// Copyright 2019 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_wire/server/Server.h"
#include <memory>
namespace dawn_wire { namespace server {
void Server::OnFenceCompletedValueUpdated(WGPUFenceCompletionStatus status,
FenceCompletionUserdata* data) {
if (status != WGPUFenceCompletionStatus_Success) {
return;
}
ReturnFenceUpdateCompletedValueCmd cmd;
cmd.fence = data->fence;
cmd.value = data->value;
SerializeCommand(cmd);
}
bool Server::DoFenceOnCompletion(ObjectId fenceId, uint64_t value, uint64_t requestSerial) {
// The null object isn't valid as `self`
if (fenceId == 0) {
return false;
}
auto* fence = FenceObjects().Get(fenceId);
if (fence == nullptr) {
return false;
}
auto userdata = MakeUserdata<FenceOnCompletionUserdata>();
userdata->fence = ObjectHandle{fenceId, fence->generation};
userdata->requestSerial = requestSerial;
mProcs.fenceOnCompletion(
fence->handle, value,
ForwardToServer<decltype(
&Server::OnFenceOnCompletion)>::Func<&Server::OnFenceOnCompletion>(),
userdata.release());
return true;
}
void Server::OnFenceOnCompletion(WGPUFenceCompletionStatus status,
FenceOnCompletionUserdata* data) {
ReturnFenceOnCompletionCallbackCmd cmd;
cmd.fence = data->fence;
cmd.requestSerial = data->requestSerial;
cmd.status = status;
SerializeCommand(cmd);
}
}} // namespace dawn_wire::server

23
src/dawn_wire/server/ServerQueue.cpp
View File

@@ -17,29 +17,6 @@
namespace dawn_wire { namespace server {
bool Server::DoQueueSignal(WGPUQueue cSelf, WGPUFence cFence, uint64_t signalValue) {
if (cFence == nullptr) {
return false;
}
mProcs.queueSignal(cSelf, cFence, signalValue);
ObjectId fenceId = FenceObjectIdTable().Get(cFence);
ASSERT(fenceId != 0);
auto* fence = FenceObjects().Get(fenceId);
ASSERT(fence != nullptr);
auto userdata = MakeUserdata<FenceCompletionUserdata>();
userdata->fence = ObjectHandle{fenceId, fence->generation};
userdata->value = signalValue;
mProcs.fenceOnCompletion(
cFence, signalValue,
ForwardToServer<decltype(&Server::OnFenceCompletedValueUpdated)>::Func<
&Server::OnFenceCompletedValueUpdated>(),
userdata.release());
return true;
}
void Server::OnQueueWorkDone(WGPUQueueWorkDoneStatus status, QueueWorkDoneUserdata* data) {
ReturnQueueWorkDoneCallbackCmd cmd;
cmd.queue = data->queue;