src/OSD/OSD_MemInfo.cxx

   1 // Created on: 2011-10-05
   2 // Created by: Kirill GAVRILOV
   3 // Copyright (c) 2013-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 #if (defined(_WIN32) || defined(__WIN32__))
  17   #include <windows.h>
  18   #include <winbase.h>
  19   #include <process.h>
  20   #include <malloc.h>
  21   #include <psapi.h>
  22   #ifdef _MSC_VER
  23     #pragma comment(lib, "Psapi.lib")
  24   #endif
  25 #elif (defined(__APPLE__))
  26   #include <mach/task.h>
  27   #include <mach/mach.h>
  28   #include <malloc/malloc.h>
  29 #else
  30   #include <unistd.h>
  31   #include <malloc.h>
  32 #endif
  33
  34 #include <string>
  35 #include <sstream>
  36 #include <fstream>
  37
  38 #include <OSD_MemInfo.hxx>
  39
  40 #if defined(__EMSCRIPTEN__)
  41   #include <emscripten.h>
  42
  43   //! Return WebAssembly heap size in bytes.
  44   EM_JS(size_t, OSD_MemInfo_getModuleHeapLength, (), {
  45     return Module.HEAP8.length;
  46   });
  47 #endif
  48
  49 // =======================================================================
  50 // function : OSD_MemInfo
  51 // purpose  :
  52 // =======================================================================
  53 OSD_MemInfo::OSD_MemInfo (const Standard_Boolean theImmediateUpdate)
  54 {
  55   SetActive (Standard_True);
  56   if (theImmediateUpdate)
  57   {
  58     Update();
  59   }
  60   else
  61   {
  62     Clear();
  63   }
  64 }
  65
  66 // =======================================================================
  67 // function : SetActive
  68 // purpose  :
  69 // =======================================================================
  70 void OSD_MemInfo::SetActive (const Standard_Boolean theActive)
  71 {
  72   for (Standard_Integer anIter = 0; anIter < MemCounter_NB; ++anIter)
  73   {
  74     SetActive ((Counter)anIter, theActive);
  75   }
  76 }
  77
  78 // =======================================================================
  79 // function : Clear
  80 // purpose  :
  81 // =======================================================================
  82 void OSD_MemInfo::Clear()
  83 {
  84   for (Standard_Integer anIter = 0; anIter < MemCounter_NB; ++anIter)
  85   {
  86     myCounters[anIter] = Standard_Size(-1);
  87   }
  88 }
  89
  90 // =======================================================================
  91 // function : Update
  92 // purpose  :
  93 // =======================================================================
  94 void OSD_MemInfo::Update()
  95 {
  96   Clear();
  97 #ifndef OCCT_UWP
  98 #if defined(_WIN32)
  99 #if (_WIN32_WINNT >= 0x0500)
 100   if (IsActive (MemVirtual))
 101   {
 102     MEMORYSTATUSEX aStatEx;
 103     aStatEx.dwLength = sizeof(aStatEx);
 104     GlobalMemoryStatusEx (&aStatEx);
 105     myCounters[MemVirtual] = Standard_Size(aStatEx.ullTotalVirtual - aStatEx.ullAvailVirtual);
 106   }
 107 #else
 108   if (IsActive (MemVirtual))
 109   {
 110     MEMORYSTATUS aStat;
 111     aStat.dwLength = sizeof(aStat);
 112     GlobalMemoryStatus (&aStat);
 113     myCounters[MemVirtual] = Standard_Size(aStat.dwTotalVirtual - aStat.dwAvailVirtual);
 114   }
 115 #endif
 116
 117   if (IsActive (MemPrivate)
 118    || IsActive (MemWorkingSet)
 119    || IsActive (MemWorkingSetPeak)
 120    || IsActive (MemSwapUsage)
 121    || IsActive (MemSwapUsagePeak))
 122   {
 123     // use Psapi library
 124     HANDLE aProcess = GetCurrentProcess();
 125   #if (_WIN32_WINNT >= 0x0501)
 126     PROCESS_MEMORY_COUNTERS_EX aProcMemCnts;
 127   #else
 128     PROCESS_MEMORY_COUNTERS    aProcMemCnts;
 129   #endif
 130     if (GetProcessMemoryInfo (aProcess, (PROCESS_MEMORY_COUNTERS* )&aProcMemCnts, sizeof(aProcMemCnts)))
 131     {
 132     #if (_WIN32_WINNT >= 0x0501)
 133       myCounters[MemPrivate]        = aProcMemCnts.PrivateUsage;
 134     #endif
 135       myCounters[MemWorkingSet]     = aProcMemCnts.WorkingSetSize;
 136       myCounters[MemWorkingSetPeak] = aProcMemCnts.PeakWorkingSetSize;
 137       myCounters[MemSwapUsage]      = aProcMemCnts.PagefileUsage;
 138       myCounters[MemSwapUsagePeak]  = aProcMemCnts.PeakPagefileUsage;
 139     }
 140   }
 141
 142   if (IsActive (MemHeapUsage))
 143   {
 144     _HEAPINFO hinfo;
 145     int heapstatus;
 146     hinfo._pentry = NULL;
 147
 148     myCounters[MemHeapUsage] = 0;
 149     while((heapstatus = _heapwalk(&hinfo)) == _HEAPOK)
 150     {
 151       if (hinfo._useflag == _USEDENTRY)
 152       {
 153         myCounters[MemHeapUsage] += hinfo._size;
 154       }
 155     }
 156   }
 157
 158 #elif defined(__EMSCRIPTEN__)
 159   if (IsActive (MemHeapUsage)
 160    || IsActive (MemWorkingSet)
 161    || IsActive (MemWorkingSetPeak))
 162   {
 163     // /proc/%d/status is not emulated - get more info from mallinfo()
 164     const struct mallinfo aMI = mallinfo();
 165     if (IsActive (MemHeapUsage))
 166     {
 167       myCounters[MemHeapUsage] = aMI.uordblks;
 168     }
 169     if (IsActive (MemWorkingSet))
 170     {
 171       myCounters[MemWorkingSet] = aMI.uordblks;
 172     }
 173     if (IsActive (MemWorkingSetPeak))
 174     {
 175       myCounters[MemWorkingSetPeak] = aMI.usmblks;
 176     }
 177   }
 178   if (IsActive (MemVirtual))
 179   {
 180     myCounters[MemVirtual] = OSD_MemInfo_getModuleHeapLength();
 181   }
 182 #elif (defined(__linux__) || defined(__linux))
 183   if (IsActive (MemHeapUsage))
 184   {
 185   #if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
 186     #if __GLIBC_PREREQ(2,33)
 187       #define HAS_MALLINFO2
 188     #endif
 189   #endif
 190
 191   #ifdef HAS_MALLINFO2
 192     const struct mallinfo2 aMI = mallinfo2();
 193   #else
 194     const struct mallinfo aMI = mallinfo();
 195   #endif
 196     myCounters[MemHeapUsage] = aMI.uordblks;
 197   }
 198
 199   if (!IsActive (MemVirtual)
 200    && !IsActive (MemWorkingSet)
 201    && !IsActive (MemWorkingSetPeak)
 202    && !IsActive (MemPrivate))
 203   {
 204     return;
 205   }
 206
 207   // use procfs on Linux
 208   char aBuff[4096];
 209   snprintf (aBuff, sizeof(aBuff), "/proc/%d/status", getpid());
 210   std::ifstream aFile;
 211   aFile.open (aBuff);
 212   if (!aFile.is_open())
 213   {
 214     return;
 215   }
 216
 217   while (!aFile.eof())
 218   {
 219     memset (aBuff, 0, sizeof(aBuff));
 220     aFile.getline (aBuff, 4096);
 221     if (aBuff[0] == '\0')
 222     {
 223       continue;
 224     }
 225
 226     if (IsActive (MemVirtual)
 227      && strncmp (aBuff, "VmSize:", strlen ("VmSize:")) == 0)
 228     {
 229       myCounters[MemVirtual] = atol (aBuff + strlen ("VmSize:")) * 1024;
 230     }
 231     //else if (strncmp (aBuff, "VmPeak:", strlen ("VmPeak:")) == 0)
 232     //  myVirtualPeak = atol (aBuff + strlen ("VmPeak:")) * 1024;
 233     else if (IsActive (MemWorkingSet)
 234           && strncmp (aBuff, "VmRSS:", strlen ("VmRSS:")) == 0)
 235     {
 236       myCounters[MemWorkingSet] = atol (aBuff + strlen ("VmRSS:")) * 1024; // RSS - resident set size
 237     }
 238     else if (IsActive (MemWorkingSetPeak)
 239           && strncmp (aBuff, "VmHWM:", strlen ("VmHWM:")) == 0)
 240     {
 241       myCounters[MemWorkingSetPeak] = atol (aBuff + strlen ("VmHWM:")) * 1024; // HWM - high water mark
 242     }
 243     else if (IsActive (MemPrivate)
 244           && strncmp (aBuff, "VmData:", strlen ("VmData:")) == 0)
 245     {
 246       if (myCounters[MemPrivate] == Standard_Size(-1)) ++myCounters[MemPrivate];
 247       myCounters[MemPrivate] += atol (aBuff + strlen ("VmData:")) * 1024;
 248     }
 249     else if (IsActive (MemPrivate)
 250           && strncmp (aBuff, "VmStk:", strlen ("VmStk:")) == 0)
 251     {
 252       if (myCounters[MemPrivate] == Standard_Size(-1)) ++myCounters[MemPrivate];
 253       myCounters[MemPrivate] += atol (aBuff + strlen ("VmStk:")) * 1024;
 254     }
 255   }
 256   aFile.close();
 257 #elif (defined(__APPLE__))
 258   if (IsActive (MemVirtual)
 259    || IsActive (MemWorkingSet)
 260    || IsActive (MemHeapUsage))
 261   {
 262     struct task_basic_info aTaskInfo;
 263     mach_msg_type_number_t aTaskInfoCount = TASK_BASIC_INFO_COUNT;
 264     if (task_info (mach_task_self(), TASK_BASIC_INFO,
 265                    (task_info_t )&aTaskInfo, &aTaskInfoCount) == KERN_SUCCESS)
 266     {
 267       // On Mac OS X, these values in bytes, not pages!
 268       myCounters[MemVirtual]    = aTaskInfo.virtual_size;
 269       myCounters[MemWorkingSet] = aTaskInfo.resident_size;
 270
 271       //Getting malloc statistics
 272       malloc_statistics_t aStats;
 273       malloc_zone_statistics (NULL, &aStats);
 274
 275       myCounters[MemHeapUsage] = aStats.size_in_use;
 276     }
 277   }
 278 #endif
 279 #endif
 280 }
 281
 282 // =======================================================================
 283 // function : ToString
 284 // purpose  :
 285 // =======================================================================
 286 TCollection_AsciiString OSD_MemInfo::ToString() const
 287 {
 288   TCollection_AsciiString anInfo;
 289   if (hasValue (MemPrivate))
 290   {
 291     anInfo += TCollection_AsciiString("  Private memory:     ") + Standard_Integer (ValueMiB (MemPrivate)) + " MiB\n";
 292   }
 293   if (hasValue (MemWorkingSet))
 294   {
 295     anInfo += TCollection_AsciiString("  Working Set:        ") +  Standard_Integer (ValueMiB (MemWorkingSet)) + " MiB";
 296     if (hasValue (MemWorkingSetPeak))
 297     {
 298       anInfo += TCollection_AsciiString(" (peak: ") +  Standard_Integer (ValueMiB (MemWorkingSetPeak)) + " MiB)";
 299     }
 300     anInfo += "\n";
 301   }
 302   if (hasValue (MemSwapUsage))
 303   {
 304     anInfo += TCollection_AsciiString("  Pagefile usage:     ") +  Standard_Integer (ValueMiB (MemSwapUsage)) + " MiB";
 305     if (hasValue (MemSwapUsagePeak))
 306     {
 307       anInfo += TCollection_AsciiString(" (peak: ") +  Standard_Integer (ValueMiB (MemSwapUsagePeak)) + " MiB)";
 308     }
 309     anInfo += "\n";
 310   }
 311   if (hasValue (MemVirtual))
 312   {
 313     anInfo += TCollection_AsciiString("  Virtual memory:     ") +  Standard_Integer (ValueMiB (MemVirtual)) + " MiB\n";
 314   }
 315   if (hasValue (MemHeapUsage))
 316   {
 317     anInfo += TCollection_AsciiString("  Heap memory:     ") +  Standard_Integer (ValueMiB (MemHeapUsage)) + " MiB\n";
 318   }
 319   return anInfo;
 320 }
 321
 322 // =======================================================================
 323 // function : Value
 324 // purpose  :
 325 // =======================================================================
 326 Standard_Size OSD_MemInfo::Value (const OSD_MemInfo::Counter theCounter) const
 327 {
 328   if (theCounter < 0 || theCounter >= MemCounter_NB || !IsActive (theCounter))
 329   {
 330     return Standard_Size(-1);
 331   }
 332   return myCounters[theCounter];
 333 }
 334
 335 // =======================================================================
 336 // function : ValueMiB
 337 // purpose  :
 338 // =======================================================================
 339 Standard_Size OSD_MemInfo::ValueMiB (const OSD_MemInfo::Counter theCounter) const
 340 {
 341   if (theCounter < 0 || theCounter >= MemCounter_NB || !IsActive (theCounter))
 342   {
 343     return Standard_Size(-1);
 344   }
 345   return (myCounters[theCounter] == Standard_Size(-1))
 346        ? Standard_Size(-1) : (myCounters[theCounter] / (1024 * 1024));
 347 }
 348
 349 // =======================================================================
 350 // function : ValuePreciseMiB
 351 // purpose  :
 352 // =======================================================================
 353 Standard_Real OSD_MemInfo::ValuePreciseMiB (const OSD_MemInfo::Counter theCounter) const
 354 {
 355   if (theCounter < 0 || theCounter >= MemCounter_NB || !IsActive (theCounter))
 356   {
 357     return -1.0;
 358   }
 359   return (myCounters[theCounter] == Standard_Size(-1))
 360        ? -1.0 : ((Standard_Real )myCounters[theCounter] / (1024.0 * 1024.0));
 361 }
 362
 363 // =======================================================================
 364 // function : ShowInfo
 365 // purpose  :
 366 // =======================================================================
 367 TCollection_AsciiString OSD_MemInfo::PrintInfo()
 368 {
 369   OSD_MemInfo anInfo;
 370   return anInfo.ToString();
 371 }