edm::service::SimpleMemoryCheck Class Reference

Classes
struct	SignificantEvent
struct	SignificantModule

Public Member Functions
void	postBeginJob ()
void	postEndJob ()
void	postEvent (StreamContext const &)
void	postModule (StreamContext const &, ModuleCallingContext const &)
void	postModuleBeginJob (const ModuleDescription &)
void	postModuleConstruction (const ModuleDescription &)
void	postSourceConstruction (const ModuleDescription &)
void	postSourceEvent (StreamID)
void	preModule (StreamContext const &, ModuleCallingContext const &)
void	preSourceConstruction (const ModuleDescription &)
	SimpleMemoryCheck (const ParameterSet &, ActivityRegistry &)
	~SimpleMemoryCheck ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
typedef std::map< std::string, SignificantModule >	SignificantModulesMap

Private Member Functions
void	andPrint (const std::string &type, const std::string &mdlabel, const std::string &mdname) const
double	averageGrowthRate (double current, double past, int count)
std::string	eventStatOutput (std::string title, SignificantEvent const &e) const
void	eventStatOutput (std::string title, SignificantEvent const &e, std::map< std::string, std::string > &m) const
ProcInfo	fetch ()
smapsInfo	fetchSmaps ()
std::string	mallOutput (std::string title, size_t const &n) const
void	openFiles ()
double	pageSize () const
char const *	smapsLineBuffer () const
char *&	smapsLineBuffer ()
void	update ()
void	updateAndPrint (const std::string &type, const std::string &mdlabel, const std::string &mdname)
void	updateEventStats (edm::EventID const &e)
void	updateMax ()
void	updateModuleMemoryStats (SignificantModule &m, double dv, edm::EventID const &)

Private Attributes
ProcInfo	a_
ProcInfo	b_
std::atomic< int >	count_
edm::propagate_const< ProcInfo * >	current_
smapsInfo	currentSmaps_
SignificantEvent	eventDeltaRssT1_
SignificantEvent	eventDeltaRssT2_
SignificantEvent	eventDeltaRssT3_
SignificantEvent	eventL1_
SignificantEvent	eventL2_
SignificantEvent	eventM_
SignificantEvent	eventR1_
SignificantEvent	eventR2_
SignificantEvent	eventRssT1_
SignificantEvent	eventRssT2_
SignificantEvent	eventRssT3_
SignificantEvent	eventT1_
SignificantEvent	eventT2_
SignificantEvent	eventT3_
double	growthRateRss_
double	growthRateVsize_
bool	jobReportOutputOnly_
ProcInfo	max_
std::atomic< bool >	measurementUnderway_
double	moduleEntryVsize_
std::atomic< unsigned int >	moduleID_
std::atomic< bool >	moduleMeasurementUnderway_
SignificantModulesMap	modules_
std::atomic< unsigned int >	moduleStreamID_
bool	moduleSummaryRequested_
bool	monitorPssAndPrivate_
int	num_to_skip_
bool	oncePerEventMode_
double	pg_size_
ProcInfoFetcher	piFetcher_
edm::propagate_const< ProcInfo * >	previous_
bool	showMallocInfo_
edm::propagate_const< FILE * >	smapsFile_
edm::propagate_const< char * >	smapsLineBuffer_
size_t	smapsLineBufferLen_

Friends
std::ostream &	operator<< (std::ostream &os, SimpleMemoryCheck::SignificantEvent const &se)
std::ostream &	operator<< (std::ostream &os, SimpleMemoryCheck::SignificantModule const &se)
struct	SignificantEvent
struct	SignificantModule

Detailed Description

Definition at line 77 of file SimpleMemoryCheck.cc.

Member Typedef Documentation

typedef std::map<std::string, SignificantModule> edm::service::SimpleMemoryCheck::SignificantModulesMap

private

Definition at line 247 of file SimpleMemoryCheck.cc.

Constructor & Destructor Documentation

edm::service::SimpleMemoryCheck::SimpleMemoryCheck	(	const ParameterSet &	,
		ActivityRegistry &
	)

Definition at line 329 of file SimpleMemoryCheck.cc.

