b469f1f6-6a00-4958-bfb0-f9fbf427a589

Committed 06 Jun 2024 06:38PM UTC coverage: 93.399% (-0.03%) from 93.431%

Build # b469f1f6-6a00-4958-bfb0-f9fbf427a589

Build Type

push

circleci

Committed by

Nic30

Commit Message

docs

Run Details

8040 of 9100 branches covered (88.35%)

39136 of 41902 relevant lines covered (93.4%)

0.93 hits per line

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

90.14

/hwtLib/structManipulators/structWriter.py

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

from hwt.code import StaticForEach
from hwt.hdl.types.struct import HStruct
from hwt.hwIOs.std import HwIODataRdVld, HwIORdVldSync
from hwt.hwIOs.hwIOStruct import HwIOStruct
from hwt.hwIOs.utils import addClkRstn, propagateClkRstn
from hwt.hwParam import HwParam
from hwtLib.amba.axis_comp.frame_deparser import Axi4S_frameDeparser
from hwtLib.amba.datapump.intf import HwIOAxiWDatapump
from hwtLib.handshaked.builder import HsBuilder
from hwtLib.handshaked.fifo import HandshakedFifo
from hwtLib.handshaked.reg import HandshakedReg
from hwtLib.handshaked.streamNode import StreamNode
from hwtLib.structManipulators.structReader import StructReader
from hwt.pyUtils.typingFuture import override

SKIP = 1
PROPAGATE = 0


