Qiskit Aer

By default, Qiskit Aer runs simulation jobs on a single-worker Python multiprocessing ThreadPool executor, relying on low-level OpenMP and CUDA for parallelization. To customize how multiple circuits are executed in parallel at the job level, you can provide a custom multiprocessing executor and control how circuits are grouped using the executor and max_job_size backend options.

• executor: A multiprocessing executor (e.g., concurrent.futures.ThreadPoolExecutor) used to submit chunks of circuits. Defaults to None.
• max_job_size: Controls the number of circuits in each chunk.
  • If max_job_size=1, every circuit is treated as an individual job. For 60 circuits, Aer submits 60 jobs.
  • If max_job_size=2, circuits are grouped into pairs. For 60 circuits, Aer submits 30 jobs, each containing 2 circuits.

import qiskit
from concurrent.futures import ThreadPoolExecutor
from qiskit_aer import AerSimulator
from math import pi

# Generate circuits
circ = qiskit.QuantumCircuit(15, 15)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.p(pi/2, 2)
circ.measure([0, 1, 2], [0, 1 ,2])

circ2 = qiskit.QuantumCircuit(15, 15)
circ2.h(0)
circ2.cx(0, 1)
circ2.cx(1, 2)
circ2.p(pi/2, 2)
circ2.measure([0, 1, 2], [0, 1 ,2])
circ_list = [circ, circ2]

qbackend = AerSimulator()

# Set executor and max_job_size
exc = ThreadPoolExecutor(max_workers=2)
qbackend.set_options(executor=exc)
qbackend.set_options(max_job_size=1)
result = qbackend.run(circ_list).result()

Installing from source allows you to use the latest development version. You should first follow the Qiskit source installation instructions.

To build from source:

1. Clone the repository.
2. Install development dependencies using requirements-dev.txt.
3. Install the package using pip install . or build a wheel using the build module.

Building with GPU support To enable GPU acceleration (CUDA) during a source build on Linux, set the AER_THRUST_BACKEND=CUDA flag.

Building with MPI support To enable MPI support for parallelizing statevector, density_matrix, or unitary simulations, ensure an MPI library (like OpenMPI) is installed on your system and set the AER_MPI=True flag during the build.

# Clone and install dependencies
git clone https://github.com/Qiskit/qiskit-aer
cd qiskit-aer
pip install -r requirements-dev.txt

# Standard source install
pip install .

# Build wheel using build module
pip install build
python -I -m build --wheel

# Build with GPU support (Linux only)
python ./setup.py bdist_wheel -- -DAER_THRUST_BACKEND=CUDA

# Build with MPI support
python ./setup.py bdist_wheel -- -DAER_MPI=True

Benchmark results are displayed in tables organized by the number of qubits and the applied noise model.

Each row starting with Num. qubits: represents a specific configuration. For every qubit count, the framework runs benchmarks against multiple noise models.

Example Interpretation: If you see the following output:

              --                                        Noise Model                         
              ----------------- ------------------------------------------------------------
                Quantum Volume   No Noise   Mixed Unitary Noise   Reset Noise   Kraus Noise 
              ================= ========== ===================== ============= =============
                Num. qubits: 15   3.17±2s          2.38±2s           2.19±2s       9.76±2s   

This indicates that for a Quantum Volume circuit with 15 qubits, the execution times were:

• No Noise: 3.17 ± 2 seconds
• Mixed Unitary Noise: 2.38 ± 2 seconds
• Reset Noise: 2.19 ± 2 seconds
• Kraus Noise: 9.76 ± 2 seconds

Qiskit Aer parallelizes simulations by distributing quantum states into chunks (sub-states of smaller qubit counts) to manage distributed memory space. To enable this distributed parallelization across multiple GPUs or nodes, you must configure specific backend options. While Aer may attempt to set these automatically if memory is insufficient, it is recommended to set them explicitly.

Required configuration options:

• blocking_enable: Set to True to enable distributed parallelization. (Default is False).
• blocking_qubits: Sets the number of qubits per chunk. This value must be small enough so that the chunk fits within the smallest available memory space (e.g., a single GPU).

To ensure the chunk fits, satisfy the following inequality in bytes: sizeof(complex) * 2^(blocking_qubits + 4) < size of the smallest memory space

sim = AerSimulator(method='statevector', device='GPU')
circ = transpile(QuantumVolume(qubit, 10, seed = 0))
circ.measure_all()
result = execute(circ, sim, shots=100, blocking_enable=True, blocking_qubits=23).result()