10199425044

Committed 01 Aug 2024 12:59PM UTC coverage: 89.945% (+0.02%) from 89.925%

Build # 10199425044

Build Type

push

github

Committed by

web-flow

Commit Message

Move `QuantumCircuit.assign_parameters` to Rust (#12794) (#12878)

* Move `QuantumCircuit.assign_parameters` to Rust

This is (as far as I could tell), the last really major performance
regression in our asv suite compared to 1.1.0, so with this commit, we
should be at _not worse_ for important utility-scale benchmarks.

This largely rewrites `ParamTable` (renamed back to `ParameterTable`
because I kept getting confused with `Param`) to have more Rust-friendly
interfaces available, so that `assign_parameters` can then use them.

This represents a 2-3x speedup in `assign_parameters` performance over
1.1.0, when binding simple `Parameter` instances.  Approximately 75% of
the time is now spent in Python-space `Parameter.assign` and
`ParameterExpression.numeric` calls; almost all of this could be removed
were we to move `Parameter` and `ParameterExpression` to have their data
exposed directly to Rust space.  The percentage of time spent in Python
space only increases if the expressions to be bound are actual
`ParameterExpression`s and not just `Parameter`.

Most changes in the test suite are because of the use of internal-only
methods that changed with the new `ParameterTable`.  The only
discrepancy is a bug in `test_pauli_feature_map`, which was trying to
assign using a set.

* Add unit test of parameter insertion

This catches a bug that was present in the parent commit, but this PR
fixes.

* Update crates/circuit/src/imports.rs

* Fix assignment to `AnnotatedOperation`

* Rename `CircuitData::num_params` to match normal terminology

* Fix typos and :us:

* Fix lint

(cherry picked from commit a68de4f9f)

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

Run Details

485 of 513 new or added lines in 5 files covered. (94.54%)

16 existing lines in 5 files now uncovered.

66676 of 74130 relevant lines covered (89.94%)

232695.05 hits per line

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

94.55

/crates/circuit/src/parameter_table.rs

// This code is part of Qiskit.
//
// (C) Copyright IBM 2024
//
// 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 hashbrown::hash_map::Entry;
use hashbrown::{HashMap, HashSet};
use thiserror::Error;

use pyo3::exceptions::PyTypeError;
use pyo3::prelude::*;
use pyo3::pybacked::PyBackedStr;
use pyo3::types::{PyList, PySet};
use pyo3::{import_exception, intern, PyTraverseError, PyVisit};

use crate::imports::UUID;

import_exception!(qiskit.circuit, CircuitError);

#[derive(Error, Debug)]
pub enum ParameterTableError {
    #[error("parameter '{0:?}' is not tracked in the table")]
    ParameterNotTracked(ParameterUuid),
    #[error("usage {0:?} is not tracked by the table")]
    UsageNotTracked(ParameterUse),
}
impl From<ParameterTableError> for PyErr {
    fn from(value: ParameterTableError) -> PyErr {
        CircuitError::new_err(value.to_string())
    }
}

/// A single use of a symbolic parameter.
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
pub enum ParameterUse {
    Index { instruction: usize, parameter: u32 },
    GlobalPhase,
}

/// Rust-space extra information that a `ParameterVectorElement` has.  This is used most heavily
/// during sorting; vector elements are sorted by their parent name, and index within that.
#[derive(Clone, Debug)]
struct VectorElement {
    vector_uuid: VectorUuid,
    index: usize,
}

/// Tracked data tied to each parameter's UUID in the table.
#[derive(Clone, Debug)]
pub struct ParameterInfo {
    uses: HashSet<ParameterUse>,
    name: PyBackedStr,
    element: Option<VectorElement>,
    object: Py<PyAny>,
}

/// Rust-space information on a Python `ParameterVector` and its uses in the table.
#[derive(Clone, Debug)]
struct VectorInfo {
    name: PyBackedStr,
    /// Number of elements of the vector tracked within the parameter table.
    refcount: usize,
}

/// Type-safe UUID for a symbolic parameter.  This does not track the name of the `Parameter`; it
/// can't be used alone to reconstruct a Python instance.  That tracking remains only withing the
/// `ParameterTable`.
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
pub struct ParameterUuid(u128);
impl ParameterUuid {
    /// Extract a UUID from a Python-space `Parameter` object. This assumes that the object is known
    /// to be a parameter.
    pub fn from_parameter(ob: &Bound<PyAny>) -> PyResult<Self> {
        ob.getattr(intern!(ob.py(), "_uuid"))?.extract()
    }
}

/// This implementation of `FromPyObject` is for the UUID itself, which is what the `ParameterUuid`
/// struct actually encapsulates.
impl<'py> FromPyObject<'py> for ParameterUuid {
    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
        if ob.is_exact_instance(UUID.get_bound(ob.py())) {
            ob.getattr(intern!(ob.py(), "int"))?.extract().map(Self)
        } else {
            Err(PyTypeError::new_err("not a UUID"))
        }
    }
}

