Home Research Papers Posters Manuals Talks Download People Help Internal

ck-perf/trace-counter.h

Go to the documentation of this file.

#ifndef __trace_counter_h__
#define __trace_counter_h__

#include <stdio.h>
#include <errno.h>
#include "trace.h"
#include "trace-common.h"
#include "conv-config.h"

#define MAX_ENTRIES 500

//*******************************************************
//* TIME IS ALWAYS IN SECONDS UNTIL IT IS PRINTED OUT,  *
//* IN WHICH CASE IT IS CONVERTED TO (us)               *
//*******************************************************

class StatTable {
  public:
    StatTable();
    ~StatTable();
    void init(int argc);
    void setEp(int epidx, int stat, long long value, double time);
    void write(FILE* fp);
    void clear();
    int numStats() { return numStats_; }
    void doReduction(int phase, double idleTime);

  private:
    struct Statistics {
      char*  name;                    // name of stat being tracked
      char*  desc;                    // description of stat being tracked
      unsigned int numCalled  [MAX_ENTRIES];  // total number times called
      double       avgCount   [MAX_ENTRIES];  // track average of value
      double       stdDevCount[MAX_ENTRIES];  // track stddev of value
      double       totTime    [MAX_ENTRIES];  // total time assoc with counter
      long long    maxCount   [MAX_ENTRIES];  // maximum count among all times
      long long    minCount   [MAX_ENTRIES];  // minimum count among all times

      Statistics(): name(NULL) { }
    };

    Statistics* stats_;             // track stats for each entry point
    int         numStats_;          // size of statistics being tracked
};

class CountLogPool {
  public:
    CountLogPool();
    ~CountLogPool() { }
    // if phase is -1 and always has been, write normal filename
    // if phase not -1, but has been higher before, write filename + "phaseX"
    void write(int phase=-1) ;
    // if phase is -1 and always has been, write normal filename
    // if phase not -1, but has been higher before, write filename + "phaseX"
    void writeSts(int phase=-1);
    FILE* openFile(int phase=-1);
    void setEp(int epidx, 
               int index1, long long count1, 
               int index2, long long count2, 
               double time);
    void clearEps() { stats_.clear(); }
    void init(int argc) { stats_.init(argc); }
    void doReduction(int phase, double idleTime) { 
      stats_.doReduction(phase, idleTime); 
    }

  private:
    StatTable stats_;       // store stats per counter
    int       lastPhase_;   // keep track of last phase for closing behavior
};

class TraceCounter : public Trace {
  public:
    TraceCounter();
    ~TraceCounter();
    void traceInit(char **argv);
    void traceBegin();
    void traceEnd();
    int traceRegisterUserEvent(const char* userEvent) { 
      // CmiPrintf("%d/%d traceRegisterUserEvent(%s)\n", 
      // CkMyPe(), CkNumPes(), userEvent);
      return 0;
    }
    void userEvent(int e) { 
      // CmiPrintf("%d/%d userEvent %d\n", CkMyPe(), CkNumPes(), e); 
    }
    void creation(envelope *e, int epIdx, int num=1) { }
    void messageRecv(char *env, int pe) { }
    void beginExecute(envelope *e);
    void beginExecute(
      int event,   
      int msgType, 
      int ep,      
      int srcPe,   
      int ml=0,   
      CmiObjId *idx=0);   
    void endExecute();
    void beginIdle(double curWallTime);
    void endIdle(double curWallTime);
    void beginPack();
    void endPack();
    void beginUnpack();
    void endUnpack();
    void enqueue(envelope *e) { }
    void dequeue(envelope *e) { }
    void beginComputation();
    void endComputation();
    void traceClearEps();
    void traceWriteSts();
    void traceClose();

    struct CounterArg {
      int         code;
      char*       arg;
      char*       desc;
      CounterArg* next;
      int         index;  // index into statTable

      CounterArg(): code(-1), arg(NULL), desc(NULL), next(NULL), index(-1) { }
      CounterArg(int c, char* a, char* d):
        code(c), arg(a), desc(d), next(NULL), index(-1) { }
      void setValues(int _code, char* _arg, char* _desc) {
        code = _code;  arg = _arg;  desc = _desc;
      }
    };

  private:
    enum TC_Status { IDLE, WORKING };
    int cancel_beginIdle, cancel_endIdle;
    
    // command line processing
    CounterArg* firstArg_;      // pointer to start of linked list of args
    CounterArg* lastArg_;       // pointer to end of linked list of args
    int         argStrSize_;    // size of max arg string (formatted output)
    CounterArg* commandLine_;   // list of command line args
    int         commandLineSz_; // size of commande line args array
    CounterArg* counter1_;      // point to current counter, circle linked list
    CounterArg* counter2_;      // point to current counter, circle linked list
    int         counter1Sz_;    // size of cycle
    int         counter2Sz_;    // size of cycle
    
    // result of different command line opts
    bool        overview_;      // if true, just measure between phases
    bool        switchRandom_;  // if true, switch counters randomly
    bool        switchByPhase_; // if true, switch counters only at phases
    bool        noLog_;         // if true, don't write a log file
    bool        writeByPhase_;  // if true, write out a log file every phase

    // store between start/stop of counter read
    int         execEP_;        // id currently executing entry point
    double      startEP_;       // start time of currently executing ep
    double      startIdle_;     // start time of currently executing idle
    int         genStart_;      // track value of start_counters

    // store state
    double      idleTime_;        // total idle time
    int         phase_;           // current phase
    int         reductionPhase_;  // for reduction output
    bool        traceOn_;         // true if trace is turned on
    TC_Status   status_;          // to prevent errors
    bool        dirty_;           // true if endExecute called 

    void beginOverview();
    void endOverview();
    void switchCounters();
    void registerArg(CounterArg* arg);
    bool matchArg(CounterArg* arg);
    void usage();
    void printHelp();
};

#endif  // __trace_counter_h__

---