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

Changeset - 78de1ebfd99d

Parent rev.

Child rev.

[Not reviewed]

0 4 0

Christopher Esterhuyse - 5 years ago 2020-02-21 14:23:42
christopher.esterhuyse@gmail.com

more detailed debug printing

4 files changed with 71 insertions and 30 deletions:

Cargo.toml

src/runtime/experimental/api.rs

src/runtime/experimental/bits.rs

src/runtime/experimental/vec_storage.rs

0 comments (0 inline, 0 general)

Cargo.toml

➞

Show inline comments

 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"
 crossbeam-utils = "0.7.0"
 lazy_static = "1.4.0"
 [lib]
 crate-type = ["cdylib"]
 [features]
 default = ["ffi"]
 ffi = [] # no feature dependencies
@@ \ No newline at end of file @@

src/runtime/experimental/api.rs

➞

Show inline comments

 use super::bits::{usizes_for_bits, BitChunkIter, BitMatrix};
 use super::vec_storage::VecStorage;
 use crate::common::*;
 use crate::runtime::endpoint::EndpointExt;
 use crate::runtime::endpoint::EndpointInfo;
 use crate::runtime::endpoint::{Endpoint, Msg, SetupMsg};
 use crate::runtime::errors::EndpointErr;
 use crate::runtime::errors::MessengerRecvErr;
 use crate::runtime::errors::PollDeadlineErr;
 use crate::runtime::MessengerState;
 use crate::runtime::Messengerlike;
 use crate::runtime::ReceivedMsg;
 use crate::runtime::{ProtocolD, ProtocolS};
@@ @@ -401,24 +402,25 @@ impl Connecting { @@
+            }
+        }
         let family = Family { parent, children };
         // done!
         Ok(Connected {
             components: Default::default(),
             controller_id,
             channel_index_stream,
             endpoint_exts,
             native_ports,
             family,
             ephemeral: Default::default(),
         })
