memory.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "base-precomp.h"  // Precompiled headers
 
#include <cstdio>  // for size_t, fclose, fopen, fscanf, FILE
#include <cstdlib>  // for free, posix_memalign, realloc
#include <exception>  // for exception
#include <mrpt/config.h>  // for HAVE_POSIX_MEMALIGN, MRPT_OS_LINUX
#include <mrpt/utils/mrpt_macros.h>  // for MRPT_END, MRPT_START, MRPT_UNUSE...
#include <mrpt/system/memory.h>
 
#ifdef MRPT_OS_APPLE
#include <mach/mach_init.h>
#include <mach/task.h>
#endif
 
using namespace mrpt;
using namespace mrpt::system;
using namespace std;
 
// Management of aligned memory for efficiency:
// If we have "posix_memalign", use it, then realloc / free as usual.
// (GCC/Linux)
// If we have "_aligned_malloc", use it, then _aligned_realloc/_aligned_free
// (MSVC, MinGW)
 
/** Returns an aligned memory block.
  * \param alignment The desired alignment, typ. 8 or 16 bytes. 1 means no
 * alignment required. It must be a power of two.
  * \sa aligned_free, aligned_realloc
  * \note Based on code by William Chan
*/
void* mrpt::system::os::aligned_malloc(size_t bytes, size_t alignment)
{
#if defined(HAVE_ALIGNED_MALLOC)
#if defined(__GNUC__) && !defined(__MINGW32__)
        return ::aligned_malloc(bytes, alignment);
#else
        return _aligned_malloc(bytes, alignment);
#endif
#elif defined(HAVE_POSIX_MEMALIGN)
        void* ptr = nullptr;
        int ret = posix_memalign(&ptr, alignment, bytes);
        if (ret) THROW_EXCEPTION("posix_memalign returned an error.");
        return ptr;
#else
        // We don't have aligned memory:
        return ::malloc(bytes);
#endif
}
 
/** Frees a memory block reserved by aligned_malloc.
  * \param alignment The desired alignment, typ. 8 or 16 bytes. 1 means no
 * alignment required.
  * If old_ptr is nullptr, a new block will be reserved from scratch.
  * \sa aligned_malloc, aligned_free
  */
void* mrpt::system::os::aligned_realloc(
        void* old_ptr, size_t bytes, size_t alignment)
{
#if defined(HAVE_ALIGNED_MALLOC)
#if defined(__GNUC__) && !defined(__MINGW32__)
        return ::aligned_realloc(old_ptr, bytes, alignment);
#else
        return _aligned_realloc(old_ptr, bytes, alignment);
#endif
#elif defined(HAVE_POSIX_MEMALIGN)
        MRPT_UNUSED_PARAM(alignment);
        return ::realloc(old_ptr, bytes);
#else
        MRPT_UNUSED_PARAM(alignment);
        // We don't have aligned memory:
        return ::realloc(old_ptr, bytes);
#endif
}
 
/** Frees a memory block reserved by aligned_malloc
  * \sa aligned_malloc
  */
void mrpt::system::os::aligned_free(void* p)
{
#if defined(HAVE_ALIGNED_MALLOC)
#if defined(__GNUC__) && !defined(__MINGW32__)
        ::aligned_free(p);
#else
        _aligned_free(p);
#endif
#elif defined(HAVE_POSIX_MEMALIGN)
        free(p);
#else
        // We don't have aligned memory:
        free(p);
#endif
}
 
#ifdef MRPT_OS_WINDOWS
#include <windows.h>
// Windows:
typedef struct _PROCESS_MEMORY_COUNTERS
{
        DWORD cb;
        DWORD PageFaultCount;
        SIZE_T PeakWorkingSetSize;
        SIZE_T WorkingSetSize;
        SIZE_T QuotaPeakPagedPoolUsage;
        SIZE_T QuotaPagedPoolUsage;
        SIZE_T QuotaPeakNonPagedPoolUsage;
        SIZE_T QuotaNonPagedPoolUsage;
        SIZE_T PagefileUsage;
        SIZE_T PeakPagefileUsage;
} PROCESS_MEMORY_COUNTERS, *PPROCESS_MEMORY_COUNTERS;
 
namespace mrpt
{
namespace system
{
/** This is an auxiliary class for mrpt::system::getMemoryUsage() under Windows.
  *  It loads in runtime PSAPI.DLL. This is to avoid problems in some platforms,
 * i.e Windows 2000,
  *  where this DLL must not be present.
  */
class CAuxPSAPI_Loader
{
   protected:
        typedef BOOL(WINAPI* TGetProcessMemoryInfo)(
                HANDLE Process, PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb);
 
        TGetProcessMemoryInfo m_ptr;
 
   public:
        HMODULE m_dll;
 
        CAuxPSAPI_Loader()
        {
                m_ptr = nullptr;
 
                m_dll = LoadLibraryA("PSAPI.DLL");
                if (m_dll)
                {
                        m_ptr = (TGetProcessMemoryInfo)GetProcAddress(
                                m_dll, "GetProcessMemoryInfo");
                }
        }
        ~CAuxPSAPI_Loader()
        {
                if (m_dll)
                {
                        FreeLibrary(m_dll);
                        m_dll = nullptr;
                        m_ptr = nullptr;
                }
        }
 
        BOOL WINAPI GetProcessMemoryInfo(
                HANDLE Process, PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb)
        {
                try
                {
                        if (!m_ptr)
                                return false;
                        else
                                return (*m_ptr)(Process, ppsmemCounters, cb);
                }
                catch (...)
                {
                        return false;
                }
        }
};
}
}
 
#endif
 
/*---------------------------------------------------------------
                                                getMemoryUsage
 ---------------------------------------------------------------*/
unsigned long mrpt::system::getMemoryUsage()
{
        MRPT_START
        unsigned long MEM = 0;
 
#ifdef MRPT_OS_WINDOWS
        // Windows:
        static CAuxPSAPI_Loader PSAPI_LOADER;
 
        PROCESS_MEMORY_COUNTERS pmc;
        pmc.cb = sizeof(pmc);
 
        if (PSAPI_LOADER.GetProcessMemoryInfo(
                        GetCurrentProcess(), &pmc, sizeof(pmc)))
        {
                MEM = (long)pmc.PagefileUsage;
        }
#endif
 
#ifdef MRPT_OS_LINUX
        // Linux:
        // int page_size = getpagesize();
 
        FILE* f = ::fopen("/proc/self/stat", "r");
        if (!f) return 0;
 
        // Note: some of these scanf specifiers would normally be 'long' versions if
        // not for the fact that we are using suppression (gcc warns).  see 'man
        // proc' for scanf specifiers and meanings.
        if (!::fscanf(
                        f,
                        "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %*u %*u %*d "
                        "%*d %*d %*d %*d %*d %*u %lu",
                        &MEM))
        {
                // Error parsing:
                MEM = 0;
        }
        ::fclose(f);
//::system("cat /proc/self/statm");
#endif
 
#ifdef MRPT_OS_APPLE
        mach_task_basic_info info;
        mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
        if (task_info(
                        mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info,
                        &count) == 0)
        {
                MEM = info.virtual_size;
        }
#endif
        return MEM;
        MRPT_END
}