Inline 8 bytes: #1

Author: tomtomwombat

README.md

@@ -34,17 +34,18 @@ ColdString is an 8 byte array (4 bytes on 32-bit machines):
 ```rust,ignore
 pub struct ColdString([u8; 8]);
 ```
-The array acts as either a pointer to heap data for strings longer than 7 bytes or is the inlined data itself.
-## Inline Mode
-`self.0[1]` to `self.0[7]` store the bytes of string. In the least significant byte, `self.0[0]`, the least significant bit signifies the inline/heap flag, and is set to "1" for inline mode. The next bits encode the length (always between 0 and 7).
-```text,ignore
-b0 b1 b2 b3 b4 b5 b6 b7
-b0 = <7 bit len> | 1
-```
-For example, `"qwerty" = [13, 'q', 'w', 'e', 'r', 't', 'y', 0]`, where 13 is `"qwerty".len() << 1 | 1`.
+The array acts as either a pointer to heap data for strings longer than 8 bytes or is the inlined data itself. The first byte indicates one of 3 encodings:
+
+## Inline Mode (0 to 7 Bytes)
+The first byte has bits 11111xxx, where xxx is the length. `self.0[1]` to `self.0[7]` store the bytes of string.
+
+## Inline Mode (8 Bytes)
+`self.0` stores the bytes of string. Since the string is UTF-8, the first byte is guaranteed to not be 10xxxxx or 11111xxx.
 
 ## Heap Mode