/// Type-safe UUID for a parameter vector.  This is just used internally for tracking.
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
struct VectorUuid(u128);
impl VectorUuid {
    /// Extract a UUID from a Python-space `ParameterVector` object. This assumes that the object is
    /// the correct type.
    fn from_vector(ob: &Bound<PyAny>) -> PyResult<Self> {
        ob.getattr(intern!(ob.py(), "_root_uuid"))?.extract()
    }
}
impl<'py> FromPyObject<'py> for VectorUuid {
    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
        if ob.is_exact_instance(UUID.get_bound(ob.py())) {
            ob.getattr(intern!(ob.py(), "int"))?.extract().map(Self)
        } else {
            Err(PyTypeError::new_err("not a UUID"))
        }
    }
}

#[derive(Clone, Default, Debug)]
pub struct ParameterTable {
    /// Mapping of the parameter key (its UUID) to the information on it tracked by this table.
    by_uuid: HashMap<ParameterUuid, ParameterInfo>,
    /// Mapping of the parameter names to the UUID that represents them.  Since we always get
    /// parameters in as Python-space objects, we use the string object extracted from Python space.
    by_name: HashMap<PyBackedStr, ParameterUuid>,
    /// Additional information on any `ParameterVector` instances that have elements in the circuit.
    vectors: HashMap<VectorUuid, VectorInfo>,
    /// Sort order of the parameters.  This is lexicographical for most parameters, except elements
    /// of a `ParameterVector` are sorted within the vector by numerical index.  We calculate this
    /// on demand and cache it; an empty `order` implies it is not currently calculated.  We don't
    /// use `Option<Vec>` so we can re-use the allocation for partial parameter bindings.
    ///
    /// Any method that adds or a removes a parameter is responsible for invalidating this cache.
    order: Vec<ParameterUuid>,
    /// Cache of a Python-space list of the parameter objects, in order.  We only generate this
    /// specifically when asked.
    ///
    /// Any method that adds or a removes a parameter is responsible for invalidating this cache.
    py_parameters: Option<Py<PyList>>,
}

impl ParameterTable {
    pub fn new() -> Self {
        Default::default()
    }

    /// Get the number of parameters tracked by the table.
    pub fn num_parameters(&self) -> usize {
        self.by_uuid.len()
    }

    /// Add a new usage of a parameter coming in from Python space, optionally adding a first usage
    /// to it.
    ///
    /// The no-use form is useful when doing parameter assignments from Rust space, where the
    /// replacement is itself parametric; the replacement can be extracted once, then subsequent
    /// lookups and updates done without interaction with Python.
    pub fn track(
        &mut self,
        param_ob: &Bound<PyAny>,
        usage: Option<ParameterUse>,
    ) -> PyResult<ParameterUuid> {
        let py = param_ob.py();
        let uuid = ParameterUuid::from_parameter(param_ob)?;
        match self.by_uuid.entry(uuid) {
            Entry::Occupied(mut entry) => {
                if let Some(usage) = usage {
                    entry.get_mut().uses.insert(usage);
                }
            }
            Entry::Vacant(entry) => {
                let py_name_attr = intern!(py, "name");
                let name = param_ob.getattr(py_name_attr)?.extract::<PyBackedStr>()?;
                if self.by_name.contains_key(&name) {
                    return Err(CircuitError::new_err(format!(
                        "name conflict adding parameter '{}'",
                        &name
                    )));
                }
                let element = if let Ok(vector) = param_ob.getattr(intern!(py, "vector")) {
                    let vector_uuid = VectorUuid::from_vector(&vector)?;
                    match self.vectors.entry(vector_uuid) {
                        Entry::Occupied(mut entry) => entry.get_mut().refcount += 1,
                        Entry::Vacant(entry) => {
                            entry.insert(VectorInfo {
                                name: vector.getattr(py_name_attr)?.extract()?,
                                refcount: 1,
                            });
                        }
                    }
                    Some(VectorElement {
                        vector_uuid,
                        index: param_ob.getattr(intern!(py, "index"))?.extract()?,
                    })
                } else {
                    None
                };
                self.by_name.insert(name.clone(), uuid);
                self.order.clear();
                self.py_parameters = None;
                let mut uses = HashSet::new();
                if let Some(usage) = usage {
                    uses.insert_unique_unchecked(usage);
                };
                entry.insert(ParameterInfo {
                    name,
                    uses,
                    element,
                    object: param_ob.clone().unbind(),
                });
            }
        }
        Ok(uuid)
    }

