src: Implement a pool allocator for execution stacks

Author: solb

src/lib.rs

@@ -12,6 +12,7 @@ mod preemption;
 pub mod profiler;
 mod reusable;
 mod signals;
+mod stacks;
 mod timer;
 mod unfurl;
 

src/linger.rs

@@ -7,8 +7,8 @@ use reusable::ReusableSync;
 use signal::Set;
 use signal::Signal;
 use signal::siginfo_t;
+use stacks::DerefAdapter;
 use super::QUANTUM_MICROSECS;
-use super::STACK_SIZE_BYTES;
 use std::cell::Cell;
 use std::cell::RefCell;
 use std::io::Result;
@@ -87,7 +87,7 @@ struct Task {
 	//  * None at end of resume() means it has completed.
 	//  * Some at either point means it timed out and is currently paused.
 	errno: Option<c_int>,
-	checkpoint: Option<Context<Box<[u8]>>>,
+	checkpoint: Option<Context<DerefAdapter<'static, ReusableSync<'static, Box<[u8]>>>>>,
 	yielded: bool,
 }
 
@@ -153,7 +153,7 @@ pub fn launch<T: Send>(fun: impl FnOnce() -> T + Send, us: u64)
 		}
 	});
 
-	let checkpoint = setup_stack(STACK_SIZE_BYTES)?;
+	let checkpoint = setup_stack()?;
 	let mut linger = Linger::Continuation(Continuation {
 		functional: fun,
 		stateful: Task {
@@ -232,12 +232,14 @@ pub fn resume<T>(fun: &mut Linger<T, impl FnMut(*mut Option<ThdResult<T>>) + Sen
 
 /// Set up the oneshot execution stack.  Always returns a Some when things are Ok.
 #[inline(never)]
-fn setup_stack(bytes: usize) -> Result<Option<Context<Box<[u8]>>>> {
+fn setup_stack()
+-> Result<Option<Context<DerefAdapter<'static, ReusableSync<'static, Box<[u8]>>>>>> {
+	use stacks::alloc_stack;
 	use timetravel::makecontext;
 
 	let mut checkpoint = None;
 	makecontext(
-		vec![0; bytes].into_boxed_slice(),
+		DerefAdapter::from(alloc_stack()),
 		|goto| drop(checkpoint.replace(goto)),
 		schedule,
 	)?;

src/stacks.rs

@@ -0,0 +1,53 @@
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::ops::DerefMut;
+use super::STACK_SIZE_BYTES;
+use timetravel::stable::StableAddr;
+use timetravel::stable::StableMutAddr;
+use reusable::ReusableSync;
+
+pub fn alloc_stack() -> ReusableSync<'static, Box<[u8]>> {
+	use compile_assert::assert_sync;
+	use reusable::SyncPool;
+	use std::convert::TryInto;
+	use std::sync::Once;
+
+	static mut STACKS: Option<SyncPool<Box<[u8]>>> = None;
+	static INIT: Once = Once::new();
+	INIT.call_once(|| unsafe {
+		STACKS.replace(SyncPool::new(|| Some(vec![0; STACK_SIZE_BYTES].into_boxed_slice())));
+	});
+
+	let stacks = unsafe {
+		STACKS.as_ref()
+	}.unwrap();
+	assert_sync(&stacks);
+	stacks.try_into().expect("libinger: stack allocator lock is poisoned")
+}
+
+pub struct DerefAdapter<'a, T> (T, PhantomData<&'a ()>);
+
+impl<T> From<T> for DerefAdapter<'_, T> {
+	fn from(t: T) -> Self {
+		Self (t, PhantomData::default())
+	}
+}
+
+impl<'a, T: Deref<Target = U>, U: Deref<Target = V> + 'a, V: ?Sized> Deref for DerefAdapter<'a, T> {
+	type Target = V;
+
+	fn deref(&self) -> &Self::Target {
+		let Self (t, _) = self;
+		&***t
+	}
+}
+
+impl<'a, T: DerefMut<Target = U>, U: DerefMut<Target = V> + 'a, V: ?Sized> DerefMut for DerefAdapter<'a, T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		let Self (t, _) = self;
+		&mut ***t
+	}
+}
+
+unsafe impl<'a, T: Deref<Target = U>, U: StableAddr + 'a> StableAddr for DerefAdapter<'a, T> {}
+unsafe impl<'a, T: DerefMut<Target = U>, U: StableMutAddr + 'a> StableMutAddr for DerefAdapter<'a, T> {}