Classes
struct	Config

struct	PerScheduleData

Public Types
using	Parameters = ServiceTable< Config >

Public Member Functions
	MemoryTracker (fhicl::ParameterSet const &)

	MemoryTracker (ServiceTable< Config > const &, ActivityRegistry &)

Private Types
template<unsigned N>
using	name_array = cet::sqlite::name_array< N >

using	peakUsage_t = cet::sqlite::Ntuple< std::string, double, std::string >

using	otherInfo_t = cet::sqlite::Ntuple< std::string, std::string, std::string, double, double >

using	memEvent_t = cet::sqlite::Ntuple< std::string, uint32_t, uint32_t, uint32_t, double, double >

using	memModule_t = cet::sqlite::Ntuple< std::string, uint32_t, uint32_t, uint32_t, std::string, std::string, std::string, double, double >

using	memEventHeap_t = cet::sqlite::Ntuple< std::string, uint32_t, uint32_t, uint32_t, int, int, int, int, int, int, int >

using	memModuleHeap_t = cet::sqlite::Ntuple< std::string, uint32_t, uint32_t, uint32_t, std::string, std::string, std::string, int, int, int, int, int, int, int >

Private Member Functions
void	prePathProcessing (std::string const &)

void	recordOtherData (ModuleDescription const &md, std::string const &step)

void	recordEventData (Event const &e, std::string const &step)

void	recordModuleData (ModuleDescription const &md, std::string const &step)

void	postEndJob ()

bool	checkMallocConfig_ (std::string const &, bool)

void	recordPeakUsages_ ()

void	flushTables_ ()

void	summary_ ()

Private Attributes
LinuxProcMgr	procInfo_

std::string	fileName_

cet::sqlite::Connection	db_

bool	overwriteContents_

bool	includeMallocInfo_

std::vector< PerScheduleData >	data_

name_array< 3u >	peakUsageColumns_ {{"Name", "Value", "Description"}}

name_array< 5u >	otherInfoColumns_

name_array< 6u >	eventColumns_

name_array< 9u >	moduleColumns_

name_array< 11u >	eventHeapColumns_

name_array< 14u >	moduleHeapColumns_

peakUsage_t	peakUsageTable_

otherInfo_t	otherInfoTable_

memEvent_t	eventTable_

memModule_t	moduleTable_

std::unique_ptr< memEventHeap_t >	eventHeapTable_

std::unique_ptr< memModuleHeap_t >	moduleHeapTable_

Detailed Description

Definition at line 16 of file MemoryTrackerDarwin_service.cc.

Member Typedef Documentation

using art::MemoryTracker::memEvent_t = cet::sqlite:: Ntuple<std::string, uint32_t, uint32_t, uint32_t, double, double>

private

Definition at line 147 of file MemoryTrackerLinux_service.cc.

using art::MemoryTracker::memEventHeap_t = cet::sqlite::Ntuple<std::string, uint32_t, uint32_t, uint32_t, int, int, int, int, int, int, int>

private

Definition at line 167 of file MemoryTrackerLinux_service.cc.

using art::MemoryTracker::memModule_t = cet::sqlite::Ntuple<std::string, uint32_t, uint32_t, uint32_t, std::string, std::string, std::string, double, double>

private

Definition at line 156 of file MemoryTrackerLinux_service.cc.

using art::MemoryTracker::memModuleHeap_t = cet::sqlite::Ntuple<std::string, uint32_t, uint32_t, uint32_t, std::string, std::string, std::string, int, int, int, int, int, int, int>

private

Definition at line 181 of file MemoryTrackerLinux_service.cc.

template<unsigned N>

using art::MemoryTracker::name_array = cet::sqlite::name_array<N>

private

Definition at line 101 of file MemoryTrackerLinux_service.cc.

using art::MemoryTracker::otherInfo_t = cet::sqlite:: Ntuple<std::string, std::string, std::string, double, double>

private

Definition at line 145 of file MemoryTrackerLinux_service.cc.

