Function runTest

examples/matmul/run.cpp:783–864

template<class precision=float>
void runTest(int version, size_t M, size_t K, size_t N,
             std::unique_ptr<precision[]> &inputPtr,
             std::unique_ptr<precision[]> &weightsPtr,
             std::unique_ptr<precision[]> &outputPtr,
	     NumType numtype) {
  if constexpr (std::is_same<precision, float>::value) {
    assert(numtype == kf32);
  } else if constexpr (std::is_same<precision, half>::value) {
    assert(numtype == kf16);
  }

  // Allocate GPU buffers and copy data
  Context ctx = createContext(
      {}, {},
      /*device descriptor, enabling f16 in WGSL*/
      {
          .requiredFeatureCount = 1,
          .requiredFeatures = std::array{WGPUFeatureName_ShaderF16}.data(),
      });

  Tensor input = createTensor(ctx, Shape{M, K}, numtype, inputPtr.get());
  Tensor weights = createTensor(ctx, Shape{N, K}, numtype, weightsPtr.get()); // column-major

#ifdef METAL_PROFILER
  constexpr size_t nIter = 1;
#else
  constexpr size_t nIter = 30;
#endif

  // Initialize Kernel and bind GPU buffers


  // pre-allocate for async dispatch
  std::array<std::promise<void>, nIter> promises;
  std::array<std::future<void>, nIter> futures;
  std::array<Kernel, nIter> kernels;
  std::array<Tensor, nIter> outputs;
  for (int i = 0; i < nIter; i++) {
    futures[i] = promises[i].get_future();
    outputs[i] = createTensor(ctx, Shape{M, N}, numtype);
    kernels[i] = selectMatmul(ctx, version, {input, weights, outputs[i]}, M, K, N, numtype);
  }

#ifndef METAL_PROFILER
  printf("[ Press enter to start tests ... ]\n");
  getchar();
#endif
  LOG(kDefLog, kInfo, "Dispatching Kernel version %d: %s, %d iterations ...",
      version, versionToStr(version).c_str(), nIter);

  // Dispatch kernel nIter times
  auto start = std::chrono::high_resolution_clock::now();
  for (int i = 0; i < nIter; i++) {
    dispatchKernel(ctx, kernels[i], promises[i]);
  }
  for (int i = 0; i < nIter; i++) {
    wait(ctx, futures[i]);
  }