rk35xx-android14/external/OpenCL-CTS/test_conformance/events/test_events.cpp

//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "testBase.h"

#if !defined(_WIN32)
#include "unistd.h" // for "sleep" used in the "while (1)" busy wait loop in
#endif
// test_event_flush

const char *sample_long_test_kernel[] = {
    "__kernel void sample_test(__global float *src, __global int *dst)\n"
    "{\n"
    "    int  tid = get_global_id(0);\n"
    "     int  i;\n"
    "\n"
    "    for( i = 0; i < 10000; i++ )\n"
    "    {\n"
    "        dst[tid] = (int)src[tid] * 3;\n"
    "    }\n"
    "\n"
    "}\n"
};

int create_and_execute_kernel(cl_context inContext, cl_command_queue inQueue,
                              cl_program *outProgram, cl_kernel *outKernel,
                              cl_mem *streams, unsigned int lineCount,
                              const char **lines, const char *kernelName,
                              cl_event *outEvent)
{
    size_t threads[1] = { 1000 }, localThreads[1];
    int error;

    if (create_single_kernel_helper(inContext, outProgram, outKernel, lineCount,
                                    lines, kernelName))
    {
        return -1;
    }

    error = get_max_common_work_group_size(inContext, *outKernel, threads[0],
                                           &localThreads[0]);
    test_error(error, "Unable to get work group size to use");

    streams[0] = clCreateBuffer(inContext, CL_MEM_READ_WRITE,
                                sizeof(cl_float) * 1000, NULL, &error);
    test_error(error, "Creating test array failed");
    streams[1] = clCreateBuffer(inContext, CL_MEM_READ_WRITE,
                                sizeof(cl_int) * 1000, NULL, &error);
    test_error(error, "Creating test array failed");

    /* Set the arguments */
    error = clSetKernelArg(*outKernel, 0, sizeof(streams[0]), &streams[0]);
    test_error(error, "Unable to set kernel arguments");
    error = clSetKernelArg(*outKernel, 1, sizeof(streams[1]), &streams[1]);
    test_error(error, "Unable to set kernel arguments");

    error = clEnqueueNDRangeKernel(inQueue, *outKernel, 1, NULL, threads,
                                   localThreads, 0, NULL, outEvent);
    test_error(error, "Unable to execute test kernel");

    return 0;
}

#define SETUP_EVENT(c, q)                                                      \
    clProgramWrapper program;                                                  \
    clKernelWrapper kernel;                                                    \
    clMemWrapper streams[2];                                                   \
    clEventWrapper event;                                                      \
    int error;                                                                 \
    if (create_and_execute_kernel(c, q, &program, &kernel, &streams[0], 1,     \
                                  sample_long_test_kernel, "sample_test",      \
                                  &event))                                     \
        return -1;

#define FINISH_EVENT(_q) clFinish(_q)

const char *IGetStatusString(cl_int status)
{
    static char tempString[128];
    switch (status)
    {
        case CL_COMPLETE: return "CL_COMPLETE";
        case CL_RUNNING: return "CL_RUNNING";
        case CL_QUEUED: return "CL_QUEUED";
        case CL_SUBMITTED: return "CL_SUBMITTED";
        default:
            sprintf(tempString, "<unknown: %d>", (int)status);
            return tempString;
    }
}

/* Note: tests clGetEventStatus and clReleaseEvent (implicitly) */
int test_event_get_execute_status(cl_device_id deviceID, cl_context context,
                                  cl_command_queue queue, int num_elements)
{
    cl_int status;
    SETUP_EVENT(context, queue);

    /* Now wait for it to be done */
    error = clWaitForEvents(1, &event);
    test_error(error, "Unable to wait for event");

    error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error,
               "Calling clGetEventStatus to wait for event completion failed");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after event complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    FINISH_EVENT(queue);
    return 0;
}

