scc  2022.4.0
SystemC components library
chi_tlm.cpp
1 /*
2  * Copyright 2020 Arteris IP
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "chi_tlm.h"
18 #include <iostream>
19 #include <tlm/scc/scv/tlm_extension_recording_registry.h>
20 
21 namespace chi {
22 std::array<char const*, 103> opc2str = {
23  "ReqLCrdReturn",
24  "ReadShared",
25  "ReadClean",
26  "ReadOnce",
27  "ReadNoSnp",
28  "PCrdReturn",
29  "Reserved",
30  "ReadUnique",
31  "CleanShared",
32  "CleanInvalid",
33  "MakeInvalid",
34  "CleanUnique",
35  "MakeUnique",
36  "Evict",
37  "EOBarrier",
38  "ECBarrier",
39  "RESERVED",
40  "ReadNoSnpSep",
41  "RESERVED",
42  "CleanSharedPersistSep",
43  "DVMOp",
44  "WriteEvictFull",
45  "WriteCleanPtl",
46  "WriteCleanFull",
47  "WriteUniquePtl",
48  "WriteUniqueFull",
49  "WriteBackPtl",
50  "WriteBackFull",
51  "WriteNoSnpPtl",
52  "WriteNoSnpFull",
53  "RESERVED",
54  "RESERVED",
55  "WriteUniqueFullStash",
56  "WriteUniquePtlStash",
57  "StashOnceShared",
58  "StashOnceUnique",
59  "ReadOnceCleanInvalid",
60  "ReadOnceMakeInvalid",
61  "ReadNotSharedDirty",
62  "CleanSharedPersist",
63  "AtomicStoreAdd",
64  "AtomicStoreClr",
65  "AtomicStoreEor",
66  "AtomicStoreSet",
67  "AtomicStoreSmax",
68  "AtomicStoreSmin",
69  "AtomicStoreUmax",
70  "AtomicStoreUmin",
71  "AtomicLoadAdd",
72  "AtomicLoadClr",
73  "AtomicLoadEor",
74  "AtomicLoadSet",
75  "AtomicLoadSmax",
76  "AtomicLoadSmin",
77  "AtomicLoadUmax",
78  "AtomicLoadUmin",
79  "AtomicSwap",
80  "AtomicCompare",
81  "PrefetchTgt",
82  "RESERVED",
83  "RESERVED",
84  "RESERVED",
85  "RESERVED",
86  "RESERVED",
87  "RESERVED",
88  "MakeReadUnique",
89  "WriteEvictOrEvict",
90  "WriteUniqueZero",
91  "WriteNoSnpZero",
92  "RESERVED",
93  "RESERVED",
94  "StashOnceSepShared",
95  "StashOnceSepUnique",
96  "RESERVED",
97  "RESERVED",
98  "RESERVED",
99  "ReadPreferUnique",
100  "RESERVED",
101  "RESERVED",
102  "RESERVED",
103  "WriteNoSnpFullCleanSh",
104  "WriteNoSnpFullCleanInv",
105  "WriteNoSnpFullCleanShPerSep",
106  "RESERVED",
107  "WriteUniqueFullCleanSh",
108  "RESERVED",
109  "WriteUniqueFullCleanShPerSep",
110  "RESERVED",
111  "WriteBackFullCleanSh",
112  "WriteBackFullCleanInv",
113  "WriteBackFullCleanShPerSep",
114  "RESERVED",
115  "WriteCleanFullCleanSh",
116  "RESERVED",
117  "WriteCleanFullCleanShPerSep",
118  "RESERVED",
119  "WriteNoSnpPtlCleanSh",
120  "WriteNoSnpPtlCleanInv",
121  "WriteNoSnpPtlCleanShPerSep",
122  "RESERVED",
123  "WriteUniquePtlCleanSh",
124  "RESERVED",
125  "WriteUniquePtlCleanShPerSep",
126 };
127 template <> const char* to_char<req_optype_e>(req_optype_e v) {
128  auto idx = static_cast<unsigned>(v);
129  if(idx<opc2str.size())
130  return opc2str[idx];
131  else return "RESERVED";
132 }
133 
134 template <> const char* to_char<dat_optype_e>(dat_optype_e v) {
135  switch(v) {
136  case dat_optype_e::DataLCrdReturn:
137  return "DataLCrdReturn";
138  case dat_optype_e::SnpRespData:
139  return "SnpRespData";
140  case dat_optype_e::CopyBackWrData:
141  return "CopyBackWrData";
142  case dat_optype_e::NonCopyBackWrData:
143  return "NonCopyBackWrData";
144  case dat_optype_e::CompData:
145  return "CompData";
146  case dat_optype_e::SnpRespDataPtl:
147  return "SnpRespDataPtl";
148  case dat_optype_e::SnpRespDataFwded:
149  return "SnpRespDataFwded";
150  case dat_optype_e::WriteDataCancel:
151  return "WriteDataCancel";
152  case dat_optype_e::DataSepResp:
153  return "DataSepResp";
154  case dat_optype_e::NCBWrDataCompAck:
155  return "NCBWrDataCompAck";
156  default:
157  return "UNKNOWN_dat_optype_e";
158  }
159 }
160 
161 template <> const char* to_char<rsp_optype_e>(rsp_optype_e v) {
162  switch(v) {
163  case rsp_optype_e::RespLCrdReturn:
164  return "RespLCrdReturn";
165  case rsp_optype_e::SnpResp:
166  return "SnpResp";
167  case rsp_optype_e::CompAck:
168  return "CompAck";
169  case rsp_optype_e::RetryAck:
170  return "RetryAck";
171  case rsp_optype_e::Comp:
172  return "Comp";
173  case rsp_optype_e::CompDBIDResp:
174  return "CompDBIDResp";
175  case rsp_optype_e::DBIDResp:
176  return "DBIDResp";
177  case rsp_optype_e::PCrdGrant:
178  return "PCrdGrant";
179  case rsp_optype_e::ReadReceipt:
180  return "ReadReceipt";
181  case rsp_optype_e::SnpRespFwded:
182  return "SnpRespFwded";
183  case rsp_optype_e::TagMatch:
184  return "TagMatch";
185  case rsp_optype_e::RespSepData:
186  return "RespSepData";
187  case rsp_optype_e::Persist:
188  return "Persist";
189  case rsp_optype_e::CompPersist:
190  return "CompPersist";
191  case rsp_optype_e::DBIDRespOrd:
192  return "DBIDRespOrd";
193  case rsp_optype_e::StashDone:
194  return "StashDone";
195  case rsp_optype_e::CompStashDone:
196  return "CompStashDone";
197  case rsp_optype_e::CompCMO:
198  return "CompCMO";
199  case rsp_optype_e::INVALID:
200  return "---";
201  default:
202  return "UNKNOWN_rsp_optype_e";
203  }
204 }
205 
206 template <> const char* to_char<snp_optype_e>(snp_optype_e v) {
207  switch(v) {
208  case snp_optype_e::SnpLCrdReturn:
209  return "SnpLCrdReturn";
210  case snp_optype_e::SnpShared:
211  return "SnpShared";
212  case snp_optype_e::SnpClean:
213  return "SnpClean";
214  case snp_optype_e::SnpOnce:
215  return "SnpOnce";
216  case snp_optype_e::SnpNotSharedDirty:
217  return "SnpNotSharedDirty";
218  case snp_optype_e::SnpUniqueStash:
219  return "SnpUniqueStash";
220  case snp_optype_e::SnpMakeInvalidStash:
221  return "SnpMakeInvalidStash";
222  case snp_optype_e::SnpUnique:
223  return "SnpUnique";
224  case snp_optype_e::SnpCleanShared:
225  return "SnpCleanShared";
226  case snp_optype_e::SnpCleanInvalid:
227  return "SnpCleanInvalid";
228  case snp_optype_e::SnpMakeInvalid:
229  return "SnpMakeInvalid";
230  case snp_optype_e::SnpStashUnique:
231  return "SnpStashUnique";
232  case snp_optype_e::SnpStashShared:
233  return "SnpStashShared";
234  case snp_optype_e::SnpDVMOp:
235  return "SnpDVMOp";
236  case snp_optype_e::SnpSharedFwd:
237  return "SnpSharedFwd";
238  case snp_optype_e::SnpCleanFwd:
239  return "SnpCleanFwd";
240  case snp_optype_e::SnpOnceFwd:
241  return "SnpOnceFwd";
242  case snp_optype_e::SnpNotSharedDirtyFwd:
243  return "SnpNotSharedDirtyFwd";
244  case snp_optype_e::SnpUniqueFwd:
245  return "SnpUniqueFwd";
246  default:
247  return "UNKNOWN_snp_optype_e";
248  }
249 }
250 
251 template <> const char* to_char<dat_resptype_e>(dat_resptype_e v) {
252  switch(v) {
253  // case CompData_I: return "CompData_I";
254  // case DataSepResp_I: return "DataSepResp_I";
255  // case RespSepData_I: return "RespSepData_I";
256  // case CompData_UC: return "CompData_UC";
257  // case DataSepResp_UC: return "DataSepResp_UC";
258  // case RespSepData_UC: return "RespSepData_UC";
259  // case CompData_SC: return "CompData_SC";
260  // case DataSepResp_SC: return "DataSepResp_SC";
261  // case RespSepData_SC: return "RespSepData_SC";
262  case dat_resptype_e::CompData_UD_PD:
263  return "CompData_UD_PD";
264  case dat_resptype_e::CompData_SD_PD:
265  return "CompData_SD_PD";
266  case dat_resptype_e::Comp_I:
267  return "Comp_I";
268  case dat_resptype_e::Comp_UC:
269  return "Comp_UC";
270  case dat_resptype_e::Comp_SC:
271  return "Comp_SC";
272  // case CopyBackWrData_I: return "CopyBackWrData_I";
273  // case CopyBackWrData_UC: return "CopyBackWrData_UC";
274  // case CopyBackWrData_SC: return "CopyBackWrData_SC";
275  // case CopyBackWrData_UD_PD: return "CopyBackWrData_UD_PD";
276  // case CopyBackWrData_SD_PD: return "CopyBackWrData_SD_PD";
277  // case NonCopyBackWrData: return "NonCopyBackWrData";
278  // case NCBWrDataCompAck: return "NCBWrDataCompAck";
279  default:
280  return "UNKNOWN_dat_resptype_e";
281  }
282 }
283 
284 template <> const char* to_char<rsp_resptype_e>(rsp_resptype_e v) {
285  switch(v) {
286  case rsp_resptype_e::SnpResp_I:
287  return "SnpResp_I";
288  case rsp_resptype_e::SnpResp_SC:
289  return "SnpResp_SC";
290  case rsp_resptype_e::SnpResp_UC:
291  return "SnpResp_UC";
292  // case SnpResp_UD: return "SnpResp_UD";
293  case rsp_resptype_e::SnpResp_SD:
294  return "SnpResp_SD";
295  default:
296  return "UNKNOWN_rsp_resptype_e";
297  }
298 }
299 
300 template <> const char* to_char<rsp_resperrtype_e>(rsp_resperrtype_e v) {
301  switch(v) {
302  case rsp_resperrtype_e::OK:
303  return "OK";
304  case rsp_resperrtype_e::EXOK:
305  return "EXOK";
306  case rsp_resperrtype_e::DERR:
307  return "DERR";
308  case rsp_resperrtype_e::NDERR:
309  return "NDERR";
310  default:
311  return "rsp_resperrtype_e";
312  }
313 }
314 
315 template <> const char* to_char<credit_type_e>(credit_type_e v) {
316  switch(v) {
317  case credit_type_e::LINK:
318  return "LINK";
319  case credit_type_e::REQ:
320  return "REQ";
321  case credit_type_e::RESP:
322  return "RESP";
323  case credit_type_e::DATA:
324  return "DATA";
325  default:
326  return "credit_type_e";
327  }
328 }
329 
330 template <> bool is_valid<chi::chi_ctrl_extension>(chi_ctrl_extension* ext) {
331  auto sz = ext->req.get_size();
332  if(sz > 6)
333  return false;
334  return true;
335 }
336 
337 } // namespace chi
338 
339 #include <tlm/scc/scv/tlm_recorder.h>
340 #include <tlm/scc/tlm_id.h>
341 namespace chi {
342 using namespace tlm::scc::scv;
343 
344 class tlm_id_ext_recording : public tlm_extensions_recording_if<chi_protocol_types> {
345 
346  void recordBeginTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {
347  if(auto ext = trans.get_extension<tlm::scc::tlm_id_extension>()) {
348  handle.record_attribute("trans.uid", ext->id);
349  }
350  }
351 
352  void recordEndTx(SCVNS scv_tr_handle& handle, tlm::tlm_base_protocol_types::tlm_payload_type& trans) override {
353  }
354 };
355 
356 class chi_ctrl_ext_recording : public tlm_extensions_recording_if<chi_protocol_types> {
357 
358  void recordBeginTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {
359  auto ext = trans.get_extension<chi_ctrl_extension>();
360  if(ext) {
361  handle.record_attribute("trans.chi_c.qos", ext->get_qos());
362  handle.record_attribute("trans.chi_c.src_id", ext->get_src_id());
363  handle.record_attribute("trans.chi_c.txn_id", ext->get_txn_id());
364  handle.record_attribute("trans.chi_c.tgt_id", ext->req.get_tgt_id());
365  handle.record_attribute("trans.chi_c.lp_id", ext->req.get_lp_id());
366  handle.record_attribute("trans.chi_c.return_txn_id", ext->req.get_return_txn_id());
367  handle.record_attribute("trans.chi_c.stash_lp_id", ext->req.get_stash_lp_id());
368  handle.record_attribute("trans.chi_c.size", ext->req.get_size());
369  handle.record_attribute("trans.chi_c.mem_attr", ext->req.get_mem_attr());
370  handle.record_attribute("trans.chi_c.req.pcrd_type", ext->req.get_pcrd_type());
371  handle.record_attribute("trans.chi_c.order", ext->req.get_order());
372  handle.record_attribute("trans.chi_c.endian", ext->req.is_endian());
373  handle.record_attribute("trans.chi_c.req.trace_tag", ext->req.is_trace_tag());
374  handle.record_attribute("trans.chi_c.return_n_id", ext->req.get_return_n_id());
375  handle.record_attribute("trans.chi_c.stash_n_id", ext->req.get_stash_n_id());
376  handle.record_attribute("trans.chi_c.opcode", std::string(to_char(ext->req.get_opcode())));
377  handle.record_attribute("trans.chi_c.stash_nnode_id_valid", ext->req.is_stash_n_id_valid());
378  handle.record_attribute("trans.chi_c.stash_lp_id_valid", ext->req.is_stash_lp_id_valid());
379  handle.record_attribute("trans.chi_c.non_secure", ext->req.is_non_secure());
380  handle.record_attribute("trans.chi_c.exp_comp_ack", ext->req.is_exp_comp_ack());
381  handle.record_attribute("trans.chi_c.allow_retry", ext->req.is_allow_retry());
382  handle.record_attribute("trans.chi_c.snp_attr", ext->req.is_snp_attr());
383  handle.record_attribute("trans.chi_c.excl", ext->req.is_excl());
384  handle.record_attribute("trans.chi_c.snoop_me", ext->req.is_snoop_me());
385  handle.record_attribute("trans.chi_c.likely_shared", ext->req.is_likely_shared());
386  handle.record_attribute("trans.chi_c.txn_rsvdc", ext->req.get_rsvdc()); // Reserved for customer use.
387  handle.record_attribute("trans.chi_c.tag_op", ext->req.get_tag_op());
388  handle.record_attribute("trans.chi_c.tag_group_id", ext->req.get_tag_group_id());
389  handle.record_attribute("trans.chi_c.mpam", ext->req.get_mpam());
390  handle.record_attribute("trans.chi_c.rsp.db_id", ext->resp.get_db_id());
391  handle.record_attribute("trans.chi_c.rsp.pcrd_type", ext->resp.get_pcrd_type());
392  handle.record_attribute("trans.chi_c.rsp.resp_err", std::string(to_char(ext->resp.get_resp_err())));
393  handle.record_attribute("trans.chi_c.rsp.fwd_state", ext->resp.get_fwd_state());
394  handle.record_attribute("trans.chi_c.rsp.data_pull", ext->resp.get_data_pull());
395  handle.record_attribute("trans.chi_c.rsp.opcode", std::string(to_char(ext->resp.get_opcode())));
396  handle.record_attribute("trans.chi_c.rsp.resp", std::string(to_char(ext->resp.get_resp())));
397  handle.record_attribute("trans.chi_c.rsp.tgt_id", ext->resp.get_tgt_id());
398  handle.record_attribute("trans.chi_c.rsp.trace_tag", ext->resp.is_trace_tag());
399  handle.record_attribute("trans.chi_c.rsp.tag_op", ext->resp.get_tag_op());
400  handle.record_attribute("trans.chi_c.rsp.tag_group_id", ext->resp.get_tag_group_id());
401  }
402  }
403 
404  void recordEndTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {}
405 };
406 
407 class chi_data_ext_recording : public tlm_extensions_recording_if<chi_protocol_types> {
408 
409  void recordBeginTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {
410  auto ext = trans.get_extension<chi_data_extension>();
411  if(ext) {
412  handle.record_attribute("trans.chi_d.qos", ext->get_qos());
413  handle.record_attribute("trans.chi_d.src_id", ext->get_src_id());
414  handle.record_attribute("trans.chi_d.txn_id", ext->get_txn_id());
415  handle.record_attribute("trans.chi_d.db_id", ext->dat.get_db_id());
416  handle.record_attribute("trans.chi_d.resp_err", std::string(to_char(ext->dat.get_resp_err())));
417  handle.record_attribute("trans.chi_d.resp", std::string(to_char(ext->dat.get_resp())));
418  handle.record_attribute("trans.chi_d.fwd_state", ext->dat.get_fwd_state());
419  handle.record_attribute("trans.chi_d.data_pull", ext->dat.get_data_pull());
420  handle.record_attribute("trans.chi_d.data_source", ext->dat.get_data_source());
421  handle.record_attribute("trans.chi_d.cc_id", ext->dat.get_cc_id());
422  handle.record_attribute("trans.chi_d.data_id", ext->dat.get_data_id());
423  handle.record_attribute("trans.chi_d.poison", ext->dat.get_poison());
424  handle.record_attribute("trans.chi_d.tgt_id", ext->dat.get_tgt_id());
425  handle.record_attribute("trans.chi_d.home_node_id", ext->dat.get_home_n_id());
426  handle.record_attribute("trans.chi_d.opcode", std::string(to_char(ext->dat.get_opcode())));
427  handle.record_attribute("trans.chi_d.rsvdc", ext->dat.get_rsvdc());
428  handle.record_attribute("trans.chi_d.data_check", ext->dat.get_data_check());
429  handle.record_attribute("trans.chi_d.trace_tag", ext->dat.is_trace_tag());
430  handle.record_attribute("trans.chi_d.tag_op", ext->dat.get_tag_op());
431  handle.record_attribute("trans.chi_c.tag", ext->dat.get_tag());
432  handle.record_attribute("trans.chi_c.tu", ext->dat.get_tu());
433  }
434  }
435 
436  void recordEndTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {}
437 };
438 
439 class chi_snp_ext_recording : public tlm_extensions_recording_if<chi_protocol_types> {
440 
441  void recordBeginTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {
442  auto ext = trans.get_extension<chi_snp_extension>();
443  if(ext) {
444  handle.record_attribute("trans.chi_s.qos", ext->get_qos());
445  handle.record_attribute("trans.chi_s.src_id", ext->get_src_id());
446  handle.record_attribute("trans.chi_s.txn_id", ext->get_txn_id());
447  handle.record_attribute("trans.chi_s.fwd_txn_id", ext->req.get_fwd_txn_id());
448  handle.record_attribute("trans.chi_s.stash_lp_id", ext->req.get_stash_lp_id());
449  handle.record_attribute("trans.chi_s.vm_id_ext", ext->req.get_vm_id_ext());
450  handle.record_attribute("trans.chi_s.stash_lp_id_valid", ext->req.is_stash_lp_id_valid());
451  handle.record_attribute("trans.chi_s.opcode", std::string(to_char(ext->req.get_opcode())));
452  handle.record_attribute("trans.chi_s.fwd_n_id", ext->req.get_fwd_n_id());
453  handle.record_attribute("trans.chi_s.non_secure", ext->req.is_non_secure());
454  handle.record_attribute("trans.chi_s.do_not_goto_sd", ext->req.is_do_not_goto_sd());
455  handle.record_attribute("trans.chi_s.do_not_data_pull", ext->req.is_do_not_data_pull());
456  handle.record_attribute("trans.chi_s.ret_to_src", ext->req.is_ret_to_src());
457  handle.record_attribute("trans.chi_s.trace_tag", ext->req.is_trace_tag());
458  handle.record_attribute("trans.chi_s.rsp.db_id", ext->resp.get_db_id());
459  handle.record_attribute("trans.chi_s.rsp.pcrd_type", ext->resp.get_pcrd_type());
460  handle.record_attribute("trans.chi_s.rsp.resp_err", std::string(to_char(ext->resp.get_resp_err())));
461  handle.record_attribute("trans.chi_s.rsp.fwd_state", ext->resp.get_fwd_state());
462  handle.record_attribute("trans.chi_s.rsp.data_pull", ext->resp.get_data_pull());
463  handle.record_attribute("trans.chi_s.rsp.opcode", std::string(to_char(ext->resp.get_opcode())));
464  handle.record_attribute("trans.chi_s.rsp.resp", std::string(to_char(ext->resp.get_resp())));
465  handle.record_attribute("trans.chi_s.rsp.tgt_id", ext->resp.get_tgt_id());
466  handle.record_attribute("trans.chi_s.rsp.trace_tag", ext->resp.is_trace_tag());
467  }
468  }
469 
470  void recordEndTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {}
471 };
472 
473 class chi_credit_ext_recording : public tlm_extensions_recording_if<chi_protocol_types> {
474 
475  void recordBeginTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {
476  auto ext = trans.get_extension<chi_credit_extension>();
477  if(ext) {
478  handle.record_attribute("trans.chi_credit.type", std::string(to_char(ext->type)));
479  handle.record_attribute("trans.chi_credit.count", ext->count);
480  }
481  }
482 
483  void recordEndTx(SCVNS scv_tr_handle& handle, chi_protocol_types::tlm_payload_type& trans) override {
484  auto ext = trans.get_extension<chi_credit_extension>();
485  if(ext) {
486  handle.record_attribute("trans.chi_credit.type", std::string(to_char(ext->type)));
487  handle.record_attribute("trans.chi_credit.count", ext->count);
488  }
489  }
490 };
491 namespace scv {
492 using namespace tlm::scc::scv;
493 #if defined(__GNUG__)
494 __attribute__((constructor))
495 #endif
496 bool register_extensions() {
497  tlm::scc::tlm_id_extension ext(nullptr); // NOLINT
498  tlm_extension_recording_registry<chi::chi_protocol_types>::inst().register_ext_rec(
499  ext.ID, new tlm_id_ext_recording()); // NOLINT
500  chi::chi_ctrl_extension extchi_req; // NOLINT
501  tlm_extension_recording_registry<chi::chi_protocol_types>::inst().register_ext_rec(
502  extchi_req.ID,
503  new chi::chi_ctrl_ext_recording()); // NOLINT
504  chi::chi_data_extension extchi_data; // NOLINT
505  tlm_extension_recording_registry<chi::chi_protocol_types>::inst().register_ext_rec(
506  extchi_data.ID,
507  new chi::chi_data_ext_recording()); // NOLINT
508  chi::chi_snp_extension extchi_snp; // NOLINT
509  tlm_extension_recording_registry<chi::chi_protocol_types>::inst().register_ext_rec(
510  extchi_snp.ID,
511  new chi::chi_snp_ext_recording()); // NOLINT
512  chi::chi_credit_extension extchi_credit; // NOLINT
513  tlm_extension_recording_registry<chi::chi_protocol_types>::inst().register_ext_rec(
514  extchi_credit.ID,
515  new chi::chi_credit_ext_recording()); // NOLINT
516  return true; // NOLINT
517 }
518 bool registered = register_extensions();
519 } // namespace scv
520 } // namespace chi
chi::chi_credit_ext_recording
Definition: chi_tlm.cpp:473
chi::chi_ctrl_ext_recording
Definition: chi_tlm.cpp:356
chi::chi_data_ext_recording
Definition: chi_tlm.cpp:407
chi::chi_snp_ext_recording
Definition: chi_tlm.cpp:439
tlm::scc::scv::tlm_extension_recording_registry
The TLM transaction extensions recorder registry.
Definition: tlm_extension_recording_registry.h:68
tlm::scc::scv::tlm_extensions_recording_if
The TLM transaction extensions recorder interface.
Definition: tlm_extension_recording_registry.h:45
tlm::scc::scv::tlm_id_ext_recording
Definition: tlm_recorder.cpp:74
chi
TLM2.0 components modeling CHI.
Definition: chi_tlm.cpp:21
chi::to_char
const char * to_char(E t)
tlm::scc::scv
SCC SCV4TLM classes and functions.
Definition: tlm_extension_recording_registry.h:38
chi::chi_credit_extension
Definition: chi_tlm.h:861
chi::chi_ctrl_extension
Definition: chi_tlm.h:744
chi::chi_data_extension
Definition: chi_tlm.h:822
chi::chi_snp_extension
Definition: chi_tlm.h:784
tlm::scc::tlm_id_extension
Definition: tlm_id.h:27