References edm::MallocOptionSetter::adjustMallocParams(), edm::MallocOptionSetter::error_message(), edm::MallocOptionSetter::get(), edm::getGlobalOptionSetter(), edm::ParameterSet::getUntrackedParameter(), edm::MallocOptionSetter::hasErrors(), moduleSummaryRequested_, oncePerEventMode_, openFiles(), postBeginJob(), postEndJob(), postEvent(), postModule(), postModuleBeginJob(), postModuleConstruction(), postSourceConstruction(), postSourceEvent(), preModule(), preSourceConstruction(), edm::MallocOptionSetter::set_mmap_max(), edm::MallocOptionSetter::set_mmap_thr(), edm::MallocOptionSetter::set_top_pad(), edm::MallocOptionSetter::set_trim_thr(), edm::ActivityRegistry::watchPostBeginJob(), edm::ActivityRegistry::watchPostEndJob(), edm::ActivityRegistry::watchPostEvent(), edm::ActivityRegistry::watchPostModuleBeginJob(), edm::ActivityRegistry::watchPostModuleConstruction(), edm::ActivityRegistry::watchPostModuleEvent(), edm::ActivityRegistry::watchPostSourceConstruction(), edm::ActivityRegistry::watchPostSourceEvent(), edm::ActivityRegistry::watchPreModuleEvent(), and edm::ActivityRegistry::watchPreSourceConstruction().

        : a_(),
          b_(),
          current_(&a_),
          previous_(&b_),
          pg_size_(sysconf(_SC_PAGESIZE))  // getpagesize()
          ,
          num_to_skip_(iPS.getUntrackedParameter<int>("ignoreTotal")),
          showMallocInfo_(iPS.getUntrackedParameter<bool>("showMallocInfo")),
          oncePerEventMode_(iPS.getUntrackedParameter<bool>("oncePerEventMode")),
          jobReportOutputOnly_(iPS.getUntrackedParameter<bool>("jobReportOutputOnly")),
          monitorPssAndPrivate_(iPS.getUntrackedParameter<bool>("monitorPssAndPrivate")),
          count_(),
          smapsFile_(nullptr),
          smapsLineBuffer_(nullptr),
          smapsLineBufferLen_(0),
          growthRateVsize_(),
          growthRateRss_(),
          moduleSummaryRequested_(iPS.getUntrackedParameter<bool>("moduleMemorySummary")),
          measurementUnderway_(false) {
      // changelog 2
      // pg_size = (double)getpagesize();
      std::ostringstream ost;

      openFiles();

      if (!oncePerEventMode_) {  // default, prints on increases
        iReg.watchPreSourceConstruction(this, &SimpleMemoryCheck::preSourceConstruction);
        iReg.watchPostSourceConstruction(this, &SimpleMemoryCheck::postSourceConstruction);
        iReg.watchPostSourceEvent(this, &SimpleMemoryCheck::postSourceEvent);
        iReg.watchPostModuleConstruction(this, &SimpleMemoryCheck::postModuleConstruction);
        iReg.watchPostModuleBeginJob(this, &SimpleMemoryCheck::postModuleBeginJob);
        iReg.watchPostEvent(this, &SimpleMemoryCheck::postEvent);
        iReg.watchPostModuleEvent(this, &SimpleMemoryCheck::postModule);
        iReg.watchPostBeginJob(this, &SimpleMemoryCheck::postBeginJob);
        iReg.watchPostEndJob(this, &SimpleMemoryCheck::postEndJob);
      } else {
        iReg.watchPostEvent(this, &SimpleMemoryCheck::postEvent);
        iReg.watchPostEndJob(this, &SimpleMemoryCheck::postEndJob);
      }
      if (moduleSummaryRequested_) {  // changelog 2
        iReg.watchPreModuleEvent(this, &SimpleMemoryCheck::preModule);
        if (oncePerEventMode_) {
          iReg.watchPostModuleEvent(this, &SimpleMemoryCheck::postModule);
        }
      }

      // The following are not currenty used/implemented below for either
      // of the print modes (but are left here for reference)
      //  iReg.watchPostBeginJob(this,
      //       &SimpleMemoryCheck::postBeginJob);
      //  iReg.watchPreProcessEvent(this,
      //       &SimpleMemoryCheck::preEventProcessing);
      //  iReg.watchPreModule(this,
      //       &SimpleMemoryCheck::preModule);

#ifndef __SANITIZE_ADDRESS__
      typedef MallocOpts::opt_type opt_type;
      MallocOptionSetter& mopts = getGlobalOptionSetter();

      opt_type p_mmap_max = iPS.getUntrackedParameter<int>("M_MMAP_MAX"),
               p_trim_thr = iPS.getUntrackedParameter<int>("M_TRIM_THRESHOLD"),
               p_top_pad = iPS.getUntrackedParameter<int>("M_TOP_PAD"),
               p_mmap_thr = iPS.getUntrackedParameter<int>("M_MMAP_THRESHOLD");

      if (p_mmap_max >= 0)
        mopts.set_mmap_max(p_mmap_max);
      if (p_trim_thr >= 0)
        mopts.set_trim_thr(p_trim_thr);
      if (p_top_pad >= 0)
        mopts.set_top_pad(p_top_pad);
      if (p_mmap_thr >= 0)
        mopts.set_mmap_thr(p_mmap_thr);

      mopts.adjustMallocParams();

      if (mopts.hasErrors()) {
        LogWarning("MemoryCheck") << "ERROR: Problem with setting malloc options\n" << mopts.error_message();
      }

      if (iPS.getUntrackedParameter<bool>("dump") == true) {
        MallocOpts mo = mopts.get();
        LogWarning("MemoryCheck") << "Malloc options: " << mo << "\n";
      }
#endif
    }

edm::service::SimpleMemoryCheck::~SimpleMemoryCheck

(

)

Definition at line 416 of file SimpleMemoryCheck.cc.

References smapsFile_, and smapsLineBuffer_.

                                          {
#ifdef LINUX
      if (nullptr != smapsFile_) {
        fclose(smapsFile_);
      }
#endif
      if (smapsLineBuffer_) {
        //getline will create the memory using malloc
        free(smapsLineBuffer_);
      }
    }

Member Function Documentation

void edm::service::SimpleMemoryCheck::andPrint ( const std::string &  type, const std::string &  mdlabel, const std::string &  mdname  ) const

private

Definition at line 861 of file SimpleMemoryCheck.cc.

References count_, current_, jobReportOutputOnly_, max_, num_to_skip_, oncePerEventMode_, edm::service::ProcInfo::rss, showMallocInfo_, and edm::service::ProcInfo::vsize.

Referenced by postEvent(), and updateAndPrint().

                                                                    {
      if (not jobReportOutputOnly_ && ((*current_ > max_) || oncePerEventMode_)) {
        if (count_ >= num_to_skip_) {
          double deltaVSIZE = current_->vsize - max_.vsize;
          double deltaRSS = current_->rss - max_.rss;
          if (!showMallocInfo_) {  // default
            LogWarning("MemoryCheck") << "MemoryCheck: " << type << " " << mdname << ":" << mdlabel << " VSIZE "
                                      << current_->vsize << " " << deltaVSIZE << " RSS " << current_->rss << " "
                                      << deltaRSS;
          } else {
#ifdef __linux__
            struct mallinfo minfo = mallinfo();
#endif
            LogWarning("MemoryCheck") << "MemoryCheck: " << type << " " << mdname << ":" << mdlabel << " VSIZE "
                                      << current_->vsize << " " << deltaVSIZE << " RSS " << current_->rss << " "
                                      << deltaRSS
#ifdef __linux__
                                      << " HEAP-ARENA [ SIZE-BYTES " << minfo.arena << " N-UNUSED-CHUNKS "
                                      << minfo.ordblks << " TOP-FREE-BYTES " << minfo.keepcost << " ]"
                                      << " HEAP-MAPPED [ SIZE-BYTES " << minfo.hblkhd << " N-CHUNKS " << minfo.hblks
                                      << " ]"
                                      << " HEAP-USED-BYTES " << minfo.uordblks << " HEAP-UNUSED-BYTES "
                                      << minfo.fordblks
#endif
                ;
          }
        }
      }
    }

double edm::service::SimpleMemoryCheck::averageGrowthRate ( double  current, double  past, int  count  )

private

Definition at line 325 of file SimpleMemoryCheck.cc.

Referenced by postEndJob().

                                                                                      {
      return (current - past) / (double)count;
    }

std::string edm::service::SimpleMemoryCheck::eventStatOutput ( std::string  title, SignificantEvent const &  e  ) const

private

Referenced by eventStatOutput(), and postEndJob().

void edm::service::SimpleMemoryCheck::eventStatOutput ( std::string  title, SignificantEvent const &  e, std::map< std::string, std::string > &  m  ) const

private

Definition at line 902 of file SimpleMemoryCheck.cc.

