Function runTest

examples/transpose/run.cpp:145–208

}

void runTest(int version, size_t M, size_t N,
             std::unique_ptr<float[]> &inputPtr,
             std::unique_ptr<float[]> &outputPtr) {
  bool isCPU = version == 0;
  
  // Allocate GPU buffers and copy data
  Context ctx = createContext();
  Tensor input = createTensor(ctx, Shape{M, N}, kf32, inputPtr.get());
  Tensor output = createTensor(ctx, Shape{N, M}, kf32);

  constexpr size_t nIter = 50;

  // Initialize Kernel and bind GPU buffers
  LOG(kDefLog, kInfo, "Creating Kernel");
  Kernel kernel = selectTranspose(ctx, version, {input, output}, M, N);

  // Dispatch kernel execution
  LOG(kDefLog, kInfo, "Dispatching Kernel version %d, %d iterations ...",
      version, nIter);

  // pre-allocate promises and futures for async dispatch
  // TODO(avh): implement a pooling mechanism for promises/futures in gpu.h
  std::array<std::promise<void>, nIter> promises;
  std::array<std::future<void>, nIter> futures;
  for (int i = 0; i < nIter; i++) {
    futures[i] = promises[i].get_future();
  }

  // Dispatch kernel nIter times
  auto start = std::chrono::high_resolution_clock::now();
  for (int i = 0; i < nIter; i++) {
    if (!isCPU) {
      dispatchKernel(ctx, kernel, promises[i]);
      wait(ctx, futures[i]);
      resetCommandBuffer(ctx.device, kernel);
    } else {
      transpose(inputPtr.get(), outputPtr.get(), M, N);
    }
  }
  auto end = std::chrono::high_resolution_clock::now();

  // Report performance.
  // Use microsecond for more accurate time measurement
  auto duration =
      std::chrono::duration_cast<std::chrono::microseconds>(end - start);
  float gbps = sizeof(float) * M * N /
               (static_cast<double>(duration.count()) / 1000000.0) /
               1000000000.0 * static_cast<float>(nIter);

  LOG(kDefLog, kInfo, "Copying result to CPU");
  if (!isCPU) {
    toCPU(ctx, output, outputPtr.get(), M * N * sizeof(float));
  }
  LOG(kDefLog, kInfo, "%s",
      show<float>(outputPtr.get(), N, M, "Output").c_str());

  LOG(kDefLog, kInfo, "\n\n===================================================================="
      "============\nExecution Time: (M = %d, N = %d) x %d iterations "