using art::MemoryTracker::Parameters = ServiceTable<Config>

Definition at line 65 of file MemoryTrackerLinux_service.cc.

using art::MemoryTracker::peakUsage_t = cet::sqlite::Ntuple<std::string, double, std::string>

private

Definition at line 143 of file MemoryTrackerLinux_service.cc.

Constructor & Destructor Documentation

art::MemoryTracker::MemoryTracker ( fhicl::ParameterSet const & )

inline

Definition at line 18 of file MemoryTrackerDarwin_service.cc.

References DECLARE_ART_SERVICE, DEFINE_ART_SERVICE, and art::LEGACY.

     {
       mf::LogAbsolute("MemoryTracker")
         << "\n"
         << "The MemoryTracker service is not supported for this operating "
            "system.\n"
         << "If desired, please log an issue with:\n\n"
         << "https://cdcvs.fnal.gov/redmine/projects/cet-is/issues/new\n\n";
     }

art::MemoryTracker::MemoryTracker	(	ServiceTable< Config > const &	config,
		ActivityRegistry &	iReg
	)

Definition at line 209 of file MemoryTrackerLinux_service.cc.

References checkMallocConfig_(), data_, db_, e, eventColumns_, eventHeapColumns_, eventHeapTable_, eventTable_, fileName_, art::ServiceHandle< T, SCOPE >::get(), includeMallocInfo_, moduleColumns_, moduleHeapColumns_, moduleHeapTable_, moduleTable_, otherInfoColumns_, otherInfoTable_, overwriteContents_, peakUsageColumns_, peakUsageTable_, postEndJob(), prePathProcessing(), recordEventData(), recordModuleData(), and recordOtherData().

   : procInfo_{nSchedules}
   , fileName_{config().dbOutput().filename()}
   , db_{ServiceHandle<DatabaseConnection>{}->get(fileName_)}
   , overwriteContents_{config().dbOutput().overwrite()}
   // Fix so that a value of 'false' is an error if filename => in-memory db.
   , includeMallocInfo_{checkMallocConfig_(config().dbOutput().filename(),
                                           config().includeMallocInfo())}
   // tables
   , peakUsageTable_{db_, "PeakUsage", peakUsageColumns_, true}
   // always recompute the peak usage
   , otherInfoTable_{db_, "OtherInfo", otherInfoColumns_, overwriteContents_}
   , eventTable_{db_, "EventInfo", eventColumns_, overwriteContents_}
   , moduleTable_{db_, "ModuleInfo", moduleColumns_, overwriteContents_}
   , eventHeapTable_{includeMallocInfo_ ?
                       std::make_unique<memEventHeap_t>(db_,
                                                        "EventMallocInfo",
                                                        eventHeapColumns_) :
                       nullptr}
   , moduleHeapTable_{includeMallocInfo_ ?
                        std::make_unique<memModuleHeap_t>(db_,
                                                          "ModuleMallocInfo",
                                                          moduleHeapColumns_) :
                        nullptr}
 {
   data_.resize(nSchedules);
 
   iReg.sPostEndJob.watch(this, &MemoryTracker::postEndJob);
 
   if (!fileName_.empty()) {
     iReg.sPreModuleConstruction.watch([this](auto const& md) {
       this->recordOtherData(md, "PreModuleConstruction");
     });
     iReg.sPostModuleConstruction.watch([this](auto const& md) {
       this->recordOtherData(md, "PostModuleConstruction");
     });
     iReg.sPreModuleBeginJob.watch(
       [this](auto const& md) { this->recordOtherData(md, "PreBeginJob"); });
     iReg.sPostModuleBeginJob.watch(
       [this](auto const& md) { this->recordOtherData(md, "PostBeginJob"); });
     iReg.sPreModuleBeginRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PreBeginRun"); });
     iReg.sPostModuleBeginRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PostBeginRun"); });
     iReg.sPreModuleBeginSubRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PreBeginSubRun"); });
     iReg.sPostModuleBeginSubRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PostBeginSubRun"); });
     iReg.sPreProcessPath.watch(this, &MemoryTracker::prePathProcessing);
     iReg.sPreProcessEvent.watch(
       [this](auto const& e) { this->recordEventData(e, "PreProcessEvent"); });
     iReg.sPostProcessEvent.watch(
       [this](auto const& e) { this->recordEventData(e, "PostProcessEvent"); });
     iReg.sPreModule.watch([this](auto const& md) {
       this->recordModuleData(md, "PreProcessModule");
     });
     iReg.sPostModule.watch([this](auto const& md) {
       this->recordModuleData(md, "PostProcessModule");
     });
     iReg.sPreWriteEvent.watch(
       [this](auto const& md) { this->recordModuleData(md, "PreWriteEvent"); });
     iReg.sPostWriteEvent.watch(
       [this](auto const& md) { this->recordModuleData(md, "PostWriteEvent"); });
     iReg.sPreModuleEndSubRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PreEndSubRun"); });
     iReg.sPreModuleEndRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PreEndRun"); });
     iReg.sPreModuleEndJob.watch(
       [this](auto const& md) { this->recordOtherData(md, "PreEndJob"); });
     iReg.sPostModuleEndSubRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PostEndSubRun"); });
     iReg.sPostModuleEndRun.watch(
       [this](auto const& md) { this->recordOtherData(md, "PostEndRun"); });
     iReg.sPostModuleEndJob.watch(
       [this](auto const& md) { this->recordOtherData(md, "PostEndJob"); });
   }
 }