References edm::service::SimpleMemoryCheck::SignificantEvent::count, edm::service::d2str(), edm::service::SimpleMemoryCheck::SignificantEvent::deltaVsize, MillePedeFileConverter_cfg::e, edm::EventID::event(), edm::service::SimpleMemoryCheck::SignificantEvent::event, eventStatOutput(), edm::service::i2str(), mallOutput(), monitorPssAndPrivate_, gen::n, edm::service::SimpleMemoryCheck::SignificantEvent::privateSize, edm::service::SimpleMemoryCheck::SignificantEvent::pss, edm::service::SimpleMemoryCheck::SignificantEvent::rss, edm::EventID::run(), AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, and edm::service::SimpleMemoryCheck::SignificantEvent::vsize.

                                                                                   {
      {
        std::ostringstream os;
        os << title << "-a-COUNT";
        m.insert(std::make_pair(os.str(), i2str(e.count)));
      }
      {
        std::ostringstream os;
        os << title << "-b-RUN";
        m.insert(std::make_pair(os.str(), d2str(static_cast<double>(e.event.run()))));
      }
      {
        std::ostringstream os;
        os << title << "-c-EVENT";
        m.insert(std::make_pair(os.str(), d2str(static_cast<double>(e.event.event()))));
      }
      {
        std::ostringstream os;
        os << title << "-d-VSIZE";
        m.insert(std::make_pair(os.str(), d2str(e.vsize)));
      }
      {
        std::ostringstream os;
        os << title << "-e-DELTV";
        m.insert(std::make_pair(os.str(), d2str(e.deltaVsize)));
      }
      {
        std::ostringstream os;
        os << title << "-f-RSS";
        m.insert(std::make_pair(os.str(), d2str(e.rss)));
      }
      if (monitorPssAndPrivate_) {
        {
          std::ostringstream os;
          os << title << "-g-PRIVATE";
          m.insert(std::make_pair(os.str(), d2str(e.privateSize)));
        }
        {
          std::ostringstream os;
          os << title << "-h-PSS";
          m.insert(std::make_pair(os.str(), d2str(e.pss)));
        }
      }
    }  // eventStatOutput

ProcInfo edm::service::SimpleMemoryCheck::fetch ( )

private

Definition at line 289 of file SimpleMemoryCheck.cc.

Referenced by update().

{ return piFetcher_.fetch(); }

smapsInfo edm::service::SimpleMemoryCheck::fetchSmaps ( )

private

Definition at line 291 of file SimpleMemoryCheck.cc.

References edm::service::smapsInfo::private_, edm::service::smapsInfo::pss_, and relativeConstraints::value.

Referenced by postEvent().

                                            {
      smapsInfo ret;
      ret.private_ = 0;
      ret.pss_ = 0;
#ifdef LINUX
      fseek(smapsFile_, 0, SEEK_SET);
      ssize_t read;

      /*
       The format of the report is
       Private_Clean:        0 kB
       Private_Dirty:       72 kB
       Swap:                 0 kB
       Pss:                 72 kB
       */

      while ((read = getline(&smapsLineBuffer(), &smapsLineBufferLen_, smapsFile_)) != -1) {
        if (read > 14) {
          //Private
          if (0 == strncmp("Private_", smapsLineBuffer_, 8)) {
            unsigned int value = atoi(smapsLineBuffer_ + 14);
            //Convert from kB to MB
            ret.private_ += static_cast<double>(value) / 1024.;
          } else if (0 == strncmp("Pss:", smapsLineBuffer_, 4)) {
            unsigned int value = atoi(smapsLineBuffer_ + 4);
            //Convert from kB to MB
            ret.pss_ += static_cast<double>(value) / 1024.;
          }
        }
      }
#endif
      return ret;
    }

void edm::service::SimpleMemoryCheck::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 428 of file SimpleMemoryCheck.cc.

References edm::ConfigurationDescriptions::add(), and edm::ParameterSetDescription::addUntracked().

                                                                                    {
      ParameterSetDescription desc;
      desc.addUntracked<int>("ignoreTotal", 1);
      desc.addUntracked<bool>("showMallocInfo", false);
      desc.addUntracked<bool>("oncePerEventMode", false);
      desc.addUntracked<bool>("jobReportOutputOnly", false);
      desc.addUntracked<bool>("monitorPssAndPrivate", false);
      desc.addUntracked<bool>("moduleMemorySummary", false);
      desc.addUntracked<int>("M_MMAP_MAX", -1);
      desc.addUntracked<int>("M_TRIM_THRESHOLD", -1);
      desc.addUntracked<int>("M_TOP_PAD", -1);
      desc.addUntracked<int>("M_MMAP_THRESHOLD", -1);
      desc.addUntracked<bool>("dump", false);
      descriptions.add("SimpleMemoryCheck", desc);
    }

std::string edm::service::SimpleMemoryCheck::mallOutput ( std::string  title, size_t const &  n  ) const

private

Referenced by eventStatOutput(), and postEndJob().

void edm::service::SimpleMemoryCheck::openFiles ( )

private

Definition at line 444 of file SimpleMemoryCheck.cc.

References edm::errors::Configuration, Exception, monitorPssAndPrivate_, and smapsFile_.

Referenced by SimpleMemoryCheck().

                                      {
#ifdef LINUX
      if (monitorPssAndPrivate_) {
        std::ostringstream smapsNameOst;
        smapsNameOst << "/proc/" << getpid() << "/smaps";
        if ((smapsFile_ = fopen(smapsNameOst.str().c_str(), "r")) == nullptr) {
          throw Exception(errors::Configuration) << "Failed to open smaps file " << smapsNameOst.str() << std::endl;
        }
      }
#endif
    }

double edm::service::SimpleMemoryCheck::pageSize ( ) const

inlineprivate

Definition at line 103 of file SimpleMemoryCheck.cc.

References KineDebug3::count(), AlCaHLTBitMon_QueryRunRegistry::string, and update.

{ return pg_size_; }

void edm::service::SimpleMemoryCheck::postBeginJob

(

)

Definition at line 456 of file SimpleMemoryCheck.cc.

References current_, growthRateRss_, and growthRateVsize_.

Referenced by SimpleMemoryCheck().

                                         {
      growthRateVsize_ = current_->vsize;
      growthRateRss_ = current_->rss;
    }

void edm::service::SimpleMemoryCheck::postEndJob

(

)

Definition at line 506 of file SimpleMemoryCheck.cc.

References averageGrowthRate(), taus_updatedMVAIds_cff::category, count_, current_, edm::service::d2str(), edm::service::SimpleMemoryCheck::SignificantEvent::deltaRss, eventDeltaRssT1_, eventDeltaRssT2_, eventDeltaRssT3_, eventL1_, eventL2_, eventM_, edm::service::SimpleMemoryCheck::SignificantModule::eventMaxDeltaV, eventR1_, eventR2_, eventRssT1_, eventRssT2_, eventRssT3_, eventStatOutput(), eventT1_, eventT2_, eventT3_, growthRateRss_, growthRateVsize_, edm::service::i2str(), jobReportOutputOnly_, label, funct::m, mallOutput(), edm::service::SimpleMemoryCheck::SignificantModule::maxDeltaVsize, edm::service::SimpleMemoryCheck::SignificantModule::maxEarlyVsize, modules_, moduleSummaryRequested_, edm::service::SimpleMemoryCheck::SignificantModule::postEarlyCount, edm::service::SimpleMemoryCheck::SignificantEvent::rss, AlCaHLTBitMon_QueryRunRegistry::string, edm::service::SimpleMemoryCheck::SignificantModule::totalDeltaVsize, edm::service::SimpleMemoryCheck::SignificantModule::totalEarlyVsize, relativeConstraints::value, and edm::service::SimpleMemoryCheck::SignificantEvent::vsize.