-The bytes act as a pointer to heap. The data on the heap has alignment 2, causing the least significant bit to always be 0 (since alignment 2 implies `addr % 2 == 0`), signifying heap mode. On the heap, the data starts with a variable length integer encoding of the length, followed by the bytes.
+`self.0` are an encoded pointer to heap, where first byte is 10xxxxxx. 10xxxxxx is chosen because it's a UTF-8 continuation byte and therefore an impossible first byte for inline mode. Since a heap-alignment of 4 is chosen, the pointer's least significant 2 bits are guaranteed to be 0 ([See more](https://doc.rust-lang.org/beta/std/alloc/struct.Layout.html#method.from_size_align)). These bits are swapped with the 10 "tag" bits when de/coding between `self.0` and the address value.
+
+On the heap, the data starts with a variable length integer encoding of the length, followed by the bytes.
 ```text,ignore
 ptr --> <var int length> <data>
 ```
@@ -61,7 +62,7 @@ ptr --> <var int length> <data>
 | `smol_str` | 24.0 B | 24.0 B | 24.0 B | 41.1 B | 72.2 B |
 | `compact_str` | 24.0 B | 24.0 B | 24.0 B | 35.4 B | 61.0 B |
 | `compact_string` | 24.1 B | 25.8 B | 32.6 B | 40.5 B | 56.5 B |
-| **`cold-string`** | **8.0 B** | **11.2 B** | **24.9 B** | **36.5 B** | **53.5 B** |
+| **`cold-string`** | **8.0 B** | **8.0 B** | **23.2 B** | **35.7 B** | **53.0 B** |
 
 **Note:** Columns represent string length (bytes/chars). Values represent average Resident Set Size (RSS) in bytes per string instance. Measurements taken with 10M iterations.
 

src/lib.rs

@@ -21,7 +21,7 @@ use core::{
 mod vint;
 use crate::vint::VarInt;
 
-const HEAP_ALIGN: usize = 2;
+const HEAP_ALIGN: usize = 4;
 const WIDTH: usize = mem::size_of::<usize>();
 
 /// Compact representation of immutable UTF-8 strings. Optimized for memory usage and struct packing.
@@ -100,27 +100,30 @@ impl ColdString {
     /// If the string is short enough, then it will be inlined on the stack.
     pub fn new<T: AsRef<str>>(x: T) -> Self {
         let s = x.as_ref();
-        if s.len() < WIDTH {
+        if s.len() <= WIDTH {
             Self::new_inline(s)
         } else {
             Self::new_heap(s)
         }
     }
 
+    /// Returns `true` if the string bytes are inlined.
     #[inline]
-    const fn is_inline(&self) -> bool {
-        self.0[0] & 1 == 1
+    pub const fn is_inline(&self) -> bool {
+        (self.0[0] & 0b11000000) != 0b10000000
     }
 
     #[inline]
     const fn new_inline(s: &str) -> Self {
-        debug_assert!(s.len() < WIDTH);
+        debug_assert!(s.len() <= WIDTH);
         let mut buf = [0u8; WIDTH];
         unsafe {
-            let dest_ptr = buf.as_mut_ptr().add(1);
+            let dest_ptr = buf.as_mut_ptr().add((s.len() < WIDTH) as usize);
             ptr::copy_nonoverlapping(s.as_ptr(), dest_ptr, s.len());
         }
-        buf[0] = ((s.len() as u8) << 1) | 1;
+        if s.len() < WIDTH {
+            buf[0] = 0b11111000 | (s.len() as u8);
+        }
         Self(buf)
     }
 
@@ -144,22 +147,28 @@ impl ColdString {
 
             let addr = ptr.expose_provenance();
             debug_assert!(addr % 2 == 0);
+            let mut addr = addr.rotate_left(6);
+            addr |= 0b10000000;
             Self(addr.to_le_bytes())
         }
     }
 
     #[inline]
     fn heap_ptr(&self) -> *mut u8 {
-        // Can be const in 1.91
         debug_assert!(!self.is_inline());
-        let addr = usize::from_le_bytes(self.0);
+        let mut addr = usize::from_le_bytes(self.0);
+        addr ^= 0b10000000;
+        let addr = addr.rotate_right(6);
         debug_assert!(addr % 2 == 0);
-        with_exposed_provenance_mut::<u8>(addr)
+        with_exposed_provenance_mut::<u8>(addr) // const in 1.91
     }
 
     #[inline]
     const fn inline_len(&self) -> usize {
-        self.0[0] as usize >> 1
+        match self.0[0] & 0b11111000 {
+            0b11111000 => (self.0[0] & 0b00000111) as usize,
+            _ => 8,
+        }
     }
 
     /// Returns the length of this `ColdString`, in bytes, not [`char`]s or
@@ -195,7 +204,7 @@ impl ColdString {
     #[inline]
     unsafe fn decode_inline(&self) -> &[u8] {
         let len = self.inline_len();
-        let ptr = self.0.as_ptr().add(1);
+        let ptr = self.0.as_ptr().add((len < WIDTH) as usize);
         slice::from_raw_parts(ptr, len)
     }
 
@@ -433,11 +442,11 @@ mod tests {
 
     #[test]
     fn it_works() {
-        for s in ["test", "", "1234567", "longer test"] {
+        for s in ["test", "", "1234567", "12345678", "longer test"] {
             let cs = ColdString::new(s);
-            assert_eq!(cs.as_str(), s);
+            assert_eq!(s.len() <= 8, cs.is_inline());
             assert_eq!(cs.len(), s.len());
-            assert_eq!(cs.len() < 8, cs.is_inline());
+            assert_eq!(cs.as_str(), s);
             assert_eq!(cs.clone(), cs);
             #[cfg(feature = "std")]
             {
@@ -451,4 +460,18 @@ mod tests {
             assert_eq!(*s, cs);
         }
     }
+
+    #[test]
+    fn test_regression() {
+        for s in [
+            str::from_utf8(&[103, 39, 240, 145, 167, 156, 194, 165]).unwrap(),
+            "AaAa0 ® ",
+            str::from_utf8(&[240, 158, 186, 128, 240, 145, 143, 151]).unwrap(),
+        ] {
+            let cs = ColdString::new(s);
+            assert_eq!(s.len() <= 8, cs.is_inline());
+            assert_eq!(s.len(), cs.len());
+            assert_eq!(cs.as_str(), s);
+        }
+    }
 }

tests/property.proptest-regressions

@@ -0,0 +1,8 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc cdedf38c4537d00fabcf8d676be43279a12ad39216d111c1e40f877bf44a8e01 # shrinks to s = "AaAa0 ® "
+cc 9f00d39889fa4d629320694a19a244655e9ab8dbe399ad7a9dbb9ce34b7f3d2c # shrinks to s = "𞺀𑏗"

tests/property.rs

@@ -32,6 +32,7 @@ proptest! {
     #[test]
     fn arb_string(s in any::<String>()) {
         let cold = ColdString::new(s.as_str());
+        assert_eq!(s.len() <= 8, cold.is_inline());
         assert_eq!(cold.len(), s.len());
         assert_eq!(cold.as_str(), s.as_str());
         assert_eq!(cold, ColdString::from(s.as_str()));