IpplTimings.h

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 *
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/
 
#ifndef IPPL_TIMINGS_H
#define IPPL_TIMINGS_H
 
/*************************************************************************
 * IpplTimings - a simple singleton class which lets the user create and
 *   timers that can be printed out at the end of the program.
 *
 * General usage
 *  1) create a timer:
 *     IpplTimings::TimerRef val = IpplTimings::getTimer("timer name");
 *  This will either create a new one, or return a ref to an existing one
 *
 *  2) start a timer:
 *     IpplTimings::startTimer(val);
 *  This will start the referenced timer running.  If it is already running,
 *  it will not change anything.
 *
 *  3) stop a timer:
 *     IpplTimings::stopTimer(val);
 *  This will stop the timer, assuming it was running, and add in the
 *  time to the accumulating time for that timer.
 *
 *  4) print out the results:
 *     IpplTimings::print();
 *
 *************************************************************************/
 
// include files
#include "Utility/Timer.h"
#include "Utility/my_auto_ptr.h"
 
#include <string>
#include <vector>
#include <map>
#include <limits>
#include <stack>
 
#ifdef TIMERDEBUG
#include <exception>
#endif
 
// a simple class used to store timer values
class IpplTimerInfo
{
public:
    // typedef for reference to a timer
    typedef unsigned int TimerRef;
 
    // constructor
    IpplTimerInfo() : name(""), cpuTime(0.0), wallTime(0.0), indx(std::numeric_limits<TimerRef>::max()) {
        clear();
    }
 
    // destructor
    ~IpplTimerInfo() { }
 
    // timer operations
    void start() {
        if (!running) {
            running = true;
            t.stop();
            t.clear();
            t.start();
        }
#ifdef TIMERDEBUG
        else {
            throw std::runtime_error("Timer '" + name + "' already running");
        }
#endif
    }
 
    void stop() {
        if (running) {
            t.stop();
            running = false;
            cpuTime += t.cpu_time();
            wallTime += t.clock_time();
        }
#ifdef TIMERDEBUG
        else {
            throw std::runtime_error("Timer '" + name + "' already idling");
        }
#endif
    }
 
    void clear() {
        t.stop();
        t.clear();
        running = false;
    }
 
    // the IPPL timer that this object manages
    Timer t;
 
    // the name of this timer
    std::string name;
 
    // the accumulated time
    double cpuTime;
    double wallTime;
 
    // is the timer turned on right now?
    bool running;
 
    // an index value for this timer
    TimerRef indx;
};
 
struct Timing
{
    // typedef for reference to a timer
    typedef unsigned int TimerRef;
 
    // a typedef for the timer information object
    typedef IpplTimerInfo TimerInfo;
 
    // Default constructor
    Timing();
 
    // Destructor - clear out the existing timers
    ~Timing();
 
    // create a timer, or get one that already exists
    TimerRef getTimer(const char *);
 
    // start a timer
    void startTimer(TimerRef);
 
    // stop a timer, and accumulate it's values
    void stopTimer(TimerRef);
 
    // clear a timer, by turning it off and throwing away its time
    void clearTimer(TimerRef);
 
    // return a TimerInfo struct by asking for the name
    TimerInfo *infoTimer(const char *nm) {
        return TimerMap[std::string(nm)];
    }
 
    // print the results to standard out
    void print();
 
    // print the results to a file
    void print(const std::string &fn,
               const std::map<std::string, unsigned int> &problemSize);
 
 
    // type of storage for list of TimerInfo
    typedef std::vector<my_auto_ptr<TimerInfo> > TimerList_t;
    typedef std::map<std::string, TimerInfo *> TimerMap_t;
 
private:
    // a list of timer info structs
    TimerList_t TimerList;
 
    // a map of timers, keyed by string
    TimerMap_t TimerMap;
};
 
 
 
class IpplTimings
{
public:
    // typedef for reference to a timer
    typedef Timing::TimerRef TimerRef;
 
    // a typedef for the timer information object
    typedef Timing::TimerInfo TimerInfo;
 
    // create a timer, or get one that already exists
    static TimerRef getTimer(const char * nm) {
        return instance->getTimer(nm);
    }
 
    // start a timer
    static void startTimer(TimerRef t) {
        instance->startTimer(t);
    }
 
    // stop a timer, and accumulate it's values
    static void stopTimer(TimerRef t) {
        instance->stopTimer(t);
    }
 
    // clear a timer, by turning it off and throwing away its time
    static void clearTimer(TimerRef t) {
        instance->clearTimer(t);
    }
 
    // return a TimerInfo struct by asking for the name
    static TimerInfo *infoTimer(const char *nm) {
        return instance->infoTimer(nm);
    }
 
    // print the results to standard out
    static void print() {
        instance->print();
    }
 
    // print the results to a file
    static void print(std::string fn,
                      const std::map<std::string, unsigned int> &problemSize = std::map<std::string, unsigned int>()) {
        instance->print(fn, problemSize);
    }
 
    static void stash();
    static void pop();
 
private:
    // type of storage for list of TimerInfo
    typedef Timing::TimerList_t TimerList_t;
    typedef Timing::TimerMap_t TimerMap_t;
 
    // Default constructor
    IpplTimings();
 
    // Destructor - clear out the existing timers
    ~IpplTimings();
 
 
    static Timing *instance;
    static std::stack<Timing*> stashedInstance;
};
 
#endif
 
/***************************************************************************
 * $RCSfile: IpplTimings.h,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:33 $
 ***************************************************************************/
 
/***************************************************************************
 * $RCSfile: addheaderfooter,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:17 $
 * IPPL_VERSION_ID: $Id: addheaderfooter,v 1.1.1.1 2003/01/23 07:40:17 adelmann Exp $
 ***************************************************************************/