class StructWriter(StructReader):
    """
    Write struct specified in constructor over wDatapump interface on address
    specified over set interface

    :ivar ~.MAX_OVERLAP: parameter which specifies the maximum number of concurrent transaction
    :ivar ~.WRITE_ACK: HwParam, if true ready on "set" will be set only
        when component is in idle (if false "set"
        is regular handshaked interface)

    .. figure:: ./_static/StructWriter.png

    :note: names in the picture are just illustrative

    .. hwt-autodoc:: _example_StructWriter
    """

    @override
    def hwConfig(self):
        StructReader.hwConfig(self)
        self.MAX_OVERLAP = HwParam(2)
        self.WRITE_ACK = HwParam(False)

    def _createInterfaceForField(self, parent, structField):
        return Axi4S_frameDeparser._mkFieldHwIO(self, parent, structField)

    @override
    def hwDeclr(self):
        addClkRstn(self)
        self.parseTemplate()
        self.dataIn = HwIOStruct(self._structT, tuple(),
                                 self._createInterfaceForField)

        s = self.set = HwIODataRdVld()  # data signal is addr of structure to write
        s.DATA_WIDTH = self.ADDR_WIDTH
        # write ack from slave
        self.writeAck: HwIORdVldSync = HwIORdVldSync()._m()

        with self._hwParamsShared():
            # interface for communication with datapump
            self.wDatapump = HwIOAxiWDatapump()._m()
            self.wDatapump.MAX_BYTES = self.maxBytesInTransaction()

            self.frameAssember = Axi4S_frameDeparser(
                self._structT,
                tmpl=self._tmpl,
                frames=self._frames
            )

    @override
    def hwImpl(self):
        req = self.wDatapump.req
        w = self.wDatapump.w
        ack = self.wDatapump.ack

        # multi frame
        if self.MAX_OVERLAP > 1:
            ackPropageteInfo = HandshakedFifo(HwIODataRdVld)
            ackPropageteInfo.DEPTH = self.MAX_OVERLAP
        else:
            ackPropageteInfo = HandshakedReg(HwIODataRdVld)
        ackPropageteInfo.DATA_WIDTH = 1
        self.ackPropageteInfo = ackPropageteInfo

        if self.WRITE_ACK:
            _set = self.set
        else:
            _set = HsBuilder(self, self.set).buff().end

        if self.ID_WIDTH:
            req.id(self.ID)

        def propagateRequest(frame, indx):
            inNode = StreamNode(slaves=[req, ackPropageteInfo.dataIn])
            ack = inNode.ack()
            isLastFrame = indx == len(self._frames) - 1
            statements = [
                req.addr(_set.data + frame.startBitAddr // 8),
                req.len(frame.getWordCnt() - 1),
                self.driveReqRem(req, frame.parts[-1].endOfPart - frame.startBitAddr),
                ackPropageteInfo.dataIn.data(SKIP if  indx != 0 else PROPAGATE),
                inNode.sync(_set.vld),
                _set.rd(ack if isLastFrame else 0),
            ]

            return statements, ack & _set.vld

        StaticForEach(self, self._frames, propagateRequest)

        # connect write channel
        w(self.frameAssember.dataOut)

        # propagate ack
        StreamNode(
            masters=[ack, ackPropageteInfo.dataOut],
            slaves=[self.writeAck],
            skipWhen={
                self.writeAck: ackPropageteInfo.dataOut.data._eq(PROPAGATE)
            }
        ).sync()

        # connect fields to assembler
        for _, transTmpl in self._tmpl.HwIO_walkFlatten():
            f = transTmpl.getFieldPath()
            hwIO = self.frameAssember.dataIn._fieldsToHwIOs[f]
            hwIO(self.dataIn._fieldsToHwIOs[f])

        propagateClkRstn(self)


def _example_StructWriter():
    from hwtLib.types.ctypes import uint16_t, uint32_t, uint64_t

    s = HStruct(
            (uint64_t, "item0"),  # tuples (type, name) where type has to be instance of Bits type
            (uint64_t, None),  # name = None means this field will be ignored
            (uint64_t, "item1"),
            (uint64_t, None),
            (uint16_t, "item2"),
            (uint16_t, "item3"),
            (uint32_t, "item4"),
            (uint32_t, None),
            (uint64_t, "item5"),  # this word is split on two bus words
            (uint32_t, None),
            (uint64_t, None),
            (uint64_t, None),
            (uint64_t, None),
            (uint64_t, "item6"),
            (uint64_t, "item7"),
        )

    m = StructWriter(s)
    return m


if __name__ == "__main__":
    from hwt.synth import to_rtl_str
    m = _example_StructWriter()
    print(to_rtl_str(m))

1	#!/usr/bin/env python3
2	# -- coding: utf-8 --
3
4	from hwt.code import StaticForEach	1✔
5	from hwt.hdl.types.struct import HStruct	1✔
6	from hwt.hwIOs.std import HwIODataRdVld, HwIORdVldSync	1✔
7	from hwt.hwIOs.hwIOStruct import HwIOStruct	1✔
8	from hwt.hwIOs.utils import addClkRstn, propagateClkRstn	1✔
9	from hwt.hwParam import HwParam	1✔
10	from hwtLib.amba.axis_comp.frame_deparser import Axi4S_frameDeparser	1✔
11	from hwtLib.amba.datapump.intf import HwIOAxiWDatapump	1✔
12	from hwtLib.handshaked.builder import HsBuilder	1✔
13	from hwtLib.handshaked.fifo import HandshakedFifo	1✔
14	from hwtLib.handshaked.reg import HandshakedReg	1✔
15	from hwtLib.handshaked.streamNode import StreamNode	1✔
16	from hwtLib.structManipulators.structReader import StructReader	1✔
17	from hwt.pyUtils.typingFuture import override	1✔
18
19	SKIP = 1	1✔
20	PROPAGATE = 0	1✔
21
22
23	class StructWriter(StructReader):	1✔
24	"""
25	Write struct specified in constructor over wDatapump interface on address
26	specified over set interface
27
28	:ivar ~.MAX_OVERLAP: parameter which specifies the maximum number of concurrent transaction
29	:ivar ~.WRITE_ACK: HwParam, if true ready on "set" will be set only
30	when component is in idle (if false "set"
31	is regular handshaked interface)
32
33	.. figure:: ./_static/StructWriter.png
34
35	:note: names in the picture are just illustrative
36
37	.. hwt-autodoc:: _example_StructWriter
38	"""
39
40	@override	1✔
41	def hwConfig(self):	1✔
42	StructReader.hwConfig(self)	1✔
43	self.MAX_OVERLAP = HwParam(2)	1✔
44	self.WRITE_ACK = HwParam(False)	1✔
45
46	def _createInterfaceForField(self, parent, structField):	1✔
47	return Axi4S_frameDeparser._mkFieldHwIO(self, parent, structField)	1✔
48
49	@override	1✔
50	def hwDeclr(self):	1✔
51	addClkRstn(self)	1✔
52	self.parseTemplate()	1✔
53	self.dataIn = HwIOStruct(self._structT, tuple(),	1✔
54	self._createInterfaceForField)
55
56	s = self.set = HwIODataRdVld() # data signal is addr of structure to write	1✔
57	s.DATA_WIDTH = self.ADDR_WIDTH	1✔
58	# write ack from slave
59	self.writeAck: HwIORdVldSync = HwIORdVldSync()._m()	1✔
60
61	with self._hwParamsShared():	1✔
62	# interface for communication with datapump
63	self.wDatapump = HwIOAxiWDatapump()._m()	1✔
64	self.wDatapump.MAX_BYTES = self.maxBytesInTransaction()	1✔
65
66	self.frameAssember = Axi4S_frameDeparser(	1✔
67	self._structT,
68	tmpl=self._tmpl,
69	frames=self._frames
70	)
71
72	@override	1✔
73	def hwImpl(self):	1✔
74	req = self.wDatapump.req	1✔
75	w = self.wDatapump.w	1✔
76	ack = self.wDatapump.ack	1✔
77
78	# multi frame
79	if self.MAX_OVERLAP > 1:	1!
80	ackPropageteInfo = HandshakedFifo(HwIODataRdVld)	1✔
81	ackPropageteInfo.DEPTH = self.MAX_OVERLAP	1✔
82	else:
83	ackPropageteInfo = HandshakedReg(HwIODataRdVld)	×
84	ackPropageteInfo.DATA_WIDTH = 1	1✔
85	self.ackPropageteInfo = ackPropageteInfo	1✔
86
87	if self.WRITE_ACK:	1!
88	_set = self.set	×
89	else:
90	_set = HsBuilder(self, self.set).buff().end	1✔
91
92	if self.ID_WIDTH:	1!
93	req.id(self.ID)	×
94
95	def propagateRequest(frame, indx):	1✔
96	inNode = StreamNode(slaves=[req, ackPropageteInfo.dataIn])	1✔
97	ack = inNode.ack()	1✔
98	isLastFrame = indx == len(self._frames) - 1	1✔
99	statements = [	1✔
100	req.addr(_set.data + frame.startBitAddr // 8),
101	req.len(frame.getWordCnt() - 1),
102	self.driveReqRem(req, frame.parts[-1].endOfPart - frame.startBitAddr),
103	ackPropageteInfo.dataIn.data(SKIP if indx != 0 else PROPAGATE),
104	inNode.sync(_set.vld),
105	_set.rd(ack if isLastFrame else 0),
106	]
107
108	return statements, ack & _set.vld	1✔
109
110	StaticForEach(self, self._frames, propagateRequest)	1✔
111
112	# connect write channel
113	w(self.frameAssember.dataOut)	1✔
114
115	# propagate ack
116	StreamNode(	1✔
117	masters=[ack, ackPropageteInfo.dataOut],
118	slaves=[self.writeAck],
119	skipWhen={
120	self.writeAck: ackPropageteInfo.dataOut.data._eq(PROPAGATE)
121	}
122	).sync()
123
124	# connect fields to assembler
125	for _, transTmpl in self._tmpl.HwIO_walkFlatten():	1✔
126	f = transTmpl.getFieldPath()	1✔
127	hwIO = self.frameAssember.dataIn._fieldsToHwIOs[f]	1✔
128	hwIO(self.dataIn._fieldsToHwIOs[f])	1✔
129
130	propagateClkRstn(self)	1✔
131
132
133	def _example_StructWriter():	1✔
134	from hwtLib.types.ctypes import uint16_t, uint32_t, uint64_t	×
135
136	s = HStruct(	×
137	(uint64_t, "item0"), # tuples (type, name) where type has to be instance of Bits type
138	(uint64_t, None), # name = None means this field will be ignored
139	(uint64_t, "item1"),
140	(uint64_t, None),
141	(uint16_t, "item2"),
142	(uint16_t, "item3"),
143	(uint32_t, "item4"),
144	(uint32_t, None),
145	(uint64_t, "item5"), # this word is split on two bus words
146	(uint32_t, None),
147	(uint64_t, None),
148	(uint64_t, None),
149	(uint64_t, None),
150	(uint64_t, "item6"),
151	(uint64_t, "item7"),
152	)
153
154	m = StructWriter(s)	×
155	return m	×
156
157
158	if __name__ == "__main__":
159	from hwt.synth import to_rtl_str
160	m = _example_StructWriter()
161	print(to_rtl_str(m))

Nic30 / hwtLib / b469f1f6-6a00-4958-bfb0-f9fbf427a589

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