Referenced by SimpleMemoryCheck().

                                       {
      if (not jobReportOutputOnly_) {
        LogAbsolute("MemoryReport")  // changelog 1
            << "MemoryReport> Peak virtual size " << eventT1_.vsize << " Mbytes"
            << "\n"
            << " Key events increasing vsize: \n"
            << eventL2_ << "\n"
            << eventL1_ << "\n"
            << eventM_ << "\n"
            << eventR1_ << "\n"
            << eventR2_ << "\n"
            << eventT3_ << "\n"
            << eventT2_ << "\n"
            << eventT1_;
      }
      if (moduleSummaryRequested_ and not jobReportOutputOnly_) {  // changelog 1
        LogAbsolute mmr("ModuleMemoryReport");                     // at end of if block, mmr
                                                                   // is destructed, causing
                                                                   // message to be logged
        mmr << "ModuleMemoryReport> Each line has module label and: \n";
        mmr << "  (after early ignored events) \n";
        mmr << "    count of times module executed; average increase in vsize \n";
        mmr << "    maximum increase in vsize; event on which maximum occurred \n";
        mmr << "  (during early ignored events) \n";
        mmr << "    total and maximum vsize increases \n \n";
        for (SignificantModulesMap::iterator im = modules_.begin(); im != modules_.end(); ++im) {
          SignificantModule const& m = im->second;
          if (m.totalDeltaVsize == 0 && m.totalEarlyVsize == 0)
            continue;
          mmr << im->first << ": ";
          mmr << "n = " << m.postEarlyCount;
          if (m.postEarlyCount > 0) {
            mmr << " avg = " << m.totalDeltaVsize / m.postEarlyCount;
          }
          mmr << " max = " << m.maxDeltaVsize << " " << m.eventMaxDeltaV;
          if (m.totalEarlyVsize > 0) {
            mmr << " early total: " << m.totalEarlyVsize;
            mmr << " max: " << m.maxEarlyVsize;
          }
          mmr << "\n";
        }
      }  // end of if; mmr goes out of scope; log message is queued

      Service<JobReport> reportSvc;
      // changelog 1
#define SIMPLE_MEMORY_CHECK_ORIGINAL_XML_OUTPUT
#ifdef SIMPLE_MEMORY_CHECK_ORIGINAL_XML_OUTPUT
      //     std::map<std::string, double> reportData;
      std::map<std::string, std::string> reportData;

      if (eventL2_.vsize > 0)
        eventStatOutput("LargeVsizeIncreaseEventL2", eventL2_, reportData);
      if (eventL1_.vsize > 0)
        eventStatOutput("LargeVsizeIncreaseEventL1", eventL1_, reportData);
      if (eventM_.vsize > 0)
        eventStatOutput("LargestVsizeIncreaseEvent", eventM_, reportData);
      if (eventR1_.vsize > 0)
        eventStatOutput("LargeVsizeIncreaseEventR1", eventR1_, reportData);
      if (eventR2_.vsize > 0)
        eventStatOutput("LargeVsizeIncreaseEventR2", eventR2_, reportData);
      if (eventT3_.vsize > 0)
        eventStatOutput("ThirdLargestVsizeEventT3", eventT3_, reportData);
      if (eventT2_.vsize > 0)
        eventStatOutput("SecondLargestVsizeEventT2", eventT2_, reportData);
      if (eventT1_.vsize > 0)
        eventStatOutput("LargestVsizeEventT1", eventT1_, reportData);

      if (eventRssT3_.rss > 0)
        eventStatOutput("ThirdLargestRssEvent", eventRssT3_, reportData);
      if (eventRssT2_.rss > 0)
        eventStatOutput("SecondLargestRssEvent", eventRssT2_, reportData);
      if (eventRssT1_.rss > 0)
        eventStatOutput("LargestRssEvent", eventRssT1_, reportData);
      if (eventDeltaRssT3_.deltaRss > 0)
        eventStatOutput("ThirdLargestIncreaseRssEvent", eventDeltaRssT3_, reportData);
      if (eventDeltaRssT2_.deltaRss > 0)
        eventStatOutput("SecondLargestIncreaseRssEvent", eventDeltaRssT2_, reportData);
      if (eventDeltaRssT1_.deltaRss > 0)
        eventStatOutput("LargestIncreaseRssEvent", eventDeltaRssT1_, reportData);

#ifdef __linux__
      struct mallinfo minfo = mallinfo();
      reportData.insert(std::make_pair("HEAP_ARENA_SIZE_BYTES", i2str(minfo.arena)));
      reportData.insert(std::make_pair("HEAP_ARENA_N_UNUSED_CHUNKS", i2str(minfo.ordblks)));
      reportData.insert(std::make_pair("HEAP_TOP_FREE_BYTES", i2str(minfo.keepcost)));
      reportData.insert(std::make_pair("HEAP_MAPPED_SIZE_BYTES", i2str(minfo.hblkhd)));
      reportData.insert(std::make_pair("HEAP_MAPPED_N_CHUNKS", i2str(minfo.hblks)));
      reportData.insert(std::make_pair("HEAP_USED_BYTES", i2str(minfo.uordblks)));
      reportData.insert(std::make_pair("HEAP_UNUSED_BYTES", i2str(minfo.fordblks)));
#endif

      // Report Growth rates for VSize and Rss
      reportData.insert(std::make_pair("AverageGrowthRateVsize",
                                       d2str(averageGrowthRate(current_->vsize, growthRateVsize_, count_))));
      reportData.insert(std::make_pair("PeakValueVsize", d2str(eventT1_.vsize)));
      reportData.insert(
          std::make_pair("AverageGrowthRateRss", d2str(averageGrowthRate(current_->rss, growthRateRss_, count_))));
      reportData.insert(std::make_pair("PeakValueRss", d2str(eventRssT1_.rss)));

      if (moduleSummaryRequested_) {  // changelog 2
        for (SignificantModulesMap::iterator im = modules_.begin(); im != modules_.end(); ++im) {
          SignificantModule const& m = im->second;
          if (m.totalDeltaVsize == 0 && m.totalEarlyVsize == 0)
            continue;
          std::string label = im->first + ":";
          reportData.insert(std::make_pair(label + "PostEarlyCount", i2str(m.postEarlyCount)));
          if (m.postEarlyCount > 0) {
            reportData.insert(std::make_pair(label + "AverageDeltaVsize", d2str(m.totalDeltaVsize / m.postEarlyCount)));
          }
          reportData.insert(std::make_pair(label + "MaxDeltaVsize", d2str(m.maxDeltaVsize)));
          if (m.totalEarlyVsize > 0) {
            reportData.insert(std::make_pair(label + "TotalEarlyVsize", d2str(m.totalEarlyVsize)));
            reportData.insert(std::make_pair(label + "MaxEarlyDeltaVsize", d2str(m.maxEarlyVsize)));
          }
        }
      }

      std::map<std::string, std::string> reportMemoryProperties;

      if (FILE* fmeminfo = fopen("/proc/meminfo", "r")) {
        char buf[128];
        char space[] = " ";
        size_t value;
        while (fgets(buf, sizeof(buf), fmeminfo)) {
          char* saveptr;
          char* token = nullptr;
          token = strtok_r(buf, space, &saveptr);
          if (token != nullptr) {
            value = atol(strtok_r(nullptr, space, &saveptr));
            std::string category = token;
            reportMemoryProperties.insert(std::make_pair(category.substr(0, strlen(token) - 1), i2str(value)));
          }
        }

        fclose(fmeminfo);
      }

      //      reportSvc->reportMemoryInfo(reportData, reportMemoryProperties);
      reportSvc->reportPerformanceSummary("ApplicationMemory", reportData);
      reportSvc->reportPerformanceSummary("SystemMemory", reportMemoryProperties);
#endif

#ifdef SIMPLE_MEMORY_CHECK_DIFFERENT_XML_OUTPUT
      std::vector<std::string> reportData;

      if (eventL2_.vsize > 0)
        reportData.push_back(eventStatOutput("LargeVsizeIncreaseEventL2", eventL2_));
      if (eventL1_.vsize > 0)
        reportData.push_back(eventStatOutput("LargeVsizeIncreaseEventL1", eventL1_));
      if (eventM_.vsize > 0)
        reportData.push_back(eventStatOutput("LargestVsizeIncreaseEvent", eventM_));
      if (eventR1_.vsize > 0)
        reportData.push_back(eventStatOutput("LargeVsizeIncreaseEventR1", eventR1_));
      if (eventR2_.vsize > 0)
        reportData.push_back(eventStatOutput("LargeVsizeIncreaseEventR2", eventR2_));
      if (eventT3_.vsize > 0)
        reportData.push_back(eventStatOutput("ThirdLargestVsizeEventT3", eventT3_));
      if (eventT2_.vsize > 0)
        reportData.push_back(eventStatOutput("SecondLargestVsizeEventT2", eventT2_));
      if (eventT1_.vsize > 0)
        reportData.push_back(eventStatOutput("LargestVsizeEventT1", eventT1_));

      if (eventRssT3_.rss > 0)
        eventStatOutput("ThirdLargestRssEvent", eventRssT3_, reportData);
      if (eventRssT2_.rss > 0)
        eventStatOutput("SecondLargestRssEvent", eventRssT2_, reportData);
      if (eventRssT1_.rss > 0)
        eventStatOutput("LargestRssEvent", eventRssT1_, reportData);
      if (eventDeltaRssT3_.deltaRss > 0)
        eventStatOutput("ThirdLargestIncreaseRssEvent", eventDeltaRssT3_, reportData);
      if (eventDeltaRssT2_.deltaRss > 0)
        eventStatOutput("SecondLargestIncreaseRssEvent", eventDeltaRssT2_, reportData);
      if (eventDeltaRssT1_.deltaRss > 0)
        eventStatOutput("LargestIncreaseRssEvent", eventDeltaRssT1_, reportData);

      struct mallinfo minfo = mallinfo();
      reportData.push_back(mallOutput("HEAP_ARENA_SIZE_BYTES", minfo.arena));
      reportData.push_back(mallOutput("HEAP_ARENA_N_UNUSED_CHUNKS", minfo.ordblks));
      reportData.push_back(mallOutput("HEAP_TOP_FREE_BYTES", minfo.keepcost));
      reportData.push_back(mallOutput("HEAP_MAPPED_SIZE_BYTES", minfo.hblkhd));
      reportData.push_back(mallOutput("HEAP_MAPPED_N_CHUNKS", minfo.hblks));
      reportData.push_back(mallOutput("HEAP_USED_BYTES", minfo.uordblks));
      reportData.push_back(mallOutput("HEAP_UNUSED_BYTES", minfo.fordblks));

      // Report Growth rates for VSize and Rss
      reportData.insert(std::make_pair("AverageGrowthRateVsize",
                                       d2str(averageGrowthRate(current_->vsize, growthRateVsize_, count_))));
      reportData.insert(std::make_pair("PeakValueVsize", d2str(eventT1_.vsize)));
      reportData.insert(
          std::make_pair("AverageGrowthRateRss", d2str(averageGrowthRate(current_->rss, growthRateRss_, count_))));
      reportData.insert(std::make_pair("PeakValueRss", d2str(eventRssT1_.rss)));

      reportSvc->reportMemoryInfo(reportData);
      // This is a form of reportMemoryInfo taking s vector, not a map
#endif
    }  // postEndJob

