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

Add dawnGetProcAddress. 

This will become wgpuGetProcAddress that is part of the webgpu.h and the
last gap in functionality for dawn.h to match webgpu.h.

BUG=dawn:22

Change-Id: I0dcb3b5e6bd99cb10db273fc101d3ec0161b7da0
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12120
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
This commit is contained in:
Corentin Wallez 2019-10-15 12:08:48 +00:00 committed by Commit Bot service account
parent 96496828a0
commit c57b180208
12 changed files with 296 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
BUILD.gn
View File

@ -773,6 +773,7 @@ test("dawn_unittests") {
"src/tests/unittests/EnumClassBitmasksTests.cpp",
"src/tests/unittests/ErrorTests.cpp",
"src/tests/unittests/ExtensionTests.cpp",
"src/tests/unittests/GetProcAddressTests.cpp",
"src/tests/unittests/MathTests.cpp",
"src/tests/unittests/ObjectBaseTests.cpp",
"src/tests/unittests/PerStageTests.cpp",

7
generator/dawn_json_generator.py
View File

@ -448,6 +448,12 @@ def c_native_methods(types, typ):
Method(Name('release'), types['void'], []),
]
def get_methods_sorted_by_name(api_params):
unsorted = [(as_MethodSuffix(typ.name, method.name), typ, method) \
for typ in api_params['by_category']['object'] \
for method in c_native_methods(api_params['types'], typ) ]
return [(typ, method) for (_, typ, method) in sorted(unsorted)]
class MultiGeneratorFromDawnJSON(Generator):
def get_description(self):
return 'Generates code for various target from Dawn.json.'
@ -486,6 +492,7 @@ class MultiGeneratorFromDawnJSON(Generator):
'convert_cType_to_cppType': convert_cType_to_cppType,
'as_varName': as_varName,
'decorate': decorate,
'methods_sorted_by_name': get_methods_sorted_by_name(api_params),
}
renders = []

8
generator/templates/api.h
View File

