furiosa-opt-std 0.3.0

Standard library for Furiosa NPU TCP Virtual ISA programming.
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! HasAlu trait for ops that provide ALU information.

use super::{
    ClipBinaryOpF32, ClipBinaryOpI32, ClipOpF, ClipOpI, FpBinaryOp, FpDivBinaryOp, FpDivOp, FpTernaryOp, FpUnaryOp,
    FxpBinaryOp, FxpOp, LogicBinaryOpF32, LogicBinaryOpI32, LogicOpF, LogicOpI,
};
use crate::engine::vector::alu::RngdAlu;

/// Trait for ops that provide ALU information.
pub trait HasAlu {
    /// Returns the ALU this operation uses.
    fn alu(&self) -> RngdAlu;
}

// ============================================================================
// HasAlu implementations
// ============================================================================

impl HasAlu for LogicBinaryOpI32 {
    fn alu(&self) -> RngdAlu {
        LogicBinaryOpI32::alu(self)
    }
}

impl HasAlu for LogicBinaryOpF32 {
    fn alu(&self) -> RngdAlu {
        LogicBinaryOpF32::alu(self)
    }
}

impl HasAlu for FxpBinaryOp {
    fn alu(&self) -> RngdAlu {
        FxpBinaryOp::alu(self)
    }
}

impl HasAlu for FpUnaryOp {
    fn alu(&self) -> RngdAlu {
        FpUnaryOp::alu(self)
    }
}

impl HasAlu for FpBinaryOp {
    fn alu(&self) -> RngdAlu {
        FpBinaryOp::alu(self)
    }
}

impl HasAlu for FpTernaryOp {
    fn alu(&self) -> RngdAlu {
        FpTernaryOp::alu(self)
    }
}

impl HasAlu for FpDivBinaryOp {
    fn alu(&self) -> RngdAlu {
        FpDivBinaryOp::alu(self)
    }
}

impl HasAlu for FpDivOp {
    fn alu(&self) -> RngdAlu {
        self.op.alu()
    }
}

impl HasAlu for ClipBinaryOpI32 {
    fn alu(&self) -> RngdAlu {
        ClipBinaryOpI32::alu(self)
    }
}

impl HasAlu for ClipBinaryOpF32 {
    fn alu(&self) -> RngdAlu {
        ClipBinaryOpF32::alu(self)
    }
}

// HasAlu implementations for "with mode" types
impl HasAlu for FxpOp {
    fn alu(&self) -> RngdAlu {
        self.op.alu()
    }
}

impl HasAlu for LogicOpI {
    fn alu(&self) -> RngdAlu {
        self.op.alu()
    }
}

impl HasAlu for LogicOpF {
    fn alu(&self) -> RngdAlu {
        self.op.alu()
    }
}

impl HasAlu for ClipOpI {
    fn alu(&self) -> RngdAlu {
        self.op.alu()
    }
}

impl HasAlu for ClipOpF {
    fn alu(&self) -> RngdAlu {
        self.op.alu()
    }
}