void edm::service::SimpleMemoryCheck::postEvent

(

StreamContext const &

iContext

)

Definition at line 703 of file SimpleMemoryCheck.cc.

References andPrint(), count_, currentSmaps_, edm::StreamContext::eventID(), fetchSmaps(), measurementUnderway_, monitorPssAndPrivate_, oncePerEventMode_, update(), updateEventStats(), and updateMax().

Referenced by SimpleMemoryCheck().

                                                                   {
      ++count_;
      bool expected = false;
      if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
        std::shared_ptr<void> guard(
            nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
        update();
        if (monitorPssAndPrivate_) {
          currentSmaps_ = fetchSmaps();
        }
        updateEventStats(iContext.eventID());
        if (oncePerEventMode_) {
          // should probably use be Run:Event or count_ for the label and name
          updateMax();
          andPrint("event", "", "");
        }
      }
    }

void edm::service::SimpleMemoryCheck::postModule	(	StreamContext const &	iStreamContext,
		ModuleCallingContext const &	iModuleContext
	)

Definition at line 738 of file SimpleMemoryCheck.cc.

References current_, edm::StreamContext::eventID(), edm::ModuleDescription::id(), label, measurementUnderway_, edm::ModuleCallingContext::moduleDescription(), moduleEntryVsize_, moduleID_, edm::ModuleDescription::moduleLabel(), moduleMeasurementUnderway_, modules_, moduleStreamID_, moduleSummaryRequested_, oncePerEventMode_, edm::StreamContext::streamID(), AlCaHLTBitMon_QueryRunRegistry::string, update(), updateAndPrint(), updateModuleMemoryStats(), and edm::StreamID::value().

