wip, I need to make a flattened stim_data type

Signed-off-by: Kevin Mato <[email protected]>

Author: kvmto

runtime/common/ExecutionContext.h

@@ -20,9 +20,33 @@
 
 namespace cudaq {
 
+struct RecordStorage{
+
+  size_t memory_limit;
+  size_t current_memory;
+  RecordStorage(size_t limit = 1e9) : memory_limit(limit), current_memory(0) {}
+
+  std::vector<std::unique_ptr<SimulationState>> recordedStates;
+    void save_state(const SimulationState *state) {
+      recordedStates.push_back(std::make_unique<SimulationState>(*state););
+    }
+    std::vector<std::unique_ptr<SimulationState>> get_recorded_states() const { return recordedStates; }
+    
+    void clear() { recordedStates.clear(); }
+    void dump_recorded_states() const {
+      for (std::size_t i = 0; i < recordedStates.size(); i++) {
+        recordedStates[i]->dump(std::cout);
+      }
+    }
+}
+
 /// The ExecutionContext is an abstraction to indicate how a CUDA-Q kernel
 /// should be executed.
 class ExecutionContext {
+
+  ///@brief record storage for the states saved during execution
+  RecordStorage recordStorage;
+
 public:
   /// @brief The Constructor, takes the name of the context
   /// @param n The name of the context
@@ -155,6 +179,23 @@ class ExecutionContext {
   std::vector<std::vector<std::size_t>> errors_per_shot; // errors_per_shot[shot][error_id]
 
   /// @brief Save the current simulation state in the recorded states storage.
-  void save_state(const SimulationState *state);
+  void save_state(const SimulationState *state){
+    recordStorage.save_state(state);
+  }
+
+  /// @brief Get the recorded states saved during execution.
+  std::vector<std::unique_ptr<SimulationState>> get_recorded_states() const {
+    return recordStorage.get_recorded_states();
+  }
+
+  /// @brief Clear the recorded states saved during execution.
+  void clear_recorded_states(){
+    recordStorage.clear();
+  }
+
+  /// @brief Dump the recorded states saved during execution.
+  void dump_recorded_states() const{
+    recordStorage.dump_recorded_states();
+  }
 };
 } // namespace cudaq

runtime/common/SimulationState.h

@@ -21,6 +21,51 @@ class SimulationState;
 /// Enum to specify the initial quantum state.
 enum class InitialState { ZERO, UNIFORM };
 
+struct StimData {
+    struct TableauClone {
+        std::vector<std::vector<bool>> x_output;
+        std::vector<std::vector<bool>> z_output;
+        std::vector<bool> r_output;
+
+        TableauClone copy() const {
+            TableauClone t;
+            t.x_output = x_output;
+            t.z_output = z_output;
+            t.r_output = r_output;
+            return t;
+        }
+    } tableau;
+
+    struct PauliFrameClone {
+        std::vector<bool> x;
+        std::vector<bool> z;
+
+        PauliFrameClone copy() const {
+            PauliFrameClone f;
+            f.x = x;
+            f.z = z;
+            return f;
+        }
+    } frame;
+
+    std::size_t current_size = 0;
+    std::size_t msm_err_count = 0;
+    uint64_t num_qubits = 0;
+    void* data() { return nullptr; }
+
+    // Copy helper for the entire StimData
+    StimData copy() const {
+        StimData s;
+        s.tableau = tableau.copy();
+        s.frame = frame.copy();
+        s.current_size = current_size;
+        s.msm_err_count = msm_err_count;
+        s.num_qubits = num_qubits;
+        return s;
+    }
+};
+
+
 /// @brief Encapsulates a list of tensors (data pointer and dimensions).
 // Note: tensor data is expected in column-major.
 using TensorStateData =
@@ -31,7 +76,8 @@ using TensorStateData =
 using state_data = std::variant<
     std::vector<std::complex<double>>, std::vector<std::complex<float>>,
     std::pair<std::complex<double> *, std::size_t>,
-    std::pair<std::complex<float> *, std::size_t>, TensorStateData>;
+    std::pair<std::complex<float> *, std::size_t>, TensorStateData,
+    StimData>;
 
 /// @brief The `SimulationState` interface provides and extension point
 /// for concrete circuit simulation sub-types to describe their
@@ -131,6 +177,14 @@ class SimulationState {
           const_cast<TensorStateData::value_type *>(dataCasted.data()),
           data.index());
     }
+    if (std::holds_alternative<StimData>(data)) {
+      if (isArrayLike())
+        throw std::runtime_error(
+            "Cannot initialize state vector/density matrix state by stim "
+            "data. Please use stabilizer simulator backends.");
+      auto &dataCasted = std::get<StimData>(data);
+      return createFromSizeAndPtr(1, const_cast<StimData*>(&dataCasted), data.index());
+    }
     // Flat array state data
     // Check the precision first. Get the size and
     // data pointer from the input data.

