MeVis/Foundation/Sources/MLProfilingManager/Include/mlCallGraph.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------
// Tree structure for holding timers.
//
// \file    mlCallGraph.h
// \author  Marcus Barann
// \date    6/2010
//
//----------------------------------------------------------------------------------
#ifndef _ML_TIMER_TREE_H_
#define _ML_TIMER_TREE_H_

#include "mlProfilingManagerDllExport.h"
#include "mlTimer.h"

#include <map>
#include <string>
#include <vector>

#include <iosfwd>


#include <boost/shared_ptr.hpp>

class MLCallGraphFunction;
class MLTimeProfile;

typedef boost::shared_ptr<MLCallGraphFunction> MLCallGraphFunctionPtr;


typedef long double MLProfilingTimeType;

struct MLPROFILINGMANAGER_EXPORT MLTimeStatistics
{
  MLTimeStatistics() { reset(); }
  void reset();
  MLTimeStatistics& operator+=(const MLTimeStatistics& other);

  struct MLPROFILINGMANAGER_EXPORT Values
  {
    Values() { reset(); }
    Values& operator+=(const Values& other);
    void add(MLProfilingTimeType time);
    void reset();
    MLProfilingTimeType minimum;
    MLProfilingTimeType maximum;
    MLProfilingTimeType total;
  };

  Values elapsed;
  Values consumed;
  unsigned int count;
};


class MLPROFILINGMANAGER_EXPORT MLCallGraphNode
{
public:
  MLCallGraphNode(MLTimeProfile* timeProfile = NULL,
                  MLCallGraphNode* parent = NULL,
                  void* userData = NULL,
                  const MLCallGraphFunctionPtr& callGraphFunction = MLCallGraphFunctionPtr());

  ~MLCallGraphNode();

  MLCallGraphNode* createChild(MLTimeProfile* timeProfile, const MLCallGraphFunctionPtr& function, void* userData);

  const MLTimer& timer() const { return _timer; }
  const MLTimeProfile* timeProfile() const { return _timeProfile; }
  const MLCallGraphFunctionPtr& function() const { return _function; }
  const std::vector<MLCallGraphNode*>& children() const { return _children; }
  MLCallGraphNode* parent() const { return _parent; }

  inline bool isRecursive(const MLTimeProfile* timeProfile) const;

  inline bool isRecursive() const;

  void print(std::ostream& out, const std::string& indent = "", bool doLock=true) const;

  void removeFromParent();

  const MLTimeStatistics& statistics() const { return _statistics; }

  void* userData() const { return _userData; }

  void clearUserData() { _userData = NULL; }

private:
  MLTimer                       _timer;
  MLCallGraphFunctionPtr        _function;
  MLCallGraphNode*              _parent;
  std::vector<MLCallGraphNode*> _children;
  MLTimeProfile*                _timeProfile;
  MLTimeStatistics              _statistics;
  void*                         _userData;

  friend class MLProfilingManager;
  friend class MLTimeProfile;
};


typedef unsigned long long MLCallGraphFunctionId;

class MLPROFILINGMANAGER_EXPORT MLCallGraphFunction
{
public:
  typedef std::map<MLCallGraphFunction*, MLTimeStatistics> CallGraphFunctionMap;
  typedef std::map<const MLTimeProfile*, MLTimeStatistics> TimeStatisticsMap;

public:
  MLCallGraphFunction(MLCallGraphFunctionId id, const std::string& name, const std::string& filename,
                      int linenumber, const std::string& identifier, int type);
  ~MLCallGraphFunction();

  int type() const { return _type; }
  MLCallGraphFunctionId id() const { return _id; }
  const std::string& name() const { return _name; }
  const std::string& filename() const { return _filename; }
  int linenumber() const { return _linenumber; }
  const std::string& identifier() const { return _identifier; }

  void addCallGraphNode(MLCallGraphNode* node);
  void removeCallGraphNode(MLCallGraphNode* node);
  const std::vector<MLCallGraphNode*>& callGraphNodes() const { return _callGraphNodes; }
  std::vector<MLCallGraphNode*>& callGraphNodes() { return _callGraphNodes; }

  static std::string createIdentifier(const std::string& name, const std::string& filename, int linenumber);

  void addCaller(MLCallGraphFunction* function, MLProfilingTimeType elapsed, MLProfilingTimeType consumed);

  const CallGraphFunctionMap& callers() const { return _callers; }

  const CallGraphFunctionMap& callees() const { return _callees; }

  const MLTimeStatistics* statisticsByCaller(MLCallGraphFunction* caller);

  const MLTimeStatistics* statisticsByCallee(MLCallGraphFunction* callee);

  MLCallGraphFunction* getCallee(MLCallGraphFunction* callee);

  MLCallGraphFunction* getCaller(MLCallGraphFunction* caller);

  MLTimeStatistics& statistics() { return _statistics; }
  const MLTimeStatistics& statistics() const { return _statistics; }

  MLTimeStatistics& statistics(const MLTimeProfile* timeProfile) { return _statisticsByTimeProfile[timeProfile]; }
  const MLTimeStatistics& statistics(const MLTimeProfile* timeProfile) const { return const_cast< std::map<const MLTimeProfile*, MLTimeStatistics>& >(_statisticsByTimeProfile)[timeProfile]; }

  bool hasStatisticsForTimeProfile(const MLTimeProfile* timeProfile) const;

  const TimeStatisticsMap& statisticsByTimeProfile() const { return _statisticsByTimeProfile; }


private:
  bool removeFunctionFromMap(CallGraphFunctionMap& map, MLCallGraphFunction* function);

private:
  std::vector<MLCallGraphNode*> _callGraphNodes;
  MLCallGraphFunctionId         _id;
  std::string                   _name;
  std::string                   _filename;
  std::string                   _identifier;
  int                           _linenumber;
  int                           _type;

  MLTimeStatistics  _statistics;
  TimeStatisticsMap _statisticsByTimeProfile;

  CallGraphFunctionMap _callers;
  CallGraphFunctionMap _callees;

  friend class MLCallGraphNode;
  friend class MLTimeProfile;
};


inline bool MLCallGraphNode::isRecursive() const
{
  MLCallGraphNode* next = _parent;
  while (next) {
    if (_function->_id == next->_function->_id) {
      return true;
    }
    next = next->_parent;
  }
  return false;
}



inline bool MLCallGraphNode::isRecursive(const MLTimeProfile* timeProfile_) const
{
  MLCallGraphNode* next = _parent;
  while (next) {
    if ( (_function->_id == next->_function->_id) && (timeProfile_ == next->_timeProfile) ) {
      return true;
    }
    next = next->_parent;
  }
  return false;
}

#endif // _ML_TIMER_TREE_H_