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

Changeset - 5415acc02756

Parent rev.

Child rev.

[Not reviewed]

0 7 0

mh - 3 years ago 2022-01-28 18:40:04
contact@maxhenger.nl

WIP: Refactored port/peer management, pending more bugfixes to component shutdown

7 files changed with 166 insertions and 114 deletions:

src/runtime2/component/component_context.rs

src/runtime2/component/component_pdl.rs

src/runtime2/component/consensus.rs

src/runtime2/component/control_layer.rs

src/runtime2/runtime.rs

src/runtime2/scheduler.rs

src/runtime2/store/component.rs

0 comments (0 inline, 0 general)

src/runtime2/component/component_context.rs

➞

Show inline comments

@@ @@ -86,28 +86,29 @@ impl CompCtx { @@
     pub(crate) fn remove_port(&mut self, port_handle: LocalPortHandle) -> Port {
         let port_index = self.must_get_port_index(port_handle);
         let port = self.ports.remove(port_index);
         debug_assert!(!port.associated_with_peer);
         return port;
     }
     /// Adds a new peer. This must be called for every port, no matter the
     /// component the channel is connected to. If a `CompHandle` is supplied,
     /// then it will be used to add the peer. Otherwise it will be retrieved
     /// from the runtime using its ID.
     pub(crate) fn add_peer(&mut self, port_handle: LocalPortHandle, sched_ctx: &SchedulerCtx, peer_comp_id: CompId, handle: Option<&CompHandle>) {
         let self_id = self.id;
         let port = self.get_port_mut(port_handle);
         debug_assert_eq!(port.peer_comp_id, peer_comp_id);
         debug_assert!(!port.associated_with_peer);
-        if !self.requires_peer_reference(port) {
+        if !Self::requires_peer_reference(port, self_id) {
             return;
         }
         dbg_code!(port.associated_with_peer = true);
         match self.get_peer_index_by_id(peer_comp_id) {
             Some(peer_index) => {
                 let peer = &mut self.peers[peer_index];
                 peer.num_associated_ports += 1;
             },
             None => {
                 let handle = match handle {
                     Some(handle) => handle.clone(),
@@ @@ -115,35 +116,37 @@ impl CompCtx { @@
                 };
                 self.peers.push(Peer{
                     id: peer_comp_id,
                     num_associated_ports: 1,
                     handle,
                 });
             }
         }
     }
     /// Removes a peer associated with a port.
     pub(crate) fn remove_peer(&mut self, sched_ctx: &SchedulerCtx, port_handle: LocalPortHandle, peer_id: CompId) {
         let self_id = self.id;
         let port = self.get_port_mut(port_handle);
         debug_assert_eq!(port.peer_comp_id, peer_id);
-        if !self.requires_peer_reference(port) {
+        if !Self::requires_peer_reference(port, self_id) {
             return;
         }
         debug_assert!(port.associated_with_peer);
         dbg_code!(port.associated_with_peer = false);
         let peer_index = self.get_peer_index_by_id(peer_id).unwrap();
         let peer = &mut self.peers[peer_index];
         peer.num_associated_ports -= 1;
         println!(" ****** DEBUG: Removed peer {:?} from {:?}, now at {}", peer.id, self_id, peer.num_associated_ports);
         if peer.num_associated_ports == 0 {
             let mut peer = self.peers.remove(peer_index);
             if let Some(key) = peer.handle.decrement_users() {
                 debug_assert_ne!(key.downgrade(), self.id); // should be upheld by the code that shuts down a component
                 sched_ctx.runtime.destroy_component(key);
             }
         }
     }
     pub(crate) fn set_port_state(&mut self, port_handle: LocalPortHandle, new_state: PortState) {
         let port_info = self.get_port_mut(port_handle);
         debug_assert_ne!(port_info.state, PortState::Closed); // because then we do not expect to change the state
@@ @@ -164,56 +167,65 @@ impl CompCtx { @@
     }
     pub(crate) fn get_port(&self, port_handle: LocalPortHandle) -> &Port {
         let index = self.must_get_port_index(port_handle);
         return &self.ports[index];
     }
     pub(crate) fn get_port_mut(&mut self, port_handle: LocalPortHandle) -> &mut Port {
         let index = self.must_get_port_index(port_handle);
         return &mut self.ports[index];
     }
     pub(crate) fn get_port_by_index_mut(&mut self, index: usize) -> &mut Port {
         return &mut self.ports[index];
+    }
     pub(crate) fn get_peer(&self, peer_handle: LocalPeerHandle) -> &Peer {
         let index = self.must_get_peer_index(peer_handle);
         return &self.peers[index];
     }
     pub(crate) fn get_peer_mut(&mut self, peer_handle: LocalPeerHandle) -> &mut Peer {
         let index = self.must_get_peer_index(peer_handle);
         return &mut self.peers[index];
     }
     #[inline]
     pub(crate) fn iter_ports(&self) -> impl Iterator<Item=&Port> {
         return self.ports.iter();
     }
     #[inline]
     pub(crate) fn iter_ports_mut(&mut self) -> impl Iterator<Item=&mut Port> {
         return self.ports.iter_mut();
+    }
     #[inline]
     pub(crate) fn iter_peers(&self) -> impl Iterator<Item=&Peer> {
         return self.peers.iter();
     }
     #[inline]
     pub(crate) fn num_ports(&self) -> usize {
         return self.ports.len();
     }
     // -------------------------------------------------------------------------
     // Local utilities
     // -------------------------------------------------------------------------
     #[inline]
     fn requires_peer_reference(&self, port: &Port) -> bool {
         return port.state == PortState::Closed;
     fn requires_peer_reference(port: &Port, self_id: CompId) -> bool {
         return port.state != PortState::Closed && port.peer_comp_id != self_id;
     }
     fn must_get_port_index(&self, handle: LocalPortHandle) -> usize {
         for (index, port) in self.ports.iter().enumerate() {
             if port.self_id == handle.0 {
                 return index;
             }
         }
         unreachable!()
     }

src/runtime2/component/component_pdl.rs

➞

Show inline comments

 use crate::protocol::*;
 use crate::protocol::ast::DefinitionId;
 use crate::protocol::eval::{
     PortId as EvalPortId, Prompt,
     ValueGroup, Value,
     EvalContinuation, EvalResult, EvalError
 };
 use crate::runtime2::runtime::*;
 use crate::runtime2::scheduler::SchedulerCtx;
 use crate::runtime2::communication::*;
 use super::*;
 use super::component_context::*;
 use super::control_layer::*;
 use super::consensus::Consensus;
 pub enum CompScheduling {
     Immediate,
     Requeue,
     Sleep,
     Exit,
+}
 pub enum ExecStmt {
@@ @@ -77,41 +75,30 @@ impl RunContext for ExecCtx { @@
         match self.stmt.take() {
             ExecStmt::None => return None,
             ExecStmt::CreatedChannel(ports) => return Some(ports),
             _ => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) enum Mode {
     NonSync, // not in sync mode
     Sync, // in sync mode, can interact with other components
     SyncFail, // something went wrong during sync mode (deadlocked, error, whatever)
     SyncEnd, // awaiting a solution, i.e. encountered the end of the sync block
     BlockedGet,
     BlockedPut,
     StartExit, // temp state
     Exit,
+}
 impl Mode {
     fn can_run(&self) -> bool {
         match self {
             Mode::NonSync | Mode::Sync =>
                 return true,
             Mode::SyncFail | Mode::SyncEnd | Mode::BlockedGet | Mode::BlockedPut | Mode::StartExit | Mode::Exit =>
                 return false,
+        }
+    }
     StartExit, // temporary state: if encountered then we start the shutdown process
     BusyExit, // temporary state: waiting for Acks for all the closed ports
     Exit, // exiting: shutdown process started, now waiting until the reference count drops to 0
+}
 pub(crate) struct CompPDL {
     pub mode: Mode,
     pub mode_port: PortId, // when blocked on a port
     pub mode_value: ValueGroup, // when blocked on a put
     pub prompt: Prompt,
     pub control: ControlLayer,
     pub consensus: Consensus,
     pub sync_counter: u32,
     pub exec_ctx: ExecCtx,
     // TODO: Temporary field, simulates future plans of having one storage place
@@ @@ -167,90 +154,105 @@ impl CompPDL { @@
                 self.handle_incoming_sync_message(sched_ctx, comp_ctx, message);
+            }
+        }
+    }
     // -------------------------------------------------------------------------
     // Running component and handling changes in global component state
     // -------------------------------------------------------------------------
     pub(crate) fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError> {
         use EvalContinuation as EC;
         if self.mode == Mode::StartExit {
         sched_ctx.log(&format!("Running component (mode: {:?})", self.mode));
         // Depending on the mode don't do anything at all, take some special
         // actions, or fall through and run the PDL code.
         match self.mode {
             Mode::NonSync | Mode::Sync => {},
             Mode::SyncEnd | Mode::BlockedGet | Mode::BlockedPut => {
                 return Ok(CompScheduling::Sleep);
+            }
             Mode::StartExit => {
                 self.handle_component_exit(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             Mode::BusyExit => {
                 if self.control.has_acks_remaining() {
                     return Ok(CompScheduling::Sleep);
                 } else {
                     self.mode = Mode::Exit;
                     return Ok(CompScheduling::Exit);
+                }
         let can_run = self.mode.can_run();
         sched_ctx.log(&format!("Running component (mode: {:?}, can run: {})", self.mode, can_run));
         if !can_run {
             return Ok(CompScheduling::Sleep);
             },
             Mode::Exit => {
                 return Ok(CompScheduling::Exit);
+            }
+        }
         let run_result = self.execute_prompt(&sched_ctx)?;
         match run_result {
             EC::Stepping => unreachable!(), // execute_prompt runs until this is no longer returned
             EC::BranchInconsistent | EC::NewFork | EC::BlockFires(_) => todo!("remove these"),
             // Results that can be returned in sync mode
             EC::SyncBlockEnd => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 let scheduling = self.handle_sync_end(sched_ctx, comp_ctx);
                 return Ok(scheduling.unwrap_or(CompScheduling::Immediate));
                 self.handle_sync_end(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             EC::BlockGet(port_id) => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 debug_assert!(self.exec_ctx.stmt.is_none());
                 let port_id = port_id_from_eval(port_id);
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_index = comp_ctx.get_port_index(port_handle);
                 if let Some(message) = &self.inbox_main[port_index] {
                     // Check if we can actually receive the message
                     if self.consensus.try_receive_data_message(sched_ctx, comp_ctx, message) {
                         // Message was received. Make sure any blocked peers and
                         // pending messages are handled.
                         let message = self.inbox_main[port_index].take().unwrap();
                         self.handle_received_data_message(sched_ctx, comp_ctx, port_handle);
                         self.exec_ctx.stmt = ExecStmt::PerformedGet(message.content);
                         return Ok(CompScheduling::Immediate);
                     } else {
-                        self.mode = Mode::SyncFail;
+                        todo!("handle sync failure due to message deadlock");
                         return Ok(CompScheduling::Sleep);
+                    }
                 } else {
                     // We need to wait
                     self.mode = Mode::BlockedGet;
                     self.mode_port = port_id;
                     return Ok(CompScheduling::Sleep);
+                }
             },
             EC::Put(port_id, value) => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 let port_id = port_id_from_eval(port_id);
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_info = comp_ctx.get_port(port_handle);
                 if port_info.state == PortState::Blocked {
                     todo!("handle blocked port");
+                }
                 self.send_data_message_and_wake_up(sched_ctx, comp_ctx, port_handle, value);
                 self.exec_ctx.stmt = ExecStmt::PerformedPut;
                 return Ok(CompScheduling::Immediate);
             },
             // Results that can be returned outside of sync mode
             EC::ComponentTerminated => {
                 self.handle_component_exit(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Exit);
                 self.mode = Mode::StartExit; // next call we'll take care of the exit
                 return Ok(CompScheduling::Immediate);
             },
             EC::SyncBlockStart => {
                 debug_assert_eq!(self.mode, Mode::NonSync);
                 self.handle_sync_start(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             EC::NewComponent(definition_id, monomorph_idx, arguments) => {
                 debug_assert_eq!(self.mode, Mode::NonSync);
                 self.create_component_and_transfer_ports(
                     sched_ctx, comp_ctx,
                     definition_id, monomorph_idx, arguments
                 );
@@ @@ -281,63 +283,83 @@ impl CompPDL { @@
+        }
         return Ok(step_result)
+    }
     fn handle_sync_start(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component starting sync mode");
         self.consensus.notify_sync_start(comp_ctx);
         debug_assert_eq!(self.mode, Mode::NonSync);
         self.mode = Mode::Sync;
+    }
     fn handle_sync_end(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) -> Option<CompScheduling> {
     /// Handles end of sync. The conclusion to the sync round might arise
     /// immediately (and be handled immediately), or might come later through
     /// messaging. In any case the component should be scheduled again
     /// immediately
     fn handle_sync_end(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component ending sync mode (now waiting for solution)");
         let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);
         self.mode = Mode::SyncEnd;
         self.handle_sync_decision(sched_ctx, comp_ctx, decision)
+        self.handle_sync_decision(sched_ctx, comp_ctx, decision);
+    }
     fn handle_sync_decision(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, decision: SyncRoundDecision) -> Option<CompScheduling> {
     /// Handles decision from the consensus round. This will cause a change in
     /// the internal `Mode`, such that the next call to `run` can take the
     /// appropriate next steps.
     fn handle_sync_decision(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, decision: SyncRoundDecision) {
         debug_assert_eq!(self.mode, Mode::SyncEnd);
         sched_ctx.log(&format!("Handling sync decision: {:?}", decision));
         let is_success = match decision {
             SyncRoundDecision::None => {
                 // No decision yet
-                return None;
                 return;
             },
             SyncRoundDecision::Solution => true,
             SyncRoundDecision::Failure => false,
         };
         // If here then we've reached a decision
         self.mode = Mode::NonSync;
         if is_success {
             self.mode = Mode::NonSync;
             self.consensus.notify_sync_decision(decision);
             return None;
         } else {
             todo!("handle this better, show some kind of error");
             self.handle_component_exit(sched_ctx, comp_ctx);
             self.mode = Mode::Exit;
             return Some(CompScheduling::Exit);
             self.mode = Mode::StartExit;
+        }
+    }
     fn handle_component_exit(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component exiting");
         debug_assert_eq!(self.mode, Mode::NonSync); // not a perfect assert, but just to remind myself: cannot exit while in sync
         debug_assert_eq!(self.mode, Mode::StartExit);
         self.mode = Mode::BusyExit;
         // Doing this by index, then retrieving the handle is a bit rediculous,
         // but Rust is being Rust with its borrowing rules.
         for port_index in 0..comp_ctx.num_ports() {
             let port = comp_ctx.get_port_by_index_mut(port_index);
             if port.state == PortState::Closed {
                 // Already closed, or in the process of being closed
                 continue;
+            }
         // Note: for now we have that the scheduler handles exiting. I don't
         // know if that is a good idea, we'll see
         self.mode = Mode::Exit;
             // Mark as closed
             let port_id = port.self_id;
             port.state = PortState::Closed;
             // Notify peer of closing
             let port_handle = comp_ctx.get_port_handle(port_id);
             let (peer, message) = self.control.initiate_port_closing(port_handle, comp_ctx);
             let peer_info = comp_ctx.get_peer(peer);
             peer_info.handle.send_message(sched_ctx, Message::Control(message), true);
+        }
+    }
     // -------------------------------------------------------------------------
     // Handling messages
     // -------------------------------------------------------------------------
     fn send_data_message_and_wake_up(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, source_port_handle: LocalPortHandle, value: ValueGroup) {
         let port_info = comp_ctx.get_port(source_port_handle);
         let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         let annotated_message = self.consensus.annotate_data_message(comp_ctx, port_info, value);
         peer_info.handle.send_message(sched_ctx, Message::Data(annotated_message), true);
@@ @@ -424,73 +446,74 @@ impl CompPDL { @@
                 id: causer_id,
                 sender_comp_id: comp_ctx.id,
                 target_port_id: None,
                 content: ControlMessageContent::Ack,
             }), true);
+        }
         // Handle the content of the control message, and optionally Ack it
         match message.content {
             ControlMessageContent::Ack => {
                 let mut to_ack = message.id;
                 loop {
                     let action = self.control.handle_ack(to_ack, sched_ctx, comp_ctx);
+                    let (action, new_to_ack) = self.control.handle_ack(to_ack, sched_ctx, comp_ctx);
                     match action {
-                        AckAction::SendMessageAndAck(target_comp, message, new_to_ack) => {
+                        AckAction::SendMessage(target_comp, message) => {
                             // FIX @NoDirectHandle
                             let mut handle = sched_ctx.runtime.get_component_public(target_comp);
                             handle.send_message(sched_ctx, Message::Control(message), true);
                             let _should_remove = handle.decrement_users();
                             debug_assert!(_should_remove.is_none());
                             to_ack = new_to_ack;
                         },
                         AckAction::ScheduleComponent(to_schedule) => {
                             // FIX @NoDirectHandle
                             let mut handle = sched_ctx.runtime.get_component_public(to_schedule);
                             // Note that the component is intentionally not
                             // sleeping, so we just wake it up
                             debug_assert!(!handle.sleeping.load(std::sync::atomic::Ordering::Acquire));
                             let key = unsafe{ to_schedule.upgrade() };
                             sched_ctx.runtime.enqueue_work(key);
                             let _should_remove = handle.decrement_users();
                             debug_assert!(_should_remove.is_none());
                             break;
                         },
                         AckAction::None => {
                             break;
                         AckAction::None => {}
+                    }
                     match new_to_ack {
                         Some(new_to_ack) => to_ack = new_to_ack,
                         None => break,
+                    }
+                }
             },
             ControlMessageContent::BlockPort(port_id) => {
                 // On of our messages was accepted, but the port should be
                 // blocked.
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_info = comp_ctx.get_port(port_handle);
                 debug_assert_eq!(port_info.kind, PortKind::Putter);
                 if port_info.state != PortState::Closed {
                     comp_ctx.set_port_state(port_handle, PortState::Blocked);
+                }
             },
             ControlMessageContent::ClosePort(port_id) => {
                 // Request to close the port. We immediately comply and remove
                 // the component handle as well
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let peer_comp_id = comp_ctx.get_port(port_handle).peer_comp_id;
                 let peer_handle = comp_ctx.get_peer_handle(peer_comp_id);
                 comp_ctx.set_port_state(port_handle, PortState::Closed);
                 send_control_ack_message(sched_ctx, comp_ctx, message.id, peer_handle);
                 comp_ctx.remove_peer(sched_ctx, port_handle, peer_comp_id);
                 comp_ctx.set_port_state(port_handle, PortState::Closed);
             },
             ControlMessageContent::UnblockPort(port_id) => {
                 // We were previously blocked (or already closed)
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_info = comp_ctx.get_port(port_handle);
                 debug_assert_eq!(port_info.kind, PortKind::Putter);
                 debug_assert!(port_info.state == PortState::Blocked || port_info.state == PortState::Closed);
                 if port_info.state == PortState::Blocked {
                     self.handle_unblock_port_instruction(sched_ctx, comp_ctx, port_handle);
+                }
             },
             ControlMessageContent::PortPeerChangedBlock(port_id) => {
@@ @@ -627,24 +650,25 @@ impl CompPDL { @@
                     .position(|v| v.creator_id == creator_port_info.peer_port_id);
                 match created_peer_port_index {
                     Some(created_peer_port_index) => {
                         // Peer port moved to the new component as well. So
                         // adjust IDs appropriately.
                         let peer_pair = &port_id_pairs[created_peer_port_index];
                         created_port_info.peer_port_id = peer_pair.created_id;
                         created_port_info.peer_comp_id = reservation.id();
                         todo!("either add 'self peer', or remove that idea from Ctx altogether")
                     },
                     None => {
                         // Peer port remains with creator component.
                         println!("DEBUG: Setting peer for port {:?} of component {:?} to {:?}", created_port_info.self_id, reservation.id(), creator_ctx.id);
                         created_port_info.peer_comp_id = creator_ctx.id;
                         created_ctx.add_peer(pair.created_handle, sched_ctx, creator_ctx.id, None);
+                    }
+                }
             } else {
                 // Peer is a different component
                 let peer_handle = creator_ctx.get_peer_handle(created_port_info.peer_comp_id);
                 let peer_info = creator_ctx.get_peer(peer_handle);
                 created_ctx.add_peer(pair.created_handle, sched_ctx, peer_info.id, Some(&peer_info.handle));
                 created_component_has_remote_peers = true;
+            }
+        }
@@ @@ -661,25 +685,26 @@ impl CompPDL { @@
         let (created_key, component) = sched_ctx.runtime.finish_create_pdl_component(
             reservation, component, created_ctx, false,
         );
         let created_ctx = &component.ctx;
         // Now modify the creator's ports: remove every transferred port and
         // potentially remove the peer component. Here is also where we will
         // transfer messages in the main inbox.
         for pair in port_id_pairs.iter() {
             // Remove peer if appropriate
             let creator_port_info = creator_ctx.get_port(pair.creator_handle);
             let creator_port_index = creator_ctx.get_port_index(pair.creator_handle);
             creator_ctx.remove_peer(sched_ctx, pair.creator_handle, creator_port_info.peer_comp_id);
             let creator_peer_comp_id = creator_port_info.peer_comp_id;
             creator_ctx.remove_peer(sched_ctx, pair.creator_handle, creator_peer_comp_id);
             creator_ctx.remove_port(pair.creator_handle);
             // Transfer any messages
             let created_port_index = created_ctx.get_port_index(pair.created_handle);
             let created_port_info = created_ctx.get_port(pair.created_handle);
             debug_assert!(component.code.inbox_main[created_port_index].is_none());
             if let Some(mut message) = self.inbox_main.remove(creator_port_index) {
                 message.data_header.target_port = pair.created_id;
                 component.code.inbox_main[created_port_index] = Some(message);
+            }
             let mut message_index = 0;
@@ @@ -691,25 +716,25 @@ impl CompPDL { @@
                     message.data_header.target_port = pair.created_id;
                     component.code.inbox_backup.push(message);
                 } else {
                     message_index += 1;
+                }
+            }
             // Handle potential channel between creator and created component
             if created_port_info.peer_comp_id == creator_ctx.id {
                 let peer_port_handle = creator_ctx.get_port_handle(created_port_info.peer_port_id);
                 let peer_port_info = creator_ctx.get_port_mut(peer_port_handle);
                 peer_port_info.peer_comp_id = created_ctx.id;
-                creator_ctx.add_peer(pair.created_handle, sched_ctx, created_ctx.id, None);
+                creator_ctx.add_peer(peer_port_handle, sched_ctx, created_ctx.id, None);
+            }
+        }
         // By now all ports have been transferred. We'll now do any of the setup
         // for rerouting/messaging
         if created_component_has_remote_peers {
             let schedule_entry_id = self.control.add_schedule_entry(created_ctx.id);
             for pair in port_id_pairs.iter() {
                 let port_info = created_ctx.get_port(pair.created_handle);
                 if port_info.peer_comp_id != creator_ctx.id && port_info.peer_comp_id != created_ctx.id {
                     let message = self.control.add_reroute_entry(
                         creator_ctx.id, port_info.peer_port_id, port_info.peer_comp_id,

src/runtime2/component/consensus.rs

➞

Show inline comments

 use crate::protocol::eval::ValueGroup;
 use crate::runtime2::scheduler::*;
 use crate::runtime2::runtime::*;
 use crate::runtime2::communication::*;
 use super::component_pdl::*;
 use super::component_context::*;
 pub struct PortAnnotation {
     self_comp_id: CompId,
     self_port_id: PortId,
     peer_comp_id: CompId, // only valid for getter ports
     peer_port_id: PortId, // only valid for getter ports
     mapping: Option<u32>,
+}
 impl PortAnnotation {
     fn new(comp_id: CompId, port_id: PortId) -> Self {
@@ @@ -547,35 +546,34 @@ impl Consensus { @@
                 peers.push(getter.peer_comp_id);
+            }
+        }
         for peer in peers {
             let mut handle = sched_ctx.runtime.get_component_public(peer);
             let message = Message::Sync(SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: if is_success { SyncMessageContent::GlobalSolution } else { SyncMessageContent::GlobalFailure },
             });
             handle.send_message(sched_ctx, message, true);
             let _should_remove = handle.decrement_users();
-            debug_assert!(!_should_remove);
+            debug_assert!(_should_remove.is_none());
+        }
+    }
     fn send_to_leader(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, message: Message) {
         debug_assert_ne!(self.highest_id, comp_ctx.id); // we're not the leader
         let mut leader_info = sched_ctx.runtime.get_component_public(self.highest_id);
         leader_info.send_message(sched_ctx, message, true);
         let should_remove = leader_info.decrement_users();
         if should_remove {
             let key = unsafe{ self.highest_id.upgrade() };
         if let Some(key) = should_remove {
             sched_ctx.runtime.destroy_component(key);
+        }
+    }
     // -------------------------------------------------------------------------
     // Creating message headers
     // -------------------------------------------------------------------------
     fn create_data_header_and_update_mapping(&mut self, port_info: &Port) -> MessageDataHeader {
         let mut expected_mapping = Vec::with_capacity(self.ports.len());
         let mut port_index = usize::MAX;
         for (index, port) in self.ports.iter().enumerate() {

src/runtime2/component/control_layer.rs

➞

Show inline comments

@@ @@ -28,27 +28,32 @@ enum ControlContent { @@
     ClosedPort(PortId),
+}
 struct ContentPeerChange {
     source_port: PortId,
     source_comp: CompId,
     old_target_port: PortId,
     new_target_port: PortId,
     new_target_comp: CompId,
     schedule_entry_id: ControlId,
+}
 struct ControlClosedPort {
     closed_port: PortId,
     exit_entry_id: Option<ControlId>,
+}
 pub(crate) enum AckAction {
     None,
-    SendMessageAndAck(CompId, ControlMessage, ControlId),
+    SendMessage(CompId, ControlMessage),
     ScheduleComponent(CompId),
+}
 /// Handling/sending control messages.
 pub(crate) struct ControlLayer {
     id_counter: ControlId,
     entries: Vec<ControlEntry>,
+}
 impl ControlLayer {
     pub(crate) fn should_reroute(&self, message: &mut Message) -> Option<CompId> {
         // Safety note: rerouting should occur during the time when we're
@@ @@ -64,74 +69,86 @@ impl ControlLayer { @@
         for entry in &self.entries {
             if let ControlContent::PeerChange(entry) = &entry.content {
                 if entry.old_target_port == target_port {
                     message.modify_target_port(entry.new_target_port);
                     return Some(entry.new_target_comp);
+                }
+            }
+        }
         return None;
+    }
     pub(crate) fn handle_ack(&mut self, entry_id: ControlId, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) -> AckAction {
     /// Handles an acknowledgement. The returned action must be performed by the
     /// caller. The optionally returned `ControlId` must be used and passed to
     /// `handle_ack` again.
     pub(crate) fn handle_ack(&mut self, entry_id: ControlId, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) -> (AckAction, Option<ControlId>) {
         let entry_index = self.get_entry_index_by_id(entry_id).unwrap();
         let entry = &mut self.entries[entry_index];
         debug_assert!(entry.ack_countdown > 0);
         entry.ack_countdown -= 1;
         if entry.ack_countdown != 0 {
             return AckAction::None;
+            return (AckAction::None, None);
+        }
         let entry = self.entries.remove(entry_index);
         // All `Ack`s received, take action based on the kind of entry
-        match &entry.content {
         match entry.content {
             ControlContent::PeerChange(content) => {
                 // If change of peer is ack'd. Then we are certain we have
                 // rerouted all of the messages, and the sender's port can now
                 // be unblocked again.
                 let target_comp_id = content.source_comp;
                 let message_to_send = ControlMessage{
                     id: ControlId::new_invalid(),
                     sender_comp_id: comp_ctx.id,
                     target_port_id: Some(content.source_port),
                     content: ControlMessageContent::PortPeerChangedUnblock(
                         content.new_target_port,
                         content.new_target_comp
+                    )
                 };
                 let to_ack = content.schedule_entry_id;
                 self.entries.remove(entry_index);
                 return AckAction::SendMessageAndAck(target_comp_id, message_to_send, to_ack);
                 return (
                     AckAction::SendMessage(target_comp_id, message_to_send),
                     Some(to_ack)
                 );
             },
             ControlContent::ScheduleComponent(to_schedule) => {
                 // If all change-of-peers are `Ack`d, then we're ready to
                 // schedule the component!
-                return AckAction::ScheduleComponent(*to_schedule);
+                return (AckAction::ScheduleComponent(to_schedule), None);
             },
             ControlContent::BlockedPort(_) => unreachable!(),
-            ControlContent::ClosedPort(port_id) => {
+            ControlContent::ClosedPort(closed_port) => {
                 // If a closed port is Ack'd, then we remove the reference to
                 // that component.
-                let port_handle = comp_ctx.get_port_handle(*port_id);
+                let port_handle = comp_ctx.get_port_handle(closed_port);
                 let port_info = comp_ctx.get_port(port_handle);
                 let port_peer_comp_id = port_info.peer_comp_id;
                 debug_assert_eq!(port_info.state, PortState::Closed);
-                comp_ctx.remove_peer(sched_ctx, port_handle, port_info.peer_comp_id);
+                comp_ctx.remove_peer(sched_ctx, port_handle, port_peer_comp_id);
                 return AckAction::None;
+                return (AckAction::None, None);
+            }
+        }
+    }
     pub(crate) fn has_acks_remaining(&self) -> bool {
         return !self.entries.is_empty();
+    }
     // -------------------------------------------------------------------------
     // Port transfer (due to component creation)
     // -------------------------------------------------------------------------
     /// Adds an entry that, when completely ack'd, will schedule a component.
     pub(crate) fn add_schedule_entry(&mut self, to_schedule_id: CompId) -> ControlId {
         let entry_id = self.take_id();
         self.entries.push(ControlEntry{
             id: entry_id,
             ack_countdown: 0, // incremented by calls to `add_reroute_entry`
             content: ControlContent::ScheduleComponent(to_schedule_id),
         });
@@ @@ -160,73 +177,66 @@ impl ControlLayer { @@
             ack_countdown: 1,
             content: ControlContent::PeerChange(ContentPeerChange{
                 source_port: source_port_id,
                 source_comp: source_comp_id,
                 old_target_port: old_target_port_id,
                 new_target_port: new_target_port_id,
                 new_target_comp: new_comp_id,
                 schedule_entry_id,
             }),
         });
         // increment counter on schedule entry
         for entry in &mut self.entries {
             if entry.id == schedule_entry_id {
                 entry.ack_countdown += 1;
                 break;
+            }
+        }
         let entry_index = self.get_entry_index_by_id(schedule_entry_id).unwrap();
         self.entries[entry_index].ack_countdown += 1;
         return Message::Control(ControlMessage{
             id: entry_id,
             sender_comp_id: creator_comp_id,
             target_port_id: Some(source_port_id),
             content: ControlMessageContent::PortPeerChangedBlock(source_port_id)
         })
+    }
     // -------------------------------------------------------------------------
     // Blocking, unblocking, and closing ports
     // -------------------------------------------------------------------------
     pub(crate) fn initiate_port_closing(&mut self, port_handle: PortHandle, comp_ctx: &mut CompCtx) -> Option<(CompId, ControlMessage)> {
         let port = comp_ctx.get_port_mut(port_handle);
         let port_id = port.self_id;
         let peer_port_id = port.peer_port_id;
         let peer_comp_id = port.peer_comp_id;
         debug_assert!(port.state == PortState::Open || port.state == PortState::Blocked);
         port.state = PortState::Closed;
         if peer_comp_id == comp_ctx.id {
             // We own the other end of the channel as well.
             return None;
+        }
     /// Initiates the control message procedures for closing a port. Caller must
     /// make sure that the port state has already been set to `Closed`.
     pub(crate) fn initiate_port_closing(&mut self, port_handle: LocalPortHandle, comp_ctx: &CompCtx) -> (LocalPeerHandle, ControlMessage) {
         let port = comp_ctx.get_port(port_handle);
         let peer_port_id = port.peer_port_id;
         debug_assert!(port.state == PortState::Closed);
         // Construct the port-closing entry
         let entry_id = self.take_id();
         self.entries.push(ControlEntry{
             id: entry_id,
             ack_countdown: 1,
-            content: ControlContent::ClosedPort(port_id),
+            content: ControlContent::ClosedPort(port.self_id),
         });
         return Some((
             peer_comp_id,
         // Return the messages notifying peer of the closed port
         let peer_handle = comp_ctx.get_peer_handle(port.peer_comp_id);
         return (
             peer_handle,
             ControlMessage{
                 id: entry_id,
                 sender_comp_id: comp_ctx.id,
                 target_port_id: Some(peer_port_id),
                 content: ControlMessageContent::ClosePort(peer_port_id),
+            }
-        ));
         );
+    }
     /// Adds a control entry to track that a port is blocked. Expects the caller
     /// to have set the port's state to blocking already. The returned tuple
     /// contains a message and the peer to send it to.
     pub(crate) fn initiate_port_blocking(&mut self, comp_ctx: &CompCtx, port_handle: LocalPortHandle) -> (LocalPeerHandle, ControlMessage) {
         let port_info = comp_ctx.get_port(port_handle);
         debug_assert_eq!(port_info.kind, PortKind::Getter); // because we're telling the putter to block
         debug_assert_eq!(port_info.state, PortState::Blocked); // contract with caller
         let peer_port_id = port_info.peer_port_id;
         let peer_comp_id = port_info.peer_comp_id;

src/runtime2/runtime.rs

➞

Show inline comments

@@ @@ -50,25 +50,26 @@ pub(crate) struct CompReserved { @@
 impl CompReserved {
     pub(crate) fn id(&self) -> CompId {
         return CompId(self.reservation.index)
+    }
+}
 /// Private fields of a component, may only be modified by a single thread at
 /// a time.
 pub(crate) struct RuntimeComp {
     pub public: CompPublic,
     pub code: CompPDL,
     pub ctx: CompCtx,
     pub inbox: QueueDynMpsc<Message>
     pub inbox: QueueDynMpsc<Message>,
     pub exiting: bool,
+}
 /// Should contain everything that is accessible in a thread-safe manner
 // TODO: Do something about the `num_handles` thing. This needs to be a bit more
 //  "foolproof" to lighten the mental burden of using the `num_handles`
 //  variable.
 pub(crate) struct CompPublic {
     pub sleeping: AtomicBool,
     pub num_handles: AtomicU32, // manually modified (!)
     inbox: QueueDynProducer<Message>,
+}
@@ @@ -100,27 +101,28 @@ impl CompHandle { @@
             wake_up_if_sleeping(sched_ctx, self.id, self);
+        }
+    }
     fn increment_users(&self) {
         let old_count = self.num_handles.fetch_add(1, Ordering::AcqRel);
         debug_assert!(old_count > 0); // because we should never be able to retrieve a handle when the component is (being) destroyed
+    }
     /// Returns the `CompKey` to the component if it should be destroyed
     pub(crate) fn decrement_users(&mut self) -> Option<CompKey> {
         debug_assert!(!self.decremented, "illegal to 'decrement_users' twice");
         dbg_code!(self.decremented = true);
         let old_count = self.num_handles.fetch_sub(1, Ordering::AcqRel);
         let new_count = old_count - 1;
         dbg_code!(self.decremented = true);
         println!(" ****** DEBUG [handle]: Decremented count to {} for {:?}", new_count, self.id);
         if new_count == 0 {
             return Some(unsafe{ self.id.upgrade() });
+        }
         return None;
+    }
+}
 impl Clone for CompHandle {
     fn clone(&self) -> Self {
         debug_assert!(!self.decremented, "illegal to clone after 'decrement_users'");
         self.increment_users();
@@ @@ -239,83 +241,89 @@ impl RuntimeInner { @@
         let _id = reserved.id();
         context.id = reserved.id();
         let component = RuntimeComp {
             public: CompPublic{
                 sleeping: AtomicBool::new(initially_sleeping),
                 num_handles: AtomicU32::new(1), // the component itself acts like a handle
                 inbox: inbox_producer,
             },
             code: component,
             ctx: context,
             inbox: inbox_queue,
             exiting: false,
         };
         let index = self.components.submit(reserved.reservation, component);
         debug_assert_eq!(index, _id.0);
         let component = self.components.get_mut(index);
         return (CompKey(index), component);
+    }
     /// Creates a new component. Note that the public part will be properly
     /// initialized, but not all private fields are.
     pub(crate) fn create_pdl_component(&self, comp: CompPDL, ctx: CompCtx, initially_sleeping: bool) -> (CompKey, &mut RuntimeComp) {
         let inbox_queue = QueueDynMpsc::new(16);
         let inbox_producer = inbox_queue.producer();
         let comp = RuntimeComp{
             public: CompPublic{
                 sleeping: AtomicBool::new(initially_sleeping),
                 num_handles: AtomicU32::new(1), // the component itself acts like a handle
                 inbox: inbox_producer,
             },
             code: comp,
             ctx,
             inbox: inbox_queue,
             exiting: false,
         };
         let index = self.components.create(comp);
         // TODO: just do a reserve_index followed by a consume_index or something
         self.increment_active_components();
         let component = self.components.get_mut(index);
         component.ctx.id = CompId(index);
         return (CompKey(index), component);
+    }
     pub(crate) fn get_component(&self, key: CompKey) -> &mut RuntimeComp {
         let component = self.components.get_mut(key.0);
         return component;
+    }
     pub(crate) fn get_component_public(&self, id: CompId) -> CompHandle {
         let component = self.components.get(id.0);
         return CompHandle::new(id, &component.public);
+    }
     pub(crate) fn destroy_component(&self, key: CompKey) {
         debug_assert_eq!(self.get_component(key).public.num_handles.load(Ordering::Acquire), 0);
         dbg_code!({
             let component = self.get_component(key);
             debug_assert!(component.exiting);
             debug_assert_eq!(component.public.num_handles.load(Ordering::Acquire), 0);
         });
         self.decrement_active_components();
         self.components.destroy(key.0);
+    }
     // Tracking number of active interfaces and the active components
     #[inline]
     fn increment_active_components(&self) {
         let _old_val = self.active_elements.fetch_add(1, Ordering::AcqRel);
         debug_assert!(_old_val > 0); // can only create a component from a API/component, so can never be 0.
+    }
     fn decrement_active_components(&self) {
         let old_val = self.active_elements.fetch_sub(1, Ordering::AcqRel);
         debug_assert!(old_val > 0); // something wrong with incr/decr logic
         let new_val = old_val - 1;
         if new_val == 0 {
             // Just to be sure, in case the last thing that gets destroyed is an
             // API instead of a thread.
-            let lock = self.work_queue.lock();
+            let _lock = self.work_queue.lock();
             self.work_condvar.notify_all();
+        }
+    }
+}

src/runtime2/scheduler.rs

➞

Show inline comments

 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use super::component::*;
 use super::runtime::*;
 use super::communication::*;
 /// Data associated with a scheduler thread
 pub(crate) struct Scheduler {
     runtime: Arc<RuntimeInner>,
     scheduler_id: u32,
+}
 pub(crate) struct SchedulerCtx<'a> {
     pub runtime: &'a RuntimeInner,
     pub id: u32,
     pub comp: u32,
+}
@@ @@ -65,55 +64,55 @@ impl Scheduler { @@
             // Handle the new scheduling
             match new_scheduling {
                 CompScheduling::Immediate => unreachable!(),
                 CompScheduling::Requeue => { self.runtime.enqueue_work(comp_key); },
                 CompScheduling::Sleep => { self.mark_component_as_sleeping(comp_key, component); },
                 CompScheduling::Exit => { self.mark_component_as_exiting(&scheduler_ctx, component); }
+            }
+        }
+    }
     // local utilities
     /// Marks component as sleeping, if after marking itself as sleeping the
     /// inbox contains messages then the component will be immediately
     /// rescheduled. After calling this function the component should not be
     /// executed anymore.
     fn mark_component_as_sleeping(&self, key: CompKey, component: &mut RuntimeComp) {
         debug_assert_eq!(key.downgrade(), component.ctx.id); // make sure component matches key
         debug_assert_eq!(component.public.sleeping.load(Ordering::Acquire), false); // we're executing it, so it cannot be sleeping
         component.public.sleeping.store(true, Ordering::Release);
         if component.inbox.can_pop() {
             let should_reschedule = component.public.sleeping
                 .compare_exchange(true, false, Ordering::AcqRel, Ordering::Relaxed)
                 .is_ok();
             if should_reschedule {
                 self.runtime.enqueue_work(key);
+            }
+        }
+    }
     /// Marks the component as exiting by removing the reference it holds to
     /// itself. Afterward the component will enter "normal" sleeping mode (if it
     /// has not yet been destroyed)
     fn mark_component_as_exiting(&self, sched_ctx: &SchedulerCtx, component: &mut RuntimeComp) {
         // Send messages that all ports will be closed
         for port_index in 0..component.ctx.ports.len() {
             let port_info = &component.ctx.ports[port_index];
             if let Some((peer_id, message)) = component.code.control.initiate_port_closing(port_info.self_id, &mut component.ctx) {
                 let peer_info = component.ctx.get_peer(peer_id);
                 peer_info.handle.send_message(sched_ctx, Message::Control(message), true);
+            }
+        }
         // If we didn't yet decrement our reference count, do so now
         let comp_key = unsafe{ component.ctx.id.upgrade() };
         // Remove all references to the peers that we have
         for mut peer in component.ctx.peers.drain(..) {
             let should_remove = peer.handle.decrement_users();
             if should_remove {
                 let key = unsafe{ peer.id.upgrade() };
                 sched_ctx.runtime.destroy_component(key);
+            }
+        }
         if !component.exiting {
             component.exiting = true;
             let old_count = component.public.num_handles.fetch_sub(1, Ordering::AcqRel);
             let new_count = old_count - 1;
             println!(" ****** DEBUG [ sched]: Decremented count to {} for {:?}", new_count, component.ctx.id);
             if new_count == 0 {
             let comp_key = unsafe{ component.ctx.id.upgrade() };
                 sched_ctx.runtime.destroy_component(comp_key);
                 return;
+            }
+        }
         // Enter "regular" sleeping mode
         self.mark_component_as_sleeping(comp_key, component);
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/store/component.rs

➞

Show inline comments

@@ @@ -120,25 +120,25 @@ impl<T: Sized> ComponentStore<T> { @@
     /// Creates a new element initialized to the provided `value`. This returns
     /// the index at which the element can be retrieved.
     pub fn create(&self, value: T) -> u32 {
         let lock = self.inner.lock_shared();
         let (lock, index) = self.pop_freelist_index(lock);
         Self::initialize_at_index(lock, index, value);
         return index;
+    }
     pub fn reserve(&self) -> ComponentReservation {
         let lock = self.inner.lock_shared();
-        let (lock, index) = self.pop_freelist_index(lock);
+        let (_lock, index) = self.pop_freelist_index(lock);
         return ComponentReservation::new(index);
+    }
     pub fn submit(&self, mut reservation: ComponentReservation, value: T) -> u32 {
         dbg_code!({ reservation.submitted = true; });
         let lock = self.inner.lock_shared();
         Self::initialize_at_index(lock, reservation.index, value);
         return reservation.index;
+    }
     /// Destroys an element at the provided `index`. The caller must make sure
     /// that it does not use any previously received references to the data at

0 comments (0 inline, 0 general)