Skip to content

Changes CUDA unit tests to call PI operations through plugin #3

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Feb 13, 2020
Merged

Changes CUDA unit tests to call PI operations through plugin #3

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion sycl/.clang-format
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,2 +1 @@
BasedOnStyle: LLVM
TypenameMacros: ['PI_CALL' ,'PI_CALL_THROW', 'PI_CALL_NOCHECK']
68 changes: 43 additions & 25 deletions sycl/unittests/pi/EnqueueMemTest.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,13 +7,16 @@
//===----------------------------------------------------------------------===//

#include <CL/sycl/detail/pi.hpp>
#include <CL/sycl/detail/plugin.hpp>
#include <gtest/gtest.h>

using namespace cl::sycl;

namespace {
class DISABLED_EnqueueMemTest : public ::testing::Test {
protected:
std::vector<detail::plugin> Plugins;

constexpr static size_t _numElementsX = 8;
constexpr static size_t _numElementsY = 4;

Expand All @@ -27,30 +30,42 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
~DISABLED_EnqueueMemTest() = default;

void SetUp() override {
detail::pi::initialize();
Plugins = detail::pi::initialize();
ASSERT_FALSE(Plugins.empty());

pi_platform platform = nullptr;
ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(1, &platform, nullptr)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
1, &platform, nullptr)),
PI_SUCCESS);

ASSERT_EQ(
(PI_CALL_NOCHECK(piDevicesGet)(platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
PI_SUCCESS);

pi_result result = PI_INVALID_VALUE;
result = PI_CALL_NOCHECK(piContextCreate)(nullptr, 1u, &_device, nullptr, nullptr, &_context);
result = Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
nullptr, 1u, &_device, nullptr, nullptr, &_context);
ASSERT_EQ(result, PI_SUCCESS);

ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(_context, _device, 0, &_queue)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
_context, _device, 0, &_queue)),
PI_SUCCESS);

ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(
_context, 0, _numElementsX * _numElementsY * sizeof(pi_int32),
nullptr, &_mem)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
_context, 0, _numElementsX * _numElementsY * sizeof(pi_int32),
nullptr, &_mem)),
PI_SUCCESS);
}

void TearDown() override {
ASSERT_EQ((PI_CALL_NOCHECK(piMemRelease)(_mem)), PI_SUCCESS);
ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(_queue)), PI_SUCCESS);
ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(_context)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
_context)),
PI_SUCCESS);
}

template <typename T> void TestBufferFill(const T &pattern) {
Expand All @@ -61,21 +76,24 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
ASSERT_NE(pattern, inValues[i]);
}

ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)(_queue, _mem, PI_TRUE, 0,
_numElementsX * sizeof(T),
inValues, 0, nullptr, nullptr)),
PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
_queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues, 0,
nullptr, nullptr)),
PI_SUCCESS);

ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferFill)(_queue, _mem, &pattern, sizeof(T), 0,
sizeof(inValues), 0, nullptr,
nullptr)),
PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferFill>(
_queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0, nullptr,
nullptr)),
PI_SUCCESS);

T outValues[_numElementsX] = {};
ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferRead)(_queue, _mem, PI_TRUE, 0,
_numElementsX * sizeof(T),
outValues, 0, nullptr, nullptr)),
PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
_queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), outValues, 0,
nullptr, nullptr)),
PI_SUCCESS);

for (size_t i = 0; i < _numElementsX; ++i) {
ASSERT_EQ(pattern, outValues[i]);
Expand Down
148 changes: 103 additions & 45 deletions sycl/unittests/pi/EventTest.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//

#include "CL/sycl/detail/pi.hpp"
#include <CL/sycl/detail/plugin.hpp>
#include <atomic>
#include <gtest/gtest.h>
#include <thread>
Expand All @@ -16,6 +17,8 @@ using namespace cl::sycl;
namespace pi {
class DISABLED_EventTest : public ::testing::Test {
protected:
std::vector<detail::plugin> Plugins;

pi_platform _platform;
pi_context _context;
pi_queue _queue;
Expand All @@ -25,39 +28,50 @@ class DISABLED_EventTest : public ::testing::Test {
DISABLED_EventTest()
: _context{nullptr}, _queue{nullptr}, _device{nullptr},
_result{PI_INVALID_VALUE} {
detail::pi::initialize();
Plugins = detail::pi::initialize();
}

~DISABLED_EventTest() override = default;

void SetUp() override {
pi_uint32 numPlatforms = 0;
ASSERT_FALSE(Plugins.empty());

ASSERT_EQ((PI_CALL_NOCHECK(piPlatformsGet)(0, nullptr, &numPlatforms)),
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
0, nullptr, &numPlatforms)),
PI_SUCCESS)
<< "piPlatformsGet failed.\n";

ASSERT_EQ(
(PI_CALL_NOCHECK(piPlatformsGet)(numPlatforms, &_platform, nullptr)),
PI_SUCCESS)
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
numPlatforms, &_platform, nullptr)),
PI_SUCCESS)
<< "piPlatformsGet failed.\n";
(void)numPlatforms; // Deal with unused variable warning

ASSERT_EQ((PI_CALL_NOCHECK(piDevicesGet)(_platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
_platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
PI_SUCCESS);

ASSERT_EQ((PI_CALL_NOCHECK(piContextCreate)(nullptr, 1, &_device, nullptr, nullptr, &_context)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
nullptr, 1, &_device, nullptr, nullptr, &_context)),
PI_SUCCESS);

ASSERT_EQ((PI_CALL_NOCHECK(piQueueCreate)(_context, _device, 0, &_queue)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
_context, _device, 0, &_queue)),
PI_SUCCESS);

