Add Current (Instant) Socket Power

* Updates:
    - rocm_smi_logger:
      General cleanup &
      Aligned to cpplint rules for usage
    - rocm_smi_monitor:
      Fixed MonitorTypes
      from not displaying properly in logs
      & Added socket power label + current
      socket power MonitorTypes
    - rocm_smi API:
      Added rsmi_dev_current_socket_power_get API
    - rocm_smi CLI:
      General cleanup,
      Concise info now displays device data
      in variable width (see printLogSpacer's
      new field),
      printLogSpacer now as an adjustable
      variable that overrides appWidth,
      Added Socket Power to base rocm-smi +
      --showpower CLI calls,
      --showpower & base rocm-smi CLI defaults
      to printing socket power (if not available,
      displays average power)
    - Cleaned up temp label references
    - power_read gtests:
      Added current socket power to testing

Change-Id: Ica57e6f98ad96e2584e7c7955e188f68d2dab89d
Signed-off-by: Charis Poag <Charis.Poag@amd.com>


[ROCm/amdsmi commit: f078375350]

projects/amdsmi/src/rocm_smi.cc

@@ -77,7 +77,6 @@
 #include "rocm_smi/rocm_smi64Config.h"
 #include "rocm_smi/rocm_smi_logger.h"
 
-using namespace ROCmLogging;
 using namespace amd::smi;
 
 static const uint32_t kMaxOverdriveLevel = 20;