@ -54,7 +54,6 @@ extern "C" {
#endif
// Custom types depending on the target language
typedef void (*DawnErrorCallback)(DawnErrorType type, const char* message, void* userdata);
typedef void (*DawnBufferCreateMappedCallback)(DawnBufferMapAsyncStatus status,
DawnCreateBufferMappedResult result,
void* userdata);
@ -67,9 +66,14 @@ typedef void (*DawnBufferMapWriteCallback)(DawnBufferMapAsyncStatus status,
uint64_t dataLength,
void* userdata);
typedef void (*DawnFenceOnCompletionCallback)(DawnFenceCompletionStatus status, void* userdata);
typedef void (*DawnErrorCallback)(DawnErrorType type, const char* message, void* userdata);
typedef void (*DawnProc)();
#if !defined(DAWN_SKIP_PROCS)
typedef DawnProc (*DawnProcGetProcAddress)(DawnDevice device, const char* procName);
{% for type in by_category["object"] %}
// Procs of {{type.name.CamelCase()}}
{% for method in native_methods(type) %}
@ -86,6 +90,8 @@ typedef void (*DawnFenceOnCompletionCallback)(DawnFenceCompletionStatus status,
#if !defined(DAWN_SKIP_DECLARATIONS)
DAWN_EXPORT DawnProc DawnGetProcAddress(DawnDevice device, const char* procName);
{% for type in by_category["object"] %}
// Methods of {{type.name.CamelCase()}}
{% for method in native_methods(type) %}

4
generator/templates/api_proc.c
View File

@ -26,6 +26,10 @@ void dawnProcSetProcs(const DawnProcTable* procs_) {
}
}
DawnProc DawnGetProcAddress(DawnDevice device, const char* procName) {
return procs.getProcAddress(device, procName);
}
{% for type in by_category["object"] %}
{% for method in native_methods(type) %}
{{as_cType(method.return_type.name)}} {{as_cMethod(type.name, method.name)}}(

2
generator/templates/api_proc_table.h
View File

@ -18,6 +18,8 @@
#include "dawn/dawn.h"
typedef struct DawnProcTable {
DawnProcGetProcAddress getProcAddress;
{% for type in by_category["object"] %}
{% for method in native_methods(type) %}
{{as_cProc(type.name, method.name)}} {{as_varName(type.name, method.name)}};

4
generator/templates/apicpp.cpp
View File

@ -112,4 +112,8 @@ namespace dawn {
{% endfor %}
Proc GetProcAddress(Device const& device, const char* procName) {
return reinterpret_cast<Proc>(DawnGetProcAddress(device.Get(), procName));
}
}

3
generator/templates/apicpp.h
View File

@ -48,6 +48,7 @@ namespace dawn {
{% endfor %}
using Proc = DawnProc;
{% for type in by_category["natively defined"] %}
using {{as_cppType(type.name)}} = {{as_cType(type.name)}};
{% endfor %}
@ -175,6 +176,8 @@ namespace dawn {
{% endfor %}
DAWN_EXPORT Proc GetProcAddress(Device const& device, const char* procName);
{% for type in by_category["structure"] %}
struct {{as_cppType(type.name)}} {
{% if type.extensible %}

54
generator/templates/dawn_native/ProcTable.cpp
View File

@ -12,12 +12,10 @@
//* See the License for the specific language governing permissions and
//* limitations under the License.
#include "common/Assert.h"
#include "dawn_native/dawn_platform.h"
#include "dawn_native/DawnNative.h"
#include "dawn_native/ErrorData.h"
#include "dawn_native/ValidationUtils_autogen.h"
#include <vector>
{% for type in by_category["object"] %}
{% if type.name.canonical_case() not in ["texture view"] %}
@ -28,11 +26,12 @@
namespace dawn_native {
namespace {
{% for type in by_category["object"] %}
{% for method in native_methods(type) %}
{% set suffix = as_MethodSuffix(type.name, method.name) %}
{{as_cType(method.return_type.name)}} CToCpp{{suffix}}(
{{as_cType(method.return_type.name)}} Native{{suffix}}(
{{-as_cType(type.name)}} cSelf
{%- for arg in method.arguments -%}
, {{as_annotated_cType(arg)}}
@ -71,13 +70,56 @@ namespace dawn_native {
}
{% endfor %}
{% endfor %}
struct ProcEntry {
DawnProc proc;
const char* name;
};
static const ProcEntry sProcMap[] = {
{% for (type, method) in methods_sorted_by_name %}
{ reinterpret_cast<DawnProc>(Native{{as_MethodSuffix(type.name, method.name)}}), "{{as_cMethod(type.name, method.name)}}" },
{% endfor %}
};
static constexpr size_t sProcMapSize = sizeof(sProcMap) / sizeof(sProcMap[0]);
}
DawnProc NativeGetProcAddress(DawnDevice, const char* procName) {
if (procName == nullptr) {
return nullptr;
}
const ProcEntry* entry = std::lower_bound(&sProcMap[0], &sProcMap[sProcMapSize], procName,
[](const ProcEntry &a, const char *b) -> bool {
return strcmp(a.name, b) < 0;
}
);
if (entry != &sProcMap[sProcMapSize] && strcmp(entry->name, procName) == 0) {
return entry->proc;
}
if (strcmp(procName, "dawnGetProcAddress") == 0) {
return reinterpret_cast<DawnProc>(NativeGetProcAddress);
}
return nullptr;
}
std::vector<const char*> GetProcMapNamesForTesting() {
std::vector<const char*> result;
result.reserve(sProcMapSize);
for (const ProcEntry& entry : sProcMap) {
result.push_back(entry.name);
}
return result;
}
DawnProcTable GetProcsAutogen() {
DawnProcTable table;
table.getProcAddress = NativeGetProcAddress;
{% for type in by_category["object"] %}
{% for method in native_methods(type) %}
table.{{as_varName(type.name, method.name)}} = CToCpp{{as_MethodSuffix(type.name, method.name)}};
table.{{as_varName(type.name, method.name)}} = Native{{as_MethodSuffix(type.name, method.name)}};
{% endfor %}
{% endfor %}
return table;

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

@ -16,6 +16,9 @@
#include "dawn_wire/client/ApiProcs_autogen.h"
#include "dawn_wire/client/Client.h"
#include <string>
#include <vector>
namespace dawn_wire { namespace client {
//* Implementation of the client API functions.
{% for type in by_category["object"] %}
@ -89,6 +92,50 @@ namespace dawn_wire { namespace client {
{% endif %}
{% endfor %}
namespace {
struct ProcEntry {
DawnProc proc;
const char* name;
};
static const ProcEntry sProcMap[] = {
{% for (type, method) in methods_sorted_by_name %}
{ reinterpret_cast<DawnProc>(Client{{as_MethodSuffix(type.name, method.name)}}), "{{as_cMethod(type.name, method.name)}}" },
{% endfor %}
};
static constexpr size_t sProcMapSize = sizeof(sProcMap) / sizeof(sProcMap[0]);
} // anonymous namespace
DawnProc ClientGetProcAddress(DawnDevice, const char* procName) {
if (procName == nullptr) {
return nullptr;
}
const ProcEntry* entry = std::lower_bound(&sProcMap[0], &sProcMap[sProcMapSize], procName,
[](const ProcEntry &a, const char *b) -> bool {
return strcmp(a.name, b) < 0;
}
);
if (entry != &sProcMap[sProcMapSize] && strcmp(entry->name, procName) == 0) {
return entry->proc;
}
if (strcmp(procName, "dawnGetProcAddress") == 0) {
return reinterpret_cast<DawnProc>(ClientGetProcAddress);
}
return nullptr;
}
std::vector<const char*> GetProcMapNamesForTesting() {
std::vector<const char*> result;
result.reserve(sProcMapSize);
for (const ProcEntry& entry : sProcMap) {
result.push_back(entry.name);
}
return result;
}
//* Some commands don't have a custom wire format, but need to be handled manually to update
//* some client-side state tracking. For these we have two functions:
//* - An autogenerated Client{{suffix}} method that sends the command on the wire
@ -96,6 +143,7 @@ namespace dawn_wire { namespace client {
//* the autogenerated one, and that will have to call Client{{suffix}}
DawnProcTable GetProcs() {
DawnProcTable table;
table.getProcAddress = ClientGetProcAddress;
{% for type in by_category["object"] %}
{% for method in native_methods(type) %}
{% set suffix = as_MethodSuffix(type.name, method.name) %}

3
src/include/dawn_native/DawnNative.h
View File

@ -160,6 +160,9 @@ namespace dawn_native {
// Backdoor to get the number of lazy clears for testing
DAWN_NATIVE_EXPORT size_t GetLazyClearCountForTesting(DawnDevice device);
// Backdoor to get the order of the ProcMap for testing
DAWN_NATIVE_EXPORT std::vector<const char*> GetProcMapNamesForTesting();
} // namespace dawn_native
#endif // DAWNNATIVE_DAWNNATIVE_H_

4
src/include/dawn_wire/WireClient.h
View File

@ -120,8 +120,10 @@ namespace dawn_wire {
virtual ~WriteHandle();
};
};
} // namespace client
// Backdoor to get the order of the ProcMap for testing
DAWN_WIRE_EXPORT std::vector<const char*> GetProcMapNamesForTesting();
} // namespace client
} // namespace dawn_wire
#endif // DAWNWIRE_WIRECLIENT_H_

166
src/tests/unittests/GetProcAddressTests.cpp Normal file
View File

@ -0,0 +1,166 @@
// 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 <gtest/gtest.h>
#include "dawn/dawn_proc.h"
#include "dawn_native/Instance.h"
#include "dawn_native/null/DeviceNull.h"
#include "dawn_wire/WireClient.h"
#include "utils/TerribleCommandBuffer.h"
namespace {
// libdawn_wire and libdawn_native contain duplicated code for the handling of GetProcAddress
// so we run the tests against both implementations. This enum is used as a test parameters to
// know which implementation to test.
enum class DawnFlavor {
Native,
Wire,
};
std::ostream& operator<<(std::ostream& stream, DawnFlavor flavor) {
switch (flavor) {
case DawnFlavor::Native:
stream << "dawn_native";
break;
case DawnFlavor::Wire:
stream << "dawn_wire";
break;
default:
UNREACHABLE();
break;
}
return stream;
}
class GetProcAddressTests : public testing::TestWithParam<DawnFlavor> {
public:
GetProcAddressTests()
: testing::TestWithParam<DawnFlavor>(),
mNativeInstance(),
mNativeAdapter(&mNativeInstance) {
}
void SetUp() override {
switch (GetParam()) {
case DawnFlavor::Native: {
mDevice = dawn::Device::Acquire(
reinterpret_cast<DawnDevice>(mNativeAdapter.CreateDevice(nullptr)));
mProcs = dawn_native::GetProcs();
break;
}
case DawnFlavor::Wire: {
mC2sBuf = std::make_unique<utils::TerribleCommandBuffer>();
dawn_wire::WireClientDescriptor clientDesc = {};
clientDesc.serializer = mC2sBuf.get();
mWireClient = std::make_unique<dawn_wire::WireClient>(clientDesc);
mDevice = dawn::Device::Acquire(mWireClient->GetDevice());
mProcs = mWireClient->GetProcs();
break;
}
default:
UNREACHABLE();
break;
}
dawnProcSetProcs(&mProcs);
}
void TearDown() override {
// Destroy the device before freeing the instance or the wire client in the destructor
mDevice = dawn::Device();
}
protected:
dawn_native::InstanceBase mNativeInstance;
dawn_native::null::Adapter mNativeAdapter;
std::unique_ptr<utils::TerribleCommandBuffer> mC2sBuf;
std::unique_ptr<dawn_wire::WireClient> mWireClient;
dawn::Device mDevice;
DawnProcTable mProcs;
};
// Test GetProcAddress with and without devices on some valid examples
TEST_P(GetProcAddressTests, ValidExamples) {
ASSERT_EQ(mProcs.getProcAddress(nullptr, "dawnDeviceCreateBuffer"),
reinterpret_cast<DawnProc>(mProcs.deviceCreateBuffer));
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), "dawnDeviceCreateBuffer"),
reinterpret_cast<DawnProc>(mProcs.deviceCreateBuffer));
ASSERT_EQ(mProcs.getProcAddress(nullptr, "dawnQueueSubmit"),
reinterpret_cast<DawnProc>(mProcs.queueSubmit));
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), "dawnQueueSubmit"),
reinterpret_cast<DawnProc>(mProcs.queueSubmit));
}
// Test GetProcAddress with and without devices on nullptr procName
TEST_P(GetProcAddressTests, Nullptr) {
ASSERT_EQ(mProcs.getProcAddress(nullptr, nullptr), nullptr);
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), nullptr), nullptr);
}
// Test GetProcAddress with and without devices on some invalid
TEST_P(GetProcAddressTests, InvalidExamples) {
ASSERT_EQ(mProcs.getProcAddress(nullptr, "dawnDeviceDoSomething"), nullptr);
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), "dawnDeviceDoSomething"), nullptr);
// Trigger the condition where lower_bound will return the end of the procMap.
ASSERT_EQ(mProcs.getProcAddress(nullptr, "zzzzzzz"), nullptr);
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), "zzzzzzz"), nullptr);
ASSERT_EQ(mProcs.getProcAddress(nullptr, "ZZ"), nullptr);
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), "ZZ"), nullptr);
// Some more potential corner cases.
ASSERT_EQ(mProcs.getProcAddress(nullptr, ""), nullptr);
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), ""), nullptr);
ASSERT_EQ(mProcs.getProcAddress(nullptr, "0"), nullptr);
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), "0"), nullptr);
}
// Test that GetProcAddress supports itself: it is handled specially because it is a
// freestanding function and not a method on an object.
TEST_P(GetProcAddressTests, GetProcAddressItself) {
ASSERT_EQ(mProcs.getProcAddress(nullptr, "dawnGetProcAddress"),
reinterpret_cast<DawnProc>(mProcs.getProcAddress));
ASSERT_EQ(mProcs.getProcAddress(mDevice.Get(), "dawnGetProcAddress"),
reinterpret_cast<DawnProc>(mProcs.getProcAddress));
}
INSTANTIATE_TEST_SUITE_P(,
GetProcAddressTests,
testing::Values(DawnFlavor::Native, DawnFlavor::Wire),
testing::PrintToStringParamName());
TEST(GetProcAddressInternalTests, CheckDawnNativeProcMapOrder) {
std::vector<const char*> names = dawn_native::GetProcMapNamesForTesting();
for (size_t i = 1; i < names.size(); i++) {
ASSERT_LT(std::string(names[i - 1]), std::string(names[i]));
}
}
TEST(GetProcAddressInternalTests, CheckDawnWireClientProcMapOrder) {
std::vector<const char*> names = dawn_wire::client::GetProcMapNamesForTesting();
for (size_t i = 1; i < names.size(); i++) {
ASSERT_LT(std::string(names[i - 1]), std::string(names[i]));
}
}
} // anonymous namespace