int test_event_get_info(cl_device_id deviceID, cl_context context,
                        cl_command_queue queue, int num_elements)
{
    SETUP_EVENT(context, queue);

    /* Verify parameters of clGetEventInfo not already tested by other tests */
    cl_command_queue otherQueue;
    size_t size;

    error = clGetEventInfo(event, CL_EVENT_COMMAND_QUEUE, sizeof(otherQueue),
                           &otherQueue, &size);
    test_error(error, "Unable to get event info!");
    // We can not check if this is the right queue because this is an opaque
    // object.
    if (size != sizeof(queue))
    {
        log_error("ERROR: Returned command queue size does not validate "
                  "(expected %d, got %d)\n",
                  (int)sizeof(queue), (int)size);
        return -1;
    }

    cl_command_type type;
    error = clGetEventInfo(event, CL_EVENT_COMMAND_TYPE, sizeof(type), &type,
                           &size);
    test_error(error, "Unable to get event info!");
    if (type != CL_COMMAND_NDRANGE_KERNEL)
    {
        log_error("ERROR: Returned command type does not validate (expected "
                  "%d, got %d)\n",
                  (int)CL_COMMAND_NDRANGE_KERNEL, (int)type);
        return -1;
    }
    if (size != sizeof(type))
    {
        log_error("ERROR: Returned command type size does not validate "
                  "(expected %d, got %d)\n",
                  (int)sizeof(type), (int)size);
        return -1;
    }

    cl_uint count;
    error = clGetEventInfo(event, CL_EVENT_REFERENCE_COUNT, sizeof(count),
                           &count, &size);
    test_error(error, "Unable to get event info for CL_EVENT_REFERENCE_COUNT!");
    if (size != sizeof(count))
    {
        log_error("ERROR: Returned command type size does not validate "
                  "(expected %d, got %d)\n",
                  (int)sizeof(type), (int)size);
        return -1;
    }

    cl_context testCtx;
    error = clGetEventInfo(event, CL_EVENT_CONTEXT, sizeof(testCtx), &testCtx,
                           &size);
    test_error(error, "Unable to get event context info!");
    if (size != sizeof(context))
    {
        log_error("ERROR: Returned context size does not validate (expected "
                  "%d, got %d)\n",
                  (int)sizeof(context), (int)size);
        return -1;
    }
    if (testCtx != context)
    {
        log_error(
            "ERROR: Returned context does not match (expected %p, got %p)\n",
            (void *)context, (void *)testCtx);
        return -1;
    }

    FINISH_EVENT(queue);
    return 0;
}

int test_event_get_write_array_status(cl_device_id deviceID, cl_context context,
                                      cl_command_queue queue, int num_elements)
{
    cl_mem stream;
    cl_float testArray[1024 * 32];
    cl_event event;
    int error;
    cl_int status;


    stream = clCreateBuffer(context, CL_MEM_READ_WRITE,
                            sizeof(cl_float) * 1024 * 32, NULL, &error);
    test_error(error, "Creating test array failed");

    error = clEnqueueWriteBuffer(queue, stream, CL_FALSE, 0,
                                 sizeof(cl_float) * 1024 * 32,
                                 (void *)testArray, 0, NULL, &event);
    test_error(error, "Unable to set testing kernel data");

    /* Now wait for it to be done */
    error = clWaitForEvents(1, &event);
    test_error(error, "Unable to wait for event");

    error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error,
               "Calling clGetEventStatus to wait for event completion failed");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after array write complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }


    clReleaseMemObject(stream);
    clReleaseEvent(event);

    return 0;
}

int test_event_get_read_array_status(cl_device_id deviceID, cl_context context,
                                     cl_command_queue queue, int num_elements)
{
    cl_mem stream;
    cl_float testArray[1024 * 32];
    cl_event event;
    int error;
    cl_int status;


    stream = clCreateBuffer(context, CL_MEM_READ_WRITE,
                            sizeof(cl_float) * 1024 * 32, NULL, &error);
    test_error(error, "Creating test array failed");

    error = clEnqueueReadBuffer(queue, stream, CL_FALSE, 0,
                                sizeof(cl_float) * 1024 * 32, (void *)testArray,
                                0, NULL, &event);
    test_error(error, "Unable to get testing kernel data");


    /* It should still be running... */
    error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");

    if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
        && status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "during array read (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    /* Now wait for it to be done */
    error = clWaitForEvents(1, &event);
    test_error(error, "Unable to wait for event");

    error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error,
               "Calling clGetEventStatus to wait for event completion failed");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after array read complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }


    clReleaseMemObject(stream);
    clReleaseEvent(event);

    return 0;
}

/* clGetEventStatus not implemented yet */

int test_event_wait_for_execute(cl_device_id deviceID, cl_context context,
                                cl_command_queue queue, int num_elements)
{
    cl_int status;
    SETUP_EVENT(context, queue);

    /* Now we wait for it to be done, then test the status again */
    error = clWaitForEvents(1, &event);
    test_error(error, "Unable to wait for execute event");

    /* Make sure it worked */
    error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after event complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    FINISH_EVENT(queue);
    return 0;
}