Member Function Documentation

bool art::MemoryTracker::checkMallocConfig_	(	std::string const &	dbfilename,
		bool	include
	)

private

Definition at line 397 of file MemoryTrackerLinux_service.cc.

References art::errors::Configuration, and s.

Referenced by MemoryTracker().

 {
   if (include && dbfilename.empty()) {
     std::string const errmsg =
       "\n'includeMallocInfo : true' is valid only if a nonempty db filename is specified:\n\n"s +
       "   MemoryTracker: {\n"
       "      includeMallocInfo: true\n"
       "      dbOutput: {\n"
       "         filename: \"your_filename.db\"\n"
       "      }\n"
       "   }\n\n";
     throw Exception{errors::Configuration} << errmsg;
   }
   return include;
 }

void art::MemoryTracker::flushTables_ ( )

private

Definition at line 426 of file MemoryTrackerLinux_service.cc.

References eventHeapTable_, eventTable_, moduleHeapTable_, moduleTable_, otherInfoTable_, and peakUsageTable_.

Referenced by postEndJob().

 {
   otherInfoTable_.flush();
   eventTable_.flush();
   moduleTable_.flush();
   peakUsageTable_.flush();
   if (eventHeapTable_)
     eventHeapTable_->flush();
   if (moduleHeapTable_)
     moduleHeapTable_->flush();
 }

void art::MemoryTracker::postEndJob ( )

private

Definition at line 388 of file MemoryTrackerLinux_service.cc.

References flushTables_(), recordPeakUsages_(), and summary_().

Referenced by MemoryTracker().

 {
   recordPeakUsages_();
   flushTables_();
   summary_();
 }

void art::MemoryTracker::prePathProcessing ( std::string const & pathname )

private

Definition at line 290 of file MemoryTrackerLinux_service.cc.

References data_, art::ScheduleID::first(), and art::ScheduleID::id().

Referenced by MemoryTracker().

 {
   // MT-TODO: Placeholder until we're multi-threaded
   auto const sid = ScheduleID::first().id();
   data_[sid].pathName = pathname;
 }

void art::MemoryTracker::recordEventData	(	Event const &	e,
		std::string const &	step
	)

private

Definition at line 314 of file MemoryTrackerLinux_service.cc.

References d, data_, eventHeapTable_, eventTable_, art::ScheduleID::first(), art::ScheduleID::id(), art::Event::id(), includeMallocInfo_, and procInfo_.

