use std::path::PathBuf;
#[derive(Debug, Clone)]
pub struct PlanItem {
pub recipe_path: PathBuf,
pub recipe_name: String,
pub renderer: String,
pub renderer_argv: Vec<String>,
}
#[allow(clippy::type_complexity)]
pub fn plan_items(recipes: Vec<(PathBuf, String, Vec<(String, Vec<String>)>)>) -> Vec<PlanItem> {
let mut items = Vec::new();
for (path, name, renderers) in recipes {
for (renderer, argv) in renderers {
items.push(PlanItem {
recipe_path: path.clone(),
recipe_name: name.clone(),
renderer,
renderer_argv: argv,
});
}
}
items.sort_by(|a, b| {
a.recipe_name
.cmp(&b.recipe_name)
.then_with(|| a.renderer.cmp(&b.renderer))
});
items
}
pub fn run_parallel<T, F>(items: Vec<PlanItem>, max_workers: usize, f: F) -> Vec<T>
where
F: Fn(&PlanItem) -> T + Send + Sync,
T: Send,
{
if max_workers <= 1 || items.len() <= 1 {
return items.iter().map(&f).collect();
}
let chunk_size = items.len().div_ceil(max_workers);
let f_ref = &f;
std::thread::scope(|scope| {
let mut handles = Vec::new();
for chunk in items.chunks(chunk_size) {
let chunk_vec: Vec<PlanItem> = chunk.to_vec();
let handle = scope.spawn(move || {
let mut out = Vec::with_capacity(chunk_vec.len());
for item in &chunk_vec {
out.push(f_ref(item));
}
out
});
handles.push(handle);
}
let mut results = Vec::with_capacity(items.len());
for h in handles {
results.extend(h.join().expect("planner worker panicked"));
}
results
})
}