use std::time::Instant;
use crate::sched::call_site::{Placement, caller_site};
use crate::sched::plan::JobPlan;
use super::{GpuPeer, GpuPeerError, ResidentHandle, STATUS_DONE, layout};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MirrorState {
Host,
Device,
Both,
}
pub struct MirrorBuf {
host: Vec<u8>,
handle: Option<ResidentHandle>,
state: MirrorState,
}
impl MirrorBuf {
pub fn new(data: Vec<u8>) -> Self {
Self { host: data, handle: None, state: MirrorState::Host }
}
pub fn state(&self) -> MirrorState {
self.state
}
pub fn host_bytes<'a>(&'a mut self, peer: &mut GpuPeer) -> Result<&'a [u8], GpuPeerError> {
if self.state == MirrorState::Device {
let h = self.handle.as_ref().expect("device-valid implies handle");
let mut out = vec![0u8; h.len()];
peer.fetch(h, &mut out)?;
self.host = out;
self.state = MirrorState::Both;
}
Ok(&self.host)
}
pub fn evict(&mut self, peer: &mut GpuPeer) -> Result<(), GpuPeerError> {
if self.state == MirrorState::Device {
self.host_bytes(peer)?;
}
if let Some(h) = self.handle.take() {
peer.unpin(h)?;
}
self.state = MirrorState::Host;
Ok(())
}
fn ensure_device(&mut self, peer: &mut GpuPeer) -> Result<(), GpuPeerError> {
match (self.state, self.handle.is_some()) {
(MirrorState::Host, false) => {
self.handle = Some(peer.pin(&self.host)?);
self.state = MirrorState::Both;
}
(MirrorState::Host, true) => {
let h = *self.handle.as_ref().expect("checked");
peer.write_resident(&h, &self.host)?;
self.state = MirrorState::Both;
}
_ => {}
}
Ok(())
}
fn ensure_host(&mut self, peer: &mut GpuPeer) -> Result<(), GpuPeerError> {
if self.state == MirrorState::Device {
self.host_bytes(peer)?;
}
Ok(())
}
}
#[track_caller]
pub fn hybrid_auto_resident<C>(
plan: &JobPlan,
peer: &mut GpuPeer,
mirror: &mut MirrorBuf,
op: u32,
mut cpu_impl: C,
) -> Result<Placement, GpuPeerError>
where
C: FnMut(&mut [u8]),
{
let plan_owned = plan.with_site_if_none(caller_site());
let site = plan_owned.site.expect("attached above").get();
let batch = plan_owned.batch_size;
let run_cpu = |peer: &mut GpuPeer, mirror: &mut MirrorBuf, cpu_impl: &mut C| -> Result<u64, GpuPeerError> {
let t0 = Instant::now();
mirror.ensure_host(peer)?; cpu_impl(&mut mirror.host);
mirror.state = MirrorState::Host; Ok(t0.elapsed().as_nanos() as u64)
};
let run_dev = |peer: &mut GpuPeer, mirror: &mut MirrorBuf| -> Result<u64, GpuPeerError> {
let t0 = Instant::now();
mirror.ensure_device(peer)?; let h = *mirror.handle.as_ref().expect("ensured");
let t = peer.submit_resident(op, &h)?;
let s = peer.wait(t, std::time::Duration::from_secs(10))?;
peer.reap(t)?;
if s != STATUS_DONE {
return Err(GpuPeerError::Unavailable("resident op rejected"));
}
mirror.state = MirrorState::Device; Ok(t0.elapsed().as_nanos() as u64)
};
match site.choose_placement(batch) {
Placement::Cpu => {
let ns = run_cpu(peer, mirror, &mut cpu_impl)?;
site.record_placement(batch, Some(ns), None);
Ok(Placement::Cpu)
}
Placement::Backend => {
let ns = run_dev(peer, mirror)?;
site.record_placement(batch, None, Some(ns));
Ok(Placement::Backend)
}
Placement::Race => {
mirror.ensure_host(peer)?;
let mut snapshot = mirror.host.clone();
let dev_ns = run_dev(peer, mirror)?;
let t0 = Instant::now();
cpu_impl(&mut snapshot);
let cpu_ns = t0.elapsed().as_nanos() as u64;
mirror.host = snapshot;
mirror.state = MirrorState::Host;
site.record_placement(batch, Some(cpu_ns), Some(dev_ns));
Ok(Placement::Race)
}
}
}
pub fn add1_f32_cpu(bytes: &mut [u8]) {
for c in bytes.as_chunks_mut::<4>().0 {
*c = (f32::from_le_bytes(*c) + 1.0).to_le_bytes();
}
}
pub const ADD1_F32_RESIDENT: u32 = layout::OP_ADD1_F32_V;