mlTimeProfile.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
**
**************************************************************************************/
 
// Class for collecting time profiling information.
 
#ifndef ML_TIME_PROFILE_H
#define ML_TIME_PROFILE_H
 
#include "mlProfilingManagerDllExport.h"
 
#include "../Include/mlCallGraph.h"
 
#include <boost/thread/thread.hpp>
#include <boost/unordered_map.hpp>
#include <unordered_set>
#include <vector>
#include <memory>
 
class MLMetaProfile;
class MLTimeProfile;
 
typedef std::shared_ptr<MLCallGraphFunction> MLCallGraphFunctionPtr;
 
typedef std::vector<MLCallGraphNode*>         MLCallGraphNodesVector;
typedef std::unordered_set<MLCallGraphFunctionPtr> MLCallGraphFunctionSet;
typedef std::vector<MLCallGraphFunctionPtr>   MLCallGraphFunctionList;
typedef boost::unordered_map<MLGlobalFunctionKey, MLCallGraphFunctionPtr> MLCallGraphGlobalFunctionMap;
 
class MLPROFILINGMANAGER_EXPORT MLTimeProfileHandle
{
public:
  MLTimeProfileHandle();
 
private:
  MLTimeProfileHandle(MLCallGraphNode* callGraphNode);
 
  MLCallGraphNode* _callGraphNode;
 
  friend class MLTimeProfile;
  friend class ProfilingTest_TestCallGraphIsRecursive_Test;
  friend class ProfilingTest_TestProfileAccumulation_Test;
};
 
 
class MLPROFILINGMANAGER_EXPORT MLTimeProfile
{
public:
  MLTimeProfile(const MLMetaProfile* metaProfile = nullptr);
  ~MLTimeProfile();
 
  MLTimeProfileHandle startMeasuring(const std::string& function,
                                     int userId,
                                     void* userData,
                                     const std::string& filename,
                                     int linenumber,
                                     const std::string& nodeInfo = "");
 
  void stopMeasuring(MLTimeProfileHandle& handle, bool ignoreIfEmpty = false);
 
  void addTimeToFunction(const std::string& function,
                             int userId,
                             const std::string& filename,
                             int linenumber,
                             MLProfilingTimeType time, int callCount);
 
  void reset();
 
  void makeSnapshot();
 
  const MLMetaProfile* metaProfile() const;
 
  MLProfilingTimeType allElapsedTime() const { return _allElapsedTime; }
 
  MLProfilingTimeType allConsumedTime() const { return _allConsumedTime; }
 
  MLProfilingTimeType allElapsedTimeSnapshot() const
  {
    return _allElapsedTimeSnapshot;
  }
 
  MLProfilingTimeType allConsumedTimeSnapshot() const
  {
    return _allConsumedTimeSnapshot;
  }
 
  static MLCallGraphNode& callGraph();
 
  static MLCallGraphNode* callGraphCopy();
 
  static void refreshCallGraphCopy();
 
  const MLCallGraphFunctionSet& usedFunctions() const { return _usedFunctions; }
 
  static const MLCallGraphGlobalFunctionMap& globalFunctionMap() { return getGlobalFunctionMap(); }
 
  static const MLCallGraphFunctionList& globalFunctionList() { return getGlobalFunctionList(); }
 
  static const MLCallGraphFunctionList& globalFunctionListCopy() { return refreshGlobalFunctionListCopy(); }
 
 
  static MLCallGraphFunctionPtr getFunctionGlobal(const std::string& function, const std::string& filename, int linenumber);
 
  MLCallGraphFunctionPtr getFunctionForTesting(const std::string& function) const;
 
  static MLProfilingTimeType globalElapsedTime();
 
  static void setReduceCallGraph(bool reduceCallGraph) { _reduceCallGraph = reduceCallGraph; };
 
  static bool shouldReduceCallGraph() { return _reduceCallGraph; };
 
  static void initialize();
 
  static void deinitialize();
 
  static void enableTracing(const char* filename);
 
  static void disableTracing();
 
  static inline bool isTracingEnabled() { return _traceStream != nullptr; }
 
  static void resetGlobalFunctionListCopy();
 
private:
  MLCallGraphFunctionPtr getOrCreateGlobalFunction(const std::string& function, const std::string& filename, int linenumber, int userId);
 
  void deleteFunction(const MLCallGraphFunctionPtr& function);
 
  static void addGlobalFunction(const MLCallGraphFunctionPtr& function);
 
  static void deleteGlobalFunction(const MLCallGraphFunctionPtr& function);
 
  void removeCallGraphNode(MLCallGraphNode* node);
 
  void updateStatistics(MLTimeStatistics& statistics,
                        bool updateElapsedTime,
                        MLProfilingTimeType elapsedTime,
                        MLProfilingTimeType consumedTime,
                        int callCount = 1);
 
  static void resetGlobalData();
 
public:
  static MLCallGraphFunctionPtr mainFunction;
 
private:
  MLCallGraphFunctionSet _usedFunctions;
  static MLCallGraphFunctionList _globalFunctionListCopy;
 
  MLProfilingTimeType _allElapsedTime;
  MLProfilingTimeType _allConsumedTime;
 
  MLProfilingTimeType _allElapsedTimeSnapshot;
  MLProfilingTimeType _allConsumedTimeSnapshot;
 
  const MLMetaProfile* _metaProfile;
 
  MLCallGraphNodesVector _callGraphNodes;
 
  static bool _reduceCallGraph;
 
  static MLCallGraphGlobalFunctionMap&       getGlobalFunctionMap();
  // Duplicates the global function map values, but is required for performance reasons
  static MLCallGraphFunctionList& getGlobalFunctionList();
  static MLCallGraphFunctionList& refreshGlobalFunctionListCopy();
 
  static MLCallGraphNode* _callGraphRoot;
  static MLCallGraphNode* _callGraphRootCopy;
  static MLCallGraphNode* _lastCallGraphNode;
 
  static std::ofstream* _traceStream;
 
  friend class MLAccumulatedProfile;
  friend class MLCallGraphNode;
  friend class MLProfilingManager;
 
  friend class MLABModuleProfile;
};
 
 
#endif // _ML_TIME_PROFILE_H_