Attachment 133380 Details for Bug 102118 – Test case

Test case

ternary.c (text/x-csrc), 12.05 KB, created by Chris Cummins on 2017-08-08 13:52:13 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Chris Cummins

Created: 2017-08-08 13:52:13 UTC

Size: 12.05 KB

patch

obsolete

>/*
> * Usage: gcc -DPLATFORM_ID=0 -DDEVICE_ID=0 code.c -lOpenCL; ./a.out
> *
> * Code generated using cldrive <https://github.com/ChrisCummins/cldrive>
> */
>#ifndef PLATFORM_ID
># define PLATFORM_ID 0
>#endif
>
>#ifndef DEVICE_ID
># define DEVICE_ID 0
>#endif
>
>#include <stdio.h>
>#include <stdlib.h>
>
>#ifdef __APPLE__
>#include <OpenCL/opencl.h>
>#else
>#include <CL/cl.h>
>#endif
>
>#define True 1
>#define False 0
>typedef unsigned short ushort;
>
>const char *kernel_src = \
>"__kernel void A(__global int* a, __global int* b, __global int* c) {\n"
>"  c[0] = 100;\n"
>"  c[1] = (a[3] <= b[4]) ? a[4] : b[5];\n"
>"}\n";
>
>const char *clerror_string(cl_int err) {
>    /* written by @Selmar http://stackoverflow.com/a/24336429 */
>    switch(err) {
>        /* run-time and JIT compiler errors */
>        case 0: return "CL_SUCCESS";
>        case -1: return "CL_DEVICE_NOT_FOUND";
>        case -2: return "CL_DEVICE_NOT_AVAILABLE";
>        case -3: return "CL_COMPILER_NOT_AVAILABLE";
>        case -4: return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
>        case -5: return "CL_OUT_OF_RESOURCES";
>        case -6: return "CL_OUT_OF_HOST_MEMORY";
>        case -7: return "CL_PROFILING_INFO_NOT_AVAILABLE";
>        case -8: return "CL_MEM_COPY_OVERLAP";
>        case -9: return "CL_IMAGE_FORMAT_MISMATCH";
>        case -10: return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
>        case -11: return "CL_BUILD_PROGRAM_FAILURE";
>        case -12: return "CL_MAP_FAILURE";
>        case -13: return "CL_MISALIGNED_SUB_BUFFER_OFFSET";
>        case -14: return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
>        case -15: return "CL_COMPILE_PROGRAM_FAILURE";
>        case -16: return "CL_LINKER_NOT_AVAILABLE";
>        case -17: return "CL_LINK_PROGRAM_FAILURE";
>        case -18: return "CL_DEVICE_PARTITION_FAILED";
>        case -19: return "CL_KERNEL_ARG_INFO_NOT_AVAILABLE";
>
>        /* compile-time errors */
>        case -30: return "CL_INVALID_VALUE";
>        case -31: return "CL_INVALID_DEVICE_TYPE";
>        case -32: return "CL_INVALID_PLATFORM";
>        case -33: return "CL_INVALID_DEVICE";
>        case -34: return "CL_INVALID_CONTEXT";
>        case -35: return "CL_INVALID_QUEUE_PROPERTIES";
>        case -36: return "CL_INVALID_COMMAND_QUEUE";
>        case -37: return "CL_INVALID_HOST_PTR";
>        case -38: return "CL_INVALID_MEM_OBJECT";
>        case -39: return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
>        case -40: return "CL_INVALID_IMAGE_SIZE";
>        case -41: return "CL_INVALID_SAMPLER";
>        case -42: return "CL_INVALID_BINARY";
>        case -43: return "CL_INVALID_BUILD_OPTIONS";
>        case -44: return "CL_INVALID_PROGRAM";
>        case -45: return "CL_INVALID_PROGRAM_EXECUTABLE";
>        case -46: return "CL_INVALID_KERNEL_NAME";
>        case -47: return "CL_INVALID_KERNEL_DEFINITION";
>        case -48: return "CL_INVALID_KERNEL";
>        case -49: return "CL_INVALID_ARG_INDEX";
>        case -50: return "CL_INVALID_ARG_VALUE";
>        case -51: return "CL_INVALID_ARG_SIZE";
>        case -52: return "CL_INVALID_KERNEL_ARGS";
>        case -53: return "CL_INVALID_WORK_DIMENSION";
>        case -54: return "CL_INVALID_WORK_GROUP_SIZE";
>        case -55: return "CL_INVALID_WORK_ITEM_SIZE";
>        case -56: return "CL_INVALID_GLOBAL_OFFSET";
>        case -57: return "CL_INVALID_EVENT_WAIT_LIST";
>        case -58: return "CL_INVALID_EVENT";
>        case -59: return "CL_INVALID_OPERATION";
>        case -60: return "CL_INVALID_GL_OBJECT";
>        case -61: return "CL_INVALID_BUFFER_SIZE";
>        case -62: return "CL_INVALID_MIP_LEVEL";
>        case -63: return "CL_INVALID_GLOBAL_WORK_SIZE";
>        case -64: return "CL_INVALID_PROPERTY";
>        case -65: return "CL_INVALID_IMAGE_DESCRIPTOR";
>        case -66: return "CL_INVALID_COMPILER_OPTIONS";
>        case -67: return "CL_INVALID_LINKER_OPTIONS";
>        case -68: return "CL_INVALID_DEVICE_PARTITION_COUNT";
>
>        /* extension errors */
>        case -1000: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
>        case -1001: return "CL_PLATFORM_NOT_FOUND_KHR";
>        case -1002: return "CL_INVALID_D3D10_DEVICE_KHR";
>        case -1003: return "CL_INVALID_D3D10_RESOURCE_KHR";
>        case -1004: return "CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR";
>        case -1005: return "CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR";
>
>        default: return "Unknown OpenCL error";
>    }
>}
>
>void check_error(const char* api_call, cl_int err) {
>    if(err != CL_SUCCESS) {
>        fprintf(stderr, "%s %s\n", api_call, clerror_string(err));
>        exit(1);
>    }
>}
>
>int main() {
>    int err;
>
>    cl_uint num_platforms;
>    cl_platform_id *platform_ids = (cl_platform_id*)malloc(sizeof(cl_platform_id) * (PLATFORM_ID + 1));
>    err = clGetPlatformIDs(PLATFORM_ID + 1, platform_ids, &num_platforms);
>    check_error("clGetPlatformIDs", err);
>
>    if (num_platforms <= PLATFORM_ID) {
>        fprintf(stderr, "Platform ID %d not found\n", PLATFORM_ID);
>        return 1;
>    }
>    cl_platform_id platform_id = platform_ids[PLATFORM_ID];
>
>    char strbuf[256];
>    err = clGetPlatformInfo(platform_id, CL_PLATFORM_NAME, sizeof(strbuf), strbuf, NULL);
>    check_error("clGetPlatformInfo", err);
>    fprintf(stderr, "[cldrive] Platform: %s\n", strbuf);
>
>    cl_uint num_devices;
>    cl_device_id *device_ids = (cl_device_id*)malloc(sizeof(cl_device_id) * (DEVICE_ID + 1));
>    err = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_ALL, DEVICE_ID + 1, device_ids, &num_devices);
>    check_error("clGetDeviceIDs", err);
>
>    if (num_devices <= DEVICE_ID) {
>        fprintf(stderr, "Device ID %d not found\n", DEVICE_ID);
>        return 1;
>    }
>    cl_device_id device_id = device_ids[DEVICE_ID];
>
>    err = clGetDeviceInfo(device_id, CL_DEVICE_NAME, sizeof(strbuf), strbuf, NULL);
>    check_error("clGetDeviceInfo", err);
>    fprintf(stderr, "[cldrive] Device: %s\n", strbuf);
>
>    cl_context ctx = clCreateContext(NULL, 1, &device_id, NULL, NULL, &err);
>    check_error("clCreateContext", err);
>
>    cl_command_queue queue = clCreateCommandQueue(ctx, device_id, 0, &err);
>    check_error("clCreateCommandQueue", err);
>
>    fprintf(stderr, "[cldrive] OpenCL optimizations: on\n");
>
>    cl_program program = clCreateProgramWithSource(ctx, 1, (const char **) &kernel_src, NULL, &err);
>    check_error("clCreateProgramWithSource", err);
>
>    int build_err = clBuildProgram(program, 0, NULL, "-cl-opt-disable", NULL, NULL);
>
>    size_t log_size;
>    err = clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
>    check_error("clGetProgramBuildInfo", err);
>
>    if (log_size > 2) {
>        char* log = (char*)malloc(sizeof(char) * (log_size + 1));
>        err = clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, log_size, log, NULL);
>        check_error("clGetProgramBuildInfo", err);
>        fprintf(stderr, "%s", log);
>    }
>
>    check_error("clBuildProgram", build_err);
>
>    fprintf(stderr, "[cldrive] Kernel: \"A\"\n");
>    cl_kernel kernel = clCreateKernel(program, "A", &err);
>    check_error("clCreateKernel", err);
>
>    int host_0[255] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };
>    cl_mem dev_0 = clCreateBuffer(ctx, CL_MEM_COPY_HOST_PTR | CL_MEM_READ_WRITE, sizeof(int) * 255, &host_0, &err);
>    check_error("clCreateBuffer", err);
>    err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &dev_0);
>    check_error("clSetKernelArg", err);
>
>    int host_1[255] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };
>    cl_mem dev_1 = clCreateBuffer(ctx, CL_MEM_COPY_HOST_PTR | CL_MEM_READ_WRITE, sizeof(int) * 255, &host_1, &err);
>    check_error("clCreateBuffer", err);
>    err = clSetKernelArg(kernel, 1, sizeof(cl_mem), &dev_1);
>    check_error("clSetKernelArg", err);
>
>    int host_2[255] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 };
>    cl_mem dev_2 = clCreateBuffer(ctx, CL_MEM_COPY_HOST_PTR | CL_MEM_READ_WRITE, sizeof(int) * 255, &host_2, &err);
>    check_error("clCreateBuffer", err);
>    err = clSetKernelArg(kernel, 2, sizeof(cl_mem), &dev_2);
>    check_error("clSetKernelArg", err);
>
>    const size_t lsize[3] = { 1, 1, 1 };
>    const size_t gsize[3] = { 1, 1, 1 };
>
>    err = clEnqueueNDRangeKernel(queue, kernel, 3, NULL, gsize, lsize, 0, NULL, NULL);
>    check_error("clEnqueueNDRangeKernel", err);
>
>    err = clEnqueueReadBuffer(queue, dev_0, CL_TRUE, 0, sizeof(int) * 255, &host_0, 0, NULL, NULL);
>    check_error("clEnqueueReadBuffer", err);
>
>    err = clEnqueueReadBuffer(queue, dev_1, CL_TRUE, 0, sizeof(int) * 255, &host_1, 0, NULL, NULL);
>    check_error("clEnqueueReadBuffer", err);
>
>    err = clEnqueueReadBuffer(queue, dev_2, CL_TRUE, 0, sizeof(int) * 255, &host_2, 0, NULL, NULL);
>    check_error("clEnqueueReadBuffer", err);
>
>    err = clFinish(queue);
>    check_error("clFinish", err);
>
>    printf("c[0] = %d, c[1] = %d\n", host_2[0], host_2[1]);
>
>    /* clReleaseMemObject(); */
>    clReleaseProgram(program);
>    clReleaseKernel(kernel);
>    clReleaseCommandQueue(queue);
>    clReleaseContext(ctx);
>
>    fprintf(stderr, "done.\n");
>    return 0;
>}

Actions: View

Attachments on bug 102118: 133380

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.