use std::convert::Infallible;
use rand::SeedableRng;
use rand_chacha::ChaCha12Rng;
use crate::{
CancellationToken, Deadline, LoaderCancelled, Stateless, WaitOutcome, WorkerCheckpoint,
WorkerContext,
};
pub const TASK_RNG_DERIVATION_VERSION: u32 = 1;
#[derive(Clone, Debug)]
pub struct TaskContext {
pub loader_seed: u64,
pub epoch: u64,
pub rank: usize,
pub logical_sample: u64,
pub stage: u32,
pub cancellation: CancellationToken,
pub deadline: Deadline,
}
impl TaskContext {
pub fn deterministic_seed(&self) -> u64 {
derive_task_seed(self)
}
pub fn rng(&self) -> ChaCha12Rng {
ChaCha12Rng::seed_from_u64(self.deterministic_seed())
}
pub fn check(&self) -> std::result::Result<(), LoaderCancelled> {
if self.cancellation.is_cancelled() || self.deadline.is_expired() {
Err(LoaderCancelled)
} else {
Ok(())
}
}
pub fn wait_cancelled_or_deadline(&self) -> WaitOutcome {
self.cancellation.wait_cancelled_or_deadline(&self.deadline)
}
}
pub trait Transform<Input> {
type Output;
type Error;
fn transform(
&mut self,
input: Input,
context: &TaskContext,
) -> std::result::Result<Self::Output, Self::Error>;
}
#[derive(Clone, Copy, Debug)]
pub struct FnTransform<F> {
transform: F,
}
impl<F> FnTransform<F> {
pub fn new(transform: F) -> Self {
Self { transform }
}
}
impl<Input, Output, E, F> Transform<Input> for FnTransform<F>
where
F: FnMut(Input, &TaskContext) -> std::result::Result<Output, E>,
{
type Output = Output;
type Error = E;
fn transform(
&mut self,
input: Input,
context: &TaskContext,
) -> std::result::Result<Self::Output, Self::Error> {
(self.transform)(input, context)
}
}
pub trait TransformFactory<Input> {
type Transform: Transform<Input>;
type Error;
fn create(
&self,
worker: Option<&WorkerContext>,
) -> std::result::Result<Self::Transform, Self::Error>;
}
#[derive(Clone, Copy, Debug)]
pub struct FnTransformFactory<F> {
create: F,
}
impl<F> FnTransformFactory<F> {
pub fn new(create: F) -> Self {
Self { create }
}
}
impl<Input, T, E, F> TransformFactory<Input> for FnTransformFactory<F>
where
T: Transform<Input>,
F: Fn(Option<&WorkerContext>) -> std::result::Result<T, E>,
{
type Transform = T;
type Error = E;
fn create(
&self,
worker: Option<&WorkerContext>,
) -> std::result::Result<Self::Transform, Self::Error> {
(self.create)(worker)
}
}
#[derive(Clone, Copy, Debug)]
pub struct CloneTransformFactory<T> {
transform: T,
}
impl<T> CloneTransformFactory<T> {
pub(crate) fn new(transform: T) -> Self {
Self { transform }
}
}
impl<Input, T> TransformFactory<Input> for CloneTransformFactory<T>
where
T: Transform<Input> + Clone,
{
type Transform = T;
type Error = Infallible;
fn create(
&self,
_worker: Option<&WorkerContext>,
) -> std::result::Result<Self::Transform, Self::Error> {
Ok(self.transform.clone())
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct IdentityTransform;
impl Stateless for IdentityTransform {}
impl WorkerCheckpoint for IdentityTransform {
type State = ();
fn snapshot(&self) -> Self::State {}
fn validate_snapshot(&self, _state: &Self::State) -> rusttorch_core::Result<()> {
Ok(())
}
fn restore_validated(&mut self, _state: &Self::State) {}
}
impl<Input> Transform<Input> for IdentityTransform {
type Output = Input;
type Error = Infallible;
fn transform(
&mut self,
input: Input,
_context: &TaskContext,
) -> std::result::Result<Self::Output, Self::Error> {
Ok(input)
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct IdentityTransformFactory;
impl<Input> TransformFactory<Input> for IdentityTransformFactory {
type Transform = IdentityTransform;
type Error = Infallible;
fn create(
&self,
_worker: Option<&WorkerContext>,
) -> std::result::Result<Self::Transform, Self::Error> {
Ok(IdentityTransform)
}
}
fn splitmix64(mut value: u64) -> u64 {
value = value.wrapping_add(0x9e37_79b9_7f4a_7c15);
value = (value ^ (value >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
value = (value ^ (value >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
value ^ (value >> 31)
}
fn derive_task_seed(context: &TaskContext) -> u64 {
let fields = [
context.loader_seed,
context.epoch,
context.rank as u64,
context.logical_sample,
u64::from(context.stage),
];
fields
.into_iter()
.enumerate()
.fold(0x5255_5354_544f_5243, |state, (index, value)| {
let domain = (index as u64 + 1).wrapping_mul(0x9e37_79b9_7f4a_7c15);
splitmix64(state ^ value.wrapping_add(domain))
})
}