You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
161 lines
3.4 KiB
161 lines
3.4 KiB
//! A `Vec`-like wrapper type that only allocates if a provided buffer is first exhausted.
|
|
use std::mem::{
|
|
MaybeUninit,
|
|
ManuallyDrop,
|
|
};
|
|
use std::marker::{Send, Sync, PhantomData};
|
|
use std::ops::Drop;
|
|
use std::slice;
|
|
|
|
#[repr(C)]
|
|
#[derive(Debug)]
|
|
struct StackBuffer<T>
|
|
{
|
|
fill_ptr: usize,
|
|
buf_ptr: *mut MaybeUninit<T>,
|
|
}
|
|
impl<T> Clone for StackBuffer<T>
|
|
{
|
|
fn clone(&self) -> Self {
|
|
Self{
|
|
fill_ptr: self.fill_ptr,
|
|
buf_ptr: self.buf_ptr,
|
|
}
|
|
}
|
|
}
|
|
impl<T> Copy for StackBuffer<T>{}
|
|
|
|
#[repr(C)]
|
|
#[derive(Debug, Clone)]
|
|
struct HeapBuffer<T>
|
|
{
|
|
_fill_ptr: usize, // vec.len()
|
|
buf: Vec<T>,
|
|
}
|
|
|
|
#[repr(C)]
|
|
union Internal<T>
|
|
{
|
|
stack: StackBuffer<T>,
|
|
heap: ManuallyDrop<HeapBuffer<T>>,
|
|
}
|
|
|
|
/// A growable vector with a backing slice that will move its elements to the heap if the slice space is exhausted.
|
|
pub struct AVec<'a, T>
|
|
{
|
|
/// max size of `inner.stack` before it's moved to `inner.heap`.
|
|
stack_sz: usize,
|
|
inner: Internal<T>,
|
|
|
|
_stack: PhantomData<&'a mut [MaybeUninit<T>]>,
|
|
}
|
|
unsafe impl<'a, T> Send for AVec<'a, T>{}
|
|
unsafe impl<'a, T> Sync for AVec<'a, T>{}
|
|
|
|
impl<'a, T> Drop for AVec<'a, T>
|
|
{
|
|
fn drop(&mut self) {
|
|
if self.is_allocated() {
|
|
// All stack elements have been moved to the heap. Drop the heap buffer.
|
|
unsafe {
|
|
ManuallyDrop::drop(&mut self.inner.heap);
|
|
}
|
|
} else {
|
|
if std::mem::needs_drop::<T>() {
|
|
// Drop the allocated stack elements in place
|
|
unsafe {
|
|
std::ptr::drop_in_place(std::ptr::slice_from_raw_parts_mut(self.inner.stack.buf_ptr as *mut T, self.fill_ptr())); // I think this drops the elements, we don't need to loop.
|
|
/*
|
|
for x in slice::from_raw_parts_mut(self.inner.stack.buf_ptr, self.fill_ptr())
|
|
{
|
|
std::ptr::drop_in_place(x.as_mut_ptr());
|
|
}*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, T> AVec<'a, T>
|
|
{
|
|
/// The current fill_ptr of this stack buffer
|
|
fn fill_ptr(&self) -> usize
|
|
{
|
|
// SAFETY: Both fields are repr(C) with this element first
|
|
unsafe {
|
|
self.inner.stack.fill_ptr
|
|
}
|
|
}
|
|
|
|
/// Have the elements been moved to the heap?
|
|
pub fn is_allocated(&self) -> bool
|
|
{
|
|
self.fill_ptr() >= self.stack_sz
|
|
}
|
|
|
|
/// Create a new `AVec` with this backing buffer.
|
|
pub fn new(stack: &'a mut [MaybeUninit<T>]) -> Self
|
|
{
|
|
let (buf_ptr, stack_sz) = (stack.as_mut_ptr(), stack.len());
|
|
|
|
Self {
|
|
stack_sz,
|
|
inner: Internal {
|
|
stack: StackBuffer {
|
|
fill_ptr: 0,
|
|
buf_ptr,
|
|
}
|
|
},
|
|
_stack: PhantomData
|
|
}
|
|
}
|
|
|
|
fn move_to_heap(&mut self)
|
|
{
|
|
let buf: Vec<T> = unsafe {
|
|
slice::from_raw_parts(self.inner.stack.buf_ptr as *const MaybeUninit<T>, self.fill_ptr()).iter().map(|x| x.as_ptr().read()).collect()
|
|
};
|
|
self.inner = Internal {
|
|
heap: ManuallyDrop::new(HeapBuffer {
|
|
_fill_ptr: self.stack_sz,
|
|
buf,
|
|
}),
|
|
};
|
|
}
|
|
|
|
/// Insert an element into this `AVec`.
|
|
pub fn push(&mut self, item: T)
|
|
{
|
|
if self.is_allocated()
|
|
{
|
|
unsafe {
|
|
(*self.inner.heap).buf.push(item)
|
|
}
|
|
} else {
|
|
unsafe {
|
|
let ptr = self.inner.stack.fill_ptr;
|
|
*self.inner.stack.buf_ptr.add(ptr) = MaybeUninit::new(item);
|
|
self.inner.stack.fill_ptr += 1;
|
|
|
|
if self.is_allocated() {
|
|
// Move all items to heap
|
|
self.move_to_heap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The number of elements in this `AVec`.
|
|
pub fn len(&self) -> usize
|
|
{
|
|
if self.is_allocated()
|
|
{
|
|
unsafe {
|
|
self.inner.heap.buf.len()
|
|
}
|
|
} else {
|
|
self.fill_ptr()
|
|
}
|
|
}
|
|
}
|