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

Changeset - 1e885fa95b12

Parent rev.

Child rev.

[Not reviewed]

0 5 0

Christopher Esterhuyse - 6 years ago 2020-02-04 14:41:54
christopheresterhuyse@gmail.com

more debug prints on branch predicates

5 files changed with 67 insertions and 14 deletions:

Cargo.toml

src/macros.rs

src/runtime/actors.rs

src/runtime/communication.rs

src/runtime/mod.rs

0 comments (0 inline, 0 general)

Cargo.toml

➞

Show inline comments

 [package]
 name = "reowolf_rs"
 version = "0.1.0"
 authors = ["Christopher Esterhuyse <christopher.esterhuyse@gmail.com>", "Hans-Dieter Hiep <hdh@cwi.nl>"]
 authors = [
 	"Christopher Esterhuyse <christopher.esterhuyse@gmail.com>",
 	"Hans-Dieter Hiep <hdh@cwi.nl>"
+]
 edition = "2018"
 [dependencies]
 # runtime stuff
 getrandom = "0.1.14" # tiny crate. used to guess controller-id
 take_mut = "0.2.2"
 maplit = "1.0.2" # convenience macros
 indexmap = "1.3.0" # hashsets with efficient arbitrary element removal
+indexmap = "1.3.0" # hashsets/hashmaps with efficient arbitrary element removal
 # network stuff
 integer-encoding = "1.0.7"
 byteorder = "1.3.2"
 mio = "0.6.21" # migrate to mio 0.7.0 when it stabilizes. It's much better.
 mio-extras = "2.0.6"
 # protocol stuff
 id-arena = "2.2.1"
 backtrace = "0.3"
 [dev-dependencies]
 test-generator = "0.3.0"
 [lib]
 crate-type = ["cdylib"]
 [features]
 default = ["ffi"]
 ffi = []
@@ \ No newline at end of file @@
 ffi = [] # no feature dependencies
@@ \ No newline at end of file @@

src/macros.rs

➞

Show inline comments

 macro_rules! lockprintln {
     () => (print!("\n"));
     ($($arg:tt)*) => ({
         use std::io::Write;
         std::writeln!(std::io::stdout().lock(), $($arg)*).expect("LPRINTLN");
     })
+}
 macro_rules! assert_let {
     ($pat:pat = $expr:expr => $work:expr) => {
         if let $pat = $expr {
             $work
         } else {
             panic!("assert_let failed");
+        }
     };
+}
 #[test]
 fn assert_let() {
     let x = Some(5);
     let z = assert_let![Some(y) = x => {
         println!("{:?}", y);
     }];
     println!("{:?}", z);
+}
 #[test]
 #[should_panic]
 fn must_let_panic() {
     let x: Option<u32> = None;
     assert_let![Some(y) = x => {
         println!("{:?}", y);
     }];
+}

src/runtime/actors.rs

➞

Show inline comments

@@ @@ -96,148 +96,192 @@ impl PolyP { @@
                         .iter()
                         .map(|&ekey| m_ctx.inner.endpoint_exts.get(ekey).unwrap().info.channel_id);
                     predicate.batch_assign_nones(ekeys_channel_id_iter, false);
                     // report the local solution
                     m_ctx
                         .solution_storage
                         .submit_and_digest_subtree_solution(m_ctx.my_subtree_id, predicate.clone());
                     // store the solution for recovering later
                     self.complete.insert(predicate, branch);
+                }
                 Sb::PutMsg(ekey, payload) => {
                     assert!(self.ekeys.contains(&ekey));
                     let EndpointExt { info, endpoint } =
                         m_ctx.inner.endpoint_exts.get_mut(ekey).unwrap();
                     if predicate.replace_assignment(info.channel_id, true) != Some(false) {
                         let msg = CommMsgContents::SendPayload {
                             payload_predicate: predicate.clone(),
                             payload,
+                        }
                         .into_msg(m_ctx.inner.round_index);
                         endpoint.send(msg)?;
                         to_run.push((predicate, branch));
+                    }
                     // ELSE DROP
+                }
+            }
+        }
         // all in self.incomplete most recently returned Blocker::CouldntReadMsg
         Ok(if self.incomplete.is_empty() {
             if self.complete.is_empty() {
                 Srr::NoBranches
             } else {
                 Srr::AllBranchesComplete
+            }
         } else {
             Srr::BlockingForRecv
         })
