Remove skipPipelineSubstitution boolean in getCompileTarget

Signed-off-by: Luca Mondada <luca@mondada.net>

Author: lmondada

docs/sphinx/using/backends/hardware/backend_iqm.rst

@@ -20,6 +20,11 @@ Emulation Mode
     This can be done by setting `mapping_file` to point to a file describing the QPU architecture which should be emulated.
     If an architecture is specified no server URL is needed anymore.
 
+    Without an architecture file, the target attempts to fetch the dynamic quantum architecture from the server.
+    If that fetch fails (for example due to missing authentication or no network access), CUDA-Q emits a warning and continues.
+    Execution modes that do not require qubit mapping, such as detector error model generation, still work in that case.
+    Execution that does require qubit mapping will fail later with an unresolved architecture placeholder.
+
     .. code:: python
 
         cudaq.set_target('iqm', emulate=True, mapping_file="<path+filename>")
@@ -53,6 +58,11 @@ Emulation Mode
     This can be done by specifying a file with the architecture either at compile time or in an variable in the environment executing the binary.
     If an architecture is specified no server URL is needed anymore.
 
+    Without an architecture file, the target attempts to fetch the dynamic quantum architecture from the server.
+    If that fetch fails (for example due to missing authentication or no network access), CUDA-Q emits a warning and continues.
+    Execution modes that do not require qubit mapping, such as detector error model generation, still work in that case.
+    Execution that does require qubit mapping will fail later with an unresolved architecture placeholder.
+
     .. code:: bash
 
         // With this binary multiple QPU architectures can be tested without recompilation.

python/runtime/cudaq/platform/py_alt_launch_kernel.cpp

@@ -706,9 +706,9 @@ static std::pair<cudaq::CompileTarget, cudaq::CompileOptions>
 getCompileConfig(std::optional<cudaq::CompileTarget> target = std::nullopt) {
   auto *ctx = cudaq::getExecutionContext();
   cudaq::CompileOptions options;
+  if (!target)
+    target = cudaq::get_compile_target();
   if (!ctx) {
-    if (!target)
-      target = cudaq::get_compile_target(cudaq::other_policies{});
     options = cudaq::get_compile_options(cudaq::other_policies{});
   } else {
     cudaq::policies::withPolicy(ctx->name, [&](auto policy) {
@@ -717,8 +717,6 @@ getCompileConfig(std::optional<cudaq::CompileTarget> target = std::nullopt) {
         policy.spin = ctx->spin.value();
       }
 
-      if (!target)
-        target = cudaq::get_compile_target(policy);
       options = cudaq::get_compile_options(policy);
     });
   }

runtime/common/BaseRemoteRESTQPU.h

@@ -221,12 +221,9 @@ class BaseRemoteRESTQPU : public QPU {
                                         serverHelper, executor);
   }
 
