ProcStats.h

Go to the documentation of this file.

#ifndef GAUDIAUD_PROCSTATS_H
#define GAUDIAUD_PROCSTATS_H

// Class: ProcStats
// Description:  Keeps statistics on memory usage
// Author: Jim Kowalkowski (FNAL), modified by M. Shapiro (LBNL)

#include <string>
#include <vector>
#if defined(__linux__) or defined(__APPLE__)
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#endif // __linux__ or __APPLE__

struct procInfo
{
  procInfo() : vsize(0), rss(0) {}
  procInfo(double sz, double rss_sz): vsize(sz),rss(rss_sz) {}

  bool operator==(const procInfo& p) const {
#ifdef __ICC
// disable icc remark #1572: floating-point equality and inequality comparisons are unreliable
#pragma warning(push)
#pragma warning(disable:1572)
#endif

    return vsize==p.vsize && rss==p.rss;

#ifdef __ICC
// re-enable icc remark #1572
#pragma warning(pop)
#endif
  }
  
  // see proc(4) man pages for units and a description
  double vsize;  // in MB (used to be in pages?)
  double rss;    // in MB (used to be in pages?)
};

class ProcStats
{
public:
  static ProcStats* instance();

  bool fetch(procInfo& fill_me);
  double pageSize() const { return pg_size; }

private:
  ProcStats();

  struct cleanup
  {
    cleanup() { }
    ~cleanup();
  };

  friend struct cleanup;

  class unique_fd {
      int m_fd;
      unique_fd(const unique_fd&) = delete;
      unique_fd& operator=(const unique_fd&) = delete;
  public:
      unique_fd(int fd=-1) : m_fd(fd) {}
      unique_fd(unique_fd&& other) { m_fd = other.m_fd; other.m_fd = -1; }
      ~unique_fd() { if (m_fd != -1) ::close(m_fd); }

      explicit operator bool() const { return m_fd != -1; }
      template <typename... Args>
      unique_fd& open(Args&& ... args) { m_fd = ::open(std::forward<Args>(args)...); return *this; }
#define unique_fd_forward(fun) template <typename...Args> auto fun(Args&&... args) const \
                               -> decltype(::fun(m_fd,std::forward<Args>(args)...)) \
                               { return ::fun(m_fd,std::forward<Args>(args)...); }
      unique_fd_forward(lseek)
      unique_fd_forward(read)
      unique_fd_forward(write)
      unique_fd_forward(fcntl)
      unique_fd_forward(fsync)
      unique_fd_forward(fchown)
      unique_fd_forward(stat)
#undef unique_fd_forward
      int close() { auto r = ::close(m_fd); m_fd = -1; return r; }
  };


  unique_fd fd;
  double pg_size;
  procInfo curr;
  std::string fname;
  char buf[500];
  bool valid;

  static ProcStats* inst;
};

#endif