    /// Untrack one use of a single Python-space `Parameter` object from the table, discarding all
    /// other tracking of that `Parameter` if this was the last usage of it.
    pub fn untrack(&mut self, param_ob: &Bound<PyAny>, usage: ParameterUse) -> PyResult<()> {
        self.remove_use(ParameterUuid::from_parameter(param_ob)?, usage)
            .map_err(PyErr::from)
    }

    /// Lookup the Python parameter object by name.
    pub fn py_parameter_by_name(&self, name: &PyBackedStr) -> Option<&Py<PyAny>> {
        self.by_name
            .get(name)
            .map(|uuid| &self.by_uuid[uuid].object)
    }

    /// Get the (maybe cached) Python list of the sorted `Parameter` objects.
    pub fn py_parameters<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyList> {
        if let Some(py_parameters) = self.py_parameters.as_ref() {
            return py_parameters.clone_ref(py).into_bound(py);
        }
        self.ensure_sorted();
        let out = PyList::new_bound(
            py,
            self.order
                .iter()
                .map(|uuid| self.by_uuid[uuid].object.clone_ref(py).into_bound(py)),
        );
        self.py_parameters = Some(out.clone().unbind());
        out
    }

    /// Get a Python set of all tracked `Parameter` objects.
    pub fn py_parameters_unsorted<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PySet>> {
        PySet::new_bound(py, self.by_uuid.values().map(|info| &info.object))
    }

    /// Ensure that the `order` field is populated and sorted.
    fn ensure_sorted(&mut self) {
        // If `order` is already populated, it's sorted; it's the responsibility of the methods of
        // this struct that mutate it to invalidate the cache.
        if !self.order.is_empty() {
            return;
        }
        self.order.reserve(self.by_uuid.len());
        self.order.extend(self.by_uuid.keys());
        self.order.sort_unstable_by_key(|uuid| {
            let info = &self.by_uuid[uuid];
            if let Some(vec) = info.element.as_ref() {
                (&self.vectors[&vec.vector_uuid].name, vec.index)
            } else {
                (&info.name, 0)
            }
        })
    }

    /// Add a use of a parameter to the table.
    pub fn add_use(
        &mut self,
        uuid: ParameterUuid,
        usage: ParameterUse,
    ) -> Result<(), ParameterTableError> {
        self.by_uuid
            .get_mut(&uuid)
            .ok_or(ParameterTableError::ParameterNotTracked(uuid))?
            .uses
            .insert(usage);
        Ok(())
    }

    /// Return a use of a parameter.
    ///
    /// If the last use a parameter is discarded, the parameter is untracked.
    pub fn remove_use(
        &mut self,
        uuid: ParameterUuid,
        usage: ParameterUse,
    ) -> Result<(), ParameterTableError> {
        let Entry::Occupied(mut entry) = self.by_uuid.entry(uuid) else {
            return Err(ParameterTableError::ParameterNotTracked(uuid));
        };
        let info = entry.get_mut();
        if !info.uses.remove(&usage) {
            return Err(ParameterTableError::UsageNotTracked(usage));
        }
        if info.uses.is_empty() {
            self.by_name.remove(&info.name);
            if let Some(vec) = info.element.as_ref() {
                let Entry::Occupied(mut vec_entry) = self.vectors.entry(vec.vector_uuid) else {
                    unreachable!()
                };
                vec_entry.get_mut().refcount -= 1;
                if vec_entry.get().refcount == 0 {
                    vec_entry.remove_entry();
                }
            }
            self.order.clear();
            self.py_parameters = None;
            entry.remove_entry();
        }
        Ok(())
    }