int test_event_wait_for_array(cl_device_id deviceID, cl_context context,
                              cl_command_queue queue, int num_elements)
{
    cl_mem streams[2];
    cl_float readArray[1024 * 32];
    cl_float writeArray[1024 * 32];
    cl_event events[2];
    int error;
    cl_int status;


    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                sizeof(cl_float) * 1024 * 32, NULL, &error);
    test_error(error, "Creating test array failed");
    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                sizeof(cl_float) * 1024 * 32, NULL, &error);
    test_error(error, "Creating test array failed");

    error = clEnqueueReadBuffer(queue, streams[0], CL_FALSE, 0,
                                sizeof(cl_float) * 1024 * 32, (void *)readArray,
                                0, NULL, &events[0]);
    test_error(error, "Unable to read testing kernel data");

    error = clEnqueueWriteBuffer(queue, streams[1], CL_FALSE, 0,
                                 sizeof(cl_float) * 1024 * 32,
                                 (void *)writeArray, 0, NULL, &events[1]);
    test_error(error, "Unable to write testing kernel data");

    /* Both should still be running */
    error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
        && status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "during array read (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
        && status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "during array write (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    /* Now try waiting for both */
    error = clWaitForEvents(2, events);
    test_error(error, "Unable to wait for array events");

    /* Double check status on both */
    error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after array read complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after array write complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    clReleaseMemObject(streams[0]);
    clReleaseMemObject(streams[1]);
    clReleaseEvent(events[0]);
    clReleaseEvent(events[1]);

    return 0;
}

int test_event_flush(cl_device_id deviceID, cl_context context,
                     cl_command_queue queue, int num_elements)
{
    int loopCount = 0;
    cl_int status;
    SETUP_EVENT(context, queue);

    /* Now flush. Note that we can't guarantee this actually lets the op finish,
     * but we can guarantee it's no longer queued */
    error = clFlush(queue);
    test_error(error, "Unable to flush events");

    /* Make sure it worked */
    while (1)
    {
        error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                               sizeof(status), &status, NULL);
        test_error(error, "Calling clGetEventStatus didn't work!");

        if (status != CL_QUEUED) break;

#if !defined(_WIN32)
        sleep(1); // give it some time here.
#else // _WIN32
        Sleep(1000);
#endif
        ++loopCount;
    }

    /*
    CL_QUEUED (command has been enqueued in the command-queue),
    CL_SUBMITTED (enqueued command has been submitted by the host to the device
    associated with the command-queue), CL_RUNNING (device is currently
    executing this command), CL_COMPLETE (the command has completed), or Error
    code given by a negative integer value. (command was abnormally terminated –
    this may be caused by a bad memory access etc.).
    */
    if (status != CL_COMPLETE && status != CL_SUBMITTED && status != CL_RUNNING
        && status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after event flush (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    /* Now wait */
    error = clFinish(queue);
    test_error(error, "Unable to finish events");

    FINISH_EVENT(queue);
    return 0;
}


int test_event_finish_execute(cl_device_id deviceID, cl_context context,
                              cl_command_queue queue, int num_elements)
{
    cl_int status;
    SETUP_EVENT(context, queue);

    /* Now flush and finish all ops */
    error = clFinish(queue);
    test_error(error, "Unable to finish all events");

    /* Make sure it worked */
    error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after event complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    FINISH_EVENT(queue);
    return 0;
}

int test_event_finish_array(cl_device_id deviceID, cl_context context,
                            cl_command_queue queue, int num_elements)
{
    cl_mem streams[2];
    cl_float readArray[1024 * 32];
    cl_float writeArray[1024 * 32];
    cl_event events[2];
    int error;
    cl_int status;


    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                sizeof(cl_float) * 1024 * 32, NULL, &error);
    test_error(error, "Creating test array failed");
    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                sizeof(cl_float) * 1024 * 32, NULL, &error);
    test_error(error, "Creating test array failed");

    error = clEnqueueReadBuffer(queue, streams[0], CL_FALSE, 0,
                                sizeof(cl_float) * 1024 * 32, (void *)readArray,
                                0, NULL, &events[0]);
    test_error(error, "Unable to read testing kernel data");

    error = clEnqueueWriteBuffer(queue, streams[1], CL_FALSE, 0,
                                 sizeof(cl_float) * 1024 * 32,
                                 (void *)writeArray, 0, NULL, &events[1]);
    test_error(error, "Unable to write testing kernel data");

    /* Both should still be running */
    error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
        && status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "during array read (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
        && status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "during array write (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    /* Now try finishing all ops */
    error = clFinish(queue);
    test_error(error, "Unable to finish all events");

    /* Double check status on both */
    error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after array read complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventStatus didn't work!");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetErrorStatus "
                  "after array write complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    clReleaseMemObject(streams[0]);
    clReleaseMemObject(streams[1]);
    clReleaseEvent(events[0]);
    clReleaseEvent(events[1]);

    return 0;
}


