use std::time::Duration;
use super::lanes::Ticket;
use super::{GpuPeer, GpuPeerConfig, GpuPeerError, ResidentHandle};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct GroupHandle {
pub peer: usize,
pub handle: ResidentHandle,
}
pub struct PeerGroup {
peers: Vec<GpuPeer>,
}
impl PeerGroup {
pub fn init(configs: Vec<GpuPeerConfig>) -> Result<Self, GpuPeerError> {
let mut peers = Vec::with_capacity(configs.len());
for c in configs {
peers.push(GpuPeer::init(c)?);
}
if peers.is_empty() {
return Err(GpuPeerError::Unavailable("empty peer group"));
}
Ok(Self { peers })
}
pub fn len(&self) -> usize {
self.peers.len()
}
pub fn is_empty(&self) -> bool {
self.peers.is_empty()
}
pub fn peer_mut(&mut self, idx: usize) -> &mut GpuPeer {
&mut self.peers[idx]
}
pub fn calibrations(&self) -> Vec<super::PeerCalibration> {
self.peers.iter().map(|p| p.calibration()).collect()
}
pub fn pin(&mut self, data: &[u8]) -> Result<GroupHandle, GpuPeerError> {
let peer = (0..self.peers.len())
.max_by_key(|&i| self.peers[i].pool_stats().0)
.unwrap_or(0);
let handle = self.peers[peer].pin(data)?;
Ok(GroupHandle { peer, handle })
}
pub fn submit_resident(
&mut self,
op: u32,
h: &GroupHandle,
) -> Result<(usize, Ticket), GpuPeerError> {
Ok((h.peer, self.peers[h.peer].submit_resident(op, &h.handle)?))
}
pub fn wait_reap(
&mut self,
peer: usize,
t: Ticket,
timeout: Duration,
) -> Result<u32, GpuPeerError> {
let s = self.peers[peer].wait(t, timeout)?;
self.peers[peer].reap(t)?;
Ok(s)
}
pub fn fetch(&mut self, h: &GroupHandle, out: &mut [u8]) -> Result<(), GpuPeerError> {
self.peers[h.peer].fetch(&h.handle, out)
}
pub fn unpin(&mut self, h: GroupHandle) -> Result<(), GpuPeerError> {
self.peers[h.peer].unpin(h.handle)
}
pub fn migrate(
&mut self,
h: GroupHandle,
to_peer: usize,
) -> Result<GroupHandle, GpuPeerError> {
if to_peer >= self.peers.len() {
return Err(GpuPeerError::Unavailable("migrate target out of range"));
}
if to_peer == h.peer {
return Ok(h);
}
let mut buf = vec![0u8; h.handle.len()];
self.peers[h.peer].fetch(&h.handle, &mut buf)?;
let new_handle = self.peers[to_peer].pin(&buf)?;
self.peers[h.peer].unpin(h.handle)?;
Ok(GroupHandle { peer: to_peer, handle: new_handle })
}
}