9101005981

Committed 15 May 2024 06:38PM UTC coverage: 89.606% (-0.004%) from 89.61%

Build # 9101005981

Build Type

push

github

Committed by

web-flow

Commit Message

Fix unnecessary serialisation of `PassManager` in serial contexts (#12410) (#12413)

* Fix unnecessary serialisation of `PassManager` in serial contexts

This exposes the interal decision in `parallel_map` of whether to
actually run in serial or not.  If not, there's no need for
`PassManager` to side-car its `dill` serialisation onto the side of the
IPC (we use `dill` because we need to pickle lambdas), which can be an
unfortunately huge cost for certain IBM pulse-enabled backends.

* Remove new function from public API

This makes the patch series safe for backport to 1.1.

(cherry picked from commit b12e9ec3c)

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

Run Details

12 of 12 new or added lines in 3 files covered. (100.0%)

25 existing lines in 5 files now uncovered.

62245 of 69465 relevant lines covered (89.61%)

229139.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.13

/crates/accelerate/src/sabre/neighbor_table.rs

// This code is part of Qiskit.
//
// (C) Copyright IBM 2022
//
// This code is licensed under the Apache License, Version 2.0. You may
// obtain a copy of this license in the LICENSE.txt file in the root directory
// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
//
// Any modifications or derivative works of this code must retain this
// copyright notice, and modified files need to carry a notice indicating
// that they have been altered from the originals.

use crate::getenv_use_multiple_threads;
use ndarray::prelude::*;
use numpy::PyReadonlyArray2;
use pyo3::prelude::*;
use pyo3::types::PyList;
use rayon::prelude::*;
use rustworkx_core::petgraph::prelude::*;
use smallvec::SmallVec;

use crate::nlayout::PhysicalQubit;

/// A simple container that contains a vector of vectors representing
/// neighbors of each node in the coupling map
///
/// This object is typically created once from the adjacency matrix of
/// a coupling map, for example::
///
///     neigh_table = NeighborTable(rustworkx.adjacency_matrix(coupling_map.graph))
///
/// and used solely to represent neighbors of each node in qiskit-terra's rust
/// module.
#[pyclass(module = "qiskit._accelerate.sabre")]
#[derive(Clone, Debug)]
pub struct NeighborTable {
    // The choice of 4 `PhysicalQubit`s in the stack-allocated region is because a) this causes the
    // `SmallVec<T>` to be the same width as a `Vec` on 64-bit systems (three machine words == 24
    // bytes); b) the majority of coupling maps we're likely to encounter have a degree of 3 (heavy
    // hex) or 4 (grid / heavy square).
    neighbors: Vec<SmallVec<[PhysicalQubit; 4]>>,
}

impl NeighborTable {
    /// Regenerate a Rust-space coupling graph from the table.
    pub fn coupling_graph(&self) -> DiGraph<(), ()> {
        DiGraph::from_edges(self.neighbors.iter().enumerate().flat_map(|(u, targets)| {
            targets
                .iter()
                .map(move |v| (NodeIndex::new(u), NodeIndex::new(v.index())))
        }))
    }

    pub fn num_qubits(&self) -> usize {
        self.neighbors.len()
    }
}

impl std::ops::Index<PhysicalQubit> for NeighborTable {
    type Output = [PhysicalQubit];

    fn index(&self, index: PhysicalQubit) -> &Self::Output {
        &self.neighbors[index.index()]
    }
}

#[pymethods]
impl NeighborTable {
    #[new]
    #[pyo3(text_signature = "(/, adjacency_matrix=None)")]
    pub fn new(adjacency_matrix: Option<PyReadonlyArray2<f64>>) -> PyResult<Self> {
        let run_in_parallel = getenv_use_multiple_threads();
        let neighbors = match adjacency_matrix {
            Some(adjacency_matrix) => {
                let adj_mat = adjacency_matrix.as_array();
                let build_neighbors =
                    |row: ArrayView1<f64>| -> PyResult<SmallVec<[PhysicalQubit; 4]>> {
                        row.iter()
                            .enumerate()
                            .filter_map(|(row_index, value)| {
                                if *value == 0. {
                                    None
                                } else {
                                    Some(match row_index.try_into() {
                                        Ok(index) => Ok(PhysicalQubit::new(index)),
                                        Err(err) => Err(err.into()),
                                    })
                                }
                            })
                            .collect()
                    };
                if run_in_parallel {
                    adj_mat
                        .axis_iter(Axis(0))
                        .into_par_iter()
                        .map(build_neighbors)
                        .collect::<PyResult<_>>()?
                } else {
                    adj_mat
                        .axis_iter(Axis(0))
                        .map(build_neighbors)
                        .collect::<PyResult<_>>()?
                }
            }
            None => Vec::new(),
        };
        Ok(NeighborTable { neighbors })
    }

    fn __getstate__(&self, py: Python<'_>) -> Py<PyList> {
        PyList::new_bound(
            py,
            self.neighbors
                .iter()
                .map(|v| PyList::new_bound(py, v.iter()).to_object(py)),
        )
        .into()
    }

    fn __setstate__(&mut self, state: &Bound<PyList>) -> PyResult<()> {
        self.neighbors = state
            .iter()
            .map(|v| {
                v.downcast::<PyList>()?
                    .iter()
                    .map(|b| b.extract())
                    .collect::<PyResult<_>>()
            })
            .collect::<PyResult<_>>()?;
        Ok(())
    }
}

1	// This code is part of Qiskit.
2	//
3	// (C) Copyright IBM 2022
4	//
5	// This code is licensed under the Apache License, Version 2.0. You may
6	// obtain a copy of this license in the LICENSE.txt file in the root directory
7	// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	//
9	// Any modifications or derivative works of this code must retain this
10	// copyright notice, and modified files need to carry a notice indicating
11	// that they have been altered from the originals.
12
13	use crate::getenv_use_multiple_threads;
14	use ndarray::prelude::*;
15	use numpy::PyReadonlyArray2;
16	use pyo3::prelude::*;
17	use pyo3::types::PyList;
18	use rayon::prelude::*;
19	use rustworkx_core::petgraph::prelude::*;
20	use smallvec::SmallVec;
21
22	use crate::nlayout::PhysicalQubit;
23
24	/// A simple container that contains a vector of vectors representing
25	/// neighbors of each node in the coupling map
26	///
27	/// This object is typically created once from the adjacency matrix of
28	/// a coupling map, for example::
29	///
30	/// neigh_table = NeighborTable(rustworkx.adjacency_matrix(coupling_map.graph))
31	///
32	/// and used solely to represent neighbors of each node in qiskit-terra's rust
33	/// module.
34	#[pyclass(module = "qiskit._accelerate.sabre")]	3,262✔
35	#[derive(Clone, Debug)]
36	pub struct NeighborTable {
37	// The choice of 4 `PhysicalQubit`s in the stack-allocated region is because a) this causes the
38	// `SmallVec<T>` to be the same width as a `Vec` on 64-bit systems (three machine words == 24
39	// bytes); b) the majority of coupling maps we're likely to encounter have a degree of 3 (heavy
40	// hex) or 4 (grid / heavy square).
41	neighbors: Vec<SmallVec<[PhysicalQubit; 4]>>,
42	}
43
44	impl NeighborTable {
45	/// Regenerate a Rust-space coupling graph from the table.
46	pub fn coupling_graph(&self) -> DiGraph<(), ()> {	736✔
47	DiGraph::from_edges(self.neighbors.iter().enumerate().flat_map(\|(u, targets)\| {	13,660✔
48	targets	13,660✔
49	.iter()	13,660✔
50	.map(move \|v\| (NodeIndex::new(u), NodeIndex::new(v.index())))	28,588✔
51	}))	13,660✔
52	}	736✔
53
54	pub fn num_qubits(&self) -> usize {	107,546✔
55	self.neighbors.len()	107,546✔
56	}	107,546✔
57	}
58
59	impl std::ops::Index<PhysicalQubit> for NeighborTable {
60	type Output = [PhysicalQubit];
61
62	fn index(&self, index: PhysicalQubit) -> &Self::Output {	2,680,240✔
63	&self.neighbors[index.index()]	2,680,240✔
64	}	2,680,240✔
65	}
66
67	#[pymethods]	3,862✔
68	impl NeighborTable {
69	#[new]
70	#[pyo3(text_signature = "(/, adjacency_matrix=None)")]
71	pub fn new(adjacency_matrix: Option<PyReadonlyArray2<f64>>) -> PyResult<Self> {	3,806✔
72	let run_in_parallel = getenv_use_multiple_threads();	3,806✔
73	let neighbors = match adjacency_matrix {	3,806✔
74	Some(adjacency_matrix) => {	3,806✔
75	let adj_mat = adjacency_matrix.as_array();	3,806✔
76	let build_neighbors =	3,806✔
77	\|row: ArrayView1<f64>\| -> PyResult<SmallVec<[PhysicalQubit; 4]>> {	67,296✔
78	row.iter()	67,296✔
79	.enumerate()	67,296✔
80	.filter_map(\|(row_index, value)\| {	3,288,652✔
81	if *value == 0. {	3,288,652✔
82	None	1,946,744✔
83	} else {
84	Some(match row_index.try_into() {	1,341,908✔
85	Ok(index) => Ok(PhysicalQubit::new(index)),	1,341,908✔
86	Err(err) => Err(err.into()),	×
87	})
88	}
89	})	3,288,652✔
90	.collect()	67,296✔
91	};	67,296✔
92	if run_in_parallel {	3,806✔
93	adj_mat	3,806✔
94	.axis_iter(Axis(0))	3,806✔
95	.into_par_iter()	3,806✔
96	.map(build_neighbors)	3,806✔
97	.collect::<PyResult<_>>()?	3,806✔
98	} else {
99	adj_mat	×
100	.axis_iter(Axis(0))	×
101	.map(build_neighbors)	×
102	.collect::<PyResult<_>>()?	×
103	}
104	}
UNCOV 105	None => Vec::new(),	×
106	};
107	Ok(NeighborTable { neighbors })	3,806✔
108	}	3,806✔
109
110	fn __getstate__(&self, py: Python<'_>) -> Py<PyList> {	56✔
111	PyList::new_bound(	56✔
112	py,	56✔
113	self.neighbors	56✔
114	.iter()	56✔
115	.map(\|v\| PyList::new_bound(py, v.iter()).to_object(py)),	696✔
116	)	56✔
117	.into()	56✔
118	}	56✔
119
UNCOV 120	fn __setstate__(&mut self, state: &Bound<PyList>) -> PyResult<()> {	×
UNCOV 121	self.neighbors = state	×
UNCOV 122	.iter()	×
UNCOV 123	.map(\|v\| {	×
UNCOV 124	v.downcast::<PyList>()?	×
UNCOV 125	.iter()	×
UNCOV 126	.map(\|b\| b.extract())	×
UNCOV 127	.collect::<PyResult<_>>()	×
UNCOV 128	})	×
UNCOV 129	.collect::<PyResult<_>>()?;	×
UNCOV 130	Ok(())	×
UNCOV 131	}	×
132	}

Qiskit / qiskit / 9101005981

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous