def test_abs(self): sys = py4hw.HWSystem() fp = py4hw.FloatingPointHelper() a = sys.wire('a', 32) b = sys.wire('b', 32) gt = sys.wire('gt') eq= sys.wire('eq') lt = sys.wire('lt') py4hw.FPComparator_SP(sys, 'cmp', a, b, gt, eq, lt, absolute=True) av = -971.0587159810018 bv = -353.1498041093273 a.put(fp.sp_to_ieee754(av)) b.put(fp.sp_to_ieee754(bv)) print('TESTING: ', av, bv, fp.zp_bin(fp.sp_to_ieee754(av), 32), fp.zp_bin(fp.sp_to_ieee754(bv), 32)) sys.getSimulator().clk(1) assert(bool(gt.get()) == (abs(av) > abs(bv))) assert(bool(eq.get()) == (abs(av) == abs(bv))) assert(bool(lt.get()) == (abs(av) < abs(bv)))
def test_1(self): sys = py4hw.HWSystem() fp = py4hw.FloatingPointHelper() a = sys.wire('a', 32) b = sys.wire('b', 32) gt = sys.wire('gt') eq= sys.wire('eq') lt = sys.wire('lt') py4hw.FPComparator_SP(sys, 'cmp', a, b, gt, eq, lt) av = 305.531528442573 bv = 443.5870680854455 a.put(fp.sp_to_ieee754(av)) b.put(fp.sp_to_ieee754(bv)) print('TESTING: ', av, bv, fp.zp_bin(fp.sp_to_ieee754(av), 32), fp.zp_bin(fp.sp_to_ieee754(bv), 32)) sys.getSimulator().clk(1) assert(bool(gt.get()) == (av > bv)) assert(bool(eq.get()) == (av == bv)) assert(bool(lt.get()) == (av < bv))
def test_1(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) c = sys.wire("c", 32) r1 = sys.wire("r1", 32) r2 = sys.wire("r2", 32) r3 = sys.wire("r3", 32) py4hw.And2(sys, "and1", a, b, r1) py4hw.And2(sys, "and2", a, c, r2) py4hw.And2(sys, "and3", b, c, r3) py4hw.Constant(sys, "a", 0xF, a) py4hw.Constant(sys, "b", 0xA, b) py4hw.Constant(sys, "c", 0x5, c) py4hw.Scope(sys, "r1 (0xF & 0xA)", r1) py4hw.Scope(sys, "r2 (0xF & 0x5)", r2) py4hw.Scope(sys, "r3 (0xA & 0x5)", r3) sys.getSimulator().clk(1) assert (r1.get() == 10) assert (r2.get() == 5) assert (r3.get() == 0)
def test_random_abs(self): import random sys = py4hw.HWSystem() fp = py4hw.FloatingPointHelper() a = sys.wire('a', 32) b = sys.wire('b', 32) gt = sys.wire('gt') eq= sys.wire('eq') lt = sys.wire('lt') py4hw.FPComparator_SP(sys, 'cmp', a, b, gt, eq, lt, absolute=True) for i in range(100): av = (random.random()-0.5) * 2000 bv = (random.random()-0.5) * 2000 a.put(fp.sp_to_ieee754(av)) b.put(fp.sp_to_ieee754(bv)) print('TESTING: ', av, bv) sys.getSimulator().clk(1) assert(bool(gt.get()) == (abs(av) > abs(bv))) assert(bool(eq.get()) == (abs(av) == abs(bv))) assert(bool(lt.get()) == (abs(av) < abs(bv)))
def test_1(self): print('testing minterms equal to 5') sys = py4hw.HWSystem() r = sys.wire("r", 1) a0 = sys.wire("a0", 1) a1 = sys.wire("a1", 1) a2 = sys.wire("a2", 1) exp_a0 = [0, 1, 0, 1, 0, 1, 0, 1] exp_a1 = [0, 0, 1, 1, 0, 0, 1, 1] exp_a2 = [0, 0, 0, 0, 1, 1, 1, 1] py4hw.Sequence(sys, "a0", exp_a0, a0) py4hw.Sequence(sys, "a1", exp_a1, a1) py4hw.Sequence(sys, "a2", exp_a2, a2) py4hw.Minterm(sys, 'minterm', [a0, a1, a2], 5, r) for i in range(8): sys.getSimulator().clk(1) rv = r.get() a0v = a0.get() a1v = a1.get() a2v = a2.get() print(a2v, a1v, a0v, rv) assert (a0v == exp_a0[i]) assert (a1v == exp_a1[i]) assert (a2v == exp_a2[i])
def test_3(self): # concatenating larger wires should raise an error sys = py4hw.HWSystem() a = sys.wire("a", 13) b = sys.wire("b", 23) c = sys.wire("c", 11) r = sys.wire("r", 32) av = 11 bv = 23 cv = 111 try: py4hw.ConcatenateMSBF(sys, "concat", [a, b, c], r) a.put(av) b.put(bv) c.put(cv) sys.getSimulator().clk(1) exception = False except: exception = True assert (exception)
def test_1(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) r1 = sys.wire("r", 32) py4hw.Constant(sys, "a", 10, a) py4hw.Constant(sys, "b", 20, b) py4hw.Add(sys, "add1", a, b, r1) sys.getSimulator().clk(1) assert (r1.get() == 30)
def test_integrity(self): sys = py4hw.HWSystem() a = sys.wire("a", 2) r = sys.wire("r", 1) py4hw.Constant(sys, "a", 0, a) py4hw.EqualConstant(sys, 'equal', a, 0, r) py4hw.debug.checkIntegrity(sys)
def test_And_integrity(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) c = sys.wire("c", 32) r = sys.wire("r", 32) py4hw.Constant(sys, "a", 0xF7F7, a) py4hw.Constant(sys, "b", 0x7685, b) py4hw.Constant(sys, "c", 0x3452, c) py4hw.And(sys, 'andx', [a, b, c], r) py4hw.debug.checkIntegrity(sys)
def test_printHierarchyWithValuesFormat(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) c = sys.wire("c", 32) r = sys.wire("r", 32) py4hw.Constant(sys, "a", 0xF7F7, a) py4hw.Constant(sys, "b", 0x7685, b) py4hw.Constant(sys, "c", 0x3452, c) py4hw.And(sys, 'andx', [a, b, c], r) py4hw.debug.printHierarchyWithValues(sys, format="{}")
def test_notEqual(self): sys = py4hw.HWSystem() a = sys.wire("a", 2) r = sys.wire("r", 1) py4hw.Constant(sys, "a", 3, a) py4hw.EqualConstant(sys, 'equal', a, 0, r) sys.getSimulator().clk(1) assert (r.get() == 0)
def test_noneEqual(self): sys = py4hw.HWSystem() ins = sys.wires('wi', 3, 8) py4hw.Constant(sys, 'i0', 3, ins[0]) py4hw.Constant(sys, 'i1', 7, ins[1]) py4hw.Constant(sys, 'i2', 9, ins[2]) r = sys.wire('r', 1) py4hw.AnyEqual(sys, 'any', ins, r) sys.getSimulator().clk(1) assert (r.get() == 0)
def test_And(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) c = sys.wire("c", 32) r = sys.wire("r", 32) py4hw.Constant(sys, "a", 0xF7F7, a) py4hw.Constant(sys, "b", 0x7685, b) py4hw.Constant(sys, "c", 0x3452, c) py4hw.And(sys, 'andx', [a, b, c], r) sys.getSimulator().clk(1) assert (r.get() == 0x3400)
def test_concat_lsbf_1(self): sys = py4hw.HWSystem() a = sys.wire("a", 8) b = sys.wire("b", 8) r = sys.wire("r", 16) av = 0x5F bv = 0x37 py4hw.ConcatenateLSBF(sys, "concat", [a, b], r) a.put(av) b.put(bv) sys.getSimulator().clk(1) assert (r.get() == 0x375F)
def test_1(self): sys = py4hw.HWSystem() reset = sys.wire('reset', 1) inc = sys.wire('inc', 1) count = sys.wire('count', 8) carry = sys.wire('carry', 1) py4hw.Constant(sys, 'reset', 0, reset) py4hw.Constant(sys, 'inc', 1, inc) counter = py4hw.ModuloCounter(sys, 'counter', 3, reset, inc, count, carry) rtlgen = py4hw.VerilogGenerator(counter) print(rtlgen.getVerilog())
def test_oneBitWire(self): print('check values = 1') sys = py4hw.HWSystem() a = sys.wire("a", 1) r = sys.wire("1", 1) py4hw.Sequence(sys, "a", [0, 1], a) py4hw.EqualConstant(sys, 'equal', a, 1, r) for i in range(8): sys.getSimulator().clk(1) v = a.get() exp = 1 if (v == 1) else 0 print(v, exp, r.get()) assert (r.get() == exp)
def test_random(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) r = sys.wire("r", 32) py4hw.Abs(sys, "abs", a, r) import random for i in range(1000): v = random.randint(-((1 << 31) - 1), (1 << 31) - 1) a.put(v) sys.getSimulator().clk(1) assert (r.get() == abs(v))
def test_random(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) r = sys.wire("r") py4hw.Sign(sys, "signTest1", a, r) import random for i in range(1000): v = random.randint(-((1 << 31) - 1), (1 << 31) - 1) a.put(v) sys.getSimulator().clk(1) assert (bool(r.get()) == (v < 0))
def test_Integrity(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) c = sys.wire("c", 32) r1 = sys.wire("r", 32) r2 = sys.wire("r2", 32) py4hw.Add(sys, "add1", a, b, r1) py4hw.Add(sys, "add2", r1, c, r2) py4hw.Constant(sys, "a", 10, a) py4hw.Constant(sys, "b", 20, b) py4hw.Constant(sys, "c", 5, c) py4hw.Scope(sys, "r2", r2) py4hw.debug.checkIntegrity(sys)
def test_sub1(self): sys = py4hw.HWSystem() a = sys.wire('a', 23) b = sys.wire('b', 23) r = sys.wire('r', 24) va = 1623049 vb = 6146853 vr = (va - vb) & ((1 << 24) - 1) py4hw.Constant(sys, 'a', va, a) py4hw.Constant(sys, 'b', vb, b) py4hw.Sub(sys, 'r', a, b, r) sys.getSimulator().clk(1) assert (r.get() == vr)
def test_integrity(self): sys = py4hw.HWSystem() a = sys.wire("a", 2) bits = sys.wires('b', 2, 1) minterm = sys.wire('minterm', 1) py4hw.BitsLSBF(sys, 'bits', a, bits) py4hw.Minterm(sys, 'minterm', bits, 0, minterm) py4hw.Constant(sys, "a", 0, a) for i in range(len(bits)): py4hw.Scope(sys, 'b{}'.format(i), bits[i]) py4hw.Scope(sys, 'minterm_5', minterm) py4hw.debug.checkIntegrity(sys)
def test_1(self): sys = py4hw.HWSystem() g = py4hw.LogicHelper(sys) fp = py4hw.FloatingPointHelper() r = sys.wire('r', 32) av = 1.2 bv = 0.0000002 a = g.hw_constant(32, fp.sp_to_ieee754(av)) b = g.hw_constant(32, fp.sp_to_ieee754(bv)) fpa = py4hw.FPAdder_SP(sys, 'fpa', a, b, r) sys.getSimulator().clk(1) err = fp.ieee754_to_sp(r.get()) - (av + bv) assert (abs(err) < 1E-7)
def test_equal5(self): print('check values = 5') sys = py4hw.HWSystem() a = sys.wire("a", 3) r = sys.wire("1", 1) py4hw.Sequence(sys, "a", [0, 1, 2, 3, 4, 5, 6, 7], a) py4hw.EqualConstant(sys, 'equal', a, 5, r) for i in range(8): sys.getSimulator().clk(1) v = a.get() rv = r.get() exp = 1 if (v == 5) else 0 print(v, exp, rv) assert (rv == exp)
def test_concat_lsbf_2(self): sys = py4hw.HWSystem() a = sys.wire("a", 8) b = sys.wire("b", 8) c = sys.wire("c", 8) r = sys.wire("r", 24) av = 0x5F bv = 0x37 cv = 0xD1 py4hw.ConcatenateLSBF(sys, "concat", [a, b, c], r) a.put(av) b.put(bv) c.put(cv) sys.getSimulator().clk(1) assert (r.get() == 0xD1375F)
def test_random_inv(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) r = sys.wire("r", 32) n = sys.wire("n") py4hw.Abs(sys, "abs", a, r, inverted=n) import random for i in range(1000): v = random.randint(-((1 << 31) - 1), (1 << 31) - 1) a.put(v) sys.getSimulator().clk(1) assert (r.get() == abs(v)) assert (bool(n.get()) == (v < 0))
def test_msbf_3(self): sys = py4hw.HWSystem() a = sys.wire("a", 1) b = sys.wire("b", 8) c = sys.wire("c", 23) r = sys.wire("r", 32) av = 0 bv = 127 cv = 2516585 ev = (127 << 23) | cv py4hw.ConcatenateMSBF(sys, "concat", [a, b, c], r) a.put(av) b.put(bv) c.put(cv) sys.getSimulator().clk(1) assert (r.get() == ev)
def test_EqualWire(self): print('check values = 5') sys = py4hw.HWSystem() a = sys.wire("a", 3) b = sys.wire("b", 3) c = sys.wire("c", 3) r1 = sys.wire("r1", 1) r2 = sys.wire("r2", 1) py4hw.Constant(sys, "a", 3, a) py4hw.Constant(sys, "b", 3, b) py4hw.Constant(sys, "c", 5, c) py4hw.Equal(sys, 'equal1', a, b, r1) py4hw.Equal(sys, 'equal2', a, c, r2) sys.getSimulator().clk(1) assert (r1.get() == 1) assert (r2.get() == 0)
def test_2(self): sys = py4hw.HWSystem() a = sys.wire("a", 5) b = sys.wire("b", 7) c = sys.wire("c", 11) r = sys.wire("r", 32) av = 11 bv = 23 cv = 111 ev = (((av << 7) | bv) << 11) | cv py4hw.ConcatenateMSBF(sys, "concat", [a, b, c], r) a.put(av) b.put(bv) c.put(cv) sys.getSimulator().clk(1) assert (r.get() == ev)
def test_integrity(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) c = sys.wire("c", 32) sa = sys.wire("sa") sb = sys.wire("sb") sc = sys.wire("sc") r = sys.wire("r", 32) py4hw.Sequence(sys, "a", [1, 2, 3], a) py4hw.Sequence(sys, "b", [1, 2, 3], b) py4hw.Sequence(sys, "c", [1, 2, 3], c) py4hw.Sequence(sys, "sa", [1, 0, 0], sa) py4hw.Sequence(sys, "sb", [0, 1, 0], sb) py4hw.Sequence(sys, "sc", [0, 0, 1], sc) py4hw.Select(sys, 'select', [sa, sb, sc], [a, b, c], r) py4hw.debug.checkIntegrity(sys)
def test_printHierarchy(self): sys = py4hw.HWSystem() a = sys.wire("a", 32) b = sys.wire("b", 32) c = sys.wire("c", 32) r1 = sys.wire("r1", 32) r2 = sys.wire("r2", 32) r3 = sys.wire("r3", 32) py4hw.And2(sys, "and1", a, b, r1) py4hw.And2(sys, "and2", a, c, r2) py4hw.And2(sys, "and3", b, c, r3) py4hw.Constant(sys, "a", 0xF, a) py4hw.Constant(sys, "b", 0xA, b) py4hw.Constant(sys, "c", 0x5, c) py4hw.Scope(sys, "r1 (0xF & 0xA)", r1) py4hw.Scope(sys, "r2 (0xF & 0x5)", r2) py4hw.Scope(sys, "r3 (0xA & 0x5)", r3) py4hw.debug.printHierarchy(sys)