int AsyncDataTransfer::executeAsyncKernel(void)
{
    int status = SDK_SUCCESS;
    std::vector<cl::Event> eventList;
    eventList.reserve(2);
    cl::Event *writeEvents = new cl::Event[iterations * numKernels];
    cl::Event *kernelEvents = new cl::Event[iterations * numKernels];
    cl::Event *readEvents = new cl::Event[iterations * numKernels];
    writeQueue.finish();
    kernelQueue.finish();
    readQueue.finish();

    sampleTimer->resetTimer(cpuTimer);
    sampleTimer->startTimer(cpuTimer);
    for(int i = 0; i < iterations; i++)
    {
        for(int k = 0; k < numKernels; ++k)
        {
            // Write
            eventList.clear();
            if(i > 0)
            {
                eventList.push_back(kernelEvents[((i-1) * numKernels) + k]);
            }
            status |= writeQueue.enqueueWriteBuffer(inputBuffer[k], CL_FALSE, 0, bufferSize,
                                                    input[k],
                                                    &eventList, &(writeEvents[(i * numKernels) + k]));

            // Execute Kernel
            eventList.clear();
            if(i > 0)
            {
                eventList.push_back(readEvents[((i-1) * numKernels) + k]);
            }
            eventList.push_back(writeEvents[(i * numKernels) + k]);
            status |= kernel.setArg(0, inputBuffer[k]);
            status |= kernel.setArg(1, outputBuffer[k]);
            status |= kernel.setArg(2, k);
            status |= kernelQueue.enqueueNDRangeKernel(kernel, cl::NullRange, globalThreads,
                      localThreads,
                      &eventList, &kernelEvents[(i * numKernels) + k]);

            // Read
            eventList.clear();
            eventList.push_back(kernelEvents[(i * numKernels) + k]);
            status |= readQueue.enqueueReadBuffer(outputBuffer[k], CL_FALSE, 0, bufferSize,
                                                  output[k],
                                                  &eventList, &(readEvents[(i * numKernels) + k]));
        }
    }
    // Flush all the queues
    status |= writeQueue.flush();
    status |= kernelQueue.flush();
    status |= readQueue.flush();

    // Wait for finish all the operations
    status |= writeQueue.finish();
    status |= kernelQueue.finish();
    status |= readQueue.finish();

    sampleTimer-> stopTimer(cpuTimer);
    asyncTime = (sampleTimer-> readTimer(cpuTimer) * 1000) /
                (numKernels * iterations);

    // Free events
    delete [] writeEvents;
    delete [] kernelEvents;
    delete [] readEvents;

    return status;
}