def test_BitsFromIncompatibleType(self):
t = Bits(2)
with self.assertRaises(ValueError):
t.fromPy("a1")
with self.assertRaises(TypeError):
t.fromPy(object())
def test_BitsFromIncompatibleType(self):
t = Bits(2)
with self.assertRaises(ValueError):
t.fromPy("a1")
with self.assertRaises(TypeError):
t.fromPy(object())
def test_8b_xor(self, t=int8_t):
ut = Bits(t.bit_length())
m = t.all_mask()
v = t.fromPy(-1)
self.assertEqual(v ^ ut.fromPy(m), 0)
self.assertEqual(v ^ ut.fromPy(0), -1)
self.assertEqual(v ^ ut.fromPy(1), -2)
def test_8b_xor(self, t=int8_t):
ut = Bits(t.bit_length())
m = t.all_mask()
v = t.fromPy(-1)
self.assertEqual(v ^ ut.fromPy(m), 0)
self.assertEqual(v ^ ut.fromPy(0), -1)
self.assertEqual(v ^ ut.fromPy(1), -2)
def test_BitsIndexOnSingleBit(self):
t = Bits(1)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v[0]
t = Bits(1, forceVector=True)
v = t.fromPy(1)
self.assertEqual(v[0], hBit(1))
def test_BitsIndexOnSingleBit(self):
t = Bits(1)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v[0]
t = Bits(1, forceVector=True)
v = t.fromPy(1)
self.assertEqual(v[0], hBit(1))
def test_8b_cast(self, t=int8_t):
w = t.bit_length()
ut = Bits(w)
self.assertEqual(int(t.fromPy(-1)._auto_cast(ut)), mask(w))
self.assertEqual(int(t.fromPy(-1)._unsigned()), mask(w))
self.assertEqual(int(t.fromPy(-1)._vec()), mask(w))
self.assertEqual(int(t.fromPy(1)._auto_cast(ut)), 1)
self.assertEqual(int(t.fromPy(0)._auto_cast(ut)), 0)
self.assertEqual(int(ut.fromPy(1)._auto_cast(t)), 1)
self.assertEqual(int(ut.fromPy(mask(w))._auto_cast(t)), -1)
self.assertEqual(int(ut.fromPy(mask(w))._signed()), -1)
def test_BitsFromPyEnum(self):
class PyEnumCls(Enum):
A = 1
B = 3
C = 4
t = Bits(2)
self.assertValEq(t.fromPy(PyEnumCls.A), 1)
self.assertValEq(t.fromPy(PyEnumCls.B), 3)
with self.assertRaises(ValueError):
t.fromPy(PyEnumCls.C)
def test_8b_and(self, t=int8_t):
low, up, intLow, intUp = self.getMinMaxVal(t)
ut = Bits(t.bit_length())
m = t.all_mask()
v = t.fromPy(-1)
self.assertEqual(v & ut.fromPy(m), -1)
self.assertEqual(v & ut.fromPy(0), 0)
self.assertEqual(v & ut.fromPy(1), 1)
self.assertEqual(low & up, 0)
self.assertEqual(low & -1, intLow)
self.assertEqual(up & ut.fromPy(m), intUp)
def test_BitsFromPyEnum(self):
class PyEnumCls(Enum):
A = 1
B = 3
C = 4
t = Bits(2)
self.assertValEq(t.fromPy(PyEnumCls.A), 1)
self.assertValEq(t.fromPy(PyEnumCls.B), 3)
with self.assertRaises(ValueError):
t.fromPy(PyEnumCls.C)
def test_8b_cast(self, t=int8_t):
w = t.bit_length()
ut = Bits(w)
self.assertEqual(int(t.fromPy(-1)._auto_cast(ut)), mask(w))
self.assertEqual(int(t.fromPy(-1)._unsigned()), mask(w))
self.assertEqual(int(t.fromPy(-1)._vec()), mask(w))
self.assertEqual(int(t.fromPy(1)._auto_cast(ut)), 1)
self.assertEqual(int(t.fromPy(0)._auto_cast(ut)), 0)
self.assertEqual(int(ut.fromPy(1)._auto_cast(t)), 1)
self.assertEqual(int(ut.fromPy(mask(w))._auto_cast(t)), -1)
self.assertEqual(int(ut.fromPy(mask(w))._signed()), -1)
def test_8b_and(self, t=int8_t):
low, up, intLow, intUp = self.getMinMaxVal(t)
ut = Bits(t.bit_length())
m = t.all_mask()
v = t.fromPy(-1)
self.assertEqual(v & ut.fromPy(m), -1)
self.assertEqual(v & ut.fromPy(0), 0)
self.assertEqual(v & ut.fromPy(1), 1)
self.assertEqual(low & up, 0)
self.assertEqual(low & -1, intLow)
self.assertEqual(up & ut.fromPy(m), intUp)
def test_8b_or(self, t=int8_t):
ut = Bits(t.bit_length())
m = t.all_mask()
low, up, intLow, intUp = self.getMinMaxVal(t)
v = t.fromPy(-1)
self.assertEqual(v | ut.fromPy(m), -1)
self.assertEqual(v | ut.fromPy(0), -1)
self.assertEqual(low | ut.fromPy(m), -1)
self.assertEqual(low | ut.fromPy(0), intLow)
self.assertEqual(up | ut.fromPy(m), -1)
self.assertEqual(up | ut.fromPy(0), intUp)
def test_8b_or(self, t=int8_t):
ut = Bits(t.bit_length())
m = t.all_mask()
low, up, intLow, intUp = self.getMinMaxVal(t)
v = t.fromPy(-1)
self.assertEqual(v | ut.fromPy(m), -1)
self.assertEqual(v | ut.fromPy(0), -1)
self.assertEqual(low | ut.fromPy(m), -1)
self.assertEqual(low | ut.fromPy(0), intLow)
self.assertEqual(up | ut.fromPy(m), -1)
self.assertEqual(up | ut.fromPy(0), intUp)
def test_8b_mul(self, t=int8_t):
w = t.bit_length()
low, up, _, _ = self.getMinMaxVal(t)
ut = Bits(w)
self.assertEqual(int(t.fromPy(-1) * t.fromPy(-1)), 1)
self.assertEqual(int(t.fromPy(0) * t.fromPy(-1)), 0)
self.assertEqual(int(ut.fromPy(0) * ut.fromPy(1)), 0)
self.assertEqual(int(ut.fromPy(mask(w)) * ut.fromPy(2)), (mask(w) << 1) & mask(w))
self.assertEqual(int(t.fromPy(-1) * ut.fromPy(2)), -2)
self.assertEqual(low * t.fromPy(2), 0)
self.assertEqual(up * t.fromPy(2), -2)
m = up * t.fromPy(None)
self.assertEqual(valToInt(m), None)
def test_array_eq_neq(self):
t = Bits(8)[5]
v0 = t.fromPy(range(5))
v1 = t.fromPy({0: 10, 1: 2})
v2 = t.fromPy([1, 2, 3, 4, 5])
self.assertTrue(v0._eq(v0))
with self.assertRaises(ValueError):
self.assertNotEqual(v0, v1)
self.assertNotEqual(v0, v2)
with self.assertRaises(ValueError):
self.assertNotEqual(v1, v2)
with self.assertRaises(ValueError):
self.assertNotEqual(v1, v1)
self.assertTrue(v2, v2)
def test_array_eq_neq(self):
t = Bits(8)[5]
v0 = t.fromPy(range(5))
v1 = t.fromPy({0: 10, 1: 2})
v2 = t.fromPy([1, 2, 3, 4, 5])
self.assertTrue(v0._eq(v0))
with self.assertRaises(ValueError):
self.assertNotEqual(v0, v1)
self.assertNotEqual(v0, v2)
with self.assertRaises(ValueError):
self.assertNotEqual(v1, v2)
with self.assertRaises(ValueError):
self.assertNotEqual(v1, v1)
self.assertTrue(v2, v2)
def _get(self, numberOfBits: int, doCollect: bool):
"""
:param numberOfBits: number of bits to get from actual possition
:param doCollect: if False output is not collected just iterator moves
in structure
"""
if not isinstance(numberOfBits, int):
numberOfBits = int(numberOfBits)
while self.actuallyHave < numberOfBits:
# accumulate while not has enought
try:
f = next(self.it)
except StopIteration:
if self.fillup and self.actual is not None:
break
else:
raise NotEnoughtBitsErr()
thisFieldLen = f._dtype.bit_length()
if self.actual is None:
if not doCollect and thisFieldLen <= numberOfBits:
numberOfBits -= thisFieldLen
else:
self.actual = f
self.actuallyHave = thisFieldLen
else:
if not doCollect and self.actuallyHave < numberOfBits:
self.actuallyHave = thisFieldLen
self.actual = f
else:
self.actuallyHave += thisFieldLen
self.actual = f._concat(self.actual)
# slice out from actual
actual = self.actual
actualOffset = self.actualOffset
if self.actuallyHave < numberOfBits:
assert self.fillup
if doCollect:
t = self.actual._dtype
fillupW = numberOfBits - self.actuallyHave
padding_t = Bits(fillupW, signed=t.signed, negated=t.negated)
padding = padding_t.fromPy(None)
actual = padding._concat(actual)
self.actuallyHave = 0
# update about what was taken
self.actuallyHave -= numberOfBits
self.actualOffset += numberOfBits
if self.actuallyHave == 0:
self.actual = None
self.actualOffset = 0
if doCollect:
if numberOfBits == 1:
return actual[actualOffset]
else:
return actual[(actualOffset + numberOfBits):actualOffset]
def makeTestbenchTemplate(unit: Unit, name: str=None):
"""
:param unit: synthesized unit
:return: (entity, arch, context) of testbench
"""
if name is None:
name = unit._name + "_tb"
entity = Entity(name)
arch = Architecture(entity)
arch.components.append(unit._entity)
arch.componentInstances.append(unit._entity)
nl = RtlNetlist()
ctx = {}
for p in unit._entity.ports:
t = p._dtype
if isinstance(t, Bits) and not t == BIT:
t = Bits(t.bit_length(), signed=t.signed,
forceVector=t.forceVector)
s = RtlSignal(nl, p.name, t, t.fromPy(0))
ctx[p._interface] = s
p.connectSig(s)
arch.variables.extend(ctx.values())
return entity, arch, ctx
def test_8b_mul(self, t=int8_t):
w = t.bit_length()
low, up, _, _ = self.getMinMaxVal(t)
ut = Bits(w)
self.assertEqual(int(t.fromPy(-1) * t.fromPy(-1)), 1)
self.assertEqual(int(t.fromPy(0) * t.fromPy(-1)), 0)
self.assertEqual(int(ut.fromPy(0) * ut.fromPy(1)), 0)
self.assertEqual(int(ut.fromPy(mask(w)) * ut.fromPy(2)),
(mask(w) << 1) & mask(w))
self.assertEqual(int(t.fromPy(-1) * ut.fromPy(2)), -2)
self.assertEqual(low * t.fromPy(2), 0)
self.assertEqual(up * t.fromPy(2), -2)
m = up * t.fromPy(None)
self.assertEqual(valToInt(m), None)
def test_BitsConcatIncompatibleType(self):
t = Bits(1)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v._concat(hInt(2))
p = Param(1)
with self.assertRaises(TypeError):
v._concat(p)
def test_BitsConcatIncompatibleType(self):
t = Bits(1)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v._concat(hInt(2))
p = Param(1)
with self.assertRaises(TypeError):
v._concat(p)
def test_BitsIndexTypes(self):
t = Bits(8)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v[object()]
with self.assertRaises(IndexError):
v[9:]
with self.assertRaises(IndexError):
v[:-1]
p = Param(2)
self.assertIsInstance(v[p], RtlSignalBase)
self.assertEqual(v[p]._dtype.bit_length(), 1)
p2 = p._downto(0)
self.assertIsInstance(v[p2], RtlSignalBase)
self.assertEqual(v[p2]._dtype.bit_length(), 2)
p3 = Param("abc")
with self.assertRaises(TypeError):
v[p3]
a = RtlSignal(None, "a", BIT)
a._const = False
with self.assertRaises(TypeError):
v[p] = a
with self.assertRaises(TypeError):
v[a] = p
v[p] = 1
self.assertEqual(v, 5)
v[p2] = 2
self.assertEqual(v, 6)
with self.assertRaises(TypeError):
v[hInt(None)] = 2
v[:] = 0
self.assertEqual(v, 0)
v[2] = 1
self.assertEqual(v, 4)
v[3:] = p
self.assertEqual(v, 2)
v._setitem__val(hInt(None), hInt(1))
with self.assertRaises(ValueError):
int(v)
with self.assertRaises(TypeError):
v[hStr("asfs")]
def test_BitsIndexTypes(self):
t = Bits(8)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v[object()]
with self.assertRaises(IndexError):
v[9:]
with self.assertRaises(IndexError):
v[:-1]
p = Param(2)
self.assertIsInstance(v[p], RtlSignalBase)
self.assertEqual(v[p]._dtype.bit_length(), 1)
p2 = p._downto(0)
self.assertIsInstance(v[p2], RtlSignalBase)
self.assertEqual(v[p2]._dtype.bit_length(), 2)
p3 = Param("abc")
with self.assertRaises(TypeError):
v[p3]
a = RtlSignal(None, "a", BIT)
a._const = False
with self.assertRaises(TypeError):
v[p] = a
with self.assertRaises(TypeError):
v[a] = p
v[p] = 1
self.assertEqual(v, 5)
v[p2] = 2
self.assertEqual(v, 6)
with self.assertRaises(TypeError):
v[hInt(None)] = 2
v[:] = 0
self.assertEqual(v, 0)
v[2] = 1
self.assertEqual(v, 4)
v[3:] = p
self.assertEqual(v, 2)
v._setitem__val(hInt(None), hInt(1))
with self.assertRaises(ValueError):
int(v)
with self.assertRaises(TypeError):
v[hStr("asfs")]
def __setitem__(self, index, value):
"""this can not be called in desing description on non static values,
only simulator can resolve this (in design use self[index] ** value
instead of self[index] = value)
"""
# convert index to hSlice or hInt
indexConst = True
if not isinstance(index, Value):
if isinstance(index, RtlSignalBase):
if index._const:
index = index.staticEval()
else:
indexConst = False
elif isinstance(index, slice):
length = self._dtype.bit_length()
index = slice_to_SLICE(index, length)
else:
index = hInt(index)
if indexConst and not index._isFullVld():
indexConst = False
# convert value to bits of length specified by index
if indexConst:
if index._dtype == SLICE:
itemT = Bits(index._size())
else:
itemT = BIT
if not isinstance(value, Value):
if isinstance(value, RtlSignalBase):
if value._const:
value = value.staticEval()._auto_cast(itemT)
valueConst = True
else:
valueConst = False
else:
value = itemT.fromPy(value)
valueConst = True
else:
valueConst = True
value = value._auto_cast(itemT)
if indexConst and valueConst and isinstance(self, Value):
return self._setitem__val(index, value)
raise TypeError(
"Only simulator can resolve []= for signals or invalid index")
def test_8b_eq(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertTrue(t.fromPy(-1)._eq(-1))
self.assertTrue(t.fromPy(0)._eq(0))
self.assertTrue(up._eq(up))
self.assertTrue(low._eq(low))
self.assertFalse(t.fromPy(0)._eq(-1))
self.assertFalse(t.fromPy(-1)._eq(0))
self.assertFalse(up._eq(low))
self.assertFalse(low._eq(up))
with self.assertRaises(TypeError):
t.fromPy(0)._eq(ut.fromPy(0))
def test_8b_ne(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertFalse(t.fromPy(-1) != -1)
self.assertFalse(t.fromPy(0) != 0)
self.assertFalse(up != up)
self.assertFalse(low != low)
self.assertTrue(t.fromPy(0) != -1)
self.assertTrue(t.fromPy(-1) != 0)
self.assertTrue(up != low)
self.assertTrue(low != up)
with self.assertRaises(TypeError):
t.fromPy(0) != ut.fromPy(0)
def test_8b_ne(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertFalse(t.fromPy(-1) != -1)
self.assertFalse(t.fromPy(0) != 0)
self.assertFalse(up != up)
self.assertFalse(low != low)
self.assertTrue(t.fromPy(0) != -1)
self.assertTrue(t.fromPy(-1) != 0)
self.assertTrue(up != low)
self.assertTrue(low != up)
with self.assertRaises(TypeError):
t.fromPy(0) != ut.fromPy(0)
def test_8b_eq(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertTrue(t.fromPy(-1)._eq(-1))
self.assertTrue(t.fromPy(0)._eq(0))
self.assertTrue(up._eq(up))
self.assertTrue(low._eq(low))
self.assertFalse(t.fromPy(0)._eq(-1))
self.assertFalse(t.fromPy(-1)._eq(0))
self.assertFalse(up._eq(low))
self.assertFalse(low._eq(up))
with self.assertRaises(TypeError):
t.fromPy(0)._eq(ut.fromPy(0))
def test_8b_lt(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertFalse(t.fromPy(-1) < -1)
self.assertFalse(t.fromPy(0) < 0)
self.assertFalse(t.fromPy(1) < 1)
self.assertFalse(up < up)
self.assertFalse(low < low)
self.assertFalse(t.fromPy(0) < -1)
self.assertTrue(t.fromPy(-1) < 0)
self.assertFalse(up < low)
self.assertTrue(low < up)
with self.assertRaises(TypeError):
t.fromPy(0) < ut.fromPy(0)
def test_8b_gt(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertFalse(t.fromPy(-1) > -1)
self.assertFalse(t.fromPy(0) > 0)
self.assertFalse(t.fromPy(1) > 1)
self.assertFalse(up > up)
self.assertFalse(low > low)
self.assertTrue(t.fromPy(0) > -1)
self.assertFalse(t.fromPy(-1) > 0)
self.assertTrue(up > low)
self.assertFalse(low > up)
with self.assertRaises(TypeError):
t.fromPy(0) > ut.fromPy(0)
def test_8b_lt(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertFalse(t.fromPy(-1) < -1)
self.assertFalse(t.fromPy(0) < 0)
self.assertFalse(t.fromPy(1) < 1)
self.assertFalse(up < up)
self.assertFalse(low < low)
self.assertFalse(t.fromPy(0) < -1)
self.assertTrue(t.fromPy(-1) < 0)
self.assertFalse(up < low)
self.assertTrue(low < up)
with self.assertRaises(TypeError):
t.fromPy(0) < ut.fromPy(0)
def test_8b_gt(self, t=int8_t):
ut = Bits(t.bit_length())
low, up, _, _ = self.getMinMaxVal(t)
self.assertFalse(t.fromPy(-1) > -1)
self.assertFalse(t.fromPy(0) > 0)
self.assertFalse(t.fromPy(1) > 1)
self.assertFalse(up > up)
self.assertFalse(low > low)
self.assertTrue(t.fromPy(0) > -1)
self.assertFalse(t.fromPy(-1) > 0)
self.assertTrue(up > low)
self.assertFalse(low > up)
with self.assertRaises(TypeError):
t.fromPy(0) > ut.fromPy(0)
def test_BitsMulInvalidType(self):
t = Bits(8)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v * "a"
def test_BitsMulInvalidType(self):
t = Bits(8)
v = t.fromPy(1)
with self.assertRaises(TypeError):
v * "a"
