use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::ffi::{c_char, c_void};
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::sync::mpsc::{self, Receiver, SyncSender, TrySendError};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use super::device::{MetalDevice, MetalError};
use super::objc::AutoreleasePool;
use super::renderer::MetalRenderer;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MetalWorkerQos {
UserInteractive,
UserInitiated,
Utility,
Background,
}
impl MetalWorkerQos {
fn raw(self) -> u32 {
match self {
Self::UserInteractive => 0x21,
Self::UserInitiated => 0x19,
Self::Utility => 0x11,
Self::Background => 0x09,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct MetalRenderPoolConfig {
pub threads: usize,
pub queue_depth: usize,
pub qos: MetalWorkerQos,
pub name: String,
}
impl MetalRenderPoolConfig {
pub fn for_this_device() -> Self {
let cap = if cfg!(target_os = "macos") { 4 } else { 2 };
let threads = performance_cores().clamp(1, cap);
Self {
threads,
queue_depth: threads,
qos: MetalWorkerQos::UserInteractive,
name: "threers-metal".into(),
}
}
pub fn with_threads(threads: usize) -> Self {
let threads = threads.max(1);
Self { threads, queue_depth: threads, ..Self::for_this_device() }
}
}
impl Default for MetalRenderPoolConfig {
fn default() -> Self {
Self::for_this_device()
}
}
fn performance_cores() -> usize {
unsafe extern "C" {
fn sysctlbyname(
name: *const c_char,
oldp: *mut c_void,
oldlenp: *mut usize,
newp: *mut c_void,
newlen: usize,
) -> i32;
}
let mut n: i32 = 0;
let mut len = std::mem::size_of::<i32>();
let ok = unsafe {
sysctlbyname(
c"hw.perflevel0.physicalcpu".as_ptr(),
(&mut n as *mut i32).cast(),
&mut len,
std::ptr::null_mut(),
0,
)
} == 0;
if ok && n > 0 {
return n as usize;
}
std::thread::available_parallelism().map(|n| n.get()).unwrap_or(2)
}
pub struct MetalWorker {
index: usize,
device: MetalDevice,
renderer: Option<MetalRenderer>,
locals: HashMap<TypeId, Box<dyn Any + Send>>,
}
impl MetalWorker {
pub fn index(&self) -> usize {
self.index
}
pub fn device(&self) -> &MetalDevice {
&self.device
}
pub fn renderer(&mut self) -> Result<&mut MetalRenderer, MetalError> {
if self.renderer.is_none() {
self.renderer = Some(MetalRenderer::with_device(self.device.clone())?);
}
Ok(self.renderer.as_mut().expect("just built"))
}
pub fn local<T: Default + Send + 'static>(&mut self) -> &mut T {
self.locals
.entry(TypeId::of::<T>())
.or_insert_with(|| Box::new(T::default()))
.downcast_mut()
.expect("keyed by its own TypeId")
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MetalJobError {
Panicked(String),
QueueFull,
Closed,
}
impl std::fmt::Display for MetalJobError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Panicked(m) => write!(f, "render job panicked: {m}"),
Self::QueueFull => write!(f, "render pool queue is full"),
Self::Closed => write!(f, "render pool is closed"),
}
}
}
impl std::error::Error for MetalJobError {}
pub struct MetalJob<T> {
rx: Receiver<Result<T, MetalJobError>>,
}
impl<T> MetalJob<T> {
pub fn wait(self) -> Result<T, MetalJobError> {
self.rx.recv().unwrap_or(Err(MetalJobError::Closed))
}
pub fn try_wait(self) -> Result<Result<T, MetalJobError>, Self> {
match self.rx.try_recv() {
Ok(r) => Ok(r),
Err(mpsc::TryRecvError::Empty) => Err(self),
Err(mpsc::TryRecvError::Disconnected) => Ok(Err(MetalJobError::Closed)),
}
}
}
type Task = Box<dyn FnOnce(&mut MetalWorker) + Send>;
pub struct MetalRenderPool {
tx: Option<SyncSender<Task>>,
workers: Vec<JoinHandle<()>>,
config: MetalRenderPoolConfig,
}
impl MetalRenderPool {
pub fn new(device: &MetalDevice, config: MetalRenderPoolConfig) -> Self {
let config = MetalRenderPoolConfig { threads: config.threads.max(1), ..config };
let (tx, rx) = mpsc::sync_channel::<Task>(config.queue_depth);
let rx = Arc::new(Mutex::new(rx));
let workers = (0..config.threads)
.map(|index| {
let rx = rx.clone();
let device = device.clone();
let qos = config.qos;
std::thread::Builder::new()
.name(format!("{}-{index}", config.name))
.spawn(move || worker_main(index, device, qos, rx))
.expect("spawning a render worker")
})
.collect();
Self { tx: Some(tx), workers, config }
}
pub fn config(&self) -> &MetalRenderPoolConfig {
&self.config
}
pub fn submit<T, F>(&self, job: F) -> Result<MetalJob<T>, MetalJobError>
where
T: Send + 'static,
F: FnOnce(&mut MetalWorker) -> T + Send + 'static,
{
let (task, handle) = package(job);
self.tx
.as_ref()
.ok_or(MetalJobError::Closed)?
.send(task)
.map_err(|_| MetalJobError::Closed)?;
Ok(handle)
}
pub fn try_submit<T, F>(&self, job: F) -> Result<MetalJob<T>, MetalJobError>
where
T: Send + 'static,
F: FnOnce(&mut MetalWorker) -> T + Send + 'static,
{
let (task, handle) = package(job);
match self.tx.as_ref().ok_or(MetalJobError::Closed)?.try_send(task) {
Ok(()) => Ok(handle),
Err(TrySendError::Full(_)) => Err(MetalJobError::QueueFull),
Err(TrySendError::Disconnected(_)) => Err(MetalJobError::Closed),
}
}
}
impl Drop for MetalRenderPool {
fn drop(&mut self) {
drop(self.tx.take());
for w in self.workers.drain(..) {
let _ = w.join();
}
}
}
impl std::fmt::Debug for MetalRenderPool {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetalRenderPool").field("config", &self.config).finish()
}
}
fn package<T, F>(job: F) -> (Task, MetalJob<T>)
where
T: Send + 'static,
F: FnOnce(&mut MetalWorker) -> T + Send + 'static,
{
let (tx, rx) = mpsc::sync_channel(1);
let task: Task = Box::new(move |worker: &mut MetalWorker| {
let result = catch_unwind(AssertUnwindSafe(|| job(worker))).map_err(|p| {
worker.renderer = None;
MetalJobError::Panicked(panic_message(&*p))
});
let _ = tx.send(result);
});
(task, MetalJob { rx })
}
fn panic_message(p: &(dyn Any + Send)) -> String {
p.downcast_ref::<&str>()
.map(|s| s.to_string())
.or_else(|| p.downcast_ref::<String>().cloned())
.unwrap_or_else(|| "non-string panic payload".into())
}
fn worker_main(
index: usize,
device: MetalDevice,
qos: MetalWorkerQos,
rx: Arc<Mutex<Receiver<Task>>>,
) {
unsafe extern "C" {
fn pthread_set_qos_class_self_np(qos_class: u32, relative_priority: i32) -> i32;
}
unsafe { pthread_set_qos_class_self_np(qos.raw(), 0) };
let mut worker = MetalWorker { index, device, renderer: None, locals: HashMap::new() };
loop {
let task = match rx.lock() {
Ok(rx) => rx.recv(),
Err(_) => return,
};
let Ok(task) = task else { break };
let _pool = AutoreleasePool::new();
task(&mut worker);
}
let _pool = AutoreleasePool::new();
drop(worker);
}