Struct CPU 

pub struct CPU {
    pub cache: RefCell<Cache<CPU>>,
    pub graph: RefCell<Graph>,
}

A CPU is used to perform calculations on the host CPU. To make new operations invocable, a trait providing new functions should be implemented for CPU.

Example

use custos::{CPU, Read, Buffer};

let device = CPU::new();
let a = Buffer::from((&device, [1, 2, 3]));

let out = device.read(&a);

assert_eq!(out, vec![1, 2, 3]);

Fields

cache: RefCell<Cache<CPU>>

graph: RefCell<Graph>

Implementations

impl CPU

pub fn new() -> CPU

Creates an CPU with an InternCPU that holds an empty vector of pointers.

Examples found in repository

examples/cpu_device.rs (line 7)

fn main() {
    let device = CPU::new();
    let a = Matrix::<f32>::new(&device, (5, 5));
    let b = Matrix::from((&device, (5, 5), vec![1.3; 5 * 5]));

    let out = device.add(&a, &b);

    assert_eq!(device.read(&out), vec![1.3; 5 * 5]);
}

examples/simple.rs (line 9)

fn main() -> custos::Result<()> {
    //select() ... sets CPU as 'global device'
    // -> when device is not specified in an operation, the 'global device' is used
    let cpu = CPU::new();

    with_select(&cpu);
    specify_device(&cpu);

    using_opencl()
}

examples/gemm.rs (line 4)

fn main() {
    let device = CPU::new();

    let a = Matrix::from((&device, (2, 3), [1., 2., 3., 4., 5., 6.]));
    let b = Matrix::from((&device, (3, 2), [6., 5., 4., 3., 2., 1.]));

    let c = a.gemm(&b);
    println!("c: {c:?}");

    assert_eq!(c.read(), vec![20., 14., 56., 41.,]);
}

examples/cpu_cache.rs (line 7)

fn main() {
    let device = CPU::new();

    let a = Matrix::<i16>::new(&device, (100, 100));
    let b = Matrix::<i16>::new(&device, (100, 100));

    let out = a + b;
    let ptr = {
        let cache = device.cache.borrow();
        let mut node = Ident::new(100 * 100);
        node.idx = 0;
        cache.nodes.get(&node).unwrap().ptr
    };

    assert!(ptr == out.as_buf().ptr.ptr as *mut u8);
}

Trait Implementations

impl<T: Float, D: MainMemory, S: Shape> ActivationOps<T, S, D> for CPU

Available on crate feature cpu only.

