From 7f164e9c1507517b3df9517de9a42899460cef8b Mon Sep 17 00:00:00 2001 From: Yuqi Sun <791079835@qq.com> Date: Mon, 9 Dec 2024 22:58:20 +0800 Subject: [PATCH 01/45] Simulation traces are not understandable for human being #23 --- cgra/CGRAKingMeshRTL.py | 2 +- fu/flexible/FlexibleFuRTL.py | 8 +++++--- mem/ctrl/CtrlMemRTL.py | 4 ++-- mem/data/DataMemRTL.py | 12 ++++++------ tile/TileRTL.py | 14 ++++++++------ 5 files changed, 22 insertions(+), 18 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index e9e37b0..a5d1dff 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -155,5 +155,5 @@ def line_trace( s ): # str += " :: [" + s.data_mem.line_trace() + "]" res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) for (i,x) in enumerate(s.tile) ]) - res += "\n :: [" + s.data_mem.line_trace() + "] \n" + res += "\n data_mem:: [" + s.data_mem.line_trace() + "] \n" return res diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 2fdbadd..3be4caf 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -8,6 +8,7 @@ Date : Dec 24, 2019 """ +import json from pymtl3 import * from ...fu.single.MemUnitRTL import MemUnitRTL @@ -111,11 +112,12 @@ def comb_logic(): s.fu_recv_in_rdy_vector[port][i] @= s.fu[i].recv_in[port].rdy s.recv_in[port].rdy @= reduce_or( s.fu_recv_in_rdy_vector[port] ) + def line_trace( s ): opt_str = " #" if s.recv_opt.en: opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - out_str = ",".join([str(x.msg) for x in s.send_out]) - recv_str = ",".join([str(x.msg) for x in s.recv_in]) - return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' + recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' + return f'class: {s.__class__.__name__}, [recv: {recv_str}] opt: {opt_str} (P{s.recv_opt.msg.predicate}) (const: {str(s.recv_const.msg.__dict__)}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {str(s.recv_predicate.msg.__dict__)}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 644882f..0b41bfd 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -73,6 +73,6 @@ def update_raddr(): s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) def line_trace( s ): - out_str = "||".join([ str(data) for data in s.reg_file.regs ]) - return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' + out_str = f'[{", ".join([ str(data.__dict__) for data in s.reg_file.regs ])}]' + return f'class: {s.__class__.__name__}, recv_ctrl_msg: {s.recv_ctrl.msg.__dict__} : out: {out_str} : send_ctrl_msg: {str(s.send_ctrl.msg.__dict__)}' diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index ac7bda0..9f620a6 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -99,12 +99,12 @@ def update_signal(): s.recv_wdata[i].rdy @= Bits1( 1 ) def line_trace(s): - recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) - recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) - recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) - content_str = "content: " + "|".join([str(data) for data in s.reg_file.regs]) - send_rdata_str = "send_read_data: " + "|".join([str(data.msg) for data in s.send_rdata]) - return f'{recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' + recv_raddr_str = "recv_read_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_raddr])}]' + recv_waddr_str = "recv_write_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_waddr])}]' + recv_wdata_str = "recv_write_data: " + f'[{", ".join([str(data.msg.__dict__) for data in s.recv_wdata])}]' + content_str = "content: " + f'[{", ".join([str(data.__dict__) for data in s.reg_file.regs])}]' + send_rdata_str = "send_read_data: " + f'[{", ".join([str(data.msg) for data in s.send_rdata])}]' + return f'class: {s.__class__.__name__}, {recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' # return s.reg_file.line_trace() # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index dd68900..3add022 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -6,6 +6,7 @@ Author : Cheng Tan Date : Dec 11, 2019 """ +import json from pymtl3 import * @@ -123,12 +124,13 @@ def update_opt(): s.crossbar.recv_opt.en @= s.ctrl_mem.send_ctrl.en s.ctrl_mem.send_ctrl.rdy @= s.element.recv_opt.rdy & s.crossbar.recv_opt.rdy + # Line trace def line_trace( s ): - - recv_str = "|".join([ str(x.msg) for x in s.recv_data ]) - channel_recv_str = "|".join([ str(x.recv.msg) for x in s.channel ]) - channel_send_str = "|".join([ str(x.send.msg) for x in s.channel ]) - out_str = "|".join([ "("+str(x.msg.payload)+","+str(x.msg.predicate)+")" for x in s.send_data ]) - return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + recv_str = f'[{", ".join([ str(x.msg.__dict__) for x in s.recv_data ])}]' + # recv_json = json.dumps(s.recv_data) + channel_recv_str = f'[{", ".join([ str(x.recv.msg.__dict__) for x in s.channel ])}]' + channel_send_str = f'[{", ".join([ str(x.send.msg.__dict__) for x in s.channel ])}]' + out_str = f'[{", ".join([ "{send_msg_payload: "+str(x.msg.payload)+", send_msg_predicate: "+str(x.msg.predicate)+"}" for x in s.send_data ])}]' + return f"class: {s.__class__.__name__}, recv: {recv_str} => [recv_opt_msg: {str(s.crossbar.recv_opt.msg.__dict__)}] ({s.element.line_trace()}) => channel_recv: {channel_recv_str} => channel_send: {channel_send_str} => out: {out_str}" From 30d3a31bd481c1c1075736248b8715fc830481be Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 16 Dec 2024 17:22:10 +0800 Subject: [PATCH 02/45] Simulation traces are not understandable for human being #23 --- cgra/CGRAKingMeshRTL.py | 8 ++++-- fu/flexible/FlexibleFuRTL.py | 26 +++++++++++++++++--- mem/ctrl/CtrlMemRTL.py | 16 +++++++++--- tile/TileRTL.py | 47 +++++++++++++++++++++++++++++++----- 4 files changed, 82 insertions(+), 15 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index a5d1dff..5dd7ed5 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -153,7 +153,11 @@ def construct( s, DataType, PredicateType, CtrlType, width, height, def line_trace( s ): # str = "||".join([ x.element.line_trace() for x in s.tile ]) # str += " :: [" + s.data_mem.line_trace() + "]" - res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - for (i,x) in enumerate(s.tile) ]) + # res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + # for (i,x) in enumerate(s.tile) ]) + res = '' + for (i, x) in enumerate(s.tile): + res += "# [tile"+str(i)+"]: " + x.line_trace() + x.ctrl_mem.line_trace() + '\n' res += "\n data_mem:: [" + s.data_mem.line_trace() + "] \n" + res += "------\n\n" return res diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 3be4caf..4f15d3d 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -10,6 +10,7 @@ """ import json +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from ...fu.single.MemUnitRTL import MemUnitRTL from ...fu.single.AdderRTL import AdderRTL @@ -117,7 +118,26 @@ def line_trace( s ): opt_str = " #" if s.recv_opt.en: opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' - recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' - return f'class: {s.__class__.__name__}, [recv: {recv_str}] opt: {opt_str} (P{s.recv_opt.msg.predicate}) (const: {str(s.recv_const.msg.__dict__)}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {str(s.recv_predicate.msg.__dict__)}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + # out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' + out_md = markdown_table([x.msg.__dict__ for x in s.send_out]).set_params(quote=False).get_markdown() + # recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' + recv_list = [x.msg.__dict__ for x in s.recv_in] + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + return (f'## class: {s.__class__.__name__}\n' + f'- recv:' + f'{recv_md}\n' + f'- opt ({opt_str}):\n' + f' (P{s.recv_opt.msg.predicate})\n' + f' const: {str(s.recv_const.msg.__dict__)}\n' + f' en: {s.recv_const.en}\n' + f'===>\n' + f'- out:' + f'{out_md}\n' + f'- recv_opt.rdy: {s.recv_opt.rdy}\n' + f'- recv_in[0].rdy: {s.recv_in[0].rdy}\n' + f'- recv_in[1].rdy: {s.recv_in[1].rdy}\n' + f'- recv_predicate.msg: {str(s.recv_predicate.msg.__dict__)}\n' + f'- opt: {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}\n' + f'- recv_opt.en: {s.recv_opt.en}\n' + f'- send[0].en: {s.send_out[0].en}\n') diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 0b41bfd..a0dbc60 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -7,8 +7,7 @@ Author : Cheng Tan Date : Dec 21, 2019 """ - - +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from pymtl3.stdlib.primitive import RegisterFile from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL @@ -73,6 +72,15 @@ def update_raddr(): s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) def line_trace( s ): - out_str = f'[{", ".join([ str(data.__dict__) for data in s.reg_file.regs ])}]' - return f'class: {s.__class__.__name__}, recv_ctrl_msg: {s.recv_ctrl.msg.__dict__} : out: {out_str} : send_ctrl_msg: {str(s.send_ctrl.msg.__dict__)}' + + out_md = markdown_table([ data.__dict__ for data in s.reg_file.regs ]).set_params(quote=False).get_markdown() + # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) + recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.recv_ctrl.msg.__dict__.items()]) + send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.send_ctrl.msg.__dict__.items()]) + return (f'\n## class: {s.__class__.__name__}\n' + f'- recv_ctrl_msg:\n' + f'{recv_ctrl_msg}\n' + f'- out: {out_md}\n' + f'- send_ctrl_msg:\n' + f'{send_ctrl_msg}\n') diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 3add022..17d9ec9 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -10,6 +10,8 @@ from pymtl3 import * + +from lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL @@ -24,7 +26,10 @@ from ..noc.ChannelRTL import ChannelRTL from ..rf.RegisterRTL import RegisterRTL # from ..noc.BypassChannelRTL import BypassChannelRTL +from py_markdown_table.markdown_table import markdown_table +tile_port_direction_dict = {0: "NORTH", 1: "SOUTH", 2: "WEST", 3: "EAST", 4: "NORTHWEST", 5: "NORTHEAST", + 6: "SOUTHEAST", 7: "SOUTHWEST"} class TileRTL( Component ): @@ -127,10 +132,40 @@ def update_opt(): # Line trace def line_trace( s ): - recv_str = f'[{", ".join([ str(x.msg.__dict__) for x in s.recv_data ])}]' - # recv_json = json.dumps(s.recv_data) - channel_recv_str = f'[{", ".join([ str(x.recv.msg.__dict__) for x in s.channel ])}]' - channel_send_str = f'[{", ".join([ str(x.send.msg.__dict__) for x in s.channel ])}]' - out_str = f'[{", ".join([ "{send_msg_payload: "+str(x.msg.payload)+", send_msg_predicate: "+str(x.msg.predicate)+"}" for x in s.send_data ])}]' - return f"class: {s.__class__.__name__}, recv: {recv_str} => [recv_opt_msg: {str(s.crossbar.recv_opt.msg.__dict__)}] ({s.element.line_trace()}) => channel_recv: {channel_recv_str} => channel_send: {channel_send_str} => out: {out_str}" + # recv_str = f'[{", ".join([ str(x.msg.__dict__) for x in s.recv_data ])}]' + recv_data = [ x.msg.__dict__ for x in s.recv_data ] + recv_list = [] + for idx, data in enumerate(recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + recv_list.append(dict_with_direction) + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + recv_opt_msg_dict = s.crossbar.recv_opt.msg.__dict__ + # todo + # E AttributeError: 'str' object has no attribute 'clone' + # print(f"s.crossbar.recv_opt.msg: {s.crossbar.recv_opt.msg}") + # recv_opt_msg_dict['ctrl'] = OPT_SYMBOL_DICT[s.crossbar.recv_opt.msg.ctrl] + recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) + + channel_recv_md = markdown_table([ x.recv.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() + channel_send_md = markdown_table([ x.send.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() + out_md = markdown_table([ dict(send_msg_payload=x.msg.payload, send_msg_predicate=x.msg.predicate) for x in s.send_data ]).set_params(quote=False).get_markdown() + return (f"\n## class[{s.__class__.__name__}]:\n" + f"- recv:" + f"{recv_md}\n" + f"===>\n" + f"- recv_opt_msg:\n" + f"{recv_opt_msg}\n" + f"- element:\n" + f"{s.element.line_trace()}\n" + f"===>\n" + f"- channel_recv:\n" + f"{channel_recv_md}\n" + f"===>\n" + f"- channel_send:" + f"{channel_send_md}\n" + f"===>\n" + f"- out:" + f"{out_md}\n") From 86de5ef788a9c78ecce4d2e276edfd0450e1838f Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 16 Dec 2024 17:30:13 +0800 Subject: [PATCH 03/45] Simulation traces are not understandable for human being #23 --- .github/workflows/python-package.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 7ddb5b9..3306516 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -52,6 +52,7 @@ jobs: pip install -U git+https://github.com/tancheng/pymtl3.1@yo-struct-list-fix pip install hypothesis pip install pytest + pip install py-markdown-table pip list - name: Test and translate with pytest From fe9ba2ce6cffd488a37399ddcc66f4379e84480d Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 16 Dec 2024 17:33:15 +0800 Subject: [PATCH 04/45] Simulation traces are not understandable for human being #23 --- tile/TileRTL.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 17d9ec9..3a8d719 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -11,7 +11,6 @@ from pymtl3 import * -from lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL From 9b9c737b69bc897dd64c125522b93c27bd77e0ba Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:17:10 +0800 Subject: [PATCH 05/45] Populate values for #ctrl and use decimal for fu_in, outport and predicate_in list instead of 0x --- mem/ctrl/CtrlMemRTL.py | 24 ++++++++++++++++++++---- tile/TileRTL.py | 11 ++++++----- 2 files changed, 26 insertions(+), 9 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index a0dbc60..da50684 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -72,11 +72,27 @@ def update_raddr(): s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) def line_trace( s ): - - out_md = markdown_table([ data.__dict__ for data in s.reg_file.regs ]).set_params(quote=False).get_markdown() + out_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] + for out_dict in out_dicts: + out_dict['ctrl'] = OPT_SYMBOL_DICT[out_dict['ctrl']] + out_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] + out_dict['outport'] = [ int(op) for op in out_dict['outport']] + out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) - recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.recv_ctrl.msg.__dict__.items()]) - send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.send_ctrl.msg.__dict__.items()]) + recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) + recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] + recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] + recv_ctrl_msg_dict['outport'] = [ int(op) for op in out_dict['outport']] + recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) + send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) + send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] + send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] + send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] + send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] + send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) + print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' f'- recv_ctrl_msg:\n' f'{recv_ctrl_msg}\n' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 3a8d719..768dd35 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -11,6 +11,7 @@ from pymtl3 import * +from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL @@ -140,11 +141,11 @@ def line_trace( s ): dict_with_direction.update(data) recv_list.append(dict_with_direction) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - recv_opt_msg_dict = s.crossbar.recv_opt.msg.__dict__ - # todo - # E AttributeError: 'str' object has no attribute 'clone' - # print(f"s.crossbar.recv_opt.msg: {s.crossbar.recv_opt.msg}") - # recv_opt_msg_dict['ctrl'] = OPT_SYMBOL_DICT[s.crossbar.recv_opt.msg.ctrl] + recv_opt_msg_dict = dict(s.crossbar.recv_opt.msg.__dict__) + recv_opt_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_opt_msg_dict['ctrl']] + recv_opt_msg_dict['fu_in'] = [int(fi) for fi in recv_opt_msg_dict['fu_in']] + recv_opt_msg_dict['outport'] = [int(op) for op in recv_opt_msg_dict['outport']] + recv_opt_msg_dict['predicate_in'] = [int(pi) for pi in recv_opt_msg_dict['predicate_in']] recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) channel_recv_md = markdown_table([ x.recv.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() From dddb3e16bc461766131135c6d2a4044a9c5ff802 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:23:08 +0800 Subject: [PATCH 06/45] Populate values for #ctrl and use decimal for fu_in, outport and predicate_in list instead of 0x --- mem/ctrl/CtrlMemRTL.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index da50684..3afe78b 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -76,7 +76,8 @@ def line_trace( s ): for out_dict in out_dicts: out_dict['ctrl'] = OPT_SYMBOL_DICT[out_dict['ctrl']] out_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] - out_dict['outport'] = [ int(op) for op in out_dict['outport']] + if out_dict['outport']: + out_dict['outport'] = [ int(op) for op in out_dict['outport']] out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) From 04f63fa5499a1d70028d43384706378923edf186 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:27:08 +0800 Subject: [PATCH 07/45] Populate values for #ctrl and use decimal for fu_in, outport and predicate_in list instead of 0x --- mem/ctrl/CtrlMemRTL.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 3afe78b..13b692b 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -76,22 +76,27 @@ def line_trace( s ): for out_dict in out_dicts: out_dict['ctrl'] = OPT_SYMBOL_DICT[out_dict['ctrl']] out_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] - if out_dict['outport']: + if 'outport' in out_dict: out_dict['outport'] = [ int(op) for op in out_dict['outport']] - out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + if 'predicate_in' in out_dict: + out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] - recv_ctrl_msg_dict['outport'] = [ int(op) for op in out_dict['outport']] - recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + if 'outport' in recv_ctrl_msg_dict: + recv_ctrl_msg_dict['outport'] = [ int(op) for op in out_dict['outport']] + if 'predicate_in' in recv_ctrl_msg_dict: + recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] - send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] - send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] + if 'outport' in send_ctrl_msg_dict: + send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] + if 'predicate_in' in send_ctrl_msg_dict: + send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' From 3e0a5060ccc241ed3368a5c54c4e79541998b8c9 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:57:56 +0800 Subject: [PATCH 08/45] Use decimal for trace bit values instead of 0x --- mem/ctrl/CtrlMemRTL.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 13b692b..2daa3ab 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -92,11 +92,19 @@ def line_trace( s ): recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] + if 'predicate' in send_ctrl_msg_dict: + send_ctrl_msg_dict['predicate'] = int(send_ctrl_msg_dict['predicate']) send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] if 'outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] if 'predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] + if 'routing_xbar_outport' in send_ctrl_msg_dict: + send_ctrl_msg_dict['routing_xbar_outport'] = [int(rxop) for rxop in send_ctrl_msg_dict['routing_xbar_outport']] + if 'fu_xbar_outport' in send_ctrl_msg_dict: + send_ctrl_msg_dict['fu_xbar_outport'] = [int(fxop) for fxop in send_ctrl_msg_dict['fu_xbar_outport']] + if 'routing_predicate_in' in send_ctrl_msg_dict: + send_ctrl_msg_dict['routing_predicate_in'] = [int(rpi) for rpi in send_ctrl_msg_dict['routing_predicate_in']] send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' From 3c650210c11aee0316127275f5e6190aa6d49018 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 23:24:53 +0800 Subject: [PATCH 09/45] Format Ctrl and Crossbar RTL --- fu/flexible/FlexibleFuRTL.py | 15 ++++- mem/ctrl/CtrlMemRTL.py | 7 +- tile/TileRTL.py | 4 +- tile/TileRTL_constant.py | 10 +++ tile/TileSeparateCrossbarRTL.py | 109 ++++++++++++++++++++++++++++---- 5 files changed, 127 insertions(+), 18 deletions(-) create mode 100644 tile/TileRTL_constant.py diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 4f15d3d..60c3e6c 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -12,6 +12,8 @@ from py_markdown_table.markdown_table import markdown_table from pymtl3 import * + +from tile.TileRTL_constant import tile_port_direction_dict from ...fu.single.MemUnitRTL import MemUnitRTL from ...fu.single.AdderRTL import AdderRTL from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL @@ -118,11 +120,18 @@ def line_trace( s ): opt_str = " #" if s.recv_opt.en: opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - # out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' + out_md = markdown_table([x.msg.__dict__ for x in s.send_out]).set_params(quote=False).get_markdown() - # recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' - recv_list = [x.msg.__dict__ for x in s.recv_in] + + recv_data = [x.msg.__dict__ for x in s.recv_in] + recv_list = [] + for idx, data in enumerate(recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + recv_list.append(dict_with_direction) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + return (f'## class: {s.__class__.__name__}\n' f'- recv:' f'{recv_md}\n' diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 2daa3ab..6fb8383 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -80,6 +80,12 @@ def line_trace( s ): out_dict['outport'] = [ int(op) for op in out_dict['outport']] if 'predicate_in' in out_dict: out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + if 'routing_xbar_outport' in out_dict: + out_dict['routing_xbar_outport'] = [ int(rxop) for rxop in out_dict['routing_xbar_outport']] + if 'fu_xbar_outport' in out_dict: + out_dict['fu_xbar_outport'] = [ int(fxop) for fxop in out_dict['fu_xbar_outport']] + if 'routing_predicate_in' in out_dict: + out_dict['routing_predicate_in'] = [ int(rpi) for rpi in out_dict['routing_predicate_in']] out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) @@ -106,7 +112,6 @@ def line_trace( s ): if 'routing_predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['routing_predicate_in'] = [int(rpi) for rpi in send_ctrl_msg_dict['routing_predicate_in']] send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) - print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' f'- recv_ctrl_msg:\n' f'{recv_ctrl_msg}\n' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 768dd35..d084825 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -11,6 +11,7 @@ from pymtl3 import * +from .TileRTL_constant import tile_port_direction_dict from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL @@ -28,9 +29,6 @@ # from ..noc.BypassChannelRTL import BypassChannelRTL from py_markdown_table.markdown_table import markdown_table -tile_port_direction_dict = {0: "NORTH", 1: "SOUTH", 2: "WEST", 3: "EAST", 4: "NORTHWEST", 5: "NORTHEAST", - 6: "SOUTHEAST", 7: "SOUTHWEST"} - class TileRTL( Component ): def construct( s, DataType, PredicateType, CtrlType, diff --git a/tile/TileRTL_constant.py b/tile/TileRTL_constant.py new file mode 100644 index 0000000..3cbc4a3 --- /dev/null +++ b/tile/TileRTL_constant.py @@ -0,0 +1,10 @@ +tile_port_direction_dict = { + 0: "NORTH", + 1: "SOUTH", + 2: "WEST", + 3: "EAST", + 4: "NORTHWEST", + 5: "NORTHEAST", + 6: "SOUTHEAST", + 7: "SOUTHWEST" +} diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 4dff881..8614695 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -13,10 +13,11 @@ Author : Cheng Tan Date : Nov 26, 2024 """ - - +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * +from .TileRTL_constant import tile_port_direction_dict +from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL @@ -193,12 +194,98 @@ def update_opt(): # Line trace def line_trace( s ): - recv_str = "|".join([ str(x.msg) for x in s.recv_data ]) - tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) - tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) - fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) - fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) - out_str = "|".join([ "("+str(x.msg.payload)+","+str(x.msg.predicate)+")" for x in s.send_data ]) - return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " - # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" - + recv_data = [x.msg.__dict__ for x in s.recv_data] + recv_list = [] + for idx, data in enumerate(recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + recv_list.append(dict_with_direction) + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + + routing_crossbar_dict = dict(s.routing_crossbar.recv_opt.msg.__dict__) + routing_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[routing_crossbar_dict['ctrl']] + routing_crossbar_dict['predicate'] = int(routing_crossbar_dict['predicate']) + routing_crossbar_dict['fu_in'] = [int(fi) for fi in routing_crossbar_dict['fu_in']] + routing_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in routing_crossbar_dict['fu_xbar_outport']] + routing_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in routing_crossbar_dict['routing_predicate_in']] + routing_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in routing_crossbar_dict['routing_xbar_outport']] + routing_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in routing_crossbar_dict.items()]) + + fu_crossbar_dict = dict(s.fu_crossbar.recv_opt.msg.__dict__) + fu_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[fu_crossbar_dict['ctrl']] + fu_crossbar_dict['predicate'] = int(fu_crossbar_dict['predicate']) + fu_crossbar_dict['fu_in'] = [int(fi) for fi in fu_crossbar_dict['fu_in']] + fu_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in fu_crossbar_dict['fu_xbar_outport']] + fu_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in fu_crossbar_dict['routing_predicate_in']] + fu_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in fu_crossbar_dict['routing_xbar_outport']] + fu_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in fu_crossbar_dict.items()]) + + tile_out_channel_recv_data = [x.recv.msg.__dict__ for x in s.tile_out_channel] + tile_out_channel_recv_data_list = [] + for idx, data in enumerate(tile_out_channel_recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + tile_out_channel_recv_data_list.append(dict_with_direction) + tile_out_channel_recv_md = markdown_table(tile_out_channel_recv_data_list).set_params(quote=False).get_markdown() + + tile_out_channel_send_data = [x.send.msg.__dict__ for x in s.tile_out_channel] + tile_out_channel_send_data_list = [] + for idx, data in enumerate(tile_out_channel_send_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + tile_out_channel_send_data_list.append(dict_with_direction) + tile_out_channel_send_md = markdown_table(tile_out_channel_send_data_list).set_params(quote=False).get_markdown() + + fu_in_channel_recv_data = [x.recv.msg.__dict__ for x in s.fu_in_channel] + fu_in_channel_recv_data_list = [] + for idx, data in enumerate(fu_in_channel_recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + fu_in_channel_recv_data_list.append(dict_with_direction) + fu_in_channel_recv_md = markdown_table(fu_in_channel_recv_data_list).set_params(quote=False).get_markdown() + + fu_in_channel_send_data = [x.send.msg.__dict__ for x in s.fu_in_channel] + fu_in_channel_send_data_list = [] + for idx, data in enumerate(fu_in_channel_send_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + fu_in_channel_send_data_list.append(dict_with_direction) + fu_in_channel_send_md = markdown_table(fu_in_channel_send_data_list).set_params(quote=False).get_markdown() + + tile_outports_data = [x.msg.__dict__ for x in s.send_data] + tile_outports_data_list = [] + for idx, data in enumerate(tile_outports_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + tile_outports_data_list.append(dict_with_direction) + tile_outports_md = markdown_table(tile_outports_data_list).set_params(quote=False).get_markdown() + + return (f'\n## class: {s.__class__.__name__}\n' + f'- tile_inports:\n' + f'{recv_md}\n' + f'===>\n' + f'- routing_crossbar:\n' + f'{routing_crossbar_str}\n' + f'- fu_crossbar:\n' + f'{fu_crossbar_str}\n' + f'- element:\n' + f'{s.element.line_trace()}\n' + f'- tile_out_channels_recv:\n' + f'{tile_out_channel_recv_md}\n' + f'===>\n' + f'- tile_out_channel_send:\n' + f'{tile_out_channel_send_md}\n' + f'- fu_in_channels_recv:\n' + f'{fu_in_channel_recv_md}\n' + f'===>\n' + f'- fu_in_channels_send:\n' + f'{fu_in_channel_send_md}\n' + f'===>\n' + f'- tile_outports:\n' + f'{tile_outports_md}\n') From 0dfb132ca3ba3890d369ba8dda1ea9791c55679c Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 23:29:30 +0800 Subject: [PATCH 10/45] Format Ctrl and Crossbar RTL --- fu/flexible/FlexibleFuRTL.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 60c3e6c..3e31674 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -13,7 +13,7 @@ from py_markdown_table.markdown_table import markdown_table from pymtl3 import * -from tile.TileRTL_constant import tile_port_direction_dict +from ...tile.TileRTL_constant import tile_port_direction_dict from ...fu.single.MemUnitRTL import MemUnitRTL from ...fu.single.AdderRTL import AdderRTL from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL From 84c1921712c4bf3de455ec348a63722af8d36309 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 19 Dec 2024 22:04:16 +0800 Subject: [PATCH 11/45] Format data mem --- cgra/CGRAKingMeshRTL.py | 2 +- mem/data/DataMemRTL.py | 28 +++++++++++++++------------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index 5dd7ed5..d05cf8f 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -158,6 +158,6 @@ def line_trace( s ): res = '' for (i, x) in enumerate(s.tile): res += "# [tile"+str(i)+"]: " + x.line_trace() + x.ctrl_mem.line_trace() + '\n' - res += "\n data_mem:: [" + s.data_mem.line_trace() + "] \n" + res += f"\ndata_mem: {s.data_mem.line_trace()}" res += "------\n\n" return res diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index 9f620a6..b4a7770 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -7,8 +7,7 @@ Author : Cheng Tan Date : Dec 20, 2019 """ - - +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from pymtl3.stdlib.primitive import RegisterFile from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL @@ -99,14 +98,17 @@ def update_signal(): s.recv_wdata[i].rdy @= Bits1( 1 ) def line_trace(s): - recv_raddr_str = "recv_read_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_raddr])}]' - recv_waddr_str = "recv_write_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_waddr])}]' - recv_wdata_str = "recv_write_data: " + f'[{", ".join([str(data.msg.__dict__) for data in s.recv_wdata])}]' - content_str = "content: " + f'[{", ".join([str(data.__dict__) for data in s.reg_file.regs])}]' - send_rdata_str = "send_read_data: " + f'[{", ".join([str(data.msg) for data in s.send_rdata])}]' - return f'class: {s.__class__.__name__}, {recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' - # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' - # return s.reg_file.line_trace() - # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' + recv_raddr_str = f'[{", ".join([str(data.msg) for data in s.recv_raddr])}]' + recv_waddr_str = f'[{", ".join([str(data.msg) for data in s.recv_waddr])}]' + recv_wdata_dicts = [dict(data.msg.__dict__) for data in s.recv_wdata] + recv_wdata_md = markdown_table(recv_wdata_dicts).set_params(quote=False).get_markdown() + reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] + reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() + send_rdata_dicts = [dict(data.msg.__dict__) for data in s.send_rdata] + send_rdata_md = markdown_table(send_rdata_dicts).set_params(quote=False).get_markdown() + return (f'\nclass: {s.__class__.__name__}\n' + f'- recv_raddr: {recv_raddr_str}\n' + f'- recv_waddr: {recv_waddr_str}\n' + f'- recv_wdata: {recv_wdata_md}\n' + f'- regs: {reg_md}\n' + f'- send_rdata: {send_rdata_md}') From 73d5db8725cd3b09e27568094f886ae6353ad196 Mon Sep 17 00:00:00 2001 From: Yuqi Sun <791079835@qq.com> Date: Mon, 9 Dec 2024 22:58:20 +0800 Subject: [PATCH 12/45] Simulation traces are not understandable for human being #23 --- cgra/CGRAKingMeshRTL.py | 2 +- fu/flexible/FlexibleFuRTL.py | 8 +++++--- mem/ctrl/CtrlMemRTL.py | 4 ++-- mem/data/DataMemRTL.py | 12 ++++++------ tile/TileRTL.py | 14 ++++++++------ 5 files changed, 22 insertions(+), 18 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index e9e37b0..a5d1dff 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -155,5 +155,5 @@ def line_trace( s ): # str += " :: [" + s.data_mem.line_trace() + "]" res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) for (i,x) in enumerate(s.tile) ]) - res += "\n :: [" + s.data_mem.line_trace() + "] \n" + res += "\n data_mem:: [" + s.data_mem.line_trace() + "] \n" return res diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 2fdbadd..3be4caf 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -8,6 +8,7 @@ Date : Dec 24, 2019 """ +import json from pymtl3 import * from ...fu.single.MemUnitRTL import MemUnitRTL @@ -111,11 +112,12 @@ def comb_logic(): s.fu_recv_in_rdy_vector[port][i] @= s.fu[i].recv_in[port].rdy s.recv_in[port].rdy @= reduce_or( s.fu_recv_in_rdy_vector[port] ) + def line_trace( s ): opt_str = " #" if s.recv_opt.en: opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - out_str = ",".join([str(x.msg) for x in s.send_out]) - recv_str = ",".join([str(x.msg) for x in s.recv_in]) - return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' + recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' + return f'class: {s.__class__.__name__}, [recv: {recv_str}] opt: {opt_str} (P{s.recv_opt.msg.predicate}) (const: {str(s.recv_const.msg.__dict__)}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {str(s.recv_predicate.msg.__dict__)}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 644882f..0b41bfd 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -73,6 +73,6 @@ def update_raddr(): s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) def line_trace( s ): - out_str = "||".join([ str(data) for data in s.reg_file.regs ]) - return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' + out_str = f'[{", ".join([ str(data.__dict__) for data in s.reg_file.regs ])}]' + return f'class: {s.__class__.__name__}, recv_ctrl_msg: {s.recv_ctrl.msg.__dict__} : out: {out_str} : send_ctrl_msg: {str(s.send_ctrl.msg.__dict__)}' diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index ac7bda0..9f620a6 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -99,12 +99,12 @@ def update_signal(): s.recv_wdata[i].rdy @= Bits1( 1 ) def line_trace(s): - recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) - recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) - recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) - content_str = "content: " + "|".join([str(data) for data in s.reg_file.regs]) - send_rdata_str = "send_read_data: " + "|".join([str(data.msg) for data in s.send_rdata]) - return f'{recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' + recv_raddr_str = "recv_read_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_raddr])}]' + recv_waddr_str = "recv_write_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_waddr])}]' + recv_wdata_str = "recv_write_data: " + f'[{", ".join([str(data.msg.__dict__) for data in s.recv_wdata])}]' + content_str = "content: " + f'[{", ".join([str(data.__dict__) for data in s.reg_file.regs])}]' + send_rdata_str = "send_read_data: " + f'[{", ".join([str(data.msg) for data in s.send_rdata])}]' + return f'class: {s.__class__.__name__}, {recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' # return s.reg_file.line_trace() # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index dd68900..3add022 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -6,6 +6,7 @@ Author : Cheng Tan Date : Dec 11, 2019 """ +import json from pymtl3 import * @@ -123,12 +124,13 @@ def update_opt(): s.crossbar.recv_opt.en @= s.ctrl_mem.send_ctrl.en s.ctrl_mem.send_ctrl.rdy @= s.element.recv_opt.rdy & s.crossbar.recv_opt.rdy + # Line trace def line_trace( s ): - - recv_str = "|".join([ str(x.msg) for x in s.recv_data ]) - channel_recv_str = "|".join([ str(x.recv.msg) for x in s.channel ]) - channel_send_str = "|".join([ str(x.send.msg) for x in s.channel ]) - out_str = "|".join([ "("+str(x.msg.payload)+","+str(x.msg.predicate)+")" for x in s.send_data ]) - return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + recv_str = f'[{", ".join([ str(x.msg.__dict__) for x in s.recv_data ])}]' + # recv_json = json.dumps(s.recv_data) + channel_recv_str = f'[{", ".join([ str(x.recv.msg.__dict__) for x in s.channel ])}]' + channel_send_str = f'[{", ".join([ str(x.send.msg.__dict__) for x in s.channel ])}]' + out_str = f'[{", ".join([ "{send_msg_payload: "+str(x.msg.payload)+", send_msg_predicate: "+str(x.msg.predicate)+"}" for x in s.send_data ])}]' + return f"class: {s.__class__.__name__}, recv: {recv_str} => [recv_opt_msg: {str(s.crossbar.recv_opt.msg.__dict__)}] ({s.element.line_trace()}) => channel_recv: {channel_recv_str} => channel_send: {channel_send_str} => out: {out_str}" From 899ebf92e7bce4b9bd8a22a270a9286bd7a6a26c Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 16 Dec 2024 17:22:10 +0800 Subject: [PATCH 13/45] Simulation traces are not understandable for human being #23 --- cgra/CGRAKingMeshRTL.py | 8 ++++-- fu/flexible/FlexibleFuRTL.py | 26 +++++++++++++++++--- mem/ctrl/CtrlMemRTL.py | 16 +++++++++--- tile/TileRTL.py | 47 +++++++++++++++++++++++++++++++----- 4 files changed, 82 insertions(+), 15 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index a5d1dff..5dd7ed5 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -153,7 +153,11 @@ def construct( s, DataType, PredicateType, CtrlType, width, height, def line_trace( s ): # str = "||".join([ x.element.line_trace() for x in s.tile ]) # str += " :: [" + s.data_mem.line_trace() + "]" - res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - for (i,x) in enumerate(s.tile) ]) + # res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + # for (i,x) in enumerate(s.tile) ]) + res = '' + for (i, x) in enumerate(s.tile): + res += "# [tile"+str(i)+"]: " + x.line_trace() + x.ctrl_mem.line_trace() + '\n' res += "\n data_mem:: [" + s.data_mem.line_trace() + "] \n" + res += "------\n\n" return res diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 3be4caf..4f15d3d 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -10,6 +10,7 @@ """ import json +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from ...fu.single.MemUnitRTL import MemUnitRTL from ...fu.single.AdderRTL import AdderRTL @@ -117,7 +118,26 @@ def line_trace( s ): opt_str = " #" if s.recv_opt.en: opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' - recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' - return f'class: {s.__class__.__name__}, [recv: {recv_str}] opt: {opt_str} (P{s.recv_opt.msg.predicate}) (const: {str(s.recv_const.msg.__dict__)}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {str(s.recv_predicate.msg.__dict__)}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + # out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' + out_md = markdown_table([x.msg.__dict__ for x in s.send_out]).set_params(quote=False).get_markdown() + # recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' + recv_list = [x.msg.__dict__ for x in s.recv_in] + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + return (f'## class: {s.__class__.__name__}\n' + f'- recv:' + f'{recv_md}\n' + f'- opt ({opt_str}):\n' + f' (P{s.recv_opt.msg.predicate})\n' + f' const: {str(s.recv_const.msg.__dict__)}\n' + f' en: {s.recv_const.en}\n' + f'===>\n' + f'- out:' + f'{out_md}\n' + f'- recv_opt.rdy: {s.recv_opt.rdy}\n' + f'- recv_in[0].rdy: {s.recv_in[0].rdy}\n' + f'- recv_in[1].rdy: {s.recv_in[1].rdy}\n' + f'- recv_predicate.msg: {str(s.recv_predicate.msg.__dict__)}\n' + f'- opt: {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}\n' + f'- recv_opt.en: {s.recv_opt.en}\n' + f'- send[0].en: {s.send_out[0].en}\n') diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 0b41bfd..a0dbc60 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -7,8 +7,7 @@ Author : Cheng Tan Date : Dec 21, 2019 """ - - +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from pymtl3.stdlib.primitive import RegisterFile from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL @@ -73,6 +72,15 @@ def update_raddr(): s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) def line_trace( s ): - out_str = f'[{", ".join([ str(data.__dict__) for data in s.reg_file.regs ])}]' - return f'class: {s.__class__.__name__}, recv_ctrl_msg: {s.recv_ctrl.msg.__dict__} : out: {out_str} : send_ctrl_msg: {str(s.send_ctrl.msg.__dict__)}' + + out_md = markdown_table([ data.__dict__ for data in s.reg_file.regs ]).set_params(quote=False).get_markdown() + # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) + recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.recv_ctrl.msg.__dict__.items()]) + send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.send_ctrl.msg.__dict__.items()]) + return (f'\n## class: {s.__class__.__name__}\n' + f'- recv_ctrl_msg:\n' + f'{recv_ctrl_msg}\n' + f'- out: {out_md}\n' + f'- send_ctrl_msg:\n' + f'{send_ctrl_msg}\n') diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 3add022..17d9ec9 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -10,6 +10,8 @@ from pymtl3 import * + +from lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL @@ -24,7 +26,10 @@ from ..noc.ChannelRTL import ChannelRTL from ..rf.RegisterRTL import RegisterRTL # from ..noc.BypassChannelRTL import BypassChannelRTL +from py_markdown_table.markdown_table import markdown_table +tile_port_direction_dict = {0: "NORTH", 1: "SOUTH", 2: "WEST", 3: "EAST", 4: "NORTHWEST", 5: "NORTHEAST", + 6: "SOUTHEAST", 7: "SOUTHWEST"} class TileRTL( Component ): @@ -127,10 +132,40 @@ def update_opt(): # Line trace def line_trace( s ): - recv_str = f'[{", ".join([ str(x.msg.__dict__) for x in s.recv_data ])}]' - # recv_json = json.dumps(s.recv_data) - channel_recv_str = f'[{", ".join([ str(x.recv.msg.__dict__) for x in s.channel ])}]' - channel_send_str = f'[{", ".join([ str(x.send.msg.__dict__) for x in s.channel ])}]' - out_str = f'[{", ".join([ "{send_msg_payload: "+str(x.msg.payload)+", send_msg_predicate: "+str(x.msg.predicate)+"}" for x in s.send_data ])}]' - return f"class: {s.__class__.__name__}, recv: {recv_str} => [recv_opt_msg: {str(s.crossbar.recv_opt.msg.__dict__)}] ({s.element.line_trace()}) => channel_recv: {channel_recv_str} => channel_send: {channel_send_str} => out: {out_str}" + # recv_str = f'[{", ".join([ str(x.msg.__dict__) for x in s.recv_data ])}]' + recv_data = [ x.msg.__dict__ for x in s.recv_data ] + recv_list = [] + for idx, data in enumerate(recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + recv_list.append(dict_with_direction) + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + recv_opt_msg_dict = s.crossbar.recv_opt.msg.__dict__ + # todo + # E AttributeError: 'str' object has no attribute 'clone' + # print(f"s.crossbar.recv_opt.msg: {s.crossbar.recv_opt.msg}") + # recv_opt_msg_dict['ctrl'] = OPT_SYMBOL_DICT[s.crossbar.recv_opt.msg.ctrl] + recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) + + channel_recv_md = markdown_table([ x.recv.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() + channel_send_md = markdown_table([ x.send.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() + out_md = markdown_table([ dict(send_msg_payload=x.msg.payload, send_msg_predicate=x.msg.predicate) for x in s.send_data ]).set_params(quote=False).get_markdown() + return (f"\n## class[{s.__class__.__name__}]:\n" + f"- recv:" + f"{recv_md}\n" + f"===>\n" + f"- recv_opt_msg:\n" + f"{recv_opt_msg}\n" + f"- element:\n" + f"{s.element.line_trace()}\n" + f"===>\n" + f"- channel_recv:\n" + f"{channel_recv_md}\n" + f"===>\n" + f"- channel_send:" + f"{channel_send_md}\n" + f"===>\n" + f"- out:" + f"{out_md}\n") From 2640d30cc3ff59b784a34b2d5b1dd6da3bec5a8e Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 16 Dec 2024 17:30:13 +0800 Subject: [PATCH 14/45] Simulation traces are not understandable for human being #23 --- .github/workflows/python-package.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 2850045..beac47c 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -52,6 +52,7 @@ jobs: pip install -U git+https://github.com/tancheng/pymtl3.1@yo-struct-list-fix pip install hypothesis pip install pytest + pip install py-markdown-table pip list - name: Test and translate with pytest From 2f5f354565012c42c72ad27063231841fbed5908 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 16 Dec 2024 17:33:15 +0800 Subject: [PATCH 15/45] Simulation traces are not understandable for human being #23 --- tile/TileRTL.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 17d9ec9..3a8d719 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -11,7 +11,6 @@ from pymtl3 import * -from lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL From fd1b30e333b69684074c6385d8ba60c3a79c3a7a Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:17:10 +0800 Subject: [PATCH 16/45] Populate values for #ctrl and use decimal for fu_in, outport and predicate_in list instead of 0x --- mem/ctrl/CtrlMemRTL.py | 24 ++++++++++++++++++++---- tile/TileRTL.py | 11 ++++++----- 2 files changed, 26 insertions(+), 9 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index a0dbc60..da50684 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -72,11 +72,27 @@ def update_raddr(): s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) def line_trace( s ): - - out_md = markdown_table([ data.__dict__ for data in s.reg_file.regs ]).set_params(quote=False).get_markdown() + out_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] + for out_dict in out_dicts: + out_dict['ctrl'] = OPT_SYMBOL_DICT[out_dict['ctrl']] + out_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] + out_dict['outport'] = [ int(op) for op in out_dict['outport']] + out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) - recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.recv_ctrl.msg.__dict__.items()]) - send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in s.send_ctrl.msg.__dict__.items()]) + recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) + recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] + recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] + recv_ctrl_msg_dict['outport'] = [ int(op) for op in out_dict['outport']] + recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) + send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) + send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] + send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] + send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] + send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] + send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) + print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' f'- recv_ctrl_msg:\n' f'{recv_ctrl_msg}\n' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 3a8d719..768dd35 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -11,6 +11,7 @@ from pymtl3 import * +from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL @@ -140,11 +141,11 @@ def line_trace( s ): dict_with_direction.update(data) recv_list.append(dict_with_direction) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - recv_opt_msg_dict = s.crossbar.recv_opt.msg.__dict__ - # todo - # E AttributeError: 'str' object has no attribute 'clone' - # print(f"s.crossbar.recv_opt.msg: {s.crossbar.recv_opt.msg}") - # recv_opt_msg_dict['ctrl'] = OPT_SYMBOL_DICT[s.crossbar.recv_opt.msg.ctrl] + recv_opt_msg_dict = dict(s.crossbar.recv_opt.msg.__dict__) + recv_opt_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_opt_msg_dict['ctrl']] + recv_opt_msg_dict['fu_in'] = [int(fi) for fi in recv_opt_msg_dict['fu_in']] + recv_opt_msg_dict['outport'] = [int(op) for op in recv_opt_msg_dict['outport']] + recv_opt_msg_dict['predicate_in'] = [int(pi) for pi in recv_opt_msg_dict['predicate_in']] recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) channel_recv_md = markdown_table([ x.recv.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() From 1ce8c61a7a6154daaed478e2d3b2cfe2bd1ff95f Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:23:08 +0800 Subject: [PATCH 17/45] Populate values for #ctrl and use decimal for fu_in, outport and predicate_in list instead of 0x --- mem/ctrl/CtrlMemRTL.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index da50684..3afe78b 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -76,7 +76,8 @@ def line_trace( s ): for out_dict in out_dicts: out_dict['ctrl'] = OPT_SYMBOL_DICT[out_dict['ctrl']] out_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] - out_dict['outport'] = [ int(op) for op in out_dict['outport']] + if out_dict['outport']: + out_dict['outport'] = [ int(op) for op in out_dict['outport']] out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) From a6eaf41b51deb8533e5322d04f9c1843f1f648f8 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:27:08 +0800 Subject: [PATCH 18/45] Populate values for #ctrl and use decimal for fu_in, outport and predicate_in list instead of 0x --- mem/ctrl/CtrlMemRTL.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 3afe78b..13b692b 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -76,22 +76,27 @@ def line_trace( s ): for out_dict in out_dicts: out_dict['ctrl'] = OPT_SYMBOL_DICT[out_dict['ctrl']] out_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] - if out_dict['outport']: + if 'outport' in out_dict: out_dict['outport'] = [ int(op) for op in out_dict['outport']] - out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + if 'predicate_in' in out_dict: + out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] - recv_ctrl_msg_dict['outport'] = [ int(op) for op in out_dict['outport']] - recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + if 'outport' in recv_ctrl_msg_dict: + recv_ctrl_msg_dict['outport'] = [ int(op) for op in out_dict['outport']] + if 'predicate_in' in recv_ctrl_msg_dict: + recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] - send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] - send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] + if 'outport' in send_ctrl_msg_dict: + send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] + if 'predicate_in' in send_ctrl_msg_dict: + send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' From bca2dde4d5465cd77a62a0d5e147a1b631c50ac4 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 17:57:56 +0800 Subject: [PATCH 19/45] Use decimal for trace bit values instead of 0x --- mem/ctrl/CtrlMemRTL.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 13b692b..2daa3ab 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -92,11 +92,19 @@ def line_trace( s ): recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] + if 'predicate' in send_ctrl_msg_dict: + send_ctrl_msg_dict['predicate'] = int(send_ctrl_msg_dict['predicate']) send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] if 'outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] if 'predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] + if 'routing_xbar_outport' in send_ctrl_msg_dict: + send_ctrl_msg_dict['routing_xbar_outport'] = [int(rxop) for rxop in send_ctrl_msg_dict['routing_xbar_outport']] + if 'fu_xbar_outport' in send_ctrl_msg_dict: + send_ctrl_msg_dict['fu_xbar_outport'] = [int(fxop) for fxop in send_ctrl_msg_dict['fu_xbar_outport']] + if 'routing_predicate_in' in send_ctrl_msg_dict: + send_ctrl_msg_dict['routing_predicate_in'] = [int(rpi) for rpi in send_ctrl_msg_dict['routing_predicate_in']] send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' From 2fe23a81e370501d4489dc5e2fe96efe035c0d1a Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 23:24:53 +0800 Subject: [PATCH 20/45] Format Ctrl and Crossbar RTL --- fu/flexible/FlexibleFuRTL.py | 15 ++++- mem/ctrl/CtrlMemRTL.py | 7 +- tile/TileRTL.py | 4 +- tile/TileRTL_constant.py | 10 +++ tile/TileSeparateCrossbarRTL.py | 109 ++++++++++++++++++++++++++++---- 5 files changed, 127 insertions(+), 18 deletions(-) create mode 100644 tile/TileRTL_constant.py diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 4f15d3d..60c3e6c 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -12,6 +12,8 @@ from py_markdown_table.markdown_table import markdown_table from pymtl3 import * + +from tile.TileRTL_constant import tile_port_direction_dict from ...fu.single.MemUnitRTL import MemUnitRTL from ...fu.single.AdderRTL import AdderRTL from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL @@ -118,11 +120,18 @@ def line_trace( s ): opt_str = " #" if s.recv_opt.en: opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - # out_str = f'[{",".join([str(x.msg.__dict__) for x in s.send_out])}]' + out_md = markdown_table([x.msg.__dict__ for x in s.send_out]).set_params(quote=False).get_markdown() - # recv_str = f'[{",".join([str(x.msg.__dict__) for x in s.recv_in])}]' - recv_list = [x.msg.__dict__ for x in s.recv_in] + + recv_data = [x.msg.__dict__ for x in s.recv_in] + recv_list = [] + for idx, data in enumerate(recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + recv_list.append(dict_with_direction) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + return (f'## class: {s.__class__.__name__}\n' f'- recv:' f'{recv_md}\n' diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 2daa3ab..6fb8383 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -80,6 +80,12 @@ def line_trace( s ): out_dict['outport'] = [ int(op) for op in out_dict['outport']] if 'predicate_in' in out_dict: out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + if 'routing_xbar_outport' in out_dict: + out_dict['routing_xbar_outport'] = [ int(rxop) for rxop in out_dict['routing_xbar_outport']] + if 'fu_xbar_outport' in out_dict: + out_dict['fu_xbar_outport'] = [ int(fxop) for fxop in out_dict['fu_xbar_outport']] + if 'routing_predicate_in' in out_dict: + out_dict['routing_predicate_in'] = [ int(rpi) for rpi in out_dict['routing_predicate_in']] out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) @@ -106,7 +112,6 @@ def line_trace( s ): if 'routing_predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['routing_predicate_in'] = [int(rpi) for rpi in send_ctrl_msg_dict['routing_predicate_in']] send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) - print(f"send_ctrl_msg_dict: {send_ctrl_msg_dict}") return (f'\n## class: {s.__class__.__name__}\n' f'- recv_ctrl_msg:\n' f'{recv_ctrl_msg}\n' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 768dd35..d084825 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -11,6 +11,7 @@ from pymtl3 import * +from .TileRTL_constant import tile_port_direction_dict from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL @@ -28,9 +29,6 @@ # from ..noc.BypassChannelRTL import BypassChannelRTL from py_markdown_table.markdown_table import markdown_table -tile_port_direction_dict = {0: "NORTH", 1: "SOUTH", 2: "WEST", 3: "EAST", 4: "NORTHWEST", 5: "NORTHEAST", - 6: "SOUTHEAST", 7: "SOUTHWEST"} - class TileRTL( Component ): def construct( s, DataType, PredicateType, CtrlType, diff --git a/tile/TileRTL_constant.py b/tile/TileRTL_constant.py new file mode 100644 index 0000000..3cbc4a3 --- /dev/null +++ b/tile/TileRTL_constant.py @@ -0,0 +1,10 @@ +tile_port_direction_dict = { + 0: "NORTH", + 1: "SOUTH", + 2: "WEST", + 3: "EAST", + 4: "NORTHWEST", + 5: "NORTHEAST", + 6: "SOUTHEAST", + 7: "SOUTHWEST" +} diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 4dff881..8614695 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -13,10 +13,11 @@ Author : Cheng Tan Date : Nov 26, 2024 """ - - +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * +from .TileRTL_constant import tile_port_direction_dict +from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL @@ -193,12 +194,98 @@ def update_opt(): # Line trace def line_trace( s ): - recv_str = "|".join([ str(x.msg) for x in s.recv_data ]) - tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) - tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) - fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) - fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) - out_str = "|".join([ "("+str(x.msg.payload)+","+str(x.msg.predicate)+")" for x in s.send_data ]) - return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " - # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" - + recv_data = [x.msg.__dict__ for x in s.recv_data] + recv_list = [] + for idx, data in enumerate(recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + recv_list.append(dict_with_direction) + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + + routing_crossbar_dict = dict(s.routing_crossbar.recv_opt.msg.__dict__) + routing_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[routing_crossbar_dict['ctrl']] + routing_crossbar_dict['predicate'] = int(routing_crossbar_dict['predicate']) + routing_crossbar_dict['fu_in'] = [int(fi) for fi in routing_crossbar_dict['fu_in']] + routing_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in routing_crossbar_dict['fu_xbar_outport']] + routing_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in routing_crossbar_dict['routing_predicate_in']] + routing_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in routing_crossbar_dict['routing_xbar_outport']] + routing_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in routing_crossbar_dict.items()]) + + fu_crossbar_dict = dict(s.fu_crossbar.recv_opt.msg.__dict__) + fu_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[fu_crossbar_dict['ctrl']] + fu_crossbar_dict['predicate'] = int(fu_crossbar_dict['predicate']) + fu_crossbar_dict['fu_in'] = [int(fi) for fi in fu_crossbar_dict['fu_in']] + fu_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in fu_crossbar_dict['fu_xbar_outport']] + fu_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in fu_crossbar_dict['routing_predicate_in']] + fu_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in fu_crossbar_dict['routing_xbar_outport']] + fu_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in fu_crossbar_dict.items()]) + + tile_out_channel_recv_data = [x.recv.msg.__dict__ for x in s.tile_out_channel] + tile_out_channel_recv_data_list = [] + for idx, data in enumerate(tile_out_channel_recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + tile_out_channel_recv_data_list.append(dict_with_direction) + tile_out_channel_recv_md = markdown_table(tile_out_channel_recv_data_list).set_params(quote=False).get_markdown() + + tile_out_channel_send_data = [x.send.msg.__dict__ for x in s.tile_out_channel] + tile_out_channel_send_data_list = [] + for idx, data in enumerate(tile_out_channel_send_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + tile_out_channel_send_data_list.append(dict_with_direction) + tile_out_channel_send_md = markdown_table(tile_out_channel_send_data_list).set_params(quote=False).get_markdown() + + fu_in_channel_recv_data = [x.recv.msg.__dict__ for x in s.fu_in_channel] + fu_in_channel_recv_data_list = [] + for idx, data in enumerate(fu_in_channel_recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + fu_in_channel_recv_data_list.append(dict_with_direction) + fu_in_channel_recv_md = markdown_table(fu_in_channel_recv_data_list).set_params(quote=False).get_markdown() + + fu_in_channel_send_data = [x.send.msg.__dict__ for x in s.fu_in_channel] + fu_in_channel_send_data_list = [] + for idx, data in enumerate(fu_in_channel_send_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + fu_in_channel_send_data_list.append(dict_with_direction) + fu_in_channel_send_md = markdown_table(fu_in_channel_send_data_list).set_params(quote=False).get_markdown() + + tile_outports_data = [x.msg.__dict__ for x in s.send_data] + tile_outports_data_list = [] + for idx, data in enumerate(tile_outports_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"port_direction": port_direction} + dict_with_direction.update(data) + tile_outports_data_list.append(dict_with_direction) + tile_outports_md = markdown_table(tile_outports_data_list).set_params(quote=False).get_markdown() + + return (f'\n## class: {s.__class__.__name__}\n' + f'- tile_inports:\n' + f'{recv_md}\n' + f'===>\n' + f'- routing_crossbar:\n' + f'{routing_crossbar_str}\n' + f'- fu_crossbar:\n' + f'{fu_crossbar_str}\n' + f'- element:\n' + f'{s.element.line_trace()}\n' + f'- tile_out_channels_recv:\n' + f'{tile_out_channel_recv_md}\n' + f'===>\n' + f'- tile_out_channel_send:\n' + f'{tile_out_channel_send_md}\n' + f'- fu_in_channels_recv:\n' + f'{fu_in_channel_recv_md}\n' + f'===>\n' + f'- fu_in_channels_send:\n' + f'{fu_in_channel_send_md}\n' + f'===>\n' + f'- tile_outports:\n' + f'{tile_outports_md}\n') From 839c9794f0df4bcfdda0e1d84591b2d868dfe95e Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 17 Dec 2024 23:29:30 +0800 Subject: [PATCH 21/45] Format Ctrl and Crossbar RTL --- fu/flexible/FlexibleFuRTL.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 60c3e6c..3e31674 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -13,7 +13,7 @@ from py_markdown_table.markdown_table import markdown_table from pymtl3 import * -from tile.TileRTL_constant import tile_port_direction_dict +from ...tile.TileRTL_constant import tile_port_direction_dict from ...fu.single.MemUnitRTL import MemUnitRTL from ...fu.single.AdderRTL import AdderRTL from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL From 11f53a1585d66042da876e6de86cb6969c67a9e6 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 19 Dec 2024 22:04:16 +0800 Subject: [PATCH 22/45] Format data mem --- cgra/CGRAKingMeshRTL.py | 2 +- mem/data/DataMemRTL.py | 28 +++++++++++++++------------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index 5dd7ed5..d05cf8f 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -158,6 +158,6 @@ def line_trace( s ): res = '' for (i, x) in enumerate(s.tile): res += "# [tile"+str(i)+"]: " + x.line_trace() + x.ctrl_mem.line_trace() + '\n' - res += "\n data_mem:: [" + s.data_mem.line_trace() + "] \n" + res += f"\ndata_mem: {s.data_mem.line_trace()}" res += "------\n\n" return res diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index 9f620a6..b4a7770 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -7,8 +7,7 @@ Author : Cheng Tan Date : Dec 20, 2019 """ - - +from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from pymtl3.stdlib.primitive import RegisterFile from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL @@ -99,14 +98,17 @@ def update_signal(): s.recv_wdata[i].rdy @= Bits1( 1 ) def line_trace(s): - recv_raddr_str = "recv_read_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_raddr])}]' - recv_waddr_str = "recv_write_addr: " + f'[{", ".join([str(data.msg) for data in s.recv_waddr])}]' - recv_wdata_str = "recv_write_data: " + f'[{", ".join([str(data.msg.__dict__) for data in s.recv_wdata])}]' - content_str = "content: " + f'[{", ".join([str(data.__dict__) for data in s.reg_file.regs])}]' - send_rdata_str = "send_read_data: " + f'[{", ".join([str(data.msg) for data in s.send_rdata])}]' - return f'class: {s.__class__.__name__}, {recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' - # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' - # return s.reg_file.line_trace() - # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' + recv_raddr_str = f'[{", ".join([str(data.msg) for data in s.recv_raddr])}]' + recv_waddr_str = f'[{", ".join([str(data.msg) for data in s.recv_waddr])}]' + recv_wdata_dicts = [dict(data.msg.__dict__) for data in s.recv_wdata] + recv_wdata_md = markdown_table(recv_wdata_dicts).set_params(quote=False).get_markdown() + reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] + reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() + send_rdata_dicts = [dict(data.msg.__dict__) for data in s.send_rdata] + send_rdata_md = markdown_table(send_rdata_dicts).set_params(quote=False).get_markdown() + return (f'\nclass: {s.__class__.__name__}\n' + f'- recv_raddr: {recv_raddr_str}\n' + f'- recv_waddr: {recv_waddr_str}\n' + f'- recv_wdata: {recv_wdata_md}\n' + f'- regs: {reg_md}\n' + f'- send_rdata: {send_rdata_md}') From ede93650d52a33ba036fbb83aa0065441a063f1d Mon Sep 17 00:00:00 2001 From: yuqisun Date: Sat, 21 Dec 2024 19:24:36 +0800 Subject: [PATCH 23/45] format FlexibleFuRTL --- fu/flexible/FlexibleFuRTL.py | 51 ++++++++++++++++++------------------ 1 file changed, 25 insertions(+), 26 deletions(-) diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 3e31674..5bdbb80 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -8,8 +8,6 @@ Date : Dec 24, 2019 """ -import json - from py_markdown_table.markdown_table import markdown_table from pymtl3 import * @@ -117,36 +115,37 @@ def comb_logic(): def line_trace( s ): - opt_str = " #" - if s.recv_opt.en: - opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - - out_md = markdown_table([x.msg.__dict__ for x in s.send_out]).set_params(quote=False).get_markdown() - - recv_data = [x.msg.__dict__ for x in s.recv_in] + # for clk n + # recv: opt+rdy(if ready to receive opt) and [rdy(if ready to receive data) and msg(data) for each inport(total 4 for now)] + # ? what is recv_const for ? + # out: [en(if data is sent out) and msg for each outport(total 2 for now)] + opt_ctrl = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] + opt_rdy = s.recv_opt.rdy + + recv_data = [x for x in s.recv_in] recv_list = [] for idx, data in enumerate(recv_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} - dict_with_direction.update(data) - recv_list.append(dict_with_direction) + msg_dict = data.msg.__dict__ + fu_inport_dict = {"fu_inport_idx": idx, "rdy": data.rdy} + fu_inport_dict.update(msg_dict) + recv_list.append(fu_inport_dict) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + out_data = [x for x in s.send_out] + out_list = [] + for idx, data in enumerate(out_data): + msg_dict = data.msg.__dict__ + fu_outport_dict = {"fu_outport_idx": idx, "en": data.en} + fu_outport_dict.update(msg_dict) + out_list.append(fu_outport_dict) + out_md = markdown_table(out_list).set_params(quote=False).get_markdown() + return (f'## class: {s.__class__.__name__}\n' - f'- recv:' + f'- recv:\n' + f' opt: {opt_ctrl}, opt_rdy: {opt_rdy}\n' + f' data:' f'{recv_md}\n' - f'- opt ({opt_str}):\n' - f' (P{s.recv_opt.msg.predicate})\n' - f' const: {str(s.recv_const.msg.__dict__)}\n' - f' en: {s.recv_const.en}\n' f'===>\n' f'- out:' - f'{out_md}\n' - f'- recv_opt.rdy: {s.recv_opt.rdy}\n' - f'- recv_in[0].rdy: {s.recv_in[0].rdy}\n' - f'- recv_in[1].rdy: {s.recv_in[1].rdy}\n' - f'- recv_predicate.msg: {str(s.recv_predicate.msg.__dict__)}\n' - f'- opt: {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}\n' - f'- recv_opt.en: {s.recv_opt.en}\n' - f'- send[0].en: {s.send_out[0].en}\n') + f'{out_md}\n') From 7d04f0cb484f5d7aae0438add6e3ed2a8ee0cbce Mon Sep 17 00:00:00 2001 From: yuqisun Date: Sun, 22 Dec 2024 19:42:47 +0800 Subject: [PATCH 24/45] format with directions and addr --- cgra/CGRAKingMeshRTL.py | 4 -- fu/flexible/FlexibleFuRTL.py | 14 +++-- mem/ctrl/CtrlMemRTL.py | 107 +++++++++++++++++++++++++------- mem/data/DataMemRTL.py | 48 ++++++++++---- tile/TileRTL.py | 56 ++++++++--------- tile/TileRTL_constant.py | 11 ++++ tile/TileSeparateCrossbarRTL.py | 12 ++-- 7 files changed, 172 insertions(+), 80 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index d05cf8f..f5ff12e 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -151,10 +151,6 @@ def construct( s, DataType, PredicateType, CtrlType, width, height, # Line trace def line_trace( s ): - # str = "||".join([ x.element.line_trace() for x in s.tile ]) - # str += " :: [" + s.data_mem.line_trace() + "]" - # res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - # for (i,x) in enumerate(s.tile) ]) res = '' for (i, x) in enumerate(s.tile): res += "# [tile"+str(i)+"]: " + x.line_trace() + x.ctrl_mem.line_trace() + '\n' diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 5bdbb80..490171d 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -116,9 +116,11 @@ def comb_logic(): def line_trace( s ): # for clk n - # recv: opt+rdy(if ready to receive opt) and [rdy(if ready to receive data) and msg(data) for each inport(total 4 for now)] - # ? what is recv_const for ? + # recv: + # 1. OPT: opt+rdy(if ready to receive opt) + # 2. Data: [rdy(if ready to receive data) and msg(data) for each inport(total 4 for now)] # out: [en(if data is sent out) and msg for each outport(total 2 for now)] + # ? what is recv_const for ? opt_ctrl = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] opt_rdy = s.recv_opt.rdy @@ -141,11 +143,11 @@ def line_trace( s ): out_md = markdown_table(out_list).set_params(quote=False).get_markdown() return (f'## class: {s.__class__.__name__}\n' - f'- recv:\n' - f' opt: {opt_ctrl}, opt_rdy: {opt_rdy}\n' - f' data:' + f'- FU recv:\n' + f' FU opt: {opt_ctrl}, opt_rdy: {opt_rdy}\n' + f' FU data:' f'{recv_md}\n' f'===>\n' - f'- out:' + f'- FU out:' f'{out_md}\n') diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 6fb8383..3f0dcb2 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -10,6 +10,8 @@ from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from pymtl3.stdlib.primitive import RegisterFile + +from ...tile.TileRTL_constant import tile_port_direction_dict_short_desc from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL from ...lib.opt_type import * @@ -71,31 +73,76 @@ def update_raddr(): else: s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) + def line_trace( s ): - out_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] - for out_dict in out_dicts: - out_dict['ctrl'] = OPT_SYMBOL_DICT[out_dict['ctrl']] - out_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] - if 'outport' in out_dict: - out_dict['outport'] = [ int(op) for op in out_dict['outport']] - if 'predicate_in' in out_dict: - out_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] - if 'routing_xbar_outport' in out_dict: - out_dict['routing_xbar_outport'] = [ int(rxop) for rxop in out_dict['routing_xbar_outport']] - if 'fu_xbar_outport' in out_dict: - out_dict['fu_xbar_outport'] = [ int(fxop) for fxop in out_dict['fu_xbar_outport']] - if 'routing_predicate_in' in out_dict: - out_dict['routing_predicate_in'] = [ int(rpi) for rpi in out_dict['routing_predicate_in']] - out_md = markdown_table(out_dicts).set_params(quote=False).get_markdown() + # Is ConfigMem in Tile? + # + num_fu_in = len(s.reg_file.regs[0].fu_in) + # num_inports = len(s.reg_file.regs[0].predicate_in) + num_outports = len(s.reg_file.regs[0].outport) + num_direction_ports = num_outports - num_fu_in + reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] + for reg_dict in reg_dicts: + reg_dict['ctrl'] = OPT_SYMBOL_DICT[reg_dict['ctrl']] + reg_dict['fu_in'] = [ int(fi) for fi in reg_dict['fu_in']] + if 'outport' in reg_dict: + reg_dict['outport'] = [ int(op) for op in reg_dict['outport']] + fu_reg_num = 1 + for idx, val in enumerate(reg_dict['outport']): + # to directions + if idx <= num_direction_ports-1: + reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'})" + # to fu regs + else: + reg_dict['outport'][idx] = f"fu_reg_{fu_reg_num}({tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'})" + fu_reg_num += 1 + if 'predicate_in' in reg_dict: + reg_dict['predicate_in'] = [ int(pi) for pi in reg_dict['predicate_in']] + fu_out_num = 1 + for idx, val in enumerate(reg_dict['predicate_in']): + # from directions + if idx <= num_direction_ports - 1: + reg_dict['predicate_in'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({val})" + # from fu + else: + reg_dict['predicate_in'][idx] = f"fu_out_{fu_out_num}({val})" + fu_out_num += 1 + if 'routing_xbar_outport' in reg_dict: + reg_dict['routing_xbar_outport'] = [ int(rxop) for rxop in reg_dict['routing_xbar_outport']] + if 'fu_xbar_outport' in reg_dict: + reg_dict['fu_xbar_outport'] = [ int(fxop) for fxop in reg_dict['fu_xbar_outport']] + if 'routing_predicate_in' in reg_dict: + reg_dict['routing_predicate_in'] = [ int(rpi) for rpi in reg_dict['routing_predicate_in']] + reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() + # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] - recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in out_dict['fu_in']] + recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in recv_ctrl_msg_dict['fu_in']] if 'outport' in recv_ctrl_msg_dict: - recv_ctrl_msg_dict['outport'] = [ int(op) for op in out_dict['outport']] + recv_ctrl_msg_dict['outport'] = [ int(op) for op in recv_ctrl_msg_dict['outport']] + fu_reg_num = 1 + for idx, val in enumerate(recv_ctrl_msg_dict['outport']): + # to directions + if idx <= num_direction_ports - 1: + recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + # to fu regs + else: + recv_ctrl_msg_dict['outport'][idx] = f"fu_reg_{fu_reg_num}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + fu_reg_num += 1 if 'predicate_in' in recv_ctrl_msg_dict: - recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in out_dict['predicate_in']] + recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in recv_ctrl_msg_dict['predicate_in']] + fu_out_num = 1 + for idx, val in enumerate(recv_ctrl_msg_dict['predicate_in']): + # from directions + if idx <= num_direction_ports - 1: + recv_ctrl_msg_dict['predicate_in'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({val})" + # from fu + else: + recv_ctrl_msg_dict['predicate_in'][idx] = f"fu_out_{fu_out_num}({val})" + fu_out_num += 1 recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) + send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] if 'predicate' in send_ctrl_msg_dict: @@ -103,8 +150,26 @@ def line_trace( s ): send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] if 'outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] + fu_reg_num = 1 + for idx, val in enumerate(send_ctrl_msg_dict['outport']): + # to directions + if idx <= num_direction_ports - 1: + send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + # to fu regs + else: + send_ctrl_msg_dict['outport'][idx] = f"fu_reg_{fu_reg_num}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + fu_reg_num += 1 if 'predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] + fu_out_num = 1 + for idx, val in enumerate(send_ctrl_msg_dict['predicate_in']): + # from directions + if idx <= num_direction_ports - 1: + send_ctrl_msg_dict['predicate_in'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({val})" + # from fu + else: + send_ctrl_msg_dict['predicate_in'][idx] = f"fu_out_{fu_out_num}({val})" + fu_out_num += 1 if 'routing_xbar_outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['routing_xbar_outport'] = [int(rxop) for rxop in send_ctrl_msg_dict['routing_xbar_outport']] if 'fu_xbar_outport' in send_ctrl_msg_dict: @@ -114,8 +179,8 @@ def line_trace( s ): send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) return (f'\n## class: {s.__class__.__name__}\n' f'- recv_ctrl_msg:\n' - f'{recv_ctrl_msg}\n' - f'- out: {out_md}\n' + f'{recv_ctrl_msg}\n\n' f'- send_ctrl_msg:\n' - f'{send_ctrl_msg}\n') + f'{send_ctrl_msg}\n\n' + f'- regs: {reg_md}\n') diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index b4a7770..2a23c0c 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -98,17 +98,41 @@ def update_signal(): s.recv_wdata[i].rdy @= Bits1( 1 ) def line_trace(s): - recv_raddr_str = f'[{", ".join([str(data.msg) for data in s.recv_raddr])}]' - recv_waddr_str = f'[{", ".join([str(data.msg) for data in s.recv_waddr])}]' - recv_wdata_dicts = [dict(data.msg.__dict__) for data in s.recv_wdata] - recv_wdata_md = markdown_table(recv_wdata_dicts).set_params(quote=False).get_markdown() + # data memory: mem size, reg + # recv_raddr(rdy, msg), send_rdata(en, msg), recv_waddr(rdy, msg), recv_wdata, tile # reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] - reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() - send_rdata_dicts = [dict(data.msg.__dict__) for data in s.send_rdata] - send_rdata_md = markdown_table(send_rdata_dicts).set_params(quote=False).get_markdown() + reg_list = [] + for idx, data in enumerate(reg_dicts): + reg_dict = {"addr": f"addr {idx}"} + reg_dict.update(data) + reg_list.append(reg_dict) + reg_md = markdown_table(reg_list).set_params(quote=False).get_markdown() + + rw_ports_max_count = max(len(s.recv_raddr), len(s.recv_waddr)) + mem_list = [] + for idx in range(rw_ports_max_count): + recv_raddr_rdy, recv_raddr = None, None + send_rdata_en, send_rdata = None, None + recv_waddr_rdy, recv_waddr = None, None + recv_wdata = None + if idx <= len(s.recv_raddr) - 1: + recv_raddr_rdy = s.recv_raddr[idx].rdy + recv_raddr = s.recv_raddr[idx].msg + send_rdata_en = s.send_rdata[idx].en + send_rdata = s.send_rdata[idx].msg.payload + if idx <= len(s.recv_waddr) - 1: + recv_waddr_rdy = s.recv_waddr[idx].rdy + recv_waddr = s.recv_waddr[idx].msg + recv_wdata = s.recv_wdata[idx].msg.payload + mem_dict = {"recv_raddr(rdy, msg)": f"{recv_raddr_rdy}, {recv_raddr}", + "send_rdata(en, msg)": f"{send_rdata_en}, {send_rdata}", + "recv_waddr(rdy, msg)": f"{recv_waddr_rdy}, {recv_waddr}", + "recv_wdata": f"{recv_wdata}", + "Tiles in Col0": "<--- Tile"} + mem_list.append(mem_dict) + mem_md = markdown_table(mem_list).set_params(quote=False).get_markdown() + return (f'\nclass: {s.__class__.__name__}\n' - f'- recv_raddr: {recv_raddr_str}\n' - f'- recv_waddr: {recv_waddr_str}\n' - f'- recv_wdata: {recv_wdata_md}\n' - f'- regs: {reg_md}\n' - f'- send_rdata: {send_rdata_md}') + f'- regs(mem size: {len(reg_dicts)}): {reg_md}\n' + f'- mem_r/w:' + f'{mem_md}') diff --git a/tile/TileRTL.py b/tile/TileRTL.py index d084825..378609c 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -6,9 +6,6 @@ Author : Cheng Tan Date : Dec 11, 2019 """ -import json - - from pymtl3 import * from .TileRTL_constant import tile_port_direction_dict @@ -130,40 +127,37 @@ def update_opt(): # Line trace def line_trace( s ): - # recv_str = f'[{", ".join([ str(x.msg.__dict__) for x in s.recv_data ])}]' - recv_data = [ x.msg.__dict__ for x in s.recv_data ] + # recv: + # 1. rdy (if ready to receive data), if en and rdy: then data has been transferred (val, rdy are new type(protocol)) + # 2. data + # [3. opt will show in FU trace] + # FU: + # FlexibleFuRTL.py + # tile out: + # 1. en (is data transferred) + recv_data = [x for x in s.recv_data] recv_list = [] for idx, data in enumerate(recv_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} - dict_with_direction.update(data) - recv_list.append(dict_with_direction) + msg_dict = data.msg.__dict__ + tile_inport_dict = {"tile_inport_direction": tile_port_direction_dict[idx], "rdy": data.rdy} + tile_inport_dict.update(msg_dict) + recv_list.append(tile_inport_dict) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - recv_opt_msg_dict = dict(s.crossbar.recv_opt.msg.__dict__) - recv_opt_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_opt_msg_dict['ctrl']] - recv_opt_msg_dict['fu_in'] = [int(fi) for fi in recv_opt_msg_dict['fu_in']] - recv_opt_msg_dict['outport'] = [int(op) for op in recv_opt_msg_dict['outport']] - recv_opt_msg_dict['predicate_in'] = [int(pi) for pi in recv_opt_msg_dict['predicate_in']] - recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) - - channel_recv_md = markdown_table([ x.recv.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() - channel_send_md = markdown_table([ x.send.msg.__dict__ for x in s.channel ]).set_params(quote=False).get_markdown() - out_md = markdown_table([ dict(send_msg_payload=x.msg.payload, send_msg_predicate=x.msg.predicate) for x in s.send_data ]).set_params(quote=False).get_markdown() + + out_data = [x for x in s.send_data] + out_list = [] + for idx, data in enumerate(out_data): + msg_dict = data.msg.__dict__ + tile_outport_dict = {"tile_outport_direction": tile_port_direction_dict[idx], "en": data.en} + tile_outport_dict.update(msg_dict) + out_list.append(tile_outport_dict) + out_md = markdown_table(out_list).set_params(quote=False).get_markdown() return (f"\n## class[{s.__class__.__name__}]:\n" - f"- recv:" + f"- Tile recv:" f"{recv_md}\n" - f"===>\n" - f"- recv_opt_msg:\n" - f"{recv_opt_msg}\n" - f"- element:\n" + f"- FU element:\n" f"{s.element.line_trace()}\n" f"===>\n" - f"- channel_recv:\n" - f"{channel_recv_md}\n" - f"===>\n" - f"- channel_send:" - f"{channel_send_md}\n" - f"===>\n" - f"- out:" + f"- Tile out:" f"{out_md}\n") diff --git a/tile/TileRTL_constant.py b/tile/TileRTL_constant.py index 3cbc4a3..d5b1c40 100644 --- a/tile/TileRTL_constant.py +++ b/tile/TileRTL_constant.py @@ -8,3 +8,14 @@ 6: "SOUTHEAST", 7: "SOUTHWEST" } + +tile_port_direction_dict_short_desc = { + 0: "N", + 1: "S", + 2: "W", + 3: "E", + 4: "NW", + 5: "NE", + 6: "SE", + 7: "SW" +} diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 8614695..4129d50 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -198,7 +198,7 @@ def line_trace( s ): recv_list = [] for idx, data in enumerate(recv_data): port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} + dict_with_direction = {"inport_direction": port_direction} dict_with_direction.update(data) recv_list.append(dict_with_direction) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() @@ -225,7 +225,7 @@ def line_trace( s ): tile_out_channel_recv_data_list = [] for idx, data in enumerate(tile_out_channel_recv_data): port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} + dict_with_direction = {"inport_direction": port_direction} dict_with_direction.update(data) tile_out_channel_recv_data_list.append(dict_with_direction) tile_out_channel_recv_md = markdown_table(tile_out_channel_recv_data_list).set_params(quote=False).get_markdown() @@ -234,7 +234,7 @@ def line_trace( s ): tile_out_channel_send_data_list = [] for idx, data in enumerate(tile_out_channel_send_data): port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} + dict_with_direction = {"outport_direction": port_direction} dict_with_direction.update(data) tile_out_channel_send_data_list.append(dict_with_direction) tile_out_channel_send_md = markdown_table(tile_out_channel_send_data_list).set_params(quote=False).get_markdown() @@ -243,7 +243,7 @@ def line_trace( s ): fu_in_channel_recv_data_list = [] for idx, data in enumerate(fu_in_channel_recv_data): port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} + dict_with_direction = {"inport_direction": port_direction} dict_with_direction.update(data) fu_in_channel_recv_data_list.append(dict_with_direction) fu_in_channel_recv_md = markdown_table(fu_in_channel_recv_data_list).set_params(quote=False).get_markdown() @@ -252,7 +252,7 @@ def line_trace( s ): fu_in_channel_send_data_list = [] for idx, data in enumerate(fu_in_channel_send_data): port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} + dict_with_direction = {"outport_direction": port_direction} dict_with_direction.update(data) fu_in_channel_send_data_list.append(dict_with_direction) fu_in_channel_send_md = markdown_table(fu_in_channel_send_data_list).set_params(quote=False).get_markdown() @@ -261,7 +261,7 @@ def line_trace( s ): tile_outports_data_list = [] for idx, data in enumerate(tile_outports_data): port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"port_direction": port_direction} + dict_with_direction = {"outport_direction": port_direction} dict_with_direction.update(data) tile_outports_data_list.append(dict_with_direction) tile_outports_md = markdown_table(tile_outports_data_list).set_params(quote=False).get_markdown() From 48a8a347f2e56d1e050522dec35dbf37b3d0bbd9 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Sun, 22 Dec 2024 19:54:39 +0800 Subject: [PATCH 25/45] format with directions and addr --- mem/ctrl/CtrlMemRTL.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 3f0dcb2..8e70211 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -79,7 +79,7 @@ def line_trace( s ): # num_fu_in = len(s.reg_file.regs[0].fu_in) # num_inports = len(s.reg_file.regs[0].predicate_in) - num_outports = len(s.reg_file.regs[0].outport) + num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) num_direction_ports = num_outports - num_fu_in reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] for reg_dict in reg_dicts: From 1b33b9f17909922b70852d69875aa38f1d880fab Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 23 Dec 2024 14:48:52 +0800 Subject: [PATCH 26/45] format CtrlMemRTL reg with sub header --- mem/ctrl/CtrlMemRTL.py | 33 +++++++++++++++++++++++++++------ 1 file changed, 27 insertions(+), 6 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 8e70211..fcbf3cc 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -75,44 +75,65 @@ def update_raddr(): def line_trace( s ): - # Is ConfigMem in Tile? - # num_fu_in = len(s.reg_file.regs[0].fu_in) # num_inports = len(s.reg_file.regs[0].predicate_in) num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) num_direction_ports = num_outports - num_fu_in reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] + reg_sub_header = {} for reg_dict in reg_dicts: + for key in reg_dict.keys(): + reg_sub_header[key] = '' reg_dict['ctrl'] = OPT_SYMBOL_DICT[reg_dict['ctrl']] reg_dict['fu_in'] = [ int(fi) for fi in reg_dict['fu_in']] + fu_in_header = [] + for idx, val in enumerate(reg_dict['fu_in']): + fu_in_header.append(idx) + fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) + reg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in reg_dict['fu_in']]) + reg_sub_header['fu_in'] = fu_in_header_str if 'outport' in reg_dict: reg_dict['outport'] = [ int(op) for op in reg_dict['outport']] fu_reg_num = 1 + outport_sub_header = [] for idx, val in enumerate(reg_dict['outport']): # to directions if idx <= num_direction_ports-1: - reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'})" + outport_sub_header.append(tile_port_direction_dict_short_desc[idx]) + reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'}" # to fu regs else: - reg_dict['outport'][idx] = f"fu_reg_{fu_reg_num}({tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'})" + outport_sub_header.append(f"fu_reg_{fu_reg_num}") + reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'}" fu_reg_num += 1 + outport_sub_header_str = "|".join([f"{hd : ^8}" for hd in outport_sub_header]) + reg_dict['outport'] = "|".join([f"{v : ^8}" for v in reg_dict['outport']]) + reg_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in reg_dict: reg_dict['predicate_in'] = [ int(pi) for pi in reg_dict['predicate_in']] fu_out_num = 1 + predicate_in_sub_header = [] for idx, val in enumerate(reg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - reg_dict['predicate_in'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({val})" + predicate_in_sub_header.append(tile_port_direction_dict_short_desc[idx]) + reg_dict['predicate_in'][idx] = f"{val}" # from fu else: - reg_dict['predicate_in'][idx] = f"fu_out_{fu_out_num}({val})" + predicate_in_sub_header.append(f"fu_out_{fu_out_num}") + reg_dict['predicate_in'][idx] = f"{val}" fu_out_num += 1 + predicate_in_sub_header_str = "|".join([f"{hd : ^8}" for hd in predicate_in_sub_header]) + reg_dict['predicate_in'] = "|".join([f"{v : ^8}" for v in reg_dict['predicate_in']]) + reg_sub_header['predicate_in'] = predicate_in_sub_header_str if 'routing_xbar_outport' in reg_dict: reg_dict['routing_xbar_outport'] = [ int(rxop) for rxop in reg_dict['routing_xbar_outport']] if 'fu_xbar_outport' in reg_dict: reg_dict['fu_xbar_outport'] = [ int(fxop) for fxop in reg_dict['fu_xbar_outport']] if 'routing_predicate_in' in reg_dict: reg_dict['routing_predicate_in'] = [ int(rpi) for rpi in reg_dict['routing_predicate_in']] + + reg_dicts.insert(0, reg_sub_header) reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) From 323bf8506aaad593fbdd39e3381a30e7ec9f3c5b Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 23 Dec 2024 15:38:57 +0800 Subject: [PATCH 27/45] format CtrlMemRTL with sub header --- mem/ctrl/CtrlMemRTL.py | 86 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 71 insertions(+), 15 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index fcbf3cc..f737bc9 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -79,6 +79,8 @@ def line_trace( s ): # num_inports = len(s.reg_file.regs[0].predicate_in) num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) num_direction_ports = num_outports - num_fu_in + + # reg reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] reg_sub_header = {} for reg_dict in reg_dicts: @@ -132,76 +134,130 @@ def line_trace( s ): reg_dict['fu_xbar_outport'] = [ int(fxop) for fxop in reg_dict['fu_xbar_outport']] if 'routing_predicate_in' in reg_dict: reg_dict['routing_predicate_in'] = [ int(rpi) for rpi in reg_dict['routing_predicate_in']] - reg_dicts.insert(0, reg_sub_header) reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() - # recv_opt_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_opt_msg_dict.items()]) + # recv_ctrl recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) + recv_ctrl_sub_header = {} + for key in recv_ctrl_msg_dict.keys(): + recv_ctrl_sub_header[key] = '' + recv_ctrl_msg_list = [] recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in recv_ctrl_msg_dict['fu_in']] + fu_in_header = [] + for idx, val in enumerate(recv_ctrl_msg_dict['fu_in']): + fu_in_header.append(idx) + fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) + recv_ctrl_msg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in recv_ctrl_msg_dict['fu_in']]) + recv_ctrl_sub_header['fu_in'] = fu_in_header_str + if 'outport' in recv_ctrl_msg_dict: recv_ctrl_msg_dict['outport'] = [ int(op) for op in recv_ctrl_msg_dict['outport']] fu_reg_num = 1 + outport_sub_header = [] for idx, val in enumerate(recv_ctrl_msg_dict['outport']): # to directions if idx <= num_direction_ports - 1: - recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + outport_sub_header.append(tile_port_direction_dict_short_desc[idx]) + recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" # to fu regs else: - recv_ctrl_msg_dict['outport'][idx] = f"fu_reg_{fu_reg_num}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + outport_sub_header.append(f"fu_reg_{fu_reg_num}") + recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" fu_reg_num += 1 + outport_sub_header_str = "|".join([f"{hd : ^8}" for hd in outport_sub_header]) + recv_ctrl_msg_dict['outport'] = "|".join([f"{v : ^8}" for v in recv_ctrl_msg_dict['outport']]) + recv_ctrl_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in recv_ctrl_msg_dict: recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in recv_ctrl_msg_dict['predicate_in']] fu_out_num = 1 + predicate_in_sub_header = [] for idx, val in enumerate(recv_ctrl_msg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - recv_ctrl_msg_dict['predicate_in'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({val})" + predicate_in_sub_header.append(tile_port_direction_dict_short_desc[idx]) + recv_ctrl_msg_dict['predicate_in'][idx] = f"{val}" # from fu else: - recv_ctrl_msg_dict['predicate_in'][idx] = f"fu_out_{fu_out_num}({val})" + predicate_in_sub_header.append(f"fu_out_{fu_out_num}") + recv_ctrl_msg_dict['predicate_in'][idx] = f"{val}" fu_out_num += 1 - recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) + predicate_in_sub_header_str = "|".join([f"{hd : ^8}" for hd in predicate_in_sub_header]) + recv_ctrl_msg_dict['predicate_in'] = "|".join([f"{v : ^8}" for v in recv_ctrl_msg_dict['predicate_in']]) + recv_ctrl_sub_header['predicate_in'] = predicate_in_sub_header_str + recv_ctrl_msg_list.append(recv_ctrl_sub_header) + recv_ctrl_msg_list.append(recv_ctrl_msg_dict) + send_ctrl_md = markdown_table(recv_ctrl_msg_list).set_params(quote=False).get_markdown() + # recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) + + # send_ctrl send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) + send_ctrl_sub_header = {} + for key in send_ctrl_msg_dict.keys(): + send_ctrl_sub_header[key] = '' + send_ctrl_msg_list = [] send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] if 'predicate' in send_ctrl_msg_dict: send_ctrl_msg_dict['predicate'] = int(send_ctrl_msg_dict['predicate']) send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] + fu_in_header = [] + for idx, val in enumerate(send_ctrl_msg_dict['fu_in']): + fu_in_header.append(idx) + fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) + send_ctrl_msg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in send_ctrl_msg_dict['fu_in']]) + send_ctrl_sub_header['fu_in'] = fu_in_header_str + if 'outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] fu_reg_num = 1 + outport_sub_header = [] for idx, val in enumerate(send_ctrl_msg_dict['outport']): # to directions if idx <= num_direction_ports - 1: - send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + outport_sub_header.append(tile_port_direction_dict_short_desc[idx]) + send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" # to fu regs else: - send_ctrl_msg_dict['outport'][idx] = f"fu_reg_{fu_reg_num}({tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'})" + outport_sub_header.append(f"fu_reg_{fu_reg_num}") + send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" fu_reg_num += 1 + outport_sub_header_str = "|".join([f"{hd : ^8}" for hd in outport_sub_header]) + send_ctrl_msg_dict['outport'] = "|".join([f"{v : ^8}" for v in send_ctrl_msg_dict['outport']]) + send_ctrl_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] fu_out_num = 1 + predicate_in_sub_header = [] for idx, val in enumerate(send_ctrl_msg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - send_ctrl_msg_dict['predicate_in'][idx] = f"{tile_port_direction_dict_short_desc[idx]}({val})" + predicate_in_sub_header.append(tile_port_direction_dict_short_desc[idx]) + send_ctrl_msg_dict['predicate_in'][idx] = f"{val}" # from fu else: - send_ctrl_msg_dict['predicate_in'][idx] = f"fu_out_{fu_out_num}({val})" + predicate_in_sub_header.append(f"fu_out_{fu_out_num}") + send_ctrl_msg_dict['predicate_in'][idx] = f"{val}" fu_out_num += 1 + predicate_in_sub_header_str = "|".join([f"{hd : ^8}" for hd in predicate_in_sub_header]) + send_ctrl_msg_dict['predicate_in'] = "|".join([f"{v : ^8}" for v in send_ctrl_msg_dict['predicate_in']]) + send_ctrl_sub_header['predicate_in'] = predicate_in_sub_header_str if 'routing_xbar_outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['routing_xbar_outport'] = [int(rxop) for rxop in send_ctrl_msg_dict['routing_xbar_outport']] if 'fu_xbar_outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['fu_xbar_outport'] = [int(fxop) for fxop in send_ctrl_msg_dict['fu_xbar_outport']] if 'routing_predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['routing_predicate_in'] = [int(rpi) for rpi in send_ctrl_msg_dict['routing_predicate_in']] - send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) + + send_ctrl_msg_list.append(send_ctrl_sub_header) + send_ctrl_msg_list.append(send_ctrl_msg_dict) + send_ctrl_md = markdown_table(send_ctrl_msg_list).set_params(quote=False).get_markdown() + # send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) return (f'\n## class: {s.__class__.__name__}\n' f'- recv_ctrl_msg:\n' - f'{recv_ctrl_msg}\n\n' - f'- send_ctrl_msg:\n' - f'{send_ctrl_msg}\n\n' + f'{send_ctrl_md}\n\n' + f'- send_ctrl_msg:' + f'{send_ctrl_md}\n\n' f'- regs: {reg_md}\n') From bab8beed5f6dead5cb40bc6403e218feb9b0f3c2 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Mon, 23 Dec 2024 16:25:49 +0800 Subject: [PATCH 28/45] format CtrlMemRTL with sub header --- mem/ctrl/CtrlMemRTL.py | 86 ++++++++++++++++++++++++------------------ 1 file changed, 49 insertions(+), 37 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index f737bc9..7b42c38 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -101,15 +101,17 @@ def line_trace( s ): for idx, val in enumerate(reg_dict['outport']): # to directions if idx <= num_direction_ports-1: - outport_sub_header.append(tile_port_direction_dict_short_desc[idx]) - reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'}" + hd = tile_port_direction_dict_short_desc[idx] + outport_sub_header.append(f"{hd : ^{len(hd)+2}}") + reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-' : ^{len(hd)+2}}" # to fu regs else: - outport_sub_header.append(f"fu_reg_{fu_reg_num}") - reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-'}" + hd = f"fu_reg_{fu_reg_num}" + outport_sub_header.append(f"{hd : ^{len(hd)}}") + reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 - outport_sub_header_str = "|".join([f"{hd : ^8}" for hd in outport_sub_header]) - reg_dict['outport'] = "|".join([f"{v : ^8}" for v in reg_dict['outport']]) + outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) + reg_dict['outport'] = "|".join([v for v in reg_dict['outport']]) reg_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in reg_dict: reg_dict['predicate_in'] = [ int(pi) for pi in reg_dict['predicate_in']] @@ -118,15 +120,17 @@ def line_trace( s ): for idx, val in enumerate(reg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - predicate_in_sub_header.append(tile_port_direction_dict_short_desc[idx]) - reg_dict['predicate_in'][idx] = f"{val}" + hd = tile_port_direction_dict_short_desc[idx] + predicate_in_sub_header.append(f"{hd : ^{len(hd)+2}}") + reg_dict['predicate_in'][idx] = f"{val : ^{len(hd)+2}}" # from fu else: - predicate_in_sub_header.append(f"fu_out_{fu_out_num}") - reg_dict['predicate_in'][idx] = f"{val}" + hd = f"fu_out_{fu_out_num}" + predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") + reg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" fu_out_num += 1 - predicate_in_sub_header_str = "|".join([f"{hd : ^8}" for hd in predicate_in_sub_header]) - reg_dict['predicate_in'] = "|".join([f"{v : ^8}" for v in reg_dict['predicate_in']]) + predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) + reg_dict['predicate_in'] = "|".join([v for v in reg_dict['predicate_in']]) reg_sub_header['predicate_in'] = predicate_in_sub_header_str if 'routing_xbar_outport' in reg_dict: reg_dict['routing_xbar_outport'] = [ int(rxop) for rxop in reg_dict['routing_xbar_outport']] @@ -159,15 +163,17 @@ def line_trace( s ): for idx, val in enumerate(recv_ctrl_msg_dict['outport']): # to directions if idx <= num_direction_ports - 1: - outport_sub_header.append(tile_port_direction_dict_short_desc[idx]) - recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" + hd = tile_port_direction_dict_short_desc[idx] + outport_sub_header.append(f"{hd : ^{len(hd)+2}}") + recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)+2}}" # to fu regs else: - outport_sub_header.append(f"fu_reg_{fu_reg_num}") - recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" + hd = f"fu_reg_{fu_reg_num}" + outport_sub_header.append(f"{hd : ^{len(hd)}}") + recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 - outport_sub_header_str = "|".join([f"{hd : ^8}" for hd in outport_sub_header]) - recv_ctrl_msg_dict['outport'] = "|".join([f"{v : ^8}" for v in recv_ctrl_msg_dict['outport']]) + outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) + recv_ctrl_msg_dict['outport'] = "|".join([v for v in recv_ctrl_msg_dict['outport']]) recv_ctrl_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in recv_ctrl_msg_dict: recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in recv_ctrl_msg_dict['predicate_in']] @@ -176,15 +182,17 @@ def line_trace( s ): for idx, val in enumerate(recv_ctrl_msg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - predicate_in_sub_header.append(tile_port_direction_dict_short_desc[idx]) - recv_ctrl_msg_dict['predicate_in'][idx] = f"{val}" + hd = tile_port_direction_dict_short_desc[idx] + predicate_in_sub_header.append(f"{hd : ^{len(hd)+2}}") + recv_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)+2}}" # from fu else: - predicate_in_sub_header.append(f"fu_out_{fu_out_num}") - recv_ctrl_msg_dict['predicate_in'][idx] = f"{val}" + hd = f"fu_out_{fu_out_num}" + predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") + recv_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" fu_out_num += 1 - predicate_in_sub_header_str = "|".join([f"{hd : ^8}" for hd in predicate_in_sub_header]) - recv_ctrl_msg_dict['predicate_in'] = "|".join([f"{v : ^8}" for v in recv_ctrl_msg_dict['predicate_in']]) + predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) + recv_ctrl_msg_dict['predicate_in'] = "|".join([v for v in recv_ctrl_msg_dict['predicate_in']]) recv_ctrl_sub_header['predicate_in'] = predicate_in_sub_header_str recv_ctrl_msg_list.append(recv_ctrl_sub_header) recv_ctrl_msg_list.append(recv_ctrl_msg_dict) @@ -216,15 +224,17 @@ def line_trace( s ): for idx, val in enumerate(send_ctrl_msg_dict['outport']): # to directions if idx <= num_direction_ports - 1: - outport_sub_header.append(tile_port_direction_dict_short_desc[idx]) - send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" + hd = tile_port_direction_dict_short_desc[idx] + outport_sub_header.append(f"{hd : ^{len(hd)+2}}") + send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)+2}}" # to fu regs else: - outport_sub_header.append(f"fu_reg_{fu_reg_num}") - send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-'}" + hd = f"fu_reg_{fu_reg_num}" + outport_sub_header.append(f"{hd : ^{len(hd)}}") + send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 - outport_sub_header_str = "|".join([f"{hd : ^8}" for hd in outport_sub_header]) - send_ctrl_msg_dict['outport'] = "|".join([f"{v : ^8}" for v in send_ctrl_msg_dict['outport']]) + outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) + send_ctrl_msg_dict['outport'] = "|".join([v for v in send_ctrl_msg_dict['outport']]) send_ctrl_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in send_ctrl_msg_dict: send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] @@ -233,15 +243,17 @@ def line_trace( s ): for idx, val in enumerate(send_ctrl_msg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - predicate_in_sub_header.append(tile_port_direction_dict_short_desc[idx]) - send_ctrl_msg_dict['predicate_in'][idx] = f"{val}" + hd = tile_port_direction_dict_short_desc[idx] + predicate_in_sub_header.append(f"{hd : ^{len(hd)+2}}") + send_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)+2}}" # from fu else: - predicate_in_sub_header.append(f"fu_out_{fu_out_num}") - send_ctrl_msg_dict['predicate_in'][idx] = f"{val}" + hd = f"fu_out_{fu_out_num}" + predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") + send_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" fu_out_num += 1 - predicate_in_sub_header_str = "|".join([f"{hd : ^8}" for hd in predicate_in_sub_header]) - send_ctrl_msg_dict['predicate_in'] = "|".join([f"{v : ^8}" for v in send_ctrl_msg_dict['predicate_in']]) + predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) + send_ctrl_msg_dict['predicate_in'] = "|".join([v for v in send_ctrl_msg_dict['predicate_in']]) send_ctrl_sub_header['predicate_in'] = predicate_in_sub_header_str if 'routing_xbar_outport' in send_ctrl_msg_dict: send_ctrl_msg_dict['routing_xbar_outport'] = [int(rxop) for rxop in send_ctrl_msg_dict['routing_xbar_outport']] @@ -259,5 +271,5 @@ def line_trace( s ): f'{send_ctrl_md}\n\n' f'- send_ctrl_msg:' f'{send_ctrl_md}\n\n' - f'- regs: {reg_md}\n') + f'- ctrl_memory: {reg_md}\n') From 0e0e8e99127cd33e3b4b77413ce80db07f66e53a Mon Sep 17 00:00:00 2001 From: yuqisun Date: Tue, 24 Dec 2024 17:58:04 +0800 Subject: [PATCH 29/45] Add verbosity level. --- cgra/CGRAKingMeshRTL.py | 20 +- cgra/translate/VectorCGRAKingMeshRTL_test.py | 3 +- fu/flexible/FlexibleFuRTL.py | 14 +- mem/ctrl/CtrlMemRTL.py | 78 ++++--- mem/data/DataMemRTL.py | 22 +- tile/TileRTL.py | 78 ++++--- tile/TileSeparateCrossbarRTL.py | 208 ++++++++++--------- 7 files changed, 252 insertions(+), 171 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index f5ff12e..b1ffae3 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -149,11 +149,23 @@ def construct( s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_waddr.rdy //= 0 s.tile[i].to_mem_wdata.rdy //= 0 - # Line trace - def line_trace( s ): + # verbose trace if verbosity > 0 + def verbose_trace(s, verbosity=1): res = '' for (i, x) in enumerate(s.tile): - res += "# [tile"+str(i)+"]: " + x.line_trace() + x.ctrl_mem.line_trace() + '\n' - res += f"\ndata_mem: {s.data_mem.line_trace()}" + res += "# [tile" + str(i) + "]: " + x.line_trace(verbosity=verbosity) + x.ctrl_mem.line_trace(verbosity=verbosity) + '\n' + res += f"\ndata_mem: {s.data_mem.line_trace(verbosity=verbosity)}" res += "------\n\n" return res + + # Line trace + def line_trace(s, verbosity=0): + if verbosity==0: + # str = "||".join([ x.element.line_trace() for x in s.tile ]) + # str += " :: [" + s.data_mem.line_trace() + "]" + res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + for (i, x) in enumerate(s.tile)]) + res += "\n :: [" + s.data_mem.line_trace() + "] \n" + return res + else: + return s.verbose_trace(verbosity=verbosity) diff --git a/cgra/translate/VectorCGRAKingMeshRTL_test.py b/cgra/translate/VectorCGRAKingMeshRTL_test.py index f6826de..291db2a 100644 --- a/cgra/translate/VectorCGRAKingMeshRTL_test.py +++ b/cgra/translate/VectorCGRAKingMeshRTL_test.py @@ -67,7 +67,8 @@ def done( s ): return done def line_trace( s ): - return s.dut.line_trace() + verbosity = 1 + return s.dut.line_trace(verbosity=verbosity) def test_homo_4x4( cmdline_opts ): num_tile_inports = 8 diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 490171d..d044b8a 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -113,8 +113,8 @@ def comb_logic(): s.fu_recv_in_rdy_vector[port][i] @= s.fu[i].recv_in[port].rdy s.recv_in[port].rdy @= reduce_or( s.fu_recv_in_rdy_vector[port] ) - - def line_trace( s ): + # verbose trace if verbosity > 0 + def verbose_trace(s, verbosity=1): # for clk n # recv: # 1. OPT: opt+rdy(if ready to receive opt) @@ -151,3 +151,13 @@ def line_trace( s ): f'- FU out:' f'{out_md}\n') + def line_trace( s, verbosity=0 ): + if verbosity == 0: + opt_str = " #" + if s.recv_opt.en: + opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] + out_str = ",".join([str(x.msg) for x in s.send_out]) + recv_str = ",".join([str(x.msg) for x in s.recv_in]) + return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + else: + return s.verbose_trace(verbosity=verbosity) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 7b42c38..9be4d47 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -73,21 +73,21 @@ def update_raddr(): else: s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) - - def line_trace( s ): + # verbose trace if verbosity > 0 + def verbose_trace(s, verbosity=1): num_fu_in = len(s.reg_file.regs[0].fu_in) # num_inports = len(s.reg_file.regs[0].predicate_in) num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) num_direction_ports = num_outports - num_fu_in # reg - reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] + reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] reg_sub_header = {} for reg_dict in reg_dicts: for key in reg_dict.keys(): reg_sub_header[key] = '' reg_dict['ctrl'] = OPT_SYMBOL_DICT[reg_dict['ctrl']] - reg_dict['fu_in'] = [ int(fi) for fi in reg_dict['fu_in']] + reg_dict['fu_in'] = [int(fi) for fi in reg_dict['fu_in']] fu_in_header = [] for idx, val in enumerate(reg_dict['fu_in']): fu_in_header.append(idx) @@ -95,34 +95,36 @@ def line_trace( s ): reg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in reg_dict['fu_in']]) reg_sub_header['fu_in'] = fu_in_header_str if 'outport' in reg_dict: - reg_dict['outport'] = [ int(op) for op in reg_dict['outport']] + reg_dict['outport'] = [int(op) for op in reg_dict['outport']] fu_reg_num = 1 outport_sub_header = [] for idx, val in enumerate(reg_dict['outport']): # to directions - if idx <= num_direction_ports-1: + if idx <= num_direction_ports - 1: hd = tile_port_direction_dict_short_desc[idx] - outport_sub_header.append(f"{hd : ^{len(hd)+2}}") - reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-' : ^{len(hd)+2}}" + outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") + reg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" # to fu regs else: hd = f"fu_reg_{fu_reg_num}" outport_sub_header.append(f"{hd : ^{len(hd)}}") - reg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val-1] if val != 0 else '-' : ^{len(hd)}}" + reg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) reg_dict['outport'] = "|".join([v for v in reg_dict['outport']]) - reg_sub_header['outport'] = outport_sub_header_str + reg_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in reg_dict: - reg_dict['predicate_in'] = [ int(pi) for pi in reg_dict['predicate_in']] + reg_dict['predicate_in'] = [int(pi) for pi in reg_dict['predicate_in']] fu_out_num = 1 predicate_in_sub_header = [] for idx, val in enumerate(reg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: hd = tile_port_direction_dict_short_desc[idx] - predicate_in_sub_header.append(f"{hd : ^{len(hd)+2}}") - reg_dict['predicate_in'][idx] = f"{val : ^{len(hd)+2}}" + predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") + reg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" # from fu else: hd = f"fu_out_{fu_out_num}" @@ -133,13 +135,13 @@ def line_trace( s ): reg_dict['predicate_in'] = "|".join([v for v in reg_dict['predicate_in']]) reg_sub_header['predicate_in'] = predicate_in_sub_header_str if 'routing_xbar_outport' in reg_dict: - reg_dict['routing_xbar_outport'] = [ int(rxop) for rxop in reg_dict['routing_xbar_outport']] + reg_dict['routing_xbar_outport'] = [int(rxop) for rxop in reg_dict['routing_xbar_outport']] if 'fu_xbar_outport' in reg_dict: - reg_dict['fu_xbar_outport'] = [ int(fxop) for fxop in reg_dict['fu_xbar_outport']] + reg_dict['fu_xbar_outport'] = [int(fxop) for fxop in reg_dict['fu_xbar_outport']] if 'routing_predicate_in' in reg_dict: - reg_dict['routing_predicate_in'] = [ int(rpi) for rpi in reg_dict['routing_predicate_in']] + reg_dict['routing_predicate_in'] = [int(rpi) for rpi in reg_dict['routing_predicate_in']] reg_dicts.insert(0, reg_sub_header) - reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() + reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() # recv_ctrl recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) @@ -148,7 +150,7 @@ def line_trace( s ): recv_ctrl_sub_header[key] = '' recv_ctrl_msg_list = [] recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] - recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in recv_ctrl_msg_dict['fu_in']] + recv_ctrl_msg_dict['fu_in'] = [int(fi) for fi in recv_ctrl_msg_dict['fu_in']] fu_in_header = [] for idx, val in enumerate(recv_ctrl_msg_dict['fu_in']): fu_in_header.append(idx) @@ -157,34 +159,36 @@ def line_trace( s ): recv_ctrl_sub_header['fu_in'] = fu_in_header_str if 'outport' in recv_ctrl_msg_dict: - recv_ctrl_msg_dict['outport'] = [ int(op) for op in recv_ctrl_msg_dict['outport']] + recv_ctrl_msg_dict['outport'] = [int(op) for op in recv_ctrl_msg_dict['outport']] fu_reg_num = 1 outport_sub_header = [] for idx, val in enumerate(recv_ctrl_msg_dict['outport']): # to directions if idx <= num_direction_ports - 1: hd = tile_port_direction_dict_short_desc[idx] - outport_sub_header.append(f"{hd : ^{len(hd)+2}}") - recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)+2}}" + outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") + recv_ctrl_msg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" # to fu regs else: hd = f"fu_reg_{fu_reg_num}" outport_sub_header.append(f"{hd : ^{len(hd)}}") - recv_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" + recv_ctrl_msg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) recv_ctrl_msg_dict['outport'] = "|".join([v for v in recv_ctrl_msg_dict['outport']]) recv_ctrl_sub_header['outport'] = outport_sub_header_str if 'predicate_in' in recv_ctrl_msg_dict: - recv_ctrl_msg_dict['predicate_in'] = [ int(pi) for pi in recv_ctrl_msg_dict['predicate_in']] + recv_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in recv_ctrl_msg_dict['predicate_in']] fu_out_num = 1 predicate_in_sub_header = [] for idx, val in enumerate(recv_ctrl_msg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: hd = tile_port_direction_dict_short_desc[idx] - predicate_in_sub_header.append(f"{hd : ^{len(hd)+2}}") - recv_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)+2}}" + predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") + recv_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" # from fu else: hd = f"fu_out_{fu_out_num}" @@ -199,7 +203,6 @@ def line_trace( s ): send_ctrl_md = markdown_table(recv_ctrl_msg_list).set_params(quote=False).get_markdown() # recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) - # send_ctrl send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) send_ctrl_sub_header = {} @@ -209,7 +212,7 @@ def line_trace( s ): send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] if 'predicate' in send_ctrl_msg_dict: send_ctrl_msg_dict['predicate'] = int(send_ctrl_msg_dict['predicate']) - send_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in send_ctrl_msg_dict['fu_in']] + send_ctrl_msg_dict['fu_in'] = [int(fi) for fi in send_ctrl_msg_dict['fu_in']] fu_in_header = [] for idx, val in enumerate(send_ctrl_msg_dict['fu_in']): fu_in_header.append(idx) @@ -225,13 +228,15 @@ def line_trace( s ): # to directions if idx <= num_direction_ports - 1: hd = tile_port_direction_dict_short_desc[idx] - outport_sub_header.append(f"{hd : ^{len(hd)+2}}") - send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)+2}}" + outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") + send_ctrl_msg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" # to fu regs else: hd = f"fu_reg_{fu_reg_num}" outport_sub_header.append(f"{hd : ^{len(hd)}}") - send_ctrl_msg_dict['outport'][idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" + send_ctrl_msg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) send_ctrl_msg_dict['outport'] = "|".join([v for v in send_ctrl_msg_dict['outport']]) @@ -244,8 +249,8 @@ def line_trace( s ): # from directions if idx <= num_direction_ports - 1: hd = tile_port_direction_dict_short_desc[idx] - predicate_in_sub_header.append(f"{hd : ^{len(hd)+2}}") - send_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)+2}}" + predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") + send_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" # from fu else: hd = f"fu_out_{fu_out_num}" @@ -273,3 +278,12 @@ def line_trace( s ): f'{send_ctrl_md}\n\n' f'- ctrl_memory: {reg_md}\n') + + def line_trace( s, verbosity=0 ): + if verbosity == 0: + out_str = "||".join([str(data) for data in s.reg_file.regs]) + return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' + else: + return s.verbose_trace(verbosity=verbosity) + + diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index 2a23c0c..6a08f58 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -97,7 +97,9 @@ def update_signal(): s.recv_waddr[i].rdy @= Bits1( 1 ) s.recv_wdata[i].rdy @= Bits1( 1 ) - def line_trace(s): + + # verbose trace if verbosity > 0 + def verbose_trace(s, verbosity=1): # data memory: mem size, reg # recv_raddr(rdy, msg), send_rdata(en, msg), recv_waddr(rdy, msg), recv_wdata, tile # reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] @@ -136,3 +138,21 @@ def line_trace(s): f'- regs(mem size: {len(reg_dicts)}): {reg_md}\n' f'- mem_r/w:' f'{mem_md}') + + + def line_trace(s, verbosity=0): + if verbosity == 0: + recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) + recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) + recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) + content_str = "content: " + "|".join([str(data) for data in s.reg_file.regs]) + send_rdata_str = "send_read_data: " + "|".join([str(data.msg) for data in s.send_rdata]) + return f'{recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' + # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' + # return s.reg_file.line_trace() + # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' + # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' + # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' + else: + return s.verbose_trace(verbosity=verbosity) + diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 378609c..03f9bf7 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -124,40 +124,50 @@ def update_opt(): s.crossbar.recv_opt.en @= s.ctrl_mem.send_ctrl.en s.ctrl_mem.send_ctrl.rdy @= s.element.recv_opt.rdy & s.crossbar.recv_opt.rdy + # verbose trace if verbosity > 0 + def verbose_trace(s, verbosity=1): + # recv: + # 1. rdy (if ready to receive data), if en and rdy: then data has been transferred (val, rdy are new type(protocol)) + # 2. data + # [3. opt will show in FU trace] + # FU: + # FlexibleFuRTL.py + # tile out: + # 1. en (is data transferred) + recv_data = [x for x in s.recv_data] + recv_list = [] + for idx, data in enumerate(recv_data): + msg_dict = data.msg.__dict__ + tile_inport_dict = {"tile_inport_direction": tile_port_direction_dict[idx], "rdy": data.rdy} + tile_inport_dict.update(msg_dict) + recv_list.append(tile_inport_dict) + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + + out_data = [x for x in s.send_data] + out_list = [] + for idx, data in enumerate(out_data): + msg_dict = data.msg.__dict__ + tile_outport_dict = {"tile_outport_direction": tile_port_direction_dict[idx], "en": data.en} + tile_outport_dict.update(msg_dict) + out_list.append(tile_outport_dict) + out_md = markdown_table(out_list).set_params(quote=False).get_markdown() + return (f"\n## class[{s.__class__.__name__}]:\n" + f"- Tile recv:" + f"{recv_md}\n" + f"- FU element:\n" + f"{s.element.line_trace(verbosity=verbosity)}\n" + f"===>\n" + f"- Tile out:" + f"{out_md}\n") # Line trace - def line_trace( s ): - # recv: - # 1. rdy (if ready to receive data), if en and rdy: then data has been transferred (val, rdy are new type(protocol)) - # 2. data - # [3. opt will show in FU trace] - # FU: - # FlexibleFuRTL.py - # tile out: - # 1. en (is data transferred) - recv_data = [x for x in s.recv_data] - recv_list = [] - for idx, data in enumerate(recv_data): - msg_dict = data.msg.__dict__ - tile_inport_dict = {"tile_inport_direction": tile_port_direction_dict[idx], "rdy": data.rdy} - tile_inport_dict.update(msg_dict) - recv_list.append(tile_inport_dict) - recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - - out_data = [x for x in s.send_data] - out_list = [] - for idx, data in enumerate(out_data): - msg_dict = data.msg.__dict__ - tile_outport_dict = {"tile_outport_direction": tile_port_direction_dict[idx], "en": data.en} - tile_outport_dict.update(msg_dict) - out_list.append(tile_outport_dict) - out_md = markdown_table(out_list).set_params(quote=False).get_markdown() - return (f"\n## class[{s.__class__.__name__}]:\n" - f"- Tile recv:" - f"{recv_md}\n" - f"- FU element:\n" - f"{s.element.line_trace()}\n" - f"===>\n" - f"- Tile out:" - f"{out_md}\n") + def line_trace( s, verbosity=0 ): + if verbosity == 0: + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + channel_recv_str = "|".join([str(x.recv.msg) for x in s.channel]) + channel_send_str = "|".join([str(x.send.msg) for x in s.channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + else: + return s.verbose_trace(verbosity=verbosity) diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 4129d50..fda984c 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -191,101 +191,115 @@ def update_opt(): s.routing_crossbar.recv_opt.rdy & \ s.fu_crossbar.recv_opt.rdy - + # verbose trace if verbosity > 0 + def verbose_trace(s, verbosity=1): + recv_data = [x.msg.__dict__ for x in s.recv_data] + recv_list = [] + for idx, data in enumerate(recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"inport_direction": port_direction} + dict_with_direction.update(data) + recv_list.append(dict_with_direction) + recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + + routing_crossbar_dict = dict(s.routing_crossbar.recv_opt.msg.__dict__) + routing_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[routing_crossbar_dict['ctrl']] + routing_crossbar_dict['predicate'] = int(routing_crossbar_dict['predicate']) + routing_crossbar_dict['fu_in'] = [int(fi) for fi in routing_crossbar_dict['fu_in']] + routing_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in routing_crossbar_dict['fu_xbar_outport']] + routing_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in + routing_crossbar_dict['routing_predicate_in']] + routing_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in + routing_crossbar_dict['routing_xbar_outport']] + routing_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in routing_crossbar_dict.items()]) + + fu_crossbar_dict = dict(s.fu_crossbar.recv_opt.msg.__dict__) + fu_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[fu_crossbar_dict['ctrl']] + fu_crossbar_dict['predicate'] = int(fu_crossbar_dict['predicate']) + fu_crossbar_dict['fu_in'] = [int(fi) for fi in fu_crossbar_dict['fu_in']] + fu_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in fu_crossbar_dict['fu_xbar_outport']] + fu_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in fu_crossbar_dict['routing_predicate_in']] + fu_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in fu_crossbar_dict['routing_xbar_outport']] + fu_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in fu_crossbar_dict.items()]) + + tile_out_channel_recv_data = [x.recv.msg.__dict__ for x in s.tile_out_channel] + tile_out_channel_recv_data_list = [] + for idx, data in enumerate(tile_out_channel_recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"inport_direction": port_direction} + dict_with_direction.update(data) + tile_out_channel_recv_data_list.append(dict_with_direction) + tile_out_channel_recv_md = markdown_table(tile_out_channel_recv_data_list).set_params(quote=False).get_markdown() + + tile_out_channel_send_data = [x.send.msg.__dict__ for x in s.tile_out_channel] + tile_out_channel_send_data_list = [] + for idx, data in enumerate(tile_out_channel_send_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"outport_direction": port_direction} + dict_with_direction.update(data) + tile_out_channel_send_data_list.append(dict_with_direction) + tile_out_channel_send_md = markdown_table(tile_out_channel_send_data_list).set_params(quote=False).get_markdown() + + fu_in_channel_recv_data = [x.recv.msg.__dict__ for x in s.fu_in_channel] + fu_in_channel_recv_data_list = [] + for idx, data in enumerate(fu_in_channel_recv_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"inport_direction": port_direction} + dict_with_direction.update(data) + fu_in_channel_recv_data_list.append(dict_with_direction) + fu_in_channel_recv_md = markdown_table(fu_in_channel_recv_data_list).set_params(quote=False).get_markdown() + + fu_in_channel_send_data = [x.send.msg.__dict__ for x in s.fu_in_channel] + fu_in_channel_send_data_list = [] + for idx, data in enumerate(fu_in_channel_send_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"outport_direction": port_direction} + dict_with_direction.update(data) + fu_in_channel_send_data_list.append(dict_with_direction) + fu_in_channel_send_md = markdown_table(fu_in_channel_send_data_list).set_params(quote=False).get_markdown() + + tile_outports_data = [x.msg.__dict__ for x in s.send_data] + tile_outports_data_list = [] + for idx, data in enumerate(tile_outports_data): + port_direction = tile_port_direction_dict[idx] + dict_with_direction = {"outport_direction": port_direction} + dict_with_direction.update(data) + tile_outports_data_list.append(dict_with_direction) + tile_outports_md = markdown_table(tile_outports_data_list).set_params(quote=False).get_markdown() + + return (f'\n## class: {s.__class__.__name__}\n' + f'- tile_inports:\n' + f'{recv_md}\n' + f'===>\n' + f'- routing_crossbar:\n' + f'{routing_crossbar_str}\n' + f'- fu_crossbar:\n' + f'{fu_crossbar_str}\n' + f'- element:\n' + f'{s.element.line_trace()}\n' + f'- tile_out_channels_recv:\n' + f'{tile_out_channel_recv_md}\n' + f'===>\n' + f'- tile_out_channel_send:\n' + f'{tile_out_channel_send_md}\n' + f'- fu_in_channels_recv:\n' + f'{fu_in_channel_recv_md}\n' + f'===>\n' + f'- fu_in_channels_send:\n' + f'{fu_in_channel_send_md}\n' + f'===>\n' + f'- tile_outports:\n' + f'{tile_outports_md}\n') # Line trace - def line_trace( s ): - recv_data = [x.msg.__dict__ for x in s.recv_data] - recv_list = [] - for idx, data in enumerate(recv_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"inport_direction": port_direction} - dict_with_direction.update(data) - recv_list.append(dict_with_direction) - recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - - routing_crossbar_dict = dict(s.routing_crossbar.recv_opt.msg.__dict__) - routing_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[routing_crossbar_dict['ctrl']] - routing_crossbar_dict['predicate'] = int(routing_crossbar_dict['predicate']) - routing_crossbar_dict['fu_in'] = [int(fi) for fi in routing_crossbar_dict['fu_in']] - routing_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in routing_crossbar_dict['fu_xbar_outport']] - routing_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in routing_crossbar_dict['routing_predicate_in']] - routing_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in routing_crossbar_dict['routing_xbar_outport']] - routing_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in routing_crossbar_dict.items()]) - - fu_crossbar_dict = dict(s.fu_crossbar.recv_opt.msg.__dict__) - fu_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[fu_crossbar_dict['ctrl']] - fu_crossbar_dict['predicate'] = int(fu_crossbar_dict['predicate']) - fu_crossbar_dict['fu_in'] = [int(fi) for fi in fu_crossbar_dict['fu_in']] - fu_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in fu_crossbar_dict['fu_xbar_outport']] - fu_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in fu_crossbar_dict['routing_predicate_in']] - fu_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in fu_crossbar_dict['routing_xbar_outport']] - fu_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in fu_crossbar_dict.items()]) - - tile_out_channel_recv_data = [x.recv.msg.__dict__ for x in s.tile_out_channel] - tile_out_channel_recv_data_list = [] - for idx, data in enumerate(tile_out_channel_recv_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"inport_direction": port_direction} - dict_with_direction.update(data) - tile_out_channel_recv_data_list.append(dict_with_direction) - tile_out_channel_recv_md = markdown_table(tile_out_channel_recv_data_list).set_params(quote=False).get_markdown() - - tile_out_channel_send_data = [x.send.msg.__dict__ for x in s.tile_out_channel] - tile_out_channel_send_data_list = [] - for idx, data in enumerate(tile_out_channel_send_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"outport_direction": port_direction} - dict_with_direction.update(data) - tile_out_channel_send_data_list.append(dict_with_direction) - tile_out_channel_send_md = markdown_table(tile_out_channel_send_data_list).set_params(quote=False).get_markdown() - - fu_in_channel_recv_data = [x.recv.msg.__dict__ for x in s.fu_in_channel] - fu_in_channel_recv_data_list = [] - for idx, data in enumerate(fu_in_channel_recv_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"inport_direction": port_direction} - dict_with_direction.update(data) - fu_in_channel_recv_data_list.append(dict_with_direction) - fu_in_channel_recv_md = markdown_table(fu_in_channel_recv_data_list).set_params(quote=False).get_markdown() - - fu_in_channel_send_data = [x.send.msg.__dict__ for x in s.fu_in_channel] - fu_in_channel_send_data_list = [] - for idx, data in enumerate(fu_in_channel_send_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"outport_direction": port_direction} - dict_with_direction.update(data) - fu_in_channel_send_data_list.append(dict_with_direction) - fu_in_channel_send_md = markdown_table(fu_in_channel_send_data_list).set_params(quote=False).get_markdown() - - tile_outports_data = [x.msg.__dict__ for x in s.send_data] - tile_outports_data_list = [] - for idx, data in enumerate(tile_outports_data): - port_direction = tile_port_direction_dict[idx] - dict_with_direction = {"outport_direction": port_direction} - dict_with_direction.update(data) - tile_outports_data_list.append(dict_with_direction) - tile_outports_md = markdown_table(tile_outports_data_list).set_params(quote=False).get_markdown() - - return (f'\n## class: {s.__class__.__name__}\n' - f'- tile_inports:\n' - f'{recv_md}\n' - f'===>\n' - f'- routing_crossbar:\n' - f'{routing_crossbar_str}\n' - f'- fu_crossbar:\n' - f'{fu_crossbar_str}\n' - f'- element:\n' - f'{s.element.line_trace()}\n' - f'- tile_out_channels_recv:\n' - f'{tile_out_channel_recv_md}\n' - f'===>\n' - f'- tile_out_channel_send:\n' - f'{tile_out_channel_send_md}\n' - f'- fu_in_channels_recv:\n' - f'{fu_in_channel_recv_md}\n' - f'===>\n' - f'- fu_in_channels_send:\n' - f'{fu_in_channel_send_md}\n' - f'===>\n' - f'- tile_outports:\n' - f'{tile_outports_md}\n') + def line_trace( s, verbosity=0 ): + if verbosity == 0: + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) + tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) + fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) + fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " + # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + else: + return s.verbose_trace(verbosity=verbosity) From a48dc0589b3ca0edcf9a52b53d01e7a013850eec Mon Sep 17 00:00:00 2001 From: yuqisun Date: Wed, 25 Dec 2024 17:21:33 +0800 Subject: [PATCH 30/45] print ctrl_memory when verbosity > 1 --- mem/ctrl/CtrlMemRTL.py | 145 +++++++++++++++++++++-------------------- 1 file changed, 76 insertions(+), 69 deletions(-) diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 9be4d47..a309b7e 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -80,69 +80,6 @@ def verbose_trace(s, verbosity=1): num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) num_direction_ports = num_outports - num_fu_in - # reg - reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] - reg_sub_header = {} - for reg_dict in reg_dicts: - for key in reg_dict.keys(): - reg_sub_header[key] = '' - reg_dict['ctrl'] = OPT_SYMBOL_DICT[reg_dict['ctrl']] - reg_dict['fu_in'] = [int(fi) for fi in reg_dict['fu_in']] - fu_in_header = [] - for idx, val in enumerate(reg_dict['fu_in']): - fu_in_header.append(idx) - fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) - reg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in reg_dict['fu_in']]) - reg_sub_header['fu_in'] = fu_in_header_str - if 'outport' in reg_dict: - reg_dict['outport'] = [int(op) for op in reg_dict['outport']] - fu_reg_num = 1 - outport_sub_header = [] - for idx, val in enumerate(reg_dict['outport']): - # to directions - if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] - outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") - reg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" - # to fu regs - else: - hd = f"fu_reg_{fu_reg_num}" - outport_sub_header.append(f"{hd : ^{len(hd)}}") - reg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" - fu_reg_num += 1 - outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) - reg_dict['outport'] = "|".join([v for v in reg_dict['outport']]) - reg_sub_header['outport'] = outport_sub_header_str - if 'predicate_in' in reg_dict: - reg_dict['predicate_in'] = [int(pi) for pi in reg_dict['predicate_in']] - fu_out_num = 1 - predicate_in_sub_header = [] - for idx, val in enumerate(reg_dict['predicate_in']): - # from directions - if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] - predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") - reg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" - # from fu - else: - hd = f"fu_out_{fu_out_num}" - predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") - reg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" - fu_out_num += 1 - predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) - reg_dict['predicate_in'] = "|".join([v for v in reg_dict['predicate_in']]) - reg_sub_header['predicate_in'] = predicate_in_sub_header_str - if 'routing_xbar_outport' in reg_dict: - reg_dict['routing_xbar_outport'] = [int(rxop) for rxop in reg_dict['routing_xbar_outport']] - if 'fu_xbar_outport' in reg_dict: - reg_dict['fu_xbar_outport'] = [int(fxop) for fxop in reg_dict['fu_xbar_outport']] - if 'routing_predicate_in' in reg_dict: - reg_dict['routing_predicate_in'] = [int(rpi) for rpi in reg_dict['routing_predicate_in']] - reg_dicts.insert(0, reg_sub_header) - reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() - # recv_ctrl recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) recv_ctrl_sub_header = {} @@ -271,12 +208,82 @@ def verbose_trace(s, verbosity=1): send_ctrl_msg_list.append(send_ctrl_msg_dict) send_ctrl_md = markdown_table(send_ctrl_msg_list).set_params(quote=False).get_markdown() # send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) - return (f'\n## class: {s.__class__.__name__}\n' - f'- recv_ctrl_msg:\n' - f'{send_ctrl_md}\n\n' - f'- send_ctrl_msg:' - f'{send_ctrl_md}\n\n' - f'- ctrl_memory: {reg_md}\n') + + if verbosity==1: + return (f'\n## class: {s.__class__.__name__}\n' + f'- recv_ctrl_msg:\n' + f'{send_ctrl_md}\n\n' + f'- send_ctrl_msg:' + f'{send_ctrl_md}\n\n') + else: + # reg + reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] + reg_sub_header = {} + for reg_dict in reg_dicts: + for key in reg_dict.keys(): + reg_sub_header[key] = '' + reg_dict['ctrl'] = OPT_SYMBOL_DICT[reg_dict['ctrl']] + reg_dict['fu_in'] = [int(fi) for fi in reg_dict['fu_in']] + fu_in_header = [] + for idx, val in enumerate(reg_dict['fu_in']): + fu_in_header.append(idx) + fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) + reg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in reg_dict['fu_in']]) + reg_sub_header['fu_in'] = fu_in_header_str + if 'outport' in reg_dict: + reg_dict['outport'] = [int(op) for op in reg_dict['outport']] + fu_reg_num = 1 + outport_sub_header = [] + for idx, val in enumerate(reg_dict['outport']): + # to directions + if idx <= num_direction_ports - 1: + hd = tile_port_direction_dict_short_desc[idx] + outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") + reg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" + # to fu regs + else: + hd = f"fu_reg_{fu_reg_num}" + outport_sub_header.append(f"{hd : ^{len(hd)}}") + reg_dict['outport'][ + idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" + fu_reg_num += 1 + outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) + reg_dict['outport'] = "|".join([v for v in reg_dict['outport']]) + reg_sub_header['outport'] = outport_sub_header_str + if 'predicate_in' in reg_dict: + reg_dict['predicate_in'] = [int(pi) for pi in reg_dict['predicate_in']] + fu_out_num = 1 + predicate_in_sub_header = [] + for idx, val in enumerate(reg_dict['predicate_in']): + # from directions + if idx <= num_direction_ports - 1: + hd = tile_port_direction_dict_short_desc[idx] + predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") + reg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" + # from fu + else: + hd = f"fu_out_{fu_out_num}" + predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") + reg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" + fu_out_num += 1 + predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) + reg_dict['predicate_in'] = "|".join([v for v in reg_dict['predicate_in']]) + reg_sub_header['predicate_in'] = predicate_in_sub_header_str + if 'routing_xbar_outport' in reg_dict: + reg_dict['routing_xbar_outport'] = [int(rxop) for rxop in reg_dict['routing_xbar_outport']] + if 'fu_xbar_outport' in reg_dict: + reg_dict['fu_xbar_outport'] = [int(fxop) for fxop in reg_dict['fu_xbar_outport']] + if 'routing_predicate_in' in reg_dict: + reg_dict['routing_predicate_in'] = [int(rpi) for rpi in reg_dict['routing_predicate_in']] + reg_dicts.insert(0, reg_sub_header) + reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() + return (f'\n## class: {s.__class__.__name__}\n' + f'- recv_ctrl_msg:\n' + f'{send_ctrl_md}\n\n' + f'- send_ctrl_msg:' + f'{send_ctrl_md}\n\n' + f'- ctrl_memory: {reg_md}\n') def line_trace( s, verbosity=0 ): From e9054d8817e6f0b589fa2f532540e7efc8e0e358 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 26 Dec 2024 15:55:26 +0800 Subject: [PATCH 31/45] verbose_trace calls verbose_trace, leave line_trace as it is. --- cgra/CGRAKingMeshRTL.py | 25 +++++++-------- cgra/translate/VectorCGRAKingMeshRTL_test.py | 2 +- fu/flexible/FlexibleFuRTL.py | 26 +++++++-------- mem/ctrl/CtrlMemRTL.py | 19 +++++------ mem/data/DataMemRTL.py | 33 +++++++++----------- tile/TileRTL.py | 23 ++++++-------- tile/TileSeparateCrossbarRTL.py | 27 +++++++--------- 7 files changed, 68 insertions(+), 87 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index b1ffae3..d031868 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -149,23 +149,20 @@ def construct( s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_waddr.rdy //= 0 s.tile[i].to_mem_wdata.rdy //= 0 - # verbose trace if verbosity > 0 - def verbose_trace(s, verbosity=1): + # verbose trace + def verbose_trace( s, verbosity = 1 ): res = '' for (i, x) in enumerate(s.tile): - res += "# [tile" + str(i) + "]: " + x.line_trace(verbosity=verbosity) + x.ctrl_mem.line_trace(verbosity=verbosity) + '\n' - res += f"\ndata_mem: {s.data_mem.line_trace(verbosity=verbosity)}" + res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' + res += f"\ndata_mem: {s.data_mem.verbose_trace(verbosity = verbosity)}" res += "------\n\n" return res # Line trace - def line_trace(s, verbosity=0): - if verbosity==0: - # str = "||".join([ x.element.line_trace() for x in s.tile ]) - # str += " :: [" + s.data_mem.line_trace() + "]" - res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - for (i, x) in enumerate(s.tile)]) - res += "\n :: [" + s.data_mem.line_trace() + "] \n" - return res - else: - return s.verbose_trace(verbosity=verbosity) + def line_trace( s ): + # str = "||".join([ x.element.line_trace() for x in s.tile ]) + # str += " :: [" + s.data_mem.line_trace() + "]" + res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + for (i, x) in enumerate(s.tile)]) + res += "\n :: [" + s.data_mem.line_trace() + "] \n" + return res diff --git a/cgra/translate/VectorCGRAKingMeshRTL_test.py b/cgra/translate/VectorCGRAKingMeshRTL_test.py index 291db2a..b6e3611 100644 --- a/cgra/translate/VectorCGRAKingMeshRTL_test.py +++ b/cgra/translate/VectorCGRAKingMeshRTL_test.py @@ -68,7 +68,7 @@ def done( s ): def line_trace( s ): verbosity = 1 - return s.dut.line_trace(verbosity=verbosity) + return s.dut.verbose_trace(verbosity = verbosity) def test_homo_4x4( cmdline_opts ): num_tile_inports = 8 diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index d044b8a..14f146e 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -114,17 +114,16 @@ def comb_logic(): s.recv_in[port].rdy @= reduce_or( s.fu_recv_in_rdy_vector[port] ) # verbose trace if verbosity > 0 - def verbose_trace(s, verbosity=1): + def verbose_trace( s, verbosity = 1 ): # for clk n # recv: # 1. OPT: opt+rdy(if ready to receive opt) # 2. Data: [rdy(if ready to receive data) and msg(data) for each inport(total 4 for now)] # out: [en(if data is sent out) and msg for each outport(total 2 for now)] - # ? what is recv_const for ? opt_ctrl = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] opt_rdy = s.recv_opt.rdy - recv_data = [x for x in s.recv_in] + recv_data = [ x for x in s.recv_in ] recv_list = [] for idx, data in enumerate(recv_data): msg_dict = data.msg.__dict__ @@ -133,14 +132,14 @@ def verbose_trace(s, verbosity=1): recv_list.append(fu_inport_dict) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - out_data = [x for x in s.send_out] + out_data = [ x for x in s.send_out ] out_list = [] for idx, data in enumerate(out_data): msg_dict = data.msg.__dict__ fu_outport_dict = {"fu_outport_idx": idx, "en": data.en} fu_outport_dict.update(msg_dict) out_list.append(fu_outport_dict) - out_md = markdown_table(out_list).set_params(quote=False).get_markdown() + out_md = markdown_table(out_list).set_params(quote = False).get_markdown() return (f'## class: {s.__class__.__name__}\n' f'- FU recv:\n' @@ -151,13 +150,10 @@ def verbose_trace(s, verbosity=1): f'- FU out:' f'{out_md}\n') - def line_trace( s, verbosity=0 ): - if verbosity == 0: - opt_str = " #" - if s.recv_opt.en: - opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - out_str = ",".join([str(x.msg) for x in s.send_out]) - recv_str = ",".join([str(x.msg) for x in s.recv_in]) - return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' - else: - return s.verbose_trace(verbosity=verbosity) + def line_trace( s ): + opt_str = " #" + if s.recv_opt.en: + opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] + out_str = ",".join([str(x.msg) for x in s.send_out]) + recv_str = ",".join([str(x.msg) for x in s.recv_in]) + return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index a309b7e..4b6d650 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -73,8 +73,8 @@ def update_raddr(): else: s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) - # verbose trace if verbosity > 0 - def verbose_trace(s, verbosity=1): + # verbose trace + def verbose_trace( s, verbosity = 1 ): num_fu_in = len(s.reg_file.regs[0].fu_in) # num_inports = len(s.reg_file.regs[0].predicate_in) num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) @@ -87,7 +87,7 @@ def verbose_trace(s, verbosity=1): recv_ctrl_sub_header[key] = '' recv_ctrl_msg_list = [] recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] - recv_ctrl_msg_dict['fu_in'] = [int(fi) for fi in recv_ctrl_msg_dict['fu_in']] + recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in recv_ctrl_msg_dict['fu_in'] ] fu_in_header = [] for idx, val in enumerate(recv_ctrl_msg_dict['fu_in']): fu_in_header.append(idx) @@ -96,7 +96,7 @@ def verbose_trace(s, verbosity=1): recv_ctrl_sub_header['fu_in'] = fu_in_header_str if 'outport' in recv_ctrl_msg_dict: - recv_ctrl_msg_dict['outport'] = [int(op) for op in recv_ctrl_msg_dict['outport']] + recv_ctrl_msg_dict['outport'] = [ int(op) for op in recv_ctrl_msg_dict['outport'] ] fu_reg_num = 1 outport_sub_header = [] for idx, val in enumerate(recv_ctrl_msg_dict['outport']): @@ -209,7 +209,7 @@ def verbose_trace(s, verbosity=1): send_ctrl_md = markdown_table(send_ctrl_msg_list).set_params(quote=False).get_markdown() # send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) - if verbosity==1: + if verbosity == 1: return (f'\n## class: {s.__class__.__name__}\n' f'- recv_ctrl_msg:\n' f'{send_ctrl_md}\n\n' @@ -286,11 +286,8 @@ def verbose_trace(s, verbosity=1): f'- ctrl_memory: {reg_md}\n') - def line_trace( s, verbosity=0 ): - if verbosity == 0: - out_str = "||".join([str(data) for data in s.reg_file.regs]) - return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' - else: - return s.verbose_trace(verbosity=verbosity) + def line_trace( s ): + out_str = "||".join([str(data) for data in s.reg_file.regs]) + return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index 6a08f58..ad126c4 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -98,11 +98,11 @@ def update_signal(): s.recv_wdata[i].rdy @= Bits1( 1 ) - # verbose trace if verbosity > 0 - def verbose_trace(s, verbosity=1): + # verbose trace + def verbose_trace( s, verbosity = 1 ): # data memory: mem size, reg # recv_raddr(rdy, msg), send_rdata(en, msg), recv_waddr(rdy, msg), recv_wdata, tile # - reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] + reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] reg_list = [] for idx, data in enumerate(reg_dicts): reg_dict = {"addr": f"addr {idx}"} @@ -140,19 +140,16 @@ def verbose_trace(s, verbosity=1): f'{mem_md}') - def line_trace(s, verbosity=0): - if verbosity == 0: - recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) - recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) - recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) - content_str = "content: " + "|".join([str(data) for data in s.reg_file.regs]) - send_rdata_str = "send_read_data: " + "|".join([str(data.msg) for data in s.send_rdata]) - return f'{recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' - # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' - # return s.reg_file.line_trace() - # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' - else: - return s.verbose_trace(verbosity=verbosity) + def line_trace( s ): + recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) + recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) + recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) + content_str = "content: " + "|".join([str(data) for data in s.reg_file.regs]) + send_rdata_str = "send_read_data: " + "|".join([str(data.msg) for data in s.send_rdata]) + return f'{recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' + # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' + # return s.reg_file.line_trace() + # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' + # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' + # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 03f9bf7..d34f327 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -124,8 +124,8 @@ def update_opt(): s.crossbar.recv_opt.en @= s.ctrl_mem.send_ctrl.en s.ctrl_mem.send_ctrl.rdy @= s.element.recv_opt.rdy & s.crossbar.recv_opt.rdy - # verbose trace if verbosity > 0 - def verbose_trace(s, verbosity=1): + # verbose trace + def verbose_trace( s, verbosity = 1 ): # recv: # 1. rdy (if ready to receive data), if en and rdy: then data has been transferred (val, rdy are new type(protocol)) # 2. data @@ -134,7 +134,7 @@ def verbose_trace(s, verbosity=1): # FlexibleFuRTL.py # tile out: # 1. en (is data transferred) - recv_data = [x for x in s.recv_data] + recv_data = [ x for x in s.recv_data ] recv_list = [] for idx, data in enumerate(recv_data): msg_dict = data.msg.__dict__ @@ -143,7 +143,7 @@ def verbose_trace(s, verbosity=1): recv_list.append(tile_inport_dict) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - out_data = [x for x in s.send_data] + out_data = [ x for x in s.send_data ] out_list = [] for idx, data in enumerate(out_data): msg_dict = data.msg.__dict__ @@ -161,13 +161,10 @@ def verbose_trace(s, verbosity=1): f"{out_md}\n") # Line trace - def line_trace( s, verbosity=0 ): - if verbosity == 0: - recv_str = "|".join([str(x.msg) for x in s.recv_data]) - channel_recv_str = "|".join([str(x.recv.msg) for x in s.channel]) - channel_send_str = "|".join([str(x.send.msg) for x in s.channel]) - out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) - return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" - else: - return s.verbose_trace(verbosity=verbosity) + def line_trace( s ): + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + channel_recv_str = "|".join([str(x.recv.msg) for x in s.channel]) + channel_send_str = "|".join([str(x.send.msg) for x in s.channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 56c76a7..e19a880 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -195,9 +195,9 @@ def update_opt(): s.routing_crossbar.recv_opt.rdy & \ s.fu_crossbar.recv_opt.rdy - # verbose trace if verbosity > 0 - def verbose_trace(s, verbosity=1): - recv_data = [x.msg.__dict__ for x in s.recv_data] + # verbose trace + def verbose_trace( s, verbosity = 1 ): + recv_data = [ x.msg.__dict__ for x in s.recv_data ] recv_list = [] for idx, data in enumerate(recv_data): port_direction = tile_port_direction_dict[idx] @@ -295,15 +295,12 @@ def verbose_trace(s, verbosity=1): f'- tile_outports:\n' f'{tile_outports_md}\n') # Line trace - def line_trace( s, verbosity=0 ): - if verbosity == 0: - recv_str = "|".join([str(x.msg) for x in s.recv_data]) - tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) - tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) - fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) - fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) - out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) - return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " - # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" - else: - return s.verbose_trace(verbosity=verbosity) + def line_trace( s ): + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) + tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) + fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) + fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " + # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" From d798f19570cf32ac99bf533a966a47c56b4ec83c Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 26 Dec 2024 16:01:24 +0800 Subject: [PATCH 32/45] Move to after from pymtl3 import *, we are sorting these in alphabet ordering. --- fu/flexible/FlexibleFuRTL.py | 2 +- mem/ctrl/CtrlMemRTL.py | 2 +- mem/data/DataMemRTL.py | 2 +- tile/TileRTL.py | 2 +- tile/TileSeparateCrossbarRTL.py | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 14f146e..f36b7b5 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -8,8 +8,8 @@ Date : Dec 24, 2019 """ -from py_markdown_table.markdown_table import markdown_table from pymtl3 import * +from py_markdown_table.markdown_table import markdown_table from ...tile.TileRTL_constant import tile_port_direction_dict from ...fu.single.MemUnitRTL import MemUnitRTL diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 4b6d650..1d95c3e 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -7,9 +7,9 @@ Author : Cheng Tan Date : Dec 21, 2019 """ -from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from pymtl3.stdlib.primitive import RegisterFile +from py_markdown_table.markdown_table import markdown_table from ...tile.TileRTL_constant import tile_port_direction_dict_short_desc from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index ad126c4..bcd2ad7 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -7,9 +7,9 @@ Author : Cheng Tan Date : Dec 20, 2019 """ -from py_markdown_table.markdown_table import markdown_table from pymtl3 import * from pymtl3.stdlib.primitive import RegisterFile +from py_markdown_table.markdown_table import markdown_table from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL from ...lib.opt_type import * diff --git a/tile/TileRTL.py b/tile/TileRTL.py index d34f327..a8f8be3 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -7,6 +7,7 @@ Date : Dec 11, 2019 """ from pymtl3 import * +from py_markdown_table.markdown_table import markdown_table from .TileRTL_constant import tile_port_direction_dict from ..lib.opt_type import OPT_SYMBOL_DICT @@ -24,7 +25,6 @@ from ..noc.ChannelRTL import ChannelRTL from ..rf.RegisterRTL import RegisterRTL # from ..noc.BypassChannelRTL import BypassChannelRTL -from py_markdown_table.markdown_table import markdown_table class TileRTL( Component ): diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index e19a880..0fefd20 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -13,8 +13,8 @@ Author : Cheng Tan Date : Nov 26, 2024 """ -from py_markdown_table.markdown_table import markdown_table from pymtl3 import * +from py_markdown_table.markdown_table import markdown_table from .TileRTL_constant import tile_port_direction_dict from ..lib.opt_type import OPT_SYMBOL_DICT From 834ccefba2c252d3042c3a97b5be859a1ba92a17 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 26 Dec 2024 16:21:35 +0800 Subject: [PATCH 33/45] Optimize imports order and move common dicts to common --- fu/flexible/FlexibleFuRTL.py | 4 ---- lib/util/common.py | 22 ++++++++++++++++++++++ mem/ctrl/CtrlMemRTL.py | 29 ++++++++++++++--------------- tile/TileRTL.py | 13 +++++++------ tile/TileRTL_constant.py | 21 --------------------- tile/TileSeparateCrossbarRTL.py | 22 ++++++++++++---------- 6 files changed, 55 insertions(+), 56 deletions(-) delete mode 100644 tile/TileRTL_constant.py diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index f36b7b5..e717270 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -8,12 +8,8 @@ Date : Dec 24, 2019 """ -from pymtl3 import * from py_markdown_table.markdown_table import markdown_table -from ...tile.TileRTL_constant import tile_port_direction_dict -from ...fu.single.MemUnitRTL import MemUnitRTL -from ...fu.single.AdderRTL import AdderRTL from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL from ...lib.opt_type import * diff --git a/lib/util/common.py b/lib/util/common.py index b26bfa3..d512a53 100644 --- a/lib/util/common.py +++ b/lib/util/common.py @@ -21,3 +21,25 @@ LINK_NO_MEM = 0 LINK_FROM_MEM = 1 LINK_TO_MEM = 2 + +TILE_PORT_DIRECTION_DICT = { + PORT_NORTH: "NORTH", + PORT_SOUTH: "SOUTH", + PORT_WEST: "WEST", + PORT_EAST: "EAST", + PORT_NORTHWEST: "NORTHWEST", + PORT_NORTHEAST: "NORTHEAST", + PORT_SOUTHEAST: "SOUTHEAST", + PORT_SOUTHWEST: "SOUTHWEST" +} + +TILE_PORT_DIRECTION_DICT_SHORT_DESC = { + PORT_NORTH: "N", + PORT_SOUTH: "S", + PORT_WEST: "W", + PORT_EAST: "E", + PORT_NORTHWEST: "NW", + PORT_NORTHEAST: "NE", + PORT_SOUTHEAST: "SE", + PORT_SOUTHWEST: "SW" +} diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 1d95c3e..3887352 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -7,13 +7,12 @@ Author : Cheng Tan Date : Dec 21, 2019 """ -from pymtl3 import * -from pymtl3.stdlib.primitive import RegisterFile from py_markdown_table.markdown_table import markdown_table +from pymtl3.stdlib.primitive import RegisterFile -from ...tile.TileRTL_constant import tile_port_direction_dict_short_desc from ...lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL from ...lib.opt_type import * +from ...lib.util.common import TILE_PORT_DIRECTION_DICT_SHORT_DESC class CtrlMemRTL( Component ): @@ -102,16 +101,16 @@ def verbose_trace( s, verbosity = 1 ): for idx, val in enumerate(recv_ctrl_msg_dict['outport']): # to directions if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") recv_ctrl_msg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" + idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" # to fu regs else: hd = f"fu_reg_{fu_reg_num}" outport_sub_header.append(f"{hd : ^{len(hd)}}") recv_ctrl_msg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" + idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) recv_ctrl_msg_dict['outport'] = "|".join([v for v in recv_ctrl_msg_dict['outport']]) @@ -123,7 +122,7 @@ def verbose_trace( s, verbosity = 1 ): for idx, val in enumerate(recv_ctrl_msg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") recv_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" # from fu @@ -164,16 +163,16 @@ def verbose_trace( s, verbosity = 1 ): for idx, val in enumerate(send_ctrl_msg_dict['outport']): # to directions if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") send_ctrl_msg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" + idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" # to fu regs else: hd = f"fu_reg_{fu_reg_num}" outport_sub_header.append(f"{hd : ^{len(hd)}}") send_ctrl_msg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" + idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) send_ctrl_msg_dict['outport'] = "|".join([v for v in send_ctrl_msg_dict['outport']]) @@ -185,7 +184,7 @@ def verbose_trace( s, verbosity = 1 ): for idx, val in enumerate(send_ctrl_msg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") send_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" # from fu @@ -237,16 +236,16 @@ def verbose_trace( s, verbosity = 1 ): for idx, val in enumerate(reg_dict['outport']): # to directions if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") reg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" + idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" # to fu regs else: hd = f"fu_reg_{fu_reg_num}" outport_sub_header.append(f"{hd : ^{len(hd)}}") reg_dict['outport'][ - idx] = f"{tile_port_direction_dict_short_desc[val - 1] if val != 0 else '-' : ^{len(hd)}}" + idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) reg_dict['outport'] = "|".join([v for v in reg_dict['outport']]) @@ -258,7 +257,7 @@ def verbose_trace( s, verbosity = 1 ): for idx, val in enumerate(reg_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: - hd = tile_port_direction_dict_short_desc[idx] + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") reg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" # from fu diff --git a/tile/TileRTL.py b/tile/TileRTL.py index a8f8be3..c8ce444 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -6,11 +6,9 @@ Author : Cheng Tan Date : Dec 11, 2019 """ -from pymtl3 import * from py_markdown_table.markdown_table import markdown_table +from pymtl3 import * -from .TileRTL_constant import tile_port_direction_dict -from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL @@ -19,11 +17,14 @@ from ..fu.single.MulRTL import MulRTL from ..fu.single.PhiRTL import PhiRTL from ..lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL +from ..lib.util.common import TILE_PORT_DIRECTION_DICT from ..mem.const.ConstQueueRTL import ConstQueueRTL from ..mem.ctrl.CtrlMemRTL import CtrlMemRTL -from ..noc.CrossbarRTL import CrossbarRTL from ..noc.ChannelRTL import ChannelRTL +from ..noc.CrossbarRTL import CrossbarRTL from ..rf.RegisterRTL import RegisterRTL + + # from ..noc.BypassChannelRTL import BypassChannelRTL class TileRTL( Component ): @@ -138,7 +139,7 @@ def verbose_trace( s, verbosity = 1 ): recv_list = [] for idx, data in enumerate(recv_data): msg_dict = data.msg.__dict__ - tile_inport_dict = {"tile_inport_direction": tile_port_direction_dict[idx], "rdy": data.rdy} + tile_inport_dict = {"tile_inport_direction": TILE_PORT_DIRECTION_DICT[idx], "rdy": data.rdy} tile_inport_dict.update(msg_dict) recv_list.append(tile_inport_dict) recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() @@ -147,7 +148,7 @@ def verbose_trace( s, verbosity = 1 ): out_list = [] for idx, data in enumerate(out_data): msg_dict = data.msg.__dict__ - tile_outport_dict = {"tile_outport_direction": tile_port_direction_dict[idx], "en": data.en} + tile_outport_dict = {"tile_outport_direction": TILE_PORT_DIRECTION_DICT[idx], "en": data.en} tile_outport_dict.update(msg_dict) out_list.append(tile_outport_dict) out_md = markdown_table(out_list).set_params(quote=False).get_markdown() diff --git a/tile/TileRTL_constant.py b/tile/TileRTL_constant.py deleted file mode 100644 index d5b1c40..0000000 --- a/tile/TileRTL_constant.py +++ /dev/null @@ -1,21 +0,0 @@ -tile_port_direction_dict = { - 0: "NORTH", - 1: "SOUTH", - 2: "WEST", - 3: "EAST", - 4: "NORTHWEST", - 5: "NORTHEAST", - 6: "SOUTHEAST", - 7: "SOUTHWEST" -} - -tile_port_direction_dict_short_desc = { - 0: "N", - 1: "S", - 2: "W", - 3: "E", - 4: "NW", - 5: "NE", - 6: "SE", - 7: "SW" -} diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 0fefd20..a093e4c 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -16,23 +16,25 @@ from pymtl3 import * from py_markdown_table.markdown_table import markdown_table -from .TileRTL_constant import tile_port_direction_dict -from ..lib.opt_type import OPT_SYMBOL_DICT from ..fu.flexible.FlexibleFuRTL import FlexibleFuRTL from ..fu.single.AdderRTL import AdderRTL from ..fu.single.BranchRTL import BranchRTL -from ..fu.single.PhiRTL import PhiRTL from ..fu.single.CompRTL import CompRTL from ..fu.single.MemUnitRTL import MemUnitRTL from ..fu.single.MulRTL import MulRTL +from ..fu.single.PhiRTL import PhiRTL from ..lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL from ..lib.basic.val_rdy.ifcs import ValRdyRecvIfcRTL +from ..lib.opt_type import OPT_SYMBOL_DICT +from ..lib.util.common import TILE_PORT_DIRECTION_DICT from ..mem.const.ConstQueueRTL import ConstQueueRTL from ..mem.ctrl.CtrlMemDynamicRTL import CtrlMemDynamicRTL -from ..noc.CrossbarSeparateRTL import CrossbarSeparateRTL from ..noc.ChannelNormalRTL import ChannelNormalRTL +from ..noc.CrossbarSeparateRTL import CrossbarSeparateRTL from ..noc.LinkOrRTL import LinkOrRTL from ..rf.RegisterRTL import RegisterRTL + + # from ..noc.BypassChannelRTL import BypassChannelRTL class TileSeparateCrossbarRTL(Component): @@ -200,7 +202,7 @@ def verbose_trace( s, verbosity = 1 ): recv_data = [ x.msg.__dict__ for x in s.recv_data ] recv_list = [] for idx, data in enumerate(recv_data): - port_direction = tile_port_direction_dict[idx] + port_direction = TILE_PORT_DIRECTION_DICT[idx] dict_with_direction = {"inport_direction": port_direction} dict_with_direction.update(data) recv_list.append(dict_with_direction) @@ -229,7 +231,7 @@ def verbose_trace( s, verbosity = 1 ): tile_out_channel_recv_data = [x.recv.msg.__dict__ for x in s.tile_out_channel] tile_out_channel_recv_data_list = [] for idx, data in enumerate(tile_out_channel_recv_data): - port_direction = tile_port_direction_dict[idx] + port_direction = TILE_PORT_DIRECTION_DICT[idx] dict_with_direction = {"inport_direction": port_direction} dict_with_direction.update(data) tile_out_channel_recv_data_list.append(dict_with_direction) @@ -238,7 +240,7 @@ def verbose_trace( s, verbosity = 1 ): tile_out_channel_send_data = [x.send.msg.__dict__ for x in s.tile_out_channel] tile_out_channel_send_data_list = [] for idx, data in enumerate(tile_out_channel_send_data): - port_direction = tile_port_direction_dict[idx] + port_direction = TILE_PORT_DIRECTION_DICT[idx] dict_with_direction = {"outport_direction": port_direction} dict_with_direction.update(data) tile_out_channel_send_data_list.append(dict_with_direction) @@ -247,7 +249,7 @@ def verbose_trace( s, verbosity = 1 ): fu_in_channel_recv_data = [x.recv.msg.__dict__ for x in s.fu_in_channel] fu_in_channel_recv_data_list = [] for idx, data in enumerate(fu_in_channel_recv_data): - port_direction = tile_port_direction_dict[idx] + port_direction = TILE_PORT_DIRECTION_DICT[idx] dict_with_direction = {"inport_direction": port_direction} dict_with_direction.update(data) fu_in_channel_recv_data_list.append(dict_with_direction) @@ -256,7 +258,7 @@ def verbose_trace( s, verbosity = 1 ): fu_in_channel_send_data = [x.send.msg.__dict__ for x in s.fu_in_channel] fu_in_channel_send_data_list = [] for idx, data in enumerate(fu_in_channel_send_data): - port_direction = tile_port_direction_dict[idx] + port_direction = TILE_PORT_DIRECTION_DICT[idx] dict_with_direction = {"outport_direction": port_direction} dict_with_direction.update(data) fu_in_channel_send_data_list.append(dict_with_direction) @@ -265,7 +267,7 @@ def verbose_trace( s, verbosity = 1 ): tile_outports_data = [x.msg.__dict__ for x in s.send_data] tile_outports_data_list = [] for idx, data in enumerate(tile_outports_data): - port_direction = tile_port_direction_dict[idx] + port_direction = TILE_PORT_DIRECTION_DICT[idx] dict_with_direction = {"outport_direction": port_direction} dict_with_direction.update(data) tile_outports_data_list.append(dict_with_direction) From 58bb723464b7f7e01b9db93456cbe8622dc848a0 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 26 Dec 2024 16:24:19 +0800 Subject: [PATCH 34/45] Test with verilog. --- cgra/translate/VectorCGRAKingMeshRTL_test.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/cgra/translate/VectorCGRAKingMeshRTL_test.py b/cgra/translate/VectorCGRAKingMeshRTL_test.py index b6e3611..88ea34d 100644 --- a/cgra/translate/VectorCGRAKingMeshRTL_test.py +++ b/cgra/translate/VectorCGRAKingMeshRTL_test.py @@ -67,8 +67,10 @@ def done( s ): return done def line_trace( s ): - verbosity = 1 - return s.dut.verbose_trace(verbosity = verbosity) + # verbose trace (test without verilog) + # verbosity = 1 + # return s.dut.verbose_trace(verbosity = verbosity) + return s.dut.line_trace() def test_homo_4x4( cmdline_opts ): num_tile_inports = 8 From dd750f79d5cffa80df16a2e9005717e3087caa1f Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 26 Dec 2024 22:23:47 +0800 Subject: [PATCH 35/45] extract common logic for verbose_trace --- cgra/CGRAKingMeshRTL.py | 2 +- cgra/translate/VectorCGRAKingMeshRTL_test.py | 2 +- fu/flexible/FlexibleFuRTL.py | 38 +-- mem/ctrl/CtrlMemRTL.py | 234 ++++++------------- tile/TileRTL.py | 40 ++-- 5 files changed, 108 insertions(+), 208 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index d031868..aacb4f8 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -154,7 +154,7 @@ def verbose_trace( s, verbosity = 1 ): res = '' for (i, x) in enumerate(s.tile): res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' - res += f"\ndata_mem: {s.data_mem.verbose_trace(verbosity = verbosity)}" + res += f"data_mem: {s.data_mem.verbose_trace(verbosity = verbosity)}" res += "------\n\n" return res diff --git a/cgra/translate/VectorCGRAKingMeshRTL_test.py b/cgra/translate/VectorCGRAKingMeshRTL_test.py index 88ea34d..6e2341a 100644 --- a/cgra/translate/VectorCGRAKingMeshRTL_test.py +++ b/cgra/translate/VectorCGRAKingMeshRTL_test.py @@ -68,7 +68,7 @@ def done( s ): def line_trace( s ): # verbose trace (test without verilog) - # verbosity = 1 + # verbosity = 2 # return s.dut.verbose_trace(verbosity = verbosity) return s.dut.line_trace() diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index e717270..b83fc04 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -109,6 +109,22 @@ def comb_logic(): s.fu_recv_in_rdy_vector[port][i] @= s.fu[i].recv_in[port].rdy s.recv_in[port].rdy @= reduce_or( s.fu_recv_in_rdy_vector[port] ) + + def verbose_trace_md_formatter( self, data_type, data ): + assert data_type in [ "recv", "send" ] + data_list = [ x for x in data ] + result_list = [] + for idx, fu_data in enumerate(data_list): + msg_dict = fu_data.msg.__dict__ + if data_type is "recv": + fu_port_dict = { "fu_inport_idx": idx, "rdy": fu_data.rdy } + else: + fu_port_dict = { "fu_outport_idx": idx, "en": fu_data.en } + fu_port_dict.update(msg_dict) + result_list.append(fu_port_dict) + result_md = markdown_table(result_list).set_params(quote = False).get_markdown() + return result_md + # verbose trace if verbosity > 0 def verbose_trace( s, verbosity = 1 ): # for clk n @@ -118,24 +134,8 @@ def verbose_trace( s, verbosity = 1 ): # out: [en(if data is sent out) and msg for each outport(total 2 for now)] opt_ctrl = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] opt_rdy = s.recv_opt.rdy - - recv_data = [ x for x in s.recv_in ] - recv_list = [] - for idx, data in enumerate(recv_data): - msg_dict = data.msg.__dict__ - fu_inport_dict = {"fu_inport_idx": idx, "rdy": data.rdy} - fu_inport_dict.update(msg_dict) - recv_list.append(fu_inport_dict) - recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - - out_data = [ x for x in s.send_out ] - out_list = [] - for idx, data in enumerate(out_data): - msg_dict = data.msg.__dict__ - fu_outport_dict = {"fu_outport_idx": idx, "en": data.en} - fu_outport_dict.update(msg_dict) - out_list.append(fu_outport_dict) - out_md = markdown_table(out_list).set_params(quote = False).get_markdown() + recv_md = s.verbose_trace_md_formatter("recv", s.recv_in) + send_md = s.verbose_trace_md_formatter("send", s.send_out) return (f'## class: {s.__class__.__name__}\n' f'- FU recv:\n' @@ -144,7 +144,7 @@ def verbose_trace( s, verbosity = 1 ): f'{recv_md}\n' f'===>\n' f'- FU out:' - f'{out_md}\n') + f'{send_md}') def line_trace( s ): opt_str = " #" diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 3887352..71bbd18 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -72,214 +72,114 @@ def update_raddr(): else: s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) - # verbose trace - def verbose_trace( s, verbosity = 1 ): - num_fu_in = len(s.reg_file.regs[0].fu_in) - # num_inports = len(s.reg_file.regs[0].predicate_in) - num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) - num_direction_ports = num_outports - num_fu_in - - # recv_ctrl - recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) - recv_ctrl_sub_header = {} - for key in recv_ctrl_msg_dict.keys(): - recv_ctrl_sub_header[key] = '' - recv_ctrl_msg_list = [] - recv_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[recv_ctrl_msg_dict['ctrl']] - recv_ctrl_msg_dict['fu_in'] = [ int(fi) for fi in recv_ctrl_msg_dict['fu_in'] ] + def verbose_trace_normal_processor( self, data_dict ): + data_dict['ctrl'] = OPT_SYMBOL_DICT[ data_dict['ctrl'] ] + if 'predicate' in data_dict: + data_dict['predicate'] = int(data_dict['predicate']) + if 'routing_xbar_outport' in data_dict: + data_dict['routing_xbar_outport'] = [ int(rxop) for rxop in data_dict['routing_xbar_outport'] ] + if 'fu_xbar_outport' in data_dict: + data_dict['fu_xbar_outport'] = [ int(fxop) for fxop in data_dict['fu_xbar_outport'] ] + if 'routing_predicate_in' in data_dict: + data_dict['routing_predicate_in'] = [ int(rpi) for rpi in data_dict['routing_predicate_in'] ] + + def verbose_trace_fu_in_processor( self, data_dict, sub_header ): + data_dict['fu_in'] = [ int(fi) for fi in data_dict['fu_in'] ] fu_in_header = [] - for idx, val in enumerate(recv_ctrl_msg_dict['fu_in']): + for idx, val in enumerate(data_dict['fu_in']): fu_in_header.append(idx) - fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) - recv_ctrl_msg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in recv_ctrl_msg_dict['fu_in']]) - recv_ctrl_sub_header['fu_in'] = fu_in_header_str + fu_in_header_str = "|".join([ f"{hd : ^3}" for hd in fu_in_header ]) + data_dict['fu_in'] = "|".join([ f"{v : ^3}" for v in data_dict['fu_in'] ]) + sub_header['fu_in'] = fu_in_header_str - if 'outport' in recv_ctrl_msg_dict: - recv_ctrl_msg_dict['outport'] = [ int(op) for op in recv_ctrl_msg_dict['outport'] ] + def verbose_trace_outport_processor( self, data_dict, sub_header, num_direction_ports ): + if 'outport' in data_dict: + data_dict['outport'] = [ int(op) for op in data_dict['outport'] ] fu_reg_num = 1 outport_sub_header = [] - for idx, val in enumerate(recv_ctrl_msg_dict['outport']): + for idx, val in enumerate(data_dict['outport']): # to directions if idx <= num_direction_ports - 1: hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") - recv_ctrl_msg_dict['outport'][ - idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" + data_dict['outport'][idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" # to fu regs else: hd = f"fu_reg_{fu_reg_num}" outport_sub_header.append(f"{hd : ^{len(hd)}}") - recv_ctrl_msg_dict['outport'][ - idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" + data_dict['outport'][idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" fu_reg_num += 1 - outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) - recv_ctrl_msg_dict['outport'] = "|".join([v for v in recv_ctrl_msg_dict['outport']]) - recv_ctrl_sub_header['outport'] = outport_sub_header_str - if 'predicate_in' in recv_ctrl_msg_dict: - recv_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in recv_ctrl_msg_dict['predicate_in']] + outport_sub_header_str = "|".join([ hd for hd in outport_sub_header ]) + data_dict['outport'] = "|".join([ v for v in data_dict['outport'] ]) + sub_header['outport'] = outport_sub_header_str + + def verbose_trace_predicate_in_processor( self, data_dict, sub_header, num_direction_ports ): + if 'predicate_in' in data_dict: + data_dict['predicate_in'] = [ int(pi) for pi in data_dict['predicate_in'] ] fu_out_num = 1 predicate_in_sub_header = [] - for idx, val in enumerate(recv_ctrl_msg_dict['predicate_in']): + for idx, val in enumerate(data_dict['predicate_in']): # from directions if idx <= num_direction_ports - 1: hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") - recv_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" + data_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" # from fu else: hd = f"fu_out_{fu_out_num}" predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") - recv_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" + data_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" fu_out_num += 1 - predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) - recv_ctrl_msg_dict['predicate_in'] = "|".join([v for v in recv_ctrl_msg_dict['predicate_in']]) - recv_ctrl_sub_header['predicate_in'] = predicate_in_sub_header_str - recv_ctrl_msg_list.append(recv_ctrl_sub_header) - recv_ctrl_msg_list.append(recv_ctrl_msg_dict) - send_ctrl_md = markdown_table(recv_ctrl_msg_list).set_params(quote=False).get_markdown() - # recv_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in recv_ctrl_msg_dict.items()]) + predicate_in_sub_header_str = "|".join([ hd for hd in predicate_in_sub_header ]) + data_dict['predicate_in'] = "|".join([ v for v in data_dict['predicate_in'] ]) + sub_header['predicate_in'] = predicate_in_sub_header_str + + def verbose_trace_data_processor( self, data_dict, num_direction_ports ): + sub_header = {} + for key in data_dict.keys(): + sub_header[key] = '' + self.verbose_trace_normal_processor(data_dict) + self.verbose_trace_fu_in_processor(data_dict, sub_header) + self.verbose_trace_outport_processor(data_dict, sub_header, num_direction_ports) + self.verbose_trace_predicate_in_processor(data_dict, sub_header, num_direction_ports) + return sub_header - # send_ctrl - send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) - send_ctrl_sub_header = {} - for key in send_ctrl_msg_dict.keys(): - send_ctrl_sub_header[key] = '' - send_ctrl_msg_list = [] - send_ctrl_msg_dict['ctrl'] = OPT_SYMBOL_DICT[send_ctrl_msg_dict['ctrl']] - if 'predicate' in send_ctrl_msg_dict: - send_ctrl_msg_dict['predicate'] = int(send_ctrl_msg_dict['predicate']) - send_ctrl_msg_dict['fu_in'] = [int(fi) for fi in send_ctrl_msg_dict['fu_in']] - fu_in_header = [] - for idx, val in enumerate(send_ctrl_msg_dict['fu_in']): - fu_in_header.append(idx) - fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) - send_ctrl_msg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in send_ctrl_msg_dict['fu_in']]) - send_ctrl_sub_header['fu_in'] = fu_in_header_str + # verbose trace + def verbose_trace( s, verbosity = 1 ): + num_fu_in = len(s.reg_file.regs[0].fu_in) + # num_inports = len(s.reg_file.regs[0].predicate_in) + num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) + num_direction_ports = num_outports - num_fu_in - if 'outport' in send_ctrl_msg_dict: - send_ctrl_msg_dict['outport'] = [int(op) for op in send_ctrl_msg_dict['outport']] - fu_reg_num = 1 - outport_sub_header = [] - for idx, val in enumerate(send_ctrl_msg_dict['outport']): - # to directions - if idx <= num_direction_ports - 1: - hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] - outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") - send_ctrl_msg_dict['outport'][ - idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" - # to fu regs - else: - hd = f"fu_reg_{fu_reg_num}" - outport_sub_header.append(f"{hd : ^{len(hd)}}") - send_ctrl_msg_dict['outport'][ - idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" - fu_reg_num += 1 - outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) - send_ctrl_msg_dict['outport'] = "|".join([v for v in send_ctrl_msg_dict['outport']]) - send_ctrl_sub_header['outport'] = outport_sub_header_str - if 'predicate_in' in send_ctrl_msg_dict: - send_ctrl_msg_dict['predicate_in'] = [int(pi) for pi in send_ctrl_msg_dict['predicate_in']] - fu_out_num = 1 - predicate_in_sub_header = [] - for idx, val in enumerate(send_ctrl_msg_dict['predicate_in']): - # from directions - if idx <= num_direction_ports - 1: - hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] - predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") - send_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" - # from fu - else: - hd = f"fu_out_{fu_out_num}" - predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") - send_ctrl_msg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" - fu_out_num += 1 - predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) - send_ctrl_msg_dict['predicate_in'] = "|".join([v for v in send_ctrl_msg_dict['predicate_in']]) - send_ctrl_sub_header['predicate_in'] = predicate_in_sub_header_str - if 'routing_xbar_outport' in send_ctrl_msg_dict: - send_ctrl_msg_dict['routing_xbar_outport'] = [int(rxop) for rxop in send_ctrl_msg_dict['routing_xbar_outport']] - if 'fu_xbar_outport' in send_ctrl_msg_dict: - send_ctrl_msg_dict['fu_xbar_outport'] = [int(fxop) for fxop in send_ctrl_msg_dict['fu_xbar_outport']] - if 'routing_predicate_in' in send_ctrl_msg_dict: - send_ctrl_msg_dict['routing_predicate_in'] = [int(rpi) for rpi in send_ctrl_msg_dict['routing_predicate_in']] + # recv_ctrl + recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) + recv_ctrl_sub_header = s.verbose_trace_data_processor(recv_ctrl_msg_dict, num_direction_ports) + recv_ctrl_msg_list = [ recv_ctrl_sub_header, recv_ctrl_msg_dict ] + recv_ctrl_md = markdown_table(recv_ctrl_msg_list).set_params(quote=False).get_markdown() - send_ctrl_msg_list.append(send_ctrl_sub_header) - send_ctrl_msg_list.append(send_ctrl_msg_dict) + # send_ctrl + send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) + send_ctrl_sub_header = s.verbose_trace_data_processor(send_ctrl_msg_dict, num_direction_ports) + send_ctrl_msg_list = [ send_ctrl_sub_header, send_ctrl_msg_dict ] send_ctrl_md = markdown_table(send_ctrl_msg_list).set_params(quote=False).get_markdown() - # send_ctrl_msg = "\n".join([(key + ": " + str(value)) for key, value in send_ctrl_msg_dict.items()]) if verbosity == 1: return (f'\n## class: {s.__class__.__name__}\n' - f'- recv_ctrl_msg:\n' - f'{send_ctrl_md}\n\n' + f'- recv_ctrl_msg:' + f'{recv_ctrl_md}\n\n' f'- send_ctrl_msg:' f'{send_ctrl_md}\n\n') else: # reg - reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] + reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] reg_sub_header = {} for reg_dict in reg_dicts: - for key in reg_dict.keys(): - reg_sub_header[key] = '' - reg_dict['ctrl'] = OPT_SYMBOL_DICT[reg_dict['ctrl']] - reg_dict['fu_in'] = [int(fi) for fi in reg_dict['fu_in']] - fu_in_header = [] - for idx, val in enumerate(reg_dict['fu_in']): - fu_in_header.append(idx) - fu_in_header_str = "|".join([f"{hd : ^3}" for hd in fu_in_header]) - reg_dict['fu_in'] = "|".join([f"{v : ^3}" for v in reg_dict['fu_in']]) - reg_sub_header['fu_in'] = fu_in_header_str - if 'outport' in reg_dict: - reg_dict['outport'] = [int(op) for op in reg_dict['outport']] - fu_reg_num = 1 - outport_sub_header = [] - for idx, val in enumerate(reg_dict['outport']): - # to directions - if idx <= num_direction_ports - 1: - hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] - outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") - reg_dict['outport'][ - idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" - # to fu regs - else: - hd = f"fu_reg_{fu_reg_num}" - outport_sub_header.append(f"{hd : ^{len(hd)}}") - reg_dict['outport'][ - idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" - fu_reg_num += 1 - outport_sub_header_str = "|".join([hd for hd in outport_sub_header]) - reg_dict['outport'] = "|".join([v for v in reg_dict['outport']]) - reg_sub_header['outport'] = outport_sub_header_str - if 'predicate_in' in reg_dict: - reg_dict['predicate_in'] = [int(pi) for pi in reg_dict['predicate_in']] - fu_out_num = 1 - predicate_in_sub_header = [] - for idx, val in enumerate(reg_dict['predicate_in']): - # from directions - if idx <= num_direction_ports - 1: - hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] - predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") - reg_dict['predicate_in'][idx] = f"{val : ^{len(hd) + 2}}" - # from fu - else: - hd = f"fu_out_{fu_out_num}" - predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") - reg_dict['predicate_in'][idx] = f"{val : ^{len(hd)}}" - fu_out_num += 1 - predicate_in_sub_header_str = "|".join([hd for hd in predicate_in_sub_header]) - reg_dict['predicate_in'] = "|".join([v for v in reg_dict['predicate_in']]) - reg_sub_header['predicate_in'] = predicate_in_sub_header_str - if 'routing_xbar_outport' in reg_dict: - reg_dict['routing_xbar_outport'] = [int(rxop) for rxop in reg_dict['routing_xbar_outport']] - if 'fu_xbar_outport' in reg_dict: - reg_dict['fu_xbar_outport'] = [int(fxop) for fxop in reg_dict['fu_xbar_outport']] - if 'routing_predicate_in' in reg_dict: - reg_dict['routing_predicate_in'] = [int(rpi) for rpi in reg_dict['routing_predicate_in']] + reg_sub_header = s.verbose_trace_data_processor(reg_dict, num_direction_ports) reg_dicts.insert(0, reg_sub_header) reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() return (f'\n## class: {s.__class__.__name__}\n' - f'- recv_ctrl_msg:\n' - f'{send_ctrl_md}\n\n' + f'- recv_ctrl_msg:' + f'{recv_ctrl_md}\n\n' f'- send_ctrl_msg:' f'{send_ctrl_md}\n\n' f'- ctrl_memory: {reg_md}\n') diff --git a/tile/TileRTL.py b/tile/TileRTL.py index c8ce444..d2a2c1d 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -125,6 +125,21 @@ def update_opt(): s.crossbar.recv_opt.en @= s.ctrl_mem.send_ctrl.en s.ctrl_mem.send_ctrl.rdy @= s.element.recv_opt.rdy & s.crossbar.recv_opt.rdy + def verbose_trace_md_formatter( self, data_type, data ): + assert data_type in [ "recv", "send" ] + data_list = [ x for x in data ] + result_list = [] + for idx, port_data in enumerate(data_list): + msg_dict = port_data.msg.__dict__ + if data_type is "recv": + tile_port_dict = { "tile_inport_direction": TILE_PORT_DIRECTION_DICT[idx], "rdy": port_data.rdy } + else: + tile_port_dict = { "tile_outport_direction": TILE_PORT_DIRECTION_DICT[idx], "en": port_data.en } + tile_port_dict.update(msg_dict) + result_list.append(tile_port_dict) + result_md = markdown_table(result_list).set_params(quote = False).get_markdown() + return result_md + # verbose trace def verbose_trace( s, verbosity = 1 ): # recv: @@ -135,31 +150,16 @@ def verbose_trace( s, verbosity = 1 ): # FlexibleFuRTL.py # tile out: # 1. en (is data transferred) - recv_data = [ x for x in s.recv_data ] - recv_list = [] - for idx, data in enumerate(recv_data): - msg_dict = data.msg.__dict__ - tile_inport_dict = {"tile_inport_direction": TILE_PORT_DIRECTION_DICT[idx], "rdy": data.rdy} - tile_inport_dict.update(msg_dict) - recv_list.append(tile_inport_dict) - recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() - - out_data = [ x for x in s.send_data ] - out_list = [] - for idx, data in enumerate(out_data): - msg_dict = data.msg.__dict__ - tile_outport_dict = {"tile_outport_direction": TILE_PORT_DIRECTION_DICT[idx], "en": data.en} - tile_outport_dict.update(msg_dict) - out_list.append(tile_outport_dict) - out_md = markdown_table(out_list).set_params(quote=False).get_markdown() + recv_md = s.verbose_trace_md_formatter("recv", s.recv_data) + send_md = s.verbose_trace_md_formatter("send", s.send_data) return (f"\n## class[{s.__class__.__name__}]:\n" f"- Tile recv:" - f"{recv_md}\n" + f"{recv_md}\n\n" f"- FU element:\n" - f"{s.element.line_trace(verbosity=verbosity)}\n" + f"{s.element.verbose_trace(verbosity=verbosity)}\n" f"===>\n" f"- Tile out:" - f"{out_md}\n") + f"{send_md}\n") # Line trace def line_trace( s ): From 787c94a2392162e751077c0802513584e95abc6e Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 26 Dec 2024 22:54:27 +0800 Subject: [PATCH 36/45] extract common logic for verbose_trace --- tile/TileSeparateCrossbarRTL.py | 113 ++++++++-------------- tile/test/TileSeparateCrossbarRTL_test.py | 1 + 2 files changed, 43 insertions(+), 71 deletions(-) diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index a093e4c..b91dfc3 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -197,84 +197,54 @@ def update_opt(): s.routing_crossbar.recv_opt.rdy & \ s.fu_crossbar.recv_opt.rdy + def verbose_trace_str_formatter( self, crossbar_dict ): + crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[crossbar_dict['ctrl']] + crossbar_dict['predicate'] = int(crossbar_dict['predicate']) + crossbar_dict['fu_in'] = [ int(fi) for fi in crossbar_dict['fu_in'] ] + crossbar_dict['fu_xbar_outport'] = [ int(fxop) for fxop in crossbar_dict['fu_xbar_outport'] ] + crossbar_dict['routing_predicate_in'] = [ int(rpi) for rpi in crossbar_dict['routing_predicate_in'] ] + crossbar_dict['routing_xbar_outport'] = [ int(rxop) for rxop in crossbar_dict['routing_xbar_outport'] ] + crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in crossbar_dict.items()]) + return crossbar_str + + def verbose_trace_md_formatter( self, header_str, data_dict ): + result_list = [] + for idx, data in enumerate(data_dict): + port_direction = TILE_PORT_DIRECTION_DICT[idx] + dict_with_direction = { header_str: port_direction } + dict_with_direction.update(data) + result_list.append(dict_with_direction) + result_md = markdown_table(result_list).set_params(quote = False).get_markdown() + return result_md + # verbose trace def verbose_trace( s, verbosity = 1 ): recv_data = [ x.msg.__dict__ for x in s.recv_data ] - recv_list = [] - for idx, data in enumerate(recv_data): - port_direction = TILE_PORT_DIRECTION_DICT[idx] - dict_with_direction = {"inport_direction": port_direction} - dict_with_direction.update(data) - recv_list.append(dict_with_direction) - recv_md = markdown_table(recv_list).set_params(quote=False).get_markdown() + recv_md = s.verbose_trace_md_formatter("inport_direction", recv_data) routing_crossbar_dict = dict(s.routing_crossbar.recv_opt.msg.__dict__) - routing_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[routing_crossbar_dict['ctrl']] - routing_crossbar_dict['predicate'] = int(routing_crossbar_dict['predicate']) - routing_crossbar_dict['fu_in'] = [int(fi) for fi in routing_crossbar_dict['fu_in']] - routing_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in routing_crossbar_dict['fu_xbar_outport']] - routing_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in - routing_crossbar_dict['routing_predicate_in']] - routing_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in - routing_crossbar_dict['routing_xbar_outport']] - routing_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in routing_crossbar_dict.items()]) + routing_crossbar_str = s.verbose_trace_str_formatter(routing_crossbar_dict) fu_crossbar_dict = dict(s.fu_crossbar.recv_opt.msg.__dict__) - fu_crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[fu_crossbar_dict['ctrl']] - fu_crossbar_dict['predicate'] = int(fu_crossbar_dict['predicate']) - fu_crossbar_dict['fu_in'] = [int(fi) for fi in fu_crossbar_dict['fu_in']] - fu_crossbar_dict['fu_xbar_outport'] = [int(fxop) for fxop in fu_crossbar_dict['fu_xbar_outport']] - fu_crossbar_dict['routing_predicate_in'] = [int(rpi) for rpi in fu_crossbar_dict['routing_predicate_in']] - fu_crossbar_dict['routing_xbar_outport'] = [int(rxop) for rxop in fu_crossbar_dict['routing_xbar_outport']] - fu_crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in fu_crossbar_dict.items()]) - - tile_out_channel_recv_data = [x.recv.msg.__dict__ for x in s.tile_out_channel] - tile_out_channel_recv_data_list = [] - for idx, data in enumerate(tile_out_channel_recv_data): - port_direction = TILE_PORT_DIRECTION_DICT[idx] - dict_with_direction = {"inport_direction": port_direction} - dict_with_direction.update(data) - tile_out_channel_recv_data_list.append(dict_with_direction) - tile_out_channel_recv_md = markdown_table(tile_out_channel_recv_data_list).set_params(quote=False).get_markdown() + fu_crossbar_str = s.verbose_trace_str_formatter(fu_crossbar_dict) - tile_out_channel_send_data = [x.send.msg.__dict__ for x in s.tile_out_channel] - tile_out_channel_send_data_list = [] - for idx, data in enumerate(tile_out_channel_send_data): - port_direction = TILE_PORT_DIRECTION_DICT[idx] - dict_with_direction = {"outport_direction": port_direction} - dict_with_direction.update(data) - tile_out_channel_send_data_list.append(dict_with_direction) - tile_out_channel_send_md = markdown_table(tile_out_channel_send_data_list).set_params(quote=False).get_markdown() + tile_out_channel_recv_data = [ x.recv.msg.__dict__ for x in s.tile_out_channel ] + tile_out_channel_recv_md = s.verbose_trace_md_formatter("inport_direction", tile_out_channel_recv_data) - fu_in_channel_recv_data = [x.recv.msg.__dict__ for x in s.fu_in_channel] - fu_in_channel_recv_data_list = [] - for idx, data in enumerate(fu_in_channel_recv_data): - port_direction = TILE_PORT_DIRECTION_DICT[idx] - dict_with_direction = {"inport_direction": port_direction} - dict_with_direction.update(data) - fu_in_channel_recv_data_list.append(dict_with_direction) - fu_in_channel_recv_md = markdown_table(fu_in_channel_recv_data_list).set_params(quote=False).get_markdown() + tile_out_channel_send_data = [ x.send.msg.__dict__ for x in s.tile_out_channel ] + tile_out_channel_send_md = s.verbose_trace_md_formatter("outport_direction", tile_out_channel_send_data) - fu_in_channel_send_data = [x.send.msg.__dict__ for x in s.fu_in_channel] - fu_in_channel_send_data_list = [] - for idx, data in enumerate(fu_in_channel_send_data): - port_direction = TILE_PORT_DIRECTION_DICT[idx] - dict_with_direction = {"outport_direction": port_direction} - dict_with_direction.update(data) - fu_in_channel_send_data_list.append(dict_with_direction) - fu_in_channel_send_md = markdown_table(fu_in_channel_send_data_list).set_params(quote=False).get_markdown() + fu_in_channel_recv_data = [ x.recv.msg.__dict__ for x in s.fu_in_channel ] + fu_in_channel_recv_md = s.verbose_trace_md_formatter("inport_direction", fu_in_channel_recv_data) - tile_outports_data = [x.msg.__dict__ for x in s.send_data] - tile_outports_data_list = [] - for idx, data in enumerate(tile_outports_data): - port_direction = TILE_PORT_DIRECTION_DICT[idx] - dict_with_direction = {"outport_direction": port_direction} - dict_with_direction.update(data) - tile_outports_data_list.append(dict_with_direction) - tile_outports_md = markdown_table(tile_outports_data_list).set_params(quote=False).get_markdown() + fu_in_channel_send_data = [ x.send.msg.__dict__ for x in s.fu_in_channel ] + fu_in_channel_send_md = s.verbose_trace_md_formatter("outport_direction", fu_in_channel_send_data) + + tile_outports_data = [ x.msg.__dict__ for x in s.send_data ] + tile_outports_md = s.verbose_trace_md_formatter("outport_direction", tile_outports_data) return (f'\n## class: {s.__class__.__name__}\n' - f'- tile_inports:\n' + f'- tile_inports:' f'{recv_md}\n' f'===>\n' f'- routing_crossbar:\n' @@ -282,20 +252,21 @@ def verbose_trace( s, verbosity = 1 ): f'- fu_crossbar:\n' f'{fu_crossbar_str}\n' f'- element:\n' - f'{s.element.line_trace()}\n' - f'- tile_out_channels_recv:\n' + f'{s.element.verbose_trace(verbosity = verbosity)}\n' + f'- tile_out_channels_recv:' f'{tile_out_channel_recv_md}\n' f'===>\n' - f'- tile_out_channel_send:\n' + f'- tile_out_channel_send:' f'{tile_out_channel_send_md}\n' - f'- fu_in_channels_recv:\n' + f'- fu_in_channels_recv:' f'{fu_in_channel_recv_md}\n' f'===>\n' - f'- fu_in_channels_send:\n' + f'- fu_in_channels_send:' f'{fu_in_channel_send_md}\n' f'===>\n' - f'- tile_outports:\n' + f'- tile_outports:' f'{tile_outports_md}\n') + # Line trace def line_trace( s ): recv_str = "|".join([str(x.msg) for x in s.recv_data]) diff --git a/tile/test/TileSeparateCrossbarRTL_test.py b/tile/test/TileSeparateCrossbarRTL_test.py index 6ee012b..f860d52 100644 --- a/tile/test/TileSeparateCrossbarRTL_test.py +++ b/tile/test/TileSeparateCrossbarRTL_test.py @@ -81,6 +81,7 @@ def done(s): return True def line_trace(s): + # return s.dut.verbose_trace(verbosity = 2) return s.dut.line_trace() def test_tile_alu(cmdline_opts): From 898e594716e4151eaf8788ec178122d83194bb6d Mon Sep 17 00:00:00 2001 From: yuqisun Date: Thu, 26 Dec 2024 23:50:55 +0800 Subject: [PATCH 37/45] enable the verbosity for https://github.com/tancheng/VectorCGRA/blob/master/scale_out/RingMultiCgraRingCtrlMemRTL.py & https://github.com/tancheng/VectorCGRA/blob/master/systolic/CgraMemRightAndBottomRTL.py --- cgra/CgraCrossbarDataMemRingCtrlMemRTL.py | 13 +++++++++++++ scale_out/RingMultiCgraRingCtrlMemRTL.py | 7 +++++++ scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py | 1 + systolic/CgraMemRightAndBottomRTL.py | 11 ++++++++++- .../CgraMemRightAndBottomRTL_matmul_2x2_test.py | 1 + 5 files changed, 32 insertions(+), 1 deletion(-) diff --git a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py index ab7df25..1d724be 100644 --- a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py +++ b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py @@ -182,6 +182,19 @@ def construct(s, DataType, PredicateType, CtrlPktType, CtrlSignalType, s.tile[i].to_mem_waddr.rdy //= 0 s.tile[i].to_mem_wdata.rdy //= 0 + + def verbose_trace( self, verbosity = 1 ): + res = '' + for (i, x) in enumerate(self.tile): + # todo + # CtrlMemDynamicRTL verbose_trace + res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.line_trace() + '\n' + # todo + # no verbose_trace for DataMemWithCrossbarRTL yet + res += f"data_mem: {self.data_mem.line_trace()}" + res += "------\n\n" + return res + # Line trace def line_trace( s ): # str = "||".join([ x.element.line_trace() for x in s.tile ]) diff --git a/scale_out/RingMultiCgraRingCtrlMemRTL.py b/scale_out/RingMultiCgraRingCtrlMemRTL.py index 9dc243c..2586e45 100644 --- a/scale_out/RingMultiCgraRingCtrlMemRTL.py +++ b/scale_out/RingMultiCgraRingCtrlMemRTL.py @@ -98,6 +98,13 @@ def construct(s, CGRADataType, PredicateType, CtrlPktType, s.cgra[cgra_row * cgra_columns + cgra_col].recv_data_on_boundary_east[tile_row].en //= 0 s.cgra[cgra_row * cgra_columns + cgra_col].recv_data_on_boundary_east[tile_row].msg //= CGRADataType() + def verbose_trace( self, verbosity = 1 ): + res = '' + for (i, x) in enumerate(self.cgra): + res += "# [cgra" + str(i) + "]:\n" + x.verbose_trace(verbosity = verbosity) + '\n' + res += f"## ring: {self.ring.line_trace()}" + return res + def line_trace(s): res = "||\n".join([(("[cgra["+str(i)+"]: ") + x.line_trace()) for (i,x) in enumerate(s.cgra)]) diff --git a/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py b/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py index ea2a223..47dcd7e 100644 --- a/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py +++ b/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py @@ -81,6 +81,7 @@ def done(s): # return True def line_trace(s): + # return s.dut.verbose_trace(verbosity = 2) return s.dut.line_trace() def test_homo_2x2(cmdline_opts): diff --git a/systolic/CgraMemRightAndBottomRTL.py b/systolic/CgraMemRightAndBottomRTL.py index f96550f..b5127ff 100644 --- a/systolic/CgraMemRightAndBottomRTL.py +++ b/systolic/CgraMemRightAndBottomRTL.py @@ -123,8 +123,17 @@ def construct(s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_waddr.rdy //= 0 s.tile[i].to_mem_wdata.rdy //= 0 + def verbose_trace( s, verbosity = 1 ): + res = '' + for (i, x) in enumerate(s.tile): + res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' + res += f"# SouthMem: {s.data_mem_south.verbose_trace(verbosity = verbosity)}" + res += f"# EastMem: {s.data_mem_east.verbose_trace(verbosity = verbosity)}" + res += "------\n\n" + return res + # Line trace - def line_trace(s): + def line_trace( s ): # str = "||".join([ x.element.line_trace() for x in s.tile ]) # str += " :: [" + s.data_mem.line_trace() + "]" res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) diff --git a/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py b/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py index 02dfb58..438e2ff 100644 --- a/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py +++ b/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py @@ -80,6 +80,7 @@ def check_parity(s): return True def line_trace(s): + # return s.dut.verbose_trace(verbosity = 2) return s.dut.line_trace() def run_sim(test_harness, enable_verification_pymtl, From 57dfc349167063a4d907e950fdf34a24c45ead1e Mon Sep 17 00:00:00 2001 From: yuqisun Date: Fri, 27 Dec 2024 16:08:40 +0800 Subject: [PATCH 38/45] 1. TILE_PORT_DIRECTION_DICT -> TILE_PORT_DIRECTION_DICT_DESC 2. recv_ctrl_msg_list = [ recv_ctrl_sub_header, recv_ctrl_msg_dict ] -> recv_ctrl_msg_list = [recv_ctrl_sub_header, recv_ctrl_msg_dict] 3. put line_trace() before verbose() --- cgra/CGRAKingMeshRTL.py | 19 ++++--- fu/flexible/FlexibleFuRTL.py | 16 +++--- lib/util/common.py | 2 +- mem/ctrl/CtrlMemRTL.py | 18 +++--- mem/data/DataMemRTL.py | 83 ++++++++++++++-------------- systolic/CgraMemRightAndBottomRTL.py | 19 ++++--- tile/TileRTL.py | 24 ++++---- tile/TileSeparateCrossbarRTL.py | 27 ++++----- 8 files changed, 103 insertions(+), 105 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index aacb4f8..9c955ca 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -149,15 +149,6 @@ def construct( s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_waddr.rdy //= 0 s.tile[i].to_mem_wdata.rdy //= 0 - # verbose trace - def verbose_trace( s, verbosity = 1 ): - res = '' - for (i, x) in enumerate(s.tile): - res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' - res += f"data_mem: {s.data_mem.verbose_trace(verbosity = verbosity)}" - res += "------\n\n" - return res - # Line trace def line_trace( s ): # str = "||".join([ x.element.line_trace() for x in s.tile ]) @@ -166,3 +157,13 @@ def line_trace( s ): for (i, x) in enumerate(s.tile)]) res += "\n :: [" + s.data_mem.line_trace() + "] \n" return res + + # verbose trace + def verbose_trace( s, verbosity = 1 ): + res = '' + for (i, x) in enumerate(s.tile): + res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace( + verbosity = verbosity) + '\n' + res += f"data_mem: {s.data_mem.verbose_trace(verbosity = verbosity)}" + res += "------\n\n" + return res diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index b83fc04..549be28 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -109,6 +109,14 @@ def comb_logic(): s.fu_recv_in_rdy_vector[port][i] @= s.fu[i].recv_in[port].rdy s.recv_in[port].rdy @= reduce_or( s.fu_recv_in_rdy_vector[port] ) + def line_trace( s ): + opt_str = " #" + if s.recv_opt.en: + opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] + out_str = ",".join([str(x.msg) for x in s.send_out]) + recv_str = ",".join([str(x.msg) for x in s.recv_in]) + return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + def verbose_trace_md_formatter( self, data_type, data ): assert data_type in [ "recv", "send" ] @@ -145,11 +153,3 @@ def verbose_trace( s, verbosity = 1 ): f'===>\n' f'- FU out:' f'{send_md}') - - def line_trace( s ): - opt_str = " #" - if s.recv_opt.en: - opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - out_str = ",".join([str(x.msg) for x in s.send_out]) - recv_str = ",".join([str(x.msg) for x in s.recv_in]) - return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' diff --git a/lib/util/common.py b/lib/util/common.py index d512a53..26af6ab 100644 --- a/lib/util/common.py +++ b/lib/util/common.py @@ -22,7 +22,7 @@ LINK_FROM_MEM = 1 LINK_TO_MEM = 2 -TILE_PORT_DIRECTION_DICT = { +TILE_PORT_DIRECTION_DICT_DESC = { PORT_NORTH: "NORTH", PORT_SOUTH: "SOUTH", PORT_WEST: "WEST", diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 71bbd18..2e102ff 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -72,6 +72,11 @@ def update_raddr(): else: s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) + def line_trace( s ): + out_str = "||".join([str(data) for data in s.reg_file.regs]) + return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' + + def verbose_trace_normal_processor( self, data_dict ): data_dict['ctrl'] = OPT_SYMBOL_DICT[ data_dict['ctrl'] ] if 'predicate' in data_dict: @@ -154,13 +159,13 @@ def verbose_trace( s, verbosity = 1 ): # recv_ctrl recv_ctrl_msg_dict = dict(s.recv_ctrl.msg.__dict__) recv_ctrl_sub_header = s.verbose_trace_data_processor(recv_ctrl_msg_dict, num_direction_ports) - recv_ctrl_msg_list = [ recv_ctrl_sub_header, recv_ctrl_msg_dict ] + recv_ctrl_msg_list = [recv_ctrl_sub_header, recv_ctrl_msg_dict] recv_ctrl_md = markdown_table(recv_ctrl_msg_list).set_params(quote=False).get_markdown() # send_ctrl send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) send_ctrl_sub_header = s.verbose_trace_data_processor(send_ctrl_msg_dict, num_direction_ports) - send_ctrl_msg_list = [ send_ctrl_sub_header, send_ctrl_msg_dict ] + send_ctrl_msg_list = [send_ctrl_sub_header, send_ctrl_msg_dict] send_ctrl_md = markdown_table(send_ctrl_msg_list).set_params(quote=False).get_markdown() if verbosity == 1: @@ -182,11 +187,4 @@ def verbose_trace( s, verbosity = 1 ): f'{recv_ctrl_md}\n\n' f'- send_ctrl_msg:' f'{send_ctrl_md}\n\n' - f'- ctrl_memory: {reg_md}\n') - - - def line_trace( s ): - out_str = "||".join([str(data) for data in s.reg_file.regs]) - return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' - - + f'- ctrl_memory: {reg_md}\n') \ No newline at end of file diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index bcd2ad7..f5e598a 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -97,49 +97,6 @@ def update_signal(): s.recv_waddr[i].rdy @= Bits1( 1 ) s.recv_wdata[i].rdy @= Bits1( 1 ) - - # verbose trace - def verbose_trace( s, verbosity = 1 ): - # data memory: mem size, reg - # recv_raddr(rdy, msg), send_rdata(en, msg), recv_waddr(rdy, msg), recv_wdata, tile # - reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] - reg_list = [] - for idx, data in enumerate(reg_dicts): - reg_dict = {"addr": f"addr {idx}"} - reg_dict.update(data) - reg_list.append(reg_dict) - reg_md = markdown_table(reg_list).set_params(quote=False).get_markdown() - - rw_ports_max_count = max(len(s.recv_raddr), len(s.recv_waddr)) - mem_list = [] - for idx in range(rw_ports_max_count): - recv_raddr_rdy, recv_raddr = None, None - send_rdata_en, send_rdata = None, None - recv_waddr_rdy, recv_waddr = None, None - recv_wdata = None - if idx <= len(s.recv_raddr) - 1: - recv_raddr_rdy = s.recv_raddr[idx].rdy - recv_raddr = s.recv_raddr[idx].msg - send_rdata_en = s.send_rdata[idx].en - send_rdata = s.send_rdata[idx].msg.payload - if idx <= len(s.recv_waddr) - 1: - recv_waddr_rdy = s.recv_waddr[idx].rdy - recv_waddr = s.recv_waddr[idx].msg - recv_wdata = s.recv_wdata[idx].msg.payload - mem_dict = {"recv_raddr(rdy, msg)": f"{recv_raddr_rdy}, {recv_raddr}", - "send_rdata(en, msg)": f"{send_rdata_en}, {send_rdata}", - "recv_waddr(rdy, msg)": f"{recv_waddr_rdy}, {recv_waddr}", - "recv_wdata": f"{recv_wdata}", - "Tiles in Col0": "<--- Tile"} - mem_list.append(mem_dict) - mem_md = markdown_table(mem_list).set_params(quote=False).get_markdown() - - return (f'\nclass: {s.__class__.__name__}\n' - f'- regs(mem size: {len(reg_dicts)}): {reg_md}\n' - f'- mem_r/w:' - f'{mem_md}') - - def line_trace( s ): recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) @@ -153,3 +110,43 @@ def line_trace( s ): # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' + # verbose trace + def verbose_trace( s, verbosity = 1 ): + # data memory: mem size, reg + # recv_raddr(rdy, msg), send_rdata(en, msg), recv_waddr(rdy, msg), recv_wdata, tile # + reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] + reg_list = [] + for idx, data in enumerate(reg_dicts): + reg_dict = { "addr": f"addr {idx}" } + reg_dict.update(data) + reg_list.append(reg_dict) + reg_md = markdown_table(reg_list).set_params(quote = False).get_markdown() + + rw_ports_max_count = max(len(s.recv_raddr), len(s.recv_waddr)) + mem_list = [] + for idx in range(rw_ports_max_count): + recv_raddr_rdy, recv_raddr = None, None + send_rdata_en, send_rdata = None, None + recv_waddr_rdy, recv_waddr = None, None + recv_wdata = None + if idx <= len(s.recv_raddr) - 1: + recv_raddr_rdy = s.recv_raddr[idx].rdy + recv_raddr = s.recv_raddr[idx].msg + send_rdata_en = s.send_rdata[idx].en + send_rdata = s.send_rdata[idx].msg.payload + if idx <= len(s.recv_waddr) - 1: + recv_waddr_rdy = s.recv_waddr[idx].rdy + recv_waddr = s.recv_waddr[idx].msg + recv_wdata = s.recv_wdata[idx].msg.payload + mem_dict = { "recv_raddr(rdy, msg)": f"{recv_raddr_rdy}, {recv_raddr}", + "send_rdata(en, msg)": f"{send_rdata_en}, {send_rdata}", + "recv_waddr(rdy, msg)": f"{recv_waddr_rdy}, {recv_waddr}", + "recv_wdata": f"{recv_wdata}", + "Tiles in Col0": "<--- Tile" } + mem_list.append(mem_dict) + mem_md = markdown_table(mem_list).set_params(quote = False).get_markdown() + + return (f'\nclass: {s.__class__.__name__}\n' + f'- regs(mem size: {len(reg_dicts)}): {reg_md}\n' + f'- mem_r/w:' + f'{mem_md}') diff --git a/systolic/CgraMemRightAndBottomRTL.py b/systolic/CgraMemRightAndBottomRTL.py index b5127ff..7b342f8 100644 --- a/systolic/CgraMemRightAndBottomRTL.py +++ b/systolic/CgraMemRightAndBottomRTL.py @@ -123,15 +123,6 @@ def construct(s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_waddr.rdy //= 0 s.tile[i].to_mem_wdata.rdy //= 0 - def verbose_trace( s, verbosity = 1 ): - res = '' - for (i, x) in enumerate(s.tile): - res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' - res += f"# SouthMem: {s.data_mem_south.verbose_trace(verbosity = verbosity)}" - res += f"# EastMem: {s.data_mem_east.verbose_trace(verbosity = verbosity)}" - res += "------\n\n" - return res - # Line trace def line_trace( s ): # str = "||".join([ x.element.line_trace() for x in s.tile ]) @@ -141,3 +132,13 @@ def line_trace( s ): res += "\n :: SouthMem [" + s.data_mem_south.line_trace() + "] \n" res += "\n :: EastMem [" + s.data_mem_east.line_trace() + "] \n" return res + + + def verbose_trace( s, verbosity = 1 ): + res = '' + for (i, x) in enumerate(s.tile): + res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' + res += f"# SouthMem: {s.data_mem_south.verbose_trace(verbosity = verbosity)}" + res += f"# EastMem: {s.data_mem_east.verbose_trace(verbosity = verbosity)}" + res += "------\n\n" + return res diff --git a/tile/TileRTL.py b/tile/TileRTL.py index d2a2c1d..95f5f66 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -17,7 +17,7 @@ from ..fu.single.MulRTL import MulRTL from ..fu.single.PhiRTL import PhiRTL from ..lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL -from ..lib.util.common import TILE_PORT_DIRECTION_DICT +from ..lib.util.common import TILE_PORT_DIRECTION_DICT_DESC from ..mem.const.ConstQueueRTL import ConstQueueRTL from ..mem.ctrl.CtrlMemRTL import CtrlMemRTL from ..noc.ChannelRTL import ChannelRTL @@ -125,6 +125,15 @@ def update_opt(): s.crossbar.recv_opt.en @= s.ctrl_mem.send_ctrl.en s.ctrl_mem.send_ctrl.rdy @= s.element.recv_opt.rdy & s.crossbar.recv_opt.rdy + # Line trace + def line_trace( s ): + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + channel_recv_str = "|".join([str(x.recv.msg) for x in s.channel]) + channel_send_str = "|".join([str(x.send.msg) for x in s.channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + + def verbose_trace_md_formatter( self, data_type, data ): assert data_type in [ "recv", "send" ] data_list = [ x for x in data ] @@ -132,9 +141,9 @@ def verbose_trace_md_formatter( self, data_type, data ): for idx, port_data in enumerate(data_list): msg_dict = port_data.msg.__dict__ if data_type is "recv": - tile_port_dict = { "tile_inport_direction": TILE_PORT_DIRECTION_DICT[idx], "rdy": port_data.rdy } + tile_port_dict = { "tile_inport_direction": TILE_PORT_DIRECTION_DICT_DESC[idx], "rdy": port_data.rdy } else: - tile_port_dict = { "tile_outport_direction": TILE_PORT_DIRECTION_DICT[idx], "en": port_data.en } + tile_port_dict = { "tile_outport_direction": TILE_PORT_DIRECTION_DICT_DESC[idx], "en": port_data.en } tile_port_dict.update(msg_dict) result_list.append(tile_port_dict) result_md = markdown_table(result_list).set_params(quote = False).get_markdown() @@ -160,12 +169,3 @@ def verbose_trace( s, verbosity = 1 ): f"===>\n" f"- Tile out:" f"{send_md}\n") - - # Line trace - def line_trace( s ): - recv_str = "|".join([str(x.msg) for x in s.recv_data]) - channel_recv_str = "|".join([str(x.recv.msg) for x in s.channel]) - channel_send_str = "|".join([str(x.send.msg) for x in s.channel]) - out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) - return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" - diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index b91dfc3..6b89174 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -26,7 +26,7 @@ from ..lib.basic.en_rdy.ifcs import SendIfcRTL, RecvIfcRTL from ..lib.basic.val_rdy.ifcs import ValRdyRecvIfcRTL from ..lib.opt_type import OPT_SYMBOL_DICT -from ..lib.util.common import TILE_PORT_DIRECTION_DICT +from ..lib.util.common import TILE_PORT_DIRECTION_DICT_DESC from ..mem.const.ConstQueueRTL import ConstQueueRTL from ..mem.ctrl.CtrlMemDynamicRTL import CtrlMemDynamicRTL from ..noc.ChannelNormalRTL import ChannelNormalRTL @@ -197,6 +197,18 @@ def update_opt(): s.routing_crossbar.recv_opt.rdy & \ s.fu_crossbar.recv_opt.rdy + # Line trace + def line_trace( s ): + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) + tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) + fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) + fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " + # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + + def verbose_trace_str_formatter( self, crossbar_dict ): crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[crossbar_dict['ctrl']] crossbar_dict['predicate'] = int(crossbar_dict['predicate']) @@ -210,7 +222,7 @@ def verbose_trace_str_formatter( self, crossbar_dict ): def verbose_trace_md_formatter( self, header_str, data_dict ): result_list = [] for idx, data in enumerate(data_dict): - port_direction = TILE_PORT_DIRECTION_DICT[idx] + port_direction = TILE_PORT_DIRECTION_DICT_DESC[idx] dict_with_direction = { header_str: port_direction } dict_with_direction.update(data) result_list.append(dict_with_direction) @@ -266,14 +278,3 @@ def verbose_trace( s, verbosity = 1 ): f'===>\n' f'- tile_outports:' f'{tile_outports_md}\n') - - # Line trace - def line_trace( s ): - recv_str = "|".join([str(x.msg) for x in s.recv_data]) - tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) - tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) - fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) - fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) - out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) - return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " - # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" From f88c8f40f32b6548507487b2048123cff08e73f3 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Fri, 27 Dec 2024 16:11:06 +0800 Subject: [PATCH 39/45] put line_trace() before verbose() --- cgra/CgraCrossbarDataMemRingCtrlMemRTL.py | 19 +++++++++---------- scale_out/RingMultiCgraRingCtrlMemRTL.py | 14 +++++++------- 2 files changed, 16 insertions(+), 17 deletions(-) diff --git a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py index 1d724be..47a867d 100644 --- a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py +++ b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py @@ -182,6 +182,15 @@ def construct(s, DataType, PredicateType, CtrlPktType, CtrlSignalType, s.tile[i].to_mem_waddr.rdy //= 0 s.tile[i].to_mem_wdata.rdy //= 0 + # Line trace + def line_trace( s ): + # str = "||".join([ x.element.line_trace() for x in s.tile ]) + # str += " :: [" + s.data_mem.line_trace() + "]" + res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + for (i,x) in enumerate(s.tile) ]) + res += "\n :: [" + s.data_mem.line_trace() + "] \n" + return res + def verbose_trace( self, verbosity = 1 ): res = '' @@ -194,13 +203,3 @@ def verbose_trace( self, verbosity = 1 ): res += f"data_mem: {self.data_mem.line_trace()}" res += "------\n\n" return res - - # Line trace - def line_trace( s ): - # str = "||".join([ x.element.line_trace() for x in s.tile ]) - # str += " :: [" + s.data_mem.line_trace() + "]" - res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - for (i,x) in enumerate(s.tile) ]) - res += "\n :: [" + s.data_mem.line_trace() + "] \n" - return res - diff --git a/scale_out/RingMultiCgraRingCtrlMemRTL.py b/scale_out/RingMultiCgraRingCtrlMemRTL.py index 2586e45..efdb27d 100644 --- a/scale_out/RingMultiCgraRingCtrlMemRTL.py +++ b/scale_out/RingMultiCgraRingCtrlMemRTL.py @@ -98,16 +98,16 @@ def construct(s, CGRADataType, PredicateType, CtrlPktType, s.cgra[cgra_row * cgra_columns + cgra_col].recv_data_on_boundary_east[tile_row].en //= 0 s.cgra[cgra_row * cgra_columns + cgra_col].recv_data_on_boundary_east[tile_row].msg //= CGRADataType() - def verbose_trace( self, verbosity = 1 ): - res = '' - for (i, x) in enumerate(self.cgra): - res += "# [cgra" + str(i) + "]:\n" + x.verbose_trace(verbosity = verbosity) + '\n' - res += f"## ring: {self.ring.line_trace()}" - return res - def line_trace(s): res = "||\n".join([(("[cgra["+str(i)+"]: ") + x.line_trace()) for (i,x) in enumerate(s.cgra)]) res += " ## ring: " + s.ring.line_trace() return res + + def verbose_trace( self, verbosity = 1 ): + res = '' + for (i, x) in enumerate(self.cgra): + res += "# [cgra" + str(i) + "]:\n" + x.verbose_trace(verbosity = verbosity) + '\n' + res += f"## ring: {self.ring.line_trace()}" + return res From 8f9ecd8f526a6486437d1d23d410071024f962a7 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Fri, 27 Dec 2024 23:12:46 +0800 Subject: [PATCH 40/45] Add verbose trace for CtrlMemDynamicRTL.py --- cgra/CgraCrossbarDataMemRingCtrlMemRTL.py | 4 +- mem/ctrl/CtrlMemDynamicRTL.py | 122 +++++++++++++++++++++- 2 files changed, 121 insertions(+), 5 deletions(-) diff --git a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py index 47a867d..462f20d 100644 --- a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py +++ b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py @@ -195,9 +195,7 @@ def line_trace( s ): def verbose_trace( self, verbosity = 1 ): res = '' for (i, x) in enumerate(self.tile): - # todo - # CtrlMemDynamicRTL verbose_trace - res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.line_trace() + '\n' + res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' # todo # no verbose_trace for DataMemWithCrossbarRTL yet res += f"data_mem: {self.data_mem.line_trace()}" diff --git a/mem/ctrl/CtrlMemDynamicRTL.py b/mem/ctrl/CtrlMemDynamicRTL.py index 9a96fa1..167a055 100644 --- a/mem/ctrl/CtrlMemDynamicRTL.py +++ b/mem/ctrl/CtrlMemDynamicRTL.py @@ -8,14 +8,16 @@ Author : Cheng Tan Date : Dec 20, 2024 """ - -from pymtl3 import * +from py_markdown_table.markdown_table import markdown_table from pymtl3.stdlib.primitive import RegisterFile + from ...lib.basic.en_rdy.ifcs import SendIfcRTL from ...lib.basic.val_rdy.ifcs import ValRdyRecvIfcRTL from ...lib.basic.val_rdy.queues import NormalQueueRTL from ...lib.cmd_type import * from ...lib.opt_type import * +from ...lib.util.common import TILE_PORT_DIRECTION_DICT_SHORT_DESC + class CtrlMemDynamicRTL(Component): @@ -140,3 +142,119 @@ def line_trace(s): config_mem_str = "|".join([str(data) for data in s.reg_file.regs]) return f'{s.recv_pkt.msg} || config_mem: [{config_mem_str}] || out: {s.send_ctrl.msg}' + + def verbose_trace_normal_processor( self, data_dict ): + if 'ctrl_operation' in data_dict: + data_dict['ctrl_operation'] = OPT_SYMBOL_DICT[ data_dict['ctrl_operation'] ] + if 'ctrl' in data_dict: + data_dict['ctrl'] = OPT_SYMBOL_DICT[ data_dict['ctrl'] ] + + def verbose_trace_fu_in_processor( self, data_dict, sub_header, key_prefix = None ): + fu_in_key = 'fu_in' + if key_prefix: + fu_in_key = key_prefix + fu_in_key + data_dict[fu_in_key] = [ int(fi) for fi in data_dict[fu_in_key] ] + fu_in_header = [] + for idx, val in enumerate(data_dict[fu_in_key]): + fu_in_header.append(idx) + fu_in_header_str = "|".join([ f"{hd : ^3}" for hd in fu_in_header ]) + data_dict[fu_in_key] = "|".join([ f"{v : ^3}" for v in data_dict[fu_in_key] ]) + sub_header[fu_in_key] = fu_in_header_str + + # outport: fu_xbar_outport, routing_xbar_outport + def verbose_trace_outport_processor( self, data_dict, sub_header, num_direction_ports, outport_key, key_prefix = None ): + if key_prefix: + outport_key = key_prefix + outport_key + if outport_key in data_dict: + data_dict[outport_key] = [ int(op) for op in data_dict[outport_key] ] + fu_reg_num = 1 + outport_sub_header = [] + for idx, val in enumerate(data_dict[outport_key]): + # to directions + if idx <= num_direction_ports - 1: + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] + outport_sub_header.append(f"{hd : ^{len(hd) + 2}}") + data_dict[outport_key][idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd) + 2}}" + # to fu regs + else: + hd = f"fu_reg_{fu_reg_num}" + outport_sub_header.append(f"{hd : ^{len(hd)}}") + data_dict[outport_key][idx] = f"{TILE_PORT_DIRECTION_DICT_SHORT_DESC[val - 1] if val != 0 else '-' : ^{len(hd)}}" + fu_reg_num += 1 + outport_sub_header_str = "|".join([ hd for hd in outport_sub_header ]) + data_dict[outport_key] = "|".join([ v for v in data_dict[outport_key] ]) + sub_header[outport_key] = outport_sub_header_str + + def verbose_trace_predicate_in_processor( self, data_dict, sub_header, num_direction_ports, key_prefix = None ): + predicate_in_key = 'routing_predicate_in' + if key_prefix: + predicate_in_key = key_prefix + predicate_in_key + if predicate_in_key in data_dict: + data_dict[predicate_in_key] = [ int(pi) for pi in data_dict[predicate_in_key] ] + fu_out_num = 1 + predicate_in_sub_header = [] + for idx, val in enumerate(data_dict[predicate_in_key]): + # from directions + if idx <= num_direction_ports - 1: + hd = TILE_PORT_DIRECTION_DICT_SHORT_DESC[idx] + predicate_in_sub_header.append(f"{hd : ^{len(hd) + 2}}") + data_dict[predicate_in_key][idx] = f"{val : ^{len(hd) + 2}}" + # from fu + else: + hd = f"fu_out_{fu_out_num}" + predicate_in_sub_header.append(f"{hd : ^{len(hd)}}") + data_dict[predicate_in_key][idx] = f"{val : ^{len(hd)}}" + fu_out_num += 1 + predicate_in_sub_header_str = "|".join([ hd for hd in predicate_in_sub_header ]) + data_dict[predicate_in_key] = "|".join([ v for v in data_dict[predicate_in_key] ]) + sub_header[predicate_in_key] = predicate_in_sub_header_str + + def verbose_trace_data_processor( self, data_dict, num_direction_ports, key_prefix = None ): + sub_header = {} + for key in data_dict.keys(): + sub_header[key] = '' + self.verbose_trace_normal_processor(data_dict) + self.verbose_trace_fu_in_processor(data_dict, sub_header, key_prefix) + self.verbose_trace_outport_processor(data_dict, sub_header, num_direction_ports, 'fu_xbar_outport', key_prefix) + self.verbose_trace_outport_processor(data_dict, sub_header, num_direction_ports, 'routing_xbar_outport', key_prefix) + self.verbose_trace_predicate_in_processor(data_dict, sub_header, num_direction_ports, key_prefix) + return sub_header + + # verbose trace + def verbose_trace( s, verbosity = 1 ): + num_routing_outports = len(s.reg_file.wdata[0].routing_xbar_outport) + num_fu_inports = len(s.reg_file.wdata[0].fu_in) + num_tile_outports = num_routing_outports - num_fu_inports + + # recv_ctrl + recv_pkt_msg_dict = dict(s.recv_pkt.msg.__dict__) + recv_pkt_msg_header = s.verbose_trace_data_processor(recv_pkt_msg_dict, num_tile_outports, key_prefix = 'ctrl_') + recv_pkt_msg_list = [recv_pkt_msg_header, recv_pkt_msg_dict] + recv_pkt_msg_md = markdown_table(recv_pkt_msg_list).set_params(quote = False).get_markdown() + + # send_ctrl + send_ctrl_msg_dict = dict(s.send_ctrl.msg.__dict__) + send_ctrl_sub_header = s.verbose_trace_data_processor(send_ctrl_msg_dict, num_tile_outports) + send_ctrl_msg_list = [send_ctrl_sub_header, send_ctrl_msg_dict] + send_ctrl_msg_md = markdown_table(send_ctrl_msg_list).set_params(quote = False).get_markdown() + + if verbosity == 1: + return (f'\n## class: {s.__class__.__name__}\n' + f'- recv_pkt_msg:' + f'{recv_pkt_msg_md}\n\n' + f'- send_ctrl_msg:' + f'{send_ctrl_msg_md}\n\n') + else: + # reg + reg_dicts = [ dict(data.__dict__) for data in s.reg_file.regs ] + reg_sub_header = {} + for reg_dict in reg_dicts: + reg_sub_header = s.verbose_trace_data_processor(reg_dict, num_tile_outports) + reg_dicts.insert(0, reg_sub_header) + reg_md = markdown_table(reg_dicts).set_params(quote=False).get_markdown() + return (f'\n## class: {s.__class__.__name__}\n' + f'- recv_pkt_msg:' + f'{recv_pkt_msg_md}\n\n' + f'- send_ctrl_msg:' + f'{send_ctrl_msg_md}\n\n' + f'- config_memory: {reg_md}\n') \ No newline at end of file From f702763cc35f20682a016b74bd7a4f05664484a2 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Sat, 28 Dec 2024 20:45:22 +0800 Subject: [PATCH 41/45] Remove the unnecessary space. --- cgra/CGRAKingMeshRTL.py | 18 ++--- cgra/CgraCrossbarDataMemRingCtrlMemRTL.py | 2 +- fu/flexible/FlexibleFuRTL.py | 4 +- mem/ctrl/CtrlMemDynamicRTL.py | 12 ++-- mem/ctrl/CtrlMemRTL.py | 12 ++-- mem/data/DataMemRTL.py | 80 +++++++++++------------ scale_out/RingMultiCgraRingCtrlMemRTL.py | 2 +- systolic/CgraMemRightAndBottomRTL.py | 2 +- tile/TileRTL.py | 4 +- tile/TileSeparateCrossbarRTL.py | 6 +- 10 files changed, 71 insertions(+), 71 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index 9c955ca..6db59fc 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -158,12 +158,12 @@ def line_trace( s ): res += "\n :: [" + s.data_mem.line_trace() + "] \n" return res - # verbose trace - def verbose_trace( s, verbosity = 1 ): - res = '' - for (i, x) in enumerate(s.tile): - res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace( - verbosity = verbosity) + '\n' - res += f"data_mem: {s.data_mem.verbose_trace(verbosity = verbosity)}" - res += "------\n\n" - return res + # verbose trace + def verbose_trace(s, verbosity = 1): + res = '' + for (i, x) in enumerate(s.tile): + res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace( + verbosity = verbosity) + '\n' + res += f"data_mem: {s.data_mem.verbose_trace(verbosity = verbosity)}" + res += "------\n\n" + return res diff --git a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py index 462f20d..391036f 100644 --- a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py +++ b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py @@ -192,7 +192,7 @@ def line_trace( s ): return res - def verbose_trace( self, verbosity = 1 ): + def verbose_trace(self, verbosity = 1): res = '' for (i, x) in enumerate(self.tile): res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 549be28..1d0cc05 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -118,7 +118,7 @@ def line_trace( s ): return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' - def verbose_trace_md_formatter( self, data_type, data ): + def verbose_trace_md_formatter(self, data_type, data): assert data_type in [ "recv", "send" ] data_list = [ x for x in data ] result_list = [] @@ -134,7 +134,7 @@ def verbose_trace_md_formatter( self, data_type, data ): return result_md # verbose trace if verbosity > 0 - def verbose_trace( s, verbosity = 1 ): + def verbose_trace(s, verbosity = 1): # for clk n # recv: # 1. OPT: opt+rdy(if ready to receive opt) diff --git a/mem/ctrl/CtrlMemDynamicRTL.py b/mem/ctrl/CtrlMemDynamicRTL.py index 167a055..184a2db 100644 --- a/mem/ctrl/CtrlMemDynamicRTL.py +++ b/mem/ctrl/CtrlMemDynamicRTL.py @@ -143,13 +143,13 @@ def line_trace(s): return f'{s.recv_pkt.msg} || config_mem: [{config_mem_str}] || out: {s.send_ctrl.msg}' - def verbose_trace_normal_processor( self, data_dict ): + def verbose_trace_normal_processor(self, data_dict): if 'ctrl_operation' in data_dict: data_dict['ctrl_operation'] = OPT_SYMBOL_DICT[ data_dict['ctrl_operation'] ] if 'ctrl' in data_dict: data_dict['ctrl'] = OPT_SYMBOL_DICT[ data_dict['ctrl'] ] - def verbose_trace_fu_in_processor( self, data_dict, sub_header, key_prefix = None ): + def verbose_trace_fu_in_processor(self, data_dict, sub_header, key_prefix = None): fu_in_key = 'fu_in' if key_prefix: fu_in_key = key_prefix + fu_in_key @@ -162,7 +162,7 @@ def verbose_trace_fu_in_processor( self, data_dict, sub_header, key_prefix = Non sub_header[fu_in_key] = fu_in_header_str # outport: fu_xbar_outport, routing_xbar_outport - def verbose_trace_outport_processor( self, data_dict, sub_header, num_direction_ports, outport_key, key_prefix = None ): + def verbose_trace_outport_processor(self, data_dict, sub_header, num_direction_ports, outport_key, key_prefix = None): if key_prefix: outport_key = key_prefix + outport_key if outport_key in data_dict: @@ -185,7 +185,7 @@ def verbose_trace_outport_processor( self, data_dict, sub_header, num_direction_ data_dict[outport_key] = "|".join([ v for v in data_dict[outport_key] ]) sub_header[outport_key] = outport_sub_header_str - def verbose_trace_predicate_in_processor( self, data_dict, sub_header, num_direction_ports, key_prefix = None ): + def verbose_trace_predicate_in_processor(self, data_dict, sub_header, num_direction_ports, key_prefix = None): predicate_in_key = 'routing_predicate_in' if key_prefix: predicate_in_key = key_prefix + predicate_in_key @@ -209,7 +209,7 @@ def verbose_trace_predicate_in_processor( self, data_dict, sub_header, num_direc data_dict[predicate_in_key] = "|".join([ v for v in data_dict[predicate_in_key] ]) sub_header[predicate_in_key] = predicate_in_sub_header_str - def verbose_trace_data_processor( self, data_dict, num_direction_ports, key_prefix = None ): + def verbose_trace_data_processor(self, data_dict, num_direction_ports, key_prefix = None): sub_header = {} for key in data_dict.keys(): sub_header[key] = '' @@ -221,7 +221,7 @@ def verbose_trace_data_processor( self, data_dict, num_direction_ports, key_pref return sub_header # verbose trace - def verbose_trace( s, verbosity = 1 ): + def verbose_trace(s, verbosity = 1): num_routing_outports = len(s.reg_file.wdata[0].routing_xbar_outport) num_fu_inports = len(s.reg_file.wdata[0].fu_in) num_tile_outports = num_routing_outports - num_fu_inports diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 2e102ff..032c79d 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -77,7 +77,7 @@ def line_trace( s ): return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' - def verbose_trace_normal_processor( self, data_dict ): + def verbose_trace_normal_processor(self, data_dict): data_dict['ctrl'] = OPT_SYMBOL_DICT[ data_dict['ctrl'] ] if 'predicate' in data_dict: data_dict['predicate'] = int(data_dict['predicate']) @@ -88,7 +88,7 @@ def verbose_trace_normal_processor( self, data_dict ): if 'routing_predicate_in' in data_dict: data_dict['routing_predicate_in'] = [ int(rpi) for rpi in data_dict['routing_predicate_in'] ] - def verbose_trace_fu_in_processor( self, data_dict, sub_header ): + def verbose_trace_fu_in_processor(self, data_dict, sub_header): data_dict['fu_in'] = [ int(fi) for fi in data_dict['fu_in'] ] fu_in_header = [] for idx, val in enumerate(data_dict['fu_in']): @@ -97,7 +97,7 @@ def verbose_trace_fu_in_processor( self, data_dict, sub_header ): data_dict['fu_in'] = "|".join([ f"{v : ^3}" for v in data_dict['fu_in'] ]) sub_header['fu_in'] = fu_in_header_str - def verbose_trace_outport_processor( self, data_dict, sub_header, num_direction_ports ): + def verbose_trace_outport_processor(self, data_dict, sub_header, num_direction_ports): if 'outport' in data_dict: data_dict['outport'] = [ int(op) for op in data_dict['outport'] ] fu_reg_num = 1 @@ -118,7 +118,7 @@ def verbose_trace_outport_processor( self, data_dict, sub_header, num_direction_ data_dict['outport'] = "|".join([ v for v in data_dict['outport'] ]) sub_header['outport'] = outport_sub_header_str - def verbose_trace_predicate_in_processor( self, data_dict, sub_header, num_direction_ports ): + def verbose_trace_predicate_in_processor(self, data_dict, sub_header, num_direction_ports): if 'predicate_in' in data_dict: data_dict['predicate_in'] = [ int(pi) for pi in data_dict['predicate_in'] ] fu_out_num = 1 @@ -139,7 +139,7 @@ def verbose_trace_predicate_in_processor( self, data_dict, sub_header, num_direc data_dict['predicate_in'] = "|".join([ v for v in data_dict['predicate_in'] ]) sub_header['predicate_in'] = predicate_in_sub_header_str - def verbose_trace_data_processor( self, data_dict, num_direction_ports ): + def verbose_trace_data_processor(self, data_dict, num_direction_ports): sub_header = {} for key in data_dict.keys(): sub_header[key] = '' @@ -150,7 +150,7 @@ def verbose_trace_data_processor( self, data_dict, num_direction_ports ): return sub_header # verbose trace - def verbose_trace( s, verbosity = 1 ): + def verbose_trace(s, verbosity = 1): num_fu_in = len(s.reg_file.regs[0].fu_in) # num_inports = len(s.reg_file.regs[0].predicate_in) num_outports = len(s.reg_file.regs[0].outport if hasattr(s.reg_file.regs[0], 'outport') else []) diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index f5e598a..485cc08 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -110,43 +110,43 @@ def line_trace( s ): # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' - # verbose trace - def verbose_trace( s, verbosity = 1 ): - # data memory: mem size, reg - # recv_raddr(rdy, msg), send_rdata(en, msg), recv_waddr(rdy, msg), recv_wdata, tile # - reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] - reg_list = [] - for idx, data in enumerate(reg_dicts): - reg_dict = { "addr": f"addr {idx}" } - reg_dict.update(data) - reg_list.append(reg_dict) - reg_md = markdown_table(reg_list).set_params(quote = False).get_markdown() - - rw_ports_max_count = max(len(s.recv_raddr), len(s.recv_waddr)) - mem_list = [] - for idx in range(rw_ports_max_count): - recv_raddr_rdy, recv_raddr = None, None - send_rdata_en, send_rdata = None, None - recv_waddr_rdy, recv_waddr = None, None - recv_wdata = None - if idx <= len(s.recv_raddr) - 1: - recv_raddr_rdy = s.recv_raddr[idx].rdy - recv_raddr = s.recv_raddr[idx].msg - send_rdata_en = s.send_rdata[idx].en - send_rdata = s.send_rdata[idx].msg.payload - if idx <= len(s.recv_waddr) - 1: - recv_waddr_rdy = s.recv_waddr[idx].rdy - recv_waddr = s.recv_waddr[idx].msg - recv_wdata = s.recv_wdata[idx].msg.payload - mem_dict = { "recv_raddr(rdy, msg)": f"{recv_raddr_rdy}, {recv_raddr}", - "send_rdata(en, msg)": f"{send_rdata_en}, {send_rdata}", - "recv_waddr(rdy, msg)": f"{recv_waddr_rdy}, {recv_waddr}", - "recv_wdata": f"{recv_wdata}", - "Tiles in Col0": "<--- Tile" } - mem_list.append(mem_dict) - mem_md = markdown_table(mem_list).set_params(quote = False).get_markdown() - - return (f'\nclass: {s.__class__.__name__}\n' - f'- regs(mem size: {len(reg_dicts)}): {reg_md}\n' - f'- mem_r/w:' - f'{mem_md}') + # verbose trace + def verbose_trace(s, verbosity = 1): + # data memory: mem size, reg + # recv_raddr(rdy, msg), send_rdata(en, msg), recv_waddr(rdy, msg), recv_wdata, tile # + reg_dicts = [dict(data.__dict__) for data in s.reg_file.regs] + reg_list = [] + for idx, data in enumerate(reg_dicts): + reg_dict = { "addr": f"addr {idx}" } + reg_dict.update(data) + reg_list.append(reg_dict) + reg_md = markdown_table(reg_list).set_params(quote = False).get_markdown() + + rw_ports_max_count = max(len(s.recv_raddr), len(s.recv_waddr)) + mem_list = [] + for idx in range(rw_ports_max_count): + recv_raddr_rdy, recv_raddr = None, None + send_rdata_en, send_rdata = None, None + recv_waddr_rdy, recv_waddr = None, None + recv_wdata = None + if idx <= len(s.recv_raddr) - 1: + recv_raddr_rdy = s.recv_raddr[idx].rdy + recv_raddr = s.recv_raddr[idx].msg + send_rdata_en = s.send_rdata[idx].en + send_rdata = s.send_rdata[idx].msg.payload + if idx <= len(s.recv_waddr) - 1: + recv_waddr_rdy = s.recv_waddr[idx].rdy + recv_waddr = s.recv_waddr[idx].msg + recv_wdata = s.recv_wdata[idx].msg.payload + mem_dict = { "recv_raddr(rdy, msg)": f"{recv_raddr_rdy}, {recv_raddr}", + "send_rdata(en, msg)": f"{send_rdata_en}, {send_rdata}", + "recv_waddr(rdy, msg)": f"{recv_waddr_rdy}, {recv_waddr}", + "recv_wdata": f"{recv_wdata}", + "Tiles in Col0": "<--- Tile" } + mem_list.append(mem_dict) + mem_md = markdown_table(mem_list).set_params(quote = False).get_markdown() + + return (f'\nclass: {s.__class__.__name__}\n' + f'- regs(mem size: {len(reg_dicts)}): {reg_md}\n' + f'- mem_r/w:' + f'{mem_md}') diff --git a/scale_out/RingMultiCgraRingCtrlMemRTL.py b/scale_out/RingMultiCgraRingCtrlMemRTL.py index efdb27d..14f1b7c 100644 --- a/scale_out/RingMultiCgraRingCtrlMemRTL.py +++ b/scale_out/RingMultiCgraRingCtrlMemRTL.py @@ -105,7 +105,7 @@ def line_trace(s): return res - def verbose_trace( self, verbosity = 1 ): + def verbose_trace(self, verbosity = 1): res = '' for (i, x) in enumerate(self.cgra): res += "# [cgra" + str(i) + "]:\n" + x.verbose_trace(verbosity = verbosity) + '\n' diff --git a/systolic/CgraMemRightAndBottomRTL.py b/systolic/CgraMemRightAndBottomRTL.py index 7b342f8..d618a8e 100644 --- a/systolic/CgraMemRightAndBottomRTL.py +++ b/systolic/CgraMemRightAndBottomRTL.py @@ -134,7 +134,7 @@ def line_trace( s ): return res - def verbose_trace( s, verbosity = 1 ): + def verbose_trace(s, verbosity = 1): res = '' for (i, x) in enumerate(s.tile): res += "# [tile" + str(i) + "]: " + x.verbose_trace(verbosity = verbosity) + x.ctrl_mem.verbose_trace(verbosity = verbosity) + '\n' diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 95f5f66..1f1cf84 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -134,7 +134,7 @@ def line_trace( s ): return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" - def verbose_trace_md_formatter( self, data_type, data ): + def verbose_trace_md_formatter(self, data_type, data): assert data_type in [ "recv", "send" ] data_list = [ x for x in data ] result_list = [] @@ -150,7 +150,7 @@ def verbose_trace_md_formatter( self, data_type, data ): return result_md # verbose trace - def verbose_trace( s, verbosity = 1 ): + def verbose_trace(s, verbosity = 1): # recv: # 1. rdy (if ready to receive data), if en and rdy: then data has been transferred (val, rdy are new type(protocol)) # 2. data diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 6b89174..7561751 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -209,7 +209,7 @@ def line_trace( s ): # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" - def verbose_trace_str_formatter( self, crossbar_dict ): + def verbose_trace_str_formatter(self, crossbar_dict): crossbar_dict['ctrl'] = OPT_SYMBOL_DICT[crossbar_dict['ctrl']] crossbar_dict['predicate'] = int(crossbar_dict['predicate']) crossbar_dict['fu_in'] = [ int(fi) for fi in crossbar_dict['fu_in'] ] @@ -219,7 +219,7 @@ def verbose_trace_str_formatter( self, crossbar_dict ): crossbar_str = "\n".join([(key + ": " + str(value)) for key, value in crossbar_dict.items()]) return crossbar_str - def verbose_trace_md_formatter( self, header_str, data_dict ): + def verbose_trace_md_formatter(self, header_str, data_dict): result_list = [] for idx, data in enumerate(data_dict): port_direction = TILE_PORT_DIRECTION_DICT_DESC[idx] @@ -230,7 +230,7 @@ def verbose_trace_md_formatter( self, header_str, data_dict ): return result_md # verbose trace - def verbose_trace( s, verbosity = 1 ): + def verbose_trace(s, verbosity = 1): recv_data = [ x.msg.__dict__ for x in s.recv_data ] recv_md = s.verbose_trace_md_formatter("inport_direction", recv_data) From 877ab24e7e2e73b0bb83fde4365c9f9e5153128b Mon Sep 17 00:00:00 2001 From: yuqisun Date: Sat, 28 Dec 2024 20:48:15 +0800 Subject: [PATCH 42/45] Remove the unnecessary space. --- systolic/CgraMemRightAndBottomRTL.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/systolic/CgraMemRightAndBottomRTL.py b/systolic/CgraMemRightAndBottomRTL.py index d618a8e..263f2f5 100644 --- a/systolic/CgraMemRightAndBottomRTL.py +++ b/systolic/CgraMemRightAndBottomRTL.py @@ -124,7 +124,7 @@ def construct(s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_wdata.rdy //= 0 # Line trace - def line_trace( s ): + def line_trace(s): # str = "||".join([ x.element.line_trace() for x in s.tile ]) # str += " :: [" + s.data_mem.line_trace() + "]" res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) From a11819c237adf0b926ccdea796f543f0d5e32d85 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Sat, 28 Dec 2024 20:58:14 +0800 Subject: [PATCH 43/45] Remove the unnecessary space. --- mem/data/DataMemRTL.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index 485cc08..fed49e8 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -97,7 +97,7 @@ def update_signal(): s.recv_waddr[i].rdy @= Bits1( 1 ) s.recv_wdata[i].rdy @= Bits1( 1 ) - def line_trace( s ): + def line_trace(s): recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) From 51bbc5cd90a6d583ee9dddff496eec992b8d172f Mon Sep 17 00:00:00 2001 From: yuqisun Date: Sat, 28 Dec 2024 20:59:55 +0800 Subject: [PATCH 44/45] enable verbose_trace by default --- tile/test/TileSeparateCrossbarRTL_test.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tile/test/TileSeparateCrossbarRTL_test.py b/tile/test/TileSeparateCrossbarRTL_test.py index f860d52..282f315 100644 --- a/tile/test/TileSeparateCrossbarRTL_test.py +++ b/tile/test/TileSeparateCrossbarRTL_test.py @@ -81,8 +81,8 @@ def done(s): return True def line_trace(s): - # return s.dut.verbose_trace(verbosity = 2) - return s.dut.line_trace() + return s.dut.verbose_trace(verbosity = 2) + # return s.dut.line_trace() def test_tile_alu(cmdline_opts): num_tile_inports = 4 From bf825b136d3ee2436b0c8051e117b3dbf9f96064 Mon Sep 17 00:00:00 2001 From: yuqisun Date: Wed, 1 Jan 2025 20:20:30 +0800 Subject: [PATCH 45/45] Control verbose_trace by set_param. --- cgra/CGRAKingMeshRTL.py | 17 +++++++----- cgra/CgraCrossbarDataMemRingCtrlMemRTL.py | 17 +++++++----- cgra/translate/VectorCGRAKingMeshRTL_test.py | 4 +-- fu/flexible/FlexibleFuRTL.py | 17 +++++++----- mem/ctrl/CtrlMemDynamicRTL.py | 9 ++++--- mem/ctrl/CtrlMemRTL.py | 9 ++++--- mem/data/DataMemRTL.py | 27 ++++++++++--------- scale_out/RingMultiCgraRingCtrlMemRTL.py | 13 +++++---- .../test/RingMultiCgraRingCtrlMemRTL_test.py | 3 ++- systolic/CgraMemRightAndBottomRTL.py | 19 +++++++------ ...graMemRightAndBottomRTL_matmul_2x2_test.py | 2 +- tile/TileRTL.py | 15 ++++++----- tile/TileSeparateCrossbarRTL.py | 21 ++++++++------- tile/test/TileSeparateCrossbarRTL_test.py | 5 ++-- 14 files changed, 104 insertions(+), 74 deletions(-) diff --git a/cgra/CGRAKingMeshRTL.py b/cgra/CGRAKingMeshRTL.py index 6db59fc..70cac58 100644 --- a/cgra/CGRAKingMeshRTL.py +++ b/cgra/CGRAKingMeshRTL.py @@ -150,13 +150,16 @@ def construct( s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_wdata.rdy //= 0 # Line trace - def line_trace( s ): - # str = "||".join([ x.element.line_trace() for x in s.tile ]) - # str += " :: [" + s.data_mem.line_trace() + "]" - res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - for (i, x) in enumerate(s.tile)]) - res += "\n :: [" + s.data_mem.line_trace() + "] \n" - return res + def line_trace(s, verbosity = 0): + if verbosity == 0: + # str = "||".join([ x.element.line_trace() for x in s.tile ]) + # str += " :: [" + s.data_mem.line_trace() + "]" + res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + for (i, x) in enumerate(s.tile)]) + res += "\n :: [" + s.data_mem.line_trace() + "] \n" + return res + else: + return s.verbose_trace(verbosity) # verbose trace def verbose_trace(s, verbosity = 1): diff --git a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py index 391036f..5e0cb06 100644 --- a/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py +++ b/cgra/CgraCrossbarDataMemRingCtrlMemRTL.py @@ -183,13 +183,16 @@ def construct(s, DataType, PredicateType, CtrlPktType, CtrlSignalType, s.tile[i].to_mem_wdata.rdy //= 0 # Line trace - def line_trace( s ): - # str = "||".join([ x.element.line_trace() for x in s.tile ]) - # str += " :: [" + s.data_mem.line_trace() + "]" - res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - for (i,x) in enumerate(s.tile) ]) - res += "\n :: [" + s.data_mem.line_trace() + "] \n" - return res + def line_trace(s, verbosity = 0): + if verbosity == 0: + # str = "||".join([ x.element.line_trace() for x in s.tile ]) + # str += " :: [" + s.data_mem.line_trace() + "]" + res = "||\n".join([ (("[tile"+str(i)+"]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + for (i,x) in enumerate(s.tile) ]) + res += "\n :: [" + s.data_mem.line_trace() + "] \n" + return res + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace(self, verbosity = 1): diff --git a/cgra/translate/VectorCGRAKingMeshRTL_test.py b/cgra/translate/VectorCGRAKingMeshRTL_test.py index 6e2341a..b87a2bd 100644 --- a/cgra/translate/VectorCGRAKingMeshRTL_test.py +++ b/cgra/translate/VectorCGRAKingMeshRTL_test.py @@ -67,9 +67,6 @@ def done( s ): return done def line_trace( s ): - # verbose trace (test without verilog) - # verbosity = 2 - # return s.dut.verbose_trace(verbosity = verbosity) return s.dut.line_trace() def test_homo_4x4( cmdline_opts ): @@ -134,6 +131,7 @@ def test_homo_4x4( cmdline_opts ): else: print( f' - set tile[{idx}] to scalar') th.set_param( f'top.dut.tile[{idx}].construct', FuList=scalar_list ) + th.set_param('top.dut.line_trace', verbosity = 1) th.elaborate() th.dut.set_metadata( VerilogTranslationPass.explicit_module_name, diff --git a/fu/flexible/FlexibleFuRTL.py b/fu/flexible/FlexibleFuRTL.py index 1d0cc05..e1464d5 100644 --- a/fu/flexible/FlexibleFuRTL.py +++ b/fu/flexible/FlexibleFuRTL.py @@ -109,13 +109,16 @@ def comb_logic(): s.fu_recv_in_rdy_vector[port][i] @= s.fu[i].recv_in[port].rdy s.recv_in[port].rdy @= reduce_or( s.fu_recv_in_rdy_vector[port] ) - def line_trace( s ): - opt_str = " #" - if s.recv_opt.en: - opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] - out_str = ",".join([str(x.msg) for x in s.send_out]) - recv_str = ",".join([str(x.msg) for x in s.recv_in]) - return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + def line_trace(s, verbosity = 0): + if verbosity == 0: + opt_str = " #" + if s.recv_opt.en: + opt_str = OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl] + out_str = ",".join([str(x.msg) for x in s.send_out]) + recv_str = ",".join([str(x.msg) for x in s.recv_in]) + return f'[recv: {recv_str}] {opt_str}(P{s.recv_opt.msg.predicate}) (const: {s.recv_const.msg}, en: {s.recv_const.en}) ] = [out: {out_str}] (recv_opt.rdy: {s.recv_opt.rdy}, recv_in[0].rdy: {s.recv_in[0].rdy}, recv_in[1].rdy: {s.recv_in[1].rdy}, recv_predicate.msg: {s.recv_predicate.msg}, {OPT_SYMBOL_DICT[s.recv_opt.msg.ctrl]}, recv_opt.en: {s.recv_opt.en}, send[0].en: {s.send_out[0].en}) ' + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace_md_formatter(self, data_type, data): diff --git a/mem/ctrl/CtrlMemDynamicRTL.py b/mem/ctrl/CtrlMemDynamicRTL.py index 184a2db..65c98f2 100644 --- a/mem/ctrl/CtrlMemDynamicRTL.py +++ b/mem/ctrl/CtrlMemDynamicRTL.py @@ -138,9 +138,12 @@ def update_raddr(): else: s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + CtrlAddrType(1) - def line_trace(s): - config_mem_str = "|".join([str(data) for data in s.reg_file.regs]) - return f'{s.recv_pkt.msg} || config_mem: [{config_mem_str}] || out: {s.send_ctrl.msg}' + def line_trace(s, verbosity = 0): + if verbosity == 0: + config_mem_str = "|".join([str(data) for data in s.reg_file.regs]) + return f'{s.recv_pkt.msg} || config_mem: [{config_mem_str}] || out: {s.send_ctrl.msg}' + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace_normal_processor(self, data_dict): diff --git a/mem/ctrl/CtrlMemRTL.py b/mem/ctrl/CtrlMemRTL.py index 032c79d..e50ff3d 100644 --- a/mem/ctrl/CtrlMemRTL.py +++ b/mem/ctrl/CtrlMemRTL.py @@ -72,9 +72,12 @@ def update_raddr(): else: s.reg_file.raddr[0] <<= s.reg_file.raddr[0] + AddrType( 1 ) - def line_trace( s ): - out_str = "||".join([str(data) for data in s.reg_file.regs]) - return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' + def line_trace(s, verbosity = 0): + if verbosity == 0: + out_str = "||".join([str(data) for data in s.reg_file.regs]) + return f'{s.recv_ctrl.msg} : [{out_str}] : {s.send_ctrl.msg}' + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace_normal_processor(self, data_dict): diff --git a/mem/data/DataMemRTL.py b/mem/data/DataMemRTL.py index fed49e8..d4366ad 100644 --- a/mem/data/DataMemRTL.py +++ b/mem/data/DataMemRTL.py @@ -97,18 +97,21 @@ def update_signal(): s.recv_waddr[i].rdy @= Bits1( 1 ) s.recv_wdata[i].rdy @= Bits1( 1 ) - def line_trace(s): - recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) - recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) - recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) - content_str = "content: " + "|".join([str(data) for data in s.reg_file.regs]) - send_rdata_str = "send_read_data: " + "|".join([str(data.msg) for data in s.send_rdata]) - return f'{recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' - # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' - # return s.reg_file.line_trace() - # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' - # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' + def line_trace(s, verbosity = 0): + if verbosity == 0: + recv_raddr_str = "recv_read_addr: " + "|".join([str(data.msg) for data in s.recv_raddr]) + recv_waddr_str = "recv_write_addr: " + "|".join([str(data.msg) for data in s.recv_waddr]) + recv_wdata_str = "recv_write_data: " + "|".join([str(data.msg) for data in s.recv_wdata]) + content_str = "content: " + "|".join([str(data) for data in s.reg_file.regs]) + send_rdata_str = "send_read_data: " + "|".join([str(data.msg) for data in s.send_rdata]) + return f'{recv_raddr_str} || {recv_waddr_str} || {recv_wdata_str} || [{content_str}] || {send_rdata_str}' + # return f'DataMem: {recv_str} : [{out_str}] : {send_str} initWrites: {s.initWrites}' + # return s.reg_file.line_trace() + # return f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' + # rf_trace = f'<{s.reg_file.wen[0]}>{s.reg_file.waddr[0]}:{s.reg_file.wdata[0]}|{s.reg_file.raddr[0]}:{s.reg_file.rdata[0]}' + # return f'[{s.recv_wdata[0].en & s.recv_waddr[0].en}]{s.recv_waddr[0]}<{s.recv_wdata[0]}({rf_trace}){s.recv_raddr[0]}>{s.send_rdata[0]}' + else: + return s.verbose_trace(verbosity = verbosity) # verbose trace def verbose_trace(s, verbosity = 1): diff --git a/scale_out/RingMultiCgraRingCtrlMemRTL.py b/scale_out/RingMultiCgraRingCtrlMemRTL.py index 14f1b7c..7d90502 100644 --- a/scale_out/RingMultiCgraRingCtrlMemRTL.py +++ b/scale_out/RingMultiCgraRingCtrlMemRTL.py @@ -98,11 +98,14 @@ def construct(s, CGRADataType, PredicateType, CtrlPktType, s.cgra[cgra_row * cgra_columns + cgra_col].recv_data_on_boundary_east[tile_row].en //= 0 s.cgra[cgra_row * cgra_columns + cgra_col].recv_data_on_boundary_east[tile_row].msg //= CGRADataType() - def line_trace(s): - res = "||\n".join([(("[cgra["+str(i)+"]: ") + x.line_trace()) - for (i,x) in enumerate(s.cgra)]) - res += " ## ring: " + s.ring.line_trace() - return res + def line_trace(s, verbosity = 0): + if verbosity == 0: + res = "||\n".join([(("[cgra["+str(i)+"]: ") + x.line_trace()) + for (i,x) in enumerate(s.cgra)]) + res += " ## ring: " + s.ring.line_trace() + return res + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace(self, verbosity = 1): diff --git a/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py b/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py index 47dcd7e..9be1583 100644 --- a/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py +++ b/scale_out/test/RingMultiCgraRingCtrlMemRTL_test.py @@ -81,7 +81,6 @@ def done(s): # return True def line_trace(s): - # return s.dut.verbose_trace(verbosity = 2) return s.dut.line_trace() def test_homo_2x2(cmdline_opts): @@ -210,6 +209,8 @@ def test_homo_2x2(cmdline_opts): width, height, ctrl_mem_size, data_mem_size_global, data_mem_size_per_bank, num_banks_per_cgra, src_ctrl_pkt, ctrl_mem_size, controller2addr_map) + th.set_param('top.dut.line_trace', verbosity = 1) + th.elaborate() th.dut.set_metadata(VerilogVerilatorImportPass.vl_Wno_list, ['UNSIGNED', 'UNOPTFLAT', 'WIDTH', 'WIDTHCONCAT', diff --git a/systolic/CgraMemRightAndBottomRTL.py b/systolic/CgraMemRightAndBottomRTL.py index 263f2f5..fe1ee20 100644 --- a/systolic/CgraMemRightAndBottomRTL.py +++ b/systolic/CgraMemRightAndBottomRTL.py @@ -124,14 +124,17 @@ def construct(s, DataType, PredicateType, CtrlType, width, height, s.tile[i].to_mem_wdata.rdy //= 0 # Line trace - def line_trace(s): - # str = "||".join([ x.element.line_trace() for x in s.tile ]) - # str += " :: [" + s.data_mem.line_trace() + "]" - res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) - for (i,x) in enumerate(s.tile)]) - res += "\n :: SouthMem [" + s.data_mem_south.line_trace() + "] \n" - res += "\n :: EastMem [" + s.data_mem_east.line_trace() + "] \n" - return res + def line_trace(s, verbosity = 0): + if verbosity == 0: + # str = "||".join([ x.element.line_trace() for x in s.tile ]) + # str += " :: [" + s.data_mem.line_trace() + "]" + res = "||\n".join([(("[tile" + str(i) + "]: ") + x.line_trace() + x.ctrl_mem.line_trace()) + for (i,x) in enumerate(s.tile)]) + res += "\n :: SouthMem [" + s.data_mem_south.line_trace() + "] \n" + res += "\n :: EastMem [" + s.data_mem_east.line_trace() + "] \n" + return res + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace(s, verbosity = 1): diff --git a/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py b/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py index 438e2ff..a339adf 100644 --- a/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py +++ b/systolic/translate/CgraMemRightAndBottomRTL_matmul_2x2_test.py @@ -80,7 +80,6 @@ def check_parity(s): return True def line_trace(s): - # return s.dut.verbose_trace(verbosity = 2) return s.dut.line_trace() def run_sim(test_harness, enable_verification_pymtl, @@ -391,6 +390,7 @@ def test_CGRA_systolic(cmdline_opts): CtrlType, width, height, ctrl_mem_size, data_mem_size, src_opt, ctrl_waddr, preload_mem, preload_const, expected_out) + th.set_param('top.dut.line_trace', verbosity = 1) th.elaborate() th.dut.set_metadata(VerilogTranslationPass.explicit_module_name, diff --git a/tile/TileRTL.py b/tile/TileRTL.py index 1f1cf84..a9dcdd1 100644 --- a/tile/TileRTL.py +++ b/tile/TileRTL.py @@ -126,12 +126,15 @@ def update_opt(): s.ctrl_mem.send_ctrl.rdy @= s.element.recv_opt.rdy & s.crossbar.recv_opt.rdy # Line trace - def line_trace( s ): - recv_str = "|".join([str(x.msg) for x in s.recv_data]) - channel_recv_str = "|".join([str(x.recv.msg) for x in s.channel]) - channel_send_str = "|".join([str(x.send.msg) for x in s.channel]) - out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) - return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + def line_trace(s, verbosity = 0): + if verbosity == 0: + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + channel_recv_str = "|".join([str(x.recv.msg) for x in s.channel]) + channel_send_str = "|".join([str(x.send.msg) for x in s.channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace_md_formatter(self, data_type, data): diff --git a/tile/TileSeparateCrossbarRTL.py b/tile/TileSeparateCrossbarRTL.py index 7561751..cf800d6 100644 --- a/tile/TileSeparateCrossbarRTL.py +++ b/tile/TileSeparateCrossbarRTL.py @@ -198,15 +198,18 @@ def update_opt(): s.fu_crossbar.recv_opt.rdy # Line trace - def line_trace( s ): - recv_str = "|".join([str(x.msg) for x in s.recv_data]) - tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) - tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) - fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) - fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) - out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) - return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " - # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + def line_trace(s, verbosity = 0): + if verbosity == 0: + recv_str = "|".join([str(x.msg) for x in s.recv_data]) + tile_out_channel_recv_str = "|".join([str(x.recv.msg) for x in s.tile_out_channel]) + tile_out_channel_send_str = "|".join([str(x.send.msg) for x in s.tile_out_channel]) + fu_in_channel_recv_str = "|".join([str(x.recv.msg) for x in s.fu_in_channel]) + fu_in_channel_send_str = "|".join([str(x.send.msg) for x in s.fu_in_channel]) + out_str = "|".join(["(" + str(x.msg.payload) + "," + str(x.msg.predicate) + ")" for x in s.send_data]) + return f"tile_inports: {recv_str} => [routing_crossbar: {s.routing_crossbar.recv_opt.msg} || fu_crossbar: {s.fu_crossbar.recv_opt.msg} || element: {s.element.line_trace()} || tile_out_channels: {tile_out_channel_recv_str} => {tile_out_channel_send_str} || fu_in_channels: {fu_in_channel_recv_str} => {fu_in_channel_send_str}] => tile_outports: {out_str} ## " + # return f"{recv_str} => [{s.crossbar.recv_opt.msg}] ({s.element.line_trace()}) => {channel_recv_str} => {channel_send_str} => {out_str}" + else: + return s.verbose_trace(verbosity = verbosity) def verbose_trace_str_formatter(self, crossbar_dict): diff --git a/tile/test/TileSeparateCrossbarRTL_test.py b/tile/test/TileSeparateCrossbarRTL_test.py index 282f315..e75ac4b 100644 --- a/tile/test/TileSeparateCrossbarRTL_test.py +++ b/tile/test/TileSeparateCrossbarRTL_test.py @@ -81,8 +81,7 @@ def done(s): return True def line_trace(s): - return s.dut.verbose_trace(verbosity = 2) - # return s.dut.line_trace() + return s.dut.line_trace() def test_tile_alu(cmdline_opts): num_tile_inports = 4 @@ -166,6 +165,8 @@ def test_tile_alu(cmdline_opts): data_mem_size, num_fu_inports, num_fu_outports, num_tile_inports, num_tile_outports, src_data, src_ctrl_pkt, sink_out) + th.set_param('top.dut.line_trace', verbosity = 1) + th.elaborate() th.dut.set_metadata(VerilogVerilatorImportPass.vl_Wno_list, ['UNSIGNED', 'UNOPTFLAT', 'WIDTH', 'WIDTHCONCAT',