Referenced by SimpleMemoryCheck().

                                                                                   {
      if (!oncePerEventMode_) {
        bool expected = false;
        if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
          std::shared_ptr<void> guard(
              nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
          auto const md = iModuleContext.moduleDescription();
          updateAndPrint("module", md->moduleLabel(), md->moduleName());
        }
      }

      if (moduleSummaryRequested_) {
        //is this the module instance we are measuring?
        if (moduleMeasurementUnderway_.load(std::memory_order_acquire) and
            (iStreamContext.streamID().value() == moduleStreamID_.load(std::memory_order_acquire)) and
            (iModuleContext.moduleDescription()->id() == moduleID_.load(std::memory_order_acquire))) {
          //Need to release our module measurement lock
          std::shared_ptr<void> guard(
              nullptr, [this](void const*) { moduleMeasurementUnderway_.store(false, std::memory_order_release); });
          bool expected = false;
          if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
            std::shared_ptr<void> guard(
                nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
            if (oncePerEventMode_) {
              update();
            }
            // changelog 2
            double dv = current_->vsize - moduleEntryVsize_;
            std::string label = iModuleContext.moduleDescription()->moduleLabel();
            updateModuleMemoryStats(modules_[label], dv, iStreamContext.eventID());
          }
        }
      }
    }

void edm::service::SimpleMemoryCheck::postModuleBeginJob

(

const ModuleDescription &

)

Definition at line 497 of file SimpleMemoryCheck.cc.

References measurementUnderway_, edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), and updateAndPrint().

Referenced by SimpleMemoryCheck().

                                                                          {
      bool expected = false;
      if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
        std::shared_ptr<void> guard(
            nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
        updateAndPrint("beginJob", md.moduleLabel(), md.moduleName());
      }
    }

void edm::service::SimpleMemoryCheck::postModuleConstruction

(

const ModuleDescription &

)

Definition at line 488 of file SimpleMemoryCheck.cc.

References measurementUnderway_, edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), and updateAndPrint().

Referenced by SimpleMemoryCheck().

                                                                              {
      bool expected = false;
      if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
        std::shared_ptr<void> guard(
            nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
        updateAndPrint("ctor", md.moduleLabel(), md.moduleName());
      }
    }

void edm::service::SimpleMemoryCheck::postSourceConstruction

(

const ModuleDescription &

)

Definition at line 470 of file SimpleMemoryCheck.cc.

References measurementUnderway_, edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), and updateAndPrint().

Referenced by SimpleMemoryCheck().

                                                                              {
      bool expected = false;
      if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
        std::shared_ptr<void> guard(
            nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
        updateAndPrint("ctor", md.moduleLabel(), md.moduleName());
      }
    }

void edm::service::SimpleMemoryCheck::postSourceEvent

(

StreamID

sid

)

Definition at line 479 of file SimpleMemoryCheck.cc.

References measurementUnderway_, and updateAndPrint().

Referenced by SimpleMemoryCheck().

                                                        {
      bool expected = false;
      if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
        std::shared_ptr<void> guard(
            nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
        updateAndPrint("module", "source", "source");
      }
    }

void edm::service::SimpleMemoryCheck::preModule	(	StreamContext const &	iStreamContext,
		ModuleCallingContext const &	iModuleContext
	)

Definition at line 722 of file SimpleMemoryCheck.cc.

References current_, edm::ModuleDescription::id(), measurementUnderway_, edm::ModuleCallingContext::moduleDescription(), moduleEntryVsize_, moduleID_, moduleMeasurementUnderway_, moduleStreamID_, edm::StreamContext::streamID(), update(), and edm::StreamID::value().

Referenced by SimpleMemoryCheck().

                                                                                                                     {
      bool expected = false;
      if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
        std::shared_ptr<void> guard(
            nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
        bool expected = false;
        if (moduleMeasurementUnderway_.compare_exchange_strong(expected, true)) {
          update();
          // changelog 2
          moduleEntryVsize_ = current_->vsize;
          moduleStreamID_.store(iStreamContext.streamID().value(), std::memory_order_release);
          moduleID_.store(iModuleContext.moduleDescription()->id(), std::memory_order_release);
        }
      }
    }

void edm::service::SimpleMemoryCheck::preSourceConstruction

(

const ModuleDescription &

)

Definition at line 461 of file SimpleMemoryCheck.cc.

References measurementUnderway_, edm::ModuleDescription::moduleLabel(), edm::ModuleDescription::moduleName(), and updateAndPrint().

Referenced by SimpleMemoryCheck().

                                                                             {
      bool expected = false;
      if (measurementUnderway_.compare_exchange_strong(expected, true, std::memory_order_acq_rel)) {
        std::shared_ptr<void> guard(
            nullptr, [this](void const*) { measurementUnderway_.store(false, std::memory_order_release); });
        updateAndPrint("pre-ctor", md.moduleLabel(), md.moduleName());
      }
    }

char const* edm::service::SimpleMemoryCheck::smapsLineBuffer ( ) const

inlineprivate

Definition at line 111 of file SimpleMemoryCheck.cc.

References edm::get_underlying_safe().

{ return get_underlying_safe(smapsLineBuffer_); }

char*& edm::service::SimpleMemoryCheck::smapsLineBuffer ( )

inlineprivate

Definition at line 112 of file SimpleMemoryCheck.cc.

References edm::get_underlying_safe().

{ return get_underlying_safe(smapsLineBuffer_); }

void edm::service::SimpleMemoryCheck::update ( )

private

Definition at line 774 of file SimpleMemoryCheck.cc.