runtime/nvqir/stim/StimState.h

@@ -0,0 +1,123 @@
+/*************************************************************** -*- 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.    *
+ ******************************************************************************/
+#pragma once
+
+#include "common/SimulationState.h"
+#include <iostream>
+#include <memory>
+#include <variant>
+#include <stdexcept>
+
+namespace cudaq {
+
+/// @brief Provides stabilizer simulation state representation using StimData.
+class StimState : public SimulationState {
+public:
+  /// @brief Construct from StimData (may copy).
+  explicit StimState(const StimData& d) : data_(d.copy()) {}
+
+  /// @brief Construct from an rvalue StimData
+  explicit StimState(StimData&& d) : data_(std::move(d)) {}
+
+  /// @brief Factory for this type from state_data.
+  std::unique_ptr<SimulationState>
+  createFromData(const state_data& d) override {
+    if (!std::holds_alternative<StimData>(d))
+      throw std::runtime_error("[StimState] only supports StimData for initialization.");
+    return std::make_unique<StimState>(std::get<StimData>(d));
+  }
+
+protected:
+  /// @brief Create from data pointer.
+  std::unique_ptr<SimulationState>
+  createFromSizeAndPtr(std::size_t, void* ptr, std::size_t dataType) override {
+    if (dataType != state_data::variant_type_index<StimData>())
+      throw std::runtime_error("[StimState] only supports StimData for initialization.");
+    auto stim_data = static_cast<StimData*>(ptr);
+    return std::make_unique<StimState>(*stim_data);
+  }
+
+public:
+  /// @brief This simulator is not array-like (must use Pauli frame/tableau APIs).
+  bool isArrayLike() const override { return false; }
+
+  /// @brief Return the number of qubits.
+  std::size_t getNumQubits() const override { return data_.num_qubits; }
+
+  /// @brief Tensor interface not supported for StimState.
+  Tensor getTensor(std::size_t idx = 0) const override {
+    throw std::runtime_error("[StimState] Tensor interface not supported.");
+  }
+
+  std::vector<Tensor> getTensors() const override { return {}; }
+  std::size_t getNumTensors() const override { return 0; }
+
+  /// @brief Overlap is not implemented for stabilizer states.
+  std::complex<double> overlap(const SimulationState& other) override {
+    throw std::runtime_error("[StimState] overlap not implemented for stabilizer data.");
+  }
+
+  /// @brief Amplitude access not supported for StimState.
+  std::complex<double> getAmplitude(const std::vector<int>&) override {
+    throw std::runtime_error("[StimState] amplitudes not supported for stabilizer states.");
+  }
+
+  /// @brief Dump stabilizer state summary.
+  void dump(std::ostream &os) const override {
+    os << "StimState { qubits=" << data_.num_qubits
+       << ", msm_err_count=" << data_.msm_err_count
+       << ", current_size=" << data_.current_size << " }";
+    // Optionally list the tableau or Pauli frame if desired
+    os << "\nTableau X_output:\n";
+    for (const auto& row : data_.tableau.x_output) {
+      for (bool b : row) os << (b ? '1' : '0');
+      os << "\n";
+    }
+    os << "Tableau Z_output:\n";
+    for (const auto& row : data_.tableau.z_output) {
+      for (bool b : row) os << (b ? '1' : '0');
+      os << "\n";
+    }
+    os << "PauliFrame X:\n";
+    for (bool b : data_.frame.x) os << (b ? '1' : '0');
+    os << "\nPauliFrame Z:\n";
+    for (bool b : data_.frame.z) os << (b ? '1' : '0');
+    os << "\n";
+  }
+
+  /// @brief Precision is always double for stabilizer/Stim data.
+  precision getPrecision() const override { return precision::fp64; }
+
+  /// @brief Destroy any resources (none needed here).
+  void destroyState() override {
+    // No-op: All managed by RAII.
+  }
+
+  /// @brief Returns a const reference to the tableau (stabilizer generator).
+  const StimData::TableauClone& getTableau() const { return data_.tableau; }
+
+  /// @brief Returns a const reference to the Pauli frame.
+  const StimData::PauliFrameClone& getPauliFrame() const { return data_.frame; }
+
+  /// @brief Access StimData internals, if needed.
+  const StimData& stim_data() const { return data_; }
+
+    void set_tableau(const StimData::TableauClone& t) { data_.set_tableau(t); }
+    void set_pauli_frame(const StimData::PauliFrameClone& f) { data_.set_pauli_frame(f); }
+    void set_current_size(std::size_t s) { data_.set_current_size(s); }
+    void set_msm_err_count(std::size_t c) { data_.set_msm_err_count(c); }
+    void set_num_qubits(uint64_t n) { data_.set_num_qubits(n); }
+
+    
+
+
+private:
+  StimData data_;
+};
+
+} // namespace cudaq