From 8c4568d25e771a4c4cc405c53adaa09b7abd684f Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Sun, 25 Aug 2024 20:21:05 +0100
Subject: [PATCH] Add no-hash-lookup way to retrieve the default interned value

This makes it possible to do `Interner::get_default()` without any
value, in order to retrieve a key pointing to the default allocation
without making any hash lookups.  While the hashing and equality check
of the default allocation is typically very cheap (like the empty
slice), acquiring it still generally required a function call, which
often needed to be paid frequently.
---
 crates/circuit/src/circuit_data.rs |  4 ++--
 crates/circuit/src/interner.rs     | 30 +++++++++++++++++++++++++++++-
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index 640eb22b9401..94475d2a7d86 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -199,7 +199,7 @@ impl CircuitData {
             instruction_iter.size_hint().0,
             global_phase,
         )?;
-        let no_clbit_index = res.cargs_interner.insert(&[]);
+        let no_clbit_index = res.cargs_interner.get_default();
         for (operation, params, qargs) in instruction_iter {
             let qubits = res.qargs_interner.insert(&qargs);
             let params = (!params.is_empty()).then(|| Box::new(params));
@@ -258,7 +258,7 @@ impl CircuitData {
         params: &[Param],
         qargs: &[Qubit],
     ) -> PyResult<()> {
-        let no_clbit_index = self.cargs_interner.insert(&[]);
+        let no_clbit_index = self.cargs_interner.get_default();
         let params = (!params.is_empty()).then(|| Box::new(params.iter().cloned().collect()));
         let qubits = self.qargs_interner.insert(qargs);
         self.data.push(PackedInstruction {
diff --git a/crates/circuit/src/interner.rs b/crates/circuit/src/interner.rs
index 007256422e25..4c42bdcfd50f 100644
--- a/crates/circuit/src/interner.rs
+++ b/crates/circuit/src/interner.rs
@@ -50,17 +50,23 @@ unsafe impl<T: ?Sized> Sync for Interned<T> {}
 /// itself (the `Interned` type), rather than raw references; the `Interned` type is narrower than a
 /// true reference.
 ///
+/// This can only be implemented for owned types that implement `Default`, so that the convenience
+/// method `Interned::get_default` can work reliably and correctly; the "default" index needs to be
+/// guaranteed to be reserved and present for safety.
+///
 /// # Examples
 ///
 /// ```rust
 /// let mut interner = Interner::<[usize]>::new();
 ///
 /// // These are of type `Interned<[usize]>`.
+/// let default_empty = interner.get_default();
 /// let empty = interner.insert(&[]);
 /// let other_empty = interner.insert(&[]);
 /// let key = interner.insert(&[0, 1, 2, 3, 4]);
 ///
 /// assert_eq!(empty, other_empty);
+/// assert_eq!(empty, default_empty);
 /// assert_ne!(empty, key);
 ///
 /// assert_eq!(interner.get(empty), &[]);
@@ -93,9 +99,31 @@ where
 impl<T> Interner<T>
 where
     T: ?Sized + ToOwned,
+    <T as ToOwned>::Owned: Hash + Eq + Default,
 {
+    /// Construct a new interner.  The stored type must have a default value, in order for
+    /// `Interner::get_default` to reliably work correctly without a hash lookup (though ideally
+    /// we'd just use specialisation to do that).
     pub fn new() -> Self {
-        Self(Default::default())
+        let mut set = IndexSet::with_capacity_and_hasher(1, Default::default());
+        set.insert(Default::default());
+        Self(set)
+    }
+
+    /// Retrieve the key corresponding to the default store, without any hash or equality lookup.
+    /// For example, if the interned type is `[Clbit]`, the default key corresponds to the empty
+    /// slice `&[]`.  This is a common operation with the cargs interner, for things like pushing
+    /// gates.
+    ///
+    /// In an ideal world, we wouldn't have the `Default` trait bound on `new`, but would use
+    /// specialisation to insert the default key only if the stored value implemented `Default`
+    /// (we'd still trait-bound this method).
+    #[inline(always)]
+    pub fn get_default(&self) -> Interned<T> {
+        Interned {
+            index: 0,
+            _type: PhantomData,
+        }
     }
 }