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

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------
// Class to combine count, memory and time profiles.
//
// \file    mlMetaProfile.h
// \author  Marcus Barann
// \date    8/2009
//
//----------------------------------------------------------------------------------
#ifndef _ML_META_PROFILE_H_
#define _ML_META_PROFILE_H_

#include "mlProfilingManagerDllExport.h"
#include "mlCountProfile.h"
#include "mlMemoryProfile.h"
#include "mlTimeProfile.h"

#include <map>
#include <vector>

class MLMetaProfilePtr;

typedef std::map<std::string, MLCountProfile*>  MLCountProfileMap;
typedef std::map<std::string, MLMemoryProfile*> MLMemoryProfileMap;


typedef void MLMetaProfileIsDestroyedCB(void);


class MLPROFILINGMANAGER_EXPORT MLMetaProfile
{
public:
  typedef enum {
    MLCall = 0,
    PythonCall = 1,
    FieldNotificationCall = 2,
    CppCall = 3,
    GLRenderCall = 4,
    PythonQtCall = 5,
    MLWEMCall = 6,
    MDLCommandCall = 7,
    MainFunctionCall = 8,
    CallTypeCount = 9
  } MLProfilingFunctionType;

  const std::vector<MLMetaProfile*>& getSubMetaProfiles() const { return _subMetaProfiles; }

  void addSubMetaProfile(MLMetaProfile* subMetaProfile) { _subMetaProfiles.push_back(subMetaProfile); subMetaProfile->_superProfile = this; }

  /* @ingroup CountProfiling
   * @{
   */
  MLCountProfile* createCountProfile(const std::string& key);

  MLCountProfile* getCountProfile(const std::string& key) const;

  bool incrementCountValue(const std::string& key);

  MLProfilingCountType getCountValue(const std::string& key, bool* ok = NULL) const;

  const MLCountProfileMap& getCountProfileMap() const { return _countProfileMap; }

  void setCountProfileDescription(const std::string& key, const std::string& description);
  /* @}
   */

  /* @ingroup MemoryProfiling
   * @{
   */
  MLMemoryProfile* createMemoryProfile(const std::string& key,
                                       MLCurrentlyUsedMemoryTracker* tracker);

  MLMemoryProfile* getMemoryProfile(const std::string& key) const;

  bool addMemory(const std::string& key, MLProfilingMemoryType memory);

  MLProfilingMemoryType getMemory(const std::string& key, bool* ok = NULL) const;

  MLProfilingMemoryType getAllMemory() const;

  MLProfilingMemoryType getCurrentlyUsedMemory(const std::string& key, bool* ok = NULL) const;

  MLProfilingMemoryType getAllCurrentlyUsedMemory() const;

  const MLMemoryProfileMap& getMemoryProfileMap() const { return _memoryProfileMap; }

  void setMemoryProfileDescription(const std::string& key, const std::string& description);
  /* @}
   */

  /* @ingroup TimeProfiling
   * @{
   */
  MLTimeProfileHandle startMeasuring(const std::string& function,
                                     int userId,
                                     void* userData=NULL,
                                     const std::string& filename="",
                                     int linenumber=-1)
  {
    return _timeProfile->startMeasuring(function, userId, userData, filename, linenumber);
  }

  void stopMeasuring(MLTimeProfileHandle& handle)  { return _timeProfile->stopMeasuring(handle); }

  MLTimeProfile* getTimeProfile() const { return _timeProfile; }
  /* @}
   */

  void setDescription(const std::string& description_) { _description = description_; }
  const std::string& description() const { return _description; }

  ~MLMetaProfile();

private:
  MLMetaProfile(const std::string& description, MLMetaProfilePtr* metaProfilePtr);
  // Disallow copying of the meta profile.
  MLMetaProfile(const MLMetaProfile&);

private:
  MLCountProfileMap     _countProfileMap;
  MLMemoryProfileMap    _memoryProfileMap;
  MLTimeProfile*        _timeProfile;

  std::vector<MLMetaProfile*> _subMetaProfiles;

  std::string _description;

  MLMetaProfilePtr* _metaProfilePtr;

  MLMetaProfile* _superProfile;

  friend class MLMetaProfilePtr;
  friend class MLProfilingManager;
};


#endif // _ML_META_PROFILE_H_