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

@@ @@ -181,13 +181,12 @@ impl Connected { @@
         _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)
@@ @@ -230,15 +229,70 @@ pub struct PortOp { @@
 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

@@ @@ -3,18 +3,21 @@ 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,
+}
@@ @@ -142,27 +145,23 @@ impl Debug for BitMatrix { @@
             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;

0 comments (0 inline, 0 general)