reflect review comments

src/controllers/controller.hpp

@@ -51,6 +51,7 @@
 #include "noise/noise_model.hpp"
 #include "transpile/basic_opts.hpp"
 #include "transpile/truncate_qubits.hpp"
+#include "transpile/cacheblocking.hpp"
 
 namespace AER {
 namespace Base {
@@ -221,6 +222,14 @@ class Controller {
 
   void save_exception_to_results(Result &result,const std::exception &e);
 
+
+  //setting cache blocking transpiler
+  Transpile::CacheBlocking transpile_cache_blocking(const Circuit& circ,
+                                     const Noise::NoiseModel& noise,
+                                     const json_t& config,
+                                     const size_t complex_size,bool is_matrix) const;
+
+
   // Get system memory size
   size_t get_system_memory_mb();
   size_t get_gpu_memory_mb();
@@ -679,6 +688,27 @@ void Controller::save_exception_to_results(Result &result,const std::exception &
   }
 }
 
+Transpile::CacheBlocking Controller::transpile_cache_blocking(const Circuit& circ,
+                                     const Noise::NoiseModel& noise,
+                                     const json_t& config,
+                                     const size_t complex_size,bool is_matrix) const
+{
+  Transpile::CacheBlocking cache_block_pass;
+
+  cache_block_pass.set_config(config);
+  if(!cache_block_pass.enabled()){
+    //if blocking is not set by config, automatically set if required
+    if(multiple_chunk_required(circ,noise)){
+      int nplace = num_process_per_experiment_;
+      if(num_gpus_ > 0)
+        nplace *= num_gpus_;
+      cache_block_pass.set_blocking(circ.num_qubits, get_min_memory_mb() << 20, nplace, complex_size,is_matrix);
+    }
+  }
+
+  return cache_block_pass;
+}
+
 //-------------------------------------------------------------------------
 // Qobj execution
 //-------------------------------------------------------------------------

src/controllers/qasm_controller.hpp

@@ -215,11 +215,6 @@ class QasmController : public Base::Controller {
                                      const Operations::OpSet &opset,
                                      const json_t& config) const;
 
-
-  Transpile::CacheBlocking transpile_cache_blocking(const Circuit& circ,
-                                     const Noise::NoiseModel& noise,
-                                     const json_t& config) const;
-
   //----------------------------------------------------------------
   // Run circuit helpers
   //----------------------------------------------------------------
@@ -930,42 +925,6 @@ Transpile::Fusion QasmController::transpile_fusion(Method method,
   return fusion_pass;
 }
 
-Transpile::CacheBlocking QasmController::transpile_cache_blocking(const Circuit& circ,
-                                   const Noise::NoiseModel& noise,
-                                   const json_t& config) const
-{
-  Transpile::CacheBlocking cache_block_pass;
-
-  cache_block_pass.set_config(config);
-  if(!cache_block_pass.enabled()){
-    //if blocking is not set by config, automatically set if required
-    if(Base::Controller::multiple_chunk_required(circ,noise)){
-      int nplace = Base::Controller::num_process_per_experiment_;
-      if(Base::Controller::num_gpus_ > 0)
-        nplace *= Base::Controller::num_gpus_;
-
-      size_t complex_size = (simulation_precision_ == Precision::single_precision) ? sizeof(std::complex<float>) : sizeof(std::complex<double>);
-
-      switch (simulation_method(circ, noise, false)) {
-        case Method::statevector:
-        case Method::statevector_thrust_cpu:
-        case Method::statevector_thrust_gpu:
-          cache_block_pass.set_blocking(circ.num_qubits, Base::Controller::get_min_memory_mb() << 20, nplace, complex_size,false);
-          break;
-        case Method::density_matrix:
-        case Method::density_matrix_thrust_cpu:
-        case Method::density_matrix_thrust_gpu:
-          cache_block_pass.set_blocking(circ.num_qubits, Base::Controller::get_min_memory_mb() << 20, nplace, complex_size,true);
-          break;
-        default:
-          throw std::runtime_error("QasmController: No enough memory to simulate this method on the sysytem");
-      }
-    }
-  }
-
-  return cache_block_pass;
-}
-
 void QasmController::set_parallelization_circuit(
     const Circuit& circ,
     const Noise::NoiseModel& noise_model) {
@@ -1140,7 +1099,10 @@ void QasmController::run_circuit_helper(const Circuit& circ,
   auto fusion_pass = transpile_fusion(method, opt_circ.opset(), config);
   fusion_pass.optimize_circuit(opt_circ, dummy_noise, state.opset(), result);
 
-  auto cache_block_pass = transpile_cache_blocking(opt_circ,noise,config);
+  bool is_matrix = false;
+  if(method == Method::density_matrix || method == Method::density_matrix_thrust_gpu || method == Method::density_matrix_thrust_cpu)
+   is_matrix = true;
+  auto cache_block_pass = transpile_cache_blocking(opt_circ,noise,config,(simulation_precision_ == Precision::single_precision) ? sizeof(std::complex<float>) : sizeof(std::complex<double>),is_matrix);
   cache_block_pass.optimize_circuit(opt_circ, dummy_noise, state.opset(), result);
 
   uint_t block_bits = 0;
@@ -1218,7 +1180,10 @@ void QasmController::run_circuit_with_sampled_noise(const Circuit& circ,
   measure_pass.set_config(config);
   Noise::NoiseModel dummy_noise;
 
-  auto cache_block_pass = transpile_cache_blocking(circ,noise,config);
+  bool is_matrix = false;
+  if(method == Method::density_matrix || method == Method::density_matrix_thrust_gpu || method == Method::density_matrix_thrust_cpu)
+   is_matrix = true;
+  auto cache_block_pass = transpile_cache_blocking(circ,noise,config,(simulation_precision_ == Precision::single_precision) ? sizeof(std::complex<float>) : sizeof(std::complex<double>),is_matrix);
 
   // Sample noise using circuit method
   while (shots-- > 0) {

src/controllers/statevector_controller.hpp

@@ -355,18 +355,7 @@ void StatevectorController::run_circuit_helper(
     fusion_pass.optimize_circuit(opt_circ, dummy_noise, state.opset(), result);
   }
 
-  Transpile::CacheBlocking cache_block_pass;
-  cache_block_pass.set_config(config);
-  if(!cache_block_pass.enabled()){
-    //if blocking is not set by config, automatically set if required
-    if(Base::Controller::multiple_chunk_required(opt_circ,noise)){
-      int nplace = Base::Controller::num_process_per_experiment_;
-      if(Base::Controller::num_gpus_ > 0)
-        nplace *= Base::Controller::num_gpus_;
-      size_t complex_size = (precision_ == Precision::single_precision) ? sizeof(std::complex<float>) : sizeof(std::complex<double>);
-      cache_block_pass.set_blocking(circ.num_qubits, Base::Controller::get_min_memory_mb() << 20, nplace, complex_size,false);
-    }
-  }
+  Transpile::CacheBlocking cache_block_pass = transpile_cache_blocking(opt_circ,dummy_noise,config,(precision_ == Precision::single_precision) ? sizeof(std::complex<float>) : sizeof(std::complex<double>),false);
   cache_block_pass.optimize_circuit(opt_circ, dummy_noise, state.opset(), result);
 
   uint_t block_bits = 0;

src/controllers/unitary_controller.hpp

@@ -356,18 +356,7 @@ void UnitaryController::run_circuit_helper(
     fusion_pass.optimize_circuit(opt_circ, dummy_noise, state.opset(), result);
   }
 
-  Transpile::CacheBlocking cache_block_pass;
-  cache_block_pass.set_config(config);
-  if(!cache_block_pass.enabled()){
-    //if blocking is not set by config, automatically set if required
-    if(Base::Controller::multiple_chunk_required(opt_circ,noise)){
-      int nplace = Base::Controller::num_process_per_experiment_;
-      if(Base::Controller::num_gpus_ > 0)
-        nplace *= Base::Controller::num_gpus_;
-      size_t complex_size = (precision_ == Precision::single_precision) ? sizeof(std::complex<float>) : sizeof(std::complex<double>);
-      cache_block_pass.set_blocking(circ.num_qubits, Base::Controller::get_min_memory_mb() << 20, nplace, complex_size,true);
-    }
-  }
+  Transpile::CacheBlocking cache_block_pass = transpile_cache_blocking(opt_circ,dummy_noise,config,(precision_ == Precision::single_precision) ? sizeof(std::complex<float>) : sizeof(std::complex<double>),true);
   cache_block_pass.optimize_circuit(opt_circ, dummy_noise, state.opset(), result);
 
   uint_t block_bits = 0;

src/simulators/density_matrix/densitymatrix_state_chunk.hpp

@@ -30,6 +30,32 @@
 namespace AER {
 namespace DensityMatrixChunk {
 
+using OpType = Operations::OpType;
+
+// OpSet of supported instructions
+const Operations::OpSet StateOpSet(
+    // Op types
+    {OpType::gate, OpType::measure,
+     OpType::reset, OpType::snapshot,
+     OpType::barrier, OpType::bfunc,
+     OpType::roerror, OpType::matrix,
+     OpType::diagonal_matrix, OpType::kraus,
+     OpType::superop, OpType::save_expval,
+     OpType::save_expval_var, OpType::save_densmat,
+     OpType::save_probs, OpType::save_probs_ket,
+     OpType::save_amps_sq
+     },
+    // Gates
+    {"U",    "CX",  "u1", "u2",  "u3", "u",   "cx",   "cy",  "cz",
+     "swap", "id",  "x",  "y",   "z",  "h",   "s",    "sdg", "t",
+     "tdg",  "ccx", "r",  "rx",  "ry", "rz",  "rxx",  "ryy", "rzz",
+     "rzx",  "p",   "cp", "cu1", "sx", "x90", "delay", "pauli"},
+    // Snapshots
+    {"density_matrix", "memory", "register", "probabilities",
+     "probabilities_with_variance", "expectation_value_pauli",
+     "expectation_value_pauli_with_variance"});
+
+
 //=========================================================================
 // DensityMatrix State subclass
 //=========================================================================
@@ -39,7 +65,7 @@ class State : public Base::StateChunk<densmat_t> {
 public:
   using BaseState = Base::StateChunk<densmat_t>;
 
-  State() : BaseState(DensityMatrix::StateOpSet) {}
+  State() : BaseState(StateOpSet) {}
   virtual ~State() {}
 
   //-----------------------------------------------------------------------
@@ -446,9 +472,8 @@ auto State<densmat_t>::apply_to_matrix(bool copy)
     //TO DO check memory availability
     matrix.resize(1ull << (BaseState::num_qubits_),1ull << (BaseState::num_qubits_));
 
-    auto recv = BaseState::qregs_[0].copy_to_matrix();
-
 #ifdef AER_MPI
+    auto recv = BaseState::qregs_[0].copy_to_matrix();
     //gather states from other processes
     for(iChunk=BaseState::num_local_chunks_;iChunk<BaseState::num_global_chunks_;iChunk++){
       BaseState::recv_data(recv.data(),size,0,iChunk);
@@ -849,10 +874,10 @@ void State<densmat_t>::apply_snapshot(const Operations::Op &op,
       snapshot_pauli_expval(op, result, true);
     } break;
     /* TODO
-    case DensityMatrix::Snapshots::expval_matrix: {
+    case Snapshots::expval_matrix: {
       snapshot_matrix_expval(op, data, false);
     }  break;
-    case DensityMatrix::Snapshots::expval_matrix_var: {
+    case Snapshots::expval_matrix_var: {
       snapshot_matrix_expval(op, data, true);
     }  break;
     */
@@ -947,8 +972,8 @@ cmatrix_t State<densmat_t>::reduced_density_matrix(const reg_t& qubits, bool las
   return reduced_state;
 }
 
-template <class statevec_t>
-cmatrix_t State<statevec_t>::reduced_density_matrix_helper(const reg_t &qubits,
+template <class densmat_t>
+cmatrix_t State<densmat_t>::reduced_density_matrix_helper(const reg_t &qubits,
                                           const reg_t &qubits_sorted) 
 {
   // Get superoperator qubits

src/simulators/statevector/qubitvector_thrust.hpp

@@ -958,11 +958,6 @@ bool QubitVectorThrust<data_t>::fetch_chunk(void) const
   int tid,nid;
   int idev;
 
-//  tid = omp_get_thread_num();
-//  nid = omp_get_num_threads();
-
-//  idev = tid * chunk_manager_.num_devices() / nid;
-
   if(chunk_->device() < 0){
     //on host
     idev = 0;

src/simulators/statevector/statevector_state_chunk.hpp

@@ -33,6 +33,41 @@
 namespace AER {
 namespace StatevectorChunk {
 
+using OpType = Operations::OpType;
+
+// OpSet of supported instructions
+const Operations::OpSet StateOpSet(
+    // Op types
+    {OpType::gate, OpType::measure,
+     OpType::reset, OpType::initialize,
+     OpType::snapshot, OpType::barrier,
+     OpType::bfunc, OpType::roerror,
+     OpType::matrix, OpType::diagonal_matrix,
+     OpType::multiplexer, OpType::kraus,
+     OpType::sim_op, OpType::save_expval,
+     OpType::save_expval_var, OpType::save_densmat,
+     OpType::save_probs, OpType::save_probs_ket,
+     OpType::save_amps, OpType::save_amps_sq,
+     OpType::save_statevec
+     // OpType::save_statevec_ket  // TODO
+     },
+    // Gates
+    {"u1",     "u2",      "u3",  "u",    "U",    "CX",   "cx",   "cz",
+     "cy",     "cp",      "cu1", "cu2",  "cu3",  "swap", "id",   "p",
+     "x",      "y",       "z",   "h",    "s",    "sdg",  "t",    "tdg",
+     "r",      "rx",      "ry",  "rz",   "rxx",  "ryy",  "rzz",  "rzx",
+     "ccx",    "cswap",   "mcx", "mcy",  "mcz",  "mcu1", "mcu2", "mcu3",
+     "mcswap", "mcphase", "mcr", "mcrx", "mcry", "mcry", "sx",   "csx",
+     "mcsx",   "delay", "pauli", "mcx_gray"},
+    // Snapshots
+    {"statevector", "memory", "register", "probabilities",
+     "probabilities_with_variance", "expectation_value_pauli", "density_matrix",
+     "density_matrix_with_variance", "expectation_value_pauli_with_variance",
+     "expectation_value_matrix_single_shot", "expectation_value_matrix",
+     "expectation_value_matrix_with_variance",
+     "expectation_value_pauli_single_shot"});
+
+
 //=========================================================================
 // QubitVector State subclass
 //=========================================================================
@@ -42,7 +77,7 @@ class State : public Base::StateChunk<statevec_t> {
 public:
   using BaseState = Base::StateChunk<statevec_t>;
 
-  State() : BaseState(Statevector::StateOpSet) {}
+  State() : BaseState(StateOpSet) {}
 
   //-----------------------------------------------------------------------
   // Base class overrides

src/simulators/unitary/unitary_state_chunk.hpp

@@ -30,6 +30,23 @@
 namespace AER {
 namespace QubitUnitaryChunk {
 
+// OpSet of supported instructions
+const Operations::OpSet StateOpSet(
+    // Op types
+    {Operations::OpType::gate, Operations::OpType::barrier,
+     Operations::OpType::matrix, Operations::OpType::diagonal_matrix,
+     Operations::OpType::snapshot, Operations::OpType::save_unitary},
+    // Gates
+    {"u1",     "u2",      "u3",  "u",    "U",    "CX",   "cx",   "cz",
+     "cy",     "cp",      "cu1", "cu2",  "cu3",  "swap", "id",   "p",
+     "x",      "y",       "z",   "h",    "s",    "sdg",  "t",    "tdg",
+     "r",      "rx",      "ry",  "rz",   "rxx",  "ryy",  "rzz",  "rzx",
+     "ccx",    "cswap",   "mcx", "mcy",  "mcz",  "mcu1", "mcu2", "mcu3",
+     "mcswap", "mcphase", "mcr", "mcrx", "mcry", "mcry", "sx",   "csx",
+     "mcsx",   "delay", "pauli"},
+    // Snapshots
+    {"unitary"});
+
 //=========================================================================
 // QubitUnitary State subclass
 //=========================================================================
@@ -39,7 +56,7 @@ class State : public Base::StateChunk<unitary_matrix_t> {
 public:
   using BaseState = Base::StateChunk<unitary_matrix_t>;
 
-  State() : BaseState(QubitUnitary::StateOpSet) {}
+  State() : BaseState(StateOpSet) {}
   virtual ~State() = default;
 
   //-----------------------------------------------------------------------
@@ -345,9 +362,8 @@ auto State<unitary_matrix_t>::move_to_matrix()
     //TO DO check memory availability
     matrix.resize(1ull << (BaseState::num_qubits_),1ull << (BaseState::num_qubits_));
 
-    auto recv = BaseState::qregs_[0].copy_to_matrix();
-
 #ifdef AER_MPI
+    auto recv = BaseState::qregs_[0].copy_to_matrix();
     //gather states from other processes
     for(iChunk=BaseState::num_local_chunks_;iChunk<BaseState::num_global_chunks_;iChunk++){
       BaseState::recv_data(recv.data(),size,0,iChunk);

src/transpile/cacheblocking.hpp

@@ -65,7 +65,7 @@ class CacheBlocking : public CircuitOptimization {
   }
 
   //setting blocking parameters automatically
-  void set_blocking(int bits, size_t min_memory, uint_t n_place, size_t complex_size = 16, bool is_matrix = false);
+  void set_blocking(int bits, size_t min_memory, uint_t n_place, const size_t complex_size, bool is_matrix = false);
 
 protected:
   mutable int block_bits_;    //qubits less than this will be blocked