Skip to main content

tpt_uir_core/
lib.rs

1#![no_std]
2#![doc = include_str!("../README.md")]
3extern crate alloc;
4
5pub mod attr;
6pub mod builder;
7pub mod ir;
8pub mod op_name;
9pub mod quant;
10pub mod types;
11
12pub use attr::*;
13pub use builder::*;
14pub use ir::*;
15pub use op_name::*;
16pub use quant::*;
17pub use types::*;
18
19#[cfg(test)]
20mod tests {
21    extern crate std;
22    use super::*;
23    use alloc::string::ToString;
24    use alloc::vec;
25
26    #[test]
27    fn scalar_type_sizes() {
28        use ScalarType::*;
29        assert_eq!(I8.size_bytes(), 1);
30        assert_eq!(I16.size_bytes(), 2);
31        assert_eq!(I32.size_bytes(), 4);
32        assert_eq!(I64.size_bytes(), 8);
33        assert_eq!(U8.size_bytes(), 1);
34        assert_eq!(U16.size_bytes(), 2);
35        assert_eq!(U32.size_bytes(), 4);
36        assert_eq!(U64.size_bytes(), 8);
37        assert_eq!(F16.size_bytes(), 2);
38        assert_eq!(F32.size_bytes(), 4);
39        assert_eq!(F64.size_bytes(), 8);
40        assert_eq!(BF16.size_bytes(), 2);
41        assert_eq!(Bool.size_bytes(), 1);
42        assert_eq!(Q8_0.size_bytes(), 1);
43        // Packed 4-bit formats have no whole-byte per-element size.
44        assert_eq!(Q4_0.size_bytes(), 0);
45        assert_eq!(Q4_1.size_bytes(), 0);
46    }
47
48    #[test]
49    fn opname_parse_roundtrip() {
50        let n = OpName::parse("tpt_gpu.launch").unwrap();
51        assert!(n.dialect == "tpt_gpu");
52        assert!(n.op == "launch");
53        assert_eq!(n.to_string(), "tpt_gpu.launch");
54
55        assert!(OpName::parse("invalid").is_err());
56        assert!(OpName::parse(".op").is_err());
57        assert!(OpName::parse("d.").is_err());
58        assert!(OpName::parse("").is_err());
59    }
60
61    #[test]
62    fn ssa_validation_ok() {
63        let region = Region {
64            blocks: vec![Block {
65                arguments: vec![(0u32, Type::Index)],
66                operations: vec![Operation {
67                    id: 1,
68                    op_name: OpName::parse("core.add").unwrap(),
69                    operands: vec![0],
70                    results: vec![1],
71                    regions: vec![],
72                    attributes: vec![],
73                }],
74            }],
75        };
76        assert!(validate_region(&region).is_ok());
77    }
78
79    #[test]
80    fn ssa_validation_error() {
81        let region = Region {
82            blocks: vec![Block {
83                arguments: vec![],
84                operations: vec![Operation {
85                    id: 1,
86                    op_name: OpName::parse("core.add").unwrap(),
87                    operands: vec![99],
88                    results: vec![],
89                    regions: vec![],
90                    attributes: vec![],
91                }],
92            }],
93        };
94        let errs = validate_region(&region);
95        assert!(errs.is_err());
96        assert!(!errs.unwrap_err().is_empty());
97    }
98}