CSY/reowolf Changeset - 2591c0d940f8 · Centrum Wiskunde & Informatica (CWI)

Changeset - 2591c0d940f8

Parent rev.

Child rev.

[Not reviewed]

0 2 0

Christopher Esterhuyse - 5 years ago 2020-02-20 12:10:59
christopher.esterhuyse@gmail.com

one buffer, multiple ranges

2 files changed with 64 insertions and 11 deletions:

src/runtime/experimental/api.rs

src/runtime/experimental/bits.rs

0 comments (0 inline, 0 general)

src/runtime/experimental/api.rs

➞

Show inline comments

@@ @@ -175,25 +175,24 @@ impl Connected { @@
+    }
     pub fn sync_set(&mut self, _inbuf: &mut [u8], _ops: &mut [PortOpRs]) -> Result<(), ()> {
         Ok(())
+    }
     pub fn sync_subsets(
         &mut self,
         _inbuf: &mut [u8],
         _ops: &mut [PortOpRs],
         bit_subsets: &[&[usize]],
     ) -> Result<usize, ()> {
         for (batch_index, bit_subset) in bit_subsets.iter().enumerate() {
             println!("batch_index {:?}", batch_index);
             use super::bits::BitChunkIter;
             let chunk_iter = bit_subset.iter().copied();
             for index in BitChunkIter::new(chunk_iter) {
                 println!("  index {:?}", index);
+            }
+        }
         Ok(0)
+    }
+}
 macro_rules! bitslice {
     ($( $num:expr  ),*) => {{
         &[0 $( | (1usize << $num)  )*]
@@ @@ -224,21 +223,76 @@ fn api_new_test() { @@
 pub struct PortOp {
     msgptr: *mut u8, // read if OUT, field written if IN, will point into buf
     msglen: usize,   // read if OUT, written if IN, won't exceed buf
     port: Port,
     optional: bool, // no meaning if
+}
 pub enum PortOpRs<'a> {
     In { msg_range: Option<Range<usize>>, port: &'a InPort },
     Out { msg: &'a [u8], port: &'a OutPort, optional: bool },
+}
 fn c_sync_set(
+unsafe fn c_sync_set(
     connected: &mut Connected,
     inbuflen: usize,
-    inbuf: *mut u8,
+    inbufptr: *mut u8,
     opslen: usize,
-    ops: *mut PortOp,
+    opsptr: *mut PortOp,
 ) -> i32 {
     let buf = as_mut_slice(inbuflen, inbufptr);
     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);
     let subsetlen = usizes_for_bits(opslen);
     // don't yet know subsetptr; which subset fires unknown!
     let (subset_index, wrote) = sync_inner(connected, buf);
     let subsetptr: *const usize = subsets[subset_index];
     let subset: &[usize] = as_const_slice(subsetlen, subsetptr);
     for index in BitChunkIter::new(subset.iter().copied()) {
         let op = &mut ops[index as usize];
         if let Some(range) = wrote.get(&op.port) {
             op.msgptr = inbufptr.add(range.start);
             op.msglen = range.end - range.start;
+        }
+    }
     subset_index as i32
+}
 // dummy fn for the actual synchronous round
 fn sync_inner<'c, 'b>(
     _connected: &'c mut Connected,
     _buf: &'b mut [u8],
 ) -> (usize, &'b HashMap<Port, Range<usize>>) {
     todo!()
+}
 unsafe fn as_mut_slice<'a, T>(len: usize, ptr: *mut T) -> &'a mut [T] {
     std::slice::from_raw_parts_mut(ptr, len)
+}
 unsafe fn as_const_slice<'a, T>(len: usize, ptr: *const T) -> &'a [T] {
     std::slice::from_raw_parts(ptr, len)
+}

src/runtime/experimental/bits.rs

➞

Show inline comments

 use crate::common::*;
 /// Given an iterator over BitChunk Items, iterates over the indices (each represented as a u32) for which the bit is SET,
 /// treating the bits in the BitChunk as a contiguous array.
 /// e.g. input [0b111000, 0b11] gives output [3, 4, 5, 32, 33].
 /// observe that the bits per chunk are ordered from least to most significant bits, yielding smaller to larger usizes.
 /// assumes chunk_iter will yield no more than std::u32::MAX / 32 chunks
 const fn usize_bytes() -> usize {
+pub const fn usize_bytes() -> usize {
     std::mem::size_of::<usize>()
+}
 const fn usize_bits() -> usize {
+pub const fn usize_bits() -> usize {
     usize_bytes() * 8
+}
 pub const fn usizes_for_bits(bits: usize) -> usize {
     (bits + (usize_bits() - 1)) / usize_bits()
+}
 pub(crate) struct BitChunkIter<I: Iterator<Item = usize>> {
     cached: usize,
     chunk_iter: I,
     next_bit_index: u32,
+}
 impl<I: Iterator<Item = usize>> BitChunkIter<I> {
     pub fn new(chunk_iter: I) -> Self {
         // first chunk is always a dummy zero, as if chunk_iter yielded Some(FALSE).
         // Consequences:
         // 1. our next_bit_index is always off by usize_bits() (we correct for it in Self::next) (no additional overhead)
         // 2. we cache usize and not Option<usize>, because chunk_iter.next() is only called in Self::next.
@@ @@ -136,39 +139,35 @@ impl Debug for BitMatrix { @@
                         _ => '1',
                     };
                     write!(f, "{}", c)?;
                     chunk >>= 1;
+                }
+            }
             write!(f, "|\n")?;
+        }
         Ok(())
+    }
+}
 impl BitMatrix {
     #[inline]
     const fn chunk_len_ceil(value: usize) -> usize {
         (value + usize_bits() - 1) & !(usize_bits() - 1)
+    }
     #[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 {
-        Self::chunk_len_ceil(entity_bound) / usize_bits()
+        usizes_for_bits(entity_bound + 1)
+    }
     #[inline]
     fn offsets_unchecked(&self, at: Pair) -> [usize; 2] {
         let o_in = at.entity as usize % usize_bits();
         let row = Self::row_of(at.entity as usize);
         let row_chunks = self.bounds.property as usize;
         let o_of = row * row_chunks + at.property as usize;
         [o_of, o_in]
+    }
     // returns a u32 which has bits 000...000111...111
     // for the last JAGGED chunk given the column size
     // if the last chunk is not jagged (when entity_bound % 32 == 0)

0 comments (0 inline, 0 general)