[refactoring] Tease apart explicit_measurements option into its own context

python/cudaq/runtime/sample.py

@@ -21,10 +21,11 @@ def __broadcastSample(kernel,
     N = len(argSet)
     results = []
     for i, a in enumerate(argSet):
-        ctx = cudaq_runtime.ExecutionContext('sample', shots_count)
+        ctx = cudaq_runtime.ExecutionContext(
+            "sample_explicit" if explicit_measurements else "sample",
+            shots_count)
         ctx.totalIterations = N
         ctx.batchIteration = i
-        ctx.explicitMeasurements = explicit_measurements
         cudaq_runtime.setExecutionContext(ctx)
         kernel(*a)
         res = ctx.result
@@ -111,9 +112,9 @@ def sample(kernel,
         cudaq_runtime.unset_noise()
         return res
 
-    ctx = cudaq_runtime.ExecutionContext("sample", shots_count)
+    ctx = cudaq_runtime.ExecutionContext(
+        "sample_explicit" if explicit_measurements else "sample", shots_count)
     ctx.hasConditionalsOnMeasureResults = has_conditionals_on_measure_result
-    ctx.explicitMeasurements = explicit_measurements
     cudaq_runtime.setExecutionContext(ctx)
 
     counts = cudaq_runtime.SampleResult()

python/runtime/common/py_ExecutionContext.cpp

@@ -36,8 +36,6 @@ void bindExecutionContext(py::module &mod) {
       .def_readwrite("batchIteration", &cudaq::ExecutionContext::batchIteration)
       .def_readwrite("numberTrajectories",
                      &cudaq::ExecutionContext::numberTrajectories)
-      .def_readwrite("explicitMeasurements",
-                     &cudaq::ExecutionContext::explicitMeasurements)
       .def_readonly("invocationResultBuffer",
                     &cudaq::ExecutionContext::invocationResultBuffer)
       .def("setSpinOperator",

runtime/common/BaseRemoteRESTQPU.h

@@ -19,6 +19,7 @@
 #include "common/Resources.h"
 #include "common/RestClient.h"
 #include "common/RuntimeMLIR.h"
+#include "common/SamplingMode.h"
 #include "cudaq.h"
 #include "cudaq/Frontend/nvqpp/AttributeNames.h"
 #include "cudaq/Optimizer/Builder/Intrinsics.h"
@@ -711,7 +712,7 @@ class BaseRemoteRESTQPU : public QPU {
     }
 
     if (executionContext) {
-      if (executionContext->name == "sample") {
+      if (cudaq::details::isSamplingContext(executionContext)) {
         executionContext->reorderIdx = mapping_reorder_idx;
         // No need to add measurements only to remove them eventually
         if (postCodeGenPasses.find("remove-measurements") == std::string::npos)

runtime/common/ExecutionContext.h

@@ -124,10 +124,6 @@ class ExecutionContext {
   /// calculation on simulation backends that support trajectory simulation.
   std::optional<std::size_t> numberTrajectories = std::nullopt;
 
-  /// @brief Whether or not to simply concatenate measurements in execution
-  /// order.
-  bool explicitMeasurements = false;
-
   /// @brief Probability of occurrence of each error mechanism (column) in
   /// Measurement Syndrome Matrix (0-1 range).
   std::optional<std::vector<double>> msm_probabilities;

runtime/common/SamplingMode.h

@@ -0,0 +1,56 @@
+/****************************************************************-*- C++ -*-****
+ * Copyright (c) 2025 NVIDIA Corporation & Affiliates.                         *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+#include "ExecutionContext.h"
+
+namespace cudaq::details {
+
+enum class SamplingMode {
+  // Standard sampling mode, measurements are ordered by the qubit allocation
+  // order, no duplicates
+  Default,
+  // Explicit measurement mode, measurements are concatenated by the execution
+  // order, duplicates allowed
+  Explicit,
+};
+
+/// Derive sampling mode from execution context
+inline SamplingMode getSamplingMode(const ExecutionContext *ctx) {
+  if (!ctx)
+    throw std::runtime_error("ExecutionContext is null.");
+  if (ctx->name == "sample")
+    return SamplingMode::Default;
+  if (ctx->name == "sample_explicit")
+    return SamplingMode::Explicit;
+  throw std::runtime_error("Unknown sampling mode - " + ctx->name);
+}
+
+/// Check if this is any sampling context
+inline bool isSamplingContext(const ExecutionContext *ctx) {
+  if (!ctx)
+    throw std::runtime_error("ExecutionContext is null.");
+  return ctx->name.find("sample") != std::string::npos;
+}
+
+/// Check if this is explicit measurements sampling mode
+inline bool isExplicitSamplingMode(const ExecutionContext *ctx) {
+  if (!ctx)
+    throw std::runtime_error("ExecutionContext is null.");
+  return getSamplingMode(ctx) == SamplingMode::Explicit;
+}
+
+/// Derive sampling mode from execution context name
+inline SamplingMode getSamplingMode(const std::string &contextName) {
+  if (contextName == "sample")
+    return SamplingMode::Default;
+  if (contextName == "sample_explicit")
+    return SamplingMode::Explicit;
+  throw std::runtime_error("Unknown sampling mode - " + contextName);
+}
+
+} // namespace cudaq::details

runtime/cudaq/algorithms/sample.h

@@ -54,12 +54,12 @@ runSampling(KernelFunctor &&wrappedKernel, quantum_platform &platform,
           "kernel with conditional logic on a measurement result.");
   }
   // Create the execution context.
-  auto ctx = std::make_unique<ExecutionContext>("sample", shots);
+  auto ctx = std::make_unique<ExecutionContext>(
+      explicitMeasurements ? "sample_explicit" : "sample", shots);
   ctx->kernelName = kernelName;
   ctx->batchIteration = batchIteration;
   ctx->totalIterations = totalBatchIters;
   ctx->hasConditionalsOnMeasureResults = hasConditionalFeebdback;
-  ctx->explicitMeasurements = explicitMeasurements;
 
 #ifdef CUDAQ_LIBRARY_MODE
   // If we have a kernel that has its quake code registered, we