Rename Monitor to PmMeasurement to avoid conflicts in AliceO2 (#301)

CMakeLists.txt

@@ -31,7 +31,7 @@ endif()
 
 # Define project
 project(Monitoring
-  VERSION 3.13.0
+  VERSION 3.13.1
   DESCRIPTION "O2 Monitoring library"
   LANGUAGES CXX
 )

README.md

@@ -154,25 +154,25 @@ See how it works in the example: [examples/4-RateDerivedMetric.cxx](examples/4-R
 This feature provides basic performance status of the process. Note that is runs in separate thread.
 
 ```cpp
-enableProcessMonitoring([interval in seconds, {Measurement list}]);
+enableProcessMonitoring([interval in seconds, {PmMeasurement list}]);
 ```
 List of valid measurement lists:
-- `Monitor::Cpu`
-- `Monitor::Mem`
-- `Monitor::Smaps` - Beware. Enabling this will trigger kernel to run `smaps_account` periodically.
+- `PmMeasurement::Cpu`
+- `PmMeasurement::Mem`
+- `PmMeasurement::Smaps` - Beware. Enabling this will trigger kernel to run `smaps_account` periodically.
 
 Following metrics are generated every time interval:
-`Monitor::Cpu`:
+`PmMeasurement::Cpu`:
  + **cpuUsedPercentage** - percentage of a core usage (kernel + user mode) over time interval
  + **involuntaryContextSwitches** - involuntary context switches over time interval
  + **cpuUsedAbsolute** - amount of time spent on process execution (in user and kernel mode) over time interval (expressed in microseconds)
 
-`Monitor::Mem`: (Linux only)
+`PmMeasurement::Mem`: (Linux only)
  + **memoryUsagePercentage** - ratio of the process's virtual memory to memory available on the machine
  + **virtualMemorySize** - virtual memory reserved by process (expressed in kB)
  + **residentSetSize** - resident set size reserved by process (expressed in kB)
 
-`Monitor::Smaps`: (Linux only)
+`PmMeasurement::Smaps`: (Linux only)
 + **proportionalSetSize** - count of pages it has in memory, where each page is divided by the number of processes sharing it
 + **memoryPrivateClean** - unmodified private pages
 + **memoryPrivateDirty** - modified private pages

examples/5-Benchmark.cxx

@@ -67,7 +67,7 @@ int main(int argc, char* argv[])
 
   auto monitoring = MonitoringFactory::Get(vm["url"].as<std::string>());
   if (vm["monitor"].as<bool>()) {
-    monitoring->enableProcessMonitoring(1, {Monitor::Cpu, Monitor::Mem, Monitor::Smaps});
+    monitoring->enableProcessMonitoring(1, {PmMeasurement::Cpu, PmMeasurement::Mem, PmMeasurement::Smaps});
   }
   if (vm["multiple"].as<bool>()) {
     for (int j = 1; j <= count; j++) {

include/Monitoring/Monitoring.h

@@ -70,8 +70,8 @@ class Monitoring
 
   /// Enables process monitoring
   /// \param interval		refresh interval
-  /// \param enabledMeasurements vector of monitor measurements, eg. Monitor::Cpu
-  void enableProcessMonitoring(const unsigned int interval = 5, std::vector<Monitor> enabledMeasurements = {Monitor::Cpu, Monitor::Mem});
+  /// \param enabledMeasurements vector of monitor measurements, eg. PmMeasurement::Cpu
+  void enableProcessMonitoring(const unsigned int interval = 5, std::vector<PmMeasurement> enabledMeasurements = {PmMeasurement::Cpu, PmMeasurement::Mem});
 
   /// Flushes metric buffer (this can also happen when buffer is full)
   void flushBuffer();

include/Monitoring/ProcessMonitor.h

@@ -31,7 +31,7 @@ namespace o2
 namespace monitoring
 {
 
-enum class Monitor : short {
+enum class PmMeasurement : short {
   Cpu,
   Mem,
   Smaps
@@ -74,7 +74,7 @@ class ProcessMonitor
   void init();
 
   /// Enable given measurement
-  void enable(Monitor measurement);
+  void enable(PmMeasurement measurement);
 
  private:
   /// States which measurements are enabled

src/Monitoring.cxx

@@ -82,7 +82,7 @@ void Monitoring::flushBuffer(const short index)
   mStorage[index].clear();
 }
 
-void Monitoring::enableProcessMonitoring(const unsigned int interval, std::vector<Monitor> enabledMeasurements)
+void Monitoring::enableProcessMonitoring(const unsigned int interval, std::vector<PmMeasurement> enabledMeasurements)
 {
   mProcessMonitoringInterval = interval;
   for (const auto& measurement : enabledMeasurements) {

src/ProcessMonitor.cxx

@@ -53,7 +53,7 @@ void ProcessMonitor::init()
   getrusage(RUSAGE_SELF, &mPreviousGetrUsage);
 }
 
-void ProcessMonitor::enable(Monitor measurement)
+void ProcessMonitor::enable(PmMeasurement measurement)
 {
   mEnabledMeasurements[static_cast<short>(measurement)] = true;
 }
@@ -161,16 +161,16 @@ std::vector<Metric> ProcessMonitor::getPerformanceMetrics()
 {
   std::vector<Metric> metrics;
   metrics.reserve(12);
-  if (mEnabledMeasurements.at(static_cast<short>(Monitor::Cpu))) {
+  if (mEnabledMeasurements.at(static_cast<short>(PmMeasurement::Cpu))) {
     auto cpuMetrics = getCpuAndContexts();
     std::move(cpuMetrics.begin(), cpuMetrics.end(), std::back_inserter(metrics));
   }
 #ifdef O2_MONITORING_OS_LINUX
-  if (mEnabledMeasurements.at(static_cast<short>(Monitor::Mem))) {
+  if (mEnabledMeasurements.at(static_cast<short>(PmMeasurement::Mem))) {
     auto memoryMetrics = getMemoryUsage();
     std::move(memoryMetrics.begin(), memoryMetrics.end(), std::back_inserter(metrics));
   }
-  if (mEnabledMeasurements.at(static_cast<short>(Monitor::Smaps))) {
+  if (mEnabledMeasurements.at(static_cast<short>(PmMeasurement::Smaps))) {
     auto smapMetrics = getSmaps();
     std::move(smapMetrics.begin(), smapMetrics.end(), std::back_inserter(metrics));
   }
@@ -182,7 +182,7 @@ std::vector<Metric> ProcessMonitor::makeLastMeasurementAndGetMetrics()
 {
   std::vector<Metric> metrics;
 #ifdef O2_MONITORING_OS_LINUX
-  if (mEnabledMeasurements.at(static_cast<short>(Monitor::Mem))) {
+  if (mEnabledMeasurements.at(static_cast<short>(PmMeasurement::Mem))) {
     getMemoryUsage();
 
     auto avgVmRSS = std::accumulate(mVmRssMeasurements.begin(), mVmRssMeasurements.end(), 0.0) /
@@ -195,7 +195,7 @@ std::vector<Metric> ProcessMonitor::makeLastMeasurementAndGetMetrics()
     metrics.emplace_back(avgVmSize, metricsNames[AVG_VIRTUAL_MEMORY_SIZE]);
   }
 #endif
-  if (mEnabledMeasurements.at(static_cast<short>(Monitor::Cpu))) {
+  if (mEnabledMeasurements.at(static_cast<short>(PmMeasurement::Cpu))) {
     getCpuAndContexts();
 
     auto avgCpuUsage = std::accumulate(mCpuPerctange.begin(), mCpuPerctange.end(), 0.0) /

test/testProcessMonitor.cxx

@@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE(monitorProcessCpuOnly)
                                       "averageCpuUsedPercentage", "cpuTimeConsumedByProcess"};
   {
     auto monitoring = o2::monitoring::MonitoringFactory::Get("influxdb-stdout://");
-    monitoring->enableProcessMonitoring(1, {Monitor::Cpu});
+    monitoring->enableProcessMonitoring(1, {PmMeasurement::Cpu});
     enableRedirect();
     std::this_thread::sleep_for(std::chrono::milliseconds(200));
   }
@@ -89,7 +89,7 @@ BOOST_AUTO_TEST_CASE(monitorProcessAll)
                                        "cpuTimeConsumedByProcess", "proportionalSetSize", "memoryPrivateClean", "memoryPrivateDirty"};
   {
     auto monitoring = o2::monitoring::MonitoringFactory::Get("influxdb-stdout://");
-    monitoring->enableProcessMonitoring(1, {Monitor::Cpu, Monitor::Smaps, Monitor::Mem});
+    monitoring->enableProcessMonitoring(1, {PmMeasurement::Cpu, PmMeasurement::Smaps, PmMeasurement::Mem});
     enableRedirect();
     std::this_thread::sleep_for(std::chrono::milliseconds(200));
   }