CSY/reowolf Changeset - dd4e6a5314f7 · Centrum Wiskunde & Informatica (CWI)

Changeset - dd4e6a5314f7

Parent rev.

Child rev.

[Not reviewed]

0 6 0

MH - 4 years ago 2021-11-23 15:16:34
contact@maxhenger.nl

WIP on more failure fixing

6 files changed with 164 insertions and 35 deletions:

src/collections/sets.rs

src/runtime2/connector.rs

src/runtime2/consensus.rs

149

src/runtime2/inbox.rs

src/runtime2/tests/mod.rs

src/runtime2/tests/sync_failure.rs

0 comments (0 inline, 0 general)

src/collections/sets.rs

➞

Show inline comments

@@ @@ -61,53 +61,58 @@ impl<T: Eq> DequeSet<T> { @@
 pub struct VecSet<T: Eq> {
     inner: Vec<T>,
+}
 impl<T: Eq> VecSet<T> {
     pub fn new() -> Self {
         Self{ inner: Vec::new() }
+    }
     #[inline]
     pub fn pop(&mut self) -> Option<T> {
         self.inner.pop()
+    }
     /// Pushes a new element into the set. Returns `false` if it was already
     /// present and `true` if it is newly added.
     #[inline]
     pub fn push(&mut self, to_push: T) -> bool {
         for element in self.inner.iter() {
             if *element == to_push {
                 return false;
+            }
+        }
         self.inner.push(to_push);
         return true
+    }
     #[inline]
     pub fn clear(&mut self) {
         self.inner.clear();
+    }
     #[inline]
     pub fn iter(&self) -> impl Iterator<Item=&T> {
         return self.inner.iter();
+    }
     #[inline]
     pub fn contains(&self, item: &T) -> bool {
         return self.inner.contains(item);
+    }
     #[inline]
     pub fn is_empty(&self) -> bool {
         self.inner.is_empty()
+    }
     #[inline]
     pub fn len(&self) -> usize {
         return self.inner.len();
+    }
     #[inline]
     pub fn into_vec(self) -> Vec<T> {
         return self.inner;
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/connector.rs

➞

Show inline comments

@@ @@ -358,102 +358,104 @@ impl ConnectorPDL { @@
                     return ConnectorScheduling::Immediate;
+                }
+            }
             EvalContinuation::SyncBlockEnd => {
                 let consistency = self.consensus.notify_of_finished_branch(branch_id);
                 if consistency == Consistency::Valid {
                     branch.sync_state = SpeculativeState::ReachedSyncEnd;
                     self.tree.push_into_queue(QueueKind::FinishedSync, branch_id);
                 } else {
                     branch.sync_state = SpeculativeState::Inconsistent;
+                }
             },
             EvalContinuation::NewFork => {
                 // Like the `NewChannel` result. This means we're setting up
                 // a branch and putting a marker inside the RunContext for the
                 // next time we run the PDL code
                 let left_id = branch_id;
                 let right_id = self.tree.fork_branch(left_id);
                 self.consensus.notify_of_new_branch(left_id, right_id);
                 self.tree.push_into_queue(QueueKind::Runnable, left_id);
                 self.tree.push_into_queue(QueueKind::Runnable, right_id);
                 let left_branch = &mut self.tree[left_id];
                 left_branch.prepared = PreparedStatement::ForkedExecution(true);
                 let right_branch = &mut self.tree[right_id];
                 right_branch.prepared = PreparedStatement::ForkedExecution(false);
+            }
             EvalContinuation::Put(port_id, content) => {
                 // Branch is attempting to send data
                 let port_id = PortIdLocal::new(port_id.0.u32_suffix);
                 let (sync_header, data_header) = self.consensus.handle_message_to_send(branch_id, port_id, &content, comp_ctx);
                 let message = DataMessage{ sync_header, data_header, content };
                 match comp_ctx.submit_message(Message::Data(message)) {
                     Ok(_) => {
                         // Message is underway
                         branch.prepared = PreparedStatement::PerformedPut;
                         self.tree.push_into_queue(QueueKind::Runnable, branch_id);
                         return ConnectorScheduling::Immediate;
                     },
                     Err(_) => {
                         // We don't own the port
                         let pd = &sched_ctx.runtime.protocol_description;
                         let eval_error = branch.code_state.new_error_at_expr(
                             &pd.modules, &pd.heap,
                             String::from("attempted to 'put' on port that is no longer owned")
                         );
                         self.eval_error = Some(eval_error);
                         self.mode = Mode::SyncError;
                         println!("DEBUGERINO: Notify of fatal branch");
                         if let Some(conclusion) = self.consensus.notify_of_fatal_branch(branch_id, comp_ctx) {
                             println!("DEBUGERINO: Actually got {:?}", conclusion);
                             return self.enter_non_sync_mode(conclusion, comp_ctx);
+                        }
+                    }
+                }
                 branch.prepared = PreparedStatement::PerformedPut;
                 self.tree.push_into_queue(QueueKind::Runnable, branch_id);
                 return ConnectorScheduling::Immediate;
             },
             _ => unreachable!("unexpected run result {:?} in sync mode", run_result),
+        }
         // If here then the run result did not require a particular action. We
         // return whether we have more active branches to run or not.
         if self.tree.queue_is_empty(QueueKind::Runnable) {
             return ConnectorScheduling::NotNow;
         } else {
             return ConnectorScheduling::Later;
+        }
+    }
     pub fn run_in_deterministic_mode(&mut self, sched_ctx: SchedulerCtx, comp_ctx: &mut ComponentCtx) -> ConnectorScheduling {
         debug_assert!(!self.tree.is_in_sync() && !self.consensus.is_in_sync());
         let branch = self.tree.base_branch_mut();
         debug_assert!(branch.sync_state == SpeculativeState::RunningNonSync);
         let mut run_context = ConnectorRunContext{
             branch_id: branch.id,
             consensus: &self.consensus,
             prepared: branch.prepared.take(),
         };
         let run_result = Self::run_prompt(&mut branch.code_state, &sched_ctx.runtime.protocol_description, &mut run_context);
         if let Err(eval_error) = run_result {
             comp_ctx.push_error(eval_error);
             return ConnectorScheduling::Exit
+        }
         let run_result = run_result.unwrap();
         match run_result {
             EvalContinuation::ComponentTerminated => {
                 branch.sync_state = SpeculativeState::Finished;
                 return ConnectorScheduling::Exit;
             },
             EvalContinuation::SyncBlockStart => {
                 comp_ctx.notify_sync_start();
                 let sync_branch_id = self.tree.start_sync();
                 debug_assert!(self.last_finished_handled.is_none());
                 self.consensus.start_sync(comp_ctx);
                 self.consensus.notify_of_new_branch(BranchId::new_invalid(), sync_branch_id);
                 self.tree.push_into_queue(QueueKind::Runnable, sync_branch_id);
                 self.mode = Mode::Sync;
                 return ConnectorScheduling::Immediate;
             },
             EvalContinuation::NewComponent(definition_id, monomorph_idx, arguments) => {

src/runtime2/consensus.rs

➞

Show inline comments

 use crate::collections::VecSet;
 use crate::protocol::eval::ValueGroup;
 use crate::runtime2::inbox::SyncCompContent::Presence;
 use crate::runtime2::port::PortState;
 use super::ConnectorId;
 use super::branch::BranchId;
 use super::port::{ChannelId, PortIdLocal};
 use super::inbox::{
     Message, DataHeader, SyncHeader, ChannelAnnotation, BranchMarker,
     DataMessage,
     SyncCompMessage, SyncCompContent,
     SyncPortMessage, SyncPortContent,
     SyncControlMessage, SyncControlContent
 };
 use super::scheduler::{ComponentCtx, ComponentPortChange};
 struct BranchAnnotation {
     channel_mapping: Vec<ChannelAnnotation>,
     cur_marker: BranchMarker,
+}
 #[derive(Debug)]
 pub(crate) struct LocalSolution {
     component: ConnectorId,
     final_branch_id: BranchId,
     port_mapping: Vec<(ChannelId, BranchMarker)>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct GlobalSolution {
     component_branches: Vec<(ConnectorId, BranchId)>,
     channel_mapping: Vec<(ChannelId, BranchMarker)>, // TODO: This can go, is debugging info
+}
 #[derive(Debug, PartialEq, Eq)]
 pub enum RoundConclusion {
     Failure,
     Success(BranchId),
+}
 // -----------------------------------------------------------------------------
 // Consensus
 // -----------------------------------------------------------------------------
 struct Peer {
     id: ConnectorId,
     encountered_this_round: bool,
     expected_sync_round: u32,
+}
 /// The consensus algorithm. Currently only implemented to find the component
@@ @@ -122,103 +124,118 @@ impl Consensus { @@
     pub fn start_sync(&mut self, ctx: &ComponentCtx) {
         debug_assert!(!self.highest_connector_id.is_valid());
         debug_assert!(self.branch_annotations.is_empty());
         debug_assert!(self.solution_combiner.local.is_empty());
         // We'll use the first "branch" (the non-sync one) to store our ports,
         // this allows cloning if we created a new branch.
         self.branch_annotations.push(BranchAnnotation{
             channel_mapping: ctx.get_ports().iter()
                 .map(|v| ChannelAnnotation {
                     channel_id: v.channel_id,
                     registered_id: None,
                     expected_firing: None,
                 })
                 .collect(),
             cur_marker: BranchMarker::new_invalid(),
         });
         self.branch_markers.push(BranchId::new_invalid());
         self.highest_connector_id = ctx.id;
+    }
     /// Notifies the consensus algorithm that a new branch has appeared. Must be
     /// called for each forked branch in the execution tree.
     pub fn notify_of_new_branch(&mut self, parent_branch_id: BranchId, new_branch_id: BranchId) {
         // If called correctly. Then each time we are notified the new branch's
         // index is the length in `branch_annotations`.
         debug_assert!(self.branch_annotations.len() == new_branch_id.index as usize);
         let parent_branch_annotations = &self.branch_annotations[parent_branch_id.index as usize];
         let new_marker = BranchMarker::new(self.branch_markers.len() as u32);
         let new_branch_annotations = BranchAnnotation{
             channel_mapping: parent_branch_annotations.channel_mapping.clone(),
             cur_marker: new_marker,
         };
         self.branch_annotations.push(new_branch_annotations);
         self.branch_markers.push(new_branch_id);
+    }
     /// Notifies the consensus algorithm that a particular branch has
     /// encountered an unrecoverable error.
     pub fn notify_of_fatal_branch(&mut self, failed_branch_id: BranchId, ctx: &mut ComponentCtx) -> Option<RoundConclusion> {
         debug_assert!(self.is_in_sync());
         // Check for trivial case, where branch has not yet communicated within
         // the consensus algorithm
         let branch = &self.branch_annotations[failed_branch_id.index as usize];
         if branch.channel_mapping.iter().all(|v| v.registered_id.is_none()) {
             println!("DEBUG: Failure everything silent");
             return Some(RoundConclusion::Failure);
+        }
         // We need to go through the hassle of notifying all participants in the
         // sync round that we've encountered an error.
         // --- notify leader
         let mut channel_presence = Vec::with_capacity(branch.channel_mapping.len());
         for mapping in &branch.channel_mapping {
             let port = ctx.get_port_by_channel_id(mapping.channel_id).unwrap();
             channel_presence.push(LocalChannelPresence{
                 channel_id: mapping.channel_id,
                 is_closed: port.state == PortState::Closed,
             });
+        }
         let _never_conclusion = self.send_to_leader_or_handle_as_leader(SyncCompContent::Presence(ComponentPresence{
             component_id: ctx.id,
             channels: channel_presence,
         }), ctx);
         debug_assert!(_never_conclusion.is_none());
         let maybe_conclusion = self.send_to_leader_or_handle_as_leader(SyncCompContent::LocalFailure, ctx);
         println!("DEBUG: Maybe conclusion is {:?}", maybe_conclusion);
         // --- initiate discovery wave (to let leader know about all components)
         self.handled_wave = true;
         for mapping in &self.branch_annotations[0].channel_mapping {
             let channel_id = mapping.channel_id;
             let port_info = ctx.get_port_by_channel_id(channel_id).unwrap();
             let message = SyncPortMessage{
                 sync_header: self.create_sync_header(ctx),
                 source_port: port_info.self_id,
                 target_port: port_info.peer_id,
                 content: SyncPortContent::NotificationWave,
             };
             // Note: submitting the message might fail. But we're attempting to
             // handle the error anyway.
             // TODO: Think about this a second time: how do we make sure the
             //  entire network will fail if we reach this condition
             let _unused = ctx.submit_message(Message::SyncPort(message));
+        }
         return maybe_conclusion;
+    }
     /// Notifies the consensus algorithm that a branch has reached the end of
     /// the sync block. A final check for consistency will be performed that the
     /// caller has to handle. Note that
     pub fn notify_of_finished_branch(&self, branch_id: BranchId) -> Consistency {
         debug_assert!(self.is_in_sync());
         let branch = &self.branch_annotations[branch_id.index as usize];
         for mapping in &branch.channel_mapping {
             match mapping.expected_firing {
                 Some(expected) => {
                     if expected != mapping.registered_id.is_some() {
                         // Inconsistent speculative state and actual state
                         debug_assert!(mapping.registered_id.is_none()); // because if we did fire on a silent port, we should've caught that earlier
                         return Consistency::Inconsistent;
+                    }
                 },
                 None => {},
+            }
+        }
         return Consistency::Valid;
+    }
     /// Notifies the consensus algorithm that a particular branch has assumed
     /// a speculative value for its port mapping.
     pub fn notify_of_speculative_mapping(&mut self, branch_id: BranchId, port_id: PortIdLocal, does_fire: bool, ctx: &ComponentCtx) -> Consistency {
@@ @@ -373,177 +390,198 @@ impl Consensus { @@
             new_mapping: branch.cur_marker,
         };
         // Update port mapping
         for mapping in &mut branch.channel_mapping {
             if mapping.channel_id == port_info.channel_id {
                 mapping.expected_firing = Some(true);
                 mapping.registered_id = Some(branch.cur_marker);
+            }
+        }
         // Update branch marker
         let new_marker = BranchMarker::new(self.branch_markers.len() as u32);
         branch.cur_marker = new_marker;
         self.branch_markers.push(branch_id);
         self.encountered_ports.push(source_port_id);
         return (self.create_sync_header(ctx), data_header);
+    }
     /// Handles a new data message by handling the sync header. The caller is
     /// responsible for checking for branches that might be able to receive
     /// the message.
     pub fn handle_new_data_message(&mut self, message: &DataMessage, ctx: &mut ComponentCtx) -> bool {
         let handled = self.handle_received_sync_header(&message.sync_header, ctx);
         if handled {
             self.encountered_ports.push(message.data_header.target_port);
+        }
         return handled;
+    }
     /// Handles a new sync message by handling the sync header and the contents
     /// of the message. Returns `Some` with the branch ID of the global solution
     /// if the sync solution has been found.
     pub fn handle_new_sync_comp_message(&mut self, message: SyncCompMessage, ctx: &mut ComponentCtx) -> Option<RoundConclusion> {
         if !self.handle_received_sync_header(&message.sync_header, ctx) {
             return None;
+        }
         // And handle the contents
         debug_assert_eq!(message.target_component_id, ctx.id);
         match &message.content {
             SyncCompContent::LocalFailure |
             SyncCompContent::LocalSolution(_) |
             SyncCompContent::PartialSolution(_) |
             SyncCompContent::AckFailure |
-            SyncCompContent::Presence(_, _) => {
             SyncCompContent::Presence(_) => {
                 // Needs to be handled by the leader
                 return self.send_to_leader_or_handle_as_leader(message.content, ctx);
             },
             SyncCompContent::GlobalSolution(solution) => {
                 // Found a global solution
                 debug_assert_ne!(self.highest_connector_id, ctx.id); // not the leader
                 let (_, branch_id) = solution.component_branches.iter()
                     .find(|(component_id, _)| *component_id == ctx.id)
                     .unwrap();
                 return Some(RoundConclusion::Success(*branch_id));
             },
             SyncCompContent::GlobalFailure => {
                 // Global failure of round, send Ack to leader
                 println!("DEBUGERINO: Got GlobalFailure, sending Ack in response");
                 debug_assert_ne!(self.highest_connector_id, ctx.id); // not the leader
                 let _result = self.send_to_leader_or_handle_as_leader(SyncCompContent::AckFailure, ctx);
                 debug_assert!(_result.is_none());
                 return Some(RoundConclusion::Failure);
             },
             SyncCompContent::Notification => {
                 // We were just interested in the sync header we handled above
                 return None;
+            }
+        }
+    }
     pub fn handle_new_sync_port_message(&mut self, message: SyncPortMessage, ctx: &mut ComponentCtx) {
+    pub fn handle_new_sync_port_message(&mut self, message: SyncPortMessage, ctx: &mut ComponentCtx) -> Option<RoundConclusion> {
         if !self.handle_received_sync_header(&message.sync_header, ctx) {
             return;
+            return None;
+        }
         debug_assert!(self.is_in_sync());
         debug_assert!(ctx.get_port_by_id(message.target_port).is_some());
         match message.content {
             SyncPortContent::SilentPortNotification => {
                 // The point here is to let us become part of the sync round and
                 // take note of the leader in case all of our ports are silent.
                 self.encountered_ports.push(message.target_port);
                 return None
+            }
             SyncPortContent::NotificationWave => {
                 // Wave to discover everyone in the network, handling sync
                 // header takes care of leader discovery, here we need to make
                 // sure we propagate the wave
                 if self.handled_wave {
                     return;
+                    return None;
+                }
                 self.handled_wave = true;
                 // Propagate wave to all peers except the one that has sent us
                 // the wave.
                 for mapping in &self.branch_annotations[0].channel_mapping {
                     let channel_id = mapping.channel_id;
                     let port_desc = ctx.get_port_by_channel_id(channel_id).unwrap();
                     if port_desc.self_id == message.target_port {
                         // Wave came from this port, no need to send one back
                         continue;
+                    }
                     let message = SyncPortMessage{
                         sync_header: self.create_sync_header(ctx),
                         source_port: port_desc.self_id,
                         target_port: port_desc.peer_id,
                         content: SyncPortContent::NotificationWave,
                     };
                     // As with the other SyncPort where we throw away the
                     // result: we're dealing with an error here anyway
                     let _unused = ctx.submit_message(Message::SyncPort(message));
+                }
                 // And let the leader know about our port state
                 let annotations = &self.branch_annotations[0];
                 let mut channels = Vec::with_capacity(annotations.channel_mapping.len());
                 for mapping in &annotations.channel_mapping {
                     let port_info = ctx.get_port_by_channel_id(mapping.channel_id).unwrap();
                     channels.push(LocalChannelPresence{
                         channel_id: mapping.channel_id,
                         is_closed: port_info.state == PortState::Closed,
                     });
+                }
                 let maybe_conlusion = self.send_to_leader_or_handle_as_leader(SyncCompContent::Presence(ComponentPresence{
                     component_id: ctx.id,
                     channels,
                 }), ctx);
                 return maybe_conlusion;
+            }
+        }
+    }
     pub fn handle_new_sync_control_message(&mut self, message: SyncControlMessage, ctx: &mut ComponentCtx) -> Option<RoundConclusion> {
         if message.in_response_to_sync_round < self.sync_round {
             // Old message
             return None
+        }
         match message.content {
             SyncControlContent::ChannelIsClosed(_) => {
                 // TODO: This is wrong! This might happen in a normal sync. And
                 // we don't want to fail immediately!
                 return Some(RoundConclusion::Failure);
+            }
+        }
+    }
     pub fn notify_of_received_message(&mut self, branch_id: BranchId, message: &DataMessage, ctx: &ComponentCtx) {
         debug_assert!(self.branch_can_receive(branch_id, message));
         let target_port = ctx.get_port_by_id(message.data_header.target_port).unwrap();
         let branch = &mut self.branch_annotations[branch_id.index as usize];
         for mapping in &mut branch.channel_mapping {
             if mapping.channel_id == target_port.channel_id {
                 // Found the port in which the message should be inserted
                 mapping.registered_id = Some(message.data_header.new_mapping);
                 // Check for sent ports
                 debug_assert!(self.workspace_ports.is_empty());
                 find_ports_in_value_group(&message.content, &mut self.workspace_ports);
                 if !self.workspace_ports.is_empty() {
                     todo!("handle received ports");
                     self.workspace_ports.clear();
+                }
                 return;
+            }
+        }
         // If here, then the branch didn't actually own the port? Means the
         // caller made a mistake
         unreachable!("incorrect notify_of_received_message");
+    }
     /// Matches the mapping between the branch and the data message. If they
     /// match then the branch can receive the message.
     pub fn branch_can_receive(&self, branch_id: BranchId, message: &DataMessage) -> bool {
         if let Some(peer) = self.peers.iter().find(|v| v.id == message.sync_header.sending_component_id) {
             if message.sync_header.sync_round < peer.expected_sync_round {
                 return false;
+            }
+        }
         let annotation = &self.branch_annotations[branch_id.index as usize];
         for expected in &message.data_header.expected_mapping {
             // If we own the port, then we have an entry in the
             // annotation, check if the current mapping matches
             for current in &annotation.channel_mapping {
                 if expected.channel_id == current.channel_id {
                     if expected.registered_id != current.registered_id {
@@ @@ -611,249 +649,288 @@ impl Consensus { @@
                 entry.encountered_this_round = true;
                 // TODO: Proper handling of potential overflow
                 if sync_header.sync_round >= entry.expected_sync_round {
                     entry.expected_sync_round = sync_header.sync_round;
                     return true;
                 } else {
                     return false;
+                }
             },
             None => {
                 self.peers.push(Peer{
                     id: sync_header.sending_component_id,
                     encountered_this_round: true,
                     expected_sync_round: sync_header.sync_round,
                 });
                 return true;
+            }
+        }
+    }
     /// Sends a message towards the leader, if already the leader then the
     /// message will be handled immediately.
     fn send_to_leader_or_handle_as_leader(&mut self, content: SyncCompContent, ctx: &mut ComponentCtx) -> Option<RoundConclusion> {
         if self.highest_connector_id == ctx.id {
             // We are the leader
             match content {
                 SyncCompContent::LocalFailure => {
                     if self.solution_combiner.mark_failure_and_check_for_global_failure() {
                         return self.handle_global_failure_as_leader(ctx);
+                    }
                 },
                 SyncCompContent::LocalSolution(local_solution) => {
                     if let Some(global_solution) = self.solution_combiner.add_solution_and_check_for_global_solution(local_solution) {
                         return self.handle_global_solution_as_leader(global_solution, ctx);
+                    }
                 },
                 SyncCompContent::PartialSolution(partial_solution) => {
                     if let Some(conclusion) = self.solution_combiner.combine(partial_solution) {
                         match conclusion {
                             LeaderConclusion::Solution(global_solution) => {
                                 return self.handle_global_solution_as_leader(global_solution, ctx);
                             },
                             LeaderConclusion::Failure => {
                                 return self.handle_global_failure_as_leader(ctx);
+                            }
+                        }
+                    }
                 },
                 SyncCompContent::Presence(component_id, presence) => {
                     if self.solution_combiner.add_presence_and_check_for_global_failure(component_id, &presence) {
                 SyncCompContent::Presence(component_presence) => {
                     if self.solution_combiner.add_presence_and_check_for_global_failure(component_presence.component_id, &component_presence.channels) {
                         return self.handle_global_failure_as_leader(ctx);
+                    }
                 },
                 SyncCompContent::AckFailure => {
                     debug_assert_eq!(Some(RoundConclusion::Failure), self.conclusion);
                     debug_assert!(self.ack_remaining > 0);
                     self.ack_remaining -= 1;
                     if self.ack_remaining == 0 {
                         return Some(RoundConclusion::Failure);
+                    }
+                }
                 SyncCompContent::Notification | SyncCompContent::GlobalSolution(_) |
                 SyncCompContent::GlobalFailure => {
                     unreachable!("unexpected message content for leader");
                 },
+            }
         } else {
             // Someone else is the leader
             let message = SyncCompMessage {
                 sync_header: self.create_sync_header(ctx),
                 target_component_id: self.highest_connector_id,
                 content,
             };
             ctx.submit_message(Message::SyncComp(message)).unwrap(); // unwrap: sending to component instead of through channel
+        }
         return None;
+    }
     fn handle_global_solution_as_leader(&mut self, global_solution: GlobalSolution, ctx: &mut ComponentCtx) -> Option<RoundConclusion> {
         if self.conclusion.is_some() {
             return None;
+        }
         // Handle the global solution
         let mut my_final_branch_id = BranchId::new_invalid();
         for (connector_id, branch_id) in global_solution.component_branches.iter().copied() {
             if connector_id == ctx.id {
                 // This is our solution branch
                 my_final_branch_id = branch_id;
                 continue;
+            }
             let message = SyncCompMessage {
                 sync_header: self.create_sync_header(ctx),
                 target_component_id: connector_id,
                 content: SyncCompContent::GlobalSolution(global_solution.clone()),
             };
             ctx.submit_message(Message::SyncComp(message)).unwrap(); // unwrap: sending to component instead of through channel
+        }
         debug_assert!(my_final_branch_id.is_valid());
         self.conclusion = Some(RoundConclusion::Success(my_final_branch_id));
         return Some(RoundConclusion::Success(my_final_branch_id));
+    }
     fn handle_global_failure_as_leader(&mut self, ctx: &mut ComponentCtx) -> Option<RoundConclusion> {
         debug_assert!(self.solution_combiner.failure_reported && self.solution_combiner.check_for_global_failure());
         if self.conclusion.is_some() {
             // Already sent out a failure
             return None;
+        }
         // TODO: Performance
         let mut encountered = VecSet::new();
         for presence in &self.solution_combiner.presence {
-            if presence.added_by != ctx.id {
+            if presence.owner_a != ctx.id {
                 // Did not add it ourselves
-                if encountered.push(presence.added_by) {
+                if encountered.push(presence.owner_a) {
                     // Not yet sent a message
                     let message = SyncCompMessage{
                         sync_header: self.create_sync_header(ctx),
-                        target_component_id: presence.added_by,
+                        target_component_id: presence.owner_a,
                         content: SyncCompContent::GlobalFailure,
                     };
                     ctx.submit_message(Message::SyncComp(message)).unwrap(); // unwrap: sending to component instead of through channel
+                }
             } else if let Some(owner_b) = presence.owner_b {
                 if owner_b != ctx.id {
                     if encountered.push(owner_b) {
                         let message = SyncCompMessage{
                             sync_header: self.create_sync_header(ctx),
                             target_component_id: owner_b,
                             content: SyncCompContent::GlobalFailure,
                         };
                         ctx.submit_message(Message::SyncComp(message)).unwrap();
+                    }
+                }
+            }
+        }
         println!("DEBUERINO: Leader entering error state, we need to wait on {:?}", encountered.iter().map(|v| v.0).collect::<Vec<_>>());
         self.conclusion = Some(RoundConclusion::Failure);
         if encountered.is_empty() {
             // We don't have to wait on Acks
             return Some(RoundConclusion::Failure);
         } else {
             self.ack_remaining = encountered.len() as u32;
             return None;
+        }
+    }
     #[inline]
     fn create_sync_header(&self, ctx: &ComponentCtx) -> SyncHeader {
         return SyncHeader{
             sending_component_id: ctx.id,
             highest_component_id: self.highest_connector_id,
             sync_round: self.sync_round,
+        }
+    }
     fn forward_local_data_to_new_leader(&mut self, ctx: &mut ComponentCtx) {
         debug_assert_ne!(self.highest_connector_id, ctx.id);
         if let Some(partial_solution) = self.solution_combiner.drain() {
             let message = SyncCompMessage {
                 sync_header: self.create_sync_header(ctx),
                 target_component_id: self.highest_connector_id,
                 content: SyncCompContent::PartialSolution(partial_solution),
             };
             ctx.submit_message(Message::SyncComp(message)).unwrap(); // unwrap: sending to component instead of through channel
+        }
+    }
+}
 // -----------------------------------------------------------------------------
 // Solution storage and algorithms
 // -----------------------------------------------------------------------------
 // TODO: Remove all debug derives
 #[derive(Debug, Clone)]
 struct MatchedLocalSolution {
     final_branch_id: BranchId,
     channel_mapping: Vec<(ChannelId, BranchMarker)>,
     matches: Vec<ComponentMatches>,
+}
 #[derive(Debug, Clone)]
 struct ComponentMatches {
     target_id: ConnectorId,
     target_index: usize,
     match_indices: Vec<usize>, // of local solution in connector
+}
 #[derive(Debug, Clone)]
 struct ComponentPeer {
     target_id: ConnectorId,
     target_index: usize, // in array of global solution components
     involved_channels: Vec<ChannelId>,
+}
 #[derive(Debug, Clone)]
 struct ComponentLocalSolutions {
     component: ConnectorId,
     peers: Vec<ComponentPeer>,
     solutions: Vec<MatchedLocalSolution>,
     all_peers_present: bool,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct ComponentPresence {
     component_id: ConnectorId,
     channels: Vec<LocalChannelPresence>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct LocalChannelPresence {
     channel_id: ChannelId,
     is_closed: bool,
+}
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum PresenceState {
     OnePresent, // one component reported the channel being open
     BothPresent, // two components reported the channel being open
     Closed, // one component reported the channel being closed
+}
 /// Record to hold channel state during the error-resolving mode of the leader.
 /// This is used to determine when the sync region has grown to its largest
 /// size. The structure is eventually consistent in the sense that a component
 /// might initially presume a channel is open, only to figure out later it is
 /// actually closed.
 #[derive(Debug, Clone)]
 struct ChannelPresence {
     added_by: ConnectorId,
     channel: ChannelId,
     both_sides_present: bool,
     owner_a: ConnectorId,
     owner_b: Option<ConnectorId>,
     id: ChannelId,
     state: PresenceState,
+}
 // TODO: Flatten? Flatten. Flatten everything.
 #[derive(Debug)]
 pub(crate) struct SolutionCombiner {
     local: Vec<ComponentLocalSolutions>, // used for finding solution
     presence: Vec<ChannelPresence>, // used to detect all channels present in case of failure
     failure_reported: bool,
+}
 struct CheckEntry {
     component_index: usize,         // component index in combiner's vector
     solution_index: usize,          // solution entry in the above component entry
     parent_entry_index: usize,      // parent that caused the creation of this checking entry
     match_index_in_parent: usize,   // index in the matches array of the parent
     solution_index_in_parent: usize,// index in the solution array of the match entry in the parent
+}
 enum LeaderConclusion {
     Solution(GlobalSolution),
     Failure,
+}
 impl SolutionCombiner {
     fn new() -> Self {
         return Self{
             local: Vec::new(),
             presence: Vec::new(),
             failure_reported: false,
         };
+    }
     /// Adds a new local solution to the global solution storage. Will check the
     /// new local solutions for matching against already stored local solutions
     /// of peer connectors.
     fn add_solution_and_check_for_global_solution(&mut self, solution: LocalSolution) -> Option<GlobalSolution> {
         let component_id = solution.component;
         let solution = MatchedLocalSolution{
             final_branch_id: solution.final_branch_id,
             channel_mapping: solution.port_mapping,
             matches: Vec::new(),
         };
         // Create an entry for the solution for the particular component
         let component_exists = self.local.iter_mut()
             .enumerate()
             .find(|(_, v)| v.component == component_id);
         let (component_index, solution_index, new_component) = match component_exists {
@@ @@ -994,115 +1071,132 @@ impl SolutionCombiner { @@
         // And now that we have the new solution-to-solution matches, we need to
         // add those in the appropriate storage.
         for new_component_match in new_component_matches {
             let other_component = &mut self.local[new_component_match.target_index];
             for other_solution_index in new_component_match.match_indices.iter().copied() {
                 let other_solution = &mut other_component.solutions[other_solution_index];
                 // Add a completely new entry for the component, or add it to
                 // the existing component entry's matches
                 match other_solution.matches.iter_mut()
                     .find(|v| v.target_id == component_id)
+                {
                     Some(other_match) => {
                         other_match.match_indices.push(solution_index);
                     },
                     None => {
                         other_solution.matches.push(ComponentMatches{
                             target_id: component_id,
                             target_index: component_index,
                             match_indices: vec![solution_index],
                         })
+                    }
+                }
+            }
             let cur_component = &mut self.local[component_index];
             let cur_solution = &mut cur_component.solutions[solution_index];
             match cur_solution.matches.iter_mut()
                 .find(|v| v.target_id == new_component_match.target_id)
+            {
                 Some(other_match) => {
                     // Already have an entry
                     debug_assert_eq!(other_match.target_index, new_component_match.target_index);
                     other_match.match_indices.extend(&new_component_match.match_indices);
                 },
                 None => {
                     // Create a new entry
                     cur_solution.matches.push(new_component_match);
+                }
+            }
+        }
         return self.check_for_global_solution(component_index, solution_index);
+    }
     fn add_presence_and_check_for_global_failure(&mut self, present_component: ConnectorId, present: &[ChannelId]) -> bool {
         'new_channel_loop: for new_channel_id in present {
             for presence in &mut self.presence {
                 if presence.channel == *new_channel_id {
                     if presence.added_by != present_component {
                         presence.both_sides_present = true;
     fn add_presence_and_check_for_global_failure(&mut self, component_id: ConnectorId, channels: &[LocalChannelPresence]) -> bool {
         'new_report_loop: for entry in channels {
             let mut found = false;
             for existing in &mut self.presence {
                 if existing.id == entry.channel_id {
                     // Same entry. We only update if we have the second
                     // component coming in it owns one end of the channel, or if
                     // a component is telling us that the channel is (now)
                     // closed.
                     if entry.is_closed {
                         existing.state = PresenceState::Closed;
                     } else if component_id != existing.owner_a && existing.state != PresenceState::Closed {
                         existing.state = PresenceState::BothPresent;
+                    }
                     continue 'new_channel_loop;
                     if existing.owner_a != component_id {
                         existing.owner_b = Some(component_id);
+                    }
                     found = true;
                     break;
+                }
+            }
-            // Not added yet
+            if !found {
                 self.presence.push(ChannelPresence{
                 added_by: present_component,
                 channel: *new_channel_id,
                 both_sides_present: false,
                     owner_a: component_id,
                     owner_b: None,
                     id: entry.channel_id,
                     state: if entry.is_closed { PresenceState::Closed } else { PresenceState::OnePresent },
                 });
+            }
+        }
         println!("DEBUGGERINO Presence is now:\n{:#?}", self.presence);
         return self.check_for_global_failure();
+    }
     fn mark_failure_and_check_for_global_failure(&mut self) -> bool {
         self.failure_reported = true;
         return self.check_for_global_failure();
+    }
     /// Checks if, starting at the provided local solution, a global solution
     /// can be formed.
     // TODO: At some point, check if divide and conquer is faster?
     fn check_for_global_solution(&self, initial_component_index: usize, initial_solution_index: usize) -> Option<GlobalSolution> {
         // Small trivial test necessary (but not sufficient) for a global
         // solution
         for component in &self.local {
             if !component.all_peers_present {
                 return None;
+            }
+        }
         // Construct initial entry on stack
         let mut stack = Vec::with_capacity(self.local.len());
         stack.push(CheckEntry{
             component_index: initial_component_index,
             solution_index: initial_solution_index,
             parent_entry_index: 0,
             match_index_in_parent: 0,
             solution_index_in_parent: 0,
         });
         'check_last_stack: loop {
             let cur_index = stack.len() - 1;
             let cur_entry = &stack[cur_index];
             // Check if the current component is matching with all other entries
             let mut all_match = true;
             'check_against_existing: for prev_index in 0..cur_index {
                 let prev_entry = &stack[prev_index];
                 let prev_component = &self.local[prev_entry.component_index];
                 let prev_solution = &prev_component.solutions[prev_entry.solution_index];
                 for prev_matching_component in &prev_solution.matches {
                     if prev_matching_component.target_index == cur_entry.component_index {
                         // Previous entry has shared ports with the current
                         // entry, so see if we have a composable pair of
                         // solutions.
                         if !prev_matching_component.match_indices.contains(&cur_entry.solution_index) {
@@ @@ -1204,160 +1298,188 @@ impl SolutionCombiner { @@
         // Just debugging here, TODO: @remove
         let mut total_num_channels = 0;
         for entry in &stack {
             let component = &self.local[entry.component_index];
             total_num_channels += component.solutions[0].channel_mapping.len();
+        }
         total_num_channels /= 2;
         let mut final_mapping = Vec::with_capacity(total_num_channels);
         let mut total_num_checked = 0;
         for entry in &stack {
             let component = &self.local[entry.component_index];
             let solution = &component.solutions[entry.solution_index];
             for (channel_id, branch_id) in solution.channel_mapping.iter().copied() {
                 match final_mapping.iter().find(|(v, _)| *v == channel_id) {
                     Some((_, encountered_branch_id)) => {
                         debug_assert_eq!(*encountered_branch_id, branch_id);
                         total_num_checked += 1;
                     },
                     None => {
                         final_mapping.push((channel_id, branch_id));
+                    }
+                }
+            }
+        }
         debug_assert_eq!(total_num_checked, total_num_channels);
         return Some(GlobalSolution{
             component_branches: final_branches,
             channel_mapping: final_mapping,
         });
+    }
     /// Checks if all preconditions for global sync failure have been met
     fn check_for_global_failure(&self) -> bool {
         if !self.failure_reported {
             return false;
+        }
         // Failure is reported, if all components are present then we may emit
         // the global failure broadcast
         // Check if all are present and we're preparing to fail this round
         let mut all_present = true;
         for presence in &self.presence {
-            if !presence.both_sides_present {
+            if presence.state == PresenceState::OnePresent {
                 all_present = false;
                 break;
+            }
+        }
         return all_present; // && failure_reported, which is checked above
+    }
     /// Turns the entire (partially resolved) global solution into a structure
     /// that can be forwarded to a new parent. The new parent may then merge
     /// already obtained information.
     fn drain(&mut self) -> Option<SolutionCombiner> {
         if self.local.is_empty() && self.presence.is_empty() && !self.failure_reported {
             return None;
+        }
         let result = SolutionCombiner{
             local: self.local.clone(),
             presence: self.presence.clone(),
             failure_reported: self.failure_reported,
         };
         self.local.clear();
         self.presence.clear();
         self.failure_reported = false;
         return Some(result);
+    }
     // TODO: Entire routine is quite wasteful. Combine instead of doing all work
     //  again.
     fn combine(&mut self, combiner: SolutionCombiner) -> Option<LeaderConclusion> {
         self.failure_reported = self.failure_reported || combiner.failure_reported;
         // Handle local solutions
         if self.local.is_empty() {
             // Trivial case
             self.local = combiner.local;
         } else {
             for local in combiner.local {
                 for matched in local.solutions {
                     let local_solution = LocalSolution{
                         component: local.component,
                         final_branch_id: matched.final_branch_id,
                         port_mapping: matched.channel_mapping,
                     };
                     let maybe_solution = self.add_solution_and_check_for_global_solution(local_solution);
                     if let Some(global_solution) = maybe_solution {
                         return Some(LeaderConclusion::Solution(global_solution));
+                    }
+                }
+            }
+        }
         // Handle channel presence
         if self.presence.is_empty() {
             // Trivial case
             self.presence = combiner.presence
         } else {
             for presence in combiner.presence {
                 let global_failure = self.add_presence_and_check_for_global_failure(presence.added_by, &[presence.channel]);
                 if global_failure {
                     return Some(LeaderConclusion::Failure);
                 match self.presence.iter_mut().find(|v| v.id == presence.id) {
                     Some(entry) => {
                         // Combine entries. Take first that has Closed, then
                         // check first that has both, then check if they are
                         // combinable
                         if entry.state == PresenceState::Closed {
                             // Do nothing
                         } else if presence.state == PresenceState::Closed {
                             entry.owner_a = presence.owner_a;
                             entry.owner_b = presence.owner_b;
                             entry.state = PresenceState::Closed;
                         } else if entry.state == PresenceState::BothPresent {
                             // Again: do nothing
                         } else if presence.state == PresenceState::BothPresent {
                             entry.owner_a = presence.owner_a;
                             entry.owner_b = presence.owner_b;
                             entry.state = PresenceState::BothPresent;
                         } else {
                             // Both have one presence, combine into both present
                             debug_assert!(entry.state == PresenceState::OnePresent && presence.state == PresenceState::OnePresent);
                             entry.owner_b = Some(presence.owner_a);
+                        }
                     },
                     None => {
                         self.presence.push(presence);
+                    }
+                }
+            }
             // After adding everything we might have immediately found a solution
             if self.check_for_global_failure() {
                 return Some(LeaderConclusion::Failure);
+            }
+        }
         return None;
+    }
     fn clear(&mut self) {
         self.local.clear();
         self.presence.clear();
         self.failure_reported = false;
+    }
+}
 // -----------------------------------------------------------------------------
 // Generic Helpers
 // -----------------------------------------------------------------------------
 /// Recursively goes through the value group, attempting to find ports.
 /// Duplicates will only be added once.
 pub(crate) fn find_ports_in_value_group(value_group: &ValueGroup, ports: &mut Vec<PortIdLocal>) {
     // Helper to check a value for a port and recurse if needed.
     use crate::protocol::eval::Value;
     fn find_port_in_value(group: &ValueGroup, value: &Value, ports: &mut Vec<PortIdLocal>) {
         match value {
             Value::Input(port_id) | Value::Output(port_id) => {
                 // This is an actual port
                 let cur_port = PortIdLocal::new(port_id.0.u32_suffix);
                 for prev_port in ports.iter() {
                     if *prev_port == cur_port {
                         // Already added
                         return;
+                    }
+                }
                 ports.push(cur_port);
             },
             Value::Array(heap_pos) |
             Value::Message(heap_pos) |
             Value::String(heap_pos) |
             Value::Struct(heap_pos) |
             Value::Union(_, heap_pos) => {
                 // Reference to some dynamic thing which might contain ports,
                 // so recurse
                 let heap_region = &group.regions[*heap_pos as usize];
                 for embedded_value in heap_region {
                     find_port_in_value(group, embedded_value, ports);
+                }

src/runtime2/inbox.rs

➞

Show inline comments

 use std::sync::Mutex;
 use std::collections::VecDeque;
 use crate::protocol::eval::ValueGroup;
 use crate::runtime2::consensus::SolutionCombiner;
+use crate::runtime2::consensus::{ComponentPresence, SolutionCombiner};
 use crate::runtime2::port::ChannelId;
 use super::ConnectorId;
 use super::branch::BranchId;
 use super::consensus::{GlobalSolution, LocalSolution};
 use super::port::PortIdLocal;
 // TODO: Remove Debug derive from all types
 #[derive(Debug, Copy, Clone)]
 pub(crate) struct ChannelAnnotation {
     pub channel_id: ChannelId,
     pub registered_id: Option<BranchMarker>,
     pub expected_firing: Option<bool>,
+}
 /// Marker for a branch in a port mapping. A marker is, like a branch ID, a
 /// unique identifier for a branch, but differs in that a branch only has one
 /// branch ID, but might have multiple associated markers (i.e. one branch
 /// performing a `put` three times will generate three markers.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct BranchMarker{
     marker: u32,
+}
 impl BranchMarker {
     #[inline]
     pub(crate) fn new(marker: u32) -> Self {
         debug_assert!(marker != 0);
         return Self{ marker };
+    }
     #[inline]
     pub(crate) fn new_invalid() -> Self {
         return Self{ marker: 0 }
+    }
+}
 /// The header added by the synchronization algorithm to all.
 #[derive(Debug, Clone)]
 pub(crate) struct SyncHeader {
     pub sending_component_id: ConnectorId,
     pub highest_component_id: ConnectorId,
     pub sync_round: u32,
+}
 /// The header added to data messages
 #[derive(Debug, Clone)]
 pub(crate) struct DataHeader {
     pub expected_mapping: Vec<ChannelAnnotation>,
     pub sending_port: PortIdLocal,
     pub target_port: PortIdLocal,
     pub new_mapping: BranchMarker,
+}
 /// A data message is a message that is intended for the receiver's PDL code,
 /// but will also be handled by the consensus algorithm
 #[derive(Debug, Clone)]
 pub(crate) struct DataMessage {
     pub sync_header: SyncHeader,
     pub data_header: DataHeader,
     pub content: ValueGroup,
+}
 #[derive(Debug)]
 pub(crate) enum SyncCompContent {
     LocalFailure, // notifying leader that component has failed (e.g. timeout, whatever)
     LocalSolution(LocalSolution), // sending a local solution to the leader
     PartialSolution(SolutionCombiner), // when new leader is detected, forward all local results
     GlobalSolution(GlobalSolution), // broadcasting to everyone
     GlobalFailure, // broadcasting to everyone
     AckFailure, // acknowledgement of failure to leader
     Notification, // just a notification (so purpose of message is to send the SyncHeader)
-    Presence(ConnectorId, Vec<ChannelId>), // notifying leader of component presence (needed to ensure failing a round involves all components in a sync round)
+    Presence(ComponentPresence), // notifying leader of component presence (needed to ensure failing a round involves all components in a sync round)
+}
 /// A sync message is a message that is intended only for the consensus
 /// algorithm. The message goes directly to a component.
 #[derive(Debug)]
 pub(crate) struct SyncCompMessage {
     pub sync_header: SyncHeader,
     pub target_component_id: ConnectorId,
     pub content: SyncCompContent,
+}
 #[derive(Debug)]
 pub(crate) enum SyncPortContent {
     SilentPortNotification,
     NotificationWave,
+}
 /// A sync message intended for the consensus algorithm. This message does not
 /// go to a component, but through a channel (and results in potential
 /// rerouting) because we're not sure about the ID of the component that holds
 /// the other end of the channel.
 #[derive(Debug)]
 pub(crate) struct SyncPortMessage {
     pub sync_header: SyncHeader,
     pub source_port: PortIdLocal,
     pub target_port: PortIdLocal,
     pub content: SyncPortContent,
+}
 #[derive(Debug)]
 pub(crate) enum SyncControlContent {
     ChannelIsClosed(PortIdLocal), // contains port that is owned by the recipient of the message
+}
 /// A sync control message: originating from the scheduler, but intended for the
 /// current sync round of the recipient. Every kind of consensus algorithm must
 /// be able to handle such a message.
 #[derive(Debug)]
 pub(crate) struct SyncControlMessage {
     // For now these control messages are only aimed at components. Might change
     // in the future. But for now we respond to messages from components that
     // have, because of that message, published their ID.
     pub in_response_to_sync_round: u32,
     pub target_component_id: ConnectorId,
     pub content: SyncControlContent,
+}
 /// A control message is a message intended for the scheduler that is executing

src/runtime2/tests/mod.rs

➞

Show inline comments

 mod network_shapes;
 mod api_component;
 mod speculation;
 mod data_transmission;
 mod sync_failure;
 use super::*;
 use crate::{PortId, ProtocolDescription};
 use crate::common::Id;
 use crate::protocol::eval::*;
 use crate::runtime2::native::{ApplicationSyncAction};
 // Generic testing constants, use when appropriate to simplify stress-testing
 // pub(crate) const NUM_THREADS: u32 = 3;     // number of threads in runtime
 // pub(crate) const NUM_INSTANCES: u32 = 7;   // number of test instances constructed
 // pub(crate) const NUM_LOOPS: u32 = 8;       // number of loops within a single test (not used by all tests)
-pub(crate) const NUM_THREADS: u32 = 2;
+pub(crate) const NUM_THREADS: u32 = 4;
 pub(crate) const NUM_INSTANCES: u32 = 1;
 pub(crate) const NUM_LOOPS: u32 = 1;
 fn create_runtime(pdl: &str) -> Runtime {
     let protocol = ProtocolDescription::parse(pdl.as_bytes()).expect("parse pdl");
     let runtime = Runtime::new(NUM_THREADS, protocol);
     return runtime;
+}
 fn run_test_in_runtime<F: Fn(&mut ApplicationInterface)>(pdl: &str, constructor: F) {
     let protocol = ProtocolDescription::parse(pdl.as_bytes())
         .expect("parse PDL");
     let runtime = Runtime::new(NUM_THREADS, protocol);
     let mut api = runtime.create_interface();
     for _ in 0..NUM_INSTANCES {
         constructor(&mut api);
+    }
+}
 pub(crate) struct TestTimer {
     name: &'static str,
     started: std::time::Instant
+}
 impl TestTimer {
     pub(crate) fn new(name: &'static str) -> Self {
         Self{ name, started: std::time::Instant::now() }
+    }
+}
 impl Drop for TestTimer {
     fn drop(&mut self) {
         let delta = std::time::Instant::now() - self.started;
         let nanos = (delta.as_secs_f64() * 1_000_000.0) as u64;
         let millis = nanos / 1000;
         let nanos = nanos % 1000;
         println!("[{}] Took {:>4}.{:03} ms", self.name, millis, nanos);
+    }
+}

src/runtime2/tests/sync_failure.rs

➞

Show inline comments

@@ @@ -20,56 +20,56 @@ fn test_local_sync_failure() { @@
         u32[] only_allows_index_0 = { 1 };
         auto never_gonna_get = only_allows_index_0[1];
         while (true) sync {}
+    }
     ";
     // let thing = TestTimer::new("local_sync_failure");
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "immediate_failure_outside_sync", ValueGroup::new_stack(Vec::new()))
             .expect("create component");
         api.create_connector("", "immediate_failure_inside_sync", ValueGroup::new_stack(Vec::new()))
             .expect("create component");
     })
+}
 #[test]
 fn test_shared_sync_failure() {
     // Same as above. One of the components should fail, the other should follow
     // suit because it cannot complete a sync round. We intentionally have an
     // infinite loop in the while condition because we need at least two loops
     // for the last error to get picked up.
     const CODE: &'static str = "
     enum Location { BeforeSync, AfterPut, AfterGet, AfterSync, Never }
     primitive failing_at_location(in<bool> input, out<bool> output, Location loc) {
         u32[] failure_array = {};
         while (true) {
             if (loc == Location::BeforeSync) failure_array[0];
             sync {
                 put(output, true);
                 if (loc == Location::AfterPut) failure_array[0];
                 auto received = get(input);
                 assert(received);
                 if (loc == Location::AfterGet) failure_array[0];
+            }
             if (loc == Location::AfterSync) failure_array[0];
+        }
+    }
     composite constructor(Location loc) {
         channel output_a -> input_a;
         channel output_b -> input_b;
         new failing_at_location(input_a, output_b, Location::Never);
         new failing_at_location(input_b, output_a, loc);
+    }
     ";
     run_test_in_runtime(CODE, |api| {
-        for variant in 3..4 { // all `Location` enum variants, except `Never`.
+        for variant in 0..4 { // all `Location` enum variants, except `Never`.
             // Create the channels
             api.create_connector("", "constructor", ValueGroup::new_stack(vec![
                 Value::Enum(variant)
             ])).expect("create connector");
+        }
     })
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)