use std::marker::PhantomData;
use std::mem::size_of;
use et_abi::CACHE_LINE;
pub use et_abi::DevicePod;
use crate::device::{Device, DeviceRegion, DmaOptions};
use crate::error::{Error, Result};
use crate::transport::Transport;
fn as_bytes<E: DevicePod>(data: &[E]) -> &[u8] {
unsafe { std::slice::from_raw_parts(data.as_ptr() as *const u8, std::mem::size_of_val(data)) }
}
#[derive(Clone, Copy, Debug)]
pub struct DeviceBuffer<T> {
region: DeviceRegion,
len: usize,
_marker: PhantomData<T>,
}
impl<T: DevicePod> DeviceBuffer<T> {
pub fn addr(&self) -> u64 {
self.region.addr
}
pub fn len(&self) -> usize {
self.len
}
pub fn is_empty(&self) -> bool {
self.len == 0
}
pub fn byte_len(&self) -> usize {
self.len * size_of::<T>()
}
pub fn region(&self) -> DeviceRegion {
self.region
}
}
#[derive(Clone, Copy, Debug)]
pub struct PaddedArray<T> {
region: DeviceRegion,
len: usize,
_marker: PhantomData<T>,
}
impl<T: DevicePod> PaddedArray<T> {
pub fn addr(&self) -> u64 {
self.region.addr
}
pub fn len(&self) -> usize {
self.len
}
pub fn is_empty(&self) -> bool {
self.len == 0
}
pub fn stride(&self) -> usize {
CACHE_LINE
}
pub fn region(&self) -> DeviceRegion {
self.region
}
}
impl<Tr: Transport> Device<Tr> {
pub fn alloc_array<E: DevicePod>(&self, n: usize) -> Result<DeviceBuffer<E>> {
let region = self.alloc((n * size_of::<E>()) as u64)?;
Ok(DeviceBuffer {
region,
len: n,
_marker: PhantomData,
})
}
pub fn upload<E: DevicePod>(&self, data: &[E]) -> Result<DeviceBuffer<E>> {
let buf = self.alloc_array::<E>(data.len())?;
self.write_buffer(&buf, data)?;
Ok(buf)
}
pub fn write_buffer<E: DevicePod>(&self, buf: &DeviceBuffer<E>, data: &[E]) -> Result<()> {
if data.len() > buf.len() {
return Err(Error::Limit(format!(
"write of {} elements exceeds buffer capacity {}",
data.len(),
buf.len()
)));
}
self.memcpy_h2d(as_bytes(data), buf.addr())
}
pub fn download<E: DevicePod>(&self, buf: &DeviceBuffer<E>) -> Result<Vec<E>> {
let mut out: Vec<E> = Vec::with_capacity(buf.len());
unsafe {
let dst = std::slice::from_raw_parts_mut(out.as_mut_ptr() as *mut u8, buf.byte_len());
self.memcpy_d2h(buf.addr(), dst)?;
out.set_len(buf.len());
}
Ok(out)
}
pub fn alloc_padded<E: DevicePod>(&self, n: usize) -> Result<PaddedArray<E>> {
assert!(
size_of::<E>() <= CACHE_LINE,
"padded element ({} bytes) exceeds one cache line ({CACHE_LINE} bytes)",
size_of::<E>()
);
let region = self.alloc((n * CACHE_LINE) as u64)?;
Ok(PaddedArray {
region,
len: n,
_marker: PhantomData,
})
}
pub fn download_padded<E: DevicePod>(&self, arr: &PaddedArray<E>) -> Result<Vec<E>> {
let mut raw = vec![0u8; arr.len() * CACHE_LINE];
self.memcpy_d2h(arr.addr(), &mut raw)?;
let mut out = Vec::with_capacity(arr.len());
for i in 0..arr.len() {
let off = i * CACHE_LINE;
out.push(unsafe { std::ptr::read_unaligned(raw.as_ptr().add(off) as *const E) });
}
Ok(out)
}
pub fn upload_slice<E: DevicePod>(&self, data: &[E], dst: u64) -> Result<()> {
self.memcpy_h2d(as_bytes(data), dst)
}
pub fn upload_slice_opts<E: DevicePod>(
&self,
data: &[E],
dst: u64,
opts: &DmaOptions,
) -> Result<()> {
self.memcpy_h2d_opts(as_bytes(data), dst, opts)
}
pub fn download_slice<E: DevicePod>(&self, src: u64, n: usize) -> Result<Vec<E>> {
let byte_len = n * size_of::<E>();
let mut out: Vec<E> = Vec::with_capacity(n);
unsafe {
let dst = std::slice::from_raw_parts_mut(out.as_mut_ptr() as *mut u8, byte_len);
self.memcpy_d2h(src, dst)?;
out.set_len(n);
}
Ok(out)
}
pub fn download_slice_opts<E: DevicePod>(
&self,
src: u64,
n: usize,
opts: &DmaOptions,
) -> Result<Vec<E>> {
let byte_len = n * size_of::<E>();
let mut out: Vec<E> = Vec::with_capacity(n);
unsafe {
let dst = std::slice::from_raw_parts_mut(out.as_mut_ptr() as *mut u8, byte_len);
self.memcpy_d2h_opts(src, dst, opts)?;
out.set_len(n);
}
Ok(out)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pod_bytes_are_little_endian() {
let v = [1u32, 0x0203_0405u32];
let b = as_bytes(&v);
assert_eq!(b.len(), 8);
assert_eq!(&b[0..4], &1u32.to_le_bytes());
assert_eq!(&b[4..8], &0x0203_0405u32.to_le_bytes());
}
}