«Неблокирующие» операции чтения OpenCL обходятся дороже, чем ожидалось

Рассмотрим следующий код, который ставит в очередь от 1 до 100000 «неблокирующих» операций чтения буфера произвольного доступа и измеряет время:

#define __CL_ENABLE_EXCEPTIONS

#include <CL/cl.hpp>
#include <vector>
#include <iostream>
#include <chrono>

#include <stdio.h>

static const int size = 100000;
int host_buf[size];

int main() {
    cl::Context ctx(CL_DEVICE_TYPE_DEFAULT, nullptr, nullptr, nullptr);
    std::vector<cl::Device> devices;
    ctx.getInfo(CL_CONTEXT_DEVICES, &devices);
    printf("Using OpenCL devices: \n");
    for (auto &dev : devices) {
        std::string dev_name = dev.getInfo<CL_DEVICE_NAME>();
        printf("        %s\n", dev_name.c_str());
    }

    cl::CommandQueue queue(ctx);

    cl::Buffer gpu_buf(ctx, CL_MEM_READ_WRITE, sizeof(int) * size, nullptr, nullptr);

    std::vector<int> values(size);

    // Warmup
    queue.enqueueReadBuffer(gpu_buf, false, 0, sizeof(int), &(host_buf[0]));
    queue.finish();

    // Run from 1 to 100000 sized chunks
    for (int k = 1; k <= size; k *= 10) {
        auto cstart = std::chrono::high_resolution_clock::now();
        for (int j = 0; j < k; j++)
            queue.enqueueReadBuffer(gpu_buf, false, sizeof(int) * (j * (size / k)), sizeof(int), &(host_buf[j]));
        queue.finish();
        auto cend = std::chrono::high_resolution_clock::now();
        double time = std::chrono::duration<double>(cend - cstart).count() * 1000000.0;
        printf("%8d: %8.02f us\n", k, time);
    }
    return 0;
}

Как всегда, есть некоторые случайные вариации, но типичный вывод для меня такой:

       1:    10.03 us
      10:   107.93 us
     100:   794.54 us
    1000:  8301.35 us
   10000: 83741.06 us
  100000: 981607.26 us

Хотя я ожидал относительно высокой задержки для одного чтения, учитывая необходимость двустороннего обмена PCIe, я удивлен высокой стоимостью добавления последующих операций чтения в очередь — как будто на самом деле «очереди» вообще нет. но каждое чтение добавляет полную задержку. Это на GTX 960 с Linux и версией драйвера 455.45.01.

• Это ожидаемое поведение?
• Другие графические процессоры ведут себя так же?
• Есть ли какой-нибудь обходной путь, кроме как всегда выполнять чтение с произвольным доступом изнутри ядра?