    /// Remove a parameter from the table, returning the tracked uses of it.
    pub fn pop(
        &mut self,
        uuid: ParameterUuid,
    ) -> Result<HashSet<ParameterUse>, ParameterTableError> {
        let info = self
            .by_uuid
            .remove(&uuid)
            .ok_or(ParameterTableError::ParameterNotTracked(uuid))?;
        self.by_name
            .remove(&info.name)
            .expect("each parameter should be tracked by both UUID and name");
        if let Some(element) = info.element {
            self.vectors
                .entry(element.vector_uuid)
                .and_replace_entry_with(|_k, mut vector_info| {
                    vector_info.refcount -= 1;
                    (vector_info.refcount > 0).then_some(vector_info)
                });
        }
        self.order.clear();
        self.py_parameters = None;
        Ok(info.uses)
    }

    /// Clear this table, yielding the Python parameter objects and their uses in sorted order.
    pub fn drain_ordered(
        &'_ mut self,
    ) -> impl Iterator<Item = (Py<PyAny>, HashSet<ParameterUse>)> + '_ {
        self.ensure_sorted();
        self.by_name.clear();
        self.vectors.clear();
        self.py_parameters = None;
        self.order.drain(..).map(|uuid| {
            let info = self
                .by_uuid
                .remove(&uuid)
                .expect("tracked UUIDs should be consistent");
            (info.object, info.uses)
        })
    }

    /// Empty this `ParameterTable` of all its contents.  This does not affect the capacities of the
    /// internal data storage.
    pub fn clear(&mut self) {
        self.by_uuid.clear();
        self.by_name.clear();
        self.vectors.clear();
        self.order.clear();
        self.py_parameters = None;
    }

    /// Expose the tracked data for a given parameter as directly as possible to Python space.
    ///
    /// This is only really intended for use in testing.
    pub(crate) fn _py_raw_entry(&self, param: Bound<PyAny>) -> PyResult<Py<PySet>> {
        let py = param.py();
        let uuid = ParameterUuid::from_parameter(&param)?;
        let info = self
            .by_uuid
            .get(&uuid)
            .ok_or(ParameterTableError::ParameterNotTracked(uuid))?;
        // PyO3's `PySet::new_bound` only accepts iterables of references.
        let out = PySet::empty_bound(py)?;
        for usage in info.uses.iter() {
            match usage {
                ParameterUse::GlobalPhase => out.add((py.None(), py.None()))?,
                ParameterUse::Index {
                    instruction,
                    parameter,
                } => out.add((*instruction, *parameter))?,
            }
        }
        Ok(out.unbind())
    }

    /// Accept traversal of this object by the Python garbage collector.
    ///
    /// This is not a pyclass, so it's up to our owner to delegate their own traversal to us.
    pub fn py_gc_traverse(&self, visit: &PyVisit) -> Result<(), PyTraverseError> {
        for info in self.by_uuid.values() {
            visit.call(&info.object)?
        }
        // We don't need to / can't visit the `PyBackedStr` stores.
        if let Some(list) = self.py_parameters.as_ref() {
            visit.call(list)?
        }
        Ok(())
    }
}

