170208f5-5e39-4024-ae82-f3378a16eefe

Build # 170208f5-5e39-4024-ae82-f3378a16eefe

Build Type

push

circleci

Committed by Nic30

Commit Message

StreamNode.__repr__: improve readability

Run Details

9688 of 10705 branches covered (90.5%)

37526 of 40104 relevant lines covered (93.57%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.77

/hwtLib/examples/specialIntfTypes/intfWithArray.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from hwt.interfaces.std import Signal
from hwt.serializer.vhdl import ToHdlAstVhdl2008
from hwt.synthesizer.hObjList import HObjList
from hwt.synthesizer.param import Param
from hwt.synthesizer.unit import Unit
from hwtLib.types.ctypes import uint8_t
from hdlConvertorAst.hdlAst._expr import HdlValueId, HdlOp, HdlOpType
from hdlConvertorAst.translate.verilog_to_basic_hdl_sim_model.utils import hdl_index,\
    hdl_downto
from hwtLib.examples.base_serialization_TC import BaseSerializationTC


# class Interface1d(Unit):
#
#     def _config(self):
#         self.SIZE = Param(3)
#
#     def _declr(self):
#         self.din = Signal(dtype=uint8_t[self.SIZE])
#         self.dout = HObjList([Signal(dtype=uint8_t)._m()
#                               for _ in range(self.SIZE)])
#
#     def _impl(self):
#         for i in range(self.SIZE):
#             o = self.din[i]
#             self.dout[i](o)
# class Interface2d(Unit):
#
#     def _config(self):
#         self.SIZE_X = Param(3)
#         self.SIZE_Y = Param(3)
#
#     def _declr(self):
#         self.din = Signal(dtype=uint8_t[self.SIZE_X][self.SIZE_Y])
#         self.dout = HObjList([
#             HObjList([
#                 Signal(dtype=uint8_t)._m()
#                 for _ in range(self.SIZE_Y)])
#             for _ in range(self.SIZE_X)
#         ])
#
#     def _impl(self):
#         # for x in range(self.SIZE_X):
#         #     for y in range(self.SIZE_Y):
#         #         o = self.din[x][y]
#         #         self.dout[x][y](o)
#
#         for x_in, x_out in zip(self.din, self.dout):
#             for d_in, d_out in zip(x_in, x_out):
#                 d_out(d_in)

def example_use_vhdl_declared_array1d(SIZE_X):
    array1d_t = uint8_t[SIZE_X]

    def array1d_t_to_vhdl(to_hdl: ToHdlAstVhdl2008, declaration=False):
        if not isinstance(to_hdl, ToHdlAstVhdl2008):
            raise NotImplementedError()

        if declaration:
            raise ValueError(
                "_as_hdl_requires_def specifies that this should not be required")
        # "mem(0 to %d)(%d downto 0)" % (t.size, t.element_t.bit_length() - 1)
        _int = to_hdl.as_hdl_int
        size = HdlOp(HdlOpType.TO, [_int(0), _int(int(array1d_t.size))])
        e_width = hdl_downto(
            _int(array1d_t.element_t.bit_length() - 1), _int(0))
        return hdl_index(hdl_index(HdlValueId("mem"), size), e_width)

    def array1d_t_as_hdl_requires_def(to_hdl: ToHdlAstVhdl2008, other_types: list):
        return False

    array1d_t._as_hdl = array1d_t_to_vhdl
    array1d_t._as_hdl_requires_def = array1d_t_as_hdl_requires_def

    return array1d_t


class InterfaceWithVHDLUnconstrainedArrayImportedType(Unit):

    def _config(self):
        self.SIZE_X = Param(3)

    def _declr(self):
        # lets suppose that there is some package which has vhdl type defined as:
        #   type data_vector is array (natural range <>, natural range <>) of integer;
        #   type mem is array(natural range <>) of std_logic_vector;
        # We would like to use this type in HWT, but there is no explicit support for vhdl 2008
        # unconstrained multi dim. arrays or external VHDL types.
        # But we need to our interface with type like this:
        #   signal our_interface: mem(0 to 15)(7 downto 0);
        # so we are actually able to connect this component to existing design.

        # In this example we will mock the type with HWT array type and override
        # serialization so we will get desired type name in VHDL.
        array1d_t = example_use_vhdl_declared_array1d(self.SIZE_X)

        self.din = Signal(dtype=array1d_t)
        self.dout = HObjList([
            Signal(dtype=uint8_t)._m()
            for _ in range(self.SIZE_X)
        ])

    def _impl(self):
        for d_in, d_out in zip(self.din, self.dout):
            d_out(d_in)


class InterfaceWithVHDLUnconstrainedArrayImportedType2(Unit):

    def _config(self):
        self.SIZE_X = Param(3)

    def _declr(self):
        array1d_t = example_use_vhdl_declared_array1d(self.SIZE_X)

        self.dout = Signal(dtype=array1d_t)._m()
        self.din = HObjList([
            Signal(dtype=uint8_t)
            for _ in range(self.SIZE_X)
        ])

    def _impl(self):
        for d_in, d_out in zip(self.din, self.dout):
            d_out(d_in)


class InterfaceWithArrayTypesTC(BaseSerializationTC):
    __FILE__ = __file__

    def test_InterfaceWithVHDLUnconstrainedArrayImportedType(self):
        u = InterfaceWithVHDLUnconstrainedArrayImportedType()
        self.assert_serializes_as_file(
            u, "InterfaceWithVHDLUnconstrainedArrayImportedType.vhd")

    def test_InterfaceWithVHDLUnconstrainedArrayImportedType2(self):
        u = InterfaceWithVHDLUnconstrainedArrayImportedType2()
        self.assert_serializes_as_file(
            u, "InterfaceWithVHDLUnconstrainedArrayImportedType2.vhd")


if __name__ == "__main__":
    import unittest
    testLoader = unittest.TestLoader()
    suite = testLoader.loadTestsFromTestCase(InterfaceWithArrayTypesTC)
    runner = unittest.TextTestRunner(verbosity=3)
    runner.run(suite)
    # print(to_rtl_str(Interface1d()))
    # print(to_rtl_str(Interface2d()))
    # print(to_rtl_str(InterfaceWithVHDLUnconstrainedArrayImportedType()))
    # print(to_rtl_str(InterfaceWithVHDLUnconstrainedArrayImportedType2()))

1	#!/usr/bin/env python3
2	# -- coding: utf-8 --
3
4	from hwt.interfaces.std import Signal	1✔
5	from hwt.serializer.vhdl import ToHdlAstVhdl2008	1✔
6	from hwt.synthesizer.hObjList import HObjList	1✔
7	from hwt.synthesizer.param import Param	1✔
8	from hwt.synthesizer.unit import Unit	1✔
9	from hwtLib.types.ctypes import uint8_t	1✔
10	from hdlConvertorAst.hdlAst._expr import HdlValueId, HdlOp, HdlOpType	1✔
11	from hdlConvertorAst.translate.verilog_to_basic_hdl_sim_model.utils import hdl_index,\	1✔
12	hdl_downto
13	from hwtLib.examples.base_serialization_TC import BaseSerializationTC	1✔
14
15
16	# class Interface1d(Unit):
17	#
18	# def _config(self):
19	# self.SIZE = Param(3)
20	#
21	# def _declr(self):
22	# self.din = Signal(dtype=uint8_t[self.SIZE])
23	# self.dout = HObjList([Signal(dtype=uint8_t)._m()
24	# for _ in range(self.SIZE)])
25	#
26	# def _impl(self):
27	# for i in range(self.SIZE):
28	# o = self.din[i]
29	# self.dout[i](o)
30	# class Interface2d(Unit):
31	#
32	# def _config(self):
33	# self.SIZE_X = Param(3)
34	# self.SIZE_Y = Param(3)
35	#
36	# def _declr(self):
37	# self.din = Signal(dtype=uint8_t[self.SIZE_X][self.SIZE_Y])
38	# self.dout = HObjList([
39	# HObjList([
40	# Signal(dtype=uint8_t)._m()
41	# for _ in range(self.SIZE_Y)])
42	# for _ in range(self.SIZE_X)
43	# ])
44	#
45	# def _impl(self):
46	# # for x in range(self.SIZE_X):
47	# # for y in range(self.SIZE_Y):
48	# # o = self.din[x][y]
49	# # self.dout[x][y](o)
50	#
51	# for x_in, x_out in zip(self.din, self.dout):
52	# for d_in, d_out in zip(x_in, x_out):
53	# d_out(d_in)
54
55	def example_use_vhdl_declared_array1d(SIZE_X):	1✔
56	array1d_t = uint8_t[SIZE_X]	1✔
57
58	def array1d_t_to_vhdl(to_hdl: ToHdlAstVhdl2008, declaration=False):	1✔
59	if not isinstance(to_hdl, ToHdlAstVhdl2008):	1✔
60	raise NotImplementedError()
61
62	if declaration:	1!
63	raise ValueError(	×
64	"_as_hdl_requires_def specifies that this should not be required")
65	# "mem(0 to %d)(%d downto 0)" % (t.size, t.element_t.bit_length() - 1)
66	_int = to_hdl.as_hdl_int	1✔
67	size = HdlOp(HdlOpType.TO, [_int(0), _int(int(array1d_t.size))])	1✔
68	e_width = hdl_downto(	1✔
69	_int(array1d_t.element_t.bit_length() - 1), _int(0))
70	return hdl_index(hdl_index(HdlValueId("mem"), size), e_width)	1✔
71
72	def array1d_t_as_hdl_requires_def(to_hdl: ToHdlAstVhdl2008, other_types: list):	1✔
73	return False	1✔
74
75	array1d_t._as_hdl = array1d_t_to_vhdl	1✔
76	array1d_t._as_hdl_requires_def = array1d_t_as_hdl_requires_def	1✔
77
78	return array1d_t	1✔
79
80
81	class InterfaceWithVHDLUnconstrainedArrayImportedType(Unit):	1✔
82
83	def _config(self):	1✔
84	self.SIZE_X = Param(3)	1✔
85
86	def _declr(self):	1✔
87	# lets suppose that there is some package which has vhdl type defined as:
88	# type data_vector is array (natural range <>, natural range <>) of integer;
89	# type mem is array(natural range <>) of std_logic_vector;
90	# We would like to use this type in HWT, but there is no explicit support for vhdl 2008
91	# unconstrained multi dim. arrays or external VHDL types.
92	# But we need to our interface with type like this:
93	# signal our_interface: mem(0 to 15)(7 downto 0);
94	# so we are actually able to connect this component to existing design.
95
96	# In this example we will mock the type with HWT array type and override
97	# serialization so we will get desired type name in VHDL.
98	array1d_t = example_use_vhdl_declared_array1d(self.SIZE_X)	1✔
99
100	self.din = Signal(dtype=array1d_t)	1✔
101	self.dout = HObjList([	1✔
102	Signal(dtype=uint8_t)._m()
103	for _ in range(self.SIZE_X)
104	])
105
106	def _impl(self):	1✔
107	for d_in, d_out in zip(self.din, self.dout):	1✔
108	d_out(d_in)	1✔
109
110
111	class InterfaceWithVHDLUnconstrainedArrayImportedType2(Unit):	1✔
112
113	def _config(self):	1✔
114	self.SIZE_X = Param(3)	1✔
115
116	def _declr(self):	1✔
117	array1d_t = example_use_vhdl_declared_array1d(self.SIZE_X)	1✔
118
119	self.dout = Signal(dtype=array1d_t)._m()	1✔
120	self.din = HObjList([	1✔
121	Signal(dtype=uint8_t)
122	for _ in range(self.SIZE_X)
123	])
124
125	def _impl(self):	1✔
126	for d_in, d_out in zip(self.din, self.dout):	1✔
127	d_out(d_in)	1✔
128
129
130	class InterfaceWithArrayTypesTC(BaseSerializationTC):	1✔
131	__FILE__ = __file__	1✔
132
133	def test_InterfaceWithVHDLUnconstrainedArrayImportedType(self):	1✔
134	u = InterfaceWithVHDLUnconstrainedArrayImportedType()	1✔
135	self.assert_serializes_as_file(	1✔
136	u, "InterfaceWithVHDLUnconstrainedArrayImportedType.vhd")
137
138	def test_InterfaceWithVHDLUnconstrainedArrayImportedType2(self):	1✔
139	u = InterfaceWithVHDLUnconstrainedArrayImportedType2()	1✔
140	self.assert_serializes_as_file(	1✔
141	u, "InterfaceWithVHDLUnconstrainedArrayImportedType2.vhd")
142
143
144	if __name__ == "__main__":
145	import unittest
146	testLoader = unittest.TestLoader()
147	suite = testLoader.loadTestsFromTestCase(InterfaceWithArrayTypesTC)
148	runner = unittest.TextTestRunner(verbosity=3)
149	runner.run(suite)
150	# print(to_rtl_str(Interface1d()))
151	# print(to_rtl_str(Interface2d()))
152	# print(to_rtl_str(InterfaceWithVHDLUnconstrainedArrayImportedType()))
153	# print(to_rtl_str(InterfaceWithVHDLUnconstrainedArrayImportedType2()))

Nic30 / hwtLib / 170208f5-5e39-4024-ae82-f3378a16eefe

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous