Initial source drop of ocltst
This only adds source files for ocltst and the following test modules - oclruntime, oclperf, oclgl, ocldx. There's no build files for now.
Change-Id: I0f8d9d074c45d82e92f7d30bf22753102f272f4f
[ROCm/clr commit: 75e6add24d]
This commit is contained in:
Vlad Sytchenko
committed by
Vladislav Sytchenko
Vladislav Sytchenko
parent
a5f661537b
commit
18ce996fe2
@@ -0,0 +1,515 @@
|
||||
/* Copyright (c) 2010-present Advanced Micro Devices, Inc.
|
||||
|
||||
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 "OCLSDI.h"
|
||||
|
||||
#include "Timer.h"
|
||||
#define NUM_TESTS 6
|
||||
|
||||
#include <cmath>
|
||||
|
||||
typedef struct _threadInfo {
|
||||
int threadID_;
|
||||
OCLSDI* testObj_;
|
||||
} ThreadInfo;
|
||||
const char* kernel_str_ =
|
||||
"__kernel void test_kernel(global unsigned int * A) \
|
||||
{ \
|
||||
int id = get_global_id(0); \
|
||||
A[id] = id + 2;\
|
||||
} ";
|
||||
const char* testNames[NUM_TESTS] = {
|
||||
"WriteBuffer", "CopyBuffer", "NDRangeKernel",
|
||||
"MapBuffer", "WriteBufferRect", "CopyImageToBuffer",
|
||||
};
|
||||
|
||||
void* ThreadMain(void* data) {
|
||||
if (data == NULL) {
|
||||
return 0;
|
||||
}
|
||||
ThreadInfo* threadData = (ThreadInfo*)data;
|
||||
threadData->testObj_->threadEntry(threadData->threadID_);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
OCLSDI::OCLSDI() {
|
||||
// If there are two different gpus in the system,
|
||||
// we have to test each of them as sender and receiver
|
||||
_numSubTests = 2 * NUM_TESTS;
|
||||
}
|
||||
|
||||
OCLSDI::~OCLSDI() {}
|
||||
|
||||
void OCLSDI::open(unsigned int test, char* units, double& conversion,
|
||||
unsigned int deviceId) {
|
||||
cl_uint numPlatforms = 0;
|
||||
cl_platform_id platform = NULL;
|
||||
cl_uint num_devices = 0;
|
||||
_crcword = 0;
|
||||
conversion = 1.0f;
|
||||
program_ = 0;
|
||||
kernel_ = 0;
|
||||
srcBuff_ = 0;
|
||||
_openTest = test % NUM_TESTS;
|
||||
bufSize_ = 0x10000;
|
||||
error_ = 0;
|
||||
markerValue_ = 0x12345;
|
||||
inputArr_ = 0;
|
||||
outputArr_ = 0;
|
||||
success_ = true;
|
||||
extPhysicalBuff_ = 0;
|
||||
silentFailure = false;
|
||||
busAddressableBuff_ = 0;
|
||||
devices_[0] = devices_[1] = 0;
|
||||
contexts_[0] = contexts_[1] = 0;
|
||||
cmd_queues_[0] = cmd_queues_[1] = 0;
|
||||
image_ = 0;
|
||||
|
||||
inputArr_ = (cl_uint*)malloc(bufSize_);
|
||||
outputArr_ = (cl_uint*)malloc(bufSize_);
|
||||
for (unsigned int i = 0; i < (bufSize_ / sizeof(cl_uint)); ++i) {
|
||||
inputArr_[i] = i + 1;
|
||||
outputArr_[i] = 0;
|
||||
}
|
||||
error_ = _wrapper->clGetPlatformIDs(0, NULL, &numPlatforms);
|
||||
CHECK_RESULT(numPlatforms == 0, "clGetPlatformIDs failed");
|
||||
error_ = _wrapper->clGetPlatformIDs(1, &platform, NULL);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetPlatformIDs failed");
|
||||
error_ = _wrapper->clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL,
|
||||
&num_devices);
|
||||
if (num_devices < 2) {
|
||||
printf("\nSilent Failure: Two GPUs are required to run OCLSdi test\n");
|
||||
silentFailure = true;
|
||||
return;
|
||||
}
|
||||
error_ =
|
||||
_wrapper->clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 2, devices_, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceIDs failed");
|
||||
if (test >= NUM_TESTS) {
|
||||
cl_device_id temp = devices_[0];
|
||||
devices_[0] = devices_[1];
|
||||
devices_[1] = temp;
|
||||
}
|
||||
size_t param_size = 0;
|
||||
char* strExtensions = 0;
|
||||
error_ = _wrapper->clGetDeviceInfo(devices_[0], CL_DEVICE_EXTENSIONS, 0, 0,
|
||||
¶m_size);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
strExtensions = (char*)malloc(param_size);
|
||||
error_ = _wrapper->clGetDeviceInfo(devices_[0], CL_DEVICE_EXTENSIONS,
|
||||
param_size, strExtensions, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
if (strstr(strExtensions, "cl_amd_bus_addressable_memory") == 0) {
|
||||
printf(
|
||||
"\nSilent Failure: cl_amd_bus_addressable_memory extension is not "
|
||||
"enabled on GPU 0\n");
|
||||
silentFailure = true;
|
||||
free(strExtensions);
|
||||
return;
|
||||
}
|
||||
free(strExtensions);
|
||||
error_ = _wrapper->clGetDeviceInfo(devices_[1], CL_DEVICE_EXTENSIONS, 0, 0,
|
||||
¶m_size);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
strExtensions = (char*)malloc(param_size);
|
||||
error_ = _wrapper->clGetDeviceInfo(devices_[1], CL_DEVICE_EXTENSIONS,
|
||||
param_size, strExtensions, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
if (strstr(strExtensions, "cl_amd_bus_addressable_memory") == 0) {
|
||||
printf(
|
||||
"\nSilent Failure: cl_amd_bus_addressable_memory extension is not "
|
||||
"enabled on GPU 1\n");
|
||||
silentFailure = true;
|
||||
free(strExtensions);
|
||||
return;
|
||||
}
|
||||
free(strExtensions);
|
||||
deviceNames_ = " [";
|
||||
param_size = 0;
|
||||
char* strDeviceName = 0;
|
||||
error_ =
|
||||
_wrapper->clGetDeviceInfo(devices_[1], CL_DEVICE_NAME, 0, 0, ¶m_size);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
strDeviceName = (char*)malloc(param_size);
|
||||
error_ = _wrapper->clGetDeviceInfo(devices_[1], CL_DEVICE_NAME, param_size,
|
||||
strDeviceName, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
deviceNames_ = deviceNames_ + strDeviceName;
|
||||
free(strDeviceName);
|
||||
error_ =
|
||||
_wrapper->clGetDeviceInfo(devices_[0], CL_DEVICE_NAME, 0, 0, ¶m_size);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
strDeviceName = (char*)malloc(param_size);
|
||||
error_ = _wrapper->clGetDeviceInfo(devices_[0], CL_DEVICE_NAME, param_size,
|
||||
strDeviceName, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clGetDeviceInfo failed");
|
||||
deviceNames_ = deviceNames_ + "->";
|
||||
deviceNames_ = deviceNames_ + strDeviceName;
|
||||
free(strDeviceName);
|
||||
deviceNames_ = deviceNames_ + "]";
|
||||
cl_context_properties props[3] = {CL_CONTEXT_PLATFORM,
|
||||
(cl_context_properties)platform, 0};
|
||||
contexts_[0] =
|
||||
_wrapper->clCreateContext(props, 1, &devices_[0], 0, 0, &error_);
|
||||
CHECK_RESULT(contexts_[0] == 0, "clCreateContext failed");
|
||||
contexts_[1] =
|
||||
_wrapper->clCreateContext(props, 1, &devices_[1], 0, 0, &error_);
|
||||
CHECK_RESULT(contexts_[1] == 0, "clCreateContext failed");
|
||||
cmd_queues_[0] =
|
||||
_wrapper->clCreateCommandQueue(contexts_[0], devices_[0], 0, NULL);
|
||||
CHECK_RESULT(cmd_queues_[0] == 0, "clCreateCommandQueue failed");
|
||||
cmd_queues_[1] =
|
||||
_wrapper->clCreateCommandQueue(contexts_[1], devices_[1], 0, NULL);
|
||||
CHECK_RESULT(cmd_queues_[1] == 0, "clCreateCommandQueue failed");
|
||||
busAddressableBuff_ = _wrapper->clCreateBuffer(
|
||||
contexts_[0], CL_MEM_BUS_ADDRESSABLE_AMD, bufSize_, 0, &error_);
|
||||
CHECK_RESULT((error_ != CL_SUCCESS), "clCreateBuffer failed");
|
||||
error_ = _wrapper->clEnqueueMakeBuffersResidentAMD(
|
||||
cmd_queues_[0], 1, &busAddressableBuff_, true, &busAddr_, 0, 0, 0);
|
||||
CHECK_RESULT((error_ != CL_SUCCESS),
|
||||
"clEnqueueMakeBuffersResidentAMD failed");
|
||||
extPhysicalBuff_ = _wrapper->clCreateBuffer(
|
||||
contexts_[1], CL_MEM_EXTERNAL_PHYSICAL_AMD, bufSize_, &busAddr_, &error_);
|
||||
CHECK_RESULT((error_ != CL_SUCCESS), "clCreateBuffer failed");
|
||||
error_ = _wrapper->clEnqueueWriteSignalAMD(cmd_queues_[1], extPhysicalBuff_,
|
||||
0, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteSignalAMD failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
srcBuff_ = _wrapper->clCreateBuffer(contexts_[1],
|
||||
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
|
||||
bufSize_, inputArr_, &error_);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clCreateBuffer failed");
|
||||
error_ = _wrapper->clEnqueueMigrateMemObjects(cmd_queues_[1], 1,
|
||||
&extPhysicalBuff_, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_, "clEnqueueMigrateMemObjects failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
error_ = _wrapper->clEnqueueMigrateMemObjects(cmd_queues_[1], 1, &srcBuff_, 0,
|
||||
0, 0, 0);
|
||||
CHECK_RESULT(error_, "clEnqueueMigrateMemObjects failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
if (_openTest == 2) {
|
||||
program_ = _wrapper->clCreateProgramWithSource(contexts_[1], 1,
|
||||
&kernel_str_, NULL, &error_);
|
||||
CHECK_RESULT(error_, "clCreateProgramWithSource failed");
|
||||
error_ =
|
||||
_wrapper->clBuildProgram(program_, 1, &devices_[1], NULL, NULL, NULL);
|
||||
if (error_ != CL_SUCCESS) {
|
||||
char* errorstr;
|
||||
size_t size;
|
||||
_wrapper->clGetProgramBuildInfo(program_, devices_[1],
|
||||
CL_PROGRAM_BUILD_LOG, 0, NULL, &size);
|
||||
errorstr = new char[size];
|
||||
_wrapper->clGetProgramBuildInfo(
|
||||
program_, devices_[1], CL_PROGRAM_BUILD_LOG, size, errorstr, &size);
|
||||
printf("\n%s\n", errorstr);
|
||||
delete[] errorstr;
|
||||
}
|
||||
CHECK_RESULT(error_, "clBuildProgram failed");
|
||||
|
||||
kernel_ = _wrapper->clCreateKernel(program_, "test_kernel", &error_);
|
||||
CHECK_RESULT(error_, "clCreateKernel failed");
|
||||
error_ = _wrapper->clSetKernelArg(kernel_, 0, sizeof(cl_mem),
|
||||
(void*)&extPhysicalBuff_);
|
||||
CHECK_RESULT(error_, "clSetKernelArg failed");
|
||||
}
|
||||
if (_openTest == 5) {
|
||||
cl_image_format format = {CL_R, CL_UNSIGNED_INT32};
|
||||
cl_image_desc desc;
|
||||
desc.image_type = CL_MEM_OBJECT_IMAGE1D;
|
||||
desc.image_width = bufSize_ / sizeof(cl_uint);
|
||||
desc.image_height = 0;
|
||||
desc.image_depth = 0;
|
||||
desc.image_array_size = 0;
|
||||
desc.image_row_pitch = 0;
|
||||
desc.image_slice_pitch = 0;
|
||||
desc.num_mip_levels = 0;
|
||||
desc.num_samples = 0;
|
||||
desc.buffer = (cl_mem)NULL;
|
||||
image_ = _wrapper->clCreateImage(contexts_[1], CL_MEM_READ_ONLY, &format,
|
||||
&desc, 0, &error_);
|
||||
CHECK_RESULT(error_, "clCreateImage failed");
|
||||
}
|
||||
}
|
||||
|
||||
void OCLSDI::run(void) {
|
||||
if (silentFailure) {
|
||||
return;
|
||||
}
|
||||
++markerValue_;
|
||||
OCLutil::Thread threads[2];
|
||||
ThreadInfo threadInfo[2];
|
||||
threadInfo[0].testObj_ = threadInfo[1].testObj_ = this;
|
||||
threadInfo[0].threadID_ = 0;
|
||||
threadInfo[1].threadID_ = 1;
|
||||
threads[0].create(ThreadMain, &threadInfo[0]);
|
||||
threads[1].create(ThreadMain, &threadInfo[1]);
|
||||
threads[0].join();
|
||||
threads[1].join();
|
||||
char* descString = (char*)malloc(25 + deviceNames_.size());
|
||||
sprintf(descString, "%-20s%s", testNames[_openTest], deviceNames_.c_str());
|
||||
testDescString = descString;
|
||||
free(descString);
|
||||
if (!success_) {
|
||||
_errorFlag = true;
|
||||
_crcword += 1;
|
||||
}
|
||||
}
|
||||
|
||||
void OCLSDI::threadEntry(int threadID) {
|
||||
if (silentFailure) {
|
||||
return;
|
||||
}
|
||||
switch (_openTest) {
|
||||
case 0:
|
||||
testEnqueueWriteBuffer(threadID);
|
||||
break;
|
||||
case 1:
|
||||
testEnqueueCopyBuffer(threadID);
|
||||
break;
|
||||
case 2:
|
||||
testEnqueueNDRangeKernel(threadID);
|
||||
break;
|
||||
case 3:
|
||||
testEnqueueMapBuffer(threadID);
|
||||
break;
|
||||
case 4:
|
||||
testEnqueueWriteBufferRect(threadID);
|
||||
break;
|
||||
case 5:
|
||||
testEnqueueCopyImageToBuffer(threadID);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int OCLSDI::close(void) {
|
||||
if (srcBuff_) {
|
||||
error_ = _wrapper->clReleaseMemObject(srcBuff_);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseMemObject failed");
|
||||
}
|
||||
if (extPhysicalBuff_) {
|
||||
error_ = _wrapper->clReleaseMemObject(extPhysicalBuff_);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseMemObject failed");
|
||||
}
|
||||
if (busAddressableBuff_) {
|
||||
error_ = _wrapper->clReleaseMemObject(busAddressableBuff_);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseMemObject failed");
|
||||
}
|
||||
if (cmd_queues_[0]) {
|
||||
error_ = _wrapper->clReleaseCommandQueue(cmd_queues_[0]);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS,
|
||||
"clReleaseCommandQueue failed");
|
||||
}
|
||||
if (cmd_queues_[1]) {
|
||||
error_ = _wrapper->clReleaseCommandQueue(cmd_queues_[1]);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS,
|
||||
"clReleaseCommandQueue failed");
|
||||
}
|
||||
if (contexts_[0]) {
|
||||
error_ = _wrapper->clReleaseContext(contexts_[0]);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseContext failed");
|
||||
}
|
||||
if (contexts_[1]) {
|
||||
error_ = _wrapper->clReleaseContext(contexts_[1]);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseContext failed");
|
||||
}
|
||||
if (program_) {
|
||||
error_ = _wrapper->clReleaseProgram(program_);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseProgram failed");
|
||||
}
|
||||
if (kernel_) {
|
||||
error_ = _wrapper->clReleaseKernel(kernel_);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseKernel failed");
|
||||
}
|
||||
if (image_) {
|
||||
error_ = _wrapper->clReleaseMemObject(image_);
|
||||
CHECK_RESULT_NO_RETURN(error_ != CL_SUCCESS, "clReleaseMemObject failed");
|
||||
}
|
||||
if (inputArr_) {
|
||||
free(inputArr_);
|
||||
}
|
||||
if (outputArr_) {
|
||||
free(outputArr_);
|
||||
}
|
||||
return _crcword;
|
||||
}
|
||||
|
||||
void OCLSDI::readAndVerifyResult() {
|
||||
memset(outputArr_, 0, bufSize_);
|
||||
error_ = _wrapper->clEnqueueWaitSignalAMD(cmd_queues_[0], busAddressableBuff_,
|
||||
markerValue_, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWaitSignalAMD failed");
|
||||
error_ = _wrapper->clEnqueueReadBuffer(cmd_queues_[0], busAddressableBuff_,
|
||||
CL_TRUE, 0, bufSize_, outputArr_, 0, 0,
|
||||
NULL);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueReadBuffer failed");
|
||||
success_ = (memcmp(inputArr_, outputArr_, bufSize_) == 0);
|
||||
}
|
||||
|
||||
void OCLSDI::testEnqueueCopyImageToBuffer(int threadID) {
|
||||
if (threadID == 0) {
|
||||
size_t origin[3] = {0, 0, 0};
|
||||
size_t region[3] = {bufSize_ / sizeof(cl_uint), 1, 1};
|
||||
memset(inputArr_, (_openTest + 1), bufSize_);
|
||||
error_ =
|
||||
_wrapper->clEnqueueWriteImage(cmd_queues_[1], image_, CL_TRUE, origin,
|
||||
region, 0, 0, inputArr_, 0, 0, 0);
|
||||
CHECK_RESULT(error_, "clEnqueueWriteImage failed");
|
||||
_wrapper->clFinish(cmd_queues_[1]);
|
||||
error_ = _wrapper->clEnqueueCopyImageToBuffer(
|
||||
cmd_queues_[1], image_, extPhysicalBuff_, origin, region, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_, "clEnqueueCopyImageToBuffer failed");
|
||||
_wrapper->clFinish(cmd_queues_[1]);
|
||||
error_ = _wrapper->clEnqueueWriteSignalAMD(cmd_queues_[1], extPhysicalBuff_,
|
||||
markerValue_, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteSignalAMD failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
} else {
|
||||
readAndVerifyResult();
|
||||
}
|
||||
}
|
||||
|
||||
void OCLSDI::testEnqueueWriteBufferRect(int threadID) {
|
||||
size_t width = (size_t)sqrt((float)bufSize_);
|
||||
size_t bufOrigin[3] = {0, 0, 0};
|
||||
size_t hostOrigin[3] = {0, 0, 0};
|
||||
size_t region[3] = {width, width, 1};
|
||||
if (threadID == 0) {
|
||||
memset(inputArr_, (_openTest + 1), bufSize_);
|
||||
error_ = _wrapper->clEnqueueWriteBufferRect(
|
||||
cmd_queues_[1], extPhysicalBuff_, CL_TRUE, bufOrigin, hostOrigin,
|
||||
region, width, 0, width, 0, inputArr_, 0, 0, 0);
|
||||
CHECK_RESULT(error_, "clEnqueueWriteBufferRect failed");
|
||||
error_ = _wrapper->clEnqueueWriteSignalAMD(cmd_queues_[1], extPhysicalBuff_,
|
||||
markerValue_, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteSignalAMD failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
} else {
|
||||
memset(outputArr_, 0, bufSize_);
|
||||
error_ = _wrapper->clEnqueueWaitSignalAMD(
|
||||
cmd_queues_[0], busAddressableBuff_, markerValue_, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWaitSignalAMD failed");
|
||||
error_ = _wrapper->clEnqueueReadBufferRect(
|
||||
cmd_queues_[0], busAddressableBuff_, CL_TRUE, bufOrigin, hostOrigin,
|
||||
region, width, 0, width, 0, outputArr_, 0, 0, 0);
|
||||
CHECK_RESULT(error_, "clEnqueueReadBufferRect failed");
|
||||
success_ = (memcmp(inputArr_, outputArr_, bufSize_) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
void OCLSDI::testEnqueueMapBuffer(int threadID) {
|
||||
if (threadID == 0) {
|
||||
memset(inputArr_, (_openTest + 1), bufSize_);
|
||||
error_ = _wrapper->clEnqueueWriteBuffer(cmd_queues_[1], extPhysicalBuff_,
|
||||
CL_TRUE, 0, bufSize_, inputArr_, 0,
|
||||
0, NULL);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteBuffer failed");
|
||||
error_ = _wrapper->clEnqueueWriteSignalAMD(cmd_queues_[1], extPhysicalBuff_,
|
||||
markerValue_, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteSignalAMD failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
} else {
|
||||
error_ = _wrapper->clEnqueueWaitSignalAMD(
|
||||
cmd_queues_[0], busAddressableBuff_, markerValue_, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWaitSignalAMD failed");
|
||||
void* ptr = _wrapper->clEnqueueMapBuffer(
|
||||
cmd_queues_[0], busAddressableBuff_, CL_TRUE, CL_MAP_READ, 0, bufSize_,
|
||||
0, 0, 0, &error_);
|
||||
CHECK_RESULT(error_, "clEnqueueMapBuffer failed");
|
||||
success_ = (memcmp(inputArr_, ptr, bufSize_) == 0);
|
||||
error_ = _wrapper->clEnqueueUnmapMemObject(
|
||||
cmd_queues_[0], busAddressableBuff_, ptr, 0, 0, 0);
|
||||
CHECK_RESULT(error_, "clEnqueueUnmapMemObject failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[0]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
}
|
||||
}
|
||||
|
||||
void OCLSDI::testEnqueueNDRangeKernel(int threadID) {
|
||||
if (threadID == 0) {
|
||||
size_t global_work_size = bufSize_ / sizeof(cl_uint);
|
||||
error_ = _wrapper->clEnqueueNDRangeKernel(cmd_queues_[1], kernel_, 1, NULL,
|
||||
&global_work_size, NULL, 0, NULL,
|
||||
NULL);
|
||||
CHECK_RESULT(error_, "clEnqueueNDRangeKernel failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
error_ = _wrapper->clEnqueueWriteSignalAMD(cmd_queues_[1], extPhysicalBuff_,
|
||||
markerValue_, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteSignalAMD failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
} else {
|
||||
memset(outputArr_, 0, bufSize_);
|
||||
error_ = _wrapper->clEnqueueWaitSignalAMD(
|
||||
cmd_queues_[0], busAddressableBuff_, markerValue_, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWaitSignalAMD failed");
|
||||
error_ = _wrapper->clEnqueueReadBuffer(cmd_queues_[0], busAddressableBuff_,
|
||||
CL_TRUE, 0, bufSize_, outputArr_, 0,
|
||||
0, NULL);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteBuffer failed");
|
||||
success_ = true;
|
||||
for (cl_uint i = 0; i < bufSize_ / sizeof(cl_uint); ++i) {
|
||||
success_ &= (outputArr_[i] == i + 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void OCLSDI::testEnqueueCopyBuffer(int threadID) {
|
||||
if (threadID == 0) {
|
||||
memset(inputArr_, (_openTest + 1), bufSize_);
|
||||
error_ = _wrapper->clEnqueueWriteBuffer(cmd_queues_[1], srcBuff_, CL_TRUE,
|
||||
0, bufSize_, inputArr_, 0, 0, NULL);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteBuffer failed");
|
||||
error_ = _wrapper->clEnqueueCopyBuffer(cmd_queues_[1], srcBuff_,
|
||||
extPhysicalBuff_, 0, 0, bufSize_, 0,
|
||||
NULL, NULL);
|
||||
CHECK_RESULT(error_, "clEnqueueCopyBuffer failed");
|
||||
error_ = _wrapper->clEnqueueWriteSignalAMD(cmd_queues_[1], extPhysicalBuff_,
|
||||
markerValue_, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteSignalAMD failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
} else {
|
||||
readAndVerifyResult();
|
||||
}
|
||||
}
|
||||
|
||||
void OCLSDI::testEnqueueWriteBuffer(int threadID) {
|
||||
if (threadID == 0) {
|
||||
memset(inputArr_, (_openTest + 1), bufSize_);
|
||||
error_ = _wrapper->clEnqueueWriteBuffer(cmd_queues_[1], extPhysicalBuff_,
|
||||
CL_TRUE, 0, bufSize_, inputArr_, 0,
|
||||
0, NULL);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteBuffer failed");
|
||||
error_ = _wrapper->clEnqueueWriteSignalAMD(cmd_queues_[1], extPhysicalBuff_,
|
||||
markerValue_, 0, 0, 0, 0);
|
||||
CHECK_RESULT(error_ != CL_SUCCESS, "clEnqueueWriteSignalAMD failed");
|
||||
error_ = _wrapper->clFinish(cmd_queues_[1]);
|
||||
CHECK_RESULT(error_, "clFinish failed");
|
||||
} else {
|
||||
readAndVerifyResult();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user