-  CompileTarget
-  getCompileTarget(bool skipPipelineSubstitutions = false) override {
-    std::map<std::string, std::string> pipelineSubstitutions{};
-    if (!skipPipelineSubstitutions)
-      pipelineSubstitutions =
-          serverHelper->getPipelineSubstitutions(platformPath);
+  CompileTarget getCompileTarget() override {
+    auto pipelineSubstitutions =
+        serverHelper->getPipelineSubstitutions(platformPath);
     auto target = CompileTarget::createFromConfig(targetConfig, backendConfig,
                                                   pipelineSubstitutions);
     target.pipelineConfig.replaceStateWithKernel = true;

runtime/cudaq/algorithms/launch.h

@@ -80,11 +80,10 @@ auto launch(const Policy &policy, std::size_t qpu_id, ExecutionContext &ctx,
       cudaq::CompileOptions options;
       if constexpr (requires { policy.inner; }) {
         options = cudaq::get_compile_options(policy.inner);
-        target = platform.getCompileTarget(policy.inner, qpu_id);
       } else {
         options = cudaq::get_compile_options(policy);
-        target = platform.getCompileTarget(policy, qpu_id);
       }
+      target = platform.getCompileTarget(qpu_id);
       const bool isEmulated = platform.is_emulated(qpu_id);
       const bool isRemote = platform.is_remote(qpu_id);
       options.emulate = isEmulated;

runtime/cudaq/platform.h

@@ -42,9 +42,8 @@ inline bool is_simulator_platform() {
   return getQuantumPlatformInternal()->is_simulator();
 }
 
-template <typename Policy>
-cudaq::CompileTarget get_compile_target(const Policy &policy) {
-  return getQuantumPlatformInternal()->getCompileTarget(policy);
+inline cudaq::CompileTarget get_compile_target() {
+  return getQuantumPlatformInternal()->getCompileTarget();
 }
 
 /// Get the default compile target configuration for the given platform

runtime/cudaq/platform/default/DefaultQPU.cpp

@@ -169,7 +169,7 @@ cudaq::DefaultQPU::launchKernel(const cudaq::ptsbe::sample_policy &policy,
   });
 }
 
-cudaq::CompileTarget cudaq::DefaultQPU::getCompileTarget(bool) {
+cudaq::CompileTarget cudaq::DefaultQPU::getCompileTarget() {
   return createDefaultCompileTarget();
 }
 

runtime/cudaq/platform/default/DefaultQPU.h

@@ -72,8 +72,7 @@ class DefaultQPU : public QPU {
   launchKernel(const ptsbe::sample_policy &policy, const CompiledModule &module,
                KernelArgs args) override;
 
-  CompileTarget
-  getCompileTarget(bool skipPipelineSubstitutions = false) override;
+  CompileTarget getCompileTarget() override;
 
   void configureExecutionContext(ExecutionContext &context) const override;
   void beginExecution() override;

runtime/cudaq/platform/default/rest/helpers/iqm/IQMServerHelper.cpp

@@ -450,9 +450,18 @@ std::map<std::string, std::string> IQMServerHelper::getPipelineSubstitutions(
       // Use provided string as path+filename
       pathToFile = iter->second;
     } else {
-      // Use the dynamic quantum architecture of the configured IQM server
-      fetchQuantumArchitecture();
-      pathToFile = writeQuantumArchitectureFile();
+      // Use the dynamic quantum architecture of the configured IQM server.
+      // Fallback to an empty substitution map and let the pipeline report the
+      // problem if it is ever actually used.
+      try {
+        fetchQuantumArchitecture();
+        pathToFile = writeQuantumArchitectureFile();
+      } catch (const std::exception &e) {
+        CUDAQ_WARN("Leaving %QPU_ARCH% unresolved: {}. Set IQM_QPU_QA or pass "
+                   "--mapping-file to supply it offline.",
+                   e.what());
+        return {};
+      }
     }
   }
   CUDAQ_INFO("Using quantum architecture file: {}", pathToFile);

runtime/cudaq/platform/fermioniq/FermioniqQPU.h

@@ -36,10 +36,8 @@ class FermioniqQPU : public BaseRemoteRESTQPU {
     }
   }
 
-  CompileTarget
-  getCompileTarget(bool skipPipelineSubstitutions = false) override {
-    auto target =
-        BaseRemoteRESTQPU::getCompileTarget(skipPipelineSubstitutions);
+  CompileTarget getCompileTarget() override {
+    auto target = BaseRemoteRESTQPU::getCompileTarget();
     target.supportObservableMeasurements = true;
     return target;
   }

runtime/cudaq/platform/orca/OrcaRemoteRESTQPU.h

@@ -92,8 +92,7 @@ class OrcaRemoteRESTQPU : public cudaq::QPU {
   [[nodiscard]] KernelThunkResultType
   launchKernelCommon(const std::string &kernelName, void *args);
 
-  CompileTarget
-  getCompileTarget(bool skipPipelineSubstitutions = false) override {
+  CompileTarget getCompileTarget() override {
     return {
         .supportExplicitMeasurements = false,
     };