108 using TargetSocket = tlm::tlm_base_target_socket_b<BUSWIDTH, tlm::tlm_fw_transport_if<>,
109 tlm::tlm_bw_transport_if<>>;
111 using InitiatorSocket = tlm::tlm_base_initiator_socket_b<BUSWIDTH, tlm::tlm_fw_transport_if<>,
112 tlm::tlm_bw_transport_if<>>;
116 using initiator_socket_type =
typename gs::router<
117 BUSWIDTH, CacheType>::template multi_passthrough_initiator_socket_spying<router<BUSWIDTH, CacheType>>;
121 using CacheImpl = CacheType<uint64_t, std::shared_ptr<target_info>>;
140 template <
typename TargetInfoType>
153 std::shared_ptr<TargetInfoType> target;
155 Region(uint64_t s, uint64_t e, std::shared_ptr<TargetInfoType> t): start(s), end(e), target(t) {}
159 std::map<uint64_t, Region> m_regions;
180 void split_and_resolve(uint64_t new_start, uint64_t new_end, std::shared_ptr<TargetInfoType> new_target)
183 std::vector<Region> overlapping_regions;
184 std::vector<uint64_t> keys_to_remove;
187 for (
const auto& [start_addr, region] : m_regions) {
188 if (region.start < new_end && region.end > new_start) {
189 overlapping_regions.push_back(region);
190 keys_to_remove.push_back(start_addr);
195 for (uint64_t key : keys_to_remove) {
196 m_regions.erase(key);
202 std::shared_ptr<TargetInfoType> target;
205 Interval(uint64_t s, uint64_t e, std::shared_ptr<TargetInfoType> t)
206 : start(s), end(e), target(t), priority(t->priority)
211 std::vector<Interval> intervals;
212 intervals.reserve(overlapping_regions.size() + 1);
215 intervals.emplace_back(new_start, new_end, new_target);
218 for (
const Region& region : overlapping_regions) {
219 intervals.emplace_back(region.start, region.end, region.target);
223 std::set<uint64_t> boundaries;
224 for (
const Interval& interval : intervals) {
225 boundaries.insert(interval.start);
226 boundaries.insert(interval.end);
230 auto boundary_it = boundaries.begin();
231 while (boundary_it != boundaries.end()) {
232 uint64_t seg_start = *boundary_it;
234 if (boundary_it == boundaries.end())
break;
235 uint64_t seg_end = *boundary_it;
238 std::shared_ptr<TargetInfoType> best_target =
nullptr;
239 uint32_t best_priority = UINT32_MAX;
241 for (
const Interval& interval : intervals) {
243 if (interval.start <= seg_start && interval.end >= seg_end) {
244 if (interval.priority < best_priority) {
245 best_priority = interval.priority;
246 best_target = interval.target;
253 m_regions.emplace(seg_start, Region(seg_start, seg_end, best_target));
258 for (
const Interval& interval : intervals) {
260 if (interval.start == new_start && interval.end == new_end && interval.target == new_target) {
266 bool completely_shadowed =
true;
269 for (
const auto& [seg_start, region] : m_regions) {
271 if (region.target == interval.target && region.start < interval.end &&
272 region.end > interval.start) {
274 completely_shadowed =
false;
279 if (completely_shadowed) {
280 std::stringstream ss;
281 ss <<
"Region '" << interval.target->name <<
"' (0x" << std::hex << interval.start <<
"-0x"
282 << (interval.end - 1) <<
", priority " << std::dec << interval.priority
283 <<
") is completely shadowed by higher priority regions and will never be accessed";
284 SC_REPORT_WARNING(
"addressMap", ss.str().c_str());
291 addressMap() =
default;
307 void add(std::shared_ptr<TargetInfoType> t_info)
309 uint64_t start = t_info->address;
310 uint64_t end = t_info->address + t_info->size;
312 split_and_resolve(start, end, t_info);
331 std::shared_ptr<TargetInfoType> find(uint64_t address, uint64_t size)
334 std::shared_ptr<TargetInfoType> cached_result;
335 if (m_cache.get(address, cached_result)) {
336 return cached_result;
341 auto it = m_regions.upper_bound(address);
342 if (it != m_regions.begin()) {
346 if (address >= it->second.start && address < it->second.end) {
348 m_cache.put(address, it->second.target, size);
349 return it->second.target;
354 m_cache.put(address,
nullptr, size);
374 std::shared_ptr<TargetInfoType> find_region(uint64_t addr, tlm::tlm_dmi& dmi)
377 auto it = m_regions.upper_bound(addr);
378 if (it != m_regions.begin()) {
380 if (addr >= it->second.start && addr < it->second.end) {
385 std::shared_ptr<TargetInfoType> target = it->second.target;
386 dmi.set_start_address(it->second.start);
387 dmi.set_end_address(it->second.end - 1);
393 uint64_t hole_start = 0;
394 uint64_t hole_end = std::numeric_limits<uint64_t>::max();
397 it = m_regions.upper_bound(addr);
398 if (it != m_regions.begin()) {
400 if (it->second.end <= addr) {
401 hole_start = it->second.end;
406 it = m_regions.upper_bound(addr);
407 if (it != m_regions.end()) {
408 hole_end = it->second.start;
412 dmi.set_start_address(hole_start);
413 dmi.set_end_address(hole_end == 0 ? 0 : hole_end - 1);
424 hits = m_cache.get_hits();
425 misses = m_cache.get_misses();
434 SCP_LOGGER_VECTOR(D);
436 SCP_LOGGER((DMI),
"dmi");
441 std::set<int> initiators;
444 dmi_info(tlm::tlm_dmi& _dmi) { dmi = _dmi; }
447 std::map<uint64_t, dmi_info> m_dmi_info_map;
459 dmi_info* in_dmi_cache(tlm::tlm_dmi& dmi)
461 auto it = m_dmi_info_map.find(dmi.get_start_address());
462 if (it != m_dmi_info_map.end()) {
463 if (it->second.dmi.get_end_address() != dmi.get_end_address()) {
467 std::stringstream ss;
468 ss <<
"Can't handle that: DMI overlap with differing end address (0x" << std::hex
469 << it->second.dmi.get_end_address() <<
" vs 0x" << dmi.get_end_address() <<
")";
470 SC_REPORT_ERROR(
"DMI", ss.str().c_str());
472 return &(it->second);
474 auto insit = m_dmi_info_map.emplace(dmi.get_start_address(), dmi_info(dmi));
475 return &(insit.first->second);
488 void record_dmi(
int id, tlm::tlm_dmi& dmi)
490 auto it = m_dmi_info_map.find(dmi.get_start_address());
491 if (it != m_dmi_info_map.end()) {
492 if (it->second.dmi.get_end_address() != dmi.get_end_address()) {
493 SCP_WARN((DMI)) <<
"A new DMI overlaps with an old one, invalidating the old one";
494 invalidate_direct_mem_ptr_ts(0, dmi.get_start_address(),
495 dmi.get_end_address());
499 dmi_info* dinfo = in_dmi_cache(dmi);
500 dinfo->initiators.insert(
id);
512 void register_boundto(std::string s)
override
514 s = gs::router_if<BUSWIDTH>::nameFromSocket(s);
516 std::shared_ptr<target_info> ti_ptr = std::make_shared<target_info>();
518 ti_ptr->index = bound_targets.size();
519 SCP_LOGGER_VECTOR_PUSH_BACK(D, ti_ptr->name);
520 SCP_DEBUG((D[ti_ptr->index])) <<
"Connecting : " << ti_ptr->name;
521 ti_ptr->chained =
false;
522 std::string tmp = name();
524 for (i = 0; i < tmp.length(); i++)
525 if (s[i] != tmp[i])
break;
526 ti_ptr->shortname = s.substr(i);
527 bound_targets.push_back(ti_ptr);
540 std::string txn_tostring(
const target_info* ti, tlm::tlm_generic_payload& trans)
542 std::stringstream info;
543 const char* cmd =
"UNKOWN";
544 switch (trans.get_command()) {
545 case tlm::TLM_IGNORE_COMMAND:
548 case tlm::TLM_WRITE_COMMAND:
551 case tlm::TLM_READ_COMMAND:
557 <<
"0x" << std::hex << trans.get_address();
558 info <<
" len:" << trans.get_data_length();
559 unsigned char* ptr = trans.get_data_ptr();
560 if ((trans.get_command() == tlm::TLM_READ_COMMAND && trans.get_response_status() == tlm::TLM_OK_RESPONSE) ||
561 (trans.get_command() == tlm::TLM_WRITE_COMMAND &&
562 trans.get_response_status() == tlm::TLM_INCOMPLETE_RESPONSE)) {
564 for (
int i = trans.get_data_length(); i; i--) {
565 info << std::setw(2) << std::setfill(
'0') << std::hex << (
unsigned int)(ptr[i - 1]);
568 info <<
" " << trans.get_response_string() <<
" ";
569 for (
int i = 0; i < tlm::max_num_extensions(); i++) {
570 if (trans.get_extension(i)) {
571 info <<
" extn:" << i;
581 tlm_utils::multi_passthrough_target_socket<router<BUSWIDTH, CacheType>, BUSWIDTH>
target_socket;
587 std::vector<std::shared_ptr<target_info>> alias_targets;
589 addressMap<target_info> m_address_map;
591 std::vector<std::shared_ptr<target_info>> id_targets;
594 std::vector<PathIDExtension*> m_pathIDPool;
595#if defined(THREAD_SAFE) and THREAD_SAFE
597 std::mutex m_pool_mutex;
609 void stamp_txn(
int id, tlm::tlm_generic_payload& txn)
612 txn.get_extension(ext);
613 if (ext ==
nullptr) {
614#if defined(THREAD_SAFE) and THREAD_SAFE
615 std::lock_guard<std::mutex> l(m_pool_mutex);
617 if (m_pathIDPool.size() == 0) {
620 ext = m_pathIDPool.back();
621 m_pathIDPool.pop_back();
623 txn.set_extension(ext);
637 void unstamp_txn(
int id, tlm::tlm_generic_payload& txn)
640 txn.get_extension(ext);
642 assert(ext->back() ==
id);
644 if (ext->size() == 0) {
645#if defined(THREAD_SAFE) and THREAD_SAFE
646 std::lock_guard<std::mutex> l(m_pool_mutex);
648 txn.clear_extension(ext);
649 m_pathIDPool.push_back(ext);
665 void b_transport(
int id, tlm::tlm_generic_payload& trans, sc_core::sc_time& delay)
667 sc_dt::uint64 addr = trans.get_address();
670 SCP_WARN(())(
"Attempt to access unknown register at offset 0x{:x}", addr);
671 trans.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
675 stamp_txn(
id, trans);
677 SCP_TRACE((D[ti->index]), ti->name) <<
"Start b_transport :" << txn_tostring(ti.get(), trans);
679 if (trans.get_response_status() >= tlm::TLM_INCOMPLETE_RESPONSE) {
680 if (ti->use_offset) trans.set_address(addr - ti->address);
684 if (ti->use_offset) trans.set_address(addr);
687 SCP_TRACE((D[ti->index]), ti->name) <<
"Completed b_transport :" << txn_tostring(ti.get(), trans);
689 unstamp_txn(
id, trans);
703 unsigned int transport_dbg(
int id, tlm::tlm_generic_payload& trans)
708 sc_dt::uint64 addr = trans.get_address();
711 trans.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
715 if (ti->use_offset) trans.set_address(addr - ti->address);
716 SCP_TRACE((D[ti->index]), ti->name) <<
"calling dbg_transport : " << scp::scp_txn_tostring(trans);
718 if (ti->use_offset) trans.set_address(addr);
734 bool get_direct_mem_ptr(
int id, tlm::tlm_generic_payload& trans, tlm::tlm_dmi& dmi_data)
739 sc_dt::uint64 addr = trans.get_address();
741 tlm::tlm_dmi dmi_data_hole;
742 auto ti = m_address_map.find_region(addr, dmi_data_hole);
744 UnderlyingDMITlmExtension* u_dmi;
745 trans.get_extension(u_dmi);
748 (
"DMI info 0x{:x} 0x{:x} {}", dmi_data_hole.get_start_address(), dmi_data_hole.get_end_address(),
749 (ti ?
"mapped" :
"nomap"));
750 u_dmi->add_dmi(
this, dmi_data_hole, (ti ? gs::tlm_dmi_ex::dmi_mapped : gs::tlm_dmi_ex::dmi_nomap));
756 if (ti->use_offset) trans.set_address(addr - ti->address);
757 SCP_TRACE((D[ti->index]), ti->name) <<
"calling get_direct_mem_ptr : " << scp::scp_txn_tostring(trans);
758 bool status =
initiator_socket[ti->index]->get_direct_mem_ptr(trans, dmi_data);
759 if (ti->use_offset) trans.set_address(addr);
761 if (ti->use_offset) {
762 assert(dmi_data.get_start_address() < ti->size);
763 dmi_data.set_start_address(ti->address + dmi_data.get_start_address());
764 dmi_data.set_end_address(ti->address + dmi_data.get_end_address());
767 if (dmi_data.get_start_address() < dmi_data_hole.get_start_address()) {
768 dmi_data.set_dmi_ptr(dmi_data.get_dmi_ptr() +
769 (dmi_data_hole.get_start_address() - dmi_data.get_start_address()));
770 dmi_data.set_start_address(dmi_data_hole.get_start_address());
772 if (dmi_data.get_end_address() > dmi_data_hole.get_end_address()) {
773 dmi_data.set_end_address(dmi_data_hole.get_end_address());
775 record_dmi(
id, dmi_data);
778 (
"Providing DMI (status {:x}) {:x} - {:x}", status, dmi_data.get_start_address(), dmi_data.get_end_address());
792 void invalidate_direct_mem_ptr(
int id, sc_dt::uint64 start, sc_dt::uint64 end)
794 if (id_targets[
id]->use_offset) {
795 start = id_targets[id]->address + start;
796 end = id_targets[id]->address + end;
798 invalidate_direct_mem_ptr_ts(
id, start, end);
812 void invalidate_direct_mem_ptr_ts(
int id, sc_dt::uint64 start, sc_dt::uint64 end)
814 auto it = m_dmi_info_map.upper_bound(start);
816 if (it != m_dmi_info_map.begin()) {
823 std::set<int> initiators;
825 while (it != m_dmi_info_map.end()) {
826 tlm::tlm_dmi& r = it->second.dmi;
828 if (r.get_start_address() > end) {
833 if (r.get_end_address() < start) {
838 for (
auto t : it->second.initiators) {
839 SCP_TRACE((DMI)) <<
"Queueing initiator " << t <<
" for invalidation, its bounds are [0x" << std::hex
840 << it->second.dmi.get_start_address() <<
" - 0x" << it->second.dmi.get_end_address()
842 initiators.insert(t);
844 it = m_dmi_info_map.erase(it);
846 for (
auto t : initiators) {
847 SCP_INFO((DMI)) <<
"Invalidating initiator " << t <<
" [0x" << std::hex << start <<
" - 0x" << end <<
"]";
863 std::shared_ptr<target_info>
decode_address(tlm::tlm_generic_payload& trans)
override
867 sc_dt::uint64 addr = trans.get_address();
868 return m_address_map.find(addr, trans.get_data_length());
878 if (!lazy_init) lazy_initialize();
883 std::atomic<bool> m_initialized{
false };
885#if defined(THREAD_SAFE) and THREAD_SAFE
886 std::mutex m_init_mutex;
888 std::list<std::string> get_matching_children(cci::cci_broker_handle broker,
const std::string& prefix,
889 const std::vector<cci_name_value_pair>& list)
891 size_t prefix_len = prefix.length() + 1;
892 std::list<std::string> children;
893 for (
const auto& p : list) {
894 if (p.first.find(prefix) == 0) {
896 std::string child = p.first.substr(prefix_len, p.first.find(
".", prefix_len) - prefix_len);
897 children.push_back(child);
918 void lazy_initialize()
override
921 if (m_initialized.load(std::memory_order_acquire)) {
925#if defined(THREAD_SAFE) and THREAD_SAFE
927 std::lock_guard<std::mutex> lock(m_init_mutex);
931 if (m_initialized.load(std::memory_order_relaxed)) {
937 auto all_alias_range =
m_broker.get_unconsumed_preset_values([](
const std::pair<std::string, cci_value>& iv) {
938 return iv.first.find(
".aliases.") != std::string::npos;
940 std::vector<cci_name_value_pair> all_alias(all_alias_range.begin(), all_alias_range.end());
942 for (
auto& ti_ptr : bound_targets) {
943 std::string name = ti_ptr->name;
945 if (gs::cci_get<std::string>(
m_broker, ti_ptr->name +
".0", src)) {
947 if (
m_broker.has_preset_value(ti_ptr->name +
".address") &&
948 m_broker.get_preset_cci_value(ti_ptr->name +
".address").is_number()) {
949 SCP_WARN((D[ti_ptr->index]), ti_ptr->name)
950 (
"The configuration alias provided ({}) will be ignored as a valid address is also provided.", src);
952 if (src[0] ==
'&') src = (src.erase(0, 1)) +
".target_socket";
953 if (!
m_broker.has_preset_value(src +
".address")) {
954 std::stringstream ss;
955 ss <<
"The configuration alias provided (" << src <<
") can not be found.";
956 SC_REPORT_ERROR(
"router", ss.str().c_str());
963 ti_ptr->address = gs::cci_get<uint64_t>(
m_broker, name +
".address");
964 ti_ptr->size = gs::cci_get<uint64_t>(
m_broker, name +
".size");
965 ti_ptr->use_offset = gs::cci_get_d<bool>(
m_broker, name +
".relative_addresses",
true);
966 ti_ptr->chained = gs::cci_get_d<bool>(
m_broker, name +
".chained",
false);
967 ti_ptr->priority = gs::cci_get_d<uint32_t>(
m_broker, name +
".priority", 0);
969 SCP_INFO((D[ti_ptr->index]), ti_ptr->name)
970 <<
"Address map " << ti_ptr->name <<
" at address "
971 <<
"0x" << std::hex << ti_ptr->address <<
" size "
972 <<
"0x" << std::hex << ti_ptr->size << (ti_ptr->use_offset ?
" (with relative address) " :
" ")
973 <<
"priority : " << ti_ptr->priority;
974 if (ti_ptr->chained) SCP_DEBUG(())(
"{} is chained so debug will be suppressed", ti_ptr->name);
977 m_address_map.add(ti_ptr);
978 for (std::string n : get_matching_children(
m_broker, (ti_ptr->name +
".aliases"), all_alias)) {
979 std::string alias_name = ti_ptr->name +
".aliases." + n;
980 uint64_t address = gs::cci_get<uint64_t>(
m_broker, alias_name +
".address");
981 uint64_t size = gs::cci_get<uint64_t>(
m_broker, alias_name +
".size");
982 SCP_INFO((D[ti_ptr->index]), ti_ptr->name)(
"Adding alias {} {:#x} (size: {})", alias_name, address,
986 std::shared_ptr<target_info> alias_ti_ptr = std::make_shared<target_info>(*ti_ptr);
987 alias_ti_ptr->address = address;
988 alias_ti_ptr->size = size;
989 alias_ti_ptr->name = alias_name;
990 alias_targets.push_back(alias_ti_ptr);
993 m_address_map.add(alias_ti_ptr);
995 id_targets.push_back(ti_ptr);
999 m_initialized.store(
true, std::memory_order_release);
1003 cci::cci_param<bool> lazy_init;
1015 explicit router(
const sc_core::sc_module_name& nm, cci::cci_broker_handle broker = cci::cci_get_broker())
1016 : sc_core::sc_module(nm)
1017 ,
initiator_socket(
"initiator_socket", [&](std::string s) -> void { register_boundto(s); })
1018 , target_socket(
"target_socket")
1021 , lazy_init(
"lazy_init",
false,
"Initialize the router lazily (eg. during simulation rather than BEOL)")
1023 SCP_DEBUG(()) <<
"router constructed";
1025 target_socket.register_b_transport(
this, &router<BUSWIDTH, CacheType>::b_transport);
1026 target_socket.register_transport_dbg(
this, &router<BUSWIDTH, CacheType>::transport_dbg);
1027 target_socket.register_get_direct_mem_ptr(
this, &router<BUSWIDTH, CacheType>::get_direct_mem_ptr);
1028 initiator_socket.register_invalidate_direct_mem_ptr(
this,
1029 &router<BUSWIDTH, CacheType>::invalidate_direct_mem_ptr);
1030 SCP_DEBUG((DMI)) <<
"router Initializing DMI SCP reporting";
1056 void add_target(TargetSocket& t,
const uint64_t address, uint64_t size,
bool masked =
true,
1057 unsigned int priority = 0)
1059 std::string s = gs::router_if<BUSWIDTH>::nameFromSocket(t.get_base_export().name());
1060 if (!
m_broker.has_preset_value(s +
".address")) {
1061 m_broker.set_preset_cci_value(s +
".address", cci::cci_value(address));
1063 if (!
m_broker.has_preset_value(s +
".size")) {
1064 m_broker.set_preset_cci_value(s +
".size", cci::cci_value(size));
1066 if (!
m_broker.has_preset_value(s +
".relative_addresses")) {
1067 m_broker.set_preset_cci_value(s +
".relative_addresses", cci::cci_value(masked));
1069 if (!
m_broker.has_preset_value(s +
".priority")) {
1070 SCP_DEBUG(())(
"Setting prio to {}", priority);
1071 m_broker.set_preset_cci_value(s +
".priority", cci::cci_value(priority));
1099 void get_cache_stats(uint64_t& hits, uint64_t& misses)
const { m_address_map.get_cache_stats(hits, misses); }