use crate::coroutine::context;
#[cfg(target_arch = "wasm32")]
use instant::{Duration, Instant};
use intuicio_data::managed::{DynamicManagedLazy, ManagedLazy};
#[cfg(not(target_arch = "wasm32"))]
use std::time::{Duration, Instant};
use std::{
collections::{HashMap, HashSet, LinkedList},
error::Error,
hash::{DefaultHasher, Hash, Hasher},
pin::Pin,
sync::{
Arc, Condvar, Mutex, RwLock,
atomic::{AtomicBool, Ordering},
mpsc::{Receiver, Sender},
},
task::{Context, Poll, RawWaker, RawWakerVTable, Wake, Waker},
thread::{JoinHandle, ThreadId, available_parallelism, spawn},
};
use typid::ID;
#[derive(Default, Clone)]
pub struct JobOptions {
pub location: JobLocation,
pub priority: JobPriority,
pub meta: HashMap<String, DynamicManagedLazy>,
}
impl JobOptions {
pub fn location(mut self, location: JobLocation) -> Self {
self.location = location;
self
}
pub fn priority(mut self, priority: JobPriority) -> Self {
self.priority = priority;
self
}
pub fn meta(mut self, name: impl ToString, value: DynamicManagedLazy) -> Self {
self.meta.insert(name.to_string(), value);
self
}
pub fn meta_many(
mut self,
meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) -> Self {
self.meta.extend(meta);
self
}
}
impl From<()> for JobOptions {
fn from(_: ()) -> Self {
Default::default()
}
}
impl From<JobLocation> for JobOptions {
fn from(location: JobLocation) -> Self {
Self {
location,
..Default::default()
}
}
}
impl From<JobPriority> for JobOptions {
fn from(priority: JobPriority) -> Self {
Self {
priority,
..Default::default()
}
}
}
impl From<(JobLocation, JobPriority)> for JobOptions {
fn from((location, priority): (JobLocation, JobPriority)) -> Self {
Self {
location,
priority,
..Default::default()
}
}
}
pub(crate) struct Job(pub(crate) Pin<Box<dyn Future<Output = ()> + Send + Sync>>);
impl Job {
fn poll(
mut self,
cx: &mut Context<'_>,
#[cfg(debug_assertions)] creation_backtrace: &str,
) -> Option<Self> {
let poll_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
match self.0.as_mut().poll(cx) {
Poll::Ready(_) => None,
Poll::Pending => Some(self),
}
}));
match poll_result {
Ok(result) => result,
Err(_err) => {
#[cfg(debug_assertions)]
{
tracing::error!("Job panicked! Creation backtrace:\n{}", creation_backtrace);
if let Some(s) = _err.downcast_ref::<&str>() {
tracing::error!("Panic info: {}", s);
} else if let Some(s) = _err.downcast_ref::<String>() {
tracing::error!("Panic info: {}", s);
} else if let Some(e) = _err.downcast_ref::<Box<dyn std::error::Error>>() {
tracing::error!("Panic error: {}", e);
}
}
None
}
}
}
}
#[inline]
fn traced_spin_loop() {
#[cfg(feature = "deadlock-trace")]
println!(
"* DEADLOCK BACKTRACE: {}",
std::backtrace::Backtrace::force_capture()
);
std::hint::spin_loop();
}
pub struct JobHandle<T: Send + 'static> {
result: Arc<Mutex<Option<Option<T>>>>,
pub(crate) cancel: Arc<AtomicBool>,
pub(crate) suspend: Arc<AtomicBool>,
pub(crate) meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
}
impl<T: Send + 'static> Default for JobHandle<T> {
fn default() -> Self {
Self {
result: Default::default(),
cancel: Default::default(),
suspend: Default::default(),
meta: Default::default(),
}
}
}
impl<T: Send + 'static> JobHandle<T> {
pub fn new(value: T) -> Self {
Self {
result: Arc::new(Mutex::new(Some(Some(value)))),
cancel: Default::default(),
suspend: Default::default(),
meta: Default::default(),
}
}
pub(crate) fn with_meta(
self,
iter: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) -> Self {
if let Ok(mut meta) = self.meta.write() {
meta.extend(iter);
}
self
}
pub fn is_cancelled(&self) -> bool {
self.cancel.load(Ordering::Relaxed)
}
pub fn is_suspended(&self) -> bool {
self.suspend.load(Ordering::Relaxed)
}
pub fn is_done(&self) -> bool {
self.result
.try_lock()
.ok()
.map(|guard| guard.is_some())
.unwrap_or_default()
}
pub fn try_take(&self) -> Option<Option<T>> {
self.result
.try_lock()
.ok()
.and_then(|mut result| result.take())
}
pub fn wait(self) -> Option<T> {
loop {
if let Some(result) = self.try_take() {
return result;
} else {
traced_spin_loop();
}
}
}
pub fn cancel(&self) {
self.cancel.store(true, Ordering::Relaxed);
if let Ok(mut result) = self.result.lock() {
*result = Some(None);
}
self.resume();
}
pub fn suspend(&self) {
self.suspend.store(true, Ordering::Relaxed);
}
pub fn resume(&self) {
self.suspend.store(false, Ordering::Relaxed);
}
pub(crate) fn put(&self, value: T) {
if let Ok(mut result) = self.result.lock() {
*result = Some(Some(value));
}
}
}
impl<T: Send + 'static> Clone for JobHandle<T> {
fn clone(&self) -> Self {
Self {
result: self.result.clone(),
cancel: self.cancel.clone(),
suspend: self.suspend.clone(),
meta: self.meta.clone(),
}
}
}
impl<T: Send + 'static> Future for JobHandle<T> {
type Output = Option<T>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
if let Some(result) = self.try_take() {
cx.waker().wake_by_ref();
Poll::Ready(result)
} else {
cx.waker().wake_by_ref();
Poll::Pending
}
}
}
pub struct AllJobsHandle<T: Send + 'static> {
jobs: Vec<JobHandle<T>>,
}
impl<T: Send + 'static> Default for AllJobsHandle<T> {
fn default() -> Self {
Self {
jobs: Default::default(),
}
}
}
impl<T: Send + 'static> AllJobsHandle<T> {
pub fn new(value: T) -> Self {
Self {
jobs: vec![JobHandle::new(value)],
}
}
pub fn into_inner(self) -> Vec<JobHandle<T>> {
self.jobs
}
pub fn many(handles: impl IntoIterator<Item = JobHandle<T>>) -> Self {
Self {
jobs: handles.into_iter().collect(),
}
}
pub fn add(&mut self, handle: JobHandle<T>) {
self.jobs.push(handle);
}
pub fn iter(&self) -> impl Iterator<Item = &JobHandle<T>> {
self.jobs.iter()
}
pub fn extend(&mut self, handles: impl IntoIterator<Item = JobHandle<T>>) {
self.jobs.extend(handles);
}
pub fn is_done(&self) -> bool {
self.jobs.iter().all(|job| job.is_done())
}
pub fn try_take(&self) -> Option<Option<Vec<T>>> {
self.is_done()
.then(|| self.jobs.iter().flat_map(|job| job.try_take()).collect())
}
pub fn wait(self) -> Option<Vec<T>> {
self.jobs.into_iter().map(|job| job.wait()).collect()
}
}
impl<T: Send + 'static> Clone for AllJobsHandle<T> {
fn clone(&self) -> Self {
Self {
jobs: self.jobs.clone(),
}
}
}
impl<T: Send + 'static> Future for AllJobsHandle<T> {
type Output = Option<Vec<T>>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
if let Some(result) = self.try_take() {
cx.waker().wake_by_ref();
Poll::Ready(result)
} else {
cx.waker().wake_by_ref();
Poll::Pending
}
}
}
pub struct AnyJobHandle<T: Send + 'static> {
jobs: Vec<JobHandle<T>>,
}
impl<T: Send + 'static> Default for AnyJobHandle<T> {
fn default() -> Self {
Self {
jobs: Default::default(),
}
}
}
impl<T: Send + 'static> AnyJobHandle<T> {
pub fn new(value: T) -> Self {
Self {
jobs: vec![JobHandle::new(value)],
}
}
pub fn into_inner(self) -> Vec<JobHandle<T>> {
self.jobs
}
pub fn many(handles: impl IntoIterator<Item = JobHandle<T>>) -> Self {
Self {
jobs: handles.into_iter().collect(),
}
}
pub fn add(&mut self, handle: JobHandle<T>) {
self.jobs.push(handle);
}
pub fn extend(&mut self, handles: impl IntoIterator<Item = JobHandle<T>>) {
self.jobs.extend(handles);
}
pub fn is_done(&self) -> bool {
self.jobs.iter().any(|job| job.is_done())
}
pub fn try_take(&self) -> Option<Option<T>> {
self.is_done()
.then(|| self.jobs.iter().find_map(|job| job.try_take()).flatten())
}
pub fn wait(self) -> Option<T> {
loop {
if let Some(result) = self.try_take() {
return result;
} else {
traced_spin_loop();
}
}
}
}
impl<T: Send + 'static> Clone for AnyJobHandle<T> {
fn clone(&self) -> Self {
Self {
jobs: self.jobs.clone(),
}
}
}
impl<T: Send + 'static> Future for AnyJobHandle<T> {
type Output = Option<T>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
if let Some(result) = self.try_take() {
cx.waker().wake_by_ref();
Poll::Ready(result)
} else {
cx.waker().wake_by_ref();
Poll::Pending
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct JobContext {
pub work_group_index: usize,
pub work_groups_count: usize,
}
impl std::fmt::Display for JobContext {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"JobContext {{ work_group_index: {}, work_groups_count: {} }}",
self.work_group_index, self.work_groups_count
)
}
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum JobPriority {
#[default]
Normal,
High,
}
impl std::fmt::Display for JobPriority {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
JobPriority::Normal => write!(f, "Normal"),
JobPriority::High => write!(f, "High"),
}
}
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub enum JobLocation {
#[default]
Unknown,
Local,
NonLocal,
UnnamedWorker,
NamedWorker(String),
ExactThread(ThreadId),
OtherThanThread(ThreadId),
Exclusive,
}
impl JobLocation {
pub fn named_worker(name: impl ToString) -> Self {
JobLocation::NamedWorker(name.to_string())
}
pub fn thread(thread: ThreadId) -> Self {
JobLocation::ExactThread(thread)
}
pub fn current_thread() -> Self {
JobLocation::ExactThread(std::thread::current().id())
}
pub fn other_than_current_thread() -> Self {
JobLocation::OtherThanThread(std::thread::current().id())
}
}
impl std::fmt::Display for JobLocation {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
JobLocation::Unknown => write!(f, "Unknown"),
JobLocation::Local => write!(f, "Local"),
JobLocation::NonLocal => write!(f, "Non-local"),
JobLocation::UnnamedWorker => write!(f, "Unnamed worker"),
JobLocation::NamedWorker(name) => write!(f, "Named worker: {name}"),
JobLocation::ExactThread(id) => write!(f, "Exact thread: {id:?}"),
JobLocation::OtherThanThread(id) => write!(f, "Other than thread: {id:?}"),
JobLocation::Exclusive => write!(f, "Exclusive"),
}
}
}
#[derive(Default)]
pub struct JobToken {
hash_tokens: Arc<Mutex<HashSet<u64>>>,
hash: u64,
}
impl Drop for JobToken {
fn drop(&mut self) {
if let Ok(mut hash_tokens) = self.hash_tokens.lock() {
hash_tokens.remove(&self.hash);
}
}
}
pub(crate) struct JobObject {
pub id: ID<Jobs>,
pub job: Job,
pub context: JobContext,
pub location: JobLocation,
pub priority: JobPriority,
pub cancel: Arc<AtomicBool>,
pub suspend: Arc<AtomicBool>,
pub meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
#[cfg(debug_assertions)]
pub creation_backtrace: String,
#[cfg(feature = "tracing")]
pub tracing_span: Option<tracing::Span>,
}
#[derive(Default, Clone)]
pub struct JobQueue {
queue: Arc<RwLock<LinkedList<JobObject>>>,
}
impl JobQueue {
pub fn is_empty(&self) -> bool {
self.queue.read().map_or(true, |queue| queue.is_empty())
}
pub fn len(&self) -> usize {
self.queue.read().map_or(0, |queue| queue.len())
}
pub fn clear(&self) {
if let Ok(mut queue) = self.queue.write() {
queue.clear();
}
}
pub fn append(&self, other: &Self) {
if let Ok(mut other_queue) = other.queue.write() {
self.extend(std::mem::take(&mut *other_queue));
}
}
pub fn spawn<T: Send + 'static>(
&self,
options: impl Into<JobOptions>,
job: impl Future<Output = T> + Send + Sync + 'static,
) -> JobHandle<T> {
let options = options.into();
let handle = JobHandle::<T>::default().with_meta(options.meta);
let handle2 = handle.clone();
let job = Job(Box::pin(async move {
handle2.put(job.await);
}));
self.schedule(options.location, options.priority, handle, job)
}
pub fn spawn_closure<T: Send + 'static>(
&self,
options: impl Into<JobOptions>,
job: impl FnOnce(JobContext) -> T + Send + Sync + 'static,
) -> JobHandle<T> {
let options = options.into();
let handle = JobHandle::<T>::default().with_meta(options.meta);
let handle2 = handle.clone();
let job = Job(Box::pin(async move {
handle2.put(job(context().await));
}));
self.schedule(options.location, options.priority, handle, job)
}
fn schedule<T: Send + 'static>(
&self,
location: JobLocation,
priority: JobPriority,
handle: JobHandle<T>,
job: Job,
) -> JobHandle<T> {
#[cfg(debug_assertions)]
let creation_backtrace = std::backtrace::Backtrace::capture().to_string();
self.enqueue(JobObject {
id: ID::new(),
job,
context: JobContext {
work_group_index: 0,
work_groups_count: 1,
},
location,
priority,
cancel: handle.cancel.clone(),
suspend: handle.suspend.clone(),
meta: handle.meta.clone(),
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
tracing_span: None,
});
handle
}
pub(crate) fn enqueue(&self, object: JobObject) {
if let Ok(mut queue) = self.queue.write() {
if object.priority == JobPriority::High {
queue.push_front(object);
} else {
queue.push_back(object);
}
}
}
fn dequeue(&self, target_location: &JobLocation, ignore_location: bool) -> Option<JobObject> {
let mut queue = self.queue.write().ok()?;
let mut extract = queue.extract_if(|object| {
if ignore_location || object.location == JobLocation::Exclusive {
true
} else {
match (&object.location, target_location) {
(JobLocation::Local, JobLocation::Local)
| (JobLocation::UnnamedWorker, JobLocation::UnnamedWorker) => true,
(JobLocation::NamedWorker(a), JobLocation::NamedWorker(b)) if a == b => true,
(JobLocation::ExactThread(a), _) => *a == std::thread::current().id(),
(JobLocation::OtherThanThread(a), _) => *a != std::thread::current().id(),
(JobLocation::NonLocal, b) => b != &JobLocation::Local,
(JobLocation::Unknown, _) => true,
_ => false,
}
}
});
extract.next()
}
fn extend(&self, queue: impl IntoIterator<Item = JobObject>) {
if let Ok(mut current_queue) = self.queue.write() {
for object in queue {
if object.priority == JobPriority::High {
current_queue.push_front(object);
} else {
current_queue.push_back(object);
}
}
}
}
}
impl Future for JobQueue {
type Output = ();
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
if self.is_empty() {
cx.waker().wake_by_ref();
Poll::Pending
} else {
cx.waker().wake_by_ref();
Poll::Ready(())
}
}
}
struct Worker {
location: JobLocation,
thread: Option<JoinHandle<()>>,
terminate: Arc<AtomicBool>,
}
impl Worker {
fn new(
worker_location: JobLocation,
queue: JobQueue,
global_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
worker_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
hash_tokens: Arc<Mutex<HashSet<u64>>>,
notify: Arc<(Mutex<bool>, Condvar)>,
) -> Worker {
let terminate = Arc::new(AtomicBool::default());
let terminate2 = terminate.clone();
let worker_location2 = worker_location.clone();
let thread = spawn(move || {
let mut pending = vec![];
loop {
if terminate2.load(Ordering::Relaxed) {
return;
}
while let Some(object) = queue.dequeue(&worker_location2, false) {
if object.location == JobLocation::Exclusive {
Self::exclusive(
object,
queue.clone(),
global_meta.clone(),
Default::default(),
hash_tokens.clone(),
notify.clone(),
);
continue;
}
let JobObject {
id,
job,
context,
location,
mut priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
mut tracing_span,
} = object;
let mut notify_workers = false;
let (poll_result, receiver) = if cancel.load(Ordering::Relaxed) {
let (_, rx) = std::sync::mpsc::channel();
(None, rx)
} else if suspend.load(Ordering::Relaxed) {
let (_, rx) = std::sync::mpsc::channel();
(Some(job), rx)
} else {
let (waker, receiver) = JobsWaker::new_waker(
queue.clone(),
location.clone(),
context,
priority,
global_meta.clone(),
worker_meta.clone(),
meta.clone(),
hash_tokens.clone(),
notify.clone(),
cancel.clone(),
suspend.clone(),
);
let mut cx = Context::from_waker(&waker);
#[cfg(feature = "tracing")]
let _span = {
let span = tracing::span!(
tracing::Level::TRACE,
"Job poll",
id = id.to_string(),
location = location.to_string(),
context = context.to_string(),
priority = priority.to_string(),
thread_id = format!("{:?}", std::thread::current().id()),
);
if let Some(last) = tracing_span.take() {
span.follows_from(last);
}
span.entered()
};
let poll_result = job.poll(
&mut cx,
#[cfg(debug_assertions)]
&creation_backtrace,
);
(poll_result, receiver)
};
if let Some(job) = poll_result {
let mut move_to = None;
for command in receiver.try_iter() {
notify_workers = true;
match command {
JobsWakerCommand::MoveTo(location) => {
move_to = Some(location);
}
JobsWakerCommand::ChangePriority(new_priority) => {
priority = new_priority;
}
}
}
if let Some(location) = move_to {
pending.push(JobObject {
id,
job,
context,
location,
priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
tracing_span,
});
} else {
pending.push(JobObject {
id,
job,
context,
location,
priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
tracing_span,
});
}
}
if terminate2.load(Ordering::Relaxed) {
return;
}
if notify_workers {
let (lock, cvar) = &*notify;
if let Ok(mut running) = lock.lock() {
*running = true;
}
cvar.notify_all();
}
}
queue.extend(pending.drain(..));
if !queue.is_empty() {
continue;
}
let (lock, cvar) = &*notify;
let Ok(mut ready) = lock.lock() else {
return;
};
loop {
let Ok((new, _)) = cvar.wait_timeout(ready, Duration::from_millis(10)) else {
return;
};
ready = new;
if *ready {
break;
}
}
}
});
Worker {
location: worker_location,
thread: Some(thread),
terminate,
}
}
fn exclusive(
job: JobObject,
queue: JobQueue,
global_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
worker_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
hash_tokens: Arc<Mutex<HashSet<u64>>>,
notify: Arc<(Mutex<bool>, Condvar)>,
) -> JoinHandle<()> {
spawn(move || {
let mut pending = Some(job);
loop {
let Some(object) = pending.take() else {
return;
};
let JobObject {
id,
job,
context,
location,
mut priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
mut tracing_span,
} = object;
let (poll_result, receiver) = if cancel.load(Ordering::Relaxed) {
let (_, rx) = std::sync::mpsc::channel();
(None, rx)
} else if suspend.load(Ordering::Relaxed) {
let (_, rx) = std::sync::mpsc::channel();
(Some(job), rx)
} else {
let (waker, receiver) = JobsWaker::new_waker(
queue.clone(),
location.clone(),
context,
priority,
global_meta.clone(),
worker_meta.clone(),
meta.clone(),
hash_tokens.clone(),
notify.clone(),
cancel.clone(),
suspend.clone(),
);
let mut cx = Context::from_waker(&waker);
#[cfg(feature = "tracing")]
let _span = {
let span = tracing::span!(
tracing::Level::TRACE,
"Job poll",
id = id.to_string(),
location = location.to_string(),
context = context.to_string(),
priority = priority.to_string(),
thread_id = format!("{:?}", std::thread::current().id()),
);
if let Some(last) = tracing_span.take() {
span.follows_from(last);
}
span.entered()
};
let poll_result = job.poll(
&mut cx,
#[cfg(debug_assertions)]
&creation_backtrace,
);
(poll_result, receiver)
};
if let Some(job) = poll_result {
let mut move_to = None;
for command in receiver.try_iter() {
match command {
JobsWakerCommand::MoveTo(location) => {
move_to = Some(location);
}
JobsWakerCommand::ChangePriority(new_priority) => {
priority = new_priority;
}
}
}
if let Some(location) = move_to {
queue.enqueue(JobObject {
id,
job,
context,
location,
priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
tracing_span,
});
} else {
pending = Some(JobObject {
id,
job,
context,
location,
priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
tracing_span,
});
}
}
}
})
}
}
pub(crate) enum JobsWakerCommand {
MoveTo(JobLocation),
ChangePriority(JobPriority),
}
pub(crate) struct JobsWaker {
sender: Sender<JobsWakerCommand>,
queue: JobQueue,
location: JobLocation,
context: JobContext,
priority: JobPriority,
global_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
worker_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
local_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
hash_tokens: Arc<Mutex<HashSet<u64>>>,
notify: Arc<(Mutex<bool>, Condvar)>,
cancel: Arc<AtomicBool>,
pub(crate) suspend: Arc<AtomicBool>,
}
static JOBS_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(
JobsWaker::vtable_clone,
|_| {},
|_| {},
JobsWaker::vtable_drop,
);
impl JobsWaker {
fn vtable_clone(data: *const ()) -> RawWaker {
let arc = unsafe { Arc::<Self>::from_raw(data as *const Self) };
let cloned = arc.clone();
std::mem::forget(arc);
RawWaker::new(Arc::into_raw(cloned) as *const (), &JOBS_WAKER_VTABLE)
}
fn vtable_drop(data: *const ()) {
let _ = unsafe { Arc::from_raw(data as *const Self) };
}
#[allow(clippy::too_many_arguments)]
pub fn new_waker(
queue: JobQueue,
location: JobLocation,
context: JobContext,
priority: JobPriority,
global_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
worker_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
local_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
hash_tokens: Arc<Mutex<HashSet<u64>>>,
notify: Arc<(Mutex<bool>, Condvar)>,
cancel: Arc<AtomicBool>,
suspend: Arc<AtomicBool>,
) -> (Waker, Receiver<JobsWakerCommand>) {
let (sender, receiver) = std::sync::mpsc::channel();
let arc = Arc::new(Self {
sender,
queue,
location,
context,
priority,
global_meta,
worker_meta,
local_meta,
hash_tokens,
notify,
cancel,
suspend,
});
let raw = RawWaker::new(Arc::into_raw(arc) as *const (), &JOBS_WAKER_VTABLE);
(unsafe { Waker::from_raw(raw) }, receiver)
}
pub fn try_cast(waker: &Waker) -> Option<&Self> {
if std::ptr::eq(waker.vtable(), &JOBS_WAKER_VTABLE) {
unsafe { waker.data().cast::<Self>().as_ref() }
} else {
None
}
}
pub fn command(&self, command: JobsWakerCommand) {
let _ = self.sender.send(command);
}
pub fn enqueue(&self, object: JobObject) {
self.queue.enqueue(object);
}
pub fn queue(&self) -> JobQueue {
self.queue.clone()
}
pub fn location(&self) -> JobLocation {
self.location.clone()
}
pub fn context(&self) -> JobContext {
self.context
}
pub fn priority(&self) -> JobPriority {
self.priority
}
pub fn run_queue(&self, queue: &JobQueue) {
Jobs::run_queue_inner(
queue,
JobLocation::Unknown,
true,
Duration::MAX,
self.global_meta.clone(),
[],
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_queue_with_meta(
&self,
queue: &JobQueue,
worker_meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
Jobs::run_queue_inner(
queue,
JobLocation::Unknown,
true,
Duration::MAX,
self.global_meta.clone(),
worker_meta,
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_queue_timeout(&self, queue: &JobQueue, timeout: Duration) {
Jobs::run_queue_inner(
queue,
JobLocation::Unknown,
true,
timeout,
self.global_meta.clone(),
[],
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_queue_timeout_with_meta(
&self,
queue: &JobQueue,
timeout: Duration,
worker_meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
Jobs::run_queue_inner(
queue,
JobLocation::Unknown,
true,
timeout,
self.global_meta.clone(),
worker_meta,
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn get_meta(&self, name: &str) -> Option<DynamicManagedLazy> {
self.local_meta
.read()
.ok()
.and_then(|meta| meta.get(name).cloned())
.or_else(|| {
self.worker_meta
.read()
.ok()
.and_then(|meta| meta.get(name).cloned())
.or_else(|| {
self.global_meta
.read()
.ok()
.and_then(|meta| meta.get(name).cloned())
})
})
}
pub fn local_meta(&self) -> Arc<RwLock<HashMap<String, DynamicManagedLazy>>> {
self.local_meta.clone()
}
pub fn cancel(&self) -> Arc<AtomicBool> {
self.cancel.clone()
}
pub fn suspend(&self) -> Arc<AtomicBool> {
self.suspend.clone()
}
pub fn acquire_token<T: Hash>(&self, subject: &T) -> Option<JobToken> {
let mut hasher = DefaultHasher::new();
subject.hash(&mut hasher);
let hash = hasher.finish();
let Ok(mut hash_tokens) = self.hash_tokens.lock() else {
return None;
};
if hash_tokens.contains(&hash) {
None
} else {
hash_tokens.insert(hash);
Some(JobToken {
hash_tokens: self.hash_tokens.clone(),
hash,
})
}
}
pub fn acquire_token_timeout<T: Hash>(
&self,
subject: &T,
timeout: Duration,
) -> Option<JobToken> {
let mut hasher = DefaultHasher::new();
subject.hash(&mut hasher);
let hash = hasher.finish();
let timer = Instant::now();
while timer.elapsed() < timeout {
let Ok(mut hash_tokens) = self.hash_tokens.try_lock() else {
traced_spin_loop();
continue;
};
if hash_tokens.contains(&hash) {
traced_spin_loop();
continue;
} else {
hash_tokens.insert(hash);
return Some(JobToken {
hash_tokens: self.hash_tokens.clone(),
hash,
});
}
}
None
}
}
impl Wake for JobsWaker {
fn wake(self: Arc<Self>) {}
}
pub struct Jobs {
workers: Vec<Worker>,
queue: JobQueue,
meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
hash_tokens: Arc<Mutex<HashSet<u64>>>,
notify: Arc<(Mutex<bool>, Condvar)>,
}
impl Drop for Jobs {
fn drop(&mut self) {
for worker in &self.workers {
worker.terminate.store(true, Ordering::Relaxed);
}
let (lock, cvar) = &*self.notify;
if let Ok(mut ready) = lock.lock() {
*ready = true;
};
cvar.notify_all();
for worker in &mut self.workers {
if let Some(thread) = worker.thread.take() {
let _ = thread.join();
}
}
}
}
impl Default for Jobs {
fn default() -> Self {
Self::new(
available_parallelism()
.ok()
.map(|v| v.get())
.unwrap_or_default(),
)
}
}
impl Jobs {
pub fn empty() -> Jobs {
Jobs::new(0)
}
pub fn new(unnamed_workers_count: usize) -> Jobs {
let queue = JobQueue::default();
let notify = Arc::new((Mutex::default(), Condvar::new()));
let global_meta = Arc::new(RwLock::new(HashMap::default()));
let worker_meta = Arc::new(RwLock::new(HashMap::default()));
let hash_tokens = Arc::new(Mutex::new(HashSet::default()));
Jobs {
workers: (0..unnamed_workers_count)
.map(|_| {
Worker::new(
JobLocation::UnnamedWorker,
queue.clone(),
global_meta.clone(),
worker_meta.clone(),
hash_tokens.clone(),
notify.clone(),
)
})
.collect(),
queue,
meta: global_meta,
hash_tokens,
notify,
}
}
pub fn with_unnamed_worker(mut self) -> Self {
self.add_unnamed_worker();
self
}
pub fn with_named_worker(mut self, name: impl ToString) -> Self {
self.add_named_worker(name);
self
}
pub fn add_unnamed_worker(&mut self) {
self.add_unnamed_worker_with_meta([]);
}
pub fn add_unnamed_worker_with_meta(
&mut self,
meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
self.workers.push(Worker::new(
JobLocation::UnnamedWorker,
self.queue.clone(),
self.meta.clone(),
Arc::new(RwLock::new(meta.into_iter().collect::<HashMap<_, _>>())),
self.hash_tokens.clone(),
self.notify.clone(),
));
}
pub fn add_named_worker(&mut self, name: impl ToString) {
self.add_named_worker_with_meta(name, []);
}
pub fn add_named_worker_with_meta(
&mut self,
name: impl ToString,
meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
self.workers.push(Worker::new(
JobLocation::named_worker(name),
self.queue.clone(),
self.meta.clone(),
Arc::new(RwLock::new(meta.into_iter().collect::<HashMap<_, _>>())),
self.hash_tokens.clone(),
self.notify.clone(),
));
}
pub fn remove_named_worker(&mut self, name: &str) {
if let Some(index) = self.workers.iter().position(|worker| {
if let JobLocation::NamedWorker(worker_name) = &worker.location {
worker_name == name
} else {
false
}
}) {
let mut worker = self.workers.swap_remove(index);
worker.terminate.store(true, Ordering::Relaxed);
let (lock, cvar) = &*self.notify;
if let Ok(mut ready) = lock.lock() {
*ready = true;
};
cvar.notify_all();
if let Some(thread) = worker.thread.take() {
let _ = thread.join();
}
}
}
pub fn unnamed_workers(&self) -> usize {
self.workers
.iter()
.filter(|worker| worker.location == JobLocation::UnnamedWorker)
.count()
}
pub fn named_workers(&self) -> impl Iterator<Item = &str> {
self.workers.iter().filter_map(|worker| {
if let JobLocation::NamedWorker(name) = &worker.location {
Some(name.as_str())
} else {
None
}
})
}
pub fn set_meta(&self, name: impl ToString, value: DynamicManagedLazy) {
let Ok(mut meta) = self.meta.write() else {
return;
};
meta.insert(name.to_string(), value);
}
pub fn unset_meta(&self, name: &str) {
let Ok(mut meta) = self.meta.write() else {
return;
};
meta.remove(name);
}
pub fn get_meta<T>(&self, name: &str) -> Option<ManagedLazy<T>> {
let Ok(meta) = self.meta.read() else {
return None;
};
meta.get(name)
.cloned()
.and_then(|value| value.into_typed::<T>().ok())
}
pub fn get_meta_dynamic(&self, name: &str) -> Option<DynamicManagedLazy> {
let Ok(meta) = self.meta.read() else {
return None;
};
meta.get(name).cloned()
}
pub fn run_local(&self) {
Self::run_queue_inner(
&self.queue,
JobLocation::Local,
self.workers.is_empty(),
Duration::MAX,
self.meta.clone(),
[],
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_local_with_meta(
&self,
worker_meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
Self::run_queue_inner(
&self.queue,
JobLocation::Local,
self.workers.is_empty(),
Duration::MAX,
self.meta.clone(),
worker_meta,
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_local_timeout(&self, timeout: Duration) {
Self::run_queue_inner(
&self.queue,
JobLocation::Local,
self.workers.is_empty(),
timeout,
self.meta.clone(),
[],
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_local_timeout_with_meta(
&self,
timeout: Duration,
worker_meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
Self::run_queue_inner(
&self.queue,
JobLocation::Local,
self.workers.is_empty(),
timeout,
self.meta.clone(),
worker_meta,
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn submit_queue(&self, queue: &JobQueue) {
self.queue.append(queue);
let (lock, cvar) = &*self.notify;
if let Ok(mut running) = lock.lock() {
*running = true;
}
cvar.notify_all();
}
pub fn run_queue(&self, queue: &JobQueue) {
Self::run_queue_inner(
queue,
JobLocation::Unknown,
true,
Duration::MAX,
self.meta.clone(),
[],
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_queue_with_meta(
&self,
queue: &JobQueue,
worker_meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
Self::run_queue_inner(
queue,
JobLocation::Unknown,
true,
Duration::MAX,
self.meta.clone(),
worker_meta,
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_queue_timeout(&self, queue: &JobQueue, timeout: Duration) {
Self::run_queue_inner(
queue,
JobLocation::Unknown,
true,
timeout,
self.meta.clone(),
[],
self.hash_tokens.clone(),
self.notify.clone(),
);
}
pub fn run_queue_timeout_with_meta(
&self,
queue: &JobQueue,
timeout: Duration,
worker_meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
) {
Self::run_queue_inner(
queue,
JobLocation::Unknown,
true,
timeout,
self.meta.clone(),
worker_meta,
self.hash_tokens.clone(),
self.notify.clone(),
);
}
#[allow(clippy::too_many_arguments)]
fn run_queue_inner(
queue: &JobQueue,
worker_location: JobLocation,
ignore_location: bool,
timeout: Duration,
global_meta: Arc<RwLock<HashMap<String, DynamicManagedLazy>>>,
worker_meta: impl IntoIterator<Item = (String, DynamicManagedLazy)>,
hash_tokens: Arc<Mutex<HashSet<u64>>>,
notify: Arc<(Mutex<bool>, Condvar)>,
) {
let timer = Instant::now();
let mut pending = vec![];
let worker_meta = Arc::new(RwLock::new(
worker_meta.into_iter().collect::<HashMap<_, _>>(),
));
while let Some(object) = queue.dequeue(&worker_location, ignore_location) {
if object.location == JobLocation::Exclusive {
Worker::exclusive(
object,
queue.clone(),
global_meta.clone(),
Default::default(),
hash_tokens.clone(),
notify.clone(),
);
continue;
}
let JobObject {
id,
job,
context,
location,
mut priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
mut tracing_span,
} = object;
let mut notify_workers = false;
let (poll_result, receiver) = if cancel.load(Ordering::Relaxed) {
let (_, rx) = std::sync::mpsc::channel();
(None, rx)
} else if suspend.load(Ordering::Relaxed) {
let (_, rx) = std::sync::mpsc::channel();
(Some(job), rx)
} else {
let (waker, receiver) = JobsWaker::new_waker(
queue.clone(),
location.clone(),
context,
priority,
global_meta.clone(),
worker_meta.clone(),
meta.clone(),
hash_tokens.clone(),
notify.clone(),
cancel.clone(),
suspend.clone(),
);
let mut cx = Context::from_waker(&waker);
#[cfg(feature = "tracing")]
let _span = {
let span = tracing::span!(
tracing::Level::TRACE,
"Job poll",
id = id.to_string(),
location = location.to_string(),
context = context.to_string(),
priority = priority.to_string(),
thread_id = format!("{:?}", std::thread::current().id()),
);
if let Some(last) = tracing_span.take() {
span.follows_from(last);
}
span.entered()
};
let poll_result = job.poll(
&mut cx,
#[cfg(debug_assertions)]
&creation_backtrace,
);
(poll_result, receiver)
};
if let Some(job) = poll_result {
let mut move_to = None;
for command in receiver.try_iter() {
notify_workers = true;
match command {
JobsWakerCommand::MoveTo(location) => move_to = Some(location),
JobsWakerCommand::ChangePriority(new_priority) => {
priority = new_priority;
}
}
}
if let Some(location) = move_to {
pending.push(JobObject {
id,
job,
context,
location,
priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
tracing_span,
});
} else {
pending.push(JobObject {
id,
job,
context,
location,
priority,
cancel,
suspend,
meta,
#[cfg(debug_assertions)]
creation_backtrace,
#[cfg(feature = "tracing")]
tracing_span,
});
}
}
if notify_workers {
let (lock, cvar) = &*notify;
if let Ok(mut running) = lock.lock() {
*running = true;
}
cvar.notify_all();
}
if timer.elapsed() >= timeout {
break;
}
}
queue.extend(pending);
}
pub fn block_on<T: Send + 'static>(
&self,
job: impl Future<Output = T> + Send + Sync + 'static,
) -> Option<T> {
let queue = JobQueue::default();
let handle = queue.spawn(JobLocation::Local, job);
while !queue.is_empty() {
self.run_queue(&queue);
}
handle.wait()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.workers.is_empty()
}
#[inline]
pub fn len(&self) -> usize {
self.workers.len()
}
#[inline]
pub fn queue_is_empty(&self) -> bool {
self.queue.is_empty()
}
#[inline]
pub fn queue_len(&self) -> usize {
self.queue.len()
}
pub fn spawn<T: Send + 'static>(
&self,
options: impl Into<JobOptions>,
job: impl Future<Output = T> + Send + Sync + 'static,
) -> Result<JobHandle<T>, Box<dyn Error>> {
let options = options.into();
let handle = self.queue.spawn(options, job);
let (lock, cvar) = &*self.notify;
let mut running = lock.lock().map_err(|error| format!("{error}"))?;
*running = true;
cvar.notify_all();
Ok(handle)
}
pub fn spawn_closure<T: Send + 'static>(
&self,
options: impl Into<JobOptions>,
job: impl FnOnce(JobContext) -> T + Send + Sync + 'static,
) -> Result<JobHandle<T>, Box<dyn Error>> {
let options = options.into();
let handle = self.queue.spawn_closure(options, job);
let (lock, cvar) = &*self.notify;
let mut running = lock.lock().map_err(|error| format!("{error}"))?;
*running = true;
cvar.notify_all();
Ok(handle)
}
pub fn broadcast<T: Send + 'static>(
&self,
job: impl Fn(JobContext) -> T + Send + Sync + 'static,
) -> Result<AllJobsHandle<T>, Box<dyn Error>> {
let current_thread = std::thread::current().id();
let n = self
.workers
.iter()
.filter(|worker| {
worker
.thread
.as_ref()
.is_none_or(|t| t.thread().id() != current_thread)
})
.count();
self.broadcast_n(n, job)
}
pub fn broadcast_n<T: Send + 'static>(
&self,
work_groups: usize,
job: impl Fn(JobContext) -> T + Send + Sync + 'static,
) -> Result<AllJobsHandle<T>, Box<dyn Error>> {
if work_groups == 0 || self.workers.is_empty() {
return Ok(AllJobsHandle::new(job(JobContext {
work_group_index: 0,
work_groups_count: 1,
})));
}
let job = Arc::new(job);
#[cfg(debug_assertions)]
let creation_backtrace = std::backtrace::Backtrace::capture().to_string();
let handle = AllJobsHandle {
jobs: (0..work_groups)
.map(|group| {
let job = Arc::clone(&job);
let handle = JobHandle::<T>::default();
let handle2 = handle.clone();
self.queue.enqueue(JobObject {
id: ID::new(),
job: Job(Box::pin(async move {
handle2.put(job(context().await));
})),
context: JobContext {
work_group_index: group,
work_groups_count: work_groups,
},
location: JobLocation::other_than_current_thread(),
priority: JobPriority::High,
cancel: handle.cancel.clone(),
suspend: handle.suspend.clone(),
meta: handle.meta.clone(),
#[cfg(debug_assertions)]
creation_backtrace: creation_backtrace.clone(),
#[cfg(feature = "tracing")]
tracing_span: None,
});
handle
})
.collect::<Vec<_>>(),
};
let (lock, cvar) = &*self.notify;
let mut running = lock.lock().map_err(|error| format!("{error}"))?;
*running = true;
cvar.notify_all();
Ok(handle)
}
pub fn scope<'env, T: Send + 'static, R>(
&'env self,
f: impl FnOnce(&mut ScopedJobs<'env, T>) -> R + 'env,
) -> (Vec<T>, R) {
ScopedJobs::execute(self, f)
}
}
pub struct ScopedJobs<'env, T: Send + 'static> {
jobs: &'env Jobs,
handles: AllJobsHandle<T>,
}
impl<'env, T: Send + 'static> ScopedJobs<'env, T> {
pub fn scope<'env2: 'env, T2: Send + 'static, R>(
&'env2 self,
f: impl FnOnce(&mut ScopedJobs<'env2, T2>) -> R + 'env2,
) -> (Vec<T2>, R) {
ScopedJobs::<T2>::execute::<R>(self.jobs, f)
}
pub fn execute<R>(jobs: &'env Jobs, f: impl FnOnce(&mut Self) -> R + 'env) -> (Vec<T>, R) {
let mut scope = Self {
jobs,
handles: AllJobsHandle::default(),
};
let result = f(&mut scope);
let output = scope.handles.wait().unwrap_or_default();
(output, result)
}
pub fn spawn(
&mut self,
options: impl Into<JobOptions>,
job: impl Future<Output = T> + Send + Sync + 'env,
) -> Result<(), Box<dyn Error>> {
let job = unsafe {
std::mem::transmute::<
Pin<Box<dyn Future<Output = T> + Send + Sync + 'env>>,
Pin<Box<dyn Future<Output = T> + Send + Sync + 'static>>,
>(Box::pin(job))
};
let handle = self.jobs.spawn(options, job)?;
self.handles.add(handle);
Ok(())
}
pub fn spawn_closure(
&mut self,
options: impl Into<JobOptions>,
job: impl FnOnce(JobContext) -> T + Send + Sync + 'env,
) -> Result<(), Box<dyn Error>> {
let job = unsafe {
std::mem::transmute::<
Box<dyn FnOnce(JobContext) -> T + Send + Sync + 'env>,
Box<dyn FnOnce(JobContext) -> T + Send + Sync + 'static>,
>(Box::new(job))
};
self.handles.add(self.jobs.spawn_closure(options, job)?);
Ok(())
}
pub fn broadcast(
&mut self,
job: impl Fn(JobContext) -> T + Send + Sync + 'env,
) -> Result<(), Box<dyn Error>> {
let job = unsafe {
std::mem::transmute::<
Box<dyn Fn(JobContext) -> T + Send + Sync + 'env>,
Box<dyn Fn(JobContext) -> T + Send + Sync + 'static>,
>(Box::new(job))
};
self.handles.extend(self.jobs.broadcast(job)?.into_inner());
Ok(())
}
pub fn broadcast_n(
&mut self,
work_groups: usize,
job: impl Fn(JobContext) -> T + Send + Sync + 'env,
) -> Result<(), Box<dyn Error>> {
let job = unsafe {
std::mem::transmute::<
Box<dyn Fn(JobContext) -> T + Send + Sync + 'env>,
Box<dyn Fn(JobContext) -> T + Send + Sync + 'static>,
>(Box::new(job))
};
self.handles
.extend(self.jobs.broadcast_n(work_groups, job)?.into_inner());
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::coroutine::{
acquire_token, location, meta, move_to, on_exit, spawn, spawn_closure, suspend, wait_polls,
wait_time, with_all, with_any, yield_now,
};
use std::sync::atomic::AtomicUsize;
#[test]
fn test_jobs() {
fn is_async<T: Send + Sync>() {}
is_async::<Jobs>();
let jobs = Jobs::default();
let data = (0..100).collect::<Vec<_>>();
let data2 = data.clone();
let job = jobs
.spawn_closure((), move |_| data.into_iter().sum::<usize>())
.unwrap();
let result = job.wait().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn_closure(JobLocation::Local, move |_| {
data2.into_iter().sum::<usize>()
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs.broadcast(move |ctx| ctx.work_group_index).unwrap();
let result = job.wait().unwrap().into_iter().sum::<usize>();
assert_eq!(result, (0..jobs.workers.len()).sum());
let job = jobs
.broadcast_n(10, move |ctx| ctx.work_group_index)
.unwrap();
let result = job.wait().unwrap().into_iter().sum::<usize>();
assert_eq!(result, {
let mut accum = 0;
for index in 0..10 {
accum += index;
}
accum
});
}
#[test]
fn test_local_thread_only_jobs() {
let jobs = Jobs::new(0);
let data = (0..100).collect::<Vec<_>>();
let data2 = data.clone();
let data3 = data.clone();
let data4 = data.clone();
let data5 = data.clone();
let data6 = data.clone();
let job = jobs
.spawn_closure((), move |_| data.into_iter().sum::<usize>())
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn_closure(JobLocation::Local, move |_| {
data2.into_iter().sum::<usize>()
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn_closure(JobLocation::UnnamedWorker, move |_| {
data3.into_iter().sum::<usize>()
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn_closure(JobLocation::named_worker("temp"), move |_| {
data4.into_iter().sum::<usize>()
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn_closure(JobLocation::current_thread(), move |_| {
data5.into_iter().sum::<usize>()
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn_closure(JobLocation::other_than_current_thread(), move |_| {
data6.into_iter().sum::<usize>()
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs.broadcast(move |_| 1).unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.wait().unwrap().into_iter().sum::<usize>();
assert_eq!(result, 1);
let job = jobs.broadcast_n(10, move |_| 1).unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.wait().unwrap().into_iter().sum::<usize>();
assert_eq!(result, 1);
}
#[test]
fn test_spawn_closure_jobs() {
let jobs = Jobs::new(0);
let queue = JobQueue::default();
let data = (0..100).collect::<Vec<_>>();
let job = queue.spawn_closure((), move |_| data.into_iter().sum::<usize>());
while !job.is_done() {
jobs.run_queue(&queue);
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
}
#[test]
fn test_scoped_jobs() {
let jobs = Jobs::default();
let mut data = (0..100).collect::<Vec<_>>();
let output = jobs
.scope(|scope| {
scope
.spawn_closure(JobLocation::NonLocal, |_| {
for value in &mut data {
*value *= 2;
}
data.iter().copied().sum::<usize>()
})
.unwrap();
})
.0
.into_iter()
.sum::<usize>();
assert_eq!(output, 9900);
}
#[test]
fn test_futures_spawn() {
let jobs = Jobs::default();
let data = (0..100).collect::<Vec<_>>();
let data2 = data.clone();
let data3 = data.clone();
let job = jobs
.spawn((), async move {
let mut result = 0;
for value in data {
result += value;
yield_now().await;
}
result
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn(JobLocation::Local, async move {
let mut result = 0;
for value in data2 {
result += value;
yield_now().await;
}
result
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 4950);
let job = jobs
.spawn((), async {
let result = Arc::new(AtomicUsize::new(0));
let result1 = result.clone();
let result2 = result.clone();
with_all(vec![
Box::pin(async move {
wait_time(Duration::from_millis(10)).await;
result1.fetch_add(1, Ordering::SeqCst);
}),
Box::pin(async move {
wait_time(Duration::from_millis(5)).await;
result2.fetch_add(2, Ordering::SeqCst);
}),
])
.await;
result.load(Ordering::SeqCst)
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert_eq!(result, 3);
let job = jobs
.spawn((), async {
let result = Arc::new(AtomicUsize::new(0));
let result1 = result.clone();
let result2 = result.clone();
with_any(vec![
Box::pin(async move {
wait_polls(10).await;
result1.store(1, Ordering::SeqCst);
}),
Box::pin(async move {
wait_polls(5).await;
result2.store(2, Ordering::SeqCst);
}),
])
.await;
result.load(Ordering::SeqCst)
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert!(result > 0);
let workers_count = jobs.workers.len();
let job = jobs
.spawn(JobLocation::Exclusive, async {
let mut result = 0;
for value in data3 {
result += value;
yield_now().await;
}
result
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert_eq!(result, 4950);
assert_eq!(jobs.workers.len(), workers_count);
}
#[test]
fn test_futures_move() {
let jobs = Jobs::new(1).with_named_worker("foo");
let unnamed_thread_id = jobs.workers[0].thread.as_ref().unwrap().thread().id();
let named_thread_id = jobs.workers[1].thread.as_ref().unwrap().thread().id();
let host_thread_id = std::thread::current().id();
let job = jobs
.spawn(JobLocation::Local, async move {
yield_now().await;
let a_thread_id = std::thread::current().id();
assert_eq!(a_thread_id, host_thread_id);
assert_eq!(location().await, JobLocation::Local);
move_to(JobLocation::Unknown).await;
let b_thread_id = std::thread::current().id();
assert!(
b_thread_id == unnamed_thread_id
|| b_thread_id == named_thread_id
|| b_thread_id == host_thread_id
);
assert_eq!(location().await, JobLocation::Unknown);
move_to(JobLocation::named_worker("foo")).await;
let c_thread_id = std::thread::current().id();
assert_eq!(c_thread_id, named_thread_id);
assert_eq!(location().await, JobLocation::named_worker("foo"));
move_to(JobLocation::Exclusive).await;
let d_thread_id = std::thread::current().id();
assert!(
d_thread_id != unnamed_thread_id
&& d_thread_id != named_thread_id
&& d_thread_id != host_thread_id
);
assert_eq!(location().await, JobLocation::Exclusive);
move_to(JobLocation::Local).await;
let e_thread_id = std::thread::current().id();
assert_eq!(e_thread_id, host_thread_id);
assert_eq!(location().await, JobLocation::Local);
42
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 42);
}
#[test]
fn test_futures_schedule() {
let jobs = Jobs::new(1).with_named_worker("foo");
let job = jobs
.spawn(JobLocation::Local, async {
spawn(JobLocation::Local, async {
println!("A: {:?}", location().await);
})
.await;
spawn((), async {
println!("B: {:?}", location().await);
})
.await;
spawn(JobLocation::named_worker("foo"), async {
println!("C: {:?}", location().await);
})
.await;
spawn(JobLocation::Exclusive, async {
println!("D: {:?}", location().await);
})
.await;
spawn_closure(JobLocation::Local, |_| {
println!("E: Local closure");
})
.await;
spawn_closure((), |_| {
println!("F: Unnamed worker closure");
})
.await;
spawn_closure(JobLocation::named_worker("foo"), |_| {
println!("G: Named worker closure");
})
.await;
spawn_closure(JobLocation::Exclusive, |_| {
println!("H: Exclusive worker closure");
})
.await;
42
})
.unwrap();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 42);
}
#[test]
fn test_futures_meta() {
let jobs = Jobs::default();
let mut value = 42usize;
let (value_lazy, _value_lifetime) = DynamicManagedLazy::make(&mut value);
jobs.set_meta("value", value_lazy);
let job = jobs
.spawn((), async {
let value = meta::<usize>("value").await.unwrap();
*value.read().unwrap()
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert_eq!(result, 42);
let mut flag = true;
let (flag_lazy, _flag_lifetime) = DynamicManagedLazy::make(&mut flag);
let job = jobs
.spawn(JobOptions::default().meta("flag", flag_lazy), async {
let flag = meta::<bool>("flag").await.unwrap();
*flag.read().unwrap()
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert!(result);
let mut flag = true;
let (flag_lazy, _flag_lifetime) = DynamicManagedLazy::make(&mut flag);
let job = jobs
.spawn(JobLocation::Local, async {
let flag = meta::<bool>("flag").await.unwrap();
*flag.read().unwrap()
})
.unwrap();
while !job.is_done() {
jobs.run_local_with_meta([("flag".to_owned(), flag_lazy.clone())]);
}
let result = job.try_take().unwrap().unwrap();
assert!(result);
}
#[test]
fn test_futures_acquire_token() {
let jobs = Jobs::new(3);
let a = jobs
.spawn((), async {
let _token = acquire_token(&"foo").await;
std::thread::sleep(Duration::from_millis(50));
for i in 0..10 {
println!("{i}");
std::thread::sleep(Duration::from_millis(10));
}
})
.unwrap();
let b = jobs
.spawn((), async {
let _token = acquire_token(&"foo").await;
std::thread::sleep(Duration::from_millis(50));
for i in 10..20 {
println!("{i}");
std::thread::sleep(Duration::from_millis(10));
}
})
.unwrap();
jobs.block_on(AllJobsHandle::many([a, b])).unwrap();
#[cfg(not(miri))]
{
use std::path::Path;
async fn load_file(path: impl AsRef<Path>) -> Option<String> {
let path = path.as_ref();
let _token = acquire_token(&path).await;
std::fs::read_to_string(path).ok()
}
async fn save_file(path: impl AsRef<Path>, content: &str) {
let path = path.as_ref();
let _token = acquire_token(&path).await;
let _ = std::fs::write(path, content);
}
const PATH: &str = "../resources/test.txt";
let content = "Hello, Jobs!".repeat(1000);
let a = jobs
.spawn((), async move {
std::thread::sleep(Duration::from_millis(50));
save_file(PATH, &content).await;
})
.unwrap();
let b = jobs
.spawn((), async {
std::thread::sleep(Duration::from_millis(50));
let _ = load_file(PATH).await;
})
.unwrap();
jobs.block_on(AllJobsHandle::many([a, b])).unwrap();
}
}
#[test]
fn test_futures_on_exit() {
let jobs = Jobs::default();
let state = Arc::new(AtomicBool::new(false));
let state1 = state.clone();
let job = jobs
.spawn((), async {
let _exit = on_exit(async move {
state1.store(true, Ordering::SeqCst);
})
.await;
42
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert_eq!(result, 42);
std::thread::sleep(Duration::from_millis(100));
assert!(state.load(Ordering::SeqCst));
let state = Arc::new(AtomicBool::new(false));
let state1 = state.clone();
let job = jobs
.spawn((), async {
let exit = on_exit(async move {
state1.store(true, Ordering::SeqCst);
})
.await;
exit.invalidate();
42
})
.unwrap();
let result = jobs.block_on(job).unwrap().unwrap();
assert_eq!(result, 42);
std::thread::sleep(Duration::from_millis(100));
assert!(!state.load(Ordering::SeqCst));
let state = Arc::new(AtomicBool::new(false));
let state1 = state.clone();
let job = jobs
.spawn(JobLocation::Local, async {
let exit = on_exit(async move {
state1.store(true, Ordering::SeqCst);
})
.await;
exit.invalidate();
42
})
.unwrap();
job.cancel();
while !job.is_done() {
jobs.run_local();
}
assert_eq!(job.try_take(), Some(None));
assert!(!state.load(Ordering::SeqCst));
}
#[test]
fn test_futures_suspend() {
let jobs = Jobs::default();
let job = jobs
.spawn(JobLocation::Local, async {
suspend().await;
42
})
.unwrap();
assert!(!job.is_done());
for _ in 0..10 {
jobs.run_local();
}
assert!(!job.is_done());
job.resume();
while !job.is_done() {
jobs.run_local();
}
let result = job.try_take().unwrap().unwrap();
assert_eq!(result, 42);
}
#[test]
fn test_futures_cancel() {
let jobs = Jobs::default();
let result = Arc::new(AtomicUsize::new(0));
let result1 = result.clone();
let job = jobs
.spawn(JobLocation::Local, async move {
loop {
result1.fetch_add(1, Ordering::SeqCst);
yield_now().await;
}
})
.unwrap();
assert!(!job.is_done());
for _ in 0..10 {
jobs.run_local();
}
assert!(!job.is_done());
job.cancel();
let prev = result.load(Ordering::SeqCst);
jobs.run_local();
let next = result.load(Ordering::SeqCst);
assert_eq!(prev, next);
}
#[test]
fn test_futures_panic() {
let jobs = Jobs::default();
let job = jobs
.spawn(JobLocation::Local, async {
println!("About to panic...");
yield_now().await;
if true {
panic!("Intentional panic for testing");
}
yield_now().await;
42
})
.unwrap();
while !jobs.queue_is_empty() {
jobs.run_local();
}
assert_eq!(job.try_take(), None);
}
#[test]
fn test_futures_block_on() {
let counter = Arc::new(AtomicUsize::new(0));
let counter1 = counter.clone();
Jobs::default().block_on(async move {
for _ in 0..10 {
counter1.fetch_add(1, Ordering::SeqCst);
yield_now().await;
}
});
assert_eq!(counter.load(Ordering::SeqCst), 10);
}
}