1	// This code is part of Qiskit.
2	//
3	// (C) Copyright IBM 2024
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 hashbrown::hash_map::Entry;
14	use hashbrown::{HashMap, HashSet};
15	use thiserror::Error;
16
17	use pyo3::exceptions::PyTypeError;
18	use pyo3::prelude::*;
19	use pyo3::pybacked::PyBackedStr;
20	use pyo3::types::{PyList, PySet};
21	use pyo3::{import_exception, intern, PyTraverseError, PyVisit};
22
23	use crate::imports::UUID;
24
25	import_exception!(qiskit.circuit, CircuitError);
26
NEW 27	#[derive(Error, Debug)]	×
28	pub enum ParameterTableError {
29	#[error("parameter '{0:?}' is not tracked in the table")]
30	ParameterNotTracked(ParameterUuid),
31	#[error("usage {0:?} is not tracked by the table")]
32	UsageNotTracked(ParameterUse),
33	}
34	impl From<ParameterTableError> for PyErr {
NEW 35	fn from(value: ParameterTableError) -> PyErr {	×
NEW 36	CircuitError::new_err(value.to_string())	×
NEW 37	}	×
38	}
39
40	/// A single use of a symbolic parameter.
41	#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
42	pub enum ParameterUse {
43	Index { instruction: usize, parameter: u32 },
44	GlobalPhase,
45	}
46
47	/// Rust-space extra information that a `ParameterVectorElement` has. This is used most heavily
48	/// during sorting; vector elements are sorted by their parent name, and index within that.
49	#[derive(Clone, Debug)]
50	struct VectorElement {
51	vector_uuid: VectorUuid,
52	index: usize,
53	}
54
55	/// Tracked data tied to each parameter's UUID in the table.
56	#[derive(Clone, Debug)]
57	pub struct ParameterInfo {
58	uses: HashSet<ParameterUse>,
59	name: PyBackedStr,
60	element: Option<VectorElement>,
61	object: Py<PyAny>,
62	}
63
64	/// Rust-space information on a Python `ParameterVector` and its uses in the table.
65	#[derive(Clone, Debug)]
66	struct VectorInfo {
67	name: PyBackedStr,
68	/// Number of elements of the vector tracked within the parameter table.
69	refcount: usize,
70	}
71
72	/// Type-safe UUID for a symbolic parameter. This does not track the name of the `Parameter`; it
73	/// can't be used alone to reconstruct a Python instance. That tracking remains only withing the
74	/// `ParameterTable`.
75	#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
76	pub struct ParameterUuid(u128);
77	impl ParameterUuid {
78	/// Extract a UUID from a Python-space `Parameter` object. This assumes that the object is known
79	/// to be a parameter.
80	pub fn from_parameter(ob: &Bound<PyAny>) -> PyResult<Self> {	342,496✔
81	ob.getattr(intern!(ob.py(), "_uuid"))?.extract()	342,496✔
82	}	342,496✔
83	}
84
85	/// This implementation of `FromPyObject` is for the UUID itself, which is what the `ParameterUuid`
86	/// struct actually encapsulates.
87	impl<'py> FromPyObject<'py> for ParameterUuid {
88	fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {	342,496✔
89	if ob.is_exact_instance(UUID.get_bound(ob.py())) {	342,496✔
90	ob.getattr(intern!(ob.py(), "int"))?.extract().map(Self)	342,496✔
91	} else {
NEW 92	Err(PyTypeError::new_err("not a UUID"))	×
93	}
94	}	342,496✔
95	}
96
97	/// Type-safe UUID for a parameter vector. This is just used internally for tracking.
98	#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
99	struct VectorUuid(u128);
100	impl VectorUuid {
101	/// Extract a UUID from a Python-space `ParameterVector` object. This assumes that the object is
102	/// the correct type.
103	fn from_vector(ob: &Bound<PyAny>) -> PyResult<Self> {	76,364✔
104	ob.getattr(intern!(ob.py(), "_root_uuid"))?.extract()	76,364✔
105	}	76,364✔
106	}
107	impl<'py> FromPyObject<'py> for VectorUuid {
108	fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {	76,364✔
109	if ob.is_exact_instance(UUID.get_bound(ob.py())) {	76,364✔
110	ob.getattr(intern!(ob.py(), "int"))?.extract().map(Self)	76,364✔
111	} else {
NEW 112	Err(PyTypeError::new_err("not a UUID"))	×
113	}
114	}	76,364✔
115	}
116
117	#[derive(Clone, Default, Debug)]
118	pub struct ParameterTable {
119	/// Mapping of the parameter key (its UUID) to the information on it tracked by this table.
120	by_uuid: HashMap<ParameterUuid, ParameterInfo>,
121	/// Mapping of the parameter names to the UUID that represents them. Since we always get
122	/// parameters in as Python-space objects, we use the string object extracted from Python space.
123	by_name: HashMap<PyBackedStr, ParameterUuid>,
124	/// Additional information on any `ParameterVector` instances that have elements in the circuit.
125	vectors: HashMap<VectorUuid, VectorInfo>,
126	/// Sort order of the parameters. This is lexicographical for most parameters, except elements
127	/// of a `ParameterVector` are sorted within the vector by numerical index. We calculate this
128	/// on demand and cache it; an empty `order` implies it is not currently calculated. We don't
129	/// use `Option<Vec>` so we can re-use the allocation for partial parameter bindings.
130	///
131	/// Any method that adds or a removes a parameter is responsible for invalidating this cache.
132	order: Vec<ParameterUuid>,
133	/// Cache of a Python-space list of the parameter objects, in order. We only generate this
134	/// specifically when asked.
135	///
136	/// Any method that adds or a removes a parameter is responsible for invalidating this cache.
137	py_parameters: Option<Py<PyList>>,
138	}
139
140	impl ParameterTable {
141	pub fn new() -> Self {	2,680,972✔
142	Default::default()	2,680,972✔
143	}	2,680,972✔
144
145	/// Get the number of parameters tracked by the table.
146	pub fn num_parameters(&self) -> usize {	4,356✔
147	self.by_uuid.len()	4,356✔
148	}	4,356✔
149
150	/// Add a new usage of a parameter coming in from Python space, optionally adding a first usage
151	/// to it.
152	///
153	/// The no-use form is useful when doing parameter assignments from Rust space, where the
154	/// replacement is itself parametric; the replacement can be extracted once, then subsequent
155	/// lookups and updates done without interaction with Python.
156	pub fn track(	170,330✔
157	&mut self,	170,330✔
158	param_ob: &Bound<PyAny>,	170,330✔
159	usage: Option<ParameterUse>,	170,330✔
160	) -> PyResult<ParameterUuid> {	170,330✔
161	let py = param_ob.py();	170,330✔
162	let uuid = ParameterUuid::from_parameter(param_ob)?;	170,330✔
163	match self.by_uuid.entry(uuid) {	170,330✔
164	Entry::Occupied(mut entry) => {	9,470✔
165	if let Some(usage) = usage {	9,470✔
166	entry.get_mut().uses.insert(usage);	9,310✔
167	}	9,310✔
168	}
169	Entry::Vacant(entry) => {	160,860✔
170	let py_name_attr = intern!(py, "name");	160,860✔
171	let name = param_ob.getattr(py_name_attr)?.extract::<PyBackedStr>()?;	160,860✔
172	if self.by_name.contains_key(&name) {	160,860✔
173	return Err(CircuitError::new_err(format!(	4✔
174	"name conflict adding parameter '{}'",	4✔
175	&name	4✔
176	)));	4✔
177	}	160,856✔
178	let element = if let Ok(vector) = param_ob.getattr(intern!(py, "vector")) {	160,856✔
179	let vector_uuid = VectorUuid::from_vector(&vector)?;	76,364✔
180	match self.vectors.entry(vector_uuid) {	76,364✔
181	Entry::Occupied(mut entry) => entry.get_mut().refcount += 1,	52,058✔
182	Entry::Vacant(entry) => {	24,306✔
183	entry.insert(VectorInfo {	24,306✔
184	name: vector.getattr(py_name_attr)?.extract()?,	24,306✔
185	refcount: 1,
186	});
187	}
188	}
189	Some(VectorElement {
190	vector_uuid,	76,364✔
191	index: param_ob.getattr(intern!(py, "index"))?.extract()?,	76,364✔
192	})
193	} else {
194	None	84,492✔
195	};
196	self.by_name.insert(name.clone(), uuid);	160,856✔
197	self.order.clear();	160,856✔
198	self.py_parameters = None;	160,856✔
199	let mut uses = HashSet::new();	160,856✔
200	if let Some(usage) = usage {	160,856✔
201	uses.insert_unique_unchecked(usage);	127,794✔
202	};	127,794✔
203	entry.insert(ParameterInfo {	160,856✔
204	name,	160,856✔
205	uses,	160,856✔
206	element,	160,856✔
207	object: param_ob.clone().unbind(),	160,856✔
208	});	160,856✔
209	}
210	}
211	Ok(uuid)	170,326✔
212	}	170,330✔
213
214	/// Untrack one use of a single Python-space `Parameter` object from the table, discarding all
215	/// other tracking of that `Parameter` if this was the last usage of it.
216	pub fn untrack(&mut self, param_ob: &Bound<PyAny>, usage: ParameterUse) -> PyResult<()> {	4✔
217	self.remove_use(ParameterUuid::from_parameter(param_ob)?, usage)	4✔
218	.map_err(PyErr::from)	4✔
219	}	4✔
220
221	/// Lookup the Python parameter object by name.
222	pub fn py_parameter_by_name(&self, name: &PyBackedStr) -> Option<&Py<PyAny>> {	9,450✔
223	self.by_name	9,450✔
224	.get(name)	9,450✔
225	.map(\|uuid\| &self.by_uuid[uuid].object)	9,450✔
226	}	9,450✔
227
228	/// Get the (maybe cached) Python list of the sorted `Parameter` objects.
229	pub fn py_parameters<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyList> {	278,186✔
230	if let Some(py_parameters) = self.py_parameters.as_ref() {	278,186✔
231	return py_parameters.clone_ref(py).into_bound(py);	137,230✔
232	}	140,956✔
233	self.ensure_sorted();	140,956✔
234	let out = PyList::new_bound(	140,956✔
235	py,	140,956✔
236	self.order	140,956✔
237	.iter()	140,956✔
238	.map(\|uuid\| self.by_uuid[uuid].object.clone_ref(py).into_bound(py)),	140,956✔
239	);	140,956✔
240	self.py_parameters = Some(out.clone().unbind());	140,956✔
241	out	140,956✔
242	}	278,186✔
243
244	/// Get a Python set of all tracked `Parameter` objects.
245	pub fn py_parameters_unsorted<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PySet>> {	266,648✔
246	PySet::new_bound(py, self.by_uuid.values().map(\|info\| &info.object))	266,648✔
247	}	266,648✔
248
249	/// Ensure that the `order` field is populated and sorted.
250	fn ensure_sorted(&mut self) {	141,210✔
251	// If `order` is already populated, it's sorted; it's the responsibility of the methods of	141,210✔
252	// this struct that mutate it to invalidate the cache.	141,210✔
253	if !self.order.is_empty() {	141,210✔
254	return;	254✔
255	}	140,956✔
256	self.order.reserve(self.by_uuid.len());	140,956✔
257	self.order.extend(self.by_uuid.keys());	140,956✔
258	self.order.sort_unstable_by_key(\|uuid\| {	140,956✔
259	let info = &self.by_uuid[uuid];	116,648✔
260	if let Some(vec) = info.element.as_ref() {	116,648✔
261	(&self.vectors[&vec.vector_uuid].name, vec.index)	114,260✔
262	} else {
263	(&info.name, 0)	2,388✔
264	}
265	})	140,956✔
266	}	141,210✔
267
268	/// Add a use of a parameter to the table.
269	pub fn add_use(	37,162✔
270	&mut self,	37,162✔
271	uuid: ParameterUuid,	37,162✔
272	usage: ParameterUse,	37,162✔
273	) -> Result<(), ParameterTableError> {	37,162✔
274	self.by_uuid	37,162✔
275	.get_mut(&uuid)	37,162✔
276	.ok_or(ParameterTableError::ParameterNotTracked(uuid))?	37,162✔
277	.uses
278	.insert(usage);	37,162✔
279	Ok(())	37,162✔
280	}	37,162✔
281
282	/// Return a use of a parameter.
283	///
284	/// If the last use a parameter is discarded, the parameter is untracked.
285	pub fn remove_use(	39,122✔
286	&mut self,	39,122✔
287	uuid: ParameterUuid,	39,122✔
288	usage: ParameterUse,	39,122✔
289	) -> Result<(), ParameterTableError> {	39,122✔
290	let Entry::Occupied(mut entry) = self.by_uuid.entry(uuid) else {	39,122✔
291	return Err(ParameterTableError::ParameterNotTracked(uuid));	36,434✔
292	};
293	let info = entry.get_mut();	2,688✔
294	if !info.uses.remove(&usage) {	2,688✔
295	return Err(ParameterTableError::UsageNotTracked(usage));	4✔
296	}	2,684✔
297	if info.uses.is_empty() {	2,684✔
298	self.by_name.remove(&info.name);	2,300✔
299	if let Some(vec) = info.element.as_ref() {	2,300✔
NEW 300	let Entry::Occupied(mut vec_entry) = self.vectors.entry(vec.vector_uuid) else {	×
NEW 301	unreachable!()	×
302	};
NEW 303	vec_entry.get_mut().refcount -= 1;	×
NEW 304	if vec_entry.get().refcount == 0 {	×
NEW 305	vec_entry.remove_entry();	×
NEW 306	}	×
307	}	2,300✔
308	self.order.clear();	2,300✔
309	self.py_parameters = None;	2,300✔
310	entry.remove_entry();	2,300✔
311	}	384✔
312	Ok(())	2,684✔
313	}	39,122✔
314
315	/// Remove a parameter from the table, returning the tracked uses of it.
316	pub fn pop(	132,878✔
317	&mut self,	132,878✔
318	uuid: ParameterUuid,	132,878✔
319	) -> Result<HashSet<ParameterUse>, ParameterTableError> {	132,878✔
320	let info = self	132,878✔
321	.by_uuid	132,878✔
322	.remove(&uuid)	132,878✔
323	.ok_or(ParameterTableError::ParameterNotTracked(uuid))?;	132,878✔
324	self.by_name	132,878✔
325	.remove(&info.name)	132,878✔
326	.expect("each parameter should be tracked by both UUID and name");	132,878✔
327	if let Some(element) = info.element {	132,878✔
328	self.vectors	27,206✔
329	.entry(element.vector_uuid)	27,206✔
330	.and_replace_entry_with(\|_k, mut vector_info\| {	27,206✔
331	vector_info.refcount -= 1;	27,206✔
332	(vector_info.refcount > 0).then_some(vector_info)	27,206✔
333	});	27,206✔
334	}	105,672✔
335	self.order.clear();	132,878✔
336	self.py_parameters = None;	132,878✔
337	Ok(info.uses)	132,878✔
338	}	132,878✔
339
340	/// Clear this table, yielding the Python parameter objects and their uses in sorted order.
341	pub fn drain_ordered(	254✔
342	&'_ mut self,	254✔
343	) -> impl Iterator<Item = (Py<PyAny>, HashSet<ParameterUse>)> + '_ {	254✔
344	self.ensure_sorted();	254✔
345	self.by_name.clear();	254✔
346	self.vectors.clear();	254✔
347	self.py_parameters = None;	254✔
348	self.order.drain(..).map(\|uuid\| {	5,280✔
349	let info = self	5,280✔
350	.by_uuid	5,280✔
351	.remove(&uuid)	5,280✔
352	.expect("tracked UUIDs should be consistent");	5,280✔
353	(info.object, info.uses)	5,280✔
354	})	5,280✔
355	}	254✔
356
357	/// Empty this `ParameterTable` of all its contents. This does not affect the capacities of the
358	/// internal data storage.
359	pub fn clear(&mut self) {	157,490✔
360	self.by_uuid.clear();	157,490✔
361	self.by_name.clear();	157,490✔
362	self.vectors.clear();	157,490✔
363	self.order.clear();	157,490✔
364	self.py_parameters = None;	157,490✔
365	}	157,490✔
366
367	/// Expose the tracked data for a given parameter as directly as possible to Python space.
368	///
369	/// This is only really intended for use in testing.
370	pub(crate) fn _py_raw_entry(&self, param: Bound<PyAny>) -> PyResult<Py<PySet>> {	166✔
371	let py = param.py();	166✔
372	let uuid = ParameterUuid::from_parameter(&param)?;	166✔
373	let info = self	166✔
374	.by_uuid	166✔
375	.get(&uuid)	166✔
376	.ok_or(ParameterTableError::ParameterNotTracked(uuid))?;	166✔
377	// PyO3's `PySet::new_bound` only accepts iterables of references.
378	let out = PySet::empty_bound(py)?;	166✔
379	for usage in info.uses.iter() {	182✔
380	match usage {	182✔
381	ParameterUse::GlobalPhase => out.add((py.None(), py.None()))?,	8✔
382	ParameterUse::Index {
383	instruction,	174✔
384	parameter,	174✔
385	} => out.add((instruction, parameter))?,	174✔
386	}
387	}
388	Ok(out.unbind())	166✔
389	}	166✔
390
391	/// Accept traversal of this object by the Python garbage collector.
392	///
393	/// This is not a pyclass, so it's up to our owner to delegate their own traversal to us.
394	pub fn py_gc_traverse(&self, visit: &PyVisit) -> Result<(), PyTraverseError> {	25,211,760✔
395	for info in self.by_uuid.values() {	25,211,760✔
396	visit.call(&info.object)?	596,516✔
397	}
398	// We don't need to / can't visit the `PyBackedStr` stores.
399	if let Some(list) = self.py_parameters.as_ref() {	25,211,760✔
400	visit.call(list)?	3,145,512✔
401	}	22,066,248✔
402	Ok(())	25,211,760✔
403	}	25,211,760✔
404	}

Qiskit / qiskit / 10199425044

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