edm::service::CPU Class Reference

Inheritance diagram for edm::service::CPU:

Public Member Functions
	CPU (ParameterSet const &, ActivityRegistry &)
	~CPU () override=default
Public Member Functions inherited from edm::CPUServiceBase
	CPUServiceBase ()
	CPUServiceBase (const CPUServiceBase &)=delete
const CPUServiceBase &	operator= (const CPUServiceBase &)=delete
virtual	~CPUServiceBase ()

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

Private Member Functions
std::string	formatModels (const std::vector< std::string > &models) const
double	getAverageSpeed (const CPUInfoType &info) const
std::string	getModelFromCPUFeatures () const
std::vector< std::string >	getModels (const CPUInfoType &info) const
bool	parseCPUInfo (CPUInfoType &info) const
void	postEndJob ()

Private Attributes
const bool	disableJobReportOutput_
const bool	reportCPUProperties_

Detailed Description

Definition at line 52 of file CPU.cc.

Constructor & Destructor Documentation

CPU()

edm::service::CPU::CPU	(	ParameterSet const &	iPS,
		ActivityRegistry &	iRegistry
	)

Definition at line 124 of file CPU.cc.

References formatModels(), getAverageSpeed(), getModels(), info(), edm::Service< T >::isAvailable(), parseCPUInfo(), postEndJob(), edm::ResourceInformation::setCpuAverageSpeed(), edm::ResourceInformation::setCPUModels(), edm::ResourceInformation::setCpuModelsFormatted(), and edm::ActivityRegistry::watchPostEndJob().

        : reportCPUProperties_(iPS.getUntrackedParameter<bool>("reportCPUProperties")),
          disableJobReportOutput_(iPS.getUntrackedParameter<bool>("disableJobReportOutput")) {
      edm::Service<edm::ResourceInformation> resourceInformationService;
      if (resourceInformationService.isAvailable()) {
        CPUInfoType info;
        if (parseCPUInfo(info)) {
          const auto models{getModels(info)};
          resourceInformationService->setCPUModels(models);
          resourceInformationService->setCpuModelsFormatted(formatModels(models));
          resourceInformationService->setCpuAverageSpeed(getAverageSpeed(info));
        }
      }
      iRegistry.watchPostEndJob(this, &CPU::postEndJob);
    }

~CPU()

edm::service::CPU::~CPU ( )

overridedefault

Member Function Documentation

fillDescriptions()

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

static

Definition at line 140 of file CPU.cc.

References edm::ConfigurationDescriptions::add(), and submitPVResolutionJobs::desc.

                                                                         {
      edm::ParameterSetDescription desc;
      desc.addUntracked<bool>("reportCPUProperties", false);
      desc.addUntracked<bool>("disableJobReportOutput", false);
      descriptions.add("CPU", desc);
    }

formatModels()

std::string edm::service::CPU::formatModels ( const std::vector< std::string > &  models ) const

private

Definition at line 276 of file CPU.cc.

References ReggeGribovPartonMC_EposLHC_2760GeV_PbPb_cfi::model, and contentValuesCheck::ss.

Referenced by CPU(), and postEndJob().

                                                                        {
      std::stringstream ss;
      int model = 0;
      for (const auto &modelname : models) {
        if (model++ != 0) {
          ss << ", ";
        }
        ss << modelname;
      }
      return ss.str();
    }

getAverageSpeed()

double edm::service::CPU::getAverageSpeed ( const CPUInfoType &  info ) const

private

Definition at line 288 of file CPU.cc.

References MillePedeFileConverter_cfg::e, mps_splice::entry, and info().

Referenced by CPU(), and postEndJob().

                                                             {
      double averageCoreSpeed = 0.0;
      unsigned coreCount = 0;
      for (const auto &entry : info) {
        if (entry.first == "cpu MHz") {
          try {
            averageCoreSpeed += std::stod(entry.second);
          } catch (const std::logic_error &e) {
            LogWarning("CPU::getAverageSpeed") << "stod(" << entry.second << ") conversion error: " << e.what();
          }
          coreCount++;
        }
      }
      if (!coreCount) {
        return 0;
      }
      return averageCoreSpeed / static_cast<double>(coreCount);
    }

getModelFromCPUFeatures()

std::string edm::service::CPU::getModelFromCPUFeatures ( ) const

private

Definition at line 240 of file CPU.cc.

References dqm-mbProfile::format, info(), ReggeGribovPartonMC_EposLHC_2760GeV_PbPb_cfi::model, AlCaHLTBitMon_QueryRunRegistry::string, and makeListRunsInFiles::strings.

