use latch::Latch;
use std::any::Any;
use std::cell::UnsafeCell;
use std::mem;
use unwind;
use tlv;
pub enum JobResult<T> {
None,
Ok(T),
Panic(Box<Any + Send>),
}
pub trait Job {
unsafe fn execute(this: *const Self);
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct JobRef {
pointer: *const (),
execute_fn: unsafe fn(*const ()),
}
unsafe impl Send for JobRef {}
unsafe impl Sync for JobRef {}
impl JobRef {
pub unsafe fn new<T>(data: *const T) -> JobRef
where
T: Job,
{
let fn_ptr: unsafe fn(*const T) = <T as Job>::execute;
let fn_ptr: unsafe fn(*const ()) = mem::transmute(fn_ptr);
let pointer = data as *const ();
JobRef {
pointer: pointer,
execute_fn: fn_ptr,
}
}
#[inline]
pub unsafe fn execute(&self) {
(self.execute_fn)(self.pointer)
}
}
pub struct StackJob<L, F, R>
where
L: Latch + Sync,
F: FnOnce(bool) -> R + Send,
R: Send,
{
pub latch: L,
func: UnsafeCell<Option<F>>,
result: UnsafeCell<JobResult<R>>,
tlv: usize,
}
impl<L, F, R> StackJob<L, F, R>
where
L: Latch + Sync,
F: FnOnce(bool) -> R + Send,
R: Send,
{
pub fn new(tlv: usize, func: F, latch: L) -> StackJob<L, F, R> {
StackJob {
latch: latch,
func: UnsafeCell::new(Some(func)),
result: UnsafeCell::new(JobResult::None),
tlv,
}
}
pub unsafe fn as_job_ref(&self) -> JobRef {
JobRef::new(self)
}
pub unsafe fn run_inline(self, stolen: bool) -> R {
self.func.into_inner().unwrap()(stolen)
}
pub unsafe fn into_result(self) -> R {
self.result.into_inner().into_return_value()
}
}
impl<L, F, R> Job for StackJob<L, F, R>
where
L: Latch + Sync,
F: FnOnce(bool) -> R + Send,
R: Send,
{
unsafe fn execute(this: *const Self) {
let this = &*this;
tlv::set(this.tlv);
let abort = unwind::AbortIfPanic;
let func = (*this.func.get()).take().unwrap();
(*this.result.get()) = match unwind::halt_unwinding(|| func(true)) {
Ok(x) => JobResult::Ok(x),
Err(x) => JobResult::Panic(x),
};
this.latch.set();
mem::forget(abort);
}
}
pub struct HeapJob<BODY>
where
BODY: FnOnce() + Send,
{
job: UnsafeCell<Option<BODY>>,
tlv: usize,
}
impl<BODY> HeapJob<BODY>
where
BODY: FnOnce() + Send,
{
pub fn new(tlv: usize, func: BODY) -> Self {
HeapJob {
job: UnsafeCell::new(Some(func)),
tlv,
}
}
pub unsafe fn as_job_ref(self: Box<Self>) -> JobRef {
let this: *const Self = mem::transmute(self);
JobRef::new(this)
}
}
impl<BODY> Job for HeapJob<BODY>
where
BODY: FnOnce() + Send,
{
unsafe fn execute(this: *const Self) {
let this: Box<Self> = mem::transmute(this);
tlv::set(this.tlv);
let job = (*this.job.get()).take().unwrap();
job();
}
}
impl<T> JobResult<T> {
pub fn into_return_value(self) -> T {
match self {
JobResult::None => unreachable!(),
JobResult::Ok(x) => x,
JobResult::Panic(x) => unwind::resume_unwinding(x),
}
}
}