edm::service::CPU Class Reference

Inheritance diagram for edm::service::CPU:

Public Member Functions
	CPU (ParameterSet const &, ActivityRegistry &)
bool	cpuInfo (std::string &models, double &avgSpeed) override
	CPU information - the models present and average speed. More...
	~CPU () override
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
bool	cpuInfoImpl (std::string &models, double &avgSpeed, Service< JobReport > *reportSvc)
double	getAverageSpeed (const std::vector< std::pair< std::string, std::string >> &info)
std::string	getModelFromCPUFeatures ()
std::string	getModels (const std::vector< std::pair< std::string, std::string >> &info)
bool	parseCPUInfo (std::vector< std::pair< std::string, std::string >> &info)
void	postEndJob ()

Private Attributes
const bool	reportCPUProperties_

Detailed Description

Definition at line 49 of file CPU.cc.

Constructor & Destructor Documentation

CPU()

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

Definition at line 152 of file CPU.cc.

References postEndJob(), and edm::ActivityRegistry::watchPostEndJob().

        : reportCPUProperties_(iPS.getUntrackedParameter<bool>("reportCPUProperties")) {
      iRegistry.watchPostEndJob(this, &CPU::postEndJob);
    }

~CPU()

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

override

Definition at line 157 of file CPU.cc.

{}

Member Function Documentation

cpuInfo()

bool edm::service::CPU::cpuInfo ( std::string &  models, double &  avgSpeed  )

overridevirtual

CPU information - the models present and average speed.

Implements edm::CPUServiceBase.

Definition at line 208 of file CPU.cc.

References getAverageSpeed(), getModels(), info(), and parseCPUInfo().

                                                         {
      std::vector<std::pair<std::string, std::string>> info;
      if (!parseCPUInfo(info)) {
        return false;
      }

      models = getModels(info);
      avgSpeed = getAverageSpeed(info);
      return true;
    }

cpuInfoImpl()

bool edm::service::CPU::cpuInfoImpl ( std::string &  models, double &  avgSpeed, Service< JobReport > *  reportSvc  )

private

fillDescriptions()

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

static

Definition at line 159 of file CPU.cc.

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

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

getAverageSpeed()

double edm::service::CPU::getAverageSpeed ( const std::vector< std::pair< std::string, std::string >> &  info )

private

Definition at line 307 of file CPU.cc.

References mps_splice::entry, and info().

Referenced by cpuInfo(), and postEndJob().

                                                                                    {
      double averageCoreSpeed = 0.0;
      unsigned coreCount = 0;
      for (const auto &entry : info) {
        if (entry.first == "cpu MHz") {
          averageCoreSpeed += str2d(entry.second);
          coreCount++;
        }
      }
      if (!coreCount) {
        return 0;
      }
      return averageCoreSpeed / static_cast<double>(coreCount);
    }

getModelFromCPUFeatures()

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

private

Definition at line 264 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::string edm::service::CPU::getModels ( const std::vector< std::pair< std::string, std::string >> &  info )

private

Definition at line 284 of file CPU.cc.

References mps_splice::entry, getModelFromCPUFeatures(), info(), ReggeGribovPartonMC_EposLHC_2760GeV_PbPb_cfi::model, and contentValuesCheck::ss.

Referenced by cpuInfo(), and postEndJob().

                                                                                 {
      std::set<std::string> models;
      for (const auto &entry : info) {
        if (entry.first == "model name") {
          models.insert(entry.second);
        }
      }
      std::stringstream ss;
      int model = 0;
      for (const auto &modelname : models) {
        if (model++ != 0) {
          ss << ", ";
        }
        ss << modelname;
      }
      // If "model name" isn't present in /proc/cpuinfo, see what we can get
      // from cpu_features
      if (0 == model) {
        return getModelFromCPUFeatures();
      }
      return ss.str();
    }

parseCPUInfo()

bool edm::service::CPU::parseCPUInfo ( std::vector< std::pair< std::string, std::string >> &  info )

private

Definition at line 219 of file CPU.cc.

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

Referenced by cpuInfo(), 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") {
          value = eraseExtraSpaces(value);
        }
        info.emplace_back(property, value);
      }
      return true;
    }

postEndJob()

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

private

Definition at line 165 of file CPU.cc.

References edm::service::d2str(), mps_splice::entry, getAverageSpeed(), getModels(), edm::service::i2str(), info(), parseCPUInfo(), reportCPUProperties_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CPU().

                         {
      Service<JobReport> reportSvc;

      std::vector<std::pair<std::string, std::string>> info;
      if (!parseCPUInfo(info)) {
        return;
      }

      std::string models = getModels(info);
      double avgSpeed = getAverageSpeed(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", i2str(totalNumberCPUs)}, {"averageCoreSpeed", d2str(avgSpeed)}, {"CPUModels", models}};
      unsigned set_size = -1;
      if (getCpuSetSize(set_size)) {
        reportCPUProperties.insert(std::make_pair("cpusetCount", i2str(set_size)));
      }
      reportSvc->reportPerformanceSummary("SystemCPU", reportCPUProperties);
    }

Member Data Documentation

reportCPUProperties_

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

private

Definition at line 59 of file CPU.cc.

Referenced by postEndJob().