celox 0.4.1

Celox HDL Simulator
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
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use celox::Simulator;

#[path = "test_utils/mod.rs"]
#[macro_use]
mod test_utils;

all_backends! {

    // Issue #11: `pub module` wrapper causes "PKG doesn't have member lt"
    // when proto package has no `lt` — the `<:` operator is a builtin comparison,
    // not a proto package function call.
    //
    // Uses a combinational circuit to test that `<:` on PKG::Item resolves
    // correctly to the builtin less-than operator.
    fn test_proto_package_builtin_comparison(sim) {
        @ignore_on(sv);
        @setup { let code = r#"
proto package ItemProto {
type Item;
}
package ItemU16 for ItemProto {
type Item = logic<16>;
}
module Comparator::<PKG: ItemProto> (
a    : input  PKG::Item,
b    : input  PKG::Item,
a_lt : output logic    ,
) {
assign a_lt = a <: b;
}
pub module ComparatorU16 (
a    : input  logic<16>,
b    : input  logic<16>,
a_lt : output logic    ,
) {
inst c: Comparator::<ItemU16> (a, b, a_lt);
}
"#; }
        @build Simulator::builder(code, "ComparatorU16");
    let a = sim.signal("a");
    let b = sim.signal("b");
    let a_lt = sim.signal("a_lt");

    // 10 < 20 → true
    sim.modify(|io| {
        io.set(a, 10u16);
        io.set(b, 20u16);
    })
    .unwrap();
    assert_eq!(sim.get(a_lt), 1u8.into());

    // 20 < 10 → false
    sim.modify(|io| {
        io.set(a, 20u16);
        io.set(b, 10u16);
    })
    .unwrap();
    assert_eq!(sim.get(a_lt), 0u8.into());

    // 10 < 10 → false (strict less-than)
    sim.modify(|io| {
        io.set(a, 10u16);
        io.set(b, 10u16);
    })
    .unwrap();
    assert_eq!(sim.get(a_lt), 0u8.into());

    }

    // Positive control: proto package with an explicit `lt` function works correctly.
    // This confirms that proto package function dispatch is functional.
    fn test_proto_package_with_custom_function(sim) {
        @ignore_on(sv);
        @setup { let code = r#"
proto package ItemProto {
type Item;
function lt(
a: input Item,
b: input Item,
) -> logic;
}
package ItemU16 for ItemProto {
type Item = logic<16>;
function lt(
a: input Item,
b: input Item,
) -> logic {
return a <: b;
}
}
module Comparator::<PKG: ItemProto> (
a    : input  PKG::Item,
b    : input  PKG::Item,
a_lt : output logic    ,
) {
assign a_lt = PKG::lt(a, b);
}
pub module ComparatorU16 (
a    : input  logic<16>,
b    : input  logic<16>,
a_lt : output logic    ,
) {
inst c: Comparator::<ItemU16> (a, b, a_lt);
}
"#; }
        @build Simulator::builder(code, "ComparatorU16");
    let a = sim.signal("a");
    let b = sim.signal("b");
    let a_lt = sim.signal("a_lt");

    // 10 < 20 → true
    sim.modify(|io| {
        io.set(a, 10u16);
        io.set(b, 20u16);
    })
    .unwrap();
    assert_eq!(sim.get(a_lt), 1u8.into());

    // 20 < 10 → false
    sim.modify(|io| {
        io.set(a, 20u16);
        io.set(b, 10u16);
    })
    .unwrap();
    assert_eq!(sim.get(a_lt), 0u8.into());

    // 10 < 10 → false
    sim.modify(|io| {
        io.set(a, 10u16);
        io.set(b, 10u16);
    })
    .unwrap();
    assert_eq!(sim.get(a_lt), 0u8.into());

    }
}