encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-15 08:06:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename CreateReady*Pipeline to Create*PipelineAsync

Browse Source 
This follows the name change in the upstream WebGPU specification.

Bug: dawn:529
Change-Id: I6d940dcc89f6b75136c642b578cb01bb8e40d681
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/41720
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Auto-Submit: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Corentin Wallez
2021-02-22 18:27:36 +00:00
committed by Commit Bot service account
parent 1258e245a9
commit 2d3c2e3553
20 changed files with 483 additions and 483 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -93,26 +93,26 @@ namespace dawn_wire { namespace client {
return true;
}
bool Client::DoDeviceCreateReadyComputePipelineCallback(Device* device,
bool Client::DoDeviceCreateComputePipelineAsyncCallback(Device* device,
uint64_t requestSerial,
WGPUCreateReadyPipelineStatus status,
WGPUCreatePipelineAsyncStatus status,
const char* message) {
// The device might have been deleted or recreated so this isn't an error.
if (device == nullptr) {
return true;
}
return device->OnCreateReadyComputePipelineCallback(requestSerial, status, message);
return device->OnCreateComputePipelineAsyncCallback(requestSerial, status, message);
}
bool Client::DoDeviceCreateReadyRenderPipelineCallback(Device* device,
bool Client::DoDeviceCreateRenderPipelineAsyncCallback(Device* device,
uint64_t requestSerial,
WGPUCreateReadyPipelineStatus status,
WGPUCreatePipelineAsyncStatus status,
const char* message) {
// The device might have been deleted or recreated so this isn't an error.
if (device == nullptr) {
return true;
}
return device->OnCreateReadyRenderPipelineCallback(requestSerial, status, message);
return device->OnCreateRenderPipelineAsyncCallback(requestSerial, status, message);
}
}} // namespace dawn_wire::client

106
src/dawn_wire/client/Device.cpp
View File

@@ -55,16 +55,16 @@ namespace dawn_wire { namespace client {
it.second.userdata);
}
auto createReadyPipelineRequests = std::move(mCreateReadyPipelineRequests);
for (const auto& it : createReadyPipelineRequests) {
if (it.second.createReadyComputePipelineCallback != nullptr) {
it.second.createReadyComputePipelineCallback(
WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr,
auto createPipelineAsyncRequests = std::move(mCreatePipelineAsyncRequests);
for (const auto& it : createPipelineAsyncRequests) {
if (it.second.createComputePipelineAsyncCallback != nullptr) {
it.second.createComputePipelineAsyncCallback(
WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr,
"Device destroyed before callback", it.second.userdata);
} else {
ASSERT(it.second.createReadyRenderPipelineCallback != nullptr);
it.second.createReadyRenderPipelineCallback(
WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr,
ASSERT(it.second.createRenderPipelineAsyncCallback != nullptr);
it.second.createRenderPipelineAsyncCallback(
WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr,
"Device destroyed before callback", it.second.userdata);
}
}
@@ -84,20 +84,20 @@ namespace dawn_wire { namespace client {
}
void Device::CancelCallbacksForDisconnect() {
for (auto& it : mCreateReadyPipelineRequests) {
ASSERT((it.second.createReadyComputePipelineCallback != nullptr) ^
(it.second.createReadyRenderPipelineCallback != nullptr));
if (it.second.createReadyRenderPipelineCallback) {
it.second.createReadyRenderPipelineCallback(
WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, "Device lost",
for (auto& it : mCreatePipelineAsyncRequests) {
ASSERT((it.second.createComputePipelineAsyncCallback != nullptr) ^
(it.second.createRenderPipelineAsyncCallback != nullptr));
if (it.second.createRenderPipelineAsyncCallback) {
it.second.createRenderPipelineAsyncCallback(
WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "Device lost",
it.second.userdata);
} else {
it.second.createReadyComputePipelineCallback(
WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, "Device lost",
it.second.createComputePipelineAsyncCallback(
WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "Device lost",
it.second.userdata);
}
}
mCreateReadyPipelineRequests.clear();
mCreatePipelineAsyncRequests.clear();
for (auto& it : mErrorScopes) {
it.second.callback(WGPUErrorType_DeviceLost, "Device lost", it.second.userdata);
@@ -221,113 +221,113 @@ namespace dawn_wire { namespace client {
return GetQueue();
}
void Device::CreateReadyComputePipeline(WGPUComputePipelineDescriptor const* descriptor,
WGPUCreateReadyComputePipelineCallback callback,
void Device::CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor,
WGPUCreateComputePipelineAsyncCallback callback,
void* userdata) {
if (client->IsDisconnected()) {
return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr,
return callback(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr,
"GPU device disconnected", userdata);
}
DeviceCreateReadyComputePipelineCmd cmd;
DeviceCreateComputePipelineAsyncCmd cmd;
cmd.deviceId = this->id;
cmd.descriptor = descriptor;
uint64_t serial = mCreateReadyPipelineRequestSerial++;
ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end());
uint64_t serial = mCreatePipelineAsyncRequestSerial++;
ASSERT(mCreatePipelineAsyncRequests.find(serial) == mCreatePipelineAsyncRequests.end());
cmd.requestSerial = serial;
auto* allocation = client->ComputePipelineAllocator().New(client);
CreateReadyPipelineRequest request = {};
request.createReadyComputePipelineCallback = callback;
CreatePipelineAsyncRequest request = {};
request.createComputePipelineAsyncCallback = callback;
request.userdata = userdata;
request.pipelineObjectID = allocation->object->id;
cmd.pipelineObjectHandle = ObjectHandle{allocation->object->id, allocation->generation};
client->SerializeCommand(cmd);
mCreateReadyPipelineRequests[serial] = std::move(request);
mCreatePipelineAsyncRequests[serial] = std::move(request);
}
bool Device::OnCreateReadyComputePipelineCallback(uint64_t requestSerial,
WGPUCreateReadyPipelineStatus status,
bool Device::OnCreateComputePipelineAsyncCallback(uint64_t requestSerial,
WGPUCreatePipelineAsyncStatus status,
const char* message) {
const auto& requestIt = mCreateReadyPipelineRequests.find(requestSerial);
if (requestIt == mCreateReadyPipelineRequests.end()) {
const auto& requestIt = mCreatePipelineAsyncRequests.find(requestSerial);
if (requestIt == mCreatePipelineAsyncRequests.end()) {
return false;
}
CreateReadyPipelineRequest request = std::move(requestIt->second);
mCreateReadyPipelineRequests.erase(requestIt);
CreatePipelineAsyncRequest request = std::move(requestIt->second);
mCreatePipelineAsyncRequests.erase(requestIt);
auto pipelineAllocation =
client->ComputePipelineAllocator().GetObject(request.pipelineObjectID);
// If the return status is a failure we should give a null pipeline to the callback and
// free the allocation both on the client side and the server side.
if (status != WGPUCreateReadyPipelineStatus_Success) {
if (status != WGPUCreatePipelineAsyncStatus_Success) {
client->ComputePipelineAllocator().Free(pipelineAllocation);
request.createReadyComputePipelineCallback(status, nullptr, message, request.userdata);
request.createComputePipelineAsyncCallback(status, nullptr, message, request.userdata);
return true;
}
WGPUComputePipeline pipeline = reinterpret_cast<WGPUComputePipeline>(pipelineAllocation);
request.createReadyComputePipelineCallback(status, pipeline, message, request.userdata);
request.createComputePipelineAsyncCallback(status, pipeline, message, request.userdata);
return true;
}
void Device::CreateReadyRenderPipeline(WGPURenderPipelineDescriptor const* descriptor,
WGPUCreateReadyRenderPipelineCallback callback,
void Device::CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor,
WGPUCreateRenderPipelineAsyncCallback callback,
void* userdata) {
if (client->IsDisconnected()) {
return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr,
return callback(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr,
"GPU device disconnected", userdata);
}
DeviceCreateReadyRenderPipelineCmd cmd;
DeviceCreateRenderPipelineAsyncCmd cmd;
cmd.deviceId = this->id;
cmd.descriptor = descriptor;
uint64_t serial = mCreateReadyPipelineRequestSerial++;
ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end());
uint64_t serial = mCreatePipelineAsyncRequestSerial++;
ASSERT(mCreatePipelineAsyncRequests.find(serial) == mCreatePipelineAsyncRequests.end());
cmd.requestSerial = serial;
auto* allocation = client->RenderPipelineAllocator().New(client);
CreateReadyPipelineRequest request = {};
request.createReadyRenderPipelineCallback = callback;
CreatePipelineAsyncRequest request = {};
request.createRenderPipelineAsyncCallback = callback;
request.userdata = userdata;
request.pipelineObjectID = allocation->object->id;
cmd.pipelineObjectHandle = ObjectHandle(allocation->object->id, allocation->generation);
client->SerializeCommand(cmd);
mCreateReadyPipelineRequests[serial] = std::move(request);
mCreatePipelineAsyncRequests[serial] = std::move(request);
}
bool Device::OnCreateReadyRenderPipelineCallback(uint64_t requestSerial,
WGPUCreateReadyPipelineStatus status,
bool Device::OnCreateRenderPipelineAsyncCallback(uint64_t requestSerial,
WGPUCreatePipelineAsyncStatus status,
const char* message) {
const auto& requestIt = mCreateReadyPipelineRequests.find(requestSerial);
if (requestIt == mCreateReadyPipelineRequests.end()) {
const auto& requestIt = mCreatePipelineAsyncRequests.find(requestSerial);
if (requestIt == mCreatePipelineAsyncRequests.end()) {
return false;
}
CreateReadyPipelineRequest request = std::move(requestIt->second);
mCreateReadyPipelineRequests.erase(requestIt);
CreatePipelineAsyncRequest request = std::move(requestIt->second);
mCreatePipelineAsyncRequests.erase(requestIt);
auto pipelineAllocation =
client->RenderPipelineAllocator().GetObject(request.pipelineObjectID);
// If the return status is a failure we should give a null pipeline to the callback and
// free the allocation both on the client side and the server side.
if (status != WGPUCreateReadyPipelineStatus_Success) {
if (status != WGPUCreatePipelineAsyncStatus_Success) {
client->RenderPipelineAllocator().Free(pipelineAllocation);
request.createReadyRenderPipelineCallback(status, nullptr, message, request.userdata);
request.createRenderPipelineAsyncCallback(status, nullptr, message, request.userdata);
return true;
}
WGPURenderPipeline pipeline = reinterpret_cast<WGPURenderPipeline>(pipelineAllocation);
request.createReadyRenderPipelineCallback(status, pipeline, message, request.userdata);
request.createRenderPipelineAsyncCallback(status, pipeline, message, request.userdata);
return true;
}

26
src/dawn_wire/client/Device.h
View File

@@ -42,11 +42,11 @@ namespace dawn_wire { namespace client {
bool PopErrorScope(WGPUErrorCallback callback, void* userdata);
WGPUBuffer CreateBuffer(const WGPUBufferDescriptor* descriptor);
WGPUBuffer CreateErrorBuffer();
void CreateReadyComputePipeline(WGPUComputePipelineDescriptor const* descriptor,
WGPUCreateReadyComputePipelineCallback callback,
void CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor,
WGPUCreateComputePipelineAsyncCallback callback,
void* userdata);
void CreateReadyRenderPipeline(WGPURenderPipelineDescriptor const* descriptor,
WGPUCreateReadyRenderPipelineCallback callback,
void CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor,
WGPUCreateRenderPipelineAsyncCallback callback,
void* userdata);
void HandleError(WGPUErrorType errorType, const char* message);
@@ -54,11 +54,11 @@ namespace dawn_wire { namespace client {
bool OnPopErrorScopeCallback(uint64_t requestSerial,
WGPUErrorType type,
const char* message);
bool OnCreateReadyComputePipelineCallback(uint64_t requestSerial,
WGPUCreateReadyPipelineStatus status,
bool OnCreateComputePipelineAsyncCallback(uint64_t requestSerial,
WGPUCreatePipelineAsyncStatus status,
const char* message);
bool OnCreateReadyRenderPipelineCallback(uint64_t requestSerial,
WGPUCreateReadyPipelineStatus status,
bool OnCreateRenderPipelineAsyncCallback(uint64_t requestSerial,
WGPUCreatePipelineAsyncStatus status,
const char* message);
// TODO(dawn:22): Remove once the deprecation period is finished.
@@ -78,14 +78,14 @@ namespace dawn_wire { namespace client {
uint64_t mErrorScopeRequestSerial = 0;
uint64_t mErrorScopeStackSize = 0;
struct CreateReadyPipelineRequest {
WGPUCreateReadyComputePipelineCallback createReadyComputePipelineCallback = nullptr;
WGPUCreateReadyRenderPipelineCallback createReadyRenderPipelineCallback = nullptr;
struct CreatePipelineAsyncRequest {
WGPUCreateComputePipelineAsyncCallback createComputePipelineAsyncCallback = nullptr;
WGPUCreateRenderPipelineAsyncCallback createRenderPipelineAsyncCallback = nullptr;
void* userdata = nullptr;
ObjectId pipelineObjectID;
};
std::map<uint64_t, CreateReadyPipelineRequest> mCreateReadyPipelineRequests;
uint64_t mCreateReadyPipelineRequestSerial = 0;
std::map<uint64_t, CreatePipelineAsyncRequest> mCreatePipelineAsyncRequests;
uint64_t mCreatePipelineAsyncRequestSerial = 0;
WGPUErrorCallback mErrorCallback = nullptr;
WGPUDeviceLostCallback mDeviceLostCallback = nullptr;

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

@@ -141,7 +141,7 @@ namespace dawn_wire { namespace server {
uint64_t requestSerial;
};
struct CreateReadyPipelineUserData : CallbackUserdata {
struct CreatePipelineAsyncUserData : CallbackUserdata {
using CallbackUserdata::CallbackUserdata;
ObjectHandle device;
@@ -202,14 +202,14 @@ namespace dawn_wire { namespace server {
FenceCompletionUserdata* userdata);
void OnFenceOnCompletion(WGPUFenceCompletionStatus status,
FenceOnCompletionUserdata* userdata);
void OnCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status,
void OnCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
WGPUComputePipeline pipeline,
const char* message,
CreateReadyPipelineUserData* userdata);
void OnCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status,
CreatePipelineAsyncUserData* userdata);
void OnCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
WGPURenderPipeline pipeline,
const char* message,
CreateReadyPipelineUserData* userdata);
CreatePipelineAsyncUserData* userdata);
#include "dawn_wire/server/ServerPrototypes_autogen.inc"

44
src/dawn_wire/server/ServerDevice.cpp
View File

@@ -19,10 +19,10 @@ namespace dawn_wire { namespace server {
namespace {
template <ObjectType objectType, typename Pipeline>
void HandleCreateReadyRenderPipelineCallbackResult(KnownObjects<Pipeline>* knownObjects,
WGPUCreateReadyPipelineStatus status,
void HandleCreateRenderPipelineAsyncCallbackResult(KnownObjects<Pipeline>* knownObjects,
WGPUCreatePipelineAsyncStatus status,
Pipeline pipeline,
CreateReadyPipelineUserData* data) {
CreatePipelineAsyncUserData* data) {
// May be null if the device was destroyed. Device destruction destroys child
// objects on the wire.
auto* pipelineObject =
@@ -31,7 +31,7 @@ namespace dawn_wire { namespace server {
// they move from Reserved to Allocated, or if they are destroyed here.
ASSERT(pipelineObject != nullptr);
if (status == WGPUCreateReadyPipelineStatus_Success) {
if (status == WGPUCreatePipelineAsyncStatus_Success) {
// Assign the handle and allocated status if the pipeline is created successfully.
pipelineObject->state = AllocationState::Allocated;
pipelineObject->handle = pipeline;
@@ -101,7 +101,7 @@ namespace dawn_wire { namespace server {
SerializeCommand(cmd);
}
bool Server::DoDeviceCreateReadyComputePipeline(
bool Server::DoDeviceCreateComputePipelineAsync(
ObjectId deviceId,
uint64_t requestSerial,
ObjectHandle pipelineObjectHandle,
@@ -120,27 +120,27 @@ namespace dawn_wire { namespace server {
resultData->generation = pipelineObjectHandle.generation;
resultData->deviceInfo = device->info.get();
auto userdata = MakeUserdata<CreateReadyPipelineUserData>();
auto userdata = MakeUserdata<CreatePipelineAsyncUserData>();
userdata->device = ObjectHandle{deviceId, device->generation};
userdata->requestSerial = requestSerial;
userdata->pipelineObjectID = pipelineObjectHandle.id;
mProcs.deviceCreateReadyComputePipeline(
mProcs.deviceCreateComputePipelineAsync(
device->handle, descriptor,
ForwardToServer<decltype(&Server::OnCreateReadyComputePipelineCallback)>::Func<
&Server::OnCreateReadyComputePipelineCallback>(),
ForwardToServer<decltype(&Server::OnCreateComputePipelineAsyncCallback)>::Func<
&Server::OnCreateComputePipelineAsyncCallback>(),
userdata.release());
return true;
}
void Server::OnCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status,
void Server::OnCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
WGPUComputePipeline pipeline,
const char* message,
CreateReadyPipelineUserData* data) {
HandleCreateReadyRenderPipelineCallbackResult<ObjectType::ComputePipeline>(
CreatePipelineAsyncUserData* data) {
HandleCreateRenderPipelineAsyncCallbackResult<ObjectType::ComputePipeline>(
&ComputePipelineObjects(), status, pipeline, data);
ReturnDeviceCreateReadyComputePipelineCallbackCmd cmd;
ReturnDeviceCreateComputePipelineAsyncCallbackCmd cmd;
cmd.device = data->device;
cmd.status = status;
cmd.requestSerial = data->requestSerial;
@@ -149,7 +149,7 @@ namespace dawn_wire { namespace server {
SerializeCommand(cmd);
}
bool Server::DoDeviceCreateReadyRenderPipeline(ObjectId deviceId,
bool Server::DoDeviceCreateRenderPipelineAsync(ObjectId deviceId,
uint64_t requestSerial,
ObjectHandle pipelineObjectHandle,
const WGPURenderPipelineDescriptor* descriptor) {
@@ -167,27 +167,27 @@ namespace dawn_wire { namespace server {
resultData->generation = pipelineObjectHandle.generation;
resultData->deviceInfo = device->info.get();
auto userdata = MakeUserdata<CreateReadyPipelineUserData>();
auto userdata = MakeUserdata<CreatePipelineAsyncUserData>();
userdata->device = ObjectHandle{deviceId, device->generation};
userdata->requestSerial = requestSerial;
userdata->pipelineObjectID = pipelineObjectHandle.id;
mProcs.deviceCreateReadyRenderPipeline(
mProcs.deviceCreateRenderPipelineAsync(
device->handle, descriptor,
ForwardToServer<decltype(&Server::OnCreateReadyRenderPipelineCallback)>::Func<
&Server::OnCreateReadyRenderPipelineCallback>(),
ForwardToServer<decltype(&Server::OnCreateRenderPipelineAsyncCallback)>::Func<
&Server::OnCreateRenderPipelineAsyncCallback>(),
userdata.release());
return true;
}
void Server::OnCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status,
void Server::OnCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
WGPURenderPipeline pipeline,
const char* message,
CreateReadyPipelineUserData* data) {
HandleCreateReadyRenderPipelineCallbackResult<ObjectType::RenderPipeline>(
CreatePipelineAsyncUserData* data) {
HandleCreateRenderPipelineAsyncCallbackResult<ObjectType::RenderPipeline>(
&RenderPipelineObjects(), status, pipeline, data);
ReturnDeviceCreateReadyRenderPipelineCallbackCmd cmd;
ReturnDeviceCreateRenderPipelineAsyncCallbackCmd cmd;
cmd.device = data->device;
cmd.status = status;
cmd.requestSerial = data->requestSerial;