use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Condvar, Mutex};
use super::pipeline_state::Pipeline;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PipelineError {
pub label: String,
pub message: String,
}
impl std::fmt::Display for PipelineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}: {}", self.label, self.message)
}
}
type Progress = Arc<dyn Fn(usize, usize) + Send + Sync>;
#[derive(Clone)]
pub struct PipelineWarmup {
inner: Arc<Inner>,
}
struct Inner {
pipelines: Vec<Pipeline>,
next: AtomicUsize,
done: AtomicUsize,
errors: Mutex<Vec<PipelineError>>,
listeners: Mutex<Vec<Progress>>,
finished: (Mutex<()>, Condvar),
}
impl PipelineWarmup {
pub(crate) fn new(pipelines: Vec<Pipeline>) -> Self {
Self {
inner: Arc::new(Inner {
pipelines,
next: AtomicUsize::new(0),
done: AtomicUsize::new(0),
errors: Mutex::new(Vec::new()),
listeners: Mutex::new(Vec::new()),
finished: (Mutex::new(()), Condvar::new()),
}),
}
}
pub fn len(&self) -> usize {
self.inner.pipelines.len()
}
pub fn is_empty(&self) -> bool {
self.inner.pipelines.is_empty()
}
pub fn run(&self) -> usize {
let mut built = 0;
while self.step() {
built += 1;
}
built
}
pub fn step(&self) -> bool {
let Some(pipeline) = self.take() else {
return false;
};
let result = pipeline.compile();
self.finish(pipeline, result);
true
}
pub async fn step_async(&self) -> bool {
let Some(pipeline) = self.take() else {
return false;
};
let result = pipeline.compile_async().await;
self.finish(pipeline, result);
true
}
pub async fn run_async(&self) -> usize {
let mut built = 0;
while self.step_async().await {
built += 1;
}
built
}
pub fn on_progress(&self, f: impl Fn(usize, usize) + Send + Sync + 'static) {
let f: Progress = Arc::new(f);
self.inner
.listeners
.lock()
.unwrap_or_else(|e| e.into_inner())
.push(f.clone());
f(self.inner.done.load(Ordering::Acquire), self.len());
}
fn notify(&self, done: usize) {
let listeners: Vec<Progress> = self
.inner
.listeners
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone();
for f in listeners {
f(done, self.len());
}
}
#[cfg(not(target_arch = "wasm32"))]
pub fn spawn(&self, threads: usize) -> &Self {
for i in 0..threads.max(1).min(self.len().max(1)) {
let job = self.clone();
let _ = std::thread::Builder::new()
.name(format!("threers-warmup-{i}"))
.spawn(move || {
job.run();
});
}
self
}
fn take(&self) -> Option<&Pipeline> {
let i = self.inner.next.fetch_add(1, Ordering::Relaxed);
self.inner.pipelines.get(i)
}
fn finish(&self, pipeline: &Pipeline, result: Result<(), String>) {
if let Err(message) = result {
self.inner
.errors
.lock()
.unwrap_or_else(|e| e.into_inner())
.push(PipelineError {
label: pipeline.label().unwrap_or("").to_owned(),
message,
});
}
let done = self.inner.done.fetch_add(1, Ordering::AcqRel) + 1;
self.notify(done);
if done == self.len() {
let (lock, cvar) = &self.inner.finished;
let _held = lock.lock().unwrap_or_else(|e| e.into_inner());
cvar.notify_all();
}
}
pub fn progress(&self) -> (usize, usize) {
(self.inner.done.load(Ordering::Acquire), self.len())
}
pub fn is_ready(&self) -> bool {
self.inner.done.load(Ordering::Acquire) == self.len()
}
pub fn wait(&self) {
let (lock, cvar) = &self.inner.finished;
let mut held = lock.lock().unwrap_or_else(|e| e.into_inner());
while !self.is_ready() {
held = cvar.wait(held).unwrap_or_else(|e| e.into_inner());
}
}
pub fn errors(&self) -> Vec<PipelineError> {
self.inner
.errors
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
}
}
impl std::fmt::Debug for PipelineWarmup {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let (done, total) = self.progress();
f.debug_struct("PipelineWarmup")
.field("built", &done)
.field("total", &total)
.finish()
}
}
#[cfg(not(target_arch = "wasm32"))]
const _: () = {
const fn send_sync<T: Send + Sync>() {}
send_sync::<PipelineWarmup>();
};