fn sigmoid(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn sigmoid_grad( &self, activated: &Matrix<'_, T, D, S>, ) -> Matrix<'_, T, Self, S>

fn tanh(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn tanh_grad(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn relu(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn relu_mut(&self, x: &mut Matrix<'_, T, D, S>)

inplace

fn relu_grad(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn relu_grad_mut(&self, x: &mut Matrix<'_, T, D, S>)

inplace

impl<T: Number, D: MainMemory, S: Shape> AdditionalOps<T, S, D> for CPU

Available on crate feature cpu only.

fn adds(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn subs(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn muls(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn divs(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

impl<T, S> Alloc<'_, T, S> for CPU

where S: Shape,

fn alloc(&self, len: usize, flag: AllocFlag) -> CPUPtr<T>

Allocate memory on the implemented device.

fn with_slice(&self, data: &[T]) -> CPUPtr<T>

where T: Clone,

Allocate new memory with data

fn alloc_with_vec(&self, vec: Vec<T>) -> CPUPtr<T>

If the vector vec was allocated previously, this function can be used in order to reduce the amount of allocations, which may be faster than using a slice of vec.

fn with_array(&'a self, array: <S as Shape>::ARR<T>) -> Self::Ptr<T, S>

where T: Clone,

impl<T: Number, D: MainMemory, S: Shape> AssignOps<T, S, D> for CPU

Available on crate feature cpu only.

fn add_assign( &self, lhs: &mut Buffer<'_, T, Self, S>, rhs: &Buffer<'_, T, D, S>, )

Add assign

fn sub_assign( &self, lhs: &mut Buffer<'_, T, Self, S>, rhs: &Buffer<'_, T, D, S>, )

fn mul_assign( &self, lhs: &mut Buffer<'_, T, Self, S>, rhs: &Buffer<'_, T, D, S>, )

impl<T, S, D> BaseOps<T, S, D> for CPU

where T: Number, S: Shape, D: MainMemory,

Available on crate feature cpu only.

fn add( &self, lhs: &Matrix<'_, T, D, S>, rhs: &Matrix<'_, T, D, S>, ) -> Matrix<'_, T, Self, S>

Element-wise addition

fn sub( &self, lhs: &Matrix<'_, T, D, S>, rhs: &Matrix<'_, T, D, S>, ) -> Matrix<'_, T, Self, S>

Element-wise subtraction

fn mul( &self, lhs: &Matrix<'_, T, D, S>, rhs: &Matrix<'_, T, D, S>, ) -> Matrix<'_, T, Self, S>

Element-wise multiplication

fn div( &self, lhs: &Matrix<'_, T, D, S>, rhs: &Matrix<'_, T, D, S>, ) -> Matrix<'_, T, Self, S>

Element-wise division

impl<'a, T> CacheBuf<'a, T> for CPU

fn cached(&'a self, len: usize) -> Buffer<'a, T>

Adds a buffer to the cache. Following calls will return this buffer, if the corresponding internal count matches with the id used in the cache.

impl CacheReturn for CPU

type CT = RawCpuBuf

fn cache(&self) -> RefMut<'_, Cache<CPU>>

Returns a device specific Cache.

impl<T, D> ClearBuf<T, D> for CPU

where T: Default, D: MainMemory,

fn clear(&self, buf: &mut Buffer<'_, T, D>)

Sets all elements of the matrix to zero.

impl<T: Number, D: MainMemory, S: Shape> ClipOp<T, S, D> for CPU

Available on crate feature cpu only.

fn clip( &self, x: &Matrix<'_, T, D, S>, min: T, max: T, ) -> Matrix<'_, T, Self, S>

impl<'a, T, S> CloneBuf<'a, T, S> for CPU

where T: Clone, S: Shape,

fn clone_buf(&'a self, buf: &Buffer<'a, T, CPU, S>) -> Buffer<'a, T, CPU, S>

Creates a deep copy of the specified buffer.

impl<T: Number, D: MainMemory> ColOp<T, D> for CPU

Available on crate feature cpu only.

fn add_col( &self, lhs: &Matrix<'_, T, D>, rhs: &Matrix<'_, T, D>, ) -> Matrix<'_, T>

fn sub_col( &self, lhs: &Matrix<'_, T, D>, rhs: &Matrix<'_, T, D>, ) -> Matrix<'_, T>

fn div_col( &self, lhs: &Matrix<'_, T, D>, rhs: &Matrix<'_, T, D>, ) -> Matrix<'_, T>

impl<T, R, D> CopySlice<T, R, D> for CPU

where T: Copy, R: RangeBounds<usize>, D: MainMemory, [T]: Index<R, Output = [T]>,

fn copy_slice(&self, buf: &Buffer<'_, T, D>, range: R) -> Buffer<'_, T>

Copy a slice of the given buffer into a new buffer.

impl Debug for CPU

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for CPU

fn default() -> CPU

Returns the “default value” for a type.

impl Device for CPU

type Ptr<U, S: Shape> = CPUPtr<U>

type Cache = Cache<CPU>

fn new() -> Result<CPU, Box<dyn Error + Sync + Send>>

fn retrieve<T, S>( &self, len: usize, add_node: impl AddGraph, ) -> Buffer<'_, T, Self, S>

where S: Shape, Self: for<'a> Alloc<'a, T, S>,

impl<T: Default + Copy, D: MainMemory> DiagflatOp<T, D> for CPU

Available on crate feature cpu only.

fn diagflat(&self, x: &Matrix<'_, T, D>) -> Matrix<'_, T>

impl<T, D, S> FnsOps<T, S, D> for CPU

where T: Float, D: MainMemory, S: Shape,

Available on crate feature cpu only.

fn exp(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn ln(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn neg(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn powf(&self, x: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn powi(&self, x: &Matrix<'_, T, D, S>, rhs: i32) -> Matrix<'_, T, Self, S>

impl<T, D, LS, RS, OS> Gemm<T, LS, RS, OS, D> for CPU

where T: Default + Copy + Mul<Output = T> + AddAssign, D: MainMemory, LS: Shape, RS: Shape, OS: Shape,

Available on crate feature cpu only.

fn gemm( &self, lhs: &Matrix<'_, T, D, LS>, rhs: &Matrix<'_, T, D, RS>, ) -> Matrix<'_, T, Self, OS>

impl GraphReturn for CPU

fn graph(&self) -> RefMut<'_, Graph>

impl MainMemory for CPU

fn as_ptr<T, S>(ptr: &<CPU as Device>::Ptr<T, S>) -> *const T

where S: Shape,

fn as_ptr_mut<T, S>(ptr: &mut <CPU as Device>::Ptr<T, S>) -> *mut T

where S: Shape,

impl<T: Copy + PartialOrd, D: MainMemory> MaxOps<T, D> for CPU

Available on crate feature cpu only.

fn max(&self, x: &Matrix<'_, T, D>) -> T

fn max_rows(&self, x: &Matrix<'_, T, D>) -> Matrix<'_, T>

fn max_cols(&self, x: &Matrix<'_, T, D>) -> Matrix<'_, T>

impl RawConv for CPU

fn construct<T, S>( ptr: &<CPU as Device>::Ptr<T, S>, len: usize, node: Node, ) -> <CPU as CacheReturn>::CT

where S: Shape,

fn destruct<T, S>( ct: &<CPU as CacheReturn>::CT, flag: AllocFlag, ) -> (<CPU as Device>::Ptr<T, S>, Node)

where S: Shape,

impl<T, D, S> Read<T, D, S> for CPU

where D: MainMemory, S: Shape,

type Read<'a> = &'a [T] where T: 'a, D: 'a, S: 'a

fn read<'a>( &self, buf: &'a Buffer<'_, T, D, S>, ) -> <CPU as Read<T, D, S>>::Read<'a>

Read the data of the Buffer as type Read.

fn read_to_vec<'a>(&self, buf: &Buffer<'_, T, D, S>) -> Vec<T>

where T: Default + Clone,

Read the data of a buffer into a vector

impl<T: Number, D: MainMemory, LS: Shape, RS: Shape> RowOp<T, LS, RS, D> for CPU

Available on crate feature cpu only.

fn add_row( &self, lhs: &Matrix<'_, T, D, LS>, rhs: &Matrix<'_, T, D, RS>, ) -> Matrix<'_, T, Self, LS>

fn add_row_mut( &self, lhs: &mut Matrix<'_, T, D, LS>, rhs: &Matrix<'_, T, D, RS>, )

impl<T, D: MainMemory, S: Shape> ScalarAssign<T, S, D> for CPU

where T: Copy + AddAssign + MulAssign + DivAssign + SubAssign,

Available on crate feature cpu only.

fn adds_assign(&self, lhs: &mut Matrix<'_, T, D, S>, rhs: T)

fn muls_assign(&self, lhs: &mut Matrix<'_, T, D, S>, rhs: T)

fn divs_assign(&self, lhs: &mut Matrix<'_, T, D, S>, rhs: T)

fn subs_assign(&self, lhs: &mut Matrix<'_, T, D, S>, rhs: T)

impl<T: Float + GenericBlas + MatrixMultiply> SoftmaxOps<T> for CPU

where CPU: ColOp<T>,

Available on crate feature cpu only.

fn softmax(&self, inputs: &Matrix<'_, T>) -> Matrix<'_, T>

fn softmax_grad( &self, activated: &Matrix<'_, T>, grads: &Matrix<'_, T>, ) -> Matrix<'_, T>

impl<T: Number, D: MainMemory, IS: Shape> SumOps<T, IS, D> for CPU

Available on crate feature cpu only.

fn sum(&self, x: &Matrix<'_, T, D, IS>) -> T

fn mean(&self, x: &Matrix<'_, T, D, IS>) -> T

impl<T: Copy + Default + AddAssign, D: MainMemory, IS: Shape, OS: Shape> SumOverOps<T, IS, OS, D> for CPU

Available on crate feature cpu only.

fn sum_rows(&self, x: &Matrix<'_, T, D, IS>) -> Matrix<'_, T, Self, OS>

fn sum_cols(&self, x: &Matrix<'_, T, D, IS>) -> Matrix<'_, T, Self, OS>

impl<T: Default + Copy, D: MainMemory, IS: Shape, OS: Shape> TransposeOp<T, IS, OS, D> for CPU

Available on crate feature cpu only.

fn transpose(&self, x: &Matrix<'_, T, D, IS>) -> Matrix<'_, T, Self, OS>

impl<T, D> WriteBuf<T, D> for CPU

where T: Copy, D: MainMemory,

fn write(&self, buf: &mut Buffer<'_, T, D>, data: &[T])

Write data to the buffer.

fn write_buf( &self, _dst: &mut Buffer<'_, T, Self, S>, _src: &Buffer<'_, T, Self, S>, )

Writes data from Buffer to other Buffer.

impl<'a, T> DevicelessAble<'a, T> for CPU