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

Factor wire client handlers into proper command handlers and doers 

Bug: dawn:88
Change-Id: I3ab28efad7edc7d06f11aa5abae07a1bb3d7e59e
Reviewed-on: https://dawn-review.googlesource.com/c/4003
Commit-Queue: Austin Eng <enga@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Austin Eng 2019-01-30 03:00:17 +00:00 committed by Commit Bot service account
parent cd4fd8e7cd
commit 1139d1c12c
12 changed files with 171 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
BUILD.gn
View File

@ -764,6 +764,7 @@ dawn_generator("libdawn_wire_gen") {
"dawn_wire/client/ApiProcs_autogen.cpp",
"dawn_wire/client/ApiProcs_autogen.h",
"dawn_wire/client/ClientBase_autogen.h",
"dawn_wire/client/ClientDoers_autogen.cpp",
"dawn_wire/client/ClientHandlers_autogen.cpp",
"dawn_wire/client/ClientPrototypes_autogen.inl",
"dawn_wire/server/ServerBase_autogen.h",
@ -794,7 +795,7 @@ dawn_component("libdawn_wire") {
"src/dawn_wire/client/Buffer.h",
"src/dawn_wire/client/Client.cpp",
"src/dawn_wire/client/Client.h",
"src/dawn_wire/client/ClientHandlers.cpp",
"src/dawn_wire/client/ClientDoers.cpp",
"src/dawn_wire/client/Device.cpp",
"src/dawn_wire/client/Device.h",
"src/dawn_wire/client/Fence.cpp",

9
dawn_wire.json
View File

@ -34,14 +34,14 @@
},
"return commands": {
"buffer map read async callback": [
{ "name": "buffer", "type": "ObjectHandle" },
{ "name": "buffer", "type": "ObjectHandle", "handle_type": "buffer" },
{ "name": "request serial", "type": "uint32_t" },
{ "name": "status", "type": "uint32_t" },
{ "name": "data length", "type": "uint32_t" },
{ "name": "data", "type": "uint8_t", "annotation": "const*", "length": "data length" }
],
"buffer map write async callback": [
{ "name": "buffer", "type": "ObjectHandle" },
{ "name": "buffer", "type": "ObjectHandle", "handle_type": "buffer" },
{ "name": "request serial", "type": "uint32_t" },
{ "name": "status", "type": "uint32_t" }
],
@ -49,7 +49,7 @@
{ "name": "message", "type": "char", "annotation": "const*", "length": "strlen" }
],
"fence update completed value": [
{ "name": "fence", "type": "ObjectHandle" },
{ "name": "fence", "type": "ObjectHandle", "handle_type": "fence" },
{ "name": "value", "type": "uint64_t" }
]
},
@ -57,9 +57,10 @@
"client_side_commands": [
"FenceGetCompletedValue"
],
"client_proxied_commands": [
"client_handwritten_commands": [
"BufferUnmap",
"DeviceCreateFence",
"FenceGetCompletedValue",
"QueueSignal"
],
"client_special_objects": [

8
generator/common.py
View File

@ -84,6 +84,11 @@ class RecordMember:
self.length = None
self.optional = optional
self.is_return_value = is_return_value
self.handle_type = None
def set_handle_type(self, handle_type):
assert self.type.dict_name == "ObjectHandle"
self.handle_type = handle_type
Method = namedtuple('Method', ['name', 'return_type', 'arguments'])
class ObjectType(Type):
@ -130,6 +135,9 @@ def linked_record_members(json_data, types):
member = RecordMember(Name(m['name']), types[m['type']],
m.get('annotation', 'value'), m.get('optional', False),
m.get('is_return_value', False))
handle_type = m.get('handle_type')
if handle_type:
member.set_handle_type(types[handle_type])
members.append(member)
members_by_name[member.name.canonical_case()] = member

1
generator/main.py
View File

@ -388,6 +388,7 @@ def get_renders_for_targets(api_params, wire_json, targets):
renders.append(FileRender('dawn_wire/client/ApiProcs.cpp', 'dawn_wire/client/ApiProcs_autogen.cpp', wire_params))
renders.append(FileRender('dawn_wire/client/ApiProcs.h', 'dawn_wire/client/ApiProcs_autogen.h', wire_params))
renders.append(FileRender('dawn_wire/client/ClientBase.h', 'dawn_wire/client/ClientBase_autogen.h', wire_params))
renders.append(FileRender('dawn_wire/client/ClientDoers.cpp', 'dawn_wire/client/ClientDoers_autogen.cpp', wire_params))
renders.append(FileRender('dawn_wire/client/ClientHandlers.cpp', 'dawn_wire/client/ClientHandlers_autogen.cpp', wire_params))
renders.append(FileRender('dawn_wire/client/ClientPrototypes.inl', 'dawn_wire/client/ClientPrototypes_autogen.inl', wire_params))
renders.append(FileRender('dawn_wire/server/ServerBase.h', 'dawn_wire/server/ServerBase_autogen.h', wire_params))

8
generator/templates/dawn_wire/client/ApiProcs.cpp
View File

@ -24,7 +24,7 @@ namespace dawn_wire { namespace client {
{% for method in type.methods %}
{% set Suffix = as_MethodSuffix(type.name, method.name) %}
{% if Suffix not in client_side_commands %}
{% if Suffix not in client_handwritten_commands %}
{{as_cType(method.return_type.name)}} Client{{Suffix}}(
{{-cType}} cSelf
{%- for arg in method.arguments -%}
@ -122,11 +122,7 @@ namespace dawn_wire { namespace client {
{% for type in by_category["object"] %}
{% for method in native_methods(type) %}
{% set suffix = as_MethodSuffix(type.name, method.name) %}
{% if suffix in client_proxied_commands %}
table.{{as_varName(type.name, method.name)}} = ProxyClient{{suffix}};
{% else %}
table.{{as_varName(type.name, method.name)}} = Client{{suffix}};
{% endif %}
table.{{as_varName(type.name, method.name)}} = Client{{suffix}};
{% endfor %}
{% endfor %}
return table;

8
generator/templates/dawn_wire/client/ApiProcs.h
View File

@ -24,14 +24,6 @@ namespace dawn_wire { namespace client {
{% set cType = as_cType(type.name) %}
{% for method in native_methods(type) %}
{% set Suffix = as_MethodSuffix(type.name, method.name) %}
{% if Suffix in client_proxied_commands %}
{{as_cType(method.return_type.name)}} ProxyClient{{Suffix}}(
{{-cType}} cSelf
{%- for arg in method.arguments -%}
, {{as_annotated_cType(arg)}}
{%- endfor -%}
);
{% endif %}
{{as_cType(method.return_type.name)}} Client{{Suffix}}(
{{-cType}} cSelf
{%- for arg in method.arguments -%}

39
generator/templates/dawn_wire/client/ClientDoers.cpp Normal file
View File

@ -0,0 +1,39 @@
//* 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/Client.h"
#include <string>
namespace dawn_wire {
namespace client {
{% for type in by_category["object"] if type.is_builder %}
{% set Type = type.name.CamelCase() %}
bool Client::Do{{Type}}ErrorCallback({{type.built_type.name.CamelCase()}}* object, uint32_t status, const char* message) {
//* The object might have been deleted or a new object created with the same ID.
if (object == nullptr) {
return true;
}
bool called = object->builderCallback.Call(static_cast<dawnBuilderErrorStatus>(status), message);
//* Unhandled builder errors are forwarded to the device
if (!called && status != DAWN_BUILDER_ERROR_STATUS_SUCCESS && status != DAWN_BUILDER_ERROR_STATUS_UNKNOWN) {
mDevice->HandleError(("Unhandled builder error: " + std::string(message)).c_str());
}
return true;
}
{% endfor %}
}
}

44
generator/templates/dawn_wire/client/ClientHandlers.cpp
View File

@ -18,34 +18,38 @@
#include <string>
namespace dawn_wire { namespace client {
{% for type in by_category["object"] if type.is_builder %}
{% set Type = type.name.CamelCase() %}
bool Client::Handle{{Type}}ErrorCallback(const char** commands, size_t* size) {
Return{{Type}}ErrorCallbackCmd cmd;
{% for command in cmd_records["return command"] %}
bool Client::Handle{{command.name.CamelCase()}}(const char** commands, size_t* size) {
Return{{command.name.CamelCase()}}Cmd cmd;
DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
if (deserializeResult == DeserializeResult::FatalError) {
return false;
}
DAWN_ASSERT(cmd.message != nullptr);
{% for member in command.members if member.handle_type %}
{% set Type = member.handle_type.name.CamelCase() %}
{% set name = as_varName(member.name) %}
auto* builtObject = mDevice->GetClient()->{{type.built_type.name.CamelCase()}}Allocator().GetObject(cmd.builtObject.id);
uint32_t objectSerial = mDevice->GetClient()->{{type.built_type.name.CamelCase()}}Allocator().GetSerial(cmd.builtObject.id);
{% if member.type.dict_name == "ObjectHandle" %}
{{Type}}* {{name}} = {{Type}}Allocator().GetObject(cmd.{{name}}.id);
uint32_t {{name}}Serial = {{Type}}Allocator().GetSerial(cmd.{{name}}.id);
if ({{name}}Serial != cmd.{{name}}.serial) {
{{name}} = nullptr;
}
{% endif %}
{% endfor %}
//* The object might have been deleted or a new object created with the same ID.
if (builtObject == nullptr || objectSerial != cmd.builtObject.serial) {
return true;
}
bool called = builtObject->builderCallback.Call(static_cast<dawnBuilderErrorStatus>(cmd.status), cmd.message);
// Unhandled builder errors are forwarded to the device
if (!called && cmd.status != DAWN_BUILDER_ERROR_STATUS_SUCCESS && cmd.status != DAWN_BUILDER_ERROR_STATUS_UNKNOWN) {
mDevice->HandleError(("Unhandled builder error: " + std::string(cmd.message)).c_str());
}
return true;
return Do{{command.name.CamelCase()}}(
{%- for member in command.members -%}
{%- if member.handle_type -%}
{{as_varName(member.name)}}
{%- else -%}
cmd.{{as_varName(member.name)}}
{%- endif -%}
{%- if not loop.last -%}, {% endif %}
{%- endfor -%}
);
}
{% endfor %}

14
generator/templates/dawn_wire/client/ClientPrototypes.inl
View File

@ -16,3 +16,17 @@
{% for command in cmd_records["return command"] %}
bool Handle{{command.name.CamelCase()}}(const char** commands, size_t* size);
{% endfor %}
//* Return command doers
{% for command in cmd_records["return command"] %}
bool Do{{command.name.CamelCase()}}(
{%- for member in command.members -%}
{%- if member.handle_type -%}
{{as_cppType(member.handle_type.name)}}* {{as_varName(member.name)}}
{%- else -%}
{{as_annotated_cppType(member)}}
{%- endif -%}
{%- if not loop.last -%}, {% endif %}
{%- endfor -%}
);
{% endfor %}

13
generator/wire_cmd.py
View File

@ -27,13 +27,9 @@ def compute_wire_params(api_params, wire_json):
commands = []
return_commands = []
object_result_member = common.RecordMember(Name('result'), types['ObjectHandle'], 'value', False, True)
string_message_member = common.RecordMember(Name('message'), types['char'], 'const*', False, False)
string_message_member.length = 'strlen'
built_object_member = common.RecordMember(Name('built object'), types['ObjectHandle'], 'value', False, False)
callback_status_member = common.RecordMember(Name('status'), types['uint32_t'], 'value', False, False)
# Generate commands from object methods
@ -50,7 +46,9 @@ def compute_wire_params(api_params, wire_json):
# Client->Server commands that return an object return the result object handle
if method.return_type.category == 'object':
members.append(object_result_member)
result = common.RecordMember(Name('result'), types['ObjectHandle'], 'value', False, True)
result.set_handle_type(method.return_type)
members.append(result)
command_name = concat_names(api_object.name, method.name)
command = common.Command(command_name, members)
@ -63,9 +61,10 @@ def compute_wire_params(api_params, wire_json):
# This can be removed when WebGPU error handling is implemented
if api_object.is_builder:
command_name = concat_names(api_object.name, Name('error callback'))
built_object = common.RecordMember(Name('built object'), types['ObjectHandle'], 'value', False, False)
built_object.set_handle_type(api_object.built_type)
command = common.Command(command_name, [
built_object_member,
built_object,
callback_status_member,
string_message_member,
])

57
src/dawn_wire/client/ApiProcs.cpp
View File

@ -105,25 +105,24 @@ namespace dawn_wire { namespace client {
fence->requests.Enqueue(std::move(request), value);
}
void ProxyClientBufferUnmap(dawnBuffer cBuffer) {
void ClientBufferUnmap(dawnBuffer cBuffer) {
Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
// Invalidate the local pointer, and cancel all other in-flight requests that would
// turn into
// errors anyway (you can't double map). This prevents race when the following happens,
// where
// the application code would have unmapped a buffer but still receive a callback:
// - Client -> Server: MapRequest1, Unmap, MapRequest2
// - Server -> Client: Result of MapRequest1
// - Unmap locally on the client
// - Server -> Client: Result of MapRequest2
// turn into errors anyway (you can't double map). This prevents race when the following
// happens, where the application code would have unmapped a buffer but still receive a
// callback:
// - Client -> Server: MapRequest1, Unmap, MapRequest2
// - Server -> Client: Result of MapRequest1
// - Unmap locally on the client
// - Server -> Client: Result of MapRequest2
if (buffer->mappedData) {
// If the buffer was mapped for writing, send the update to the data to the server
if (buffer->isWriteMapped) {
BufferUpdateMappedDataCmd cmd;
cmd.bufferId = buffer->id;
cmd.dataLength = static_cast<uint32_t>(buffer->mappedDataSize);
cmd.data = reinterpret_cast<const uint8_t*>(buffer->mappedData);
cmd.data = static_cast<const uint8_t*>(buffer->mappedData);
size_t requiredSize = cmd.GetRequiredSize();
char* allocatedBuffer =
@ -136,26 +135,52 @@ namespace dawn_wire { namespace client {
}
buffer->ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
ClientBufferUnmap(cBuffer);
BufferUnmapCmd cmd;
cmd.self = cBuffer;
size_t requiredSize = cmd.GetRequiredSize();
char* allocatedBuffer =
static_cast<char*>(buffer->device->GetClient()->GetCmdSpace(requiredSize));
cmd.Serialize(allocatedBuffer, *buffer->device->GetClient());
}
dawnFence ProxyClientDeviceCreateFence(dawnDevice cSelf,
dawnFenceDescriptor const* descriptor) {
dawnFence cFence = ClientDeviceCreateFence(cSelf, descriptor);
dawnFence ClientDeviceCreateFence(dawnDevice cSelf, dawnFenceDescriptor const* descriptor) {
Device* device = reinterpret_cast<Device*>(cSelf);
DeviceCreateFenceCmd cmd;
cmd.self = cSelf;
auto* allocation = device->GetClient()->FenceAllocator().New(device);
cmd.result = ObjectHandle{allocation->object->id, allocation->serial};
cmd.descriptor = descriptor;
size_t requiredSize = cmd.GetRequiredSize();
char* allocatedBuffer = static_cast<char*>(device->GetClient()->GetCmdSpace(requiredSize));
cmd.Serialize(allocatedBuffer, *device->GetClient());
dawnFence cFence = reinterpret_cast<dawnFence>(allocation->object.get());
Fence* fence = reinterpret_cast<Fence*>(cFence);
fence->signaledValue = descriptor->initialValue;
fence->completedValue = descriptor->initialValue;
return cFence;
}
void ProxyClientQueueSignal(dawnQueue cQueue, dawnFence cFence, uint64_t signalValue) {
void ClientQueueSignal(dawnQueue cQueue, dawnFence cFence, uint64_t signalValue) {
Fence* fence = reinterpret_cast<Fence*>(cFence);
if (signalValue <= fence->signaledValue) {
fence->device->HandleError("Fence value less than or equal to signaled value");
return;
}
fence->signaledValue = signalValue;
ClientQueueSignal(cQueue, cFence, signalValue);
QueueSignalCmd cmd;
cmd.self = cQueue;
cmd.fence = cFence;
cmd.signalValue = signalValue;
size_t requiredSize = cmd.GetRequiredSize();
char* allocatedBuffer =
static_cast<char*>(fence->device->GetClient()->GetCmdSpace(requiredSize));
cmd.Serialize(allocatedBuffer, *fence->device->GetClient());
}
void ClientDeviceReference(dawnDevice) {

90
src/dawn_wire/client/ClientHandlers.cpp → src/dawn_wire/client/ClientDoers.cpp
View File

@ -18,38 +18,24 @@
namespace dawn_wire { namespace client {
bool Client::HandleDeviceErrorCallback(const char** commands, size_t* size) {
ReturnDeviceErrorCallbackCmd cmd;
DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
if (deserializeResult == DeserializeResult::FatalError) {
return false;
}
DAWN_ASSERT(cmd.message != nullptr);
mDevice->HandleError(cmd.message);
bool Client::DoDeviceErrorCallback(const char* message) {
DAWN_ASSERT(message != nullptr);
mDevice->HandleError(message);
return true;
}
bool Client::HandleBufferMapReadAsyncCallback(const char** commands, size_t* size) {
ReturnBufferMapReadAsyncCallbackCmd cmd;
DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
if (deserializeResult == DeserializeResult::FatalError) {
return false;
}
auto* buffer = mDevice->GetClient()->BufferAllocator().GetObject(cmd.buffer.id);
uint32_t bufferSerial = mDevice->GetClient()->BufferAllocator().GetSerial(cmd.buffer.id);
bool Client::DoBufferMapReadAsyncCallback(Buffer* buffer,
uint32_t requestSerial,
uint32_t status,
uint32_t count,
const uint8_t* data) {
// The buffer might have been deleted or recreated so this isn't an error.
if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
if (buffer == nullptr) {
return true;
}
// The requests can have been deleted via an Unmap so this isn't an error.
auto requestIt = buffer->requests.find(cmd.requestSerial);
auto requestIt = buffer->requests.find(requestSerial);
if (requestIt == buffer->requests.end()) {
return true;
}
@ -66,14 +52,14 @@ namespace dawn_wire { namespace client {
// On success, we copy the data locally because the IPC buffer isn't valid outside of this
// function
if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
// The server didn't send the right amount of data, this is an error and could cause
// the application to crash if we did call the callback.
if (request.size != cmd.dataLength) {
if (request.size != count) {
return false;
}
ASSERT(cmd.data != nullptr);
ASSERT(data != nullptr);
if (buffer->mappedData != nullptr) {
return false;
@ -82,36 +68,28 @@ namespace dawn_wire { namespace client {
buffer->isWriteMapped = false;
buffer->mappedDataSize = request.size;
buffer->mappedData = malloc(request.size);
memcpy(buffer->mappedData, cmd.data, request.size);
memcpy(buffer->mappedData, data, request.size);
request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status),
buffer->mappedData, request.userdata);
request.readCallback(static_cast<dawnBufferMapAsyncStatus>(status), buffer->mappedData,
request.userdata);
} else {
request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr,
request.readCallback(static_cast<dawnBufferMapAsyncStatus>(status), nullptr,
request.userdata);
}
return true;
}
bool Client::HandleBufferMapWriteAsyncCallback(const char** commands, size_t* size) {
ReturnBufferMapWriteAsyncCallbackCmd cmd;
DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
if (deserializeResult == DeserializeResult::FatalError) {
return false;
}
auto* buffer = mDevice->GetClient()->BufferAllocator().GetObject(cmd.buffer.id);
uint32_t bufferSerial = mDevice->GetClient()->BufferAllocator().GetSerial(cmd.buffer.id);
bool Client::DoBufferMapWriteAsyncCallback(Buffer* buffer,
uint32_t requestSerial,
uint32_t status) {
// The buffer might have been deleted or recreated so this isn't an error.
if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
if (buffer == nullptr) {
return true;
}
// The requests can have been deleted via an Unmap so this isn't an error.
auto requestIt = buffer->requests.find(cmd.requestSerial);
auto requestIt = buffer->requests.find(requestSerial);
if (requestIt == buffer->requests.end()) {
return true;
}
@ -128,7 +106,7 @@ namespace dawn_wire { namespace client {
// On success, we copy the data locally because the IPC buffer isn't valid outside of this
// function
if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
if (buffer->mappedData != nullptr) {
return false;
}
@ -138,33 +116,23 @@ namespace dawn_wire { namespace client {
buffer->mappedData = malloc(request.size);
memset(buffer->mappedData, 0, request.size);
request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status),
buffer->mappedData, request.userdata);
request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(status), buffer->mappedData,
request.userdata);
} else {
request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr,
request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(status), nullptr,
request.userdata);
}
return true;
}
bool Client::HandleFenceUpdateCompletedValue(const char** commands, size_t* size) {
ReturnFenceUpdateCompletedValueCmd cmd;
DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
if (deserializeResult == DeserializeResult::FatalError) {
return false;
}
auto* fence = mDevice->GetClient()->FenceAllocator().GetObject(cmd.fence.id);
uint32_t fenceSerial = mDevice->GetClient()->FenceAllocator().GetSerial(cmd.fence.id);
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 || fenceSerial != cmd.fence.serial) {
if (fence == nullptr) {
return true;
}
fence->completedValue = cmd.value;
fence->completedValue = value;
fence->CheckPassedFences();
return true;
}