itkSmapsFileParser.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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:
  using MemoryLoadType = SizeValueType;
  virtual ~MapRecord();
  void
  Reset();
 
  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:
  using MemoryLoadType = SizeValueType;
  // 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();
 
protected:
  using MapRecordVectorType = std::vector<MapRecord *>;
 
  MapRecordVectorType m_Records{};
};
 
class ITKCommon_EXPORT SmapsData_2_6 : public MapData
{
public:
  using MemoryLoadType = MapData::MemoryLoadType;
 
  ~SmapsData_2_6() override;
 
  MemoryLoadType
  GetHeapUsage() override;
 
  MemoryLoadType
  GetStackUsage() 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:
  using MemoryLoadType = MapData::MemoryLoadType;
  VMMapData_10_2();
  ~VMMapData_10_2() override;
 
  MemoryLoadType
  GetHeapUsage() override;
 
  MemoryLoadType
  GetStackUsage() override;
 
  friend ITKCommon_EXPORT std::istream &
                          operator>>(std::istream & stream, VMMapData_10_2 & data);
 
protected:
  bool m_UsingSummary{ false };
};
 
template <typename TMapData>
class ITK_TEMPLATE_EXPORT MapFileParser
{
public:
  using MemoryLoadType = typename TMapData::MemoryLoadType;
 
  virtual ~MapFileParser() = default;
  virtual void
  ReadFile(const std::string & mapFileLocation = "") = 0;
 
  bool
  Update();
 
  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 ITK_TEMPLATE_EXPORT SmapsFileParser : public MapFileParser<TSmapsDataType>
{
public:
  virtual ~SmapsFileParser() = default;
  virtual void
  ReadFile(const std::string & mapFileLocation = "");
};
 
template <typename TVMMapDataType>
class ITK_TEMPLATE_EXPORT VMMapFileParser : public MapFileParser<TVMMapDataType>
{
public:
  virtual ~VMMapFileParser() = default;
  virtual void
  ReadFile(const std::string & mapFileLocation = "");
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkSmapsFileParser.hxx"
#endif
 
#endif // itkSmapsFileParser_h