use strict provenance

Author: tomtomwombat

.github/workflows/rust.yml

@@ -32,7 +32,7 @@ jobs:
           rustup component add miri --toolchain nightly
     - name: Run Miri
       run: |
-          cargo +nightly miri test --manifest-path cold-string/Cargo.toml --test property
+          cargo +nightly miri test --manifest-path cold-string/Cargo.toml
     - name: Run Miri Unknown
       run: |
-          cargo +nightly miri test --manifest-path cold-string/Cargo.toml --test property --target mips-unknown-linux-gnu
+          cargo +nightly miri test --manifest-path cold-string/Cargo.toml --target mips-unknown-linux-gnu

Cargo.lock

@@ -98,36 +98,12 @@ fn bench_hash(c: &mut Criterion) {
     group.finish();
 }
 
-/*
-fn bench_eq(c: &mut Criterion) {
-    let cold1 = ColdString::from(LONG);
-    let cold2 = ColdString::from(LONG);
-
-    let string1 = String::from(LONG);
-    let string2 = String::from(LONG);
-
-    let mut group = c.benchmark_group("eq");
-
-    group.bench_function("ColdString eq", |b| {
-        b.iter(|| black_box(&cold1 == &cold2))
-    });
-
-    group.bench_function("String eq", |b| {
-        b.iter(|| black_box(&string1 == &string2))
-    });
-
-    group.finish();
-}
-*/
-
 fn bench_clone(c: &mut Criterion) {
     let cold = ColdString::from(LONG);
     let string = String::from(LONG);
 
     let mut group = c.benchmark_group("clone");
-
     group.bench_function("ColdString clone", |b| b.iter(|| black_box(cold.clone())));
-
     group.bench_function("String clone", |b| b.iter(|| black_box(string.clone())));
 
     group.finish();
@@ -139,7 +115,6 @@ criterion_group!(
     bench_len,
     bench_as_str,
     bench_hash,
-    // bench_eq,
     bench_clone
 );
 criterion_main!(benches);

bench/benches/bench.rs

@@ -71,7 +71,7 @@ where
 
 fn bench_eq(c: &mut Criterion) {
     bench_eq_type::<ColdString>(c, "ColdString_eq");
-    //bench_eq_type::<String>(c, "String_eq");
+    bench_eq_type::<String>(c, "String_eq");
 }
 
 criterion_group!(benches, bench_eq);

bench/benches/eq.rs

@@ -1,7 +1,7 @@
 [package]
 name = "cold-string"
 version = "0.1.0"
-edition = "2021"
+edition = "2018"
 rust-version = "1.60.0"
 authors = ["tomtomwombat"]
 description = "A 1-word SSO string that saves up to 24 bytes over String."
@@ -16,14 +16,15 @@ readme = "README.md"
 maintenance = { status = "actively-developed" }
 
 [features]
-default = ["std"]
-std = []
-serde = ["dep:serde"]
+default = []
+serde = ["dep:serde", "serde/alloc"]
 
 [dependencies]
-serde = { version = "1.0.228", optional = true }
+serde = { version = "1.0.228", optional = true, default-features = false }
+sptr = { version = "0.3.2", default-features = false }
 rustversion = "1.0.22"
 
 [dev-dependencies]
+hashbrown = "0.12.3"
 serde_test = "1.0.177"
 proptest = {version = "=1.8.0", default-features = false, features = ["std", "bit-set"] }

cold-string/Cargo.lock

@@ -5,7 +5,7 @@
 ![MSRV](https://img.shields.io/crates/msrv/cold-string?style=for-the-badge)
 ![Downloads](https://img.shields.io/crates/d/cold-string?style=for-the-badge)
 
-Compact representation of immutable UTF-8 strings. Optimized for memory usage and struct packing.
+A 1-word sized representation of immutable UTF-8 strings. In-lines up to 1 word bytes. Optimized for memory usage and struct packing.
 
 # Usage
 
@@ -22,29 +22,37 @@ Packs well with other types:
 use std::mem;
 use cold_string::ColdString;
 
-assert_eq!(mem::size_of::<ColdString>(), 8);
+assert_eq!(mem::size_of::<ColdString>(), mem::size_of::<usize>());
 assert_eq!(mem::align_of::<ColdString>(), 1);
 
-assert_eq!(mem::size_of::<(ColdString, u8)>(), 9);
+assert_eq!(mem::size_of::<(ColdString, u8)>(), mem::size_of::<usize>() + 1);
 assert_eq!(mem::align_of::<(ColdString, u8)>(), 1);
 ```
 
 # How It Works
 
-ColdString is an 8 byte array (4 bytes on 32-bit machines):
-```rust,ignore
-pub struct ColdString([u8; 8]);
+ColdString is 8-byte tagged pointer (4 bytes on 32-bit machines):
+```rust
+#[repr(packed)]
+pub struct ColdString {
+    /// The first byte of `encoded` is the "tag" and it determines the type:
+    /// - 10xxxxxx: an encoded address for the heap. To decode, 10 is set to 00 and swapped
+    ///   with the LSB bits of the tag byte. The address is always a multiple of 4 (`HEAP_ALIGN`).
+    /// - 11111xxx: xxx is the length in range 0..=7, followed by length UTF-8 bytes.
+    /// - xxxxxxxx (valid UTF-8): 8 UTF-8 bytes.
+    encoded: *mut u8,
+}
 ```
-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:
+`encoded` acts as either a pointer to the heap for strings longer than 8 bytes or is the inlined data itself. The first/"tag" 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.
+The tag 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.
+The tag byte is any valid UTF-8 byte. `self.0` stores the bytes of string. Since the string is UTF-8, the tag byte is guaranteed to not be 10xxxxx or 11111xxx.
 
 ## Heap Mode
-`self.0` encodes the 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.
+`self.0` encodes the pointer to heap, where tag byte is 10xxxxxx. 10xxxxxx is chosen because it's a UTF-8 continuation byte and therefore an impossible tag 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