Fix how an instruction's used/blocked frames are calculated

src/instruction.rs

@@ -942,6 +942,18 @@ impl Instruction {
             _ => {}
         }
     }
+
+    #[cfg(test)]
+    /// Parse a single instruction from an input string. Returns an error if the input fails to parse,
+    /// or if there is input left over after parsing.
+    pub(crate) fn parse(input: &str) -> Result<Self, String> {
+        use crate::parser::{instruction::parse_instruction, lex};
+
+        let lexed = lex(input)?;
+        let (_, instruction) =
+            nom::combinator::all_consuming(parse_instruction)(&lexed).map_err(|e| e.to_string())?;
+        Ok(instruction)
+    }
 }
 
 #[cfg(test)]

src/parser/mod.rs

@@ -28,7 +28,7 @@ mod macros;
 mod common;
 mod error;
 mod expression;
-mod instruction;
+pub(crate) mod instruction;
 mod lexer;
 
 type ParserInput<'a> = &'a [Token];

src/program/frame.rs

@@ -35,18 +35,57 @@ impl FrameSet {
         self.frames.keys().collect()
     }
 
-    /// Return all contained FrameIdentifiers which include **exactly** these qubits (in any order)
-    /// and - if names are provided - match one of the names.
-    pub fn get_matching_keys(&self, qubits: &[Qubit], names: &[String]) -> Vec<&FrameIdentifier> {
-        let qubit_set: HashSet<&Qubit> = qubits.iter().collect();
-        self.frames
-            .iter()
-            .filter(|(identifier, _)| {
-                (names.is_empty() || names.contains(&identifier.name))
-                    && qubit_set == identifier.qubits.iter().collect()
-            })
-            .map(|(id, _)| id)
-            .collect::<Vec<_>>()
+    /// Return all frames in the set which match all of these conditions. If a frame _would_ match, but is
+    /// not present in this [FrameSet], then it is not returned (notably, the [FrameMatchCondition::Specific]
+    /// match condition).
+    pub(crate) fn get_matching_keys<'s, 'a>(
+        &'s self,
+        condition: FrameMatchCondition<'a>,
+    ) -> HashSet<&'s FrameIdentifier> {
+        let keys = self.frames.keys();
+
+        match condition {
+            FrameMatchCondition::All => keys.collect(),
+            FrameMatchCondition::AnyOfNames(names) => {
+                keys.filter(|&f| names.contains(&f.name)).collect()
+            }
+            FrameMatchCondition::AnyOfQubits(qubits) => {
+                let any_of_set: HashSet<_> = qubits.iter().collect();
+
+                keys.filter(|&f| f.qubits.iter().any(|q| any_of_set.contains(q)))
+                    .collect()
+            }
+            FrameMatchCondition::ExactQubits(qubits) => {
+                let all_of_set: HashSet<_> = qubits.iter().collect();
+
+                keys.filter(|&f| f.qubits.iter().all(|q| all_of_set.contains(q)))
+                    .collect()
+            }
+            FrameMatchCondition::Specific(frame) => {
+                // This unusual pattern (fetch key & value by key, discard value) allows us to return
+                // a reference to `self` rather than `condition`, keeping lifetimes simpler.
+                if let Some((frame, _)) = self.frames.get_key_value(frame) {
+                    vec![frame].into_iter().collect()
+                } else {
+                    HashSet::new()
+                }
+            }
+            FrameMatchCondition::And(conditions) => conditions
+                .into_iter()
+                .map(|c| self.get_matching_keys(c))
+                .reduce(|acc, el| acc.into_iter().filter(|&v| el.contains(v)).collect())
+                .unwrap_or_default(),
+            FrameMatchCondition::Or(conditions) => conditions
+                .into_iter()
+                .map(|c| self.get_matching_keys(c))
+                .reduce(|mut acc, el| {
+                    el.into_iter().for_each(|v| {
+                        acc.insert(v);
+                    });
+                    acc
+                })
+                .unwrap_or_default(),
+        }
     }
 
     /// Retrieve the attributes of a frame by its identifier.
@@ -87,3 +126,27 @@ impl FrameSet {
             .collect()
     }
 }
+
+pub(crate) enum FrameMatchCondition<'a> {
+    /// Match all frames in the set
+    All,
+
+    /// Match all frames which shares any one of these names
+    AnyOfNames(&'a [String]),
+
+    /// Match all frames which contain any of these qubits
+    AnyOfQubits(&'a [Qubit]),
+
+    /// Match all frames which contain exactly these qubits
+    ExactQubits(&'a [Qubit]),
+
+    /// Return these specific frames, if present in the set
+    Specific(&'a FrameIdentifier),
+
+    /// Return all frames which match all of these conditions
+    And(Vec<FrameMatchCondition<'a>>),
+
+    /// Return all frames which match any of these conditions
+    #[allow(dead_code)]
+    Or(Vec<FrameMatchCondition<'a>>),
+}

src/program/graph.rs

@@ -234,19 +234,30 @@ impl InstructionBlock {
                     Ok(())
                 }
                 InstructionRole::RFControl => {
-                    let frames = match program.get_frames_for_instruction(instruction, true) {
+                    let used_frames = match program.get_frames_for_instruction(instruction, false) {
+                        Some(frames) => frames,
+                        None => vec![],
+                    };
+                    let blocked_frames = match program.get_frames_for_instruction(instruction, true)
+                    {
                         Some(frames) => frames,
                         None => vec![],
                     };
 
-                    // Mark a dependency on the last instruction which executed in the context of each target frame
-                    for frame in frames {
+                    // Take a dependency on any previous instructions to _block_ or _use_ a frame which this instruction _uses_.
+                    for frame in used_frames {
                         let previous_node_id = last_instruction_by_frame
                             .entry(frame.clone())
                             .or_insert(ScheduledGraphNode::BlockStart);
                         add_dependency!(graph, *previous_node_id => node, ExecutionDependency::ReferenceFrame);
                         last_instruction_by_frame.insert(frame.clone(), node);
                     }
+
+                    // We mark all "blocked" frames as such for later instructions to take a dependency on
+                    for frame in blocked_frames {
+                        last_instruction_by_frame.insert(frame.clone(), node);
+                    }
+
                     Ok(())
                 }
                 InstructionRole::ControlFlow => Err(ScheduleError {

src/program/graphviz_dot.rs

@@ -234,6 +234,8 @@ DEFFRAME 0 \"ro_rx\":
     INITIAL-FREQUENCY: 1e6
 DEFFRAME 0 \"ro_tx\":
     INITIAL-FREQUENCY: 1e6
+DEFFRAME 0 1 \"cz\":
+    INITIAL-FREQUENCY: 1e6
 ";
 
                     let program =
@@ -309,8 +311,19 @@ NONBLOCKING PULSE 0 \"rf\" test(duration: 1e6)
 NONBLOCKING PULSE 1 \"rf\" test(duration: 1e6)
 "
         );
+
         build_dot_format_snapshot_test_case!(fence_all, "FENCE");
 
+        build_dot_format_snapshot_test_case!(
+            fence_wrapper,
+            "
+FENCE
+NONBLOCKING PULSE 0 1 \"cz\" test(duration: 1e-6)
+NONBLOCKING PULSE 1 \"rf\" test(duration: 1e-6)
+FENCE 1
+"
+        );
+
         build_dot_format_snapshot_test_case!(
             jump,
             "DECLARE ro BIT