+    }
     pub(crate) fn poly_recv_run(
         &mut self,
         m_ctx: PolyPContext,
         protocol_description: &ProtocolD,
         ekey: Key,
         payload_predicate: Predicate,
         payload: Payload,
     ) -> Result<SyncRunResult, EndpointErr> {
         // try exact match
         let cid = m_ctx.inner.channel_id_stream.controller_id;
         let to_run = if self.complete.contains_key(&payload_predicate) {
             // exact match with stopped machine
             lockprintln!(
                 "{:?}: ... poly_recv_run matched stopped machine exactly! nothing to do here",
                 cid,
             );
             vec![]
         } else if let Some(mut branch) = self.incomplete.remove(&payload_predicate) {
             // exact match with running machine
             lockprintln!(
                 "{:?}: ... poly_recv_run matched running machine exactly! pred is {:?}",
                 cid,
                 &payload_predicate
             );
             branch.inbox.insert(ekey, payload);
             vec![(payload_predicate, branch)]
         } else {
             lockprintln!(
                 "{:?}: ... poly_recv_run didn't have any exact matches... Let's try feed it to all branches",
                 cid,
             );
             let mut incomplete2 = HashMap::<_, _>::default();
             let to_run = self
                 .incomplete
                 .drain()
                 .filter_map(|(old_predicate, mut branch)| {
                     use CommonSatResult as Csr;
                     match old_predicate.common_satisfier(&payload_predicate) {
                         Csr::FormerNotLatter | Csr::Equivalent => {
                             lockprintln!(
                                 "{:?}: ... poly_recv_run This branch is compatible unaltered! branch pred: {:?}",
                                 cid,
                                 &old_predicate
                             );
                             // old_predicate COVERS the assumptions of payload_predicate
                             let was = branch.inbox.insert(ekey, payload.clone());
                             assert!(was.is_none()); // INBOX MUST BE EMPTY!
                             Some((old_predicate, branch))
+                        }
                         Csr::New(unified) => {
                         Csr::New(new) => {
                             lockprintln!(
                                 "{:?}: ... poly_recv_run payloadpred {:?} and branchpred {:?} satisfied by new pred {:?}. FORKING",
                                 cid,
                                 &old_predicate,
                                 &payload_predicate,
                                 &new,
                             );
                             // payload_predicate has new assumptions. FORK!
                             let mut payload_branch = branch.clone();
                             let was = payload_branch.inbox.insert(ekey, payload.clone());
                             assert!(was.is_none()); // INBOX MUST BE EMPTY!
                             // put the original back untouched
                             incomplete2.insert(old_predicate, branch);
-                            Some((unified, payload_branch))
+                            Some((new, payload_branch))
+                        }
                         Csr::LatterNotFormer => {
                             lockprintln!(
                                 "{:?}: ... poly_recv_run payloadpred {:?} subsumes branch pred {:?}. FORKING",
                                 cid,
                                 &old_predicate,
                                 &payload_predicate,
                             );
                             // payload_predicate has new assumptions. FORK!
                             let mut payload_branch = branch.clone();
                             let was = payload_branch.inbox.insert(ekey, payload.clone());
                             assert!(was.is_none()); // INBOX MUST BE EMPTY!
                             // put the original back untouched
                             incomplete2.insert(old_predicate, branch);
                             Some((payload_predicate.clone(), payload_branch))
+                        }
                         Csr::Nonexistant => {
                             lockprintln!(
                                 "{:?}: ... poly_recv_run SKIPPING because branchpred={:?}. payloadpred={:?}",
                                 cid,
                                 &old_predicate,
                                 &payload_predicate,
                             );
                             // predicates contradict
                             incomplete2.insert(old_predicate, branch);
                             None
+                        }
+                    }
                 })
                 .collect();
             std::mem::swap(&mut self.incomplete, &mut incomplete2);
             to_run
         };
         lockprintln!("{:?}: ... DONE FEEDING BRANCHES. {} branches to run!", cid, to_run.len(),);
         self.poly_run_these_branches(m_ctx, protocol_description, to_run)
+    }
     pub(crate) fn become_mono(
         mut self,
         decision: &Predicate,
         all_inboxes: &mut HashMap<Key, Payload>,
     ) -> MonoP {
         if let Some((_, branch)) = self.complete.drain().find(|(p, _)| decision.satisfies(p)) {
             let BranchP { inbox, state } = branch;
             for (key, payload) in inbox {
                 assert!(all_inboxes.insert(key, payload).is_none());
+            }
             self.incomplete.clear();
             MonoP { state, ekeys: self.ekeys }
         } else {
             panic!("No such solution!")
+        }
+    }
+}
 impl PolyN {
     pub fn sync_recv(
         &mut self,
         ekey: Key,
         payload: Payload,
         solution_storage: &mut SolutionStorage,
     ) {
         for (predicate, branch) in self.branches.iter_mut() {
             if branch.to_get.remove(&ekey) {
                 branch.gotten.insert(ekey, payload.clone());
                 if branch.to_get.is_empty() {
                     solution_storage
                         .submit_and_digest_subtree_solution(SubtreeId::PolyN, predicate.clone());
+                }
+            }
+        }
+    }
     pub fn become_mono(
         mut self,
         decision: &Predicate,
         all_inboxes: &mut HashMap<Key, Payload>,
     ) -> MonoN {
         if let Some((_, branch)) = self.branches.drain().find(|(p, _)| decision.satisfies(p)) {
             let BranchN { gotten, sync_batch_index, .. } = branch;
             for (&key, payload) in gotten.iter() {
                 assert!(all_inboxes.insert(key, payload.clone()).is_none());

src/runtime/communication.rs

➞

Show inline comments

 use crate::common::*;
 use crate::runtime::{actors::*, endpoint::*, errors::*, *};
 macro_rules! lockprintln {
     () => (print!("\n"));
     ($($arg:tt)*) => ({
         use std::io::Write;
         std::writeln!(std::io::stdout().lock(), $($arg)*).expect("LPRINTLN");
     })
+}
 impl Controller {
     fn end_round_with_decision(&mut self, decision: Predicate) -> Result<(), SyncErr> {
         let mut all_inboxes = HashMap::default();
         self.inner.mono_n = self
             .ephemeral
             .poly_n
             .take()
             .map(|poly_n| poly_n.become_mono(&decision, &mut all_inboxes));
         self.inner.mono_ps.extend(
             self.ephemeral.poly_ps.drain(..).map(|m| m.become_mono(&decision, &mut all_inboxes)),
         );
         let valuations: HashMap<_, _> = all_inboxes
             .drain()
             .map(|(ekey, payload)| {
                 let channel_id = self.inner.endpoint_exts.get(ekey).unwrap().info.channel_id;
                 (channel_id, Some(payload))
             })
             .collect();
         for (channel_id, value) in decision.assigned.iter() {
             if !value {
                 println!("VALUE {:?} => *", channel_id);
             } else if let Some(payload) = valuations.get(channel_id) {
                 println!("VALUE {:?} => Message({:?})", channel_id, payload);
             } else {
                 println!("VALUE {:?} => Message(?)", channel_id);
+            }
+        }
         let announcement =
             CommMsgContents::Announce { oracle: decision }.into_msg(self.inner.round_index);
         for &child_ekey in self.inner.family.children_ekeys.iter() {
             self.inner
                 .endpoint_exts
                 .get_mut(child_ekey)
                 .expect("eefef")
                 .endpoint
                 .send(announcement.clone())?;
+        }
         self.inner.round_index += 1;
         self.ephemeral.clear();
         Ok(())
+    }
     // Drain self.ephemeral.solution_storage and handle the new locals. Return decision if one is found
     fn handle_locals_maybe_decide(&mut self) -> Result<bool, SyncErr> {
         if let Some(parent_ekey) = self.inner.family.parent_ekey {
             // I have a parent -> I'm not the leader
             let parent_endpoint =
                 &mut self.inner.endpoint_exts.get_mut(parent_ekey).expect("huu").endpoint;

src/runtime/mod.rs

➞

Show inline comments

@@ @@ -393,97 +393,103 @@ impl Predicate { @@
         match [s_not_o.is_empty(), o_not_s.is_empty()] {
             [true, true] => Equivalent,       // ... equivalent to both.
             [false, true] => FormerNotLatter, // ... equivalent to self.
             [true, false] => LatterNotFormer, // ... equivalent to other.
             [false, false] => {
                 // ... which is the union of the predicates' assignments but
                 //     is equivalent to neither self nor other.
                 let mut predicate = self.clone();
                 for (&id, &b) in o_not_s {
                     predicate.assigned.insert(id, b);
+                }
                 New(predicate)
+            }
+        }
+    }
     pub fn batch_assign_nones(
         &mut self,
         channel_ids: impl Iterator<Item = ChannelId>,
         value: bool,
     ) {
         for channel_id in channel_ids {
             self.assigned.entry(channel_id).or_insert(value);
+        }
+    }
     pub fn replace_assignment(&mut self, channel_id: ChannelId, value: bool) -> Option<bool> {
         self.assigned.insert(channel_id, value)
+    }
     pub fn union_with(&self, other: &Self) -> Option<Self> {
         let mut res = self.clone();
         for (&channel_id, &assignment_1) in other.assigned.iter() {
             match res.assigned.insert(channel_id, assignment_1) {
                 Some(assignment_2) if assignment_1 != assignment_2 => return None,
                 _ => {}
+            }
+        }
         Some(res)
+    }
     pub fn query(&self, x: ChannelId) -> Option<bool> {
         self.assigned.get(&x).copied()
+    }
     pub fn new_trivial() -> Self {
         Self { assigned: Default::default() }
+    }
+}
 impl Debug for Predicate {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         for (ChannelId { controller_id, channel_index }, &v) in self.assigned.iter() {
             write!(f, "{:?}=>{}", (controller_id, channel_index), if v { 'T' } else { 'F' })?;
             write!(
                 f,
                 "({:?},{:?})=>{}, ",
                 controller_id,
                 channel_index,
                 if v { 'T' } else { 'F' }
             )?;
+        }
         Ok(())
+    }
+}
 #[test]
 fn pred_sat() {
     use maplit::btreemap;
     let mut c = ChannelIdStream::new(0);
     let ch = std::iter::repeat_with(move || c.next()).take(5).collect::<Vec<_>>();
     let p = Predicate::new_trivial();
     let p_0t = Predicate { assigned: btreemap! { ch[0] => true } };
     let p_0f = Predicate { assigned: btreemap! { ch[0] => false } };
     let p_0f_3f = Predicate { assigned: btreemap! { ch[0] => false, ch[3] => false } };
     let p_0f_3t = Predicate { assigned: btreemap! { ch[0] => false, ch[3] => true } };
     assert!(p.satisfies(&p));
     assert!(p_0t.satisfies(&p_0t));
     assert!(p_0f.satisfies(&p_0f));
     assert!(p_0f_3f.satisfies(&p_0f_3f));
     assert!(p_0f_3t.satisfies(&p_0f_3t));
     assert!(p_0t.satisfies(&p));
     assert!(p_0f.satisfies(&p));
     assert!(p_0f_3f.satisfies(&p_0f));
     assert!(p_0f_3t.satisfies(&p_0f));
     assert!(!p.satisfies(&p_0t));
     assert!(!p.satisfies(&p_0f));
     assert!(!p_0f.satisfies(&p_0t));
     assert!(!p_0t.satisfies(&p_0f));
     assert!(!p_0f_3f.satisfies(&p_0f_3t));
     assert!(!p_0f_3t.satisfies(&p_0f_3f));
     assert!(!p_0t.satisfies(&p_0f_3f));
     assert!(!p_0f.satisfies(&p_0f_3f));
     assert!(!p_0t.satisfies(&p_0f_3t));
     assert!(!p_0f.satisfies(&p_0f_3t));
+}
 #[test]
 fn pred_common_sat() {
     use maplit::btreemap;
     use CommonSatResult::*;
     let mut c = ChannelIdStream::new(0);
     let ch = std::iter::repeat_with(move || c.next()).take(5).collect::<Vec<_>>();
     let p = Predicate::new_trivial();
     let p_0t = Predicate { assigned: btreemap! { ch[0] => true } };

0 comments (0 inline, 0 general)