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

Changeset - 3af8b6eaec1b

Parent rev.

Child rev.

[Not reviewed]

0 2 0

Hans-Dieter Hiep - 5 years ago 2020-02-05 17:47:22
hdh@cwi.nl

Implement change to protocol description trait interface

2 files changed with 47 insertions and 30 deletions:

src/common.rs

src/protocol/mod.rs

0 comments (0 inline, 0 general)

src/common.rs

➞

Show inline comments

 ///////////////////// PRELUDE /////////////////////
 pub use core::{
     cmp::Ordering,
     fmt::Debug,
     hash::{Hash, Hasher},
     ops::{Range, RangeFrom},
     time::Duration,
 };
 pub use indexmap::{IndexMap, IndexSet};
 pub use maplit::{hashmap, hashset};
 pub use mio::{
     net::{TcpListener, TcpStream},
     Event, Evented, Events, Poll, PollOpt, Ready, Token,
 };
 pub use std::{
     collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
     convert::TryInto,
     net::SocketAddr,
     sync::Arc,
     time::Instant,
 };
 pub use Polarity::*;
 ///////////////////// DEFS /////////////////////
 pub type Payload = Vec<u8>;
 pub type ControllerId = u32;
 pub type ChannelIndex = u32;
 /// This is a unique identifier for a channel (i.e., port).
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 pub struct ChannelId {
     pub(crate) controller_id: ControllerId,
     pub(crate) channel_index: ChannelIndex,
+}
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 pub enum Polarity {
     Putter, // output port (from the perspective of the component)
     Getter, // input port (from the perspective of the component)
+}
 #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone, Debug)]
 pub struct Key(u64);
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
 pub enum MainComponentErr {
     NoSuchComponent,
     NonPortTypeParameters,
+}
 pub trait ProtocolDescription: Sized {
     type S: ComponentState<D = Self>;
     fn parse(pdl: &[u8]) -> Result<Self, String>;
     fn component_polarities(&self, identifier: &[u8]) -> Result<Vec<Polarity>, MainComponentErr>;
     fn new_main_component(&self, identifier: &[u8], ports: &[Key]) -> Self::S;
+}
 pub trait ComponentState: Sized + Clone {
     type D: ProtocolDescription;
     fn pre_sync_run<C: MonoContext<D = Self::D, S = Self>>(
         &mut self,
         runtime_ctx: &mut C,
         protocol_description: &Self::D,
     ) -> MonoBlocker;
     fn sync_run<C: PolyContext<D = Self::D>>(
         &mut self,
         runtime_ctx: &mut C,
         protocol_description: &Self::D,
     ) -> PolyBlocker;
+}
 #[derive(Debug, Clone)]
 pub enum MonoBlocker {
     Inconsistent,
     ComponentExit,
     SyncBlockStart,
+}
 #[derive(Debug, Clone)]
 pub enum PolyBlocker {
     Inconsistent,
     SyncBlockEnd,
     CouldntReadMsg(Key),
     CouldntCheckFiring(Key),
     PutMsg(Key, Payload),
+}
 pub trait MonoContext {
     type D: ProtocolDescription;
     type S: ComponentState<D = Self::D>;
     fn new_component(&mut self, moved_keys: HashSet<Key>, init_state: Self::S);

src/protocol/mod.rs

➞

Show inline comments

 mod ast;
 mod eval;
 pub mod inputsource;
 mod lexer;
 mod library;
 mod parser;
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 use std::hint::unreachable_unchecked;
 pub struct ProtocolDescriptionImpl {
     heap: Heap,
     source: InputSource,
     root: RootId
+}
 impl std::fmt::Debug for ProtocolDescriptionImpl {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "Protocol")
+    }
+}
 impl ProtocolDescription for ProtocolDescriptionImpl {
     type S = ComponentStateImpl;
     fn parse(buffer: &[u8]) -> Result<Self, String> {
         let mut heap = Heap::new();
         let mut source = InputSource::from_buffer(buffer).unwrap();
         let mut parser = Parser::new(&mut source);
         match parser.parse(&mut heap) {
             Ok(root) => {
                 return Ok(ProtocolDescriptionImpl { heap, source, root });
+            }
             Err(err) => {
                 let mut vec: Vec<u8> = Vec::new();
                 err.write(&source, &mut vec).unwrap();
                 Err(String::from_utf8_lossy(&vec).to_string())
+            }
+        }
+    }
     // fn main_interface_polarities(&self) -> Vec<Polarity> {
     //     let def = &self.heap[self.main];
     //     let mut result = Vec::new();
     //     for &param in def.parameters().iter() {
     //         let param = &self.heap[param];
     //         let type_annot = &self.heap[param.type_annotation];
     //         let ptype = &type_annot.the_type.primitive;
     //         if ptype == &PrimitiveType::Input {
     //             result.push(Polarity::Getter)
     //         } else if ptype == &PrimitiveType::Output {
     //             result.push(Polarity::Putter)
     //         } else {
     //             unreachable!()
     //         }
     //     }
     //     result
     // }
     fn new_main_component(&self, identifier: &[u8], ports: &[(Polarity, Key)]) -> Result<ComponentStateImpl, NewMainErr> {
         // Find symbol with identifier
         let def = self.heap[self.root].get_definition_ident(&heap, identifier);
     fn component_polarities(&self, identifier: &[u8]) -> Result<Vec<Polarity>, MainComponentErr> {
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier);
         if def.is_none() {
-            return Err(NewMainErr::NoSuchComponent);
+            return Err(MainComponentErr::NoSuchComponent);
+        }
-        let def = &self.heap[def.unwrap()];
+        let def = &h[def.unwrap()];
         if !def.is_component() {
-            return Err(NewMainErr::NoSuchComponent);
+            return Err(MainComponentErr::NoSuchComponent);
+        }
         let main = def.as_component().this();
         //
         for &param in def.parameters().iter() {
             let param = &h[param];
             let type_annot = &h[param.type_annotation];
             if type_annot.the_type.array {
                 return Err(MainComponentErr::NonPortTypeParameters);
+            }
             match type_annot.the_type.primitive {
                 PrimitiveType::Input | PrimitiveType::Output => continue,
                 _ => {
                     return Err(MainComponentErr::NonPortTypeParameters);
+                }
+            }
+        }
         let mut result = Vec::new();
         for &param in def.parameters().iter() {
             let param = &h[param];
             let type_annot = &h[param.type_annotation];
             let ptype = &type_annot.the_type.primitive;
             if ptype == &PrimitiveType::Input {
                 result.push(Polarity::Getter)
             } else if ptype == &PrimitiveType::Output {
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     fn new_main_component(&self, identifier: &[u8], ports: &[Key]) -> ComponentStateImpl {
         let mut args = Vec::new();
         for &(x, y) in ports.iter() {
             match x {
                 Polarity::Getter => args.push(Value::Input(InputValue(y))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(y))),
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
             match y {
                 Polarity::Getter => args.push(Value::Input(InputValue(x))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(x)))
+            }
+        }
         ComponentStateImpl { prompt: Prompt::new(&self.heap, self.main.upcast(), &args) }
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier).unwrap();
         ComponentStateImpl {
             prompt: Prompt::new(h, def, &args)
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ComponentStateImpl {
     prompt: Prompt,
+}
 impl ComponentState for ComponentStateImpl {
     type D = ProtocolDescriptionImpl;
     fn pre_sync_run<C: MonoContext<D = ProtocolDescriptionImpl, S = Self>>(
         &mut self,
         context: &mut C,
         pd: &ProtocolDescriptionImpl,
     ) -> MonoBlocker {
         let mut context = EvalContext::Mono(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // In component definitions, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return MonoBlocker::Inconsistent,
                     EvalContinuation::Terminal => return MonoBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return MonoBlocker::SyncBlockStart,
                     // Not possible to end sync block if never entered one
                     EvalContinuation::SyncBlockEnd => unreachable!(),
                     EvalContinuation::NewComponent(args) => {
                         todo!();
                         continue;
+                    }
                     // Outside synchronous blocks, no fires/get/put happens
                     EvalContinuation::BlockFires(val) => unreachable!(),
                     EvalContinuation::BlockGet(val) => unreachable!(),
                     EvalContinuation::Put(port, msg) => unreachable!(),
                 },
+            }
+        }
+    }
     fn sync_run<C: PolyContext<D = ProtocolDescriptionImpl>>(
         &mut self,
         context: &mut C,
         pd: &ProtocolDescriptionImpl,
     ) -> PolyBlocker {
         let mut context = EvalContext::Poly(context);
         loop {

0 comments (0 inline, 0 general)