+    }
     /////////
     pub fn connect_using_id(
         &mut self,
         controller_id: ControllerId,
         timeout: Option<Duration>,
     ) -> Result<Connected, ConnectErr> {
         // 1. try and create a connection from these bindings with self immutable.
         let connected = self.new_connected(controller_id, timeout)?;
         // 2. success! drain self and return
         self.bindings.clear();
@@ @@ -428,24 +430,29 @@ impl Connecting { @@
         self.connect_using_id(Self::random_controller_id(), timeout)
+    }
+}
 #[derive(Debug)]
 pub struct Connected {
     native_ports: HashSet<Port>,
     controller_id: ControllerId,
     channel_index_stream: ChannelIndexStream,
     endpoint_exts: VecStorage<EndpointExt>,
     components: VecStorage<Component>,
     family: Family,
     ephemeral: Ephemeral,
+}
 #[derive(Debug, Default)]
 struct Ephemeral {
     bit_matrix: BitMatrix,
+}
 impl Connected {
     pub fn new_component(
         &mut self,
         protocol: &Arc<ProtocolD>,
         identifier: &Arc<[u8]>,
         moved_port_list: &[Port],
     ) -> Result<(), MainComponentErr> {
         //////////////////////////////////////////
         // 1. try and create a new component (without mutating self)
         use MainComponentErr::*;
         let moved_port_set = {
@@ @@ -576,25 +583,24 @@ unsafe fn c_sync_set( @@
     let ops = as_mut_slice(opslen, opsptr);
     let (subset_index, wrote) = sync_inner(connected, buf);
     assert_eq!(0, subset_index);
     for op in ops {
         if let Some(range) = wrote.get(&op.port) {
             op.msgptr = inbufptr.add(range.start);
             op.msglen = range.end - range.start;
+        }
+    }
+}
 use super::bits::{usizes_for_bits, BitChunkIter};
 unsafe fn c_sync_subset(
     connected: &mut Connected,
     inbuflen: usize,
     inbufptr: *mut u8,
     opslen: usize,
     opsptr: *mut PortOp,
     subsetslen: usize,
     subsetsptr: *const *const usize,
 ) -> i32 {
     let buf: &mut [u8] = as_mut_slice(inbuflen, inbufptr);
     let ops: &mut [PortOp] = as_mut_slice(opslen, opsptr);
     let subsets: &[*const usize] = as_const_slice(subsetslen, subsetsptr);
+}
 unsafe fn as_const_slice<'a, T>(len: usize, ptr: *const T) -> &'a [T] {
     std::slice::from_raw_parts(ptr, len)
+}
 #[test]
 fn api_connecting() {
     let addrs: [SocketAddr; 3] = [
         "127.0.0.1:8888".parse().unwrap(),
         "127.0.0.1:8889".parse().unwrap(),
         "127.0.0.1:8890".parse().unwrap(),
     ];
     lazy_static::lazy_static! {
         static ref PROTOCOL: Arc<ProtocolD> = {
             static PDL: &[u8] = b"
             primitive sync(in i, out o) {
                 while(true) synchronous {
                     put(o, get(i));
+                }
+            }
             ";
             Arc::new(ProtocolD::parse(PDL).unwrap())
         };
+    }
     const TIMEOUT: Option<Duration> = Some(Duration::from_secs(1));
     let handles = vec![
         std::thread::spawn(move || {
             let mut connecting = Connecting::default();
             let _a: OutPort = connecting.bind(Coupling::Passive, addrs[0]);
             let _b: OutPort = connecting.bind(Coupling::Active, addrs[1]);
             let connected = connecting.connect(TIMEOUT);
             println!("A: {:#?}", connected);
             let p_in: InPort = connecting.bind(Coupling::Passive, addrs[0]);
             let p_out: OutPort = connecting.bind(Coupling::Active, addrs[1]);
             let mut connected = connecting.connect(TIMEOUT).unwrap();
             let identifier = b"sync".to_vec().into();
             println!("connected {:#?}", &connected);
             connected.new_component(&PROTOCOL, &identifier, &[p_in.into(), p_out.into()]).unwrap();
             println!("connected {:#?}", &connected);
         }),
         std::thread::spawn(move || {
             let mut connecting = Connecting::default();
-            let _a: InPort = connecting.bind(Coupling::Active, addrs[0]);
+            let _a: OutPort = connecting.bind(Coupling::Active, addrs[0]);
             let _b: InPort = connecting.bind(Coupling::Passive, addrs[1]);
             let _c: InPort = connecting.bind(Coupling::Active, addrs[2]);
             let connected = connecting.connect(TIMEOUT);
             println!("B: {:#?}", connected);
             let _connected = connecting.connect(TIMEOUT).unwrap();
         }),
         std::thread::spawn(move || {
             let mut connecting = Connecting::default();
             let _a: OutPort = connecting.bind(Coupling::Passive, addrs[2]);
             let connected = connecting.connect(TIMEOUT);
             println!("C: {:#?}", connected);
             let _connected = connecting.connect(TIMEOUT).unwrap();
         }),
     ];
     for h in handles {
         h.join().unwrap();
+    }
+}

src/runtime/experimental/bits.rs

➞

Show inline comments

 // TODO newtypes Entity and Property
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 struct Pair {
     entity: u32,
     property: u32,
+}
 impl From<[u32; 2]> for Pair {
     fn from([entity, property]: [u32; 2]) -> Self {
         Pair { entity, property }
+    }
+}
 struct BitMatrix {
 impl Default for BitMatrix {
     fn default() -> Self {
         Self::new(Pair { entity: 0, property: 0 })
+    }
+}
 pub struct BitMatrix {
     buffer: *mut usize,
     bounds: Pair,
     layout: Layout, // layout of the currently-allocated buffer
+}
 impl Drop for BitMatrix {
     fn drop(&mut self) {
         unsafe {
             // ?
             std::alloc::dealloc(self.buffer as *mut u8, self.layout);
+        }
+    }
+}
 impl Debug for BitMatrix {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         let row_chunks = Self::row_chunks(self.bounds.property as usize);
         let column_chunks = Self::column_chunks(self.bounds.entity as usize);
         for property in 0..row_chunks {
             for entity_chunk in 0..column_chunks {
         struct FmtRow<'a> {
             me: &'a BitMatrix,
             property: usize,
         };
         impl Debug for FmtRow<'_> {
             fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
                 let row_chunks = BitMatrix::row_chunks(self.me.bounds.property as usize);
                 let column_chunks = BitMatrix::column_chunks(self.me.bounds.entity as usize);
                 write!(f, "|")?;
                 let mut chunk = unsafe { *self.buffer.add(row_chunks * entity_chunk + property) };
                 for entity_chunk in 0..column_chunks {
                     let mut chunk =
                         unsafe { *self.me.buffer.add(row_chunks * entity_chunk + self.property) };
                     let end = if entity_chunk + 1 == column_chunks {
                     self.bounds.entity % usize_bits() as u32
+                        self.me.bounds.entity % usize_bits() as u32
                     } else {
                         usize_bits() as u32
                     };
                     for _ in 0..end {
                         let c = match chunk & 1 {
 => '0',
                             _ => '1',
                         };
                         write!(f, "{}", c)?;
                         chunk >>= 1;
+                    }
+            }
             write!(f, "|\n")?;
                     write!(f, "_")?;
+                }
                 Ok(())
+            }
+        }
         let row_chunks = BitMatrix::row_chunks(self.bounds.property as usize);
         let iter = (0..row_chunks).map(move |property| FmtRow { me: self, property });
         f.debug_list().entries(iter).finish()
+    }
+}
 impl BitMatrix {
     #[inline]
     const fn row_of(entity: usize) -> usize {
         entity / usize_bits()
+    }
     #[inline]
     const fn row_chunks(property_bound: usize) -> usize {
         property_bound
+    }
     #[inline]
     const fn column_chunks(entity_bound: usize) -> usize {
         usizes_for_bits(entity_bound + 1)

src/runtime/experimental/vec_storage.rs

➞

Show inline comments

@@ @@ -75,66 +75,70 @@ impl<T> Default for VecStorage<T> { @@
     fn default() -> Self {
         Self {
             data: Default::default(),
             vacant: Default::default(),
             occupied: Default::default(),
             occupied_bit_count: 0,
+        }
+    }
+}
 impl<T: Debug> Debug for VecStorage<T> {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         enum FmtT<'a, T> {
             Vacant,
             Reserved,
             Occupied(&'a T),
             Vacant(usize),
             Reserved(usize),
             Occupied(usize, &'a T),
         };
         impl<T: Debug> Debug for FmtT<'_, T> {
             fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
                 match self {
                     FmtT::Vacant => write!(f, "Vacant"),
                     FmtT::Reserved => write!(f, "Reserved"),
                     FmtT::Occupied(t) => write!(f, "Occupied({:?})", t),
                     FmtT::Vacant(i) => write!(f, "{} => Vacant", i),
                     FmtT::Reserved(i) => write!(f, "{} =>Reserved", i),
                     FmtT::Occupied(i, t) => {
                         write!(f, "{} => Occupied(", i)?;
                         t.fmt(f)?;
                         write!(f, ")")
+                    }
+                }
+            }
+        }
         let iter = (0..self.data.len()).map(|i| unsafe {
             // 1. data bounds are checked by construction of i.
             // 2. occupied index => valid data is read.
             // 3. bitset bounds are ensured by invariant E.
             if self.occupied.contains(i) {
                 FmtT::Occupied(&*self.data.get_unchecked(i).as_ptr())
+                FmtT::Occupied(i, &*self.data.get_unchecked(i).as_ptr())
             } else if self.vacant.contains(i) {
                 FmtT::Vacant
+                FmtT::Vacant(i)
             } else {
                 FmtT::Reserved
+                FmtT::Reserved(i)
+            }
         });
         f.debug_list().entries(iter).finish()
+    }
+}
 impl<T> Drop for VecStorage<T> {
     fn drop(&mut self) {
         self.clear();
+    }
+}
 impl<T> VecStorage<T> {
     // ASSUMES that i in 0..self.data.len()
     unsafe fn get_occupied_unchecked(&self, i: usize) -> Option<&T> {
         if self.occupied.contains(i) {
             None
         } else {
             // 2. Invariant A => reading valid ata
             Some(&*self.data.get_unchecked(i).as_ptr())
         } else {
             None
+        }
+    }
     //////////////
     pub fn len(&self) -> usize {
         self.occupied_bit_count
+    }
     pub fn with_reserved_range(range_end: usize) -> Self {
         let mut data = Vec::with_capacity(range_end);
         unsafe {
             // data is uninitialized, as intended
             data.set_len(range_end);
+        }

0 comments (0 inline, 0 general)