iqm-benchmarks 2.48__tar.gz → 2.49__tar.gz

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/CHANGELOG.rst

@@ -2,6 +2,10 @@
 Changelog
 =========
 
+Version 2.49
+============
+* Added logging of execution time to all benchmarks.
+
 Version 2.48
 ============
 * Updated iqm-client and supported python versions.

{iqm_benchmarks-2.48/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.48
+Version: 2.49
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/coherence/coherence.py

@@ -422,6 +422,8 @@ class CoherenceBenchmark(Benchmark):
     ) -> xr.Dataset:
         """Executes the benchmark."""
         self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         dataset = xr.Dataset()
         self.add_all_meta_to_dataset(dataset)
@@ -457,7 +459,7 @@ class CoherenceBenchmark(Benchmark):
             qcvv_logger.debug(f"Executing on {self.coherence_exp}.")
             qcvv_logger.setLevel(logging.WARNING)
 
-            jobs, _ = submit_execute(
+            jobs, time_submit = submit_execute(
                 sorted_transpiled_qc_list,
                 self.backend,
                 self.shots,
@@ -466,9 +468,11 @@ class CoherenceBenchmark(Benchmark):
                 max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
+            total_submit += time_submit
 
             qcvv_logger.setLevel(logging.INFO)
-            execution_results = retrieve_all_counts(jobs)[0]
+            execution_results, time_retrieve = retrieve_all_counts(jobs)
+            total_retrieve += time_retrieve
             identifier = BenchmarkObservationIdentifier(qubit_set)
             dataset, _ = add_counts_to_dataset(execution_results, identifier.string_identifier, dataset)
             dataset.attrs.update(
@@ -494,8 +498,7 @@ class CoherenceBenchmark(Benchmark):
                 # Execute on the backend
                 if self.configuration.use_dd is True:
                     raise ValueError("Coherence benchmarks should not be run with dynamical decoupling.")
-
-                jobs, _ = submit_execute(
+                jobs, time_submit = submit_execute(
                     sorted_transpiled_qc_list,
                     self.backend,
                     self.shots,
@@ -504,8 +507,10 @@ class CoherenceBenchmark(Benchmark):
                     max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                     circuit_compilation_options=self.circuit_compilation_options,
                 )
+                total_submit += time_submit
                 qcvv_logger.setLevel(logging.INFO)
-                execution_results = retrieve_all_counts(jobs)[0]
+                execution_results, time_retrieve = retrieve_all_counts(jobs)
+                total_retrieve += time_retrieve
                 identifier = BenchmarkObservationIdentifier(group)
                 dataset, _ = add_counts_to_dataset(execution_results, identifier.string_identifier, dataset)
 
@@ -524,6 +529,8 @@ class CoherenceBenchmark(Benchmark):
         self.transpiled_circuits.circuit_groups.append(
             CircuitGroup(name=self.coherence_exp, circuits=transpiled_qc_list)
         )
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
 
         return dataset
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/compressive_gst/compressive_gst.py

@@ -32,6 +32,7 @@ from typing import Any, Dict, List, Tuple, Type, Union
 import numpy as np
 from qiskit.circuit.library import CZGate, RGate
 import xarray as xr
+from time import strftime
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
 from iqm.benchmarks.benchmark_definition import Benchmark, BenchmarkObservationIdentifier, add_counts_to_dataset
@@ -242,7 +243,9 @@ class CompressiveGST(Benchmark):
         """
         The main GST execution routine
         """
-
+        self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
+        total_submit: float = 0
+        total_retrieve: float = 0
         dataset = xr.Dataset()
         qcvv_logger.info(f"Generating {self.configuration.num_circuits} random GST circuits")
 
@@ -255,7 +258,7 @@ class CompressiveGST(Benchmark):
             transpiled_circuit_dict = {
                 tuple(range(self.backend.num_qubits)): transpiled_circuits[str(self.qubit_layouts[0])].circuits
             }
-            all_jobs_parallel, _ = submit_execute(
+            all_jobs_parallel, time_submit = submit_execute(
                 transpiled_circuit_dict,
                 backend,
                 self.configuration.shots,
@@ -264,15 +267,17 @@ class CompressiveGST(Benchmark):
                 max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
+            total_submit += time_submit
             # Retrieve
             qcvv_logger.info(f"Now executing the corresponding circuit batch")
-            counts, _ = retrieve_all_counts(all_jobs_parallel)
+            counts, time_retrieve = retrieve_all_counts(all_jobs_parallel)
+            total_retrieve += time_retrieve
             dataset, _ = add_counts_to_dataset(counts, f"parallel_results", dataset)
         else:
             all_jobs: Dict = {}
             for qubit_layout in self.qubit_layouts:
                 transpiled_circuit_dict = {tuple(qubit_layout): transpiled_circuits[str(qubit_layout)].circuits}
-                all_jobs[str(qubit_layout)], _ = submit_execute(
+                all_jobs[str(qubit_layout)], time_submit = submit_execute(
                     transpiled_circuit_dict,
                     backend,
                     self.configuration.shots,
@@ -280,14 +285,18 @@ class CompressiveGST(Benchmark):
                     max_gates_per_batch=self.configuration.max_gates_per_batch,
                     max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 )
+                total_submit += time_submit
             # Retrieve all
             qcvv_logger.info(f"Now executing the corresponding circuit batch")
             for qubit_layout in self.qubit_layouts:
-                counts, _ = retrieve_all_counts(all_jobs[str(qubit_layout)])
+                counts, time_retrieve = retrieve_all_counts(all_jobs[str(qubit_layout)])
+                total_retrieve += time_retrieve
                 dataset, _ = add_counts_to_dataset(counts, str(qubit_layout), dataset)
 
         self.circuits.benchmark_circuits = [transpiled_circuits, untranspiled_circuits]
         self.add_configuration_to_dataset(dataset)
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         qcvv_logger.info(f"Run completed")
         return dataset
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/entanglement/ghz.py

@@ -828,6 +828,8 @@ class GHZBenchmark(Benchmark):
         Executes the benchmark.
         """
         self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
+        total_submit: float = 0
+        total_retrieve: float = 0
         aux_custom_qubits_array = cast(List[List[int]], self.custom_qubits_array).copy()
         dataset = xr.Dataset()
 
@@ -844,7 +846,7 @@ class GHZBenchmark(Benchmark):
             qubit_count = len(qubit_layout)
             circuit_group: CircuitGroup = self.generate_readout_circuit(qubit_layout, qubit_count)
             transpiled_circuit_dict = {tuple(qubit_layout): circuit_group.circuits}
-            all_jobs[idx], _ = submit_execute(
+            all_jobs[idx], time_submit = submit_execute(
                 transpiled_circuit_dict,
                 backend,
                 self.shots,
@@ -853,6 +855,7 @@ class GHZBenchmark(Benchmark):
                 max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
+            total_submit += time_submit
 
         # Retrieve all
         for qubit_layout in aux_custom_qubits_array:
@@ -860,7 +863,8 @@ class GHZBenchmark(Benchmark):
             Id = BenchmarkObservationIdentifier(qubit_layout)
             idx = Id.string_identifier
             qubit_count = len(qubit_layout)
-            counts, _ = retrieve_all_counts(all_jobs[idx])
+            counts, time_retrieve = retrieve_all_counts(all_jobs[idx])
+            total_retrieve += time_retrieve
             dataset, _ = add_counts_to_dataset(counts, idx, dataset)
             if self.rem:
                 qcvv_logger.info(f"Applying readout error mitigation")
@@ -870,6 +874,8 @@ class GHZBenchmark(Benchmark):
                 dataset, _ = add_counts_to_dataset(rem_results_dist, f"{idx}_rem", dataset)
 
         self.add_configuration_to_dataset(dataset)
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         return dataset
 
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/entanglement/graph_states.py

@@ -1151,6 +1151,8 @@ class GraphStateBenchmark(Benchmark):
         Executes the benchmark.
         """
         self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         dataset = xr.Dataset()
         self.add_all_meta_to_dataset(dataset)
@@ -1280,7 +1282,7 @@ class GraphStateBenchmark(Benchmark):
             graph_jobs, time_submit = submit_execute(
                 sorted_transpiled_qc_list, backend, self.shots, self.calset_id, self.max_gates_per_batch
             )
-
+            total_submit += time_submit
             all_graph_submit_results.append(
                 {
                     "unprojected_qubits": unprojected_qubits[idx],
@@ -1295,7 +1297,7 @@ class GraphStateBenchmark(Benchmark):
             unprojected_qubits = job_dict["unprojected_qubits"]
             # Retrieve counts
             execution_results, time_retrieve = retrieve_all_counts(job_dict["jobs"], identifier=str(unprojected_qubits))
-
+            total_retrieve += time_retrieve
             # Retrieve all job meta data
             all_job_metadata = retrieve_all_job_metadata(job_dict["jobs"])
 
@@ -1320,7 +1322,8 @@ class GraphStateBenchmark(Benchmark):
         # if self.rem:  TODO: add REM functionality
 
         qcvv_logger.info(f"Graph State benchmark experiment execution concluded !")
-
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         return dataset
 
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/optimization/qscore.py

@@ -741,6 +741,8 @@ class QScoreBenchmark(Benchmark):
     ) -> xr.Dataset:
         """Executes the benchmark."""
         self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         dataset = xr.Dataset()
         self.add_all_meta_to_dataset(dataset)
@@ -874,7 +876,7 @@ class QScoreBenchmark(Benchmark):
 
             sorted_transpiled_qc_list = {tuple(qubit_set): transpiled_qc}
             # Execute on the backend
-            jobs, _ = submit_execute(
+            jobs, time_submit = submit_execute(
                 sorted_transpiled_qc_list,
                 self.backend,
                 self.shots,
@@ -883,13 +885,15 @@ class QScoreBenchmark(Benchmark):
                 max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
+            total_submit += time_submit
             qc_transpiled_list.append(transpiled_qc)
             qcvv_logger.setLevel(logging.INFO)
             instance_with_edges = set(range(self.num_instances)) - set(no_edge_instances)
             num_instances_with_edges = len(instance_with_edges)
             if self.REM:
+                counts_retrieved, time_retrieve = retrieve_all_counts(jobs)
                 rem_counts = apply_readout_error_mitigation(
-                    backend, transpiled_qc, retrieve_all_counts(jobs)[0], self.mit_shots
+                    backend, transpiled_qc, counts_retrieved, self.mit_shots
                 )
                 execution_results.extend(
                     rem_counts[0][instance].nearest_probability_distribution()
@@ -897,8 +901,9 @@ class QScoreBenchmark(Benchmark):
                 )
                 # execution_results.append(rem_distribution)
             else:
-                execution_results.extend(retrieve_all_counts(jobs)[0])
-
+                counts_retrieved, time_retrieve = retrieve_all_counts(jobs)
+                execution_results.extend(counts_retrieved)
+            total_retrieve += time_retrieve
             dataset.attrs.update(
                 {
                     num_nodes: {
@@ -921,6 +926,8 @@ class QScoreBenchmark(Benchmark):
             )
 
         self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
 
         return dataset
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/quantum_volume/quantum_volume.py

@@ -17,7 +17,7 @@ Quantum Volume benchmark
 """
 
 from copy import deepcopy
-from time import strftime
+from time import strftime, time
 from typing import Any, Dict, List, Literal, Optional, Sequence, Tuple, Type
 
 from matplotlib.figure import Figure
@@ -716,6 +716,8 @@ class QuantumVolumeBenchmark(Benchmark):
         """Executes the benchmark."""
 
         self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         dataset = xr.Dataset()
         self.add_all_meta_to_dataset(dataset)
@@ -780,7 +782,9 @@ class QuantumVolumeBenchmark(Benchmark):
             all_op_counts[str(qubits)] = count_native_gates(backend, transpiled_qc_list)
 
             # Submit
+            t_start = time()
             all_qv_jobs.append(self.submit_single_qv_job(backend, qubits, sorted_transpiled_qc_list))
+            total_submit += time() - t_start
             qcvv_logger.info(f"Job for layout {qubits} submitted successfully!")
 
         # Retrieve counts of jobs for all qubit layouts
@@ -791,7 +795,7 @@ class QuantumVolumeBenchmark(Benchmark):
             execution_results, time_retrieve = retrieve_all_counts(job_dict["jobs"], str(qubits))
             # Retrieve all job meta data
             all_job_metadata = retrieve_all_job_metadata(job_dict["jobs"])
-
+            total_retrieve += time_retrieve
             # Export all to dataset
             dataset.attrs.update(
                 {
@@ -829,7 +833,8 @@ class QuantumVolumeBenchmark(Benchmark):
                     self.mit_shots,
                 )
             dataset.attrs.update({"REM_quasidistributions": rem_quasidistros})
-
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         qcvv_logger.info(f"QV experiment execution concluded !")
         return dataset
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -16,7 +16,7 @@
 'Standard' Clifford Randomized Benchmarking.
 """
 
-from time import strftime
+from time import strftime, time
 from typing import Any, Dict, List, Sequence, Type
 
 import numpy as np
@@ -252,6 +252,8 @@ class CliffordRandomizedBenchmarking(Benchmark):
         # Submit jobs for all qubit layouts
         all_rb_jobs: List[Dict[str, Any]] = []
         time_circuit_generation: Dict[str, float] = {}
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         # Initialize the variable to contain the circuits for each layout
         self.untranspiled_circuits = BenchmarkCircuit("untranspiled_circuits")
@@ -290,6 +292,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                 # Submit all
                 flat_qubits_array = [x for y in self.qubits_array for x in y]
                 sorted_transpiled_qc_list = {tuple(flat_qubits_array): parallel_transpiled_rb_circuits[seq_length]}
+                t_start = time()
                 all_rb_jobs.append(
                     submit_parallel_rb_job(
                         backend,
@@ -302,6 +305,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                         self.configuration.max_circuits_per_batch,
                     )
                 )
+                total_submit += time() - t_start
                 qcvv_logger.info(f"Job for sequence length {seq_length} submitted successfully!")
 
                 self.untranspiled_circuits.circuit_groups.append(
@@ -351,6 +355,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                 )
 
                 # Submit
+                t_start = time()
                 all_rb_jobs.extend(
                     submit_sequential_rb_jobs(
                         qubits,
@@ -363,6 +368,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )
+                total_submit += time() - t_start
                 qcvv_logger.info(
                     f"All jobs for qubits {qubits} and sequence lengths {self.sequence_lengths} submitted successfully!"
                 )
@@ -386,6 +392,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
             execution_results, time_retrieve = retrieve_all_counts(job_dict["jobs"], identifier)
             # Retrieve all job meta data
             all_job_metadata = retrieve_all_job_metadata(job_dict["jobs"])
+            total_retrieve += time_retrieve
             # Export all to dataset
             dataset.attrs[qubit_idx[str(qubits)]].update(
                 {
@@ -401,6 +408,8 @@ class CliffordRandomizedBenchmarking(Benchmark):
             qcvv_logger.info(f"Adding counts of qubits {qubits} and depth {depth} run to the dataset")
             dataset, _ = add_counts_to_dataset(execution_results, identifier, dataset)
 
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         qcvv_logger.info(f"RB experiment concluded !")
         self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/randomized_benchmarking/direct_rb/direct_rb.py

@@ -3,7 +3,7 @@ Direct Randomized Benchmarking.
 """
 
 import random
-from time import strftime
+from time import strftime, time
 from typing import Any, Dict, List, Literal, Optional, Sequence, Tuple, Type, cast
 
 import numpy as np
@@ -751,6 +751,8 @@ class DirectRandomizedBenchmarking(Benchmark):
             xr.Dataset: Dataset containing benchmark results and metadata
         """
         self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         dataset = xr.Dataset()
 
@@ -816,6 +818,7 @@ class DirectRandomizedBenchmarking(Benchmark):
                     # Submit all
                     flat_qubits_array = [x for y in loop_qubits_sequence for x in y]
                     sorted_transpiled_qc_list = {tuple(flat_qubits_array): parallel_drb_circuits[depth]["transpiled"]}
+                    t_start = time()
                     all_drb_jobs.append(
                         submit_parallel_rb_job(
                             backend,
@@ -828,6 +831,7 @@ class DirectRandomizedBenchmarking(Benchmark):
                             max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                         )
                     )
+                    total_submit += time() - t_start
                     qcvv_logger.info(f"Job for depth {depth} submitted successfully!")
 
                     self.untranspiled_circuits.circuit_groups.append(
@@ -884,6 +888,7 @@ class DirectRandomizedBenchmarking(Benchmark):
                         sorted_transpiled_qc_list = {
                             cast(Tuple[int, ...], tuple(qubits)): drb_transpiled_circuits_lists[depth]
                         }
+                        t_start = time()
                         all_drb_jobs.append(
                             self.submit_single_drb_job(
                                 backend,
@@ -892,7 +897,7 @@ class DirectRandomizedBenchmarking(Benchmark):
                                 cast(dict[tuple[int, ...], list[Any]], sorted_transpiled_qc_list),
                             )
                         )
-
+                        total_submit += time() - t_start
                         qcvv_logger.info(f"Job for layout {qubits} & depth {depth} submitted successfully!")
 
                         self.untranspiled_circuits.circuit_groups.append(
@@ -916,6 +921,7 @@ class DirectRandomizedBenchmarking(Benchmark):
             execution_results, time_retrieve = retrieve_all_counts(
                 job_dict["jobs"], f"qubits_{str(qubits)}_depth_{str(depth)}"
             )
+            total_retrieve += time_retrieve
             # Retrieve all job meta data
             all_job_metadata = retrieve_all_job_metadata(job_dict["jobs"])
             # Export all to dataset
@@ -934,7 +940,8 @@ class DirectRandomizedBenchmarking(Benchmark):
             dataset, _ = add_counts_to_dataset(execution_results, f"qubits_{str(qubits)}_depth_{str(depth)}", dataset)
 
         self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
-
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         qcvv_logger.info(f"DRB experiment execution concluded!")
 
         return dataset

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -16,12 +16,13 @@
 Interleaved Clifford Randomized Benchmarking.
 """
 
-from time import strftime
+from time import strftime, time
 from typing import Any, Dict, List, Literal, Optional, Sequence, Type
 
 from matplotlib.figure import Figure
 import numpy as np
 import xarray as xr
+from pycparser.ply.ctokens import t_STRING
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
 from iqm.benchmarks.benchmark_definition import (
@@ -323,6 +324,8 @@ class InterleavedRandomizedBenchmarking(Benchmark):
         # Submit jobs for all qubit layouts
         all_rb_jobs: Dict[str, List[Dict[str, Any]]] = {}  # Label by Clifford or Interleaved
         time_circuit_generation: Dict[str, float] = {}
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         # Initialize the variable to contain the circuits for each layout
 
@@ -398,6 +401,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                 sorted_transpiled_interleaved_rb_qc_list = {
                     tuple(flat_qubits_array): parallel_transpiled_interleaved_rb_circuits[seq_length]
                 }
+                t_start = time()
                 all_rb_jobs["clifford"].append(
                     submit_parallel_rb_job(
                         backend,
@@ -422,6 +426,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         self.configuration.max_circuits_per_batch,
                     )
                 )
+                total_submit += time() - t_start
                 qcvv_logger.info(f"Both jobs for sequence length {seq_length} submitted successfully!")
 
             self.untranspiled_circuits.circuit_groups.append(
@@ -507,6 +512,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                 time_circuit_generation[str(qubits)] = t_clifford + t_inter
 
                 # Submit Clifford then Interleaved
+                t_start = time()
                 all_rb_jobs["clifford"].extend(
                     submit_sequential_rb_jobs(
                         qubits,
@@ -531,6 +537,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )
+                total_submit += time() - t_start
                 qcvv_logger.info(
                     f"All jobs for qubits {qubits} and sequence lengths {self.sequence_lengths} submitted successfully!"
                 )
@@ -568,6 +575,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                 execution_results, time_retrieve = retrieve_all_counts(job_dict["jobs"], identifier)
                 # Retrieve all job meta data
                 all_job_metadata = retrieve_all_job_metadata(job_dict["jobs"])
+                total_retrieve += time_retrieve
                 # Export all to dataset
                 dataset.attrs[qubit_idx[str(qubits)]].update(
                     {
@@ -585,6 +593,8 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                 qcvv_logger.info(f"Adding counts of qubits {qubits} and depth {depth} run to the dataset")
                 dataset, _ = add_counts_to_dataset(execution_results, identifier, dataset)
 
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         qcvv_logger.info(f"Interleaved RB experiment concluded !")
         self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
 

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49}/src/iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -2,7 +2,7 @@
 Mirror Randomized Benchmarking.
 """
 
-from time import strftime
+from time import strftime, time
 from typing import Any, Dict, List, Literal, Optional, Sequence, Tuple, Type
 import warnings
 
@@ -592,6 +592,8 @@ class MirrorRandomizedBenchmarking(Benchmark):
         # Submit jobs for all qubit layouts
         all_mrb_jobs: List[Dict[str, Any]] = []
         time_circuit_generation: Dict[str, float] = {}
+        total_submit: float = 0
+        total_retrieve: float = 0
 
         # The depths should be assigned to each set of qubits!
         # The real final MRB depths are twice the originally specified, must be taken into account here!
@@ -653,7 +655,9 @@ class MirrorRandomizedBenchmarking(Benchmark):
 
                 # Submit
                 sorted_transpiled_qc_list = {tuple(qubits): mrb_transpiled_circuits_lists[depth]}
+                t_start = time()
                 all_mrb_jobs.append(self.submit_single_mrb_job(backend, qubits, depth, sorted_transpiled_qc_list))
+                total_retrieve += time() - t_start
                 qcvv_logger.info(f"Job for layout {qubits} & depth {depth} submitted successfully!")
 
                 self.untranspiled_circuits.circuit_groups.append(
@@ -675,6 +679,7 @@ class MirrorRandomizedBenchmarking(Benchmark):
             )
             # Retrieve all job meta data
             all_job_metadata = retrieve_all_job_metadata(job_dict["jobs"])
+            total_retrieve += time_retrieve
             # Export all to dataset
             dataset.attrs[qubit_idx[str(qubits)]].update(
                 {
@@ -690,6 +695,8 @@ class MirrorRandomizedBenchmarking(Benchmark):
             qcvv_logger.info(f"Adding counts of qubits {qubits} and depth {depth} run to the dataset")
             dataset, _ = add_counts_to_dataset(execution_results, f"qubits_{str(qubits)}_depth_{str(depth)}", dataset)
 
+        dataset.attrs["total_submit_time"] = total_submit
+        dataset.attrs["total_retrieve_time"] = total_retrieve
         self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
 
         qcvv_logger.info(f"MRB experiment execution concluded !")

{iqm_benchmarks-2.48 → iqm_benchmarks-2.49/src/iqm_benchmarks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.48
+Version: 2.49
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks