Function run_async_impl

python/runtime/cudaq/algorithms/py_run.cpp:153–244

@brief Run `cudaq::run_async` on the provided kernel.

/// @brief Run `cudaq::run_async` on the provided kernel.
static async_run_result
run_async_impl(const std::string &shortName, MlirModule module,
               std::size_t shots_count, std::optional<noise_model> noise_model,
               std::size_t qpu_id, nanobind::args runtimeArgs) {
  auto &platform = get_platform();
  auto numQPUs = platform.num_qpus();
  if (qpu_id >= numQPUs)
    throw std::runtime_error("qpu_id (" + std::to_string(qpu_id) +
                             ") exceeds the number of available QPUs (" +
                             std::to_string(numQPUs) + ")");

  auto mod = unwrap(module);
  // Set the `run` attribute on the module to indicate this is a run context
  // (for result handling).
  mod->setAttr(runtime::enableCudaqRun, mlir::UnitAttr::get(mod->getContext()));
  if (noise_model.has_value() && platform.is_remote())
    throw std::runtime_error(
        "Noise model is not supported on remote platforms.");

  async_run_result result;
  result.results = std::make_unique<std::vector<nanobind::object>>();
  result.error = std::make_unique<std::string>();

  if (shots_count == 0) {
    std::promise<void> promise;
    result.ready = promise.get_future();
    promise.set_value();
    return result;
  }

  std::promise<detail::RunResultSpan> spanPromise;
  auto spanFuture = spanPromise.get_future();

  std::promise<std::string> errorPromise;
  auto errorFuture = errorPromise.get_future();

  auto fnOp = getFuncOpAndCheckResult(mod, shortName);
  auto opaques = marshal_arguments_for_module_launch(mod, runtimeArgs, fnOp);
  // Run the kernel and compute results span.
  {
    // Release GIL to allow c++ threads, all code inside the scope is c++, so
    // there is no need to re-acquire the GIL inside the thread.
    nanobind::gil_scoped_release gil_release{};
    QuantumTask wrapped = detail::make_copyable_function(
        [sp = std::move(spanPromise), ep = std::move(errorPromise),
         noise_model = std::move(noise_model), qpu_id, name = shortName,
         opaques = std::move(opaques), shots_count,
         mod = mod.clone()]() mutable {
          auto &platform = get_platform();

          // Launch the kernel in the appropriate context.
          if (noise_model.has_value())
            platform.set_noise(&noise_model.value());
          try {
            auto span = pyRunTheKernel(name, platform, mod, nullptr,
                                       shots_count, qpu_id, opaques, false);
            sp.set_value(span);
            ep.set_value("");