TestProfiler.C

Go to the documentation of this file.

#include "ProfilerTest.H"
#include "UnixUtils.H"
#include "Application.H"
#include "TestingProgram.H"

#ifdef USE_PAPI
#include <papi.h>
#endif

namespace ix {
  namespace profiler {

#ifdef USE_PAPI
    std::string EventName(int papiEvent)
    {
      std::string retVal;
      char eventName[PAPI_MAX_STR_LEN];
      if(PAPI_event_code_to_name(papiEvent,eventName) != PAPI_OK){
        PAPI_perror("Could not get event name.");
        return(retVal);
      }
      retVal = std::string(eventName);
      return(retVal);
    }

    void testmanager::Test__PAPI(testmanager::Results &result){
      int papiEventSet = PAPI_NULL;
      int maxNumEvents = 12;
      std::vector< std::vector<int> > allowedPairing(maxNumEvents);
      for(int iEvent = 0;iEvent < maxNumEvents;iEvent++){
        allowedPairing[iEvent].resize(maxNumEvents,1);
      }
      std::vector<bool> eventExists(maxNumEvents,true);
      int papiEvents[] = {PAPI_TOT_CYC,PAPI_TOT_INS,PAPI_LST_INS,PAPI_L1_TCM,
                          PAPI_L2_TCM,PAPI_L3_TCM,PAPI_TLB_TL,PAPI_TLB_DM,
                          PAPI_LD_INS,PAPI_SR_INS,PAPI_BR_INS,PAPI_RES_STL};
      PAPI_library_init(PAPI_VER_CURRENT);
      if(PAPI_create_eventset(&papiEventSet) != PAPI_OK){
        PAPI_perror("Could not create EventSet.");
        result.UpdateResult("Profiler:PAPI",false);
        exit(1);
      }
      result.UpdateResult("Profiler:PAPI",true);
      int numWorkingEvents = 0;
      for(int iEvent = 0;iEvent < maxNumEvents;iEvent++){
        int eventCode = papiEvents[iEvent];
        std::cout << "Checking for " << EventName(eventCode) << "... ";
        if(PAPI_query_event(eventCode) != PAPI_OK){
          std::cout << "No";
          eventExists[iEvent] = false;
        } else {
          std::cout << "Yes";
          numWorkingEvents++;
        }
        std::cout << std::endl;
      }
      result.UpdateResult("Profiler:PAPI:WorkingEvents",(numWorkingEvents > 0));
      for(int iEvent = 0;iEvent < maxNumEvents;iEvent++){
        if(!eventExists[iEvent]){
          for(int iClear = 0;iClear < maxNumEvents;iClear++)
            allowedPairing[iEvent][iClear] = 0;
          continue;
        }
        int eventId = papiEvents[iEvent];
        int testEventSet = PAPI_NULL;
        PAPI_create_eventset(&testEventSet);
        PAPI_add_event(testEventSet,eventId);
        std::cout << "PAIRS(" << EventName(eventId) << "): ";
        for(int iPair = iEvent+1;iPair < maxNumEvents;iPair++){
          if(eventExists[iPair]){
            int pairId = papiEvents[iPair];
            if(PAPI_add_event(testEventSet,pairId) != PAPI_OK){
              //              PAPI_perror("Pair not ok.");
              allowedPairing[iEvent][iPair] = 0;
              allowedPairing[iPair][iEvent] = 0;
            } else {
              PAPI_remove_event(testEventSet,pairId);
              std::cout << EventName(pairId) << " ";
            }
          } 
        }
        std::cout << std::endl;
      }
      PAPI_add_event(papiEventSet,PAPI_TOT_CYC);
      long long cycleCount1 = 0;
      long long cycleCount2 = 0;
      long long cycleSum = 0;
      long long maxCycles  = 0;
      long long minCycles  = 1e6;
      unsigned int numTrial = 1000;
      PAPI_start(papiEventSet);
      for(int iTrial = 0;iTrial < numTrial;iTrial++){
        PAPI_read(papiEventSet,&cycleCount1);
        PAPI_read(papiEventSet,&cycleCount2);
        long long cycleCount = cycleCount2 - cycleCount1;
        if(cycleCount > maxCycles) maxCycles = cycleCount;
        if(cycleCount < minCycles) minCycles = cycleCount;
        cycleSum += cycleCount;
      }
      cycleSum /= numTrial;
      std::cout << "PAPI Cycle Interval (min,max,mean) = ("
                << minCycles << "," << maxCycles << ","
                << cycleSum  << ")" << std::endl;
      // if(PAPI_add_event(papiEventSet,PAPI_TOT_CYC) != PAPI_OK)
      //        exit(1);
      // if(PAPI_add_event(papiEventSet,PAPI_TOT_INS) != PAPI_OK)
      //        exit(1);
      // if(PAPI_add_event(papiEventSet,PAPI_LST_INS) != PAPI_OK)
      //        exit(1);
      // // if(PAPI_add_event(papiEventSet,PAPI_L1_TCM) != PAPI_OK){
      // //   std::cout << "Cannot add L1 Misses to counter set." << std::endl;
      // // }
      // // if(PAPI_add_event(papiEventSet,PAPI_L2_TCM) != PAPI_OK){
      // //   std::cout << "Cannot add L2 Misses to counter set." << std::endl;
      // // }
      // if(PAPI_add_event(papiEventSet,PAPI_L3_TCM) != PAPI_OK){
      //        std::cout << "Cannot add L3 Misses to counter set." << std::endl;
      // }
      // // if(PAPI_add_event(papiEventSet,PAPI_TLB_TL) != PAPI_OK){
      // //   std::cout << "Cannot add TLB Misses to counter set." << std::endl;
      // // }
      // //   exit(1);
      // if(PAPI_start(papiEventSet) != PAPI_OK)
      //        exit(1);
      // numCounters = 4;
      // std::vector<long long> counterValues(numCounters,0);
      // std::vector<long long> counterTicks(numCounters,0);
      
    }
#endif
    void testmanager::Test__BasicTimer(testmanager::Results &result) {
      bool basicTimerWorks = true;
      double dtsum = 0.0;
      double dtmin = 1.0e+9;
      double dtmax = 0.0;
      int nTrial = 1000;
      double time0 = Time();
      for(int i = 0;i < nTrial;i++){
        double time1 = Time();
        double time2 = Time();
        double dt = time2 - time1;
        if(dt > dtmax) dtmax = dt;
        if(dt < dtmin) dtmin = dt;
        dtsum += dt;
      }
      double timeAccum = 0.0;
      double timeBegin = Time();
      for(int i=0;i < nTrial;i++)
        timeAccum += Time();
      double timeEnd = Time();
      std::cout << timeAccum << std::endl;
      double totalTime = (timeEnd - timeBegin);
      double timeOverhead = totalTime/((double)nTrial+1);
      double dtmean = dtsum/((double)nTrial);
      std::cout << "DT(min,max,mean) = (" << dtmin << "," 
                << dtmax << "," << dtmean << ")" << std::endl
                << "Time overhead ~= " << timeOverhead << std::endl
                << "Total Time: " << totalTime << std::endl;
      double dtmeancycles = dtmean/1e-9;
      if(dtmeancycles > 500)
        basicTimerWorks = false;
      result.UpdateResult("Profiler:BasicTimer",basicTimerWorks);
      
      ProfilerObj testProfiler;
      testProfiler.Init("test",0);
      double timeFE0 = Time();
      testProfiler.FunctionEntry("test1");
      double timeFE1 = Time();
      for(int i=0;i < nTrial;i++)
        timeAccum += Time();
      double timeFX0 = Time();
      testProfiler.FunctionExit("test1");
      double timeFX1 = Time();
      double totalTime2 = timeFX1 - timeFE0;
      double totalTime0 = timeFX0 - timeFE1;
      double timeEntry  = timeFE1 - timeFE0;
      double timeExit   = timeFX1 - timeFX0;
      double entryOverhead = timeEntry - timeOverhead;
      double exitOverhead  = timeExit  - timeOverhead;
      std::cout << timeAccum << std::endl;
      std::cout << "Total time with profiler: " << totalTime2 << std::endl
                << "Time without profiler: "    << totalTime0 << std::endl
                << "Total Profiler overhead ~= "  
                << (totalTime2 - totalTime0) - 2.0*timeOverhead
                << std::endl
                << "Time/overhead Entry: " << timeEntry << "/" << entryOverhead << std::endl
                << "Time/overhead Exit:  " << timeExit  << "/" << exitOverhead  << std::endl; 
      testProfiler.Finalize();
      std::ostringstream profileOut;
      testProfiler.SummarizeSerialExecution(profileOut);
      std::cout << profileOut.str() << std::endl;
    };

  };
};

int main(int argc,char *argv[])
{
  ix::test::program<ix::profiler::testmanager> testProgram(argc,argv);
  ix::profiler::testmanager &testManager(testProgram.TestObject());
  testManager.SetDriverProgram(&testProgram);

  return(ix::app::ProgramDriver(testProgram));
}