Referenced by getModels().

                                                 {
      using namespace cpu_features;

      std::string model;
#if defined(CPU_FEATURES_ARCH_X86)
      const auto info{GetX86Info()};
      model = info.brand_string;
#elif defined(CPU_FEATURES_ARCH_ARM)
      const auto info{GetArmInfo()};
      model = fmt::format("ARM {} {} {}", info.implementer, info.architecture, info.variant);
#elif defined(CPU_FEATURES_ARCH_AARCH64)
      const auto info{GetAarch64Info()};
      model = fmt::format("aarch64 {} {}", info.implementer, info.variant);
#elif defined(CPU_FEATURES_ARCH_PPC)
      const auto strings{GetPPCPlatformStrings()};
      model = strings.machine;
#endif
      return model;
    }

getModels()

std::vector< std::string > edm::service::CPU::getModels ( const CPUInfoType &  info ) const

private

Definition at line 260 of file CPU.cc.

References mps_splice::entry, getModelFromCPUFeatures(), and info().

Referenced by CPU(), and postEndJob().

                                                                     {
      std::set<std::string> modelSet;
      for (const auto &entry : info) {
        if (entry.first == "model name") {
          modelSet.insert(entry.second);
        }
      }
      std::vector<std::string> modelsVector(modelSet.begin(), modelSet.end());
      // If "model name" isn't present in /proc/cpuinfo, see what we can get
      // from cpu_features
      if (modelsVector.empty()) {
        modelsVector.emplace_back(getModelFromCPUFeatures());
      }
      return modelsVector;
    }

parseCPUInfo()

bool edm::service::CPU::parseCPUInfo ( CPUInfoType &  info ) const

private

Definition at line 195 of file CPU.cc.

References visDQMUpload::buf, info(), AlCaHLTBitMon_QueryRunRegistry::string, protons_cff::time, unpackBuffers-CaloStage2::token, trim(), and relativeConstraints::value.

Referenced by CPU(), and postEndJob().

                                                  {
      info.clear();
      std::ifstream fcpuinfo("/proc/cpuinfo");
      if (!fcpuinfo.is_open()) {
        return false;
      }
      while (!fcpuinfo.eof()) {
        std::string buf;
        std::getline(fcpuinfo, buf);

        std::istringstream iss(buf);
        std::string token;
        std::string property;
        std::string value;

        int time = 1;

        while (std::getline(iss, token, ':')) {
          switch (time) {
            case 1:
              property = token;
              break;
            case 2:
              value = token;
              break;
            default:
              value += token;
              break;
          }
          time++;
        }
        trim(property);
        trim(value);
        if (property.empty()) {
          continue;
        }

        if (property == "model name") {
          compressWhitespace(value);
        }
        info.emplace_back(property, value);
      }
      return true;
    }

postEndJob()

void edm::service::CPU::postEndJob ( )

private

Definition at line 147 of file CPU.cc.

References disableJobReportOutput_, mps_splice::entry, formatModels(), getAverageSpeed(), getModels(), info(), parseCPUInfo(), reportCPUProperties_, AlCaHLTBitMon_QueryRunRegistry::string, and cond::impl::to_string().

Referenced by CPU().

                         {
      if (disableJobReportOutput_) {
        return;
      }

      Service<JobReport> reportSvc;

      CPUInfoType info;
      if (!parseCPUInfo(info)) {
        return;
      }

      const auto models{formatModels(getModels(info))};
      unsigned totalNumberCPUs = 0;
      std::map<std::string, std::string> currentCoreProperties;
      std::string currentCore;

      for (const auto &entry : info) {
        if (entry.first == "processor") {
          if (reportCPUProperties_) {
            if (currentCore.empty()) {  // first core
              currentCore = entry.second;
            } else {
              reportSvc->reportPerformanceForModule("SystemCPU", "CPU-" + currentCore, currentCoreProperties);
              currentCoreProperties.clear();
              currentCore = entry.second;
            }
          }
          totalNumberCPUs++;
        } else if (reportCPUProperties_) {
          currentCoreProperties.insert(entry);
        }
      }
      if (!currentCore.empty() && reportCPUProperties_) {
        reportSvc->reportPerformanceForModule("SystemCPU", "CPU-" + currentCore, currentCoreProperties);
      }

      std::map<std::string, std::string> reportCPUProperties{
          {"totalCPUs", std::to_string(totalNumberCPUs)},
          {"averageCoreSpeed", std::to_string(getAverageSpeed(info))},
          {"CPUModels", models}};
      unsigned set_size = -1;
      if (getCpuSetSize(set_size)) {
        reportCPUProperties.insert(std::make_pair("cpusetCount", std::to_string(set_size)));
      }
      reportSvc->reportPerformanceSummary("SystemCPU", reportCPUProperties);
    }

Member Data Documentation

disableJobReportOutput_

const bool edm::service::CPU::disableJobReportOutput_

private

Definition at line 61 of file CPU.cc.

Referenced by postEndJob().

reportCPUProperties_

const bool edm::service::CPU::reportCPUProperties_

private

Definition at line 60 of file CPU.cc.

Referenced by postEndJob().