1 #define TRACE_NAME "RoutingManagerPolicy"
3 #include "artdaq/RoutingPolicies/RoutingManagerPolicy.hh"
4 #include "fhiclcpp/ParameterSet.h"
7 : tokens_used_since_last_update_(0)
12 routing_cache_max_size_ = ps.get<
size_t>(
"routing_cache_size", 1000);
21 std::lock_guard<std::mutex> lk(tokens_mutex_);
22 CreateRoutingTable(table);
24 CreateRoutingTableFromCache(table);
28 CreateRoutingTableFromCache(table);
36 if (receiver_ranks_.count(rank) == 0u)
38 TLOG(TLVL_INFO) <<
"Adding rank " << rank <<
" to receivers list (initial tokens=" << new_slots_free <<
")";
39 receiver_ranks_.insert(rank);
41 TLOG(10) <<
"AddReceiverToken BEGIN";
42 std::lock_guard<std::mutex> lk(tokens_mutex_);
43 if (new_slots_free == 1)
45 tokens_.push_back(rank);
51 for (
unsigned i = 0; i < new_slots_free; ++i)
53 auto it = tokens_.begin();
56 std::advance(it, rand() % tokens_.size());
58 tokens_.insert(it, rank);
61 if (tokens_.size() > max_token_count_)
63 max_token_count_ = tokens_.size();
65 TLOG(10) <<
"AddReceiverToken END";
70 next_sequence_id_ = 1;
71 std::unique_lock<std::mutex> lk(tokens_mutex_);
73 receiver_ranks_.clear();
80 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
81 if (routing_cache_.count(seq))
87 std::lock_guard<std::mutex> tlk(tokens_mutex_);
88 auto entry = CreateRouteForSequenceID(seq, requesting_rank);
89 if (entry.sequence_id == seq)
91 routing_cache_[seq].emplace_back(seq, entry.destination_rank, requesting_rank);
98 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
99 if (routing_cache_.count(seq))
101 for (
auto& entry : routing_cache_[seq])
103 if (entry.requesting_rank == requesting_rank)
110 std::lock_guard<std::mutex> tlk(tokens_mutex_);
111 auto entry = CreateRouteForSequenceID(seq, requesting_rank);
112 if (entry.sequence_id == seq)
114 routing_cache_[seq].emplace_back(seq, entry.destination_rank, requesting_rank);
123 void artdaq::RoutingManagerPolicy::TrimRoutingCache()
125 while (routing_cache_.size() > routing_cache_max_size_)
127 routing_cache_.erase(routing_cache_.begin());
134 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
136 for(
auto& entry : table)
138 if (!routing_cache_.count(entry.sequence_id)) {
140 routing_cache_[entry.sequence_id].emplace_back(entry.sequence_id, entry.destination_rank, my_rank);
148 std::lock_guard<std::mutex> lk(routing_cache_mutex_);
152 for (
auto& cache_entry : routing_cache_)
154 if (!cache_entry.second[0].included_in_table) {
156 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...