Added a workaround for another edge case in corid assignment involving multiple sequential zero-runtime functions; in such cases, a function can claim a maximum of 1 correlation ID. + unit test

Author: giltirn

src/ad/ADParser.cpp

@@ -684,6 +684,7 @@ std::vector<Event_t> ADParser::getEvents() const{
 
     unsigned long last_func_entry = 0; //record the entry of the currently open function
     size_t off_t[3] = {0,0,0};
+    bool func_has_corid = false;
 
     while(data_t[0] != nullptr || data_t[1] != nullptr || data_t[2] != nullptr){
       //Determine what kind of func event it is (if !nullptr)
@@ -718,12 +719,37 @@ std::vector<Event_t> ADParser::getEvents() const{
 
       //Catch edge case where ENTRY, CORRID, EXIT all have the same timestamp. We will assume the corrid is associated with this function event
       if(earliest == FUNC && func_event_type == EXIT && data_t[FUNC]->ts() == last_func_entry && 
-	 counter_is_correlation_id && data_t[COUNTER]->ts() == last_func_entry)
-	earliest = COUNTER;
+	 counter_is_correlation_id && data_t[COUNTER]->ts() == last_func_entry){
+	//There is an ambiguity here in cases where ENTRY,COUNTER,EXIT and the ENTRY,COUNTER of the *next* function all have the same timestamp
+	//this can cause the current function to claim the correlation ID which should rightfully belong to the next function
+	//To prevent this we impose a rule (which may not always be true but is perhaps the best we can manage!) that in such cases, a zero-length function
+	//can claim only one correlation ID
+
+	//First determine if an uncoming entry event has the same timestamp
+	unsigned long cur_ts = data_t[FUNC]->ts();
+	bool entry_same_timestamp = false;
+	Event_t* fdata = data_t[FUNC];
+	for(size_t off = off_t[FUNC]+1; off < ndata_t[FUNC]; off++){
+	  ++fdata;
+	  if(fdata->ts() != cur_ts) break;
+	  else if(func_event_type_map_v[fdata->eid()] == ENTRY){
+	    entry_same_timestamp = true; break;
+	  }
+	}
+	    
+	//Then we can impose the rule
+	if(!entry_same_timestamp || (entry_same_timestamp && !func_has_corid))
+	  earliest = COUNTER; //function will claim the corid
+      }
 
       //Record function entry time for logic above
-      if(earliest == FUNC && func_event_type == ENTRY)
+      if(earliest == FUNC && func_event_type == ENTRY){
 	last_func_entry = data_t[FUNC]->ts();
+	func_has_corid = false;
+      }
+
+      if(earliest == COUNTER && counter_is_correlation_id)
+	func_has_corid = true; //note that a function has at least 1 corid attached
 
       out.push_back(*data_t[earliest]);
       ++data_t[earliest];

test/unit_tests/ad/ADParser.cpp

@@ -85,6 +85,7 @@ struct SSTrw{
 };
 
 
+#if 1
 TEST(ADParserTestConstructor, opensTimesoutCorrectlySST){
   std::string filename = "commfile";
   bool got_err= false;
@@ -620,6 +621,7 @@ TEST(ADParserTestFuncDataIO, funcDataLocalToGlobalIndexReplacementWorks){
   psthr.join();
   std::cout << "Main thread finished" << std::endl;
 }
+#endif
 
 //Events same up to id string (set by parser) or idx (set by static count in unit test header)
 bool same_up_to_id_string(const Event_t &l, const Event_t &r){
@@ -954,3 +956,116 @@ TEST(ADParserTest, CorrelationIDeventOrderCorrectly){
     }
   }  
 }
+
+
+
+
+
+TEST(ADParserTest, CorrelationIDeventEdgeCases){
+  std::unordered_map<int, std::string> event_types = { {0,"ENTRY"}, {1,"EXIT"}, {2,"SEND"}, {3,"RECV"} };
+  std::unordered_map<int, std::string> func_names = { {12,"MYFUNC"}, {13,"OTHERFUNC"} };
+  std::unordered_map<int, std::string> counter_names = { {99,"Correlation ID"} };
+
+  int ENTRY = 0;
+  int EXIT = 1;
+  int SEND = 2;
+  int RECV = 3;
+  int CORRID = 99;
+  int MYFUNC = 12;
+  int OTHERFUNC = 13;
+
+  int pid=0, tid=0, rid=0;
+
+
+  {
+    std::cout << "Show that a function will claim a correlation ID if ENTRY, EXIT and COUNTER all have the same timestamp" << std::endl;
+    //    Usually an EXIT event will be prioritized over a COUNTER if they have the same timestamp and the counter is a corid
+    //    because corids are associated with ENTRY events, but the basic logic doesn't work for the case when all 3 have the same timestamp
+    //    We deal with this edge case explicitly
+
+    std::vector<Event_t> events = {
+      createFuncEvent_t(pid, rid, tid, ENTRY, MYFUNC, 100),
+      createFuncEvent_t(pid, rid, tid, EXIT, MYFUNC, 100),
+      createCounterEvent_t(pid, rid, tid, CORRID, 1256, 100),  //correlation ID associated with function
+      createFuncEvent_t(pid, rid, tid, ENTRY, OTHERFUNC, 101),
+      createFuncEvent_t(pid, rid, tid, EXIT, OTHERFUNC, 102)
+    };
+
+    ADParser parser("",0,rid,"BPFile");
+    parser.setFuncDataCapacity(100);
+    parser.setCommDataCapacity(100);
+    parser.setCounterDataCapacity(100);
+    parser.setFuncMap(func_names);
+    parser.setEventTypeMap(event_types);
+    parser.setCounterMap(counter_names);
+
+    for(int i=0;i<events.size();i++){
+      if(events[i].type() == EventDataType::FUNC)
+	parser.addFuncData(events[i].get_ptr());
+      else if(events[i].type() == EventDataType::COMM)
+	parser.addCommData(events[i].get_ptr());
+      else if(events[i].type() == EventDataType::COUNT)
+	parser.addCounterData(events[i].get_ptr());
+      else
+	FAIL() << "Invalid EventDataType";
+    }
+  
+    std::vector<Event_t> events_out = parser.getEvents();
+    
+    EXPECT_EQ(events_out.size(), events.size());
+
+    std::vector<int> order = {0,2,1,3,4};
+    for(int i=0;i<5;i++){
+      std::cout << "Expect " << events[order[i]].get_json().dump() << " got " << events_out[i].get_json().dump() << std::endl;
+      EXPECT_TRUE(  same_up_to_id_string(events_out[i], events[order[i]]) );
+    }
+  }
+
+  {
+    std::cout << "Show that if an ENTRY, CORID, EXIT and the next ENTRY, CORID all coindice, the first function will claim only one of the CORIDs" << std::endl;
+    std::vector<Event_t> events = {
+      createFuncEvent_t(pid, rid, tid, ENTRY, MYFUNC, 100), //0
+      createFuncEvent_t(pid, rid, tid, EXIT, MYFUNC, 100), //1
+      createFuncEvent_t(pid, rid, tid, ENTRY, OTHERFUNC, 100), //2
+      createFuncEvent_t(pid, rid, tid, EXIT, OTHERFUNC, 100), //3
+      createFuncEvent_t(pid, rid, tid, ENTRY, MYFUNC, 100), //4
+      createFuncEvent_t(pid, rid, tid, EXIT, MYFUNC, 100), //5
+      createCounterEvent_t(pid, rid, tid, CORRID, 1256, 100), //6
+      createCounterEvent_t(pid, rid, tid, CORRID, 1257, 100), //7
+      createCounterEvent_t(pid, rid, tid, CORRID, 1258, 100) //8
+    };
+
+    ADParser parser("",0,rid,"BPFile");
+    parser.setFuncDataCapacity(100);
+    parser.setCommDataCapacity(100);
+    parser.setCounterDataCapacity(100);
+    parser.setFuncMap(func_names);
+    parser.setEventTypeMap(event_types);
+    parser.setCounterMap(counter_names);
+
+    for(int i=0;i<events.size();i++){
+      if(events[i].type() == EventDataType::FUNC)
+	parser.addFuncData(events[i].get_ptr());
+      else if(events[i].type() == EventDataType::COMM)
+	parser.addCommData(events[i].get_ptr());
+      else if(events[i].type() == EventDataType::COUNT)
+	parser.addCounterData(events[i].get_ptr());
+      else
+	FAIL() << "Invalid EventDataType";
+    }
+  
+    std::vector<Event_t> events_out = parser.getEvents();
+    
+    EXPECT_EQ(events_out.size(), events.size());
+
+    std::vector<int> order = {0,6,1,2,7,3,4,8,5};
+    for(int i=0;i<order.size();i++){
+      std::cout << "Expect " << events[order[i]].get_json().dump() << " got " << events_out[i].get_json().dump() << std::endl;
+      EXPECT_TRUE(  same_up_to_id_string(events_out[i], events[order[i]]) );
+    }
+  }
+
+
+
+
+}