#define NUM_EVENT_RUNS 100

int test_event_release_before_done(cl_device_id deviceID, cl_context context,
                                   cl_command_queue queue, int num_elements)
{
    // Create a kernel to run
    clProgramWrapper program;
    clKernelWrapper kernel[NUM_EVENT_RUNS];
    size_t threads[1] = { 1000 };
    cl_event events[NUM_EVENT_RUNS];
    cl_int status;
    clMemWrapper streams[NUM_EVENT_RUNS][2];
    int error, i;

    // Create a kernel
    if (create_single_kernel_helper(context, &program, &kernel[0], 1,
                                    sample_long_test_kernel, "sample_test"))
    {
        return -1;
    }

    for (i = 1; i < NUM_EVENT_RUNS; i++)
    {
        kernel[i] = clCreateKernel(program, "sample_test", &error);
        test_error(error, "Unable to create kernel");
    }

    error =
        get_max_common_work_group_size(context, kernel[0], 1024, &threads[0]);
    test_error(error, "Unable to get work group size to use");

    // Create a set of streams to use as arguments
    for (i = 0; i < NUM_EVENT_RUNS; i++)
    {
        streams[i][0] =
            clCreateBuffer(context, CL_MEM_READ_WRITE,
                           sizeof(cl_float) * threads[0], NULL, &error);
        streams[i][1] =
            clCreateBuffer(context, CL_MEM_READ_WRITE,
                           sizeof(cl_int) * threads[0], NULL, &error);
        if ((streams[i][0] == NULL) || (streams[i][1] == NULL))
        {
            log_error("ERROR: Unable to allocate testing streams");
            return -1;
        }
    }

    // Execute the kernels one by one, hopefully making sure they won't be done
    // by the time we get to the end
    for (i = 0; i < NUM_EVENT_RUNS; i++)
    {
        error = clSetKernelArg(kernel[i], 0, sizeof(cl_mem), &streams[i][0]);
        error |= clSetKernelArg(kernel[i], 1, sizeof(cl_mem), &streams[i][1]);
        test_error(error, "Unable to set kernel arguments");

        error = clEnqueueNDRangeKernel(queue, kernel[i], 1, NULL, threads,
                                       threads, 0, NULL, &events[i]);
        test_error(error, "Unable to execute test kernel");
    }

    // Free all but the last event
    for (i = 0; i < NUM_EVENT_RUNS - 1; i++)
    {
        clReleaseEvent(events[i]);
    }

    // Get status on the last one, then free it
    error = clGetEventInfo(events[NUM_EVENT_RUNS - 1],
                           CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(status),
                           &status, NULL);
    test_error(error, "Unable to get event status");

    clReleaseEvent(events[NUM_EVENT_RUNS - 1]);

    // Was the status still-running?
    if (status == CL_COMPLETE)
    {
        log_info("WARNING: Events completed before they could be released, so "
                 "test is a null-op. Increase workload and try again.");
    }
    else if (status == CL_RUNNING || status == CL_QUEUED
             || status == CL_SUBMITTED)
    {
        log_info("Note: Event status was running or queued when released, so "
                 "test was good.\n");
    }

    // If we didn't crash by now, the test succeeded
    clFinish(queue);

    return 0;
}