@@ -2386,21 +2385,22 @@ rsmi_dev_temp_metric_get(uint32_t dv_ind, uint32_t sensor_type,
   amd::smi::MonitorTypes mon_type = amd::smi::kMonInvalid;
   uint16_t val_ui16;
 
-  static const std::map<rsmi_temperature_metric_t, amd::smi::MonitorTypes> kMetricTypeMap = {
-    { RSMI_TEMP_CURRENT, amd::smi::kMonTemp },
-    { RSMI_TEMP_MAX, amd::smi::kMonTempMax },
-    { RSMI_TEMP_MIN, amd::smi::kMonTempMin },
-    { RSMI_TEMP_MAX_HYST, amd::smi::kMonTempMaxHyst },
-    { RSMI_TEMP_MIN_HYST, amd::smi::kMonTempMinHyst },
-    { RSMI_TEMP_CRITICAL, amd::smi::kMonTempCritical },
-    { RSMI_TEMP_CRITICAL_HYST, amd::smi::kMonTempCriticalHyst },
-    { RSMI_TEMP_EMERGENCY, amd::smi::kMonTempEmergency },
-    { RSMI_TEMP_EMERGENCY_HYST, amd::smi::kMonTempEmergencyHyst },
-    { RSMI_TEMP_CRIT_MIN, amd::smi::kMonTempCritMin },
-    { RSMI_TEMP_CRIT_MIN_HYST, amd::smi::kMonTempCritMinHyst },
-    { RSMI_TEMP_OFFSET, amd::smi::kMonTempOffset },
-    { RSMI_TEMP_LOWEST, amd::smi::kMonTempLowest },
-    { RSMI_TEMP_HIGHEST, amd::smi::kMonTempHighest },
+  static const std::map<rsmi_temperature_metric_t, amd::smi::MonitorTypes>
+    kMetricTypeMap = {
+      { RSMI_TEMP_CURRENT, amd::smi::kMonTemp },
+      { RSMI_TEMP_MAX, amd::smi::kMonTempMax },
+      { RSMI_TEMP_MIN, amd::smi::kMonTempMin },
+      { RSMI_TEMP_MAX_HYST, amd::smi::kMonTempMaxHyst },
+      { RSMI_TEMP_MIN_HYST, amd::smi::kMonTempMinHyst },
+      { RSMI_TEMP_CRITICAL, amd::smi::kMonTempCritical },
+      { RSMI_TEMP_CRITICAL_HYST, amd::smi::kMonTempCriticalHyst },
+      { RSMI_TEMP_EMERGENCY, amd::smi::kMonTempEmergency },
+      { RSMI_TEMP_EMERGENCY_HYST, amd::smi::kMonTempEmergencyHyst },
+      { RSMI_TEMP_CRIT_MIN, amd::smi::kMonTempCritMin },
+      { RSMI_TEMP_CRIT_MIN_HYST, amd::smi::kMonTempCritMinHyst },
+      { RSMI_TEMP_OFFSET, amd::smi::kMonTempOffset },
+      { RSMI_TEMP_LOWEST, amd::smi::kMonTempLowest },
+      { RSMI_TEMP_HIGHEST, amd::smi::kMonTempHighest },
   };
 
   const auto mon_type_it = kMetricTypeMap.find(metric);
@@ -2485,7 +2485,8 @@ rsmi_dev_temp_metric_get(uint32_t dv_ind, uint32_t sensor_type,
       return RSMI_STATUS_NOT_SUPPORTED;
     }
 
-    *temperature = static_cast<int64_t>(val_ui16) * CENTRIGRADE_TO_MILLI_CENTIGRADE;
+    *temperature =
+      static_cast<int64_t>(val_ui16) * CENTRIGRADE_TO_MILLI_CENTIGRADE;
 
     ss << __PRETTY_FUNCTION__ << " | ======= end ======= "
        << " | Success "
@@ -2815,6 +2816,80 @@ rsmi_dev_power_ave_get(uint32_t dv_ind, uint32_t sensor_ind, uint64_t *power) {
   CATCH
 }
 
+rsmi_status_t
+rsmi_dev_current_socket_power_get(uint32_t dv_ind, uint64_t *socket_power) {
+  TRY
+  std::ostringstream ss;
+  rsmi_status_t rsmiReturn = RSMI_STATUS_NOT_SUPPORTED;
+  std::string val_str;
+  uint32_t sensor_ind = 1;  // socket_power sysfs files have 1-based indices
+  MonitorTypes mon_type = amd::smi::kMonPowerInput;
+  ss << __PRETTY_FUNCTION__ << " | ======= start =======, dv_ind="
+     << std::to_string(dv_ind);
+  LOG_TRACE(ss);
+  if (socket_power == nullptr) {
+    rsmiReturn = RSMI_STATUS_INVALID_ARGS;
+    ss << __PRETTY_FUNCTION__
+       << " | ======= end ======= "
+       << " | Fail "
+       << " | Device #: " << dv_ind
+       << " | Type: " << monitorTypesToString.at(mon_type)
+       << " | Cause: socket_power was a null ptr reference"
+       << " | Returning = "
+       << getRSMIStatusString(rsmiReturn) << " |";
+    LOG_ERROR(ss);
+    return RSMI_STATUS_INVALID_ARGS;
+  }
+  CHK_SUPPORT_SUBVAR_ONLY(socket_power, sensor_ind)
+  DEVICE_MUTEX
+
+  if (dev->monitor() == nullptr) {
+    ss << __PRETTY_FUNCTION__
+       << " | ======= end ======= "
+       << " | Fail "
+       << " | Device #: " << dv_ind
+       << " | Type: " << monitorTypesToString.at(mon_type)
+       << " | Cause: hwmon monitor was a null ptr reference"
+       << " | Returning = "
+       << getRSMIStatusString(rsmiReturn) << " |";
+    LOG_ERROR(ss);
+    return rsmiReturn;
+  }
+
+  int ret = dev->monitor()->readMonitor(amd::smi::kMonPowerLabel,
+                                        sensor_ind, &val_str);
+  if (ret || val_str != "PPT" || val_str.size() != 3) {
+    if (ret != 0) {
+      rsmiReturn = amd::smi::ErrnoToRsmiStatus(ret);
+    }
+    ss << __PRETTY_FUNCTION__
+       << " | ======= end ======= "
+       << " | Fail "
+       << " | Device #: " << dv_ind
+       << " | Type: " << monitorTypesToString.at(mon_type)
+       << " | Cause: readMonitor() returned an error status"
+       << " or Socket Power label did not show PPT or size of label data was"
+       << " unexpected"
+       << " | Returning = "
+       << getRSMIStatusString(rsmiReturn) << " |";
+    LOG_ERROR(ss);
+    return rsmiReturn;
+  }
+  rsmiReturn = get_dev_mon_value(mon_type, dv_ind, sensor_ind,
+                                 socket_power);
+  ss << __PRETTY_FUNCTION__
+     << " | ======= end ======= "
+     << " | Success "
+     << " | Device #: " << dv_ind
+     << " | Type: " << monitorTypesToString.at(mon_type)
+     << " | Data: " << *socket_power
+     << " | Returning = "
+     << getRSMIStatusString(rsmiReturn) << " |";
+  LOG_TRACE(ss);
+  return rsmiReturn;
+  CATCH
+}
+
 rsmi_status_t
 rsmi_dev_energy_count_get(uint32_t dv_ind, uint64_t *power,
                           float *counter_resolution, uint64_t *timestamp) {

projects/amdsmi/src/rocm_smi_device.cc

@@ -68,8 +68,6 @@
 #include "rocm_smi/rocm_smi_logger.h"
 #include "shared_mutex.h"  // NOLINT
 
-using namespace ROCmLogging;
-
 namespace amd {
 namespace smi {
 

projects/amdsmi/src/rocm_smi_gpu_metrics.cc

@@ -61,7 +61,6 @@
 #include "rocm_smi/rocm_smi_exception.h"
 #include "rocm_smi/rocm_smi_logger.h"
 
-using namespace ROCmLogging;
 using namespace amd::smi;
 
 #define TRY try {

projects/amdsmi/src/rocm_smi_logger.cc

@@ -71,9 +71,8 @@
 #include "rocm_smi/rocm_smi_logger.h"
 #include "rocm_smi/rocm_smi_main.h"
 
-using namespace ROCmLogging;
 
-Logger* Logger::m_Instance = nullptr;
+ROCmLogging::Logger *ROCmLogging::Logger::m_Instance = nullptr;
 
 // Log file name
 // WARNING: File name should be changed here and
@@ -81,39 +80,39 @@ Logger* Logger::m_Instance = nullptr;
 // in one place will cause a mismatch in these scripts,
 // files may not have proper permissions, and logrotate
 // would not function properly.
-const std::string logPath = "/var/log/rocm_smi_lib/";
-const std::string logBaseFName = "ROCm-SMI-lib";
-const std::string logExtension = ".log";
-const std::string logFileName = logPath + logBaseFName + logExtension;
+#define LOGPATH "/var/log/rocm_smi_lib/"
+#define LOGBASE_FNAME "ROCm-SMI-lib"
+#define LOGEXTENSION ".log"
+const char *logFileName = LOGPATH LOGBASE_FNAME LOGEXTENSION;
 
-Logger::Logger() {
+ROCmLogging::Logger::Logger() {
   initialize_resources();
 }
 
-Logger::~Logger() {
+ROCmLogging::Logger::~Logger() {
   if (m_loggingIsOn) {
     destroy_resources();
   }
 }
 
-Logger* Logger::getInstance() throw() {
+ROCmLogging::Logger* ROCmLogging::Logger::getInstance() throw() {
   if (m_Instance == nullptr) {
-    m_Instance = new Logger();
+    m_Instance = new ROCmLogging::Logger();
   }
   return m_Instance;
 }
 
-void Logger::lock() {
+void ROCmLogging::Logger::lock() {
   m_Lock.lock();
 }
 
-void Logger::unlock() {
+void ROCmLogging::Logger::unlock() {
   m_Lock.unlock();
 }
 
-void Logger::logIntoFile(std::string& data) {
+void ROCmLogging::Logger::logIntoFile(std::string& data) {
   lock();
-  if(!m_File.is_open()) {
+  if (!m_File.is_open()) {
     initialize_resources();
     if (!m_File.is_open()) {
       std::cout << "WARNING: re-initializing resources was unsuccessful."
@@ -127,24 +126,24 @@ void Logger::logIntoFile(std::string& data) {
   unlock();
 }
 
-void Logger::logOnConsole(std::string& data) {
+void ROCmLogging::Logger::logOnConsole(std::string& data) {
   std::cout << getCurrentTime() << "  " << data << std::endl;
 }
 
 // Returns: In string format, YY-MM-DD HH:MM:SS.microseconds
-std::string Logger::getCurrentTime(void) {
-  using namespace std::chrono;
+std::string ROCmLogging::Logger::getCurrentTime(void) {
   std::string currentTime;
 
   // get current time
-  auto now = system_clock::now();
+  auto now = std::chrono::system_clock::now();
 
   // get number of milliseconds for the current second
   // (remainder after division into seconds)
-  auto ms = duration_cast<microseconds>(now.time_since_epoch()) % 1000000;
+  auto ms = std::chrono::duration_cast<std::chrono::microseconds>(
+    now.time_since_epoch()) % 1000000;
 
   // convert to std::time_t in order to convert to std::tm (broken time)
-  auto timer = system_clock::to_time_t(now);
+  auto timer = std::chrono::system_clock::to_time_t(now);
 
   // convert to broken time
   std::tm bt = *std::localtime(&timer);
@@ -159,7 +158,7 @@ std::string Logger::getCurrentTime(void) {
 }
 
 // Interface for Error Log
-void Logger::error(const char* text) throw() {
+void ROCmLogging::Logger::error(const char* text) throw() {
   // By default, logging is disabled
   // The check below allows us to toggle logging through RSMI_LOGGING
   // set or unset
@@ -182,18 +181,18 @@ void Logger::error(const char* text) throw() {
   }
 }
 
-void Logger::error(std::string& text) throw() {
+void ROCmLogging::Logger::error(std::string& text) throw() {
   error(text.data());
 }
 
-void Logger::error(std::ostringstream& stream) throw() {
+void ROCmLogging::Logger::error(std::ostringstream& stream) throw() {
   std::string text = stream.str();
   error(text.data());
   stream.str("");
 }
 
 // Interface for Alarm Log
-void Logger::alarm(const char* text) throw() {
+void ROCmLogging::Logger::alarm(const char* text) throw() {
   // By default, logging is disabled (ie. no RSMI_LOGGING)
   // The check below allows us to toggle logging through RSMI_LOGGING
   // set or unset
@@ -216,18 +215,18 @@ void Logger::alarm(const char* text) throw() {
   }
 }
 
-void Logger::alarm(std::string& text) throw() {
+void ROCmLogging::Logger::alarm(std::string& text) throw() {
   alarm(text.data());
 }
 
-void Logger::alarm(std::ostringstream& stream) throw() {
+void ROCmLogging::Logger::alarm(std::ostringstream& stream) throw() {
   std::string text = stream.str();
   alarm(text.data());
   stream.str("");
 }
 
 // Interface for Always Log
-void Logger::always(const char* text) throw() {
+void ROCmLogging::Logger::always(const char* text) throw() {
   // By default, logging is disabled (ie. no RSMI_LOGGING)
   // The check below allows us to toggle logging through RSMI_LOGGING
   // set or unset
@@ -250,18 +249,18 @@ void Logger::always(const char* text) throw() {
   }
 }
 
-void Logger::always(std::string& text) throw() {
+void ROCmLogging::Logger::always(std::string& text) throw() {
   always(text.data());
 }
 
-void Logger::always(std::ostringstream& stream) throw() {
+void ROCmLogging::Logger::always(std::ostringstream& stream) throw() {
   std::string text = stream.str();
   always(text.data());
   stream.str("");
 }
 
 // Interface for Buffer Log
-void Logger::buffer(const char* text) throw() {
+void ROCmLogging::Logger::buffer(const char* text) throw() {
   // Buffer is the special case. So don't add log level
   // and timestamp in the buffer message. Just log the raw bytes.
   if ((m_LogType == FILE_LOG) && (m_LogLevel >= LOG_LEVEL_BUFFER)) {
@@ -284,18 +283,18 @@ void Logger::buffer(const char* text) throw() {
   }
 }
 
-void Logger::buffer(std::string& text) throw() {
+void ROCmLogging::Logger::buffer(std::string& text) throw() {
   buffer(text.data());
 }
 
-void Logger::buffer(std::ostringstream& stream) throw() {
+void ROCmLogging::Logger::buffer(std::ostringstream& stream) throw() {
   std::string text = stream.str();
   buffer(text.data());
   stream.str("");
 }
 
 // Interface for Info Log
-void Logger::info(const char* text) throw() {
+void ROCmLogging::Logger::info(const char* text) throw() {
   // By default, logging is disabled (ie. no RSMI_LOGGING)
   // The check below allows us to toggle logging through RSMI_LOGGING
   // set or unset
@@ -318,18 +317,18 @@ void Logger::info(const char* text) throw() {
   }
 }
 
-void Logger::info(std::string& text) throw() {
+void ROCmLogging::Logger::info(std::string& text) throw() {
   info(text.data());
 }
 
-void Logger::info(std::ostringstream& stream) throw() {
+void ROCmLogging::Logger::info(std::ostringstream& stream) throw() {
   std::string text = stream.str();
   info(text.data());
   stream.str("");
 }
 
 // Interface for Trace Log
-void Logger::trace(const char* text) throw() {
+void ROCmLogging::Logger::trace(const char* text) throw() {
   // By default, logging is disabled (ie. no RSMI_LOGGING)
   // The check below allows us to toggle logging through RSMI_LOGGING
   // set or unset
@@ -352,18 +351,18 @@ void Logger::trace(const char* text) throw() {
   }
 }
 
-void Logger::trace(std::string& text) throw() {
+void ROCmLogging::Logger::trace(std::string& text) throw() {
   trace(text.data());
 }
 
-void Logger::trace(std::ostringstream& stream) throw() {
+void ROCmLogging::Logger::trace(std::ostringstream& stream) throw() {
   std::string text = stream.str();
   trace(text.data());
   stream.str("");
 }
 
 // Interface for Debug Log
-void Logger::debug(const char* text) throw() {
+void ROCmLogging::Logger::debug(const char* text) throw() {
   // By default, logging is disabled (ie. no RSMI_LOGGING)
   // The check below allows us to toggle logging through RSMI_LOGGING
   // set or unset
@@ -386,51 +385,53 @@ void Logger::debug(const char* text) throw() {
   }
 }
 
-void Logger::debug(std::string& text) throw() {
+void ROCmLogging::Logger::debug(std::string& text) throw() {
   debug(text.data());
 }
 
-void Logger::debug(std::ostringstream& stream) throw() {
+void ROCmLogging::Logger::debug(std::ostringstream& stream) throw() {
   std::string text = stream.str();
   debug(text.data());
   stream.str("");
 }
 
 // Interfaces to control log levels
-void Logger::updateLogLevel(LogLevel logLevel) {
+void ROCmLogging::Logger::updateLogLevel(LogLevel logLevel) {
   m_LogLevel = logLevel;
 }
 
-void Logger::enableAllLogLevels() {
+void ROCmLogging::Logger::enableAllLogLevels() {
   m_LogLevel = ENABLE_LOG;
 }
 
 // Disable all log levels, except error and alarm
-void Logger::disableLog() {
+void ROCmLogging::Logger::disableLog() {
   m_LogLevel = DISABLE_LOG;
 }
 
 // Interfaces to control log Types
-void Logger::updateLogType(LogType logType) {
+void ROCmLogging::Logger::updateLogType(LogType logType) {
   m_LogType = logType;
 }
 
-void Logger::enableConsoleLogging() {
+void ROCmLogging::Logger::enableConsoleLogging() {
   m_LogType = CONSOLE;
 }
 
-void Logger::enableFileLogging() {
+void ROCmLogging::Logger::enableFileLogging() {
   m_LogType = FILE_LOG;
 }
 
 // Returns a string of details on current log settings
-std::string Logger::getLogSettings() {
+std::string ROCmLogging::Logger::getLogSettings() {
   std::string logSettings;
 
   if (m_File.is_open()) {
-    logSettings += "OpenStatus = File (" + logFileName + ") is open";
+    logSettings += "OpenStatus = File (" + std::string(logFileName)
+                   + ") is open";
   } else {
-    logSettings += "OpenStatus = File (" + logFileName + ") is not open";
+    logSettings += "OpenStatus = File (" + std::string(logFileName)
+                   + ") is not open";
   }
   logSettings += ", ";
 
@@ -480,11 +481,11 @@ std::string Logger::getLogSettings() {
 
 // Returns current reported enabled logging state. State is controlled by
 // user's environment variable RSMI_LOGGING.
-bool Logger::isLoggerEnabled() {
+bool ROCmLogging::Logger::isLoggerEnabled() {
   return m_loggingIsOn;
 }
 
-void Logger::initialize_resources() {
+void ROCmLogging::Logger::initialize_resources() {
   // By default, logging is disabled (ie. no RSMI_LOGGING)
   // The check below allows us to toggle logging through RSMI_LOGGING
   // set or unset
@@ -492,7 +493,7 @@ void Logger::initialize_resources() {
   if (!m_loggingIsOn) {
     return;
   }
-  m_File.open(logFileName.c_str(), std::ios::out | std::ios::app);
+  m_File.open(logFileName, std::ios::out | std::ios::app);
   m_LogLevel = LOG_LEVEL_TRACE;
   // RSMI_LOGGING = 1, output to logs only
   // RSMI_LOGGING = 2, output to console only
@@ -521,9 +522,9 @@ void Logger::initialize_resources() {
   if (m_File.fail()) {
     std::cout << "WARNING: Failed opening log file." << std::endl;
   }
-  chmod(logFileName.c_str(), S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH);
+  chmod(logFileName, S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH);
 }
 
-void Logger::destroy_resources() {
+void ROCmLogging::Logger::destroy_resources() {
   m_File.close();
 }

projects/amdsmi/src/rocm_smi_main.cc

@@ -68,7 +68,6 @@
 #include "rocm_smi/rocm_smi_kfd.h"
 #include "rocm_smi/rocm_smi_logger.h"
 
-using namespace ROCmLogging;
 
 static const char *kPathDRMRoot = "/sys/class/drm";
 static const char *kPathHWMonRoot = "/sys/class/hwmon";
@@ -314,12 +313,12 @@ RocmSMI::Initialize(uint64_t flags) {
   int i_ret;
 
   LOG_ALWAYS("=============== ROCM SMI initialize ================");
-  Logger::getInstance()->enableAllLogLevels();
+  ROCmLogging::Logger::getInstance()->enableAllLogLevels();
   // Leaving below to allow developers to check current log settings
   // std::string logSettings = Logger::getInstance()->getLogSettings();
   // std::cout << "Current log settings:\n" << logSettings << std::endl;
 
-  if (Logger::getInstance()->isLoggerEnabled()) {
+  if (ROCmLogging::Logger::getInstance()->isLoggerEnabled()) {
     logSystemDetails();
   }
 

projects/amdsmi/src/rocm_smi_monitor.cc

@@ -3,7 +3,7 @@
  * The University of Illinois/NCSA
  * Open Source License (NCSA)
  *
- * Copyright (c) 2017, Advanced Micro Devices, Inc.
+ * Copyright (c) 2017-2023, Advanced Micro Devices, Inc.
  * All rights reserved.
  *
  * Developed by:
@@ -58,8 +58,6 @@
 #include "rocm_smi/rocm_smi_exception.h"
 #include "rocm_smi/rocm_smi_logger.h"
 
-using namespace ROCmLogging;
-
 namespace amd {
 namespace smi {
 
@@ -80,6 +78,8 @@ static const char *kMonPowerCapName = "power#_cap";
 static const char *kMonPowerCapMaxName = "power#_cap_max";
 static const char *kMonPowerCapMinName = "power#_cap_min";
 static const char *kMonPowerAveName = "power#_average";
+static const char *kMonPowerInputName = "power#_input";
+static const char *kMonPowerLabelName = "power#_label";
 static const char *kMonTempMaxName = "temp#_max";
 static const char *kMonTempMinName = "temp#_min";
 static const char *kMonTempMaxHystName = "temp#_max_hyst";
@@ -135,6 +135,8 @@ static const std::map<MonitorTypes, const char *> kMonitorNameMap = {
     {kMonPowerCapMax, kMonPowerCapMaxName},
     {kMonPowerCapMin, kMonPowerCapMinName},
     {kMonPowerAve, kMonPowerAveName},
+    {kMonPowerInput, kMonPowerInputName},
+    {kMonPowerLabel, kMonPowerLabelName},
     {kMonTempMax, kMonTempMaxName},
     {kMonTempMin, kMonTempMinName},
     {kMonTempMaxHyst, kMonTempMaxHystName},
@@ -202,7 +204,8 @@ static const std::map<const char *, monitor_depends_t> kMonFuncDependsMap = {
                                       .variants = {kMonInvalid},
                                     }
   },
-  {"rsmi_dev_power_cap_default_get",        { .mandatory_depends = {kMonPowerCapDefaultName},
+  {"rsmi_dev_power_cap_default_get", { .mandatory_depends =
+                                      {kMonPowerCapDefaultName},
                                       .variants = {kMonInvalid},
                                     }
   },
@@ -613,7 +616,7 @@ void Monitor::fillSupportedFuncs(SupportedFuncMap *supported_funcs) {
         supported_monitors = intersect;
       }
       if (!supported_monitors.empty()) {
-        for (unsigned long & supported_monitor : supported_monitors) {
+        for (uint64_t &supported_monitor : supported_monitors) {
           if (m_type == eDefaultMonitor) {
             assert(supported_monitor > 0);
             supported_monitor |=

projects/amdsmi/src/rocm_smi_utils.cc

@@ -73,7 +73,6 @@
 #include "rocm_smi/rocm_smi_device.h"
 #include "rocm_smi/rocm_smi_logger.h"
 
-using namespace ROCmLogging;
 
 namespace amd {
 namespace smi {