mlCallGraph.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2009, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
// Tree structure for holding timers.
 
#ifndef ML_CALL_GRAPH_H
#define ML_CALL_GRAPH_H
 
#include "mlProfilingManagerDllExport.h"
#include "mlTimer.h"
 
#include <map>
#include <unordered_map>
#include <string>
#include <vector>
#include <boost/unordered_map.hpp>
 
#include <iosfwd>
 
#include <memory>
 
class MLCallGraphFunction;
class MLTimeProfile;
 
typedef std::shared_ptr<MLCallGraphFunction> MLCallGraphFunctionPtr;
 
class MLGlobalFunctionKey
{
public:
  std::string function;
  std::string file;
  int line;
 
  inline MLGlobalFunctionKey() : line(0) {}
 
  inline MLGlobalFunctionKey(const std::string& function_, const std::string& file_, int line_)
  {
    function = function_;
    file = file_;
    line = line_;
  }
 
  inline bool operator==(const MLGlobalFunctionKey& other) const {
    return (line == other.line) && (function == other.function) && (file == other.file);
  }
};
 
inline size_t hash_value(MLGlobalFunctionKey const& key)
{
  size_t hash = boost::hash_value(key.function);
  boost::hash_combine(hash, key.file);
  boost::hash_combine(hash, key.line);
  return hash;
}
 
typedef double MLProfilingTimeType;
 
struct MLPROFILINGMANAGER_EXPORT MLTimeStatistics
{
  MLTimeStatistics() { reset(); }
  MLTimeStatistics copy() const;
  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:
  typedef std::unordered_map<MLCallGraphFunction*, MLCallGraphFunction*> CallGraphCopyFunctionMap;
 
public:
  MLCallGraphNode(MLTimeProfile* timeProfile = nullptr,
                  MLCallGraphNode* parent = nullptr,
                  void* userData = nullptr,
                  const MLCallGraphFunctionPtr& callGraphFunction = MLCallGraphFunctionPtr(),
                  const std::string& nodeInfo = "");
 
  ~MLCallGraphNode();
 
  MLCallGraphNode* createChild(MLTimeProfile* timeProfile, const MLCallGraphFunctionPtr& function, void* userData, const std::string& nodeInfo);
 
  const MLTimer& timer() const { return _timer; }
  const MLTimeProfile* timeProfile() const { return _timeProfile; }
  const MLCallGraphFunctionPtr& function() const { return _function; }
  void clearFunctionRecursive();
  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 = "") const;
 
  void printTrace(std::ostream& out) const;
 
  void removeFromParent();
 
  const MLTimeStatistics& statistics() const
  {
    return _statistics;
  }
 
  void* userData() const { return _userData; }
 
  const std::string& nodeInfo() const { return _nodeInfo; }
 
  void clearUserData() { _userData = nullptr; }
 
 
  MLCallGraphNode* deepCopy(CallGraphCopyFunctionMap* copyFunctionMap) const;
 
private:
  MLTimer                       _timer;
  MLCallGraphFunctionPtr        _function;
  MLCallGraphNode*              _parent;
  std::vector<MLCallGraphNode*> _children;
  MLTimeProfile*                _timeProfile;
  MLTimeStatistics              _statistics;
  void*                         _userData;
  std::string                   _nodeInfo;
 
  friend class MLProfilingManager;
  friend class MLTimeProfile;
};
 
class MLPROFILINGMANAGER_EXPORT MLCallGraphFunction
{
public:
  typedef boost::unordered_map<MLCallGraphFunction*, MLTimeStatistics> CallGraphFunctionMap;
  typedef boost::unordered_map<const MLTimeProfile*, MLTimeStatistics> TimeStatisticsMap;
 
public:
  MLCallGraphFunction(const std::string& name, const std::string& filename,
                      int linenumber, int type);
  ~MLCallGraphFunction();
  MLCallGraphFunction* copyWithStatistics() const;
 
  int type() const { return _type; }
  const std::string& name() const { return _name; }
  const std::string& filename() const { return _filename; }
  int linenumber() const { return _linenumber; }
 
  MLCallGraphFunction* cachedCopy(MLCallGraphNode::CallGraphCopyFunctionMap* copyFunctionMap);
 
  MLCallGraphFunction* copiedFrom() const
  {
    return _copiedFrom;
  }
  MLCallGraphFunction* copiedTo() const
  {
    return _copiedTo;
  }
  void addCallGraphNode(MLCallGraphNode* node);
  void removeCallGraphNode(MLCallGraphNode* node);
  const std::vector<MLCallGraphNode*>& callGraphNodes() const { return _callGraphNodes; }
  std::vector<MLCallGraphNode*>& callGraphNodes() { return _callGraphNodes; }
 
  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);
 
  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< TimeStatisticsMap& >(_statisticsByTimeProfile)[timeProfile]; }
 
  bool hasStatisticsForTimeProfile(const MLTimeProfile* timeProfile) const;
 
  const TimeStatisticsMap& statisticsByTimeProfile() const { return _statisticsByTimeProfile; }
 
 
private:
  void removeFunctionFromMap(CallGraphFunctionMap& map, MLCallGraphFunction* function);
 
private:
  std::vector<MLCallGraphNode*> _callGraphNodes;
  std::string                   _name;
  std::string                   _filename;
  int                           _linenumber;
  int                           _type;
 
  MLTimeStatistics _statistics;
  TimeStatisticsMap _statisticsByTimeProfile;
 
  CallGraphFunctionMap _callers;
  CallGraphFunctionMap _callees;
  MLCallGraphFunction* _copiedFrom{nullptr};
  MLCallGraphFunction* _copiedTo{nullptr};
 
  friend class MLCallGraphNode;
  friend class MLTimeProfile;
};
 
 
inline bool MLCallGraphNode::isRecursive() const
{
  MLCallGraphNode* next = _parent;
  while (next) {
    if (_function == next->_function) {
      return true;
    }
    next = next->_parent;
  }
  return false;
}
 
 
 
inline bool MLCallGraphNode::isRecursive(const MLTimeProfile* timeProfile_) const
{
  MLCallGraphNode* next = _parent;
  while (next) {
    if ( (_function == next->_function) && (timeProfile_ == next->_timeProfile) ) {
      return true;
    }
    next = next->_parent;
  }
  return false;
}
 
#endif // _ML_TIMER_TREE_H_