8 #include <boost/bind/bind.hpp>
9 #include <boost/foreach.hpp>
21 using std::unique_ptr;
26 using namespace boost::placeholders;
70 typedef map<size_t, PeerRibState>
Map;
72 class iterator :
public boost::iterator_facade<
73 iterator, RibOut, boost::forward_traversal_tag> {
76 : indexmap_(indexmap), map_(map), index_(index) {
78 size_t index()
const {
return index_; }
83 friend class boost::iterator_core_access;
85 Map::const_iterator loc = map_->upper_bound(index_);
86 if (loc == map_->end()) {
93 return index_ == rhs.
index_;
95 RibOut &dereference()
const;
103 circular_iterator, RibOut, boost::forward_traversal_tag> {
106 int start,
bool is_valid)
107 : indexmap_(indexmap), map_(map), index_(-1), match_(true) {
111 Map::const_iterator loc = map_->lower_bound(start);
112 if (loc == map_->end()) {
116 if (is_valid) match_ =
false;
118 int index()
const {
return index_; }
123 friend class boost::iterator_core_access;
126 assert(!map_->empty());
127 Map::const_iterator loc = map_->upper_bound(index_);
128 if (loc == map_->end()) {
134 return ((match_ == rhs.
match_) && (index_ == rhs.
index_));
136 RibOut &dereference()
const;
145 : key_(peer), index_(-1),
147 in_sync_(true), rib_iterator_(
BitSet::npos) {
159 return rib_bitset_.test(index);
163 Map::const_iterator it = rib_set_.begin();
164 size_t index = (it != rib_set_.end() ? it->first : -1);
165 return iterator(indexmap, &rib_set_, index);
168 return iterator(indexmap, &rib_set_, -1);
182 Map::iterator loc = rib_set_.find(rib_index);
183 assert(loc != rib_set_.end());
184 if (!
BitIsSet(loc->second.qactive, queue_id)) {
185 SetBit(loc->second.qactive, queue_id);
186 qactive_cnt_[queue_id]++;
192 Map::iterator loc = rib_set_.find(rib_index);
193 assert(loc != rib_set_.end());
194 if (
BitIsSet(loc->second.qactive, queue_id)) {
195 ClearBit(loc->second.qactive, queue_id);
196 qactive_cnt_[queue_id]--;
202 Map::iterator loc = rib_set_.find(rib_index);
203 assert(loc != rib_set_.end());
204 return BitIsSet(loc->second.qactive, queue_id);
207 int QueueCount(
int queue_id) {
return qactive_cnt_[queue_id]; }
211 size_t index()
const {
return index_; }
220 bool empty()
const {
return rib_set_.empty(); }
256 iterator, PeerState, boost::forward_traversal_tag> {
259 const BitSet &set,
size_t index)
260 : indexmap_(indexmap), set_(set), index_(index) {
262 size_t index()
const {
return index_; }
265 friend class boost::iterator_core_access;
267 index_ = set_.find_next(index_);
270 return index_ == rhs.
index_;
273 return *indexmap_.At(index_);
281 : key_(ribout), index_(-1), in_sync_(
RibOutUpdates::QCOUNT, true) {
287 bool QueueSync(
int queue_id);
288 void SetQueueSync(
int queue_id);
289 void SetQueueUnsync(
int queue_id);
294 return iterator(indexmap, peer_set_, peer_set_.find_first());
302 size_t index()
const {
return index_; }
304 bool empty()
const {
return peer_set_.none(); }
320 peer_set_.set(ps->
index());
325 peer_set_.reset(ps->
index());
330 return (in_sync_[queue_id]);
335 in_sync_[queue_id] =
true;
340 in_sync_[queue_id] =
false;
346 rib_set_.insert(make_pair(rs->
index(),
init));
347 rib_bitset_.set(rs->
index());
353 SetQueueInactive(rs->
index(), queue_id);
355 rib_set_.erase(rs->
index());
356 rib_bitset_.reset(rs->
index());
361 for (Map::iterator it = rib_set_.begin(); it != rib_set_.end(); ++it) {
362 assert(it->second.qactive == 0);
365 assert(qactive_cnt_[i] == 0);
371 return *indexmap_.At(index_)->ribout();
375 return *indexmap_.At(index_)->ribout();
381 :
Task(partition->task_id(), partition->index()),
382 partition_(partition) {
389 unique_ptr<WorkBase> wentry = partition_->WorkDequeue();
394 switch (wentry->type) {
395 case WorkBase::WRibOut: {
400 case WorkBase::WPeer: {
402 partition_->UpdatePeer(workpeer->
peer);
410 string Description()
const {
return "BgpSenderPartition::Worker"; }
533 return (ps ? ps->
in_sync() :
false);
557 unique_ptr<WorkBase> wentry;
573 "bgp::PeerMembership");
611 if (wpeer->
peer != peer)
613 wpeer->
valid =
false;
640 if (wribout->
ribout != ribout)
642 wribout->
valid =
false;
771 RibOut *ribout = it.operator->();
794 bool done = updates->
TailDequeue(queue_id, msync, &blocked, &munsync);
828 if (!
BitIsSet(it.peer_rib_state().qactive, queue_id))
832 RibOut *ribout = it.operator->();
835 bool done = updates->
PeerDequeue(queue_id, peer, &blocked);
917 int grp_peer_count = 0;
918 int peer_grp_count = 0;
961 task_id_(
TaskScheduler::GetInstance()->GetTaskId(
"bgp::SendUpdate")),
963 TaskScheduler::GetInstance()->GetTaskId(
"bgp::SendReadyTask"), 0,
1008 partitions_[index]->RibOutActive(ribout, queue_id);
bool equal(const circular_iterator &rhs) const
RibOut & dereference() const
const PeerRibState & peer_rib_state() const
circular_iterator(const RibStateMap &indexmap, Map *map, int start, bool is_valid)
const RibStateMap & indexmap_
bool equal(const iterator &rhs) const
const RibStateMap & indexmap_
iterator(const RibStateMap &indexmap, Map *map, size_t index)
RibOut & dereference() const
const PeerRibState & peer_rib_state() const
PeerState(IPeerUpdate *peer)
iterator end(const RibStateMap &indexmap)
void SetQueueInactive(size_t rib_index, int queue_id)
void set_send_ready(bool toggle)
vector< int > qactive_cnt_
bool IsQueueActive(size_t rib_index, int queue_id)
void SetIteratorStart(size_t start)
int QueueCount(int queue_id)
iterator begin(const RibStateMap &indexmap)
void set_index(size_t index)
void SetQueueActive(size_t rib_index, int queue_id)
circular_iterator circular_begin(const RibStateMap &indexmap)
map< size_t, PeerRibState > Map
circular_iterator circular_end(const RibStateMap &indexmap)
bool CheckInvariants() const
std::atomic< bool > send_ready_
DISALLOW_COPY_AND_ASSIGN(PeerState)
IPeerUpdate * peer() const
void Remove(RibState *rs)
bool IsMember(size_t index) const
PeerState & dereference() const
const PeerStateMap & indexmap_
bool equal(const iterator &rhs) const
iterator(const PeerStateMap &indexmap, const BitSet &set, size_t index)
DISALLOW_COPY_AND_ASSIGN(RibState)
void set_index(size_t index)
iterator begin(const PeerStateMap &indexmap)
bool QueueSync(int queue_id)
void SetQueueUnsync(int queue_id)
iterator end(const PeerStateMap &indexmap)
const BitSet & peer_set() const
void SetQueueSync(int queue_id)
void Remove(PeerState *ps)
Worker(BgpSenderPartition *partition)
virtual bool Run()
Code to execute in a task. Returns true if task is completed. Return false to reschedule the task.
BgpSenderPartition * partition_
string Description() const
Gives a description of the task.
bool CheckInvariants() const
std::unique_ptr< WorkBase > WorkDequeue()
void RibOutActive(RibOut *ribout, int queue_id)
void SetSendBlocked(RibOut *ribout, int queue_id, const RibPeerSet &blocked)
void Remove(RibOut *ribout, IPeerUpdate *peer)
void Add(RibOut *ribout, IPeerUpdate *peer)
void WorkRibOutInvalidate(RibOut *ribout)
bool PeerIsSendReady(IPeerUpdate *peer) const
void BuildSyncBitSet(const RibOut *ribout, RibState *rs, RibPeerSet *msync)
void WorkRibOutEnqueue(RibOut *ribout, int queue_id)
void SetQueueSync(PeerState *ps, int queue_id)
void set_disabled(bool disabled)
bool IsQueueActive(RibOut *ribout, int queue_id, IPeerUpdate *peer)
bool PeerIsRegistered(IPeerUpdate *peer) const
RibStateMap rib_state_imap_
void WorkPeerEnqueue(IPeerUpdate *peer)
BgpUpdateSender * sender_
void UpdatePeer(IPeerUpdate *peer)
void PeerSendReady(IPeerUpdate *peer)
void SetQueueActive(const RibOut *ribout, RibState *rs, int queue_id, const RibPeerSet &munsync)
bool PeerInSync(IPeerUpdate *peer) const
bool UpdatePeerQueue(IPeerUpdate *peer, PeerState *ps, int queue_id)
PeerStateMap peer_state_imap_
BgpSenderPartition(BgpUpdateSender *sender, int index)
void WorkEnqueue(WorkBase *wentry)
void UpdateRibOut(RibOut *ribout, int queue_id)
void WorkPeerInvalidate(IPeerUpdate *peer)
bool PeerInSync(IPeerUpdate *peer) const
void Leave(RibOut *ribout, IPeerUpdate *peer)
bool PeerIsRegistered(IPeerUpdate *peer) const
BgpSenderPartition * partition(int index)
bool CheckInvariants() const
void Join(RibOut *ribout, IPeerUpdate *peer)
bool SendReadyCallback(IPeerUpdate *peer)
void RibOutActive(int index, RibOut *ribout, int queue_id)
BgpUpdateSender(BgpServer *server)
WorkQueue< IPeerUpdate * > send_ready_queue_
std::vector< BgpSenderPartition * > partitions_
void PeerSendReady(IPeerUpdate *peer)
size_t find_first() const
size_t find_next(size_t pos) const
bool Contains(const BitSet &rhs) const
bool test(size_t pos) const
static int PartitionCount()
virtual bool send_ready() const
ValueType * At(int index) const
const BitsetType & bits() const
ValueType * Locate(const KeyType &key)
void Remove(const KeyType &key, int index, bool clear_bit=true)
ValueType * Find(const KeyType &key) const
virtual bool PeerDequeue(int queue_id, IPeerUpdate *peer, RibPeerSet *blocked)
virtual bool TailDequeue(int queue_id, const RibPeerSet &msync, RibPeerSet *blocked, RibPeerSet *unsync)
RibOutUpdates * updates(int idx)
IPeerUpdate * GetPeer(int index) const
int GetPeerIndex(IPeerUpdate *peer) const
The TaskScheduler keeps track of what tasks are currently schedulable. When a task is enqueued it is ...
void Enqueue(Task *task)
Enqueues a task for running. Starts task if all policy rules are met else puts task in waitq....
static TaskScheduler * GetInstance()
CancelReturnCode Cancel(Task *task)
Cancels a Task that can be in RUN/WAIT state. The caller needs to ensure that the task exists when Ca...
Task is a class to describe a computational task within OpenSDN control plane applications....
bool Enqueue(QueueEntryT entry)
void Shutdown(bool delete_entries=true)
#define CHECK_CONCURRENCY(...)
void SetBit(IntType &value, size_t bit)
void ClearBit(IntType &value, size_t bit)
void STLDeleteValues(Container *container)
bool BitIsSet(IntType value, size_t bit)
#define CHECK_INVARIANT(Cond)