Merge pull request #26 from convince-project/y2review

Y2review

Author: EnricoGhiorzi

Diff for: scan_core/src/channel_system.rs

@@ -96,6 +96,8 @@ mod builder;
 // use ahash::AHashMap as HashMap;
 pub use builder::*;
 use hashbrown::HashMap;
+use rand::seq::SliceRandom;
+use rand::Rng;
 
 use crate::program_graph::{
     Action as PgAction, Clock as PgClock, Location as PgLocation, Var as PgVar, *,
@@ -295,24 +297,49 @@ impl ChannelSystem {
             })
     }
 
-    pub(crate) fn resolve_deterministic_transitions(&mut self) {
-        for (pg_id, pg) in self.program_graphs.iter_mut().enumerate() {
-            let pg_id = PgId(pg_id);
-            loop {
-                // `take(2)` because we need no more to establish the transition is non-deterministic
-                let trans: Vec<_> = pg.possible_transitions().take(2).collect();
-                if trans.len() == 1 {
-                    let (action, post) = trans[0];
-                    if self.communications.contains_key(&Action(pg_id, action)) {
-                        break;
-                    } else {
-                        pg.transition(action, post).expect("transition is possible");
+    pub(crate) fn monaco_execution<R: Rng>(
+        &mut self,
+        rng: &mut R,
+        duration: Time,
+    ) -> Option<Event> {
+        let pg_list = Vec::from_iter((0..self.program_graphs.len()).map(PgId));
+        let mut shuffle = pg_list.to_owned();
+        while self.time <= duration {
+            while self.possible_transitions().any(|_| true) {
+                shuffle.shuffle(rng);
+                for &pg_id in &shuffle {
+                    let mut possible_transitions = self.program_graphs[pg_id.0]
+                        .possible_transitions()
+                        .collect::<Vec<_>>();
+                    possible_transitions.shuffle(rng);
+                    while let Some((action, post)) = possible_transitions.pop() {
+                        let cs_action = Action(pg_id, action);
+                        if self.communications.contains_key(&cs_action) {
+                            if self.check_communication(pg_id, cs_action).is_ok() {
+                                let cs_post = Location(pg_id, post);
+                                let event = self
+                                    .transition(pg_id, cs_action, cs_post)
+                                    .expect("successful transition");
+                                assert!(event.is_some(), "must be a communication event");
+                                return event;
+                            } else {
+                                continue;
+                            }
+                        } else {
+                            self.program_graphs[pg_id.0]
+                                .transition(action, post)
+                                .expect("success");
+                            possible_transitions = self.program_graphs[pg_id.0]
+                                .possible_transitions()
+                                .collect::<Vec<_>>();
+                            possible_transitions.shuffle(rng);
+                        }
                     }
-                } else {
-                    break;
                 }
             }
+            self.wait(1).ok()?;
         }
+        None
     }
 
     fn check_communication(&self, pg_id: PgId, action: Action) -> Result<(), CsError> {

Diff for: scan_core/src/model.rs

@@ -24,21 +24,19 @@ impl CsModelBuilder {
         }
     }
 
-    pub fn add_port(&mut self, channel: Channel, default: Val) -> Result<(), ()> {
+    pub fn add_port(&mut self, channel: Channel, default: Val) {
         if let std::collections::hash_map::Entry::Vacant(e) = self.vals.entry(channel) {
             e.insert(default);
-            Ok(())
         } else {
-            Err(())
+            panic!("entry is already taken");
         }
     }
 
-    pub fn add_predicate(&mut self, predicate: Expression<Channel>) -> Result<usize, ()> {
+    pub fn add_predicate(&mut self, predicate: Expression<Channel>) -> usize {
         let predicate = FnExpression::<Channel>::from(predicate);
         let _ = predicate.eval(&|port| self.vals.get(&port).unwrap().clone());
-        // let _ = predicate.eval(&|port| self.vals.get(&port).cloned());
         self.predicates.push(predicate);
-        Ok(self.predicates.len() - 1)
+        self.predicates.len() - 1
     }
 
     /// Creates a new [`CsModel`] with the given underlying [`ChannelSystem`] and set of predicates.
@@ -69,6 +67,7 @@ pub struct CsModel {
 
 impl CsModel {
     /// Gets the underlying [`ChannelSystem`].
+    #[inline(always)]
     pub fn channel_system(&self) -> &ChannelSystem {
         &self.cs
     }
@@ -81,10 +80,7 @@ impl TransitionSystem for CsModel {
         self.predicates
             .iter()
             .map(|prop| {
-                if let Val::Boolean(b) = prop.eval(&|port| self.vals.get(&port).unwrap().clone())
-                // .eval(&|port| self.vals.get(&port).cloned())
-                // .expect("boolean value")
-                {
+                if let Val::Boolean(b) = prop.eval(&|port| self.vals.get(&port).unwrap().clone()) {
                     Some(b)
                 } else {
                     None
@@ -95,36 +91,22 @@ impl TransitionSystem for CsModel {
             .unwrap()
     }
 
-    fn transitions(mut self) -> Vec<(Event, CsModel)> {
-        // IntoIterator::into_iter(self.clone().list_transitions())
-        // Perform all transitions that are deterministic and do not interact with channels.
-        // The order in which these are performed does not matter.
-        self.cs.resolve_deterministic_transitions();
-        if self.cs.possible_transitions().next().is_none() {
-            self.cs.wait(1).ok();
-        }
-        self.cs
-            .possible_transitions()
-            .flat_map(|(pg_id, action, post)| {
-                let mut model = self.clone();
-                let event = model
-                    .cs
-                    .transition(pg_id, action, post)
-                    .expect("transition is possible");
-                model.last_event = event.clone();
-                if let Some(event) = event {
-                    if let EventType::Send(ref val) = event.event_type {
-                        model.vals.insert(event.channel, val.to_owned());
-                    }
-                    vec![(event, model)]
-                } else {
-                    model.transitions()
-                }
-            })
-            .collect::<Vec<_>>()
-    }
-
+    #[inline(always)]
     fn time(&self) -> Time {
         self.cs.time()
     }
+
+    fn monaco_transition<R: rand::Rng>(
+        &mut self,
+        rng: &mut R,
+        duration: Time,
+    ) -> Option<Self::Action> {
+        self.last_event = self.cs.monaco_execution(rng, duration);
+        if let Some(event) = self.last_event.as_ref() {
+            if let EventType::Send(ref val) = event.event_type {
+                self.vals.insert(event.channel, val.to_owned());
+            }
+        }
+        self.last_event.to_owned()
+    }
 }