1 #define TRACE_NAME "RoutingManagerPolicy"
2 #include "TRACE/tracemf.h"
4 #include "artdaq/DAQdata/Globals.hh"
5 #include "artdaq/RoutingPolicies/RoutingManagerPolicy.hh"
7 #include "fhiclcpp/ParameterSet.h"
10 : tokens_used_since_last_update_(0)
11 , next_sequence_id_(1)
15 routing_cache_max_size_ = ps.get<
size_t>(
"routing_cache_size", 1000);
24 std::lock_guard<std::mutex> lk(tokens_mutex_);
25 CreateRoutingTable(table);
27 CreateRoutingTableFromCache(table);
31 CreateRoutingTableFromCache(table);
39 if (receiver_ranks_.count(rank) == 0u)
41 TLOG(TLVL_INFO) <<
"Adding rank " << rank <<
" to receivers list (initial tokens=" << new_slots_free <<
")";
42 receiver_ranks_.insert(rank);
44 TLOG(TLVL_DEBUG + 35) <<
"AddReceiverToken BEGIN";
45 std::lock_guard<std::mutex> lk(tokens_mutex_);
46 if (new_slots_free == 1)
48 tokens_.push_back(rank);
54 for (
unsigned i = 0; i < new_slots_free; ++i)
56 auto it = tokens_.begin();
59 std::advance(it, rand() % tokens_.size());
61 tokens_.insert(it, rank);
64 if (tokens_.size() > max_token_count_)
66 max_token_count_ = tokens_.size();
68 TLOG(TLVL_DEBUG + 35) <<
"AddReceiverToken END";
73 next_sequence_id_ = 1;
74 std::unique_lock<std::mutex> lk(tokens_mutex_);
76 receiver_ranks_.clear();
83 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
84 if (routing_cache_.count(seq))
90 std::lock_guard<std::mutex> tlk(tokens_mutex_);
91 auto entry = CreateRouteForSequenceID(seq, requesting_rank);
92 if (entry.sequence_id == seq)
94 routing_cache_[seq].emplace_back(seq, entry.destination_rank, requesting_rank);
101 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
102 if (routing_cache_.count(seq))
104 for (
auto& entry : routing_cache_[seq])
106 if (entry.requesting_rank == requesting_rank)
113 std::lock_guard<std::mutex> tlk(tokens_mutex_);
114 auto entry = CreateRouteForSequenceID(seq, requesting_rank);
115 if (entry.sequence_id == seq)
117 routing_cache_[seq].emplace_back(seq, entry.destination_rank, requesting_rank);
126 void artdaq::RoutingManagerPolicy::TrimRoutingCache()
128 while (routing_cache_.size() > routing_cache_max_size_)
130 routing_cache_.erase(routing_cache_.begin());
136 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
138 for (
auto& entry : table)
140 if (!routing_cache_.count(entry.sequence_id))
142 routing_cache_[entry.sequence_id].emplace_back(entry.sequence_id, entry.destination_rank, my_rank);
149 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
153 for (
auto& cache_entry : routing_cache_)
155 if (!cache_entry.second[0].included_in_table)
158 cache_entry.second[0].included_in_table =
true;
void AddReceiverToken(int rank, unsigned new_slots_free)
Add a token to the token list.
A row of the Routing Table.
void Reset()
Reset the policy, setting the next sequence ID to be used to 1, and removing any tokens.
detail::RoutingPacketEntry GetRouteForSequenceID(artdaq::Fragment::sequence_id_t seq, int requesting_rank)
Get an artdaq::detail::RoutingPacketEntry for a given sequence ID and rank. Used by RequestBasedEvent...
Multiple sources sending to a single destination. RoutingManager pushes table updates to all senders...
std::vector< RoutingPacketEntry > RoutingPacket
A RoutingPacket is simply a vector of RoutingPacketEntry objects. It is not suitable for network tran...
static RoutingManagerMode stringToRoutingManagerMode(std::string const &modeString)
Convert String to RoutingManagerMode.
RoutingManagerPolicy(const fhicl::ParameterSet &ps)
RoutingManagerPolicy Constructor.
Multiple sources sending to a single destination. Table updates are triggered by senders requesting r...
detail::RoutingManagerMode routing_mode_
Current routing mode.
detail::RoutingPacket GetCurrentTable()
Create a RoutingPacket from currently-owned tokens. Used by EventBuilder and RequestBasedEventBuilder...
One source sending to one destination (i.e. moving around completed events). Uses request-based routi...