Stele is a Single Writer, Many Reader append-only concurrent data structure with opt-in support for no_std and the Allocator API
Stele is, in essence, an array of exponentially larger arrays, where the nth element of the outer array holds 2n elements. This is accomplished by taking a given index and splitting it in to two indices:
An outer index that is the log2 of the index rounded down. This is which outer array pointer holds the requested data.
An inner index that is the difference of the input index and the outer index. This is the offset from the pointer given by the outer array to the element pointed to by the index.
The tradeoff is memory usage, as the data structure has to hold an array of 32 pointers. For example, on a 64 bit system, the outer array holds 32 8-byte pointers, using 256 bytes of memory, even without any allocation.
```rust use std::thread; use stele::{Stele, ReadHandle, WriteHandle};
fn example() {
//Writers are only Send and not Sync to ensure memory safety and avoid races
let (writer, reader1) = Stele::new();
//Read handles are clone
let reader2 = reader1.clone();
//If you don't have any read handles left, you can create a new one from the write handle.
let reader3 = writer.newreadhandle();
assert!(writer.isempty());
writer.push(42);
asserteq!(writer.len(), 1);
let t1 = thread::spawn(move || {
// For most types, reads can only return references
asserteq!(reader1.read(1), &42)
});
let t2 = thread::spawn(move || {
//Readers also support indexing
asserteq!(reader2[1], 42)
});
let t3 = thread::spawn(move || {
//Supports fallible indexing via try_read
assert!(reader3.tryread(2).isnone())
});
//Copy types can be copied out using get
let copied = writer.get(1);
assert_eq!(copied, 42);
}
```
Without the allocator api, MSRV is 1.64
As of 2023-03-12, the allocator api requires nightly and does not have a stable version. Once the allocator api is supported on stable this will be replaced with said stable version