mirror of
https://github.com/intel/compute-runtime.git
synced 2025-12-24 21:18:24 +08:00
Improve build time: command_queue tests
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com> Change-Id: Ia80a8bfed28789c6c7a53478cdd56f883d61adf3
This commit is contained in:
Dunajski, Bartosz
committed by
sys_ocldev
sys_ocldev
parent
54572163d8
commit
41811852db
@@ -1,263 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2017 - 2018, Intel Corporation
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "unit_tests/fixtures/hello_world_fixture.h"
|
||||
#include "unit_tests/fixtures/image_fixture.h"
|
||||
#include "unit_tests/mocks/mock_buffer.h"
|
||||
|
||||
class clEventWrapper {
|
||||
public:
|
||||
clEventWrapper() { mMem = NULL; }
|
||||
clEventWrapper(cl_event mem) { mMem = mem; }
|
||||
clEventWrapper(const clEventWrapper &rhs) : mMem(rhs.mMem) {
|
||||
if (mMem != NULL)
|
||||
clRetainEvent(mMem);
|
||||
}
|
||||
~clEventWrapper() {
|
||||
if (mMem != NULL)
|
||||
clReleaseEvent(mMem);
|
||||
}
|
||||
clEventWrapper &operator=(const cl_event &rhs) {
|
||||
mMem = rhs;
|
||||
return *this;
|
||||
}
|
||||
clEventWrapper &operator=(clEventWrapper rhs) {
|
||||
std::swap(mMem, rhs.mMem);
|
||||
return *this;
|
||||
}
|
||||
operator cl_event() const { return mMem; }
|
||||
cl_event *operator&() { return &mMem; }
|
||||
bool operator==(const cl_event &rhs) { return mMem == rhs; }
|
||||
|
||||
protected:
|
||||
cl_event mMem;
|
||||
};
|
||||
|
||||
using namespace OCLRT;
|
||||
|
||||
namespace ULT {
|
||||
|
||||
struct EnqueueWaitlistTest;
|
||||
|
||||
typedef HelloWorldTestWithParam<HelloWorldFixtureFactory> EnqueueWaitlistFixture;
|
||||
typedef void (*ExecuteEnqueue)(EnqueueWaitlistTest *, uint32_t /*cl_uint*/, cl_event *, cl_event *, bool);
|
||||
|
||||
struct EnqueueWaitlistTest : public EnqueueWaitlistFixture,
|
||||
public ::testing::TestWithParam<ExecuteEnqueue> {
|
||||
public:
|
||||
typedef CommandQueueHwFixture CommandQueueFixture;
|
||||
using CommandQueueHwFixture::pCmdQ;
|
||||
|
||||
EnqueueWaitlistTest(void) {
|
||||
buffer = nullptr;
|
||||
}
|
||||
|
||||
void SetUp() override {
|
||||
EnqueueWaitlistFixture::SetUp();
|
||||
buffer = BufferHelper<>::create();
|
||||
bufferNonZeroCopy = new UnalignedBuffer;
|
||||
image = Image1dHelper<>::create(BufferDefaults::context);
|
||||
imageNonZeroCopy = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(BufferDefaults::context);
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
buffer->decRefInternal();
|
||||
bufferNonZeroCopy->decRefInternal();
|
||||
image->decRefInternal();
|
||||
imageNonZeroCopy->decRefInternal();
|
||||
EnqueueWaitlistFixture::TearDown();
|
||||
}
|
||||
|
||||
cl_int retVal = CL_SUCCESS;
|
||||
cl_int error = CL_SUCCESS;
|
||||
|
||||
Buffer *buffer;
|
||||
Buffer *bufferNonZeroCopy;
|
||||
Image *image;
|
||||
Image *imageNonZeroCopy;
|
||||
|
||||
void test_error(cl_int error, std::string str) {
|
||||
EXPECT_EQ(CL_SUCCESS, error) << str << std::endl;
|
||||
}
|
||||
|
||||
static void EnqueueNDRange(EnqueueWaitlistTest *test, cl_uint numWaits, cl_event *waits, cl_event *outEvent, bool blocking = false) {
|
||||
size_t threadNum = 10;
|
||||
size_t threads[1] = {threadNum};
|
||||
cl_int error = clEnqueueNDRangeKernel(test->pCmdQ, test->pKernel, 1, NULL, threads, threads, numWaits, waits, outEvent);
|
||||
test->test_error(error, "Unable to execute kernel");
|
||||
return;
|
||||
}
|
||||
|
||||
static void EnqueueMapBuffer(EnqueueWaitlistTest *test, cl_uint numWaits, cl_event *waits, cl_event *outEvent, bool blocking = false) {
|
||||
cl_int error;
|
||||
void *mappedPtr = clEnqueueMapBuffer(test->pCmdQ, test->buffer, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ, 0, test->buffer->getSize(), numWaits, waits, outEvent, &error);
|
||||
EXPECT_NE(nullptr, mappedPtr);
|
||||
test->test_error(error, "Unable to enqueue buffer map");
|
||||
error = clEnqueueUnmapMemObject(test->pCmdQ, test->buffer, mappedPtr, 0, nullptr, nullptr);
|
||||
return;
|
||||
}
|
||||
|
||||
static void TwoEnqueueMapBuffer(EnqueueWaitlistTest *test, cl_uint numWaits, cl_event *waits, cl_event *outEvent, bool blocking = false) {
|
||||
cl_int error;
|
||||
void *mappedPtr = clEnqueueMapBuffer(test->pCmdQ, test->buffer, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ, 0, test->buffer->getSize(), numWaits, waits, outEvent, &error);
|
||||
EXPECT_NE(nullptr, mappedPtr);
|
||||
test->test_error(error, "Unable to enqueue buffer map");
|
||||
|
||||
void *mappedPtr2 = clEnqueueMapBuffer(test->pCmdQ, test->bufferNonZeroCopy, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ, 0, test->bufferNonZeroCopy->getSize(), 0, nullptr, nullptr, &error);
|
||||
EXPECT_NE(nullptr, mappedPtr2);
|
||||
test->test_error(error, "Unable to enqueue buffer map");
|
||||
|
||||
error = clEnqueueUnmapMemObject(test->pCmdQ, test->buffer, mappedPtr, 0, nullptr, nullptr);
|
||||
error = clEnqueueUnmapMemObject(test->pCmdQ, test->bufferNonZeroCopy, mappedPtr2, 0, nullptr, nullptr);
|
||||
|
||||
return;
|
||||
}
|
||||
static void EnqueueUnMapBuffer(EnqueueWaitlistTest *test, cl_uint numWaits, cl_event *waits, cl_event *outEvent, bool blocking = false) {
|
||||
cl_int error;
|
||||
void *mappedPtr = clEnqueueMapBuffer(test->pCmdQ, test->buffer, CL_TRUE, CL_MAP_READ, 0, test->buffer->getSize(), 0, nullptr, nullptr, &error);
|
||||
EXPECT_NE(nullptr, mappedPtr);
|
||||
ASSERT_NE(test->buffer, nullptr);
|
||||
error = clEnqueueUnmapMemObject(test->pCmdQ, test->buffer, mappedPtr, numWaits, waits, outEvent);
|
||||
test->test_error(error, "Unable to unmap buffer");
|
||||
return;
|
||||
}
|
||||
static void EnqueueMapImage(EnqueueWaitlistTest *test, cl_uint numWaits, cl_event *waits, cl_event *outEvent, bool blocking = false) {
|
||||
cl_int error;
|
||||
cl_image_desc desc = test->image->getImageDesc();
|
||||
size_t origin[3] = {0, 0, 0}, region[3] = {desc.image_width, desc.image_height, 1};
|
||||
size_t outPitch;
|
||||
|
||||
void *mappedPtr = clEnqueueMapImage(test->pCmdQ, test->image, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ, origin, region, &outPitch, NULL, numWaits, waits, outEvent, &error);
|
||||
test->test_error(error, "Unable to enqueue image map");
|
||||
EXPECT_NE(nullptr, mappedPtr);
|
||||
test->test_error(error, "Unable to enqueue buffer map");
|
||||
error = clEnqueueUnmapMemObject(test->pCmdQ, test->image, mappedPtr, 0, nullptr, nullptr);
|
||||
return;
|
||||
}
|
||||
|
||||
static void TwoEnqueueMapImage(EnqueueWaitlistTest *test, cl_uint numWaits, cl_event *waits, cl_event *outEvent, bool blocking = false) {
|
||||
cl_int error;
|
||||
cl_image_desc desc = test->image->getImageDesc();
|
||||
size_t origin[3] = {0, 0, 0}, region[3] = {desc.image_width, desc.image_height, 1};
|
||||
size_t outPitch;
|
||||
|
||||
size_t origin2[3] = {0, 0, 0}, region2[3] = {desc.image_width, desc.image_height, 1};
|
||||
size_t outPitch2;
|
||||
|
||||
void *mappedPtr = clEnqueueMapImage(test->pCmdQ, test->image, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ, origin, region, &outPitch, NULL, numWaits, waits, outEvent, &error);
|
||||
test->test_error(error, "Unable to enqueue image map");
|
||||
EXPECT_NE(nullptr, mappedPtr);
|
||||
test->test_error(error, "Unable to enqueue buffer map");
|
||||
|
||||
void *mappedPtr2 = clEnqueueMapImage(test->pCmdQ, test->imageNonZeroCopy, blocking ? CL_TRUE : CL_FALSE, CL_MAP_READ, origin2, region2, &outPitch2, NULL, 0, nullptr, nullptr, &error);
|
||||
test->test_error(error, "Unable to enqueue image map");
|
||||
EXPECT_NE(nullptr, mappedPtr2);
|
||||
test->test_error(error, "Unable to enqueue buffer map");
|
||||
|
||||
error = clEnqueueUnmapMemObject(test->pCmdQ, test->image, mappedPtr, 0, nullptr, nullptr);
|
||||
error = clEnqueueUnmapMemObject(test->pCmdQ, test->imageNonZeroCopy, mappedPtr2, 0, nullptr, nullptr);
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_P(EnqueueWaitlistTest, BlockingWaitlist) {
|
||||
|
||||
// Set up a user event, which we use as a gate for the second event
|
||||
clEventWrapper gateEvent = clCreateUserEvent(context, &error);
|
||||
test_error(error, "Unable to set up user gate event");
|
||||
|
||||
// Set up the execution of the action with its actual event
|
||||
clEventWrapper actualEvent;
|
||||
|
||||
// call the function to execute
|
||||
GetParam()(this, 1, &gateEvent, &actualEvent, false);
|
||||
|
||||
// Now release the user event, which will allow our actual action to run
|
||||
error = clSetUserEventStatus(gateEvent, CL_COMPLETE);
|
||||
test_error(error, "Unable to trigger gate event");
|
||||
|
||||
// Now we wait for completion. Note that we can actually wait on the event itself, at least at first
|
||||
error = clWaitForEvents(1, &actualEvent);
|
||||
test_error(error, "Unable to wait for actual test event");
|
||||
}
|
||||
|
||||
typedef EnqueueWaitlistTest EnqueueWaitlistTestTwoMapEnqueues;
|
||||
TEST_P(EnqueueWaitlistTestTwoMapEnqueues, TestPreviousVirtualEvent) {
|
||||
|
||||
// Set up a user event, which we use as a gate for the second event
|
||||
clEventWrapper gateEvent = clCreateUserEvent(context, &error);
|
||||
test_error(error, "Unable to set up user gate event");
|
||||
|
||||
// Set up the execution of the action with its actual event
|
||||
clEventWrapper actualEvent;
|
||||
|
||||
// call the function to execute
|
||||
GetParam()(this, 1, &gateEvent, &actualEvent, false);
|
||||
|
||||
// Now release the user event, which will allow our actual action to run
|
||||
error = clSetUserEventStatus(gateEvent, CL_COMPLETE);
|
||||
|
||||
// Now we wait for completion. Note that we can actually wait on the event itself, at least at first
|
||||
error = clWaitForEvents(1, &actualEvent);
|
||||
test_error(error, "Unable to wait for actual test event");
|
||||
}
|
||||
|
||||
TEST_P(EnqueueWaitlistTest, BlockingWaitlistNoOutEvent) {
|
||||
|
||||
// Set up a user event, which we use as a gate for the second event
|
||||
clEventWrapper gateEvent = clCreateUserEvent(context, &error);
|
||||
test_error(error, "Unable to set up user gate event");
|
||||
|
||||
// call the function to execute
|
||||
GetParam()(this, 1, &gateEvent, nullptr, false);
|
||||
|
||||
// Now release the user event, which will allow our actual action to run
|
||||
error = clSetUserEventStatus(gateEvent, CL_COMPLETE);
|
||||
test_error(error, "Unable to trigger gate event");
|
||||
|
||||
// Now we wait for completion. Note that we can actually wait on the event itself, at least at first
|
||||
error = clFinish(pCmdQ);
|
||||
test_error(error, "Finish FAILED");
|
||||
}
|
||||
|
||||
ExecuteEnqueue Enqueues[] =
|
||||
{
|
||||
&EnqueueWaitlistTest::EnqueueNDRange,
|
||||
&EnqueueWaitlistTest::EnqueueMapBuffer,
|
||||
&EnqueueWaitlistTest::EnqueueUnMapBuffer,
|
||||
&EnqueueWaitlistTest::EnqueueMapImage};
|
||||
|
||||
ExecuteEnqueue TwoEnqueueMap[] =
|
||||
{
|
||||
&EnqueueWaitlistTest::TwoEnqueueMapBuffer,
|
||||
&EnqueueWaitlistTest::TwoEnqueueMapImage};
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
UnblockedEvent,
|
||||
EnqueueWaitlistTest,
|
||||
::testing::ValuesIn(Enqueues));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(
|
||||
TwoEnqueueMap,
|
||||
EnqueueWaitlistTestTwoMapEnqueues,
|
||||
::testing::ValuesIn(TwoEnqueueMap));
|
||||
} // namespace ULT
|
||||
Reference in New Issue
Block a user