References current_, fetch(), previous_, and std::swap().

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), Vispa.Gui.VispaWidget.VispaWidget::autosize(), Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Views.LineDecayView.LineDecayContainer::deselectAllObjects(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::deselectAllWidgets(), Vispa.Gui.VispaWidget.VispaWidget::enableAutosizing(), progressbar.ProgressBar::finish(), Vispa.Gui.MenuWidget.MenuWidget::leaveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), Vispa.Views.LineDecayView.LineDecayContainer::mouseMoveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseReleaseEvent(), Vispa.Views.LineDecayView.LineDecayContainer::objectMoved(), MatrixUtil.Steps::overwrite(), postEvent(), postModule(), preModule(), Vispa.Views.LineDecayView.LineDecayContainer::removeObject(), Vispa.Gui.ConnectableWidget.ConnectableWidget::removePorts(), Vispa.Gui.FindDialog.FindDialog::reset(), Vispa.Gui.PortConnection.PointToPointConnection::select(), Vispa.Gui.VispaWidget.VispaWidget::select(), Vispa.Views.LineDecayView.LineDecayContainer::select(), Vispa.Gui.VispaWidget.VispaWidget::setText(), Vispa.Gui.VispaWidget.VispaWidget::setTitle(), Vispa.Gui.ZoomableWidget.ZoomableWidget::setZoom(), Vispa.Views.LineDecayView.LineDecayContainer::setZoom(), updateAndPrint(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

                                   {
      std::swap(current_, previous_);
      *current_ = fetch();
    }

void edm::service::SimpleMemoryCheck::updateAndPrint ( const std::string &  type, const std::string &  mdlabel, const std::string &  mdname  )

private

Definition at line 893 of file SimpleMemoryCheck.cc.

References andPrint(), update(), and updateMax().

Referenced by postModule(), postModuleBeginJob(), postModuleConstruction(), postSourceConstruction(), postSourceEvent(), and preSourceConstruction().

                                                                    {
      update();
      andPrint(type, mdlabel, mdname);
      updateMax();
    }

void edm::service::SimpleMemoryCheck::updateEventStats ( edm::EventID const &  e )

private

Definition at line 787 of file SimpleMemoryCheck.cc.

References count_, current_, edm::service::SimpleMemoryCheck::SignificantEvent::deltaRss, edm::service::SimpleMemoryCheck::SignificantEvent::deltaVsize, eventDeltaRssT1_, eventDeltaRssT2_, eventDeltaRssT3_, eventL1_, eventL2_, eventM_, eventR1_, eventR2_, eventRssT1_, eventRssT2_, eventRssT3_, eventT1_, eventT2_, eventT3_, num_to_skip_, edm::service::SimpleMemoryCheck::SignificantEvent::rss, edm::service::SimpleMemoryCheck::SignificantEvent::set(), SignificantEvent, and edm::service::SimpleMemoryCheck::SignificantEvent::vsize.

Referenced by postEvent().

                                                             {
      if (count_ < num_to_skip_)
        return;
      if (count_ == num_to_skip_) {
        eventT1_.set(0, 0, e, this);
        eventM_.set(0, 0, e, this);
        eventRssT1_.set(0, 0, e, this);
        eventDeltaRssT1_.set(0, 0, e, this);
        return;
      }
      double vsize = current_->vsize;
      double deltaVsize = vsize - eventT1_.vsize;

      // Update significative events for Vsize
      if (vsize > eventT1_.vsize) {
        double deltaRss = current_->rss - eventT1_.rss;
        eventT3_ = eventT2_;
        eventT2_ = eventT1_;
        eventT1_.set(deltaVsize, deltaRss, e, this);
      } else if (vsize > eventT2_.vsize) {
        double deltaRss = current_->rss - eventT1_.rss;
        eventT3_ = eventT2_;
        eventT2_.set(deltaVsize, deltaRss, e, this);
      } else if (vsize > eventT3_.vsize) {
        double deltaRss = current_->rss - eventT1_.rss;
        eventT3_.set(deltaVsize, deltaRss, e, this);
      }

      if (deltaVsize > eventM_.deltaVsize) {
        double deltaRss = current_->rss - eventM_.rss;
        if (eventL1_.deltaVsize >= eventR1_.deltaVsize) {
          eventL2_ = eventL1_;
        } else {
          eventL2_ = eventR1_;
        }
        eventL1_ = eventM_;
        eventM_.set(deltaVsize, deltaRss, e, this);
        eventR1_ = SignificantEvent();
        eventR2_ = SignificantEvent();
      } else if (deltaVsize > eventR1_.deltaVsize) {
        double deltaRss = current_->rss - eventM_.rss;
        eventR2_ = eventR1_;
        eventR1_.set(deltaVsize, deltaRss, e, this);
      } else if (deltaVsize > eventR2_.deltaVsize) {
        double deltaRss = current_->rss - eventR1_.rss;
        eventR2_.set(deltaVsize, deltaRss, e, this);
      }

      // Update significative events for Rss
      double rss = current_->rss;
      double deltaRss = rss - eventRssT1_.rss;

      if (rss > eventRssT1_.rss) {
        eventRssT3_ = eventRssT2_;
        eventRssT2_ = eventRssT1_;
        eventRssT1_.set(deltaVsize, deltaRss, e, this);
      } else if (rss > eventRssT2_.rss) {
        eventRssT3_ = eventRssT2_;
        eventRssT2_.set(deltaVsize, deltaRss, e, this);
      } else if (rss > eventRssT3_.rss) {
        eventRssT3_.set(deltaVsize, deltaRss, e, this);
      }
      if (deltaRss > eventDeltaRssT1_.deltaRss) {
        eventDeltaRssT3_ = eventDeltaRssT2_;
        eventDeltaRssT2_ = eventDeltaRssT1_;
        eventDeltaRssT1_.set(deltaVsize, deltaRss, e, this);
      } else if (deltaRss > eventDeltaRssT2_.deltaRss) {
        eventDeltaRssT3_ = eventDeltaRssT2_;
        eventDeltaRssT2_.set(deltaVsize, deltaRss, e, this);
      } else if (deltaRss > eventDeltaRssT3_.deltaRss) {
        eventDeltaRssT3_.set(deltaVsize, deltaRss, e, this);
      }
    }  // updateEventStats

void edm::service::SimpleMemoryCheck::updateMax ( )

private

Definition at line 779 of file SimpleMemoryCheck.cc.

References count_, current_, max_, num_to_skip_, and oncePerEventMode_.

Referenced by postEvent(), and updateAndPrint().

                                      {
      if ((*current_ > max_) || oncePerEventMode_) {
        if (count_ >= num_to_skip_) {
        }
        max_ = *current_;
      }
    }

void edm::service::SimpleMemoryCheck::updateModuleMemoryStats ( SignificantModule &  m, double  dv, edm::EventID const &  currentEventID  )

private

Definition at line 970 of file SimpleMemoryCheck.cc.

References count_, edm::service::SimpleMemoryCheck::SignificantModule::eventMaxDeltaV, edm::service::SimpleMemoryCheck::SignificantModule::maxDeltaVsize, edm::service::SimpleMemoryCheck::SignificantModule::maxEarlyVsize, num_to_skip_, edm::service::SimpleMemoryCheck::SignificantModule::postEarlyCount, edm::service::SimpleMemoryCheck::SignificantModule::totalDeltaVsize, and edm::service::SimpleMemoryCheck::SignificantModule::totalEarlyVsize.

Referenced by postModule().

                                                                                      {
      if (count_ < num_to_skip_) {
        m.totalEarlyVsize += dv;
        if (dv > m.maxEarlyVsize)
          m.maxEarlyVsize = dv;
      } else {
        ++m.postEarlyCount;
        m.totalDeltaVsize += dv;
        if (dv > m.maxDeltaVsize) {
          m.maxDeltaVsize = dv;
          m.eventMaxDeltaV = currentEventID;
        }
      }
    }  //updateModuleMemoryStats

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, SimpleMemoryCheck::SignificantEvent const &  se  )

friend

Definition at line 987 of file SimpleMemoryCheck.cc.

                                                                                        {
      os << "[" << se.count << "] " << se.event << "  vsize = " << se.vsize << " deltaVsize = " << se.deltaVsize
         << " rss = " << se.rss << " delta = " << se.deltaRss;

      if (se.monitorPssAndPrivate) {
        os << " private = " << se.privateSize << " pss = " << se.pss;
      }
      return os;
    }

std::ostream& operator<< ( std::ostream &  os, SimpleMemoryCheck::SignificantModule const &  se  )

friend

