hardware 0.0.9

A no_std bare-metal hardware abstraction layer — all port I/O, memory and swap allocations are guarded at runtime. Do not consider this dependency stable before x.1.x
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use crate::dma::buffer::DmaBuffer;

pub struct LpuBuffer {
    dma: DmaBuffer,
    rows: usize,
    cols: usize,
    elem_size: usize,
}

impl LpuBuffer {
    pub fn rows(&self) -> usize {
        self.rows
    }

    pub fn cols(&self) -> usize {
        self.cols
    }

    pub fn elem_size(&self) -> usize {
        self.elem_size
    }

    pub fn len_bytes(&self) -> usize {
        self.rows
            .saturating_mul(self.cols)
            .saturating_mul(self.elem_size)
    }

    pub fn as_ptr(&self) -> *mut u8 {
        self.dma.as_ptr()
    }

    pub fn into_dma(self) -> DmaBuffer {
        self.dma
    }
}

pub struct LpuMemory;

impl LpuMemory {
    pub fn alloc_matrix(
        rows: usize,
        cols: usize,
        elem_size: usize,
        align: usize,
    ) -> Option<LpuBuffer> {
        if rows == 0 || cols == 0 || elem_size == 0 {
            return None;
        }
        let len = rows.checked_mul(cols)?.checked_mul(elem_size)?;
        let dma = DmaBuffer::new(len, align)?;
        Some(LpuBuffer {
            dma,
            rows,
            cols,
            elem_size,
        })
    }

    pub fn alloc_tokens(tokens: usize, hidden_size: usize, align: usize) -> Option<LpuBuffer> {
        Self::alloc_matrix(tokens, hidden_size, 1, align)
    }
}