src/ck-pics/picsautoperf.h

   1 #ifndef  TRACE__AUTOPERF__H__
   2 #define  TRACE__AUTOPERF__H__
   3 #define _VERBOSE_H
   4
   5 #include "picstreenode.h"
   6 #include "picsdecisiontree.h"
   7 #include "picsautoperfAPI.h"
   8 #include <errno.h>
   9 #include "charm++.h"
  10 #include "trace.h"
  11 #include "envelope.h"
  12 #include "register.h"
  13 #include "trace-common.h"
  14 #include "TraceAutoPerf.decl.h"
  15 #include "trace-projections.h"
  16 #include <vector>
  17 #include <map>
  18 #include <list>
  19 #include <fstream>
  20 #include <iostream>
  21 #include <utility>
  22
  23
  24 CkpvExtern(int, numOfPhases);
  25 class SavedPerfDatabase;
  26 CkpvExtern(SavedPerfDatabase*, perfDatabase);
  27 CkpvExtern(DecisionTree*, learnTree);
  28 CkpvExtern(int, perfGoal);
  29
  30 //scalable tree analysis
  31 CkpvExtern(int, myParent);
  32 CkpvExtern(int, myInterGroupParent);
  33 CkpvExtern(int, numChildren);
  34
  35
  36 extern CkGroupID traceAutoPerfGID;
  37 extern CProxy_TraceAutoPerfBOC autoPerfProxy;
  38 extern int treeBranchFactor;
  39 extern int numGroups;
  40 extern int treeGroupSize;
  41
  42 /*
  43  * raw performance summary data
  44  */
  45 class PerfData {
  46 public:
  47   double data[NUM_NODES];
  48   double timeStep;
  49   double energy;
  50   double utilPercentage;
  51   double overheadPercentage;
  52   double idlePercentage;
  53   double userMetrics;
  54
  55   PerfData() {}
  56
  57   PerfData(double step, double util, double idle, double overhead)
  58   {
  59     timeStep = step;
  60     idlePercentage = idle;
  61     overheadPercentage = overhead;
  62     utilPercentage = util;
  63   }
  64
  65   void copy(PerfData *src)
  66   {
  67     timeStep = src->timeStep;
  68     energy = src->energy;
  69     utilPercentage = src->utilPercentage;
  70     overheadPercentage = src->overheadPercentage;
  71     idlePercentage = src->idlePercentage;
  72     userMetrics = src->userMetrics;
  73   }
  74
  75   void printMe(FILE *fp, const char *str) {
  76     for(int i=0; i<NUM_NODES; i++)
  77     {
  78       if (i == AVG_IdlePercentage || i == AVG_OverheadPercentage ||
  79           i==AVG_UtilizationPercentage || i==AVG_AppPercentage ||
  80           i == MAX_IdlePercentage || i == MAX_OverheadPercentage ||
  81           i == MAX_UtilizationPercentage || i == MAX_AppPercentage ||
  82           i == MIN_IdlePercentage || i == MIN_OverheadPercentage ||
  83           i == MIN_UtilizationPercentage)
  84         fprintf(fp, "%d %s %.1f\n", i, FieldName[i], 100*data[i]);
  85       else
  86         fprintf(fp, "%d %s %f\n", i, FieldName[i], data[i]);
  87     }
  88   }
  89 };
  90
  91 /*
  92  * a set of history performance summary data
  93  */
  94 template <class DataType> class Database{
  95 private:
  96   std::vector<DataType> array;
  97   int curIdx;
  98   int prevIdx;
  99
 100 public:
 101   Database() {
 102     prevIdx = curIdx = -1;
 103     array.resize(10);
 104     for(int i=0; i<array.size(); i++)
 105       array[i] = NULL;
 106   }
 107
 108   Database(int s) {
 109     prevIdx = curIdx = -1;
 110     array.resize(s);
 111   }
 112
 113   DataType add(DataType source) {
 114     DataType oldData;
 115     prevIdx = curIdx;
 116     curIdx = (curIdx+1)%array.size();
 117     oldData = array[curIdx];
 118     array[curIdx] = source;
 119     if(prevIdx == -1) {
 120       prevIdx = 0;
 121     }
 122     return oldData;
 123   }
 124
 125   DataType getCurrent() {
 126     return array[curIdx];
 127   }
 128
 129   DataType getPrevious() {
 130     return array[prevIdx];
 131   }
 132
 133   //relative position index
 134   DataType getData(int index) {
 135     int i = (curIdx+index+array.size())%array.size();
 136     return array[i];
 137   }
 138
 139 };
 140
 141 CkpvExtern(Database<CkReductionMsg*>*, summaryPerfDatabase);
 142 #define ENTRIES_SAVED       10
 143 class SavedPerfDatabase {
 144 private:
 145   PerfData    *perfList[ENTRIES_SAVED];
 146   PerfData    *best, *secondbest;
 147   int         currentPhase;
 148   double      startTimer;
 149   int         curIdx; //current available
 150   int         prevIdx;
 151 public:
 152
 153   SavedPerfDatabase(void) ;
 154   ~SavedPerfDatabase(void);
 155   void advanceStep(void);
 156   PerfData* getCurrentPerfData(void);
 157   PerfData* getPrevPerfData(void);
 158
 159   void setUserDefinedMetrics(double v) { perfList[curIdx]->userMetrics = v; }
 160   void setPhase(int phaseId) { currentPhase = phaseId; }
 161   void endCurrent(void) ;
 162   void copyData(PerfData *source, int num);   //copy data from source
 163   void setData(PerfData *source);
 164   bool timeStepLonger() { return true;}
 165   double getCurrentTimestepDuration() { return perfList[curIdx]->timeStep; }
 166   double getTimestepRatio() { return perfList[curIdx]->timeStep/perfList[prevIdx]->timeStep; }
 167   double getUtilRatio() { return perfList[curIdx]->utilPercentage/perfList[prevIdx]->utilPercentage; }
 168   double getEnergyRatio() { return 0; }
 169   double getCurrentIdlePercentage() { return perfList[curIdx]->idlePercentage; }
 170   double getPreviousIdlePercentage() { return perfList[prevIdx]->idlePercentage; }
 171   double getIdleRatio() { return  perfList[curIdx]->idlePercentage/perfList[prevIdx]->idlePercentage; }
 172   double getCurrentOverheadPercentage() { return perfList[curIdx]->overheadPercentage; }
 173   double getPreviousOverheadPercentage() { return perfList[prevIdx]->overheadPercentage; }
 174   double getOverheadRatio() { return perfList[curIdx]->overheadPercentage/perfList[prevIdx]->overheadPercentage; }
 175 };
 176
 177 class TraceAutoPerfInit : public Chare {
 178 public:
 179   TraceAutoPerfInit(CkArgMsg*);
 180   TraceAutoPerfInit(CkMigrateMessage *m):Chare(m) {}
 181 };
 182
 183 /*
 184  * class to perform collection, analysis
 185  */
 186 class TraceAutoPerfBOC : public CBase_TraceAutoPerfBOC {
 187 private:
 188   int         numPesCollection;
 189   int         recvChildren;
 190   int         recvGroups;
 191   CkReductionMsg *redMsg;
 192   int         numPesInGroup;
 193
 194   int         picsStep;
 195   bool        isBest;
 196   double      bestTimeStep;
 197   double      currentTimeStep;
 198
 199   int         lastAnalyzeStep;
 200   int         currentAppStep;
 201   int         analyzeStep;
 202   double      endStepTimer;
 203   double      lastCriticalPathLength;
 204   double      lastAnalyzeTimer;
 205   LBDatabase  *theLbdb;
 206   std::vector<IntDoubleMap> solutions;
 207   std::vector<Condition*>    perfProblems;
 208   std::vector<int>            problemProcList;
 209   DecisionTree* priorityTree;
 210   DecisionTree* fuzzyTree;
 211
 212   int     recvGroupCnt;
 213   double  bestMetrics;
 214   int     bestSource;
 215
 216   double startLdbTimer;
 217   double endLdbTimer;
 218
 219 public:
 220   TraceAutoPerfBOC() ;
 221   TraceAutoPerfBOC(CkMigrateMessage *m) : CBase_TraceAutoPerfBOC(m) {};
 222   ~TraceAutoPerfBOC();
 223
 224   void pup(PUP::er &p) {
 225     CBase_TraceAutoPerfBOC::pup(p);
 226   }
 227   void registerPerfGoal(int goalIndex);
 228   void setUserDefinedGoal(double value);
 229   void setAutoPerfDoneCallback(CkCallback cb);
 230   static void staticAtSync(void *data);
 231
 232   void resume();
 233   void resume(CkCallback cb);
 234   void startPhase(int phaseId);
 235   void endPhase();
 236   void startStep();
 237   void endStep(bool fromGlobal, int pe, int incSteps);
 238   void endPhaseAndStep(bool fromGlobal, int pe);
 239   void endStepResumeCb(bool fromGlobal, int pe, CkCallback cb);
 240   void getPerfData(int reductionPE, CkCallback cb);
 241   void run(bool fromGlobal, int fromPE);
 242   void setCbAndRun(bool fromGlobal, int fromPE, CkCallback cb) ;
 243   void PICS_markLDBStart(int appStep) ;
 244   void PICS_markLDBEnd() ;
 245
 246   void setNumOfPhases(int num, const char names[]);
 247   void setProjectionsOutput();
 248   void recvGlobalSummary(CkReductionMsg *msg);
 249
 250   void tuneDone();
 251
 252   //scalable analysis, global decision making
 253   void globalDecision(double metrics, int source);
 254   void analyzeAndTune();
 255   void startTimeNextStep();
 256   void gatherSummary(CkReductionMsg *msg);
 257   void globalPerfAnalyze(CkReductionMsg *msg);
 258
 259   void formatPerfData(PerfData *data, int step, int phase);
 260   void analyzePerfData(PerfData *data, int step, int phase);
 261
 262   void comparePerfData(PerfData *prevData, PerfData *data, int step, int phase);
 263
 264   double getModelNetworkTime(int msgs, long bytes) ;
 265
 266   inline bool isCurrentBest() {
 267     return isBest;
 268   }
 269
 270   inline void setCurrentBest(bool b ) {
 271     isBest = b;
 272   }
 273
 274   inline double getCurrentBestRatio() {
 275     return currentTimeStep/bestTimeStep;
 276   }
 277 };
 278
 279 class ObjIdentifier {
 280 public:
 281   void *objPtr;
 282
 283   ObjIdentifier(void *p) {
 284     objPtr = p;
 285   }
 286
 287   ObjIdentifier(int a, int i, void *p) {
 288     objPtr = p;
 289   }
 290 };
 291
 292 class ObjInfo
 293 {
 294 public:
 295   double executeTime;
 296   long msgCount;
 297   long msgSize;
 298
 299   ObjInfo(double e, long mc, long ms) {
 300     executeTime = e;
 301     msgCount = mc;
 302     msgSize = ms;
 303   }
 304 };
 305
 306 class compare {
 307 public:
 308   bool operator () (const void *x, const void *y) const {
 309     return (x < y);
 310   }
 311 };
 312
 313 typedef std::map<void*, ObjInfo*, compare> ObjectLoadMap_t;
 314
 315
 316 void setCollectionMode(int m) ;
 317 void setEvaluationMode(int m) ;
 318 void setConfigMode(int m) ;
 319
 320 #endif
 321