Definition at line 997 of file SimpleMemoryCheck.cc.

                                                                                         {
      if (sm.postEarlyCount > 0) {
        os << "\nPost Early Events:  TotalDeltaVsize: " << sm.totalDeltaVsize
           << " (avg: " << sm.totalDeltaVsize / sm.postEarlyCount << "; max: " << sm.maxDeltaVsize << " during "
           << sm.eventMaxDeltaV << ")";
      }
      if (sm.totalEarlyVsize > 0) {
        os << "\n     Early Events:  TotalDeltaVsize: " << sm.totalEarlyVsize << " (max: " << sm.maxEarlyVsize << ")";
      }

      return os;
    }

friend struct SignificantEvent

friend

Definition at line 176 of file SimpleMemoryCheck.cc.

Referenced by updateEventStats().

friend struct SignificantModule

friend

Definition at line 244 of file SimpleMemoryCheck.cc.

Member Data Documentation

ProcInfo edm::service::SimpleMemoryCheck::a_

private

Definition at line 114 of file SimpleMemoryCheck.cc.

ProcInfo edm::service::SimpleMemoryCheck::b_

private

Definition at line 115 of file SimpleMemoryCheck.cc.

std::atomic<int> edm::service::SimpleMemoryCheck::count_

private

Definition at line 130 of file SimpleMemoryCheck.cc.

Referenced by andPrint(), postEndJob(), postEvent(), updateEventStats(), updateMax(), and updateModuleMemoryStats().

edm::propagate_const<ProcInfo*> edm::service::SimpleMemoryCheck::current_

private

Definition at line 117 of file SimpleMemoryCheck.cc.

Referenced by andPrint(), postBeginJob(), postEndJob(), postModule(), preModule(), update(), updateEventStats(), and updateMax().

smapsInfo edm::service::SimpleMemoryCheck::currentSmaps_

private

Definition at line 120 of file SimpleMemoryCheck.cc.

Referenced by postEvent().

SignificantEvent edm::service::SimpleMemoryCheck::eventDeltaRssT1_

private

Definition at line 218 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventDeltaRssT2_

private

Definition at line 219 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventDeltaRssT3_

private

Definition at line 220 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventL1_

private

Definition at line 195 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventL2_

private

Definition at line 196 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventM_

private

Definition at line 194 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventR1_

private

Definition at line 197 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventR2_

private

Definition at line 198 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventRssT1_

private

Definition at line 215 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventRssT2_

private

Definition at line 216 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventRssT3_

private

Definition at line 217 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventT1_

private

Definition at line 199 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventT2_

private

Definition at line 200 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

SignificantEvent edm::service::SimpleMemoryCheck::eventT3_

private

Definition at line 201 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and updateEventStats().

double edm::service::SimpleMemoryCheck::growthRateRss_

private

Definition at line 139 of file SimpleMemoryCheck.cc.

Referenced by postBeginJob(), and postEndJob().

double edm::service::SimpleMemoryCheck::growthRateVsize_

private

Definition at line 138 of file SimpleMemoryCheck.cc.

Referenced by postBeginJob(), and postEndJob().

bool edm::service::SimpleMemoryCheck::jobReportOutputOnly_

private

Definition at line 128 of file SimpleMemoryCheck.cc.

Referenced by andPrint(), and postEndJob().

ProcInfo edm::service::SimpleMemoryCheck::max_

private

Definition at line 116 of file SimpleMemoryCheck.cc.

Referenced by andPrint(), and updateMax().

std::atomic<bool> edm::service::SimpleMemoryCheck::measurementUnderway_

private

Definition at line 253 of file SimpleMemoryCheck.cc.

Referenced by postEvent(), postModule(), postModuleBeginJob(), postModuleConstruction(), postSourceConstruction(), postSourceEvent(), preModule(), and preSourceConstruction().

double edm::service::SimpleMemoryCheck::moduleEntryVsize_

private

Definition at line 249 of file SimpleMemoryCheck.cc.

Referenced by postModule(), and preModule().

std::atomic<unsigned int> edm::service::SimpleMemoryCheck::moduleID_

private

Definition at line 256 of file SimpleMemoryCheck.cc.

Referenced by postModule(), and preModule().

std::atomic<bool> edm::service::SimpleMemoryCheck::moduleMeasurementUnderway_

private

Definition at line 254 of file SimpleMemoryCheck.cc.

Referenced by postModule(), and preModule().

SignificantModulesMap edm::service::SimpleMemoryCheck::modules_

private

Definition at line 248 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), and postModule().

std::atomic<unsigned int> edm::service::SimpleMemoryCheck::moduleStreamID_

private

Definition at line 255 of file SimpleMemoryCheck.cc.

Referenced by postModule(), and preModule().

bool edm::service::SimpleMemoryCheck::moduleSummaryRequested_

private

Definition at line 246 of file SimpleMemoryCheck.cc.

Referenced by postEndJob(), postModule(), and SimpleMemoryCheck().

bool edm::service::SimpleMemoryCheck::monitorPssAndPrivate_

private

Definition at line 129 of file SimpleMemoryCheck.cc.

Referenced by eventStatOutput(), openFiles(), and postEvent().

int edm::service::SimpleMemoryCheck::num_to_skip_

private

Definition at line 124 of file SimpleMemoryCheck.cc.

Referenced by andPrint(), updateEventStats(), updateMax(), and updateModuleMemoryStats().

bool edm::service::SimpleMemoryCheck::oncePerEventMode_

private

Definition at line 127 of file SimpleMemoryCheck.cc.

Referenced by andPrint(), postEvent(), postModule(), SimpleMemoryCheck(), and updateMax().

double edm::service::SimpleMemoryCheck::pg_size_

private

Definition at line 123 of file SimpleMemoryCheck.cc.

ProcInfoFetcher edm::service::SimpleMemoryCheck::piFetcher_

private

Definition at line 122 of file SimpleMemoryCheck.cc.

edm::propagate_const<ProcInfo*> edm::service::SimpleMemoryCheck::previous_

private

Definition at line 118 of file SimpleMemoryCheck.cc.

Referenced by update().

bool edm::service::SimpleMemoryCheck::showMallocInfo_

private

Definition at line 126 of file SimpleMemoryCheck.cc.

Referenced by andPrint().

edm::propagate_const<FILE*> edm::service::SimpleMemoryCheck::smapsFile_

private

Definition at line 133 of file SimpleMemoryCheck.cc.

Referenced by openFiles(), and ~SimpleMemoryCheck().

edm::propagate_const<char*> edm::service::SimpleMemoryCheck::smapsLineBuffer_

private

Definition at line 134 of file SimpleMemoryCheck.cc.

Referenced by ~SimpleMemoryCheck().

size_t edm::service::SimpleMemoryCheck::smapsLineBufferLen_

private

Definition at line 135 of file SimpleMemoryCheck.cc.