Блог

Я пытаюсь реализовать методы отображения памяти в моей программе OpenCL, но это не работает! Вот мой код ядра:

 __kernel void update(__global char *in, __global char *out)
{
    size_t i;
    for (i = 0; i < 10; i  );
        out[i]  = 'A' - 'a';
}
  

Здесь это код хоста:

 cl_platform_id platformId = NULL;
cl_device_id deviceId = NULL;

cl_context context = NULL;
cl_command_queue commandQueue = NULL;

cl_mem cmPinnedBufIn = NULL;
cl_mem cmPinnedBufOut = NULL;
cl_mem cmDevBufIn = NULL;
cl_mem cmDevBufOut = NULL;
unsigned char *cDataIn = NULL;
unsigned char *cDataOut = NULL;

cl_program program = NULL;
cl_kernel kernel = NULL;
cl_uint retNumDevices;
cl_uint retNumPlatforms;
cl_int ret;

cl_event event;
cl_ulong start;
cl_ulong end;

size_t group_size = GLOBAL_ITEM_SIZE / LOCAL_ITEM_SIZE;

FILE *fp;
const char fileName[] = "./update.cl";
size_t sourceSize;
char *sourceStr;

unsigned char tt[10];

/* Load kernel source file */
if ( !(fp = fopen(fileName, "r")) )
    quitErr("Failed to load kernel.", EXIT_FAILURE);

sourceStr = (char *)malloc(MAX_SOURCE_SIZE);
sourceSize = fread(sourceStr, 1, MAX_SOURCE_SIZE, fp);
fclose(fp);

/* Get Platform/Device Information */
ret = clGetPlatformIDs(1, amp;platformId, amp;retNumPlatforms);
assert(ret == CL_SUCCESS);
ret = clGetDeviceIDs(platformId, CL_DEVICE_TYPE_GPU, 1, amp;deviceId, amp;retNumDevices);
assert(ret == CL_SUCCESS);

/* Create OpenCL Context */
context = clCreateContext( NULL, retNumDevices, amp;deviceId, NULL, NULL, amp;ret);

/* Create command queue with measurment of preformance */
commandQueue = clCreateCommandQueue(context, deviceId, CL_QUEUE_PROFILING_ENABLE, amp;ret);

/* Create buffer objects */
size_t memSize = 10 * sizeof(unsigned char);
cmPinnedBufIn = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, memSize, NULL, amp;ret);
assert(ret == CL_SUCCESS);
cmPinnedBufOut = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, memSize, NULL, amp;ret);
assert(ret == CL_SUCCESS);

/* Mapp pinned memmory */
cDataIn = (unsigned char *)clEnqueueMapBuffer(commandQueue, cmPinnedBufIn, CL_TRUE, CL_MAP_WRITE, 0, memSize, 0, NULL, NULL, amp;ret);
assert(ret == CL_SUCCESS);

/* Initialize data */
for (size_t w = 0; w < memSize; w  )
    cDataIn[w] = 'a'   w;

/* Create kernel program from source file */
program = clCreateProgramWithSource(context, 1, (const char **)amp;sourceStr, (const size_t *)amp;sourceSize, amp;ret);
assert(ret == CL_SUCCESS);
ret = clBuildProgram(program, 1, amp;deviceId, NULL, NULL, NULL);
if (ret != CL_SUCCESS) {  
    error("nFail to build the programn");
    char buffer[10240];
    clGetProgramBuildInfo(program, deviceId, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, NULL);
    quitErr(buffer, EXIT_FAILURE);
}

/* Create data parallel OpenCL kernel */
kernel = clCreateKernel(program, "update", amp;ret);
assert(ret == CL_SUCCESS);

/* Set OpenCL kernel arguments */
ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)amp;cmPinnedBufIn);
assert(ret == CL_SUCCESS);

ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)amp;cmPinnedBufOut);
assert(ret == CL_SUCCESS);

size_t global_item_size = GLOBAL_ITEM_SIZE;
size_t local_item_size = LOCAL_ITEM_SIZE;

/* Execute OpenCL kernel as data parallel */
ret = clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL, amp;global_item_size, amp;local_item_size, 0, NULL, amp;event);
if (ret == CL_INVALID_WORK_GROUP_SIZE)
    quitErr("Invalid work group size: error when compute group size.", EXIT_FAILURE);
assert(ret == CL_SUCCESS);

/* Execute measurment issue */
if (preformanceMeas) {
    clWaitForEvents(1, amp;event);
    clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), amp;start, NULL);
    clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), amp;end, NULL);
    printf("Kernels execution time: .6f [ms]n", (end - start) * 1.0e-6f);
}

cDataOut = (unsigned char *)clEnqueueMapBuffer(commandQueue, cmPinnedBufOut, CL_TRUE, CL_MAP_READ, 0, memSize, 0, NULL, NULL, amp;ret);
assert(ret == CL_SUCCESS);

/* Transfer result to host */
memcpy(tt, cDataOut, memSize);

/* Transfer measurment issue */
if (preformanceMeas) {
    //clWaitForEvents(1, amp;event);
    clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), amp;start, NULL);
    clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), amp;end, NULL);
    printf("Memory x buffer read: .6f [ms]n", (end - start) * 1.0e-6f);
}

/* Display Results */
int i;
for (i = 0; i < group_size; i  )
    for (size_t x = 0; x < memSize; x  )
        printf("%c", tt[x]);
printf("n"); 

/* Finalization */
clFlush(commandQueue);
clFinish(commandQueue);
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseMemObject(cmPinnedBufIn);
clReleaseMemObject(cmPinnedBufOut);
clReleaseMemObject(cmDevBufIn);
clReleaseMemObject(cmDevBufOut);
clReleaseCommandQueue(commandQueue);
clReleaseContext(context);

free(sourceStr);

return EXIT_SUCCESS;
  

Ядро изменяет символы нижнего регистра на верхний регистр, но мой вывод пуст. Когда я статически присваиваю символы в ядре следующим образом:

 __kernel void update(__global char *in, __global char *out)
{
    size_t i;
    for (i = 0; i < 10; i  )
        out[i] = 'A'   i;
}
  

чем результат в порядке. Итак, из этого я делаю вывод, что входные данные неправильно передаются в память, но почему? Кто-нибудь может мне помочь, пожалуйста?

Цикл for ядра имеет конечный «;», так что это пустой цикл.

 for (i = 0; i < 10; i  );
  

Вы должны выполнить вызов clEnqueueUnmapMemObject после записи входных данных в отображенный буфер. Смотрите спецификацию OpenCL 1.1, 5.4.2.1.

Ваши ядра не имеют доступа in и не зависят от индекса потока get_global_id(0) . Вероятно, вы хотите что-то вроде:

 size_t i = get_global_id(0)
char c = in[i];
out[i] = (c>='a' amp;amp; c<='z')?(c   'A' - 'a'):c;
  

Для записи массивов символов в OpenCL 1.0 необходимо включить byte_addressable_store расширение.r