Statistics.h

Go to the documentation of this file.

/* $Id:$ */

#include <esg/List.h>
#include <time.h>
#include <string.h>
#include <iostream>

#ifndef STATISTICS_H
#define STATISTICS_H

namespace esg {

class Receptor {
public:
        virtual ~Receptor  () {}

        virtual void init () = 0;

        virtual void print (std::ostream& stream) const = 0;
};

class Counter : public Receptor {
protected:
        unsigned long _value; 

public:
        Counter () : _value(0) {}

        virtual void  init  () { _value = 0; }
        virtual void  print (std::ostream& stream) const { stream << _value; }

        void increment () { _value++; }

        void decrement () { _value--; }

        void set (unsigned long v) { _value = v; }

        void add (unsigned long v) { _value += v; }

        unsigned long getValue () const { return _value; }
};


class Stopwatch : public Receptor {
protected:
        time_t _startTime, _stopTime; 
        double _timeDist;             
    
public:
        Stopwatch () : _timeDist(0.) {}

        virtual void init  () { _timeDist = 0.;    }
        virtual void print (std::ostream& stream) const { stream << _timeDist; }

        virtual void start () { time(&_startTime); }

        virtual void stop  () {
            time(&_stopTime);
            _timeDist += difftime(_stopTime, _startTime);
        }

        double getTime () const { return _timeDist; }
};

class StopwatchCPU : public Stopwatch {
public:
        virtual void start () { _startTime = clock(); }
        virtual void stop  () {
            _stopTime  = clock();
            _timeDist += (double)((_stopTime-_startTime)/CLOCKS_PER_SEC);
        }
};


class Statistic {
public:
        typedef unsigned OID; 

protected:
        OID        _oid;
        char     * _name;
        Receptor * _pReceptor;
        
public:
        Statistic(OID o, const char* n, Receptor* r) : _oid(o), _pReceptor(r) {
            _name = new char [strlen(n)+1];
            strcpy(_name, n);
        }

        virtual ~Statistic () {
            if (_name)      delete _name;
            if (_pReceptor) delete _pReceptor;
        }

        const char* name () const { return _name; }

        OID oid () const { return _oid; }

        Receptor* receptor () const { return _pReceptor; }  
};


class Statistics {
private:
        static Statistics * _instance; 
    
public:
        static const unsigned NUM_OIDS;
        static const Statistic::OID OID_BV_TESTS;
        static const Statistic::OID OID_BV_TESTS_SUC;
        static const Statistic::OID OID_PRIM_TESTS;
        static const Statistic::OID OID_PRIM_TESTS_SUC;
        static const Statistic::OID OID_SHADOW_TESTS;
        static const Statistic::OID OID_SHADOW_TESTS_SUC;
        static const Statistic::OID OID_REFLECTIONS;
        static const Statistic::OID OID_REFRACTIONS;
        static const Statistic::OID OID_RENDERING_TIME;
        static const Statistic::OID OID_CPU_RENDERING_TIME;
        static const Statistic::OID OID_PRIMARY_RAYS;

protected:
        Statistic* _stats [11];

protected:
        Statistics ();

public:
        virtual ~Statistics () {
            for (unsigned i = 0; i < NUM_OIDS; i++) delete _stats[i];
        }
        
        static Statistics* instance() {
            if (!_instance) _instance = new Statistics;
            return _instance;
        }

        Statistic* get (Statistic::OID i) { return _stats[i]; }
};


}; // namespace


#endif // STATISTICS_H

---