Adding circuit executor classes and shot-branching

qiskit_aer/backends/aer_simulator.py

@@ -288,6 +288,19 @@ class AerSimulator(AerBackend):
       threads per GPU. This parameter is used to optimize Pauli noise
       simulation with multiple-GPUs (Default: 1).
 
+    * ``shot_branching_enable`` (bool): This option enables/disables
+      optimized multi-shots simulation starting from single state and
+      state will be branched when some operations with randomness
+      (i.e. measure, reset, noises, etc.) is applied (Default: True).
+      This option can decrease runs of shots if there will be less branches
+      than number of shots.
+      This option is available for ``"statevector"``, ``"density_matrix"``.
+      For GPU, ``cuStateVec_enable`` is not supported for this option.
+
+    * ``runtime_noise_sampling_enable`` (bool): This option enables/disables
+      runtime noise sampling. This option is only applicable when
+      ``shot_branching_enable`` is also True. (Default: False).
+
     These backend options only apply when using the ``"statevector"``
     simulation method:
 
@@ -702,6 +715,9 @@ def _default_options(cls):
             batched_shots_gpu=False,
             batched_shots_gpu_max_qubits=16,
             num_threads_per_device=1,
+            # multi-shot branching
+            shot_branching_enable=True,
+            runtime_noise_sampling_enable=False,
             # statevector options
             statevector_parallel_threshold=14,
             statevector_sample_measure_opt=10,

qiskit_aer/backends/wrappers/aer_controller_binding.hpp

@@ -182,6 +182,11 @@ void bind_aer_controller(MODULE m) {
       [](Config &config, uint_t val) {
         config.num_threads_per_device.value(val);
       });
+  // # multi-shot branching
+  aer_config.def_readwrite("shot_branching_enable",
+                           &Config::shot_branching_enable);
+  aer_config.def_readwrite("runtime_noise_sampling_enable",
+                           &Config::runtime_noise_sampling_enable);
   // # statevector options
   aer_config.def_readwrite("statevector_parallel_threshold",
                            &Config::statevector_parallel_threshold);

releasenotes/notes/add_executor-ba4870f86ed5d8ec.yaml

@@ -0,0 +1,21 @@
+---
+features:
+  - |
+    This release restructures ``State`` classes.
+    Adding circuit executor classes that runs a circuit and manages multiple
+    states for multi-shots simulations or multi-chunk simulations for large
+    number of qubits.
+    Previously ``StateChunk`` class manages multiple chunks for multi-shots or
+    multi-chunk simulations but now ``State`` class only has one state
+    and all the parallelization codes are moved to ``Executor`` classes.
+    Now all ``State`` classes are independent from parallelization.
+    Also some of the functions in ``Aer::Controller`` class are moved to
+    ``CircuitExecutor::Executor`` class.
+  - |
+    Shot-branching technique that decreases calculation of multi-shots
+    simulation is implemented with restructured ``Executor`` classes.
+    Shot-branching is currently applicable to statevector density matrix
+    and tensor-network methods.
+    By default ``shot_branching_enable`` is enabled.
+    And by setting ``runtime_noise_sampling_enable``, noise sampling is
+    done on the fly with shot-branching.