_result = PI_INVALID_VALUE;
}

void TearDown() override {

ASSERT_EQ((PI_CALL_NOCHECK(piQueueRelease)(_queue)), PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
PI_SUCCESS);

ASSERT_EQ((PI_CALL_NOCHECK(piContextRelease)(_context)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
_context)),
PI_SUCCESS);
}
};

Expand All @@ -66,84 +80,111 @@ class DISABLED_EventTest : public ::testing::Test {

TEST_F(DISABLED_EventTest, PICreateEvent) {
pi_event foo;
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
&foo)),
PI_SUCCESS);
ASSERT_NE(foo, nullptr);

EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
PI_SUCCESS);
}

TEST_F(DISABLED_EventTest, piEventGetInfo) {

pi_event foo;
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
&foo)),
PI_SUCCESS);
ASSERT_NE(foo, nullptr);

pi_uint64 paramValue = 0;
pi_uint64 retSize = 0;
EXPECT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
&paramValue, &retSize)),
PI_SUCCESS);

EXPECT_EQ(retSize, sizeof(pi_int32));
EXPECT_EQ(paramValue, PI_EVENT_SUBMITTED);

EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
PI_SUCCESS);
}

TEST_F(DISABLED_EventTest, piEventSetStatus) {

pi_event foo;
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
&foo)),
PI_SUCCESS);
ASSERT_NE(foo, nullptr);

pi_event_status paramValue = PI_EVENT_QUEUED;
size_t retSize = 0u;
PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize);
Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
&paramValue, &retSize);

EXPECT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(foo, PI_EVENT_COMPLETE)), PI_SUCCESS);
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
foo, PI_EVENT_COMPLETE)),
PI_SUCCESS);

paramValue = {};
retSize = 0u;
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
&paramValue, &retSize)),
PI_SUCCESS);
ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);

EXPECT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
PI_SUCCESS);
}

TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) {

pi_event foo;
ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &foo)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
&foo)),
PI_SUCCESS);
ASSERT_NE(foo, nullptr);

pi_event_status paramValue = {};
size_t retSize = 0u;
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
&paramValue, &retSize)),
PI_SUCCESS);
ASSERT_EQ(paramValue, PI_EVENT_SUBMITTED);

std::atomic<bool> started{false};

auto tWaiter = std::thread([&]() {
started = true;
ASSERT_EQ((PI_CALL_NOCHECK(piEventsWait)(1, &foo)), PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &foo)),
PI_SUCCESS);
});

while (!started) {
};

ASSERT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(foo, PI_EVENT_COMPLETE)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
foo, PI_EVENT_COMPLETE)),
PI_SUCCESS);

tWaiter.join();

paramValue = {};
retSize = 0u;
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
&paramValue, &retSize)),
PI_SUCCESS);
ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);

ASSERT_EQ((PI_CALL_NOCHECK(piEventRelease)(foo)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
PI_SUCCESS);
}

TEST_F(DISABLED_EventTest, piEnqueueEventsWait) {
Expand All @@ -154,39 +195,56 @@ TEST_F(DISABLED_EventTest, piEnqueueEventsWait) {
constexpr const size_t bytes = sizeof(data);

pi_mem memObj;
ASSERT_EQ((PI_CALL_NOCHECK(piMemBufferCreate)(_context, PI_MEM_FLAGS_ACCESS_RW, bytes,
nullptr, &memObj)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
_context, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)),
PI_SUCCESS);

pi_event events[4] = {nullptr, nullptr, nullptr, nullptr};

ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferWrite)(_queue, memObj, true, 0, bytes, data, 0,
nullptr, &events[0])), PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
_queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])),
PI_SUCCESS);
ASSERT_NE(events[0], nullptr);

ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueMemBufferRead)(_queue, memObj, true, 0, bytes, output,
0, nullptr, &events[1])), PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
_queue, memObj, true, 0, bytes, output, 0, nullptr, &events[1])),
PI_SUCCESS);
ASSERT_NE(events[1], nullptr);

ASSERT_EQ((PI_CALL_NOCHECK(piEventCreate)(_context, &events[2])), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(
_context, &events[2])),
PI_SUCCESS);
ASSERT_NE(events[2], nullptr);

ASSERT_EQ((PI_CALL_NOCHECK(piEnqueueEventsWait)(_queue, 3, events, &events[3])), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueEventsWait>(
_queue, 3, events, &events[3])),
PI_SUCCESS);
ASSERT_NE(events[3], nullptr);

pi_event_status paramValue = {};
size_t retSize = 0u;
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)),
PI_SUCCESS);
ASSERT_NE(paramValue, PI_EVENT_COMPLETE);

ASSERT_EQ((PI_CALL_NOCHECK(piEventSetStatus)(events[2], PI_EVENT_COMPLETE)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
events[2], PI_EVENT_COMPLETE)),
PI_SUCCESS);

ASSERT_EQ((PI_CALL_NOCHECK(piEventsWait)(1, &events[3])), PI_SUCCESS);
ASSERT_EQ(
(Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &events[3])),
PI_SUCCESS);

paramValue = {};
retSize = 0u;
ASSERT_EQ((PI_CALL_NOCHECK(piEventGetInfo)(events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)), PI_SUCCESS);
ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
sizeof(paramValue), &paramValue, &retSize)),
PI_SUCCESS);
ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);
}

Expand Down
Loading