use std::fmt;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use datumesh_core::{Args, Cell, Descriptor, Scalar};
use crate::error::EvalError;
pub trait Runtime: Send + Sync {
fn lang(&self) -> &str;
fn evaluate(
&self,
descriptor: &Descriptor,
cell: &Cell,
inputs: &mut dyn Inputs,
budget: &mut Budget,
) -> Result<Scalar, EvalError>;
}
pub trait Inputs {
fn read(&mut self, fn_name: &str, args: &Args) -> Result<Scalar, EvalError>;
}
pub struct Budget {
fuel: Arc<Fuel>,
}
struct Fuel {
limit: u64,
remaining: AtomicU64,
exhausted: AtomicBool,
}
impl Budget {
pub fn new(fuel: u64) -> Budget {
Budget {
fuel: Arc::new(Fuel { limit: fuel, remaining: AtomicU64::new(fuel), exhausted: AtomicBool::new(false) }),
}
}
pub fn charge(&mut self, steps: u64) -> Result<(), EvalError> {
self.charge_shared(steps)
}
pub fn remaining(&self) -> u64 {
self.fuel.remaining.load(Ordering::Relaxed)
}
pub fn limit(&self) -> u64 {
self.fuel.limit
}
pub fn is_exhausted(&self) -> bool {
self.fuel.exhausted.load(Ordering::Relaxed)
}
pub(crate) fn share(&self) -> Budget {
Budget { fuel: Arc::clone(&self.fuel) }
}
pub(crate) fn charge_shared(&self, steps: u64) -> Result<(), EvalError> {
let f = &self.fuel;
let mut cur = f.remaining.load(Ordering::Relaxed);
loop {
if f.exhausted.load(Ordering::Relaxed) || cur < steps {
f.exhausted.store(true, Ordering::Relaxed);
f.remaining.store(0, Ordering::Relaxed);
return Err(EvalError::BudgetExceeded { fuel: f.limit });
}
match f.remaining.compare_exchange_weak(cur, cur - steps, Ordering::Relaxed, Ordering::Relaxed) {
Ok(_) => return Ok(()),
Err(now) => cur = now,
}
}
}
}
impl fmt::Debug for Budget {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Budget")
.field("limit", &self.limit())
.field("remaining", &self.remaining())
.field("exhausted", &self.is_exhausted())
.finish()
}
}