Make a convenience cpp method for WaitAny with one future
When one future is waited on, there is no need for FutureWaitInfo.
FutureWaitInfo tells you which futures completed when the application
passed a list of futures. But when the list is only one element,
WaitStatus::Success always means that the future completed.
When waiting on just one future, this is much more convenient than
creating the extra struct.
Bug: none
Change-Id: I75b722511a8025a5c1d9229380a5a1618d21a0a8
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/193701
Commit-Queue: Austin Eng <enga@chromium.org>
Reviewed-by: Loko Kung <lokokung@google.com>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
diff --git a/generator/templates/api_cpp.h b/generator/templates/api_cpp.h
index 63e097d..9d440fb 100644
--- a/generator/templates/api_cpp.h
+++ b/generator/templates/api_cpp.h
@@ -481,6 +481,10 @@
{% endif %}
{% endfor %}
+ {% if CppType == "Instance" %}
+ inline wgpu::WaitStatus WaitAny(wgpu::Future f, uint64_t timeout);
+ {% endif %}
+
private:
friend ObjectBase<{{CppType}}, {{CType}}>;
static inline void {{c_prefix}}AddRef({{CType}} handle);
@@ -657,6 +661,14 @@
{{render_cpp_method_impl(type, method)}}
{% endif %}
{% endfor %}
+
+ {% if CppType == "Instance" %}
+ wgpu::WaitStatus Instance::WaitAny(wgpu::Future f, uint64_t timeout) {
+ wgpu::FutureWaitInfo waitInfo { f };
+ return WaitAny(1, &waitInfo, timeout);
+ }
+ {% endif %}
+
void {{CppType}}::{{c_prefix}}AddRef({{CType}} handle) {
if (handle != nullptr) {
{{as_cMethodNamespaced(type.name, Name("add ref"), c_namespace)}}(handle);
diff --git a/src/dawn/samples/SampleUtils.cpp b/src/dawn/samples/SampleUtils.cpp
index b08c1a3..07f11bd 100644
--- a/src/dawn/samples/SampleUtils.cpp
+++ b/src/dawn/samples/SampleUtils.cpp
@@ -164,20 +164,20 @@
}
wgpu::Adapter adapter;
- wgpu::FutureWaitInfo adapterFuture = {};
- adapterFuture.future = instance.RequestAdapter(
- &options, {nullptr, wgpu::CallbackMode::WaitAnyOnly,
- [](WGPURequestAdapterStatus status, WGPUAdapter adapter, const char* message,
- void* userdata) {
- if (status != WGPURequestAdapterStatus_Success) {
- dawn::ErrorLog() << "Failed to get an adapter:" << message;
- return;
- }
- *static_cast<wgpu::Adapter*>(userdata) = wgpu::Adapter::Acquire(adapter);
- },
- &adapter});
- instance.WaitAny(1, &adapterFuture, UINT64_MAX);
- DAWN_ASSERT(adapterFuture.completed);
+ instance.WaitAny(
+ instance.RequestAdapter(&options, {nullptr, wgpu::CallbackMode::WaitAnyOnly,
+ [](WGPURequestAdapterStatus status, WGPUAdapter adapter,
+ const char* message, void* userdata) {
+ if (status != WGPURequestAdapterStatus_Success) {
+ dawn::ErrorLog()
+ << "Failed to get an adapter:" << message;
+ return;
+ }
+ *static_cast<wgpu::Adapter*>(userdata) =
+ wgpu::Adapter::Acquire(adapter);
+ },
+ &adapter}),
+ UINT64_MAX);
if (adapter == nullptr) {
return wgpu::Device();
@@ -194,20 +194,20 @@
PrintDeviceLoss, nullptr};
wgpu::Device device;
- wgpu::FutureWaitInfo deviceFuture = {};
- deviceFuture.future = adapter.RequestDevice(
- &deviceDesc, {nullptr, wgpu::CallbackMode::WaitAnyOnly,
- [](WGPURequestDeviceStatus status, WGPUDevice device, const char* message,
- void* userdata) {
- if (status != WGPURequestDeviceStatus_Success) {
- dawn::ErrorLog() << "Failed to get an device:" << message;
- return;
- }
- *static_cast<wgpu::Device*>(userdata) = wgpu::Device::Acquire(device);
- },
- &device});
- instance.WaitAny(1, &deviceFuture, UINT64_MAX);
- DAWN_ASSERT(deviceFuture.completed);
+ instance.WaitAny(
+ adapter.RequestDevice(&deviceDesc, {nullptr, wgpu::CallbackMode::WaitAnyOnly,
+ [](WGPURequestDeviceStatus status, WGPUDevice device,
+ const char* message, void* userdata) {
+ if (status != WGPURequestDeviceStatus_Success) {
+ dawn::ErrorLog()
+ << "Failed to get an device:" << message;
+ return;
+ }
+ *static_cast<wgpu::Device*>(userdata) =
+ wgpu::Device::Acquire(device);
+ },
+ &device}),
+ UINT64_MAX);
if (device == nullptr) {
return wgpu::Device();
diff --git a/src/dawn/tests/DawnTest.cpp b/src/dawn/tests/DawnTest.cpp
index fdfe569..4840b3a 100644
--- a/src/dawn/tests/DawnTest.cpp
+++ b/src/dawn/tests/DawnTest.cpp
@@ -1650,9 +1650,11 @@
MockCppCallback<void (*)(wgpu::MapAsyncStatus, const char*)> mockCb;
EXPECT_CALL(mockCb, Call(wgpu::MapAsyncStatus::Success, _)).Times(1);
- wgpu::FutureWaitInfo waitInfo = {buffer.MapAsync(
- mapMode, offset, size, wgpu::CallbackMode::WaitAnyOnly, mockCb.Callback())};
- ASSERT_EQ(instance.WaitAny(1, &waitInfo, UINT64_MAX), wgpu::WaitStatus::Success);
+ ASSERT_EQ(
+ instance.WaitAny(buffer.MapAsync(mapMode, offset, size, wgpu::CallbackMode::WaitAnyOnly,
+ mockCb.Callback()),
+ UINT64_MAX),
+ wgpu::WaitStatus::Success);
} else {
bool done = false;
buffer.MapAsync(mapMode, offset, size, wgpu::CallbackMode::AllowProcessEvents,
diff --git a/src/dawn/tests/end2end/EventTests.cpp b/src/dawn/tests/end2end/EventTests.cpp
index 28e215b..fc5f8af 100644
--- a/src/dawn/tests/end2end/EventTests.cpp
+++ b/src/dawn/tests/end2end/EventTests.cpp
@@ -506,9 +506,10 @@
}
for (uint64_t timeout : {uint64_t(1), uint64_t(0), UINT64_MAX}) {
- wgpu::FutureWaitInfo info{device2.GetQueue().OnSubmittedWorkDone(
- wgpu::CallbackMode::WaitAnyOnly, [](wgpu::QueueWorkDoneStatus) {})};
- wgpu::WaitStatus status = instance2.WaitAny(1, &info, timeout);
+ wgpu::WaitStatus status = instance2.WaitAny(
+ device2.GetQueue().OnSubmittedWorkDone(wgpu::CallbackMode::WaitAnyOnly,
+ [](wgpu::QueueWorkDoneStatus) {}),
+ timeout);
if (timeout == 0) {
ASSERT_TRUE(status == wgpu::WaitStatus::Success ||
status == wgpu::WaitStatus::TimedOut);
diff --git a/src/dawn/tests/end2end/MultithreadTests.cpp b/src/dawn/tests/end2end/MultithreadTests.cpp
index 7bbb0ec..8c920b0 100644
--- a/src/dawn/tests/end2end/MultithreadTests.cpp
+++ b/src/dawn/tests/end2end/MultithreadTests.cpp
@@ -206,14 +206,15 @@
wgpu::Buffer buffer =
CreateBuffer(kSize, wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc);
- wgpu::FutureWaitInfo waitInfo = {
- buffer.MapAsync(wgpu::MapMode::Write, 0, kSize, wgpu::CallbackMode::AllowProcessEvents,
- [](wgpu::MapAsyncStatus status, const char*) {
- ASSERT_EQ(status, wgpu::MapAsyncStatus::Success);
- })};
-
// Wait for the mapping to complete
- ASSERT_EQ(instance.WaitAny(1, &waitInfo, UINT64_MAX), wgpu::WaitStatus::Success);
+ ASSERT_EQ(instance.WaitAny(buffer.MapAsync(wgpu::MapMode::Write, 0, kSize,
+ wgpu::CallbackMode::AllowProcessEvents,
+ [](wgpu::MapAsyncStatus status, const char*) {
+ ASSERT_EQ(status,
+ wgpu::MapAsyncStatus::Success);
+ }),
+ UINT64_MAX),
+ wgpu::WaitStatus::Success);
// Buffer is mapped, write into it and unmap .
memcpy(buffer.GetMappedRange(0, kSize), myData.data(), kSize);
