/opt/ros/diamondback/stacks/graspit_simulator/graspit/graspit_source/include/profiling.h

Go to the documentation of this file.

//######################################################################
//
// GraspIt!
// Copyright (C) 2002-2009  Columbia University in the City of New York.
// All rights reserved.
//
// GraspIt! is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GraspIt! is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GraspIt!.  If not, see <http://www.gnu.org/licenses/>.
//
// Author(s): Matei T. Ciocarlie
//
// $Id: profiling.cpp,v 1.6.4.1 2009/07/23 21:18:02 cmatei Exp $
//
//######################################################################

#ifndef _profiling_h_
#define _profiling_h_

#include <iostream>
#include <vector>
#include <string>
#include "assert.h"

namespace Profiling {
        class Profiler;
        inline Profiler &getProfiler();
}

#ifdef PROF_ENABLED

//declarations
#define PROF_DECLARE(STR) namespace Profiling{extern const int STR = getProfiler().getNewIndex(#STR);}

#define PROF_EXTERN(STR) namespace Profiling{extern const int STR;}

//resetting
#define PROF_RESET(STR) Profiling::getProfiler().reset(Profiling::STR);

#define PROF_RESET_ALL Profiling::getProfiler().resetAll();

//counting
#define PROF_COUNT(STR) Profiling::getProfiler().count(Profiling::STR);

//timing
#define PROF_START_TIMER(STR) Profiling::getProfiler().startTimer(Profiling::STR);

#define PROF_STOP_TIMER(STR) Profiling::getProfiler().stopTimer(Profiling::STR);

#define PROF_TIMER_FUNC(STR) Profiling::FunctionTimer fctnTimer__##STR##__(Profiling::getProfiler(),Profiling::STR);

//printing
#define PROF_PRINT(STR) Profiling::getProfiler().print(Profiling::STR);

#define PROF_PRINT_ALL Profiling::getProfiler().printAll();

#else

#define PROF_DECLARE(STR) ;
#define PROF_EXTERN(STR) ;
#define PROF_RESET(STR) ;
#define PROF_RESET_ALL ;
#define PROF_COUNT(STR) ;
#define PROF_START_TIMER(STR) ;
#define PROF_STOP_TIMER(STR) ;
#define PROF_TIMER_FUNC(STR) ;
#define PROF_PRINT(STR) ;
#define PROF_PRINT_ALL ;

#endif

//contains all the low-level calls for getting and processing system time
#include "timer_calls.h"

namespace Profiling {

class ProfileInstance 
{
private:
  int mCount;
  bool mRunning;
  std::string mName;

  PROF_TIME_UNIT mStartTime;
  PROF_DURATION_UNIT mElapsedTime;
public:
  ProfileInstance();
  void setName(const char *name){mName = name;}

  void count(){mCount++;}
  int getCount(){return mCount;}
  void reset()
  {
    mCount=0;
    PROF_RESET_DURATION(mElapsedTime);
    if (mRunning) 
    {
      PROF_GET_TIME(mStartTime);
    }
  }
  void startTimer()
  {
    if (!mRunning) 
    {
      PROF_GET_TIME(mStartTime);
      mRunning = true;
    } 
    else 
    {
      std::cerr << "Timer " << mName << " already running.\n";
    }
  }
  void stopTimer()
  {
    if (mRunning) 
    {
      PROF_TIME_UNIT currentTime;
      PROF_GET_TIME(currentTime);
      PROF_ADD_DURATION( mElapsedTime, mStartTime, currentTime);
      mRunning = false;
    } 
    else 
    {
      std::cerr << "Timer " << mName << " is not running.\n";
    }
  }
  double getTotalTimeMicroseconds();
  void print();
};

class Profiler 
{
private:
  int mNextIndex;
  int mSize;
  std::vector<ProfileInstance> mPI;
#ifdef WIN32
  UINT64 COUNTS_PER_SEC;
#endif
public:
  Profiler();
  ~Profiler();
  
  void resize(int size);
  int getNewIndex(const char *name);

  void count(int index){mPI[index].count();}
  int getCount(int index){return mPI[index].getCount();}
  void reset(int index){mPI[index].reset();}
  void startTimer(int index){mPI[index].startTimer();}
  void stopTimer(int index){mPI[index].stopTimer();}
  void print(int index){mPI[index].print();}
  
  void resetAll();
  void printAll();
#ifdef WIN32
  UINT64 getCountsPerSec(){return COUNTS_PER_SEC;}
#endif
};

Profiler& getProfiler()
{
  //the one and only instance of the profiler
  static Profiler profInstance;
  return profInstance;
 }

class FunctionTimer 
{
private:
  Profiler &mProfiler;
  int mIndex;
public:
 FunctionTimer(Profiler &prof, int index) : mProfiler(prof), mIndex(index) 
 {
   mProfiler.count(mIndex);
   mProfiler.startTimer(mIndex);
 }
  ~FunctionTimer(){mProfiler.stopTimer(mIndex);}
};

}

#endif

---

graspit
Author(s):
autogenerated on Wed Jan 25 10:58:51 2012