Referenced by MemoryTracker().

 {
   // MT-TODO: Placeholder until we're multi-threaded
   auto const sid = ScheduleID::first().id();
   auto& d = data_[sid];
   d.eventID = e.id();
 
   auto const currentMemory = procInfo_.getCurrentData(sid);
 
   eventTable_.insert(step,
                      d.eventID.run(),
                      d.eventID.subRun(),
                      d.eventID.event(),
                      LinuxProcData::getValueInMB<vsize_t>(currentMemory),
                      LinuxProcData::getValueInMB<rss_t>(currentMemory));
 
   if (includeMallocInfo_) {
     auto minfo = LinuxMallInfo{}.get();
     eventHeapTable_->insert(step,
                             d.eventID.run(),
                             d.eventID.subRun(),
                             d.eventID.event(),
                             minfo.arena,
                             minfo.ordblks,
                             minfo.keepcost,
                             minfo.hblkhd,
                             minfo.hblks,
                             minfo.uordblks,
                             minfo.fordblks);
   }
 }

void art::MemoryTracker::recordModuleData	(	ModuleDescription const &	md,
		std::string const &	step
	)

private

Definition at line 348 of file MemoryTrackerLinux_service.cc.

References d, data_, art::ScheduleID::first(), art::ScheduleID::id(), includeMallocInfo_, moduleHeapTable_, art::ModuleDescription::moduleLabel(), art::ModuleDescription::moduleName(), moduleTable_, and procInfo_.

Referenced by MemoryTracker().

 {
   // MT-TODO: Placeholder until we're multi-threaded
   auto const sid = ScheduleID::first().id();
   auto& d = data_[sid];
 
   auto const currentMemory = procInfo_.getCurrentData(sid);
 
   moduleTable_.insert(step,
                       d.eventID.run(),
                       d.eventID.subRun(),
                       d.eventID.event(),
                       d.pathName,
                       md.moduleLabel(),
                       md.moduleName(),
                       LinuxProcData::getValueInMB<vsize_t>(currentMemory),
                       LinuxProcData::getValueInMB<rss_t>(currentMemory));
 
   if (includeMallocInfo_) {
     auto minfo = LinuxMallInfo{}.get();
     moduleHeapTable_->insert(step,
                              d.eventID.run(),
                              d.eventID.subRun(),
                              d.eventID.event(),
                              d.pathName,
                              md.moduleLabel(),
                              md.moduleName(),
                              minfo.arena,
                              minfo.ordblks,
                              minfo.keepcost,
                              minfo.hblkhd,
                              minfo.hblks,
                              minfo.uordblks,
                              minfo.fordblks);
   }
 }

void art::MemoryTracker::recordOtherData	(	ModuleDescription const &	md,
		std::string const &	step
	)

private

Definition at line 299 of file MemoryTrackerLinux_service.cc.

References art::ScheduleID::first(), art::ScheduleID::id(), art::ModuleDescription::moduleLabel(), art::ModuleDescription::moduleName(), otherInfoTable_, and procInfo_.

Referenced by MemoryTracker().

 {
   // MT-TODO: Placeholder until we're multi-threaded
   auto const sid = ScheduleID::first().id();
   auto const data = procInfo_.getCurrentData(sid);
   otherInfoTable_.insert(step,
                          md.moduleLabel(),
                          md.moduleName(),
                          LinuxProcData::getValueInMB<vsize_t>(data),
                          LinuxProcData::getValueInMB<rss_t>(data));
 }

void art::MemoryTracker::recordPeakUsages_ ( )

private

Definition at line 416 of file MemoryTrackerLinux_service.cc.

References peakUsageTable_, and procInfo_.

Referenced by postEndJob().

 {
   peakUsageTable_.insert(
     "VmPeak", procInfo_.getVmPeak(), "Peak virtual memory (MB)");
   peakUsageTable_.insert(
     "VmHWM", procInfo_.getVmHWM(), "Peak resident set size (MB)");
 }

void art::MemoryTracker::summary_ ( )

private

Definition at line 440 of file MemoryTrackerLinux_service.cc.

