LeaMemMonitor.cxx

Go to the documentation of this file.

//
// $Id: LeaMemMonitor.cxx,v 1.6 2007/02/08 17:03:42 rhatcher Exp $
//
// functions for inquiring about and printing current memory usage
// Linux specific!!!
//
#include "LeakChecker/LeaMemMonitor.h"

#include <sys/types.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <sys/stat.h>

#define PROCFS "/proc"
#define PROCSTATUS "/proc/self/status"

#include "MessageService/MsgService.h"
CVSID("$Id: LeaMemMonitor.cxx,v 1.6 2007/02/08 17:03:42 rhatcher Exp $");

void LeaMemMonitor::FillMemStat(LeaMemMonitor::memstat_t& result)
{
// use proc pseudo-file system to determine process memory usage
   
#ifndef linux
   MSG("Lea",Msg::kFatal)
      << "Not supported for any OS other than Linux" << endl;
   result.ms_total.mu_sizex = 0; // use result to avoid unused warning
#else
   char buffer[4096+1];

   int fd = open(PROCSTATUS,O_RDONLY);
   int len = read(fd,buffer,sizeof(buffer)-1);
   close(fd);
   buffer[len] = '\0';
   
   // skip 9 lines so scanf can sync
   int nskip = 0;
   char *p = buffer;
   char *pend = buffer+len;
   while (p<pend) {
      if (*p == '\n') nskip++;
      p++;
      if (nskip == 10) break;
   }   

   // interpret what should be there
   int nexpect = 14;
   int ndatum = sscanf(p,"VmSize: %u %cB \
                          VmLck: %u %cB \
                          VmRSS: %u %cB \
                          VmData: %u %cB \
                          VmStk: %u %cB \
                          VmExe: %u %cB \
                          VmLib: %u %cB",
                       &result.ms_total.mu_sizex,&result.ms_total.mu_sizeu,
                       &result.ms_lck.mu_sizex,&result.ms_lck.mu_sizeu,
                       &result.ms_rss.mu_sizex,&result.ms_rss.mu_sizeu,
                       &result.ms_data.mu_sizex,&result.ms_data.mu_sizeu,
                       &result.ms_stk.mu_sizex,&result.ms_stk.mu_sizeu,
                       &result.ms_exe.mu_sizex,&result.ms_exe.mu_sizeu,
                       &result.ms_lib.mu_sizex,&result.ms_lib.mu_sizeu);

   if (ndatum != nexpect)
      MSG("Lea",Msg::kWarning)
         << " sscanf only returned " << ndatum << " of "
         << nexpect << " items " << endl;
   
   // interpret units back to bytes
   LeaMemMonitor::CalcBytes(result.ms_total);
   LeaMemMonitor::CalcBytes(result.ms_lck);
   LeaMemMonitor::CalcBytes(result.ms_rss);
   LeaMemMonitor::CalcBytes(result.ms_data);
   LeaMemMonitor::CalcBytes(result.ms_stk);
   LeaMemMonitor::CalcBytes(result.ms_exe);
   LeaMemMonitor::CalcBytes(result.ms_lib);

#endif

}

void LeaMemMonitor::PrintMemStat(const char* tag)
{
// use proc pseudo-file system to determine process memory usage
// print the results

#ifndef linux
   MSG("Lea",Msg::kFatal)
      << "Not supported for any OS other than Linux: " 
      << tag
      << endl;
#else
   memstat_t result;
   LeaMemMonitor::FillMemStat(result);

   /* This reasonable looking code causes gcc3.0.2 to dump core during
    compile (Internal error #980715). So, I replaced this with the
    less elegant code in the if statement...  */
   /*
     MSG("Lea",Msg::kInfo)
     << ( (tag) ? tag : "" )     // protect against missing tag
     << ( (tag) ? endl : flush ) // stats on separate line if tag given
   */
   if (tag) MSG("Lea",Msg::kInfo) << tag << endl;
   MSG("Lea",Msg::kInfo)
      << "Memory:"
      << " Total " << result.ms_total.mu_sizex << result.ms_total.mu_sizeu
//      << ", Lck "   << result.ms_lck.mu_sizex   << result.ms_lck.mu_sizeu
      << ", RSS "   << result.ms_rss.mu_sizex   << result.ms_rss.mu_sizeu
      << ", Data "  << result.ms_data.mu_sizex  << result.ms_data.mu_sizeu
      << ", Stack " << result.ms_stk.mu_sizex   << result.ms_stk.mu_sizeu
      << ", Exe "   << result.ms_exe.mu_sizex   << result.ms_exe.mu_sizeu
      << ", Lib "   << result.ms_lib.mu_sizex   << result.ms_lib.mu_sizeu
      << endl;
#endif
}

void LeaMemMonitor::CalcBytes(memusage_t& usage)
{
   switch (usage.mu_sizeu) {
   case 'k':
   case 'K':
      usage.mu_size = 1024 * usage.mu_sizex;
      break;
   case 'm':
   case 'M':
      usage.mu_size = 1024 * 1024 * usage.mu_sizex;
      break;
   default:
      usage.mu_size = usage.mu_sizex;
      MSG("Lea",Msg::kWarning)
         << "unit designator \"" << usage.mu_sizeu 
         << "\" not recognized" << endl;
      
   }
}

---