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