ADEvent now stores the event indices associated with func entry/exit and comm send/recv to avoid having to do string comparisons for every event

Other minor improvements to ADEvent that may boost performance
Fixed some ADEvent unit tests incorrectly assigning different eids to the same event types and added catch for future errors of this type

Author: giltirn

include/chimbuko/ad/ADEvent.hpp

@@ -312,6 +312,12 @@ namespace chimbuko {
      */
     const std::unordered_map<int, std::string> *m_counterMap;
 
+    int m_eidx_func_entry; /**< If previously seen, the eid corresponding to the function entry event (-1 otherwise)*/
+    int m_eidx_func_exit; /**< If previously seen, the eid corresponding to the function exit event (-1 otherwise)*/
+    int m_eidx_comm_send; /**< If previously seen, the eid corresponding to the comm send event (-1 otherwise)*/
+    int m_eidx_comm_recv; /**< If previously seen, the eid corresponding to the comm recv event (-1 otherwise)*/
+
+
 
     /**
      * @brief communication event stack. Once a function call has exited, all comms events are associated with that call and the stack is cleared

src/ad/ADEvent.cpp

@@ -8,7 +8,8 @@
 using namespace chimbuko;
 
 ADEvent::ADEvent(bool verbose) 
-  : m_funcMap(nullptr), m_eventType(nullptr), m_counterMap(nullptr), m_verbose(verbose)
+  : m_funcMap(nullptr), m_eventType(nullptr), m_counterMap(nullptr), m_verbose(verbose),
+    m_eidx_func_entry(-1), m_eidx_func_exit(-1), m_eidx_comm_send(-1), m_eidx_comm_recv(-1)
 {
 
 }
@@ -123,31 +124,49 @@ CallListIterator_t ADEvent::addCall(const ExecData_t &exec){
 
 
 EventError ADEvent::addFunc(const Event_t& event) {
+  //Determine the event type. Use the known event indices if previously determined, otherwise find them
   if (m_eventType == nullptr) {
     std::cerr << "Uninitialized eventType\n";
     return EventError::UnknownEvent;
   }
-
-  std::string eventType;
   int eid = static_cast<int>(event.eid());
-  if (m_eventType->count(eid) == 0) {
-    std::cerr << "Unknown event in eventType: " << eid << std::endl;
-    return EventError::UnknownEvent;
+
+  bool is_entry(false), is_exit(false);
+
+  if(eid == m_eidx_func_entry){
+    is_entry = true;
+  }else if(eid == m_eidx_func_exit){
+    is_exit = true;
+  }else{
+    //Event might be an unknown type *or* the m_eidx* members have not yet been set
+    auto it = m_eventType->find(eid);
+    if(it == m_eventType->end()){ //event index is not in the map??
+      std::cerr << "Unknown event in eventType: " << eid << std::endl;
+      return EventError::UnknownEvent;
+    }
+    if(m_eidx_func_entry == -1 && it->second == "ENTRY"){
+      m_eidx_func_entry = eid;
+      is_entry = true;
+    }else if(m_eidx_func_exit == -1 && it->second == "EXIT"){
+      m_eidx_func_exit = eid;
+      is_exit = true;
+    }
   }
 
+  //Get the iterator to the function name
   if (m_funcMap == nullptr) {
     std::cerr << "Uninitialized function map\n";
     return EventError::UnknownEvent;
   }
-    
-  if (m_funcMap->count(event.fid()) == 0) {
+  auto func_name_it = m_funcMap->find(event.fid());
+
+  if(func_name_it == m_funcMap->end()){
     std::cerr << "Unknown function event\n";
     return EventError::UnknownFunc;
   }
+  const std::string &func_name = func_name_it->second;
 
-  eventType = m_eventType->find(eid)->second;
-
-  if (eventType.compare("ENTRY") == 0){
+  if(is_entry){
     //Create a new ExecData_t object with function entry information and push onto the call list
     CallList_t& cl = m_callList[event.pid()][event.rid()][event.tid()];
 
@@ -159,20 +178,20 @@ EventError ADEvent::addFunc(const Event_t& event) {
       it->set_parent(cs.top()->get_id());
       cs.top()->inc_n_children();
     }
-    it->set_funcname(m_funcMap->find(event.fid())->second);
+    it->set_funcname(func_name);
     cs.push(it);
 
     //Add the new call to the map of call index string
     m_callIDMap[it->get_id()] = it;
 
     return EventError::OK;
-  }else if (eventType.compare("EXIT") == 0){
+  }else if(is_exit){
     CallStack_t& cs = m_callStack[event.pid()][event.rid()][event.tid()];
     if (cs.size() == 0) { //Expect to have at least one entry; that created when the ENTRY was encountered
       std::stringstream ss;
       ss << "\n***** Empty call stack! *****" << std::endl
 	 << "Event information: " << event.get_json().dump() << std::endl
-	 << "Event type: " << m_eventType->find(event.eid())->second << "  Function name: " << m_funcMap->find(event.fid())->second << std::endl;
+	 << "Event type: EXIT  Function name: " << func_name << std::endl;
       recoverable_error(ss.str());
       return EventError::EmptyCallStack;
     }
@@ -183,13 +202,8 @@ EventError ADEvent::addFunc(const Event_t& event) {
       std::stringstream ss;
       ss << "\n***** Invalid EXIT event! *****" << std::endl
 	 << "Event information: " << event.get_json().dump() << std::endl
-	 << "Event type: " << m_eventType->find(event.eid())->second << "  Function name: " << m_funcMap->find(event.fid())->second << std::endl;
+	 << "Event type: EXIT  Function name: " << func_name << std::endl;
       recoverable_error(ss.str());
-      
-      // while (!cs.empty()) {
-      //     std::cerr << *cs.top() << std::endl;
-      //     cs.pop();
-      // }            
       return EventError::CallStackViolation;
     }
     //Remove the object from the stack (it still lives in the CallList)
@@ -249,22 +263,41 @@ EventError ADEvent::addFunc(const Event_t& event) {
 }
 
 EventError ADEvent::addComm(const Event_t& event) {
-  if (m_eventType == nullptr)
+  if (m_eventType == nullptr) {
+    std::cerr << "Uninitialized eventType\n";
     return EventError::UnknownEvent;
-
+  }
   int eid = static_cast<int>(event.eid());
-  if (m_eventType->count(eid) == 0)
-    return EventError::UnknownEvent;
 
-  std::string eventType = m_eventType->find(eid)->second;
+  bool is_send(false), is_recv(false);
+
+  if(eid == m_eidx_comm_send){
+    is_send = true;
+  }else if(eid == m_eidx_comm_recv){
+    is_recv = true;
+  }else{
+    //Event might be an unknown type *or* the m_eidx* members have not yet been set
+    auto it = m_eventType->find(eid);
+    if(it == m_eventType->end()){ //event index is not in the map??
+      std::cerr << "Unknown event in eventType: " << eid << std::endl;
+      return EventError::UnknownEvent;
+    }
+    if(m_eidx_comm_send == -1 && it->second == "SEND"){
+      m_eidx_comm_send = eid;
+      is_send = true;
+    }else if(m_eidx_comm_recv == -1 && it->second == "RECV"){
+      m_eidx_comm_recv = eid;
+      is_recv = true;
+    }
+  }
 
-  if (eventType.compare("SEND") == 0 || eventType.compare("RECV") == 0) {
+  if (is_send || is_recv) {
     CommStack_t& cs = m_commStack[event.pid()][event.rid()][event.tid()];
-    cs.push(CommData_t(event, eventType));
+    cs.push(CommData_t(event, is_send ? "SEND" : "RECV"));
+    return EventError::OK;
   }
-  else return EventError::UnknownEvent;
-
-  return EventError::OK;
+  
+  return EventError::UnknownEvent;
 }
 
 EventError ADEvent::addCounter(const Event_t& event){
@@ -278,7 +311,7 @@ EventError ADEvent::addCounter(const Event_t& event){
   if (it == m_counterMap->end())
     return EventError::UnknownEvent;
 
-  std::string counterName = it->second;
+  const std::string &counterName = it->second;
   CounterStack_t &cs = m_counterStack[event.pid()][event.rid()][event.tid()];
   cs.push(CounterData_t(event, counterName));
 

test/unit_tests/ad/ADEvent.cpp

@@ -38,10 +38,20 @@ struct ADFuncEventContainer{
   int addEvent(const FuncEvent &ev){ events.push_back(ev); return events.size() - 1; } //returns index of last added event
 
   void registerEvents(){
-    for(int i=0;i<events.size();i++) event_types[ events[i].data[IDX_E] ] = events[i].event_type;
+    for(int i=0;i<events.size();i++){
+      int eid = events[i].data[IDX_E];
+      if(event_types.count(eid) && event_types[eid] != events[i].event_type)
+	throw("registerEvents: multiple event types have same eid!");
+      event_types[eid] = events[i].event_type;
+    }
   }
   void registerFuncs(){
-    for(int i=0;i<events.size();i++) func_map[ events[i].data[FUNC_IDX_F] ] = events[i].func_name;
+    for(int i=0;i<events.size();i++){
+      int fid = events[i].data[FUNC_IDX_F];
+      if(func_map.count(fid) && func_map[fid] != events[i].func_name)
+	throw("registerFuncs: multiple funcs have same fid!");      
+      func_map[fid] = events[i].func_name;
+    }
   }
   void linkEventType(){
     event_manager.linkEventType(&event_types);
@@ -221,13 +231,15 @@ TEST(ADEventTesttrimCallList, trimsCorrectly){
   ADFuncEventContainer ad;
   long time = 100;
 
-  int event_idx = 0;
   int fid1=0;
   int fid2=1;
 
-  int idx_entry = ad.addEvent(FuncEvent("ENTRY","MYFUNC" ,event_idx++,fid1,  0    ));
-  int idx_exit = ad.addEvent(FuncEvent("EXIT","MYFUNC"   ,event_idx++,fid1,  time ));
-  int idx_entry2 = ad.addEvent(FuncEvent("ENTRY","MYFUNC",event_idx++,fid2,  time+50   )); //different function
+  int eid_entry = 0;
+  int eid_exit = 1;
+
+  int idx_entry = ad.addEvent(FuncEvent("ENTRY","MYFUNC" ,eid_entry,fid1,  0    ));
+  int idx_exit = ad.addEvent(FuncEvent("EXIT","MYFUNC"   ,eid_exit,fid1,  time ));
+  int idx_entry2 = ad.addEvent(FuncEvent("ENTRY","MYFUNC2",eid_entry,fid2,  time+50   )); //different function
   ad.initializeAD();
   EXPECT_EQ( ad.event_manager.addFunc(ad[idx_entry]), EventError::OK );
   EXPECT_EQ( ad.event_manager.addFunc(ad[idx_exit]), EventError::OK );
@@ -263,13 +275,15 @@ TEST(ADEventTest, purgeCallList){
   ADFuncEventContainer ad;
   long time = 100;
 
-  int event_idx = 0;
   int fid1=0;
   int fid2=1;
 
-  int idx_entry = ad.addEvent(FuncEvent("ENTRY","MYFUNC" ,event_idx++,fid1,  0    ));
-  int idx_exit = ad.addEvent(FuncEvent("EXIT","MYFUNC"   ,event_idx++,fid1,  time ));
-  int idx_entry2 = ad.addEvent(FuncEvent("ENTRY","MYFUNC",event_idx++,fid2,  time+50   )); //different function
+  int eid_entry = 0;
+  int eid_exit = 1;
+
+  int idx_entry = ad.addEvent(FuncEvent("ENTRY","MYFUNC" ,eid_entry,fid1,  0    ));
+  int idx_exit = ad.addEvent(FuncEvent("EXIT","MYFUNC"   ,eid_exit,fid1,  time ));
+  int idx_entry2 = ad.addEvent(FuncEvent("ENTRY","MYFUNC2",eid_entry,fid2,  time+50   )); //different function
   ad.initializeAD();
   EXPECT_EQ( ad.event_manager.addFunc(ad[idx_entry]), EventError::OK );
   EXPECT_EQ( ad.event_manager.addFunc(ad[idx_exit]), EventError::OK );