aboutsummaryrefslogtreecommitdiff
path: root/offload/unittests/OffloadAPI
diff options
context:
space:
mode:
Diffstat (limited to 'offload/unittests/OffloadAPI')
-rw-r--r--offload/unittests/OffloadAPI/CMakeLists.txt8
-rw-r--r--offload/unittests/OffloadAPI/common/Fixtures.hpp12
-rw-r--r--offload/unittests/OffloadAPI/device_code/CMakeLists.txt2
-rw-r--r--offload/unittests/OffloadAPI/device_code/sequence.c11
-rw-r--r--offload/unittests/OffloadAPI/event/olCreateEvent.cpp29
-rw-r--r--offload/unittests/OffloadAPI/event/olDestroyEvent.cpp10
-rw-r--r--offload/unittests/OffloadAPI/event/olSyncEvent.cpp37
-rw-r--r--offload/unittests/OffloadAPI/event/olWaitEvent.cpp32
-rw-r--r--offload/unittests/OffloadAPI/kernel/olLaunchKernel.cpp55
-rw-r--r--offload/unittests/OffloadAPI/memory/olMemcpy.cpp71
-rw-r--r--offload/unittests/OffloadAPI/queue/olSyncQueue.cpp (renamed from offload/unittests/OffloadAPI/queue/olWaitQueue.cpp)10
-rw-r--r--offload/unittests/OffloadAPI/queue/olWaitEvents.cpp151
12 files changed, 302 insertions, 126 deletions
diff --git a/offload/unittests/OffloadAPI/CMakeLists.txt b/offload/unittests/OffloadAPI/CMakeLists.txt
index d763386..8f0267e 100644
--- a/offload/unittests/OffloadAPI/CMakeLists.txt
+++ b/offload/unittests/OffloadAPI/CMakeLists.txt
@@ -9,8 +9,9 @@ add_offload_unittest("device"
device/olGetDeviceInfoSize.cpp)
add_offload_unittest("event"
+ event/olCreateEvent.cpp
event/olDestroyEvent.cpp
- event/olWaitEvent.cpp
+ event/olSyncEvent.cpp
event/olGetEventInfo.cpp
event/olGetEventInfoSize.cpp)
@@ -36,10 +37,11 @@ add_offload_unittest("program"
add_offload_unittest("queue"
queue/olCreateQueue.cpp
- queue/olWaitQueue.cpp
+ queue/olSyncQueue.cpp
queue/olDestroyQueue.cpp
queue/olGetQueueInfo.cpp
- queue/olGetQueueInfoSize.cpp)
+ queue/olGetQueueInfoSize.cpp
+ queue/olWaitEvents.cpp)
add_offload_unittest("symbol"
symbol/olGetSymbol.cpp
diff --git a/offload/unittests/OffloadAPI/common/Fixtures.hpp b/offload/unittests/OffloadAPI/common/Fixtures.hpp
index 5469211..24ce1a0 100644
--- a/offload/unittests/OffloadAPI/common/Fixtures.hpp
+++ b/offload/unittests/OffloadAPI/common/Fixtures.hpp
@@ -171,16 +171,8 @@ struct OffloadQueueTest : OffloadDeviceTest {
struct OffloadEventTest : OffloadQueueTest {
void SetUp() override {
RETURN_ON_FATAL_FAILURE(OffloadQueueTest::SetUp());
- // Get an event from a memcpy. We can still use it in olGetEventInfo etc
- // after it has been waited on.
- void *Alloc;
- uint32_t Value = 42;
- ASSERT_SUCCESS(
- olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, sizeof(Value), &Alloc));
- ASSERT_SUCCESS(
- olMemcpy(Queue, Alloc, Device, &Value, Host, sizeof(Value), &Event));
- ASSERT_SUCCESS(olWaitEvent(Event));
- ASSERT_SUCCESS(olMemFree(Alloc));
+ ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
}
void TearDown() override {
diff --git a/offload/unittests/OffloadAPI/device_code/CMakeLists.txt b/offload/unittests/OffloadAPI/device_code/CMakeLists.txt
index 11c8ccb..0e4695e 100644
--- a/offload/unittests/OffloadAPI/device_code/CMakeLists.txt
+++ b/offload/unittests/OffloadAPI/device_code/CMakeLists.txt
@@ -8,6 +8,7 @@ add_offload_test_device_code(localmem_static.c localmem_static)
add_offload_test_device_code(global.c global)
add_offload_test_device_code(global_ctor.c global_ctor)
add_offload_test_device_code(global_dtor.c global_dtor)
+add_offload_test_device_code(sequence.c sequence)
add_custom_target(offload_device_binaries DEPENDS
foo.bin
@@ -19,5 +20,6 @@ add_custom_target(offload_device_binaries DEPENDS
global.bin
global_ctor.bin
global_dtor.bin
+ sequence.bin
)
set(OFFLOAD_TEST_DEVICE_CODE_PATH ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE)
diff --git a/offload/unittests/OffloadAPI/device_code/sequence.c b/offload/unittests/OffloadAPI/device_code/sequence.c
new file mode 100644
index 0000000..7662f2d
--- /dev/null
+++ b/offload/unittests/OffloadAPI/device_code/sequence.c
@@ -0,0 +1,11 @@
+#include <gpuintrin.h>
+#include <stdint.h>
+
+__gpu_kernel void sequence(uint32_t idx, uint32_t *inout) {
+ if (idx == 0)
+ inout[idx] = 0;
+ else if (idx == 1)
+ inout[idx] = 1;
+ else
+ inout[idx] = inout[idx - 1] + inout[idx - 2];
+}
diff --git a/offload/unittests/OffloadAPI/event/olCreateEvent.cpp b/offload/unittests/OffloadAPI/event/olCreateEvent.cpp
new file mode 100644
index 0000000..957e9d5
--- /dev/null
+++ b/offload/unittests/OffloadAPI/event/olCreateEvent.cpp
@@ -0,0 +1,29 @@
+//===------- Offload API tests - olCreateEvent ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../common/Fixtures.hpp"
+#include <OffloadAPI.h>
+#include <gtest/gtest.h>
+
+using olCreateEventTest = OffloadQueueTest;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olCreateEventTest);
+
+TEST_P(olCreateEventTest, Success) {
+ ol_event_handle_t Event = nullptr;
+ ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
+ ASSERT_NE(Event, nullptr);
+}
+
+TEST_P(olCreateEventTest, InvalidNullQueue) {
+ ol_event_handle_t Event;
+ ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olCreateEvent(nullptr, &Event));
+}
+
+TEST_P(olCreateEventTest, InvalidNullDest) {
+ ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER, olCreateEvent(Queue, nullptr));
+}
diff --git a/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp b/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp
index 3f716d2..8cee535 100644
--- a/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp
+++ b/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp
@@ -14,16 +14,10 @@ using olDestroyEventTest = OffloadQueueTest;
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olDestroyEventTest);
TEST_P(olDestroyEventTest, Success) {
- uint32_t Src = 42;
- void *DstPtr;
-
ol_event_handle_t Event = nullptr;
- ASSERT_SUCCESS(
- olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, sizeof(uint32_t), &DstPtr));
- ASSERT_SUCCESS(
- olMemcpy(Queue, DstPtr, Device, &Src, Host, sizeof(Src), &Event));
+ ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
ASSERT_NE(Event, nullptr);
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
ASSERT_SUCCESS(olDestroyEvent(Event));
}
diff --git a/offload/unittests/OffloadAPI/event/olSyncEvent.cpp b/offload/unittests/OffloadAPI/event/olSyncEvent.cpp
new file mode 100644
index 0000000..22ecb96
--- /dev/null
+++ b/offload/unittests/OffloadAPI/event/olSyncEvent.cpp
@@ -0,0 +1,37 @@
+//===------- Offload API tests - olSyncEvent -====-------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../common/Fixtures.hpp"
+#include <OffloadAPI.h>
+#include <gtest/gtest.h>
+
+using olSyncEventTest = OffloadQueueTest;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olSyncEventTest);
+
+TEST_P(olSyncEventTest, Success) {
+ ol_event_handle_t Event = nullptr;
+ ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
+ ASSERT_NE(Event, nullptr);
+ ASSERT_SUCCESS(olSyncEvent(Event));
+ ASSERT_SUCCESS(olDestroyEvent(Event));
+}
+
+TEST_P(olSyncEventTest, InvalidNullEvent) {
+ ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olSyncEvent(nullptr));
+}
+
+TEST_P(olSyncEventTest, SuccessMultipleSync) {
+ ol_event_handle_t Event = nullptr;
+ ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
+ ASSERT_NE(Event, nullptr);
+
+ for (size_t I = 0; I < 10; I++)
+ ASSERT_SUCCESS(olSyncEvent(Event));
+
+ ASSERT_SUCCESS(olDestroyEvent(Event));
+}
diff --git a/offload/unittests/OffloadAPI/event/olWaitEvent.cpp b/offload/unittests/OffloadAPI/event/olWaitEvent.cpp
deleted file mode 100644
index f80dabb..0000000
--- a/offload/unittests/OffloadAPI/event/olWaitEvent.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===------- Offload API tests - olWaitEvent -====-------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "../common/Fixtures.hpp"
-#include <OffloadAPI.h>
-#include <gtest/gtest.h>
-
-using olWaitEventTest = OffloadQueueTest;
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olWaitEventTest);
-
-TEST_P(olWaitEventTest, Success) {
- uint32_t Src = 42;
- void *DstPtr;
-
- ol_event_handle_t Event = nullptr;
- ASSERT_SUCCESS(
- olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, sizeof(uint32_t), &DstPtr));
- ASSERT_SUCCESS(
- olMemcpy(Queue, DstPtr, Device, &Src, Host, sizeof(Src), &Event));
- ASSERT_NE(Event, nullptr);
- ASSERT_SUCCESS(olWaitEvent(Event));
- ASSERT_SUCCESS(olDestroyEvent(Event));
-}
-
-TEST_P(olWaitEventTest, InvalidNullEvent) {
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olWaitEvent(nullptr));
-}
diff --git a/offload/unittests/OffloadAPI/kernel/olLaunchKernel.cpp b/offload/unittests/OffloadAPI/kernel/olLaunchKernel.cpp
index e7e608f..758f607 100644
--- a/offload/unittests/OffloadAPI/kernel/olLaunchKernel.cpp
+++ b/offload/unittests/OffloadAPI/kernel/olLaunchKernel.cpp
@@ -91,10 +91,10 @@ TEST_P(olLaunchKernelFooTest, Success) {
void *Mem;
} Args{Mem};
- ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
- &LaunchArgs, nullptr));
+ ASSERT_SUCCESS(
+ olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *Data = (uint32_t *)Mem;
for (uint32_t i = 0; i < 64; i++) {
@@ -106,9 +106,9 @@ TEST_P(olLaunchKernelFooTest, Success) {
TEST_P(olLaunchKernelNoArgsTest, Success) {
ASSERT_SUCCESS(
- olLaunchKernel(Queue, Device, Kernel, nullptr, 0, &LaunchArgs, nullptr));
+ olLaunchKernel(Queue, Device, Kernel, nullptr, 0, &LaunchArgs));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
}
TEST_P(olLaunchKernelFooTest, SuccessSynchronous) {
@@ -121,7 +121,7 @@ TEST_P(olLaunchKernelFooTest, SuccessSynchronous) {
} Args{Mem};
ASSERT_SUCCESS(olLaunchKernel(nullptr, Device, Kernel, &Args, sizeof(Args),
- &LaunchArgs, nullptr));
+ &LaunchArgs));
uint32_t *Data = (uint32_t *)Mem;
for (uint32_t i = 0; i < 64; i++) {
@@ -144,10 +144,10 @@ TEST_P(olLaunchKernelLocalMemTest, Success) {
void *Mem;
} Args{Mem};
- ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
- &LaunchArgs, nullptr));
+ ASSERT_SUCCESS(
+ olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *Data = (uint32_t *)Mem;
for (uint32_t i = 0; i < LaunchArgs.GroupSize.x * LaunchArgs.NumGroups.x; i++)
@@ -167,10 +167,10 @@ TEST_P(olLaunchKernelLocalMemReductionTest, Success) {
void *Mem;
} Args{Mem};
- ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
- &LaunchArgs, nullptr));
+ ASSERT_SUCCESS(
+ olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *Data = (uint32_t *)Mem;
for (uint32_t i = 0; i < LaunchArgs.NumGroups.x; i++)
@@ -190,10 +190,10 @@ TEST_P(olLaunchKernelLocalMemStaticTest, Success) {
void *Mem;
} Args{Mem};
- ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
- &LaunchArgs, nullptr));
+ ASSERT_SUCCESS(
+ olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *Data = (uint32_t *)Mem;
for (uint32_t i = 0; i < LaunchArgs.NumGroups.x; i++)
@@ -210,12 +210,12 @@ TEST_P(olLaunchKernelGlobalTest, Success) {
void *Mem;
} Args{Mem};
- ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernels[0], nullptr, 0,
- &LaunchArgs, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(
+ olLaunchKernel(Queue, Device, Kernels[0], nullptr, 0, &LaunchArgs));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernels[1], &Args, sizeof(Args),
- &LaunchArgs, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ &LaunchArgs));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *Data = (uint32_t *)Mem;
for (uint32_t i = 0; i < 64; i++) {
@@ -229,9 +229,8 @@ TEST_P(olLaunchKernelGlobalTest, InvalidNotAKernel) {
ol_symbol_handle_t Global = nullptr;
ASSERT_SUCCESS(
olGetSymbol(Program, "global", OL_SYMBOL_KIND_GLOBAL_VARIABLE, &Global));
- ASSERT_ERROR(
- OL_ERRC_SYMBOL_KIND,
- olLaunchKernel(Queue, Device, Global, nullptr, 0, &LaunchArgs, nullptr));
+ ASSERT_ERROR(OL_ERRC_SYMBOL_KIND,
+ olLaunchKernel(Queue, Device, Global, nullptr, 0, &LaunchArgs));
}
TEST_P(olLaunchKernelGlobalCtorTest, Success) {
@@ -242,9 +241,9 @@ TEST_P(olLaunchKernelGlobalCtorTest, Success) {
void *Mem;
} Args{Mem};
- ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
- &LaunchArgs, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(
+ olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *Data = (uint32_t *)Mem;
for (uint32_t i = 0; i < 64; i++) {
@@ -259,6 +258,6 @@ TEST_P(olLaunchKernelGlobalDtorTest, Success) {
// find/implement a way, update this test. For now we just check that nothing
// crashes
ASSERT_SUCCESS(
- olLaunchKernel(Queue, Device, Kernel, nullptr, 0, &LaunchArgs, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ olLaunchKernel(Queue, Device, Kernel, nullptr, 0, &LaunchArgs));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
}
diff --git a/offload/unittests/OffloadAPI/memory/olMemcpy.cpp b/offload/unittests/OffloadAPI/memory/olMemcpy.cpp
index c1fb6df..cc67d78 100644
--- a/offload/unittests/OffloadAPI/memory/olMemcpy.cpp
+++ b/offload/unittests/OffloadAPI/memory/olMemcpy.cpp
@@ -44,9 +44,8 @@ TEST_P(olMemcpyTest, SuccessHtoD) {
void *Alloc;
ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, Size, &Alloc));
std::vector<uint8_t> Input(Size, 42);
- ASSERT_SUCCESS(
- olMemcpy(Queue, Alloc, Device, Input.data(), Host, Size, nullptr));
- olWaitQueue(Queue);
+ ASSERT_SUCCESS(olMemcpy(Queue, Alloc, Device, Input.data(), Host, Size));
+ olSyncQueue(Queue);
olMemFree(Alloc);
}
@@ -57,11 +56,9 @@ TEST_P(olMemcpyTest, SuccessDtoH) {
std::vector<uint8_t> Output(Size, 0);
ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, Size, &Alloc));
- ASSERT_SUCCESS(
- olMemcpy(Queue, Alloc, Device, Input.data(), Host, Size, nullptr));
- ASSERT_SUCCESS(
- olMemcpy(Queue, Output.data(), Host, Alloc, Device, Size, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olMemcpy(Queue, Alloc, Device, Input.data(), Host, Size));
+ ASSERT_SUCCESS(olMemcpy(Queue, Output.data(), Host, Alloc, Device, Size));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
for (uint8_t Val : Output) {
ASSERT_EQ(Val, 42);
}
@@ -77,13 +74,10 @@ TEST_P(olMemcpyTest, SuccessDtoD) {
ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, Size, &AllocA));
ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, Size, &AllocB));
- ASSERT_SUCCESS(
- olMemcpy(Queue, AllocA, Device, Input.data(), Host, Size, nullptr));
- ASSERT_SUCCESS(
- olMemcpy(Queue, AllocB, Device, AllocA, Device, Size, nullptr));
- ASSERT_SUCCESS(
- olMemcpy(Queue, Output.data(), Host, AllocB, Device, Size, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(olMemcpy(Queue, AllocA, Device, Input.data(), Host, Size));
+ ASSERT_SUCCESS(olMemcpy(Queue, AllocB, Device, AllocA, Device, Size));
+ ASSERT_SUCCESS(olMemcpy(Queue, Output.data(), Host, AllocB, Device, Size));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
for (uint8_t Val : Output) {
ASSERT_EQ(Val, 42);
}
@@ -96,8 +90,8 @@ TEST_P(olMemcpyTest, SuccessHtoHSync) {
std::vector<uint8_t> Input(Size, 42);
std::vector<uint8_t> Output(Size, 0);
- ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Input.data(), Host,
- Size, nullptr));
+ ASSERT_SUCCESS(
+ olMemcpy(nullptr, Output.data(), Host, Input.data(), Host, Size));
for (uint8_t Val : Output) {
ASSERT_EQ(Val, 42);
@@ -111,10 +105,8 @@ TEST_P(olMemcpyTest, SuccessDtoHSync) {
std::vector<uint8_t> Output(Size, 0);
ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, Size, &Alloc));
- ASSERT_SUCCESS(
- olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size, nullptr));
- ASSERT_SUCCESS(
- olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size, nullptr));
+ ASSERT_SUCCESS(olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size));
+ ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size));
for (uint8_t Val : Output) {
ASSERT_EQ(Val, 42);
}
@@ -128,8 +120,7 @@ TEST_P(olMemcpyTest, SuccessSizeZero) {
// As with std::memcpy, size 0 is allowed. Keep all other arguments valid even
// if they aren't used.
- ASSERT_SUCCESS(
- olMemcpy(nullptr, Output.data(), Host, Input.data(), Host, 0, nullptr));
+ ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Input.data(), Host, 0));
}
TEST_P(olMemcpyGlobalTest, SuccessRoundTrip) {
@@ -144,12 +135,12 @@ TEST_P(olMemcpyGlobalTest, SuccessRoundTrip) {
ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
64 * sizeof(uint32_t), &DestMem));
- ASSERT_SUCCESS(olMemcpy(Queue, Addr, Device, SourceMem, Host,
- 64 * sizeof(uint32_t), nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
- ASSERT_SUCCESS(olMemcpy(Queue, DestMem, Host, Addr, Device,
- 64 * sizeof(uint32_t), nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(
+ olMemcpy(Queue, Addr, Device, SourceMem, Host, 64 * sizeof(uint32_t)));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
+ ASSERT_SUCCESS(
+ olMemcpy(Queue, DestMem, Host, Addr, Device, 64 * sizeof(uint32_t)));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *DestData = (uint32_t *)DestMem;
for (uint32_t I = 0; I < 64; I++)
@@ -176,12 +167,12 @@ TEST_P(olMemcpyGlobalTest, SuccessWrite) {
void *Mem;
} Args{DestMem};
- ASSERT_SUCCESS(olMemcpy(Queue, Addr, Device, SourceMem, Host,
- 64 * sizeof(uint32_t), nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(
+ olMemcpy(Queue, Addr, Device, SourceMem, Host, 64 * sizeof(uint32_t)));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
ASSERT_SUCCESS(olLaunchKernel(Queue, Device, ReadKernel, &Args, sizeof(Args),
- &LaunchArgs, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ &LaunchArgs));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *DestData = (uint32_t *)DestMem;
for (uint32_t I = 0; I < 64; I++)
@@ -197,12 +188,12 @@ TEST_P(olMemcpyGlobalTest, SuccessRead) {
LaunchArgs.GroupSize.x * sizeof(uint32_t),
&DestMem));
- ASSERT_SUCCESS(olLaunchKernel(Queue, Device, WriteKernel, nullptr, 0,
- &LaunchArgs, nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
- ASSERT_SUCCESS(olMemcpy(Queue, DestMem, Host, Addr, Device,
- 64 * sizeof(uint32_t), nullptr));
- ASSERT_SUCCESS(olWaitQueue(Queue));
+ ASSERT_SUCCESS(
+ olLaunchKernel(Queue, Device, WriteKernel, nullptr, 0, &LaunchArgs));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
+ ASSERT_SUCCESS(
+ olMemcpy(Queue, DestMem, Host, Addr, Device, 64 * sizeof(uint32_t)));
+ ASSERT_SUCCESS(olSyncQueue(Queue));
uint32_t *DestData = (uint32_t *)DestMem;
for (uint32_t I = 0; I < 64; I++)
diff --git a/offload/unittests/OffloadAPI/queue/olWaitQueue.cpp b/offload/unittests/OffloadAPI/queue/olSyncQueue.cpp
index 5079444..f07ebbd 100644
--- a/offload/unittests/OffloadAPI/queue/olWaitQueue.cpp
+++ b/offload/unittests/OffloadAPI/queue/olSyncQueue.cpp
@@ -1,4 +1,4 @@
-//===------- Offload API tests - olWaitQueue ------------------------------===//
+//===------- Offload API tests - olSyncQueue ------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -10,9 +10,9 @@
#include <OffloadAPI.h>
#include <gtest/gtest.h>
-using olWaitQueueTest = OffloadQueueTest;
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olWaitQueueTest);
+using olSyncQueueTest = OffloadQueueTest;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olSyncQueueTest);
-TEST_P(olWaitQueueTest, SuccessEmptyQueue) {
- ASSERT_SUCCESS(olWaitQueue(Queue));
+TEST_P(olSyncQueueTest, SuccessEmptyQueue) {
+ ASSERT_SUCCESS(olSyncQueue(Queue));
}
diff --git a/offload/unittests/OffloadAPI/queue/olWaitEvents.cpp b/offload/unittests/OffloadAPI/queue/olWaitEvents.cpp
new file mode 100644
index 0000000..9838562
--- /dev/null
+++ b/offload/unittests/OffloadAPI/queue/olWaitEvents.cpp
@@ -0,0 +1,151 @@
+//===------- Offload API tests - olWaitEvents -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../common/Fixtures.hpp"
+#include <OffloadAPI.h>
+#include <gtest/gtest.h>
+
+struct olWaitEventsTest : OffloadProgramTest {
+ void SetUp() override {
+ RETURN_ON_FATAL_FAILURE(OffloadProgramTest::SetUpWith("sequence"));
+ ASSERT_SUCCESS(
+ olGetSymbol(Program, "sequence", OL_SYMBOL_KIND_KERNEL, &Kernel));
+ LaunchArgs.Dimensions = 1;
+ LaunchArgs.GroupSize = {1, 1, 1};
+ LaunchArgs.NumGroups = {1, 1, 1};
+ LaunchArgs.DynSharedMemory = 0;
+ }
+
+ void TearDown() override {
+ RETURN_ON_FATAL_FAILURE(OffloadProgramTest::TearDown());
+ }
+
+ ol_symbol_handle_t Kernel = nullptr;
+ ol_kernel_launch_size_args_t LaunchArgs{};
+};
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olWaitEventsTest);
+
+TEST_P(olWaitEventsTest, Success) {
+ constexpr size_t NUM_KERNELS = 16;
+ ol_queue_handle_t Queues[NUM_KERNELS];
+ ol_event_handle_t Events[NUM_KERNELS];
+
+ void *Mem;
+ ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
+ NUM_KERNELS * sizeof(uint32_t), &Mem));
+ struct {
+ uint32_t Idx;
+ void *Mem;
+ } Args{0, Mem};
+
+ for (size_t I = 0; I < NUM_KERNELS; I++) {
+ Args.Idx = I;
+
+ ASSERT_SUCCESS(olCreateQueue(Device, &Queues[I]));
+
+ if (I > 0)
+ ASSERT_SUCCESS(olWaitEvents(Queues[I], &Events[I - 1], 1));
+
+ ASSERT_SUCCESS(olLaunchKernel(Queues[I], Device, Kernel, &Args,
+ sizeof(Args), &LaunchArgs));
+ ASSERT_SUCCESS(olCreateEvent(Queues[I], &Events[I]));
+ }
+
+ ASSERT_SUCCESS(olSyncEvent(Events[NUM_KERNELS - 1]));
+
+ uint32_t *Data = (uint32_t *)Mem;
+ for (uint32_t i = 2; i < NUM_KERNELS; i++) {
+ ASSERT_EQ(Data[i], Data[i - 1] + Data[i - 2]);
+ }
+}
+
+TEST_P(olWaitEventsTest, SuccessSingleQueue) {
+ constexpr size_t NUM_KERNELS = 16;
+ ol_queue_handle_t Queue;
+ ol_event_handle_t Events[NUM_KERNELS];
+
+ ASSERT_SUCCESS(olCreateQueue(Device, &Queue));
+
+ void *Mem;
+ ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
+ NUM_KERNELS * sizeof(uint32_t), &Mem));
+ struct {
+ uint32_t Idx;
+ void *Mem;
+ } Args{0, Mem};
+
+ for (size_t I = 0; I < NUM_KERNELS; I++) {
+ Args.Idx = I;
+
+ if (I > 0)
+ ASSERT_SUCCESS(olWaitEvents(Queue, &Events[I - 1], 1));
+
+ ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
+ &LaunchArgs));
+ ASSERT_SUCCESS(olCreateEvent(Queue, &Events[I]));
+ }
+
+ ASSERT_SUCCESS(olSyncEvent(Events[NUM_KERNELS - 1]));
+
+ uint32_t *Data = (uint32_t *)Mem;
+ for (uint32_t i = 2; i < NUM_KERNELS; i++) {
+ ASSERT_EQ(Data[i], Data[i - 1] + Data[i - 2]);
+ }
+}
+
+TEST_P(olWaitEventsTest, SuccessMultipleEvents) {
+ constexpr size_t NUM_KERNELS = 16;
+ ol_queue_handle_t Queues[NUM_KERNELS];
+ ol_event_handle_t Events[NUM_KERNELS];
+
+ void *Mem;
+ ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
+ NUM_KERNELS * sizeof(uint32_t), &Mem));
+ struct {
+ uint32_t Idx;
+ void *Mem;
+ } Args{0, Mem};
+
+ for (size_t I = 0; I < NUM_KERNELS; I++) {
+ Args.Idx = I;
+
+ ASSERT_SUCCESS(olCreateQueue(Device, &Queues[I]));
+
+ if (I > 0)
+ ASSERT_SUCCESS(olWaitEvents(Queues[I], Events, I));
+
+ ASSERT_SUCCESS(olLaunchKernel(Queues[I], Device, Kernel, &Args,
+ sizeof(Args), &LaunchArgs));
+ ASSERT_SUCCESS(olCreateEvent(Queues[I], &Events[I]));
+ }
+
+ ASSERT_SUCCESS(olSyncEvent(Events[NUM_KERNELS - 1]));
+
+ uint32_t *Data = (uint32_t *)Mem;
+ for (uint32_t i = 2; i < NUM_KERNELS; i++) {
+ ASSERT_EQ(Data[i], Data[i - 1] + Data[i - 2]);
+ }
+}
+
+TEST_P(olWaitEventsTest, InvalidNullQueue) {
+ ol_event_handle_t Event;
+ ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olWaitEvents(nullptr, &Event, 1));
+}
+
+TEST_P(olWaitEventsTest, InvalidNullEvent) {
+ ol_queue_handle_t Queue;
+ ASSERT_SUCCESS(olCreateQueue(Device, &Queue));
+ ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER, olWaitEvents(Queue, nullptr, 1));
+}
+
+TEST_P(olWaitEventsTest, InvalidNullInnerEvent) {
+ ol_queue_handle_t Queue;
+ ASSERT_SUCCESS(olCreateQueue(Device, &Queue));
+ ol_event_handle_t Event = nullptr;
+ ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olWaitEvents(Queue, &Event, 1));
+}