Added a member list of counter indices that will not be passed to the event manager to Chimbuko main class

Added ability to obtain the counter indices of the monitored counters from ADMonitoring; these are passed to the above ignore list so those counters aren't attached to function execution events
Changed the default of ADMonitoring to capture all counters with the default prefix "monitoring: "; this should prevent any monitoring counters from appearing in the provDB in the default setup

Author: giltirn

include/chimbuko/ad/ADMonitoring.hpp

@@ -108,6 +108,11 @@ namespace chimbuko {
      */
     const std::unordered_map<std::string, std::string>& getWatchList() const{ return m_counter_watchlist; }
 
+    /**
+     * @brief Get the indices of the counters associated with the monitoring plugin
+     */
+    std::vector<int> getMonitoringCounterIndices() const;
+
   private:
     bool m_state_set; /**< True if the state has been set at least once*/
     unsigned long m_timestamp; /**< The timestamp of the most recent update*/

include/chimbuko/chimbuko.hpp

@@ -279,6 +279,8 @@ namespace chimbuko {
     unsigned long long m_n_counter_events_accum_prd; /**< Total number of counter events since last write of periodic data*/
     unsigned long m_n_outliers_accum_prd; /**< Total number of outiers detected since last write of periodic data*/
     int m_n_steps_accum_prd; /**< Number of steps since last write of periodic data */
+
+    std::set<unsigned long> m_exec_ignore_counters; /**< Counter indices in this list are ignored by the event manager (but will still be picked up by other components)*/
   };
 
 }

src/ad/ADMonitoring.cpp

@@ -101,12 +101,7 @@ nlohmann::json ADMonitoring::get_json() const{
 }
 
 void ADMonitoring::setDefaultWatchList(){
-  addWatchedCounter("monitoring: Memory Footprint (VmRSS) (KB)", "Memory Footprint (VmRSS) (KB)");
-  addWatchedCounter("monitoring: meminfo:MemAvailable (MB)", "Memory Available (MB)");
-  addWatchedCounter("monitoring: meminfo:MemFree (MB)", "Memory Free (MB)");
-  addWatchedCounter("monitoring: cpu: User %", "CPU Usage User (%)");
-  addWatchedCounter("monitoring: cpu: System %", "CPU Usage System (%)");
-  addWatchedCounter("monitoring: cpu: Idle %", "CPU Usage Idle (%)");
+  setCounterPrefix("monitoring: "); //get all counters prefixed by "monitoring: " ; this prefix is set in the default tau_monitoring.json config file
 }
 
 void ADMonitoring::parseWatchListFile(const std::string &file){
@@ -121,3 +116,11 @@ void ADMonitoring::parseWatchListFile(const std::string &file){
     addWatchedCounter(j_i[0],j_i[1]);
   }
 }
+
+std::vector<int> ADMonitoring::getMonitoringCounterIndices() const{
+  std::vector<int> out(m_cid_state_map.size());
+  size_t i=0;
+  for(auto const &e : m_cid_state_map)
+    out[i++] = e.first;
+  return out; 
+}

src/chimbuko.cpp

@@ -345,6 +345,8 @@ void Chimbuko::finalize()
 
   m_ptr_registry.resetPointers(); //delete all pointers in reverse order to which they were instantiated
   m_ptr_registry.deregisterPointers(); //allow them to be re-registered if init is called again
+
+  m_exec_ignore_counters.clear(); //reset the ignored counters list
 
   m_is_initialized = false;
 
@@ -439,8 +441,11 @@ void Chimbuko::extractEvents(unsigned long &first_event_ts,
   std::vector<Event_t> events = m_parser->getEvents();
   m_perf.add("ad_extract_events_get_events_ms", timer.elapsed_ms());
   timer.start();
-  for(auto &e : events)
-    m_event->addEvent(e);
+  for(auto &e : events){
+    if(e.type() != EventDataType::COUNT || !m_exec_ignore_counters.count(e.counter_id()) ){
+      m_event->addEvent(e);
+    }
+  }
   m_perf.add("ad_extract_events_register_ms", timer.elapsed_ms());
   m_perf.add("ad_extract_events_event_count", events.size());
   if(events.size()){
@@ -474,6 +479,13 @@ void Chimbuko::extractNodeState(){
   if(!m_counter) throw std::runtime_error("Counter is not initialized");
   PerfTimer timer;
   m_monitoring->extractCounters(m_counter->getCountersByIndex());
+
+  //Get the counters that monitoring is watching and tell the event manager to ignore them so they don't get attached to any function execution
+  std::vector<int> cidx_mon_ignore = m_monitoring->getMonitoringCounterIndices();
+  for(int i: cidx_mon_ignore){
+    m_exec_ignore_counters.insert(i);
+  }
+  
   m_perf.add("ad_extract_node_state_ms", timer.elapsed_ms());
 }
 

test/unit_tests/ad/ADMonitoring.cpp

@@ -140,3 +140,22 @@ TEST(ADMonitoringTest, FilterPrefix){
 
   EXPECT_TRUE(mon.hasState("interesting counter2")); //check the one not in the watch list is given the default name
 }
+
+TEST(ADMonitoringTest, CounterIndices){
+  std::unordered_map<int, std::string> counter_map = { {104,"interesting counter 1"}, {99,"interesting counter 2"} };
+  ADMonitoring mon;
+
+  mon.linkCounterMap(&counter_map);
+
+  mon.addWatchedCounter("interesting counter 1", "my counter field 1");
+  mon.addWatchedCounter("interesting counter 2", "my counter field 2");
+
+  CountersByIndex_t data; //don't actually need any observations of the counter for this but we do need to run extractCounters to setup the state buffer
+
+  mon.extractCounters(data);
+
+  std::vector<int> cidx = mon.getMonitoringCounterIndices();
+  ASSERT_EQ(cidx.size(), 2); 
+  EXPECT_EQ(cidx[0], 99); //output will be ordered
+  EXPECT_EQ(cidx[1], 104);
+}