jets-bench: fix multiple issues with Ctx8 encoding

* changes `var_len_buf_from_slice` to interpret its `n` such that it's
  reading the type (2^8)^<2^n rather than (2^8)^<2^(n+1); subtract 1
  from all instances of `n` except the loop counter. (Previously we
  were looping the wrong number of times, which this fixes.)
* calls `var_len_buf_from_slice` with n = 6, which matches the type
  signature for Ctx8. Before we were calling with n = 8 which was just
  wrong
* Changes `SimplicityCtx8::buffer` to have type `[u8; 64]` instead of
  the wrong `[u8; 512]`
* Changes the nonsense "v.len() >= 1 << n" comparison to one that checks
  the bits of v.len()
* Corrects various off-by-one errors

See #318 for more information.

Author: apoelstra

jets-bench/src/data_structures.rs

@@ -18,7 +18,7 @@ use simplicity::{
 /// length.
 #[derive(Clone)]
 pub struct SimplicityCtx8 {
-    buffer: [u8; 512],
+    buffer: [u8; 64],
     h: [u32; 8],
     length: usize,
 }
@@ -31,7 +31,7 @@ impl Default for SimplicityCtx8 {
                 0x5be0cd19,
             ],
             length: 0,
-            buffer: [0; 512],
+            buffer: [0; 64],
         }
     }
 }
@@ -45,24 +45,25 @@ impl SimplicityCtx8 {
     }
 }
 
-/// Read bytes from a Simplicity buffer of type (TWO^8)^<2^(n+1) as [`Value`].
+/// Read bytes from a Simplicity buffer of type (TWO^8)^<2^n as [`Value`].
 /// The notation X^<2 is notation for the type (S X)
 /// The notation X^<(2*n) is notation for the type S (X^n) * X^<n
 ///
-/// Cannot represent >= 2**16 bytes 0 <= n < 16 as simplicity consensus rule.
+/// Cannot represent >= 2**16 bytes 0 <= n < 16; higher values are unused
+/// by the current set of jets and would cause trouble on 16-bit machines
+/// that we'd rather not think about.
 ///
 /// # Panics:
 ///
-/// Panics if the length of the slice is >= 2^(n + 1) bytes
+/// Panics if the length of the slice is >= 2^n bytes, or if n >= 16.
 pub fn var_len_buf_from_slice(v: &[u8], mut n: usize) -> Result<Value, EarlyEndOfStreamError> {
-    // Simplicity consensus rule for n < 16 while reading buffers.
     assert!(n < 16);
-    assert!(v.len() < (1 << (n + 1)));
+    assert!(v.len() < 1 << n);
     let mut iter = BitIter::new(v.iter().copied());
     let mut res = None;
     while n > 0 {
-        let ty = Final::two_two_n(n);
-        let v = if v.len() >= (1 << (n + 1)) {
+        let ty = Final::two_two_n(n + 2);
+        let v = if v.len() & 1 << (n - 1) != 0 {
             let val = Value::from_compact_bits(&mut iter, &ty)?;
             Value::some(val)
         } else {
@@ -74,6 +75,7 @@ pub fn var_len_buf_from_slice(v: &[u8], mut n: usize) -> Result<Value, EarlyEndO
         };
         n -= 1;
     }
+    assert_eq!(iter.next(), None);
     Ok(res.unwrap_or(Value::unit()))
 }
 
@@ -157,8 +159,8 @@ pub trait SimplicityEncode {
 
 impl SimplicityEncode for SimplicityCtx8 {
     fn value(&self) -> Value {
-        let buf_len = self.length % 512;
-        let buf = var_len_buf_from_slice(&self.buffer[..buf_len], 8).unwrap();
+        let buf_len = self.length % 64;
+        let buf = var_len_buf_from_slice(&self.buffer[..buf_len], 6).unwrap();
         let len = Value::u64(self.length as u64);
         // convert to 32 byte array
         let mut arr = [0u8; 32];