int test_event_enqueue_marker(cl_device_id deviceID, cl_context context,
                              cl_command_queue queue, int num_elements)
{
    cl_int status;
    SETUP_EVENT(context, queue);

    /* Now we queue a marker and wait for that, which--since it queues
     * afterwards--should guarantee the execute finishes too */
    clEventWrapper markerEvent;
    // error = clEnqueueMarker( queue, &markerEvent );

#ifdef CL_VERSION_1_2
    error = clEnqueueMarkerWithWaitList(queue, 0, NULL, &markerEvent);
#else
    error = clEnqueueMarker(queue, &markerEvent);
#endif
    test_error(error, "Unable to queue marker");
    /* Now we wait for it to be done, then test the status again */
    error = clWaitForEvents(1, &markerEvent);
    test_error(error, "Unable to wait for marker event");

    /* Check the status of the first event */
    error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
                           sizeof(status), &status, NULL);
    test_error(error, "Calling clGetEventInfo didn't work!");
    if (status != CL_COMPLETE)
    {
        log_error("ERROR: Incorrect status returned from clGetEventInfo after "
                  "event complete (%d:%s)\n",
                  status, IGetStatusString(status));
        return -1;
    }

    FINISH_EVENT(queue);
    return 0;
}

#ifdef CL_VERSION_1_2
int test_event_enqueue_marker_with_event_list(cl_device_id deviceID,
                                              cl_context context,
                                              cl_command_queue queue,
                                              int num_elements)
{
    SETUP_EVENT(context, queue);
    cl_event event_list[3] = { NULL, NULL, NULL };

    size_t threads[1] = { 10 }, localThreads[1] = { 1 };
    cl_uint event_count = 2;
    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[0]);
    test_error(error, " clEnqueueMarkerWithWaitList   1 ");

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[1]);
    test_error(error, " clEnqueueMarkerWithWaitList 2");

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, NULL);
    test_error(error, " clEnqueueMarkerWithWaitList  3");

    // test the case event returned
    error = clEnqueueMarkerWithWaitList(queue, event_count, event_list,
                                        &event_list[2]);
    test_error(error, " clEnqueueMarkerWithWaitList ");

    error = clReleaseEvent(event_list[0]);
    error |= clReleaseEvent(event_list[1]);
    test_error(error, "clReleaseEvent");

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[0]);
    test_error(error, " clEnqueueMarkerWithWaitList   1 -1 ");

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[1]);
    test_error(error, " clEnqueueMarkerWithWaitList  2-2");

    // test the case event =NULL,   caused [CL_INVALID_VALUE] : OpenCL Error :
    // clEnqueueMarkerWithWaitList failed: event is a NULL value
    error = clEnqueueMarkerWithWaitList(queue, event_count, event_list, NULL);
    test_error(error, " clEnqueueMarkerWithWaitList ");

    error = clReleaseEvent(event_list[0]);
    error |= clReleaseEvent(event_list[1]);
    error |= clReleaseEvent(event_list[2]);
    test_error(error, "clReleaseEvent");

    FINISH_EVENT(queue);
    return 0;
}

int test_event_enqueue_barrier_with_event_list(cl_device_id deviceID,
                                               cl_context context,
                                               cl_command_queue queue,
                                               int num_elements)
{
    SETUP_EVENT(context, queue);
    cl_event event_list[3] = { NULL, NULL, NULL };

    size_t threads[1] = { 10 }, localThreads[1] = { 1 };
    cl_uint event_count = 2;
    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[0]);
    test_error(error, " clEnqueueBarrierWithWaitList   1 ");

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[1]);
    test_error(error, " clEnqueueBarrierWithWaitList 2");

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, NULL);
    test_error(error, " clEnqueueBarrierWithWaitList  20");

    // test the case event returned
    error = clEnqueueBarrierWithWaitList(queue, event_count, event_list,
                                         &event_list[2]);
    test_error(error, " clEnqueueBarrierWithWaitList ");

    clReleaseEvent(event_list[0]);
    clReleaseEvent(event_list[1]);

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[0]);
    test_error(error, " clEnqueueBarrierWithWaitList   1 ");

    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
                                   localThreads, 0, NULL, &event_list[1]);
    test_error(error, " clEnqueueBarrierWithWaitList 2");

    // test the case event =NULL,   caused [CL_INVALID_VALUE] : OpenCL Error :
    // clEnqueueMarkerWithWaitList failed: event is a NULL value
    error = clEnqueueBarrierWithWaitList(queue, event_count, event_list, NULL);
    test_error(error, " clEnqueueBarrierWithWaitList ");

    clReleaseEvent(event_list[0]);
    clReleaseEvent(event_list[1]);
    clReleaseEvent(event_list[2]);

    FINISH_EVENT(queue);
    return 0;
}
#endif