Ignore non-effective logging and counting events

  e.g. Deletiin of an instance which is already deleted
o Build bgp_stress_test with optimization turned on (linkage issue)
o Add an option to print traces --log-trace-enable (Default: FALSE)
o To help convergence, advertise routes from agents only after subscription
  is complete (With simple WaitForIdle() which is not perfect though..
o Wait for server_->get_output_queue_depth() to reach 0 during initial convergence

Change-Id: I412b73bad6b3267964e528ea1bf373a071bd354d
Partial-Bug: 1464016

src/bgp/bgp_peer_membership.cc

@@ -323,7 +323,7 @@ void IPeerRib::ManagedDelete() {
 // required.  Also create a WorkQueue to handle IPeerRibEvents.
 //
 PeerRibMembershipManager::PeerRibMembershipManager(BgpServer *server) :
-        server_(server) {
+        server_(server), current_jobs_count_(0), total_jobs_count_(0) {
     if (membership_task_id_ == -1) {
         TaskScheduler *scheduler = TaskScheduler::GetInstance();
         membership_task_id_ = scheduler->GetTaskId("bgp::PeerMembership");
@@ -632,6 +632,8 @@ void PeerRibMembershipManager::Register(
     request.instance_id = instance_id;
     request.policy = policy;
     request.notify_completion_fn = notify_completion_fn;
+    current_jobs_count_++;
+    total_jobs_count_++;
 
     tbb::mutex::scoped_lock lock(mutex_);
     IPeerRibEvent *event = ProcessRequest(IPeerRibEvent::REGISTER_RIB, table,
@@ -672,6 +674,8 @@ void PeerRibMembershipManager::Unregister(IPeer *ipeer, BgpTable *table,
     request.action_mask = static_cast<MembershipRequest::Action>(
         MembershipRequest::RIBIN_DELETE | MembershipRequest::RIBOUT_DELETE);
     request.notify_completion_fn = notify_completion_fn;
+    current_jobs_count_++;
+    total_jobs_count_++;
 
     tbb::mutex::scoped_lock lock(mutex_);
 
@@ -695,6 +699,8 @@ void PeerRibMembershipManager::UnregisterPeer(IPeer *ipeer,
     IPeerRibEvent *event = new IPeerRibEvent(IPeerRibEvent::UNREGISTER_PEER,
                                              ipeer, NULL);
 
+    current_jobs_count_++;
+    total_jobs_count_++;
     event->request.action_get_fn = action_get_fn;
     event->request.notify_completion_fn = notify_completion_fn;
     Enqueue(event);
@@ -732,6 +738,8 @@ void PeerRibMembershipManager::UnregisterPeerCallback(IPeerRibEvent *event) {
         request.notify_completion_fn = boost::bind(
             &PeerRibMembershipManager::UnregisterPeerDone,
             this, _1, _2, count, event->request.notify_completion_fn);
+        current_jobs_count_++;
+        total_jobs_count_++;
 
         IPeerRibEvent *process_event;
         process_event = ProcessRequest(IPeerRibEvent::UNREGISTER_RIB,
@@ -775,6 +783,8 @@ void PeerRibMembershipManager::UnregisterPeerDone(
     event->ipeer = ipeer;
     event->table = NULL;
     event->request.notify_completion_fn = notify_completion_fn;
+    current_jobs_count_++;
+    total_jobs_count_++;
     Enqueue(event);
 }
 
@@ -786,6 +796,7 @@ void PeerRibMembershipManager::UnregisterPeerDone(
 void PeerRibMembershipManager::UnregisterPeerCompleteCallback(
                                    IPeerRibEvent *event) {
     // Inform the requestor (PeerCloseManager) that this process is complete
+    current_jobs_count_--;
     event->request.notify_completion_fn(event->ipeer, NULL);
 }
 
@@ -935,6 +946,7 @@ void PeerRibMembershipManager::NotifyCompletion(BgpTable *table,
     for (MembershipRequestList::iterator iter =
             request_list->begin(); iter != request_list->end(); iter++) {
         MembershipRequest *request = iter.operator->();
+        current_jobs_count_--;
         if (request->notify_completion_fn) {
             request->notify_completion_fn(request->ipeer, table);
         }
@@ -1101,6 +1113,7 @@ void PeerRibMembershipManager::ProcessUnregisterRibCompleteEvent(
         }
 
         // Notify the caller indicating the completion this process
+        current_jobs_count_--;
         if (request->notify_completion_fn) {
             request->notify_completion_fn(request->ipeer, event->table);
         }

src/bgp/bgp_peer_membership.h

@@ -240,6 +240,8 @@ class PeerRibMembershipManager {
     bool IsQueueEmpty() const { return event_queue_->IsQueueEmpty(); }
     void FillRegisteredTable(const IPeer *peer, std::vector<std::string> *list);
     size_t GetMembershipCount() const { return peer_rib_set_.size(); }
+    int current_jobs_count() const { return current_jobs_count_; }
+    int total_jobs_count() const { return total_jobs_count_; }
 
 private:
     friend class BgpServerUnitTest;
@@ -290,6 +292,10 @@ class PeerRibMembershipManager {
     static int membership_task_id_;
 
     BgpServer *server_;
+
+    // Counters that track number of ongoing and total work items.
+    int        current_jobs_count_;
+    int        total_jobs_count_;
     WorkQueue<IPeerRibEvent *> *event_queue_;
     PeerRibSet peer_rib_set_;
     RibPeerMap rib_peer_map_;

src/bgp/test/SConscript

@@ -122,7 +122,7 @@ env.Append(LIBS = ['route', 'routing_instance', 'net'])
 
 env.Append(LIBS = ['extended_community', 'origin_vn', 'security_group', 'tunnel_encap'])
 env.Append(LIBS = ['xmpp_unicast', 'xmpp_multicast', 'xmpp_enet',
-                   'boost_regex', 'boost_program_options'])
+                   'boost_regex', 'boost_program_options', 'boost_chrono'])
 
 if sys.platform != 'darwin':
     env.Append(LIBS=['rt'])