320class ConfigurableBroker :
public cci_utils::consuming_broker
323 std::set<std::string> m_unignored;
327 std::unordered_map<std::string, cci_value> m_unignored_values;
332 std::set<std::string> hide;
333 friend class PrivateConfigurableBroker;
335 static cci_broker_if& get_broker_interface(cci_broker_handle broker) {
return unwrap_broker(broker); }
337 std::vector<std::string> get_unconsumed_preset_names_with_prefix(
const std::string& prefix)
const
339 std::vector<std::string> names;
340 auto current = m_unignored.lower_bound(prefix);
341 while (current != m_unignored.end() && current->compare(0, prefix.length(), prefix) == 0) {
342 names.emplace_back(*current++);
348 std::string m_orig_name;
349 cci_originator m_originator;
351 cci_broker_if& m_parent;
352 cci_param<ConfigurableBroker*>* m_child_ref;
354 std::unordered_set<std::string> m_initialized;
355 std::function<void(std::string)> m_uninitialized_cb;
357 friend class cci_value_converter<ConfigurableBroker>;
360 cci_broker_if& get_parent_broker()
362 if (sc_core::sc_get_current_object()) {
364 return unwrap_broker(cci_get_broker());
371 std::string hierarchical_name()
373 if (!sc_core::sc_get_current_object()) {
374 return std::string(
"");
376 return cci_originator().name();
379 cci_originator get_cci_originator(
const char* n)
381 if (!sc_core::sc_get_current_object()) {
382 return cci_originator(n);
384 return cci_originator();
387 inline bool is_log_param(
const std::string& parname)
const
389 std::string s_SCP_LOG_LEVEL_PARAM_NAME = SCP_LOG_LEVEL_PARAM_NAME;
390 int s_SCP_LOG_LEVEL_PARAM_NAME_length = s_SCP_LOG_LEVEL_PARAM_NAME.length();
391 int p_len = parname.length();
392 if (p_len >= s_SCP_LOG_LEVEL_PARAM_NAME_length) {
393 return (parname.compare(p_len - s_SCP_LOG_LEVEL_PARAM_NAME_length, s_SCP_LOG_LEVEL_PARAM_NAME_length,
394 s_SCP_LOG_LEVEL_PARAM_NAME) == 0);
405 if (m_uninitialized_cb && (!is_log_param(parname))) {
407 auto pos = std::string::npos;
408 pos = parname.find_last_of(
'.', pos);
409 if (pos == std::string::npos)
break;
410 auto parent = parname.substr(0, pos);
411 if (m_initialized.count(parent) != 0)
break;
412 const_cast<ConfigurableBroker*
>(
this)->m_initialized.insert(parent);
413 m_uninitialized_cb(parent);
416 return ((hide.find(parname) == hide.end()) && (!is_global_broker()));
428 for (
auto& p : list) {
429 hide.insert(relname(p.first));
430 if (!p.second.is_null()) {
431 set_preset_cci_value(relname(p.first), p.second, m_originator);
436 void alias_params(
const std::initializer_list<std::pair<std::string, std::string>>& list)
439 for (
auto& p : list) {
440 std::string aliasname = relname(p.second);
441 set_preset_cci_value(relname(p.first), get_preset_cci_value(aliasname), m_originator);
442 alias_param(relname(p.first), aliasname);
451 void untyped_post_write_callback(
const cci::cci_param_write_event<>& ev, cci::cci_param_handle synced_handle)
453 synced_handle.set_cci_value(ev.new_value);
464 void sync_values(cci::cci_param_handle _param_handle_1, cci::cci_param_handle _param_handle_2)
469 _param_handle_1.set_cci_value(_param_handle_2.get_cci_value());
472 sc_bind(&ConfigurableBroker::untyped_post_write_callback,
this, sc_unnamed::_1, _param_handle_2)));
475 sc_bind(&ConfigurableBroker::untyped_post_write_callback,
this, sc_unnamed::_1, _param_handle_1)));
480 cci_param_create_callback_handle register_cb;
481 std::vector<std::pair<std::string, std::string>> alias_list;
483 void alias_param(std::string a, std::string b)
485 alias_list.push_back(std::make_pair(a, b));
486 if (register_cb == cci_param_create_callback_handle()) {
487 register_cb = register_create_callback(
488 sc_bind(&ConfigurableBroker::alias_param_callback,
this, sc_unnamed::_1), m_originator);
490 alias_param_callback(cci::cci_param_handle());
493 void alias_param_callback(
const cci_param_untyped_handle& ph)
495 alias_list.erase(std::remove_if(alias_list.begin(), alias_list.end(),
497 cci_param_untyped_handle h_a = get_param_handle(a.first, m_originator);
498 if (h_a.is_valid() && h_a.get_mutable_type() == cci::CCI_IMMUTABLE_PARAM) {
501 cci_param_untyped_handle h_b = get_param_handle(a.second, m_originator);
502 if (h_b.is_valid() && !h_a.is_valid()) {
503 set_preset_cci_value(a.first, h_b.get_cci_value(), m_originator);
506 if (h_a.is_valid() && h_b.is_valid()) {
507 sync_values(h_a, h_b);
514 if (alias_list.size() == 0) {
515 unregister_create_callback(register_cb, m_originator);
524 std::vector<cci_name_value_pair> get_consumed_preset_values()
const
526 std::vector<cci_name_value_pair> consumed_preset_cci_values;
527 std::map<std::string, cci_value>::const_iterator iter;
528 std::vector<cci_preset_value_predicate>::const_iterator pred;
530 for (iter = m_unused_value_registry.begin(); iter != m_unused_value_registry.end(); ++iter) {
531 for (pred = m_ignored_unconsumed_predicates.begin(); pred != m_ignored_unconsumed_predicates.end();
533 const cci_preset_value_predicate& p = *pred;
534 if (p(std::make_pair(iter->first, iter->second))) {
538 if (pred != m_ignored_unconsumed_predicates.end()) {
539 consumed_preset_cci_values.push_back(std::make_pair(iter->first, iter->second));
542 return consumed_preset_cci_values;
552#define BROKERNAME "gs::ConfigurableBroker"
554 std::function<
void(std::string)> uninitialized_cb =
nullptr)
555 : consuming_broker(hierarchical_name() +
"." + name)
557 , m_orig_name(hierarchical_name())
558 , m_originator(get_cci_originator(name.c_str()))
559 , m_parent(get_parent_broker())
561 , m_uninitialized_cb(uninitialized_cb)
565 m_child_ref =
new cci_param<ConfigurableBroker*>((name +
".childbroker").c_str(), (
this),
"");
568 cci_register_broker(
this);
578 std::initializer_list<std::pair<std::string, std::string>> alias_list = {},
579 std::function<void(std::string)> uninitialized_cb =
nullptr)
582 initialize_params(list);
583 alias_params(alias_list);
586 std::string relname(
const std::string& n)
const
588 return (m_orig_name.empty()) ? n : m_orig_name + std::string(
".") + n;
598 void set_uninitialized_cb(std::function<
void(std::string)> uninitialized_cb)
600 m_uninitialized_cb = uninitialized_cb;
602 void clear_uninitialized_cb() { m_uninitialized_cb =
nullptr; }
604 cci_originator get_value_origin(
const std::string& parname)
const override
606 if (sendToParent(parname)) {
607 return m_parent.get_value_origin(parname);
609 return consuming_broker::get_value_origin(parname);
615 bool has_preset_value(
const std::string& parname)
const override
617 if (sendToParent(parname)) {
618 return m_parent.has_preset_value(parname);
620 return consuming_broker::has_preset_value(parname);
624 cci_value get_preset_cci_value(
const std::string& parname)
const override
626 if (sendToParent(parname)) {
627 return m_parent.get_preset_cci_value(parname);
629 return consuming_broker::get_preset_cci_value(parname);
633 void lock_preset_value(
const std::string& parname)
override
635 if (sendToParent(parname)) {
636 return m_parent.lock_preset_value(parname);
638 return consuming_broker::lock_preset_value(parname);
642 cci_value get_cci_value(
const std::string& parname,
643 const cci::cci_originator& originator = cci::cci_originator())
const override
645 if (sendToParent(parname)) {
646 return m_parent.get_cci_value(parname, originator);
648 return consuming_broker::get_cci_value(parname, originator);
652 void add_param(cci_param_if* par)
override
654 m_help_helper->clear_unused(par->name());
655 if (sendToParent(par->name())) {
656 return m_parent.add_param(par);
658 m_unignored.erase(par->name());
659 return consuming_broker::add_param(par);
663 void remove_param(cci_param_if* par)
override
665 if (sendToParent(par->name())) {
666 return m_parent.remove_param(par);
668 m_unignored.insert(par->name());
669 return consuming_broker::remove_param(par);
674 std::vector<cci_name_value_pair> get_unconsumed_preset_values()
const override
676 std::vector<cci_name_value_pair> r;
677 for (
const auto& u : m_unignored) {
678 auto value_it = m_unignored_values.find(u);
679 r.emplace_back(u, value_it != m_unignored_values.end() ? value_it->second : get_preset_cci_value(u));
682 std::vector<cci_name_value_pair> p = m_parent.get_unconsumed_preset_values();
683 r.insert(r.end(), p.begin(), p.end());
689 void ignore_unconsumed_preset_values(
const cci_preset_value_predicate& pred)
override
692 m_parent.ignore_unconsumed_preset_values(pred);
694 for (
auto u = m_unignored.begin(); u != m_unignored.end();) {
695 if (pred(make_pair(*u, cci_value(0)))) {
696 m_help_helper->clear_unused(*u);
697 u = m_unignored.erase(u);
704 cci_preset_value_range get_unconsumed_preset_values(
const cci_preset_value_predicate& pred)
const override
706 std::vector<cci_name_value_pair> values;
707 for (
const auto& name : m_unignored) {
708 auto value_it = m_unignored_values.find(name);
709 cci_name_value_pair value(
710 name, value_it != m_unignored_values.end() ? value_it->second : get_preset_cci_value(name));
711 values.emplace_back(std::move(value));
714 for (
const auto& value : m_parent.get_unconsumed_preset_values()) {
715 values.emplace_back(value);
718 return cci_preset_value_range(pred, values);
724 void set_preset_cci_value(
const std::string& parname,
const cci_value& cci_value,
725 const cci_originator& originator)
override
727 m_help_helper->set_unused(parname, originator);
728 if (sendToParent(parname)) {
729 return m_parent.set_preset_cci_value(parname, cci_value, originator);
733 if (locked.find(parname) == locked.end()) {
734 m_unignored.insert(parname);
735 m_unignored_values[parname] = cci_value;
737 return consuming_broker::set_preset_cci_value(parname, cci_value, originator);
741 cci_param_untyped_handle get_param_handle(
const std::string& parname,
742 const cci_originator& originator)
const override
744 if (sendToParent(parname)) {
745 return m_parent.get_param_handle(parname, originator);
747 cci_param_if* orig_param = get_orig_param(parname);
749 return cci_param_untyped_handle(*orig_param, originator);
752 return m_parent.get_param_handle(parname, originator);
754 return cci_param_untyped_handle(originator);
757 std::vector<cci_param_untyped_handle> get_param_handles(
const cci_originator& originator)
const override
760 std::vector<cci_param_untyped_handle> p_param_handles = m_parent.get_param_handles();
761 std::vector<cci_param_untyped_handle> param_handles = consuming_broker::get_param_handles(originator);
765 param_handles.insert(param_handles.end(), p_param_handles.begin(), p_param_handles.end());
766 return param_handles;
768 return consuming_broker::get_param_handles(originator);
772 bool is_global_broker()
const override {
return (!has_parent); }