References db_, DECLARE_ART_SERVICE, DEFINE_ART_SERVICE, fileName_, art::left(), art::LEGACY, and peakUsageTable_.

Referenced by postEndJob().

 {
   using namespace cet::sqlite;
   using namespace std;
   query_result<double> rVMax;
   query_result<double> rRMax;
   rVMax
     << select("Value").from(db_, peakUsageTable_.name()).where("Name='VmPeak'");
   rRMax
     << select("Value").from(db_, peakUsageTable_.name()).where("Name='VmHWM'");
 
   mf::LogAbsolute log{"MemoryTracker"};
   HorizontalRule const rule{100};
   log << '\n' << rule('=') << '\n';
   log << std::left << "MemoryTracker summary (base-10 MB units used)\n\n";
   log << "  Peak virtual memory usage (VmPeak)  : " << unique_value(rVMax)
       << " MB\n"
       << "  Peak resident set size usage (VmHWM): " << unique_value(rRMax)
       << " MB\n";
   if (!(fileName_.empty() || fileName_ == ":memory:")) {
     log << "  Details saved in: '" << fileName_ << "'\n";
   }
   log << rule('=');
 }

Member Data Documentation

std::vector<PerScheduleData> art::MemoryTracker::data_

private

Definition at line 98 of file MemoryTrackerLinux_service.cc.

Referenced by MemoryTracker(), prePathProcessing(), recordEventData(), and recordModuleData().

cet::sqlite::Connection art::MemoryTracker::db_

private

Definition at line 90 of file MemoryTrackerLinux_service.cc.

Referenced by MemoryTracker(), and summary_().

name_array<6u> art::MemoryTracker::eventColumns_

private

Initial value:

{

{"Step", "Run", "SubRun", "Event", "Vsize", "RSS"}}

Definition at line 106 of file MemoryTrackerLinux_service.cc.

Referenced by MemoryTracker().

name_array<11u> art::MemoryTracker::eventHeapColumns_

private

Initial value:

{{"Step",
                                       "Run",
                                       "SubRun",
                                       "Event",
                                       "arena",
                                       "ordblks",
                                       "keepcost",
                                       "hblkhd",
                                       "hblks",
                                       "uordblks",
                                       "fordblks"}}

Definition at line 117 of file MemoryTrackerLinux_service.cc.

Referenced by MemoryTracker().

std::unique_ptr<memEventHeap_t> art::MemoryTracker::eventHeapTable_

private

Definition at line 187 of file MemoryTrackerLinux_service.cc.

Referenced by flushTables_(), MemoryTracker(), and recordEventData().

memEvent_t art::MemoryTracker::eventTable_

private

Definition at line 185 of file MemoryTrackerLinux_service.cc.

Referenced by flushTables_(), MemoryTracker(), and recordEventData().

std::string art::MemoryTracker::fileName_

private

Definition at line 87 of file MemoryTrackerLinux_service.cc.

Referenced by MemoryTracker(), and summary_().

bool art::MemoryTracker::includeMallocInfo_

private

Definition at line 92 of file MemoryTrackerLinux_service.cc.

Referenced by MemoryTracker(), recordEventData(), and recordModuleData().

name_array<9u> art::MemoryTracker::moduleColumns_

private

Initial value:

{{"Step",
                                   "Run",
                                   "SubRun",
                                   "Event",
                                   "Path",
                                   "ModuleLabel",
                                   "ModuleType",
                                   "Vsize",
                                   "RSS"}}

Definition at line 108 of file MemoryTrackerLinux_service.cc.

Referenced by MemoryTracker().

name_array<14u> art::MemoryTracker::moduleHeapColumns_

private

Initial value:

{{"Step",
                                        "Run",
                                        "SubRun",
                                        "Event",
                                        "Path",
                                        "ModuleLabel",
                                        "ModuleType",
                                        "arena",
                                        "ordblks",
                                        "keepcost",
                                        "hblkhd",
                                        "hblks",
                                        "uordblks",
                                        "fordblks"}}