itkSmapsFileParser.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkSmapsFileParser_h
#define __itkSmapsFileParser_h

#include "itkMacro.h"
#include "itkIntTypes.h"

#include <string>
#include <vector>
#include <map>
#include <istream>
#include <iostream>

namespace itk
{
class ITKCommon_EXPORT MapRecord
{
public:
  typedef SizeValueType  MemoryLoadType;
  virtual ~MapRecord();
  void Reset(void);

  std::string m_RecordName;

  std::map< std::string, MemoryLoadType > m_Tokens;
};

class ITKCommon_EXPORT SmapsRecord:public MapRecord
{
  friend ITKCommon_EXPORT std::istream &  operator>>(std::istream & in, SmapsRecord & record);
};

class ITKCommon_EXPORT VMMapSummaryRecord:public MapRecord
{
  friend ITKCommon_EXPORT std::istream &  operator>>(std::istream & in, VMMapSummaryRecord & record);
};

class ITKCommon_EXPORT VMMapRecord:public MapRecord
{
  friend ITKCommon_EXPORT std::istream &  operator>>(std::istream & in, VMMapRecord & record);
};

class ITKCommon_EXPORT MapData
{
public:
  typedef SizeValueType  MemoryLoadType;
  //todo delete records
  virtual ~MapData();

  virtual MemoryLoadType GetHeapUsage() = 0;

  virtual MemoryLoadType GetStackUsage() = 0;

  virtual MemoryLoadType GetTotalMemoryUsage();

  virtual MemoryLoadType GetMemoryUsage(const char *filter, const char *token);

  bool Empty();

protected:
  void Reset(void);

protected:
  typedef std::vector< MapRecord * > MapRecordVectorType;

  MapRecordVectorType m_Records;
};

class ITKCommon_EXPORT SmapsData_2_6:public MapData
{
public:
  typedef MapData::MemoryLoadType MemoryLoadType;

  virtual ~SmapsData_2_6();

  virtual MemoryLoadType GetHeapUsage() ITK_OVERRIDE;

  virtual MemoryLoadType GetStackUsage() ITK_OVERRIDE;

  friend ITKCommon_EXPORT std::istream &  operator>>(std::istream & smapsStream,
                                                     SmapsData_2_6 & data);

protected:
  bool m_HeapRecordFound;
};

class ITKCommon_EXPORT VMMapData_10_2:public MapData
{
public:
  typedef MapData::MemoryLoadType MemoryLoadType;
  VMMapData_10_2();
  virtual ~VMMapData_10_2();

  virtual MemoryLoadType GetHeapUsage() ITK_OVERRIDE;

  virtual MemoryLoadType GetStackUsage() ITK_OVERRIDE;

  friend ITKCommon_EXPORT std::istream & operator>>(std::istream & stream,
                                                    VMMapData_10_2 & data);

protected:
  bool m_UsingSummary;
};

template< typename TMapData >
class MapFileParser
{
public:
  typedef typename TMapData::MemoryLoadType MemoryLoadType;

  virtual ~MapFileParser();
  virtual void ReadFile(const std::string & mapFileLocation = "") = 0;

  bool Update(void);

  MemoryLoadType GetHeapUsage();

  MemoryLoadType GetStackUsage();

  MemoryLoadType GetTotalMemoryUsage();

  MemoryLoadType GetMemoryUsage(const char *filter, const char *token = "Size");

protected:
  std::string m_MapFilePath;    //< location of the last loaded Map file
  TMapData    m_MapData;        //< data of the loaded smap file
};

template< typename TSmapsDataType >
class SmapsFileParser:public MapFileParser< TSmapsDataType >
{
public:
  virtual ~SmapsFileParser();
  virtual void ReadFile(const std::string & mapFileLocation = "");
};

template< typename TVMMapDataType >
class VMMapFileParser:public MapFileParser< TVMMapDataType >
{
public:
  virtual ~VMMapFileParser();
  virtual void ReadFile(const std::string & mapFileLocation = "");
};
}  // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSmapsFileParser.hxx"
#endif

#endif // __itkSmapsFileParser_h