Update performance determinism api as per the modified sysfs interface.

Signed-off-by: Divya Shikre <DivyaUday.Shikre@amd.com>
Change-Id: Ib0ec5128819644a2ff6c916da9194a7fe1dad795


[ROCm/amdsmi commit: aaf2120117]

projects/amdsmi/include/rocm_smi/rocm_smi.h

@@ -2089,24 +2089,17 @@ rsmi_status_t rsmi_dev_perf_level_get(uint32_t dv_ind,
 /**
  *  @brief Enter performance determinism mode with provided device index.
  *
- *  @details Given a device index @p dv_ind and @p freq_bitmask, this function
+ *  @details Given a device index @p dv_ind and @p clkvalue this function
  *  will enable performance determinism mode, which enforces a GFXCLK frequency
- *  SoftMax limit per GPU set by the user. This prevents the GFXCLK FLL from
+ *  SoftMax limit per GPU set by the user. This prevents the GFXCLK PLL from
  *  stretching when running the same workload on different GPUS, making
  *  performance variation minimal. This call will result in the performance
  *  level ::rsmi_dev_perf_level_t of the device being
- *  ::RSMI_DEV_PERF_LEVEL_DETERMINISM. If a bit in @p freq_bitmask has a value
- *  of 1, then the frequency (as ordered in an ::rsmi_frequencies_t returned
- *  by rsmi_dev_gpu_clk_freq_get()) corresponding to that bit index will be
- *  allowed.
- *  ::rsmi_dev_perf_level_set() should be called with ::RSMI_DEV_PERF_LEVEL_AUTO
- *  to restore the performance level to the default value.
+ *  ::RSMI_DEV_PERF_LEVEL_DETERMINISM.
  *
  *  @param[in] dv_ind a device index
  *
- *  @param[in] freq_bitmask A bitmask indicating the indices of the
- *  frequencies that are to be enabled (1) and disabled (0). Only the lowest
- *  ::rsmi_frequencies_t.num_supported bits of this mask are relevant.
+ *  @param[in] clkvalue Softmax value for GFXCLK in MHz.
  *
  *  @retval ::RSMI_STATUS_SUCCESS call was successful
  *  @retval ::RSMI_STATUS_NOT_SUPPORTED installed software or hardware does not
@@ -2115,8 +2108,7 @@ rsmi_status_t rsmi_dev_perf_level_get(uint32_t dv_ind,
  *
  */
 
-rsmi_status_t rsmi_perf_determinism_mode_set(uint32_t dv_ind,
-                                             uint64_t freq_bitmask);
+rsmi_status_t rsmi_perf_determinism_mode_set(uint32_t dv_ind, uint64_t clkvalue);
 /**
  *  @brief Get the overdrive percent associated with the device with provided
  *  device index.

projects/amdsmi/python_smi_tools/rocm_smi.py

@@ -905,7 +905,7 @@ def setClocks(deviceList, clktype, clk):
     printLogSpacer()
 
 
-def setPerfDeterminism(deviceList, value):
+def setPerfDeterminism(deviceList, clkvalue):
     """ Set clock frequency level for a list of devices to enable performance
     determinism.
 
@@ -914,18 +914,19 @@ def setPerfDeterminism(deviceList, value):
     """
     global RETCODE
     try:
-        int(value)
+        int(clkvalue)
     except ValueError:
         printErrLog(device, 'Unable to set Performance Determinism')
-        logging.error('%s is not an integer', value)
+        logging.error('%s is not an integer', clkvalue)
         RETCODE = 1
         return
+    clklevel = c_uint32(1)
     for device in deviceList:
-        ret = rocmsmi.rsmi_perf_determinism_mode_set(device, int(value))
+        ret = rocmsmi.rsmi_perf_determinism_mode_set(device, clklevel, int(clkvalue))
         if rsmi_ret_ok(ret, device):
-            printLog(device, 'Successfully set clock frequency', str(value))
+            printLog(device, 'Successfully enabled performance determinism and set GFX clock frequency', str(clkvalue))
         else:
-            printErrLog(device, 'Unable to set clock frequency', str(value))
+            printErrLog(device, 'Unable to set performance determinism and clock frequency', str(clkvalue))
             RETCODE = 1
 
 

projects/amdsmi/src/rocm_smi.cc

@@ -769,19 +769,44 @@ rsmi_dev_perf_level_get(uint32_t dv_ind, rsmi_dev_perf_level_t *perf) {
   CATCH
 }
 
+static rsmi_status_t
+set_dev_range(uint32_t dv_ind, std::string range) {
+  GET_DEV_FROM_INDX
+
+  int ret = dev->writeDevInfo(amd::smi::kDevPowerODVoltage, range);
+  return amd::smi::ErrnoToRsmiStatus(ret);
+}
+
 rsmi_status_t
-rsmi_perf_determinism_mode_set(uint32_t dv_ind, uint64_t freq_bitmask) {
+rsmi_perf_determinism_mode_set(uint32_t dv_ind, uint64_t clkvalue) {
   TRY
   DEVICE_MUTEX
 
+  // Set perf. level to performance determinism so that we can then set the power profile
   rsmi_status_t ret = rsmi_dev_perf_level_set_v1(dv_ind,
                                           RSMI_DEV_PERF_LEVEL_DETERMINISM);
   if (ret != RSMI_STATUS_SUCCESS) {
       return ret;
   }
-  ret = rsmi_dev_gpu_clk_freq_set(dv_ind, RSMI_CLK_TYPE_SYS, freq_bitmask);
 
-  return ret;
+  // For clock frequency setting, enter a new value by writing a string that
+  // contains "s index clock" to the file. The index should be 1 to set maximum
+  // clock. E.g., "s 1 500" will update maximum sclk to be 500 MHz.
+
+  std::string sysvalue = "s";
+  sysvalue += ' ' + std::to_string(RSMI_FREQ_IND_MAX);
+  sysvalue += ' ' + std::to_string(clkvalue);
+  sysvalue += '\n';
+  ret = set_dev_range(dv_ind, sysvalue);
+  if (ret != RSMI_STATUS_SUCCESS) {
+    return ret;
+  }
+  ret = set_dev_range(dv_ind, "c");
+  if (ret != RSMI_STATUS_SUCCESS) {
+    return ret;
+  }
+
+  return RSMI_STATUS_SUCCESS;
   CATCH
 }
 
@@ -853,13 +878,6 @@ rsmi_dev_perf_level_set_v1(uint32_t dv_ind, rsmi_dev_perf_level_t perf_level) {
   CATCH
 }
 
-static rsmi_status_t
-set_dev_range(uint32_t dv_ind, std::string range) {
-  GET_DEV_FROM_INDX
-
-  int ret = dev->writeDevInfo(amd::smi::kDevPowerODVoltage, range);
-  return amd::smi::ErrnoToRsmiStatus(ret);
-}
 
 static rsmi_status_t get_frequencies(amd::smi::DevInfoTypes type,
             uint32_t dv_ind, rsmi_frequencies_t *f, uint32_t *lanes = nullptr) {

projects/amdsmi/src/rocm_smi_device.cc

@@ -215,7 +215,7 @@ static const char *kDevPerfLevelStandardStr = "profile_standard";
 static const char *kDevPerfLevelMinMClkStr = "profile_min_mclk";
 static const char *kDevPerfLevelMinSClkStr = "profile_min_sclk";
 static const char *kDevPerfLevelPeakStr = "profile_peak";
-static const char *kDevPerfLevelDeterminismStr = "performance_determinism";
+static const char *kDevPerfLevelDeterminismStr = "perf_determinism";
 static const char *kDevPerfLevelUnknownStr = "unknown";
 
 static const std::map<DevInfoTypes, const char *> kDevAttribNameMap = {
@@ -380,7 +380,7 @@ static const std::map<const char *, dev_depends_t> kDevFuncDependsMap = {
   {"rsmi_dev_perf_level_set_v1",         {{kDevPerfLevelFName}, {}}},
   {"rsmi_dev_perf_level_get",            {{kDevPerfLevelFName}, {}}},
   {"rsmi_perf_determinism_mode_set",     {{kDevPerfLevelFName,
-                                           kDevGPUSClkFName}, {}}},
+                                           kDevPowerODVoltageFName}, {}}},
   {"rsmi_dev_overdrive_level_set",       {{kDevOverDriveLevelFName}, {}}},
   {"rsmi_dev_vbios_version_get",         {{kDevVBiosVerFName}, {}}},
   {"rsmi_dev_od_volt_info_get",          {{kDevPowerODVoltageFName}, {}}},

projects/amdsmi/tests/rocm_smi_test/functional/perf_determinism.cc

@@ -107,48 +107,43 @@ void TestPerfDeterminism::Close() {
 void TestPerfDeterminism::Run(void) {
   rsmi_status_t err;
   rsmi_dev_perf_level_t pfl;
-  rsmi_frequencies_t f;
+  rsmi_od_volt_freq_data_t odv;
   rsmi_status_t ret;
-
+  uint64_t clkvalue;
   TestBase::Run();
   if (setup_failed_) {
     std::cout << "** SetUp Failed for this test. Skipping.**" << std::endl;
     return;
   }
-  // Set clocks to something other than the usual default of the lowest
-  // frequency.
-  uint64_t freq_bitmask = 0b01100;  // Try the 3rd and 4th clocks
-  std::string freq_bm_str =
-          std::bitset<RSMI_MAX_NUM_FREQUENCIES>(freq_bitmask).to_string();
-
-  freq_bm_str.erase(0, std::min(freq_bm_str.find_first_not_of('0'),
-                                                   freq_bm_str.size()-1));
 
   for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
     PrintDeviceHeader(i);
+    err = rsmi_dev_od_volt_info_get(i, &odv);
+    if (err == RSMI_STATUS_NOT_SUPPORTED) {
+      IF_VERB(STANDARD) {
+        std::cout << "\t** Not supported on this machine" << std::endl;
+      }
+      return;
+    }
+    else{
+      clkvalue = odv.curr_sclk_range.lower_bound + 50;
+    }
 
-    err = rsmi_perf_determinism_mode_set(i, freq_bitmask);
-
+    err = rsmi_perf_determinism_mode_set(i, clkvalue);
     if (err == RSMI_STATUS_NOT_SUPPORTED) {
       IF_VERB(STANDARD) {
         std::cout << "\t** Not supported on this machine" << std::endl;
       }
       return;
     } else {
-      ret = rsmi_dev_gpu_clk_freq_get(i, RSMI_CLK_TYPE_SYS, &f);
-          if (ret != RSMI_STATUS_SUCCESS) {
-              return;
-          }
-
-      IF_VERB(STANDARD) {
-          std::cout << "\tFrequency is now index " << f.current << std::endl;
-      }
       ret = rsmi_dev_perf_level_get(i, &pfl);
       CHK_ERR_ASRT(ret)
       IF_VERB(STANDARD) {
           std::cout << "\t**New Perf Level:" << kDevPerfLvlNameMap.at(pfl) <<
                                                                   std::endl;
+          std::cout << "\tSCLK is now set to " << clkvalue << std::endl;
       }
+
       std::cout << "\tResetting performance determinism" << std::endl;
       err = rsmi_dev_perf_level_set(i, RSMI_DEV_PERF_LEVEL_AUTO);;
       CHK_ERR_ASRT(err)

projects/amdsmi/tests/rocm_smi_test/main.cc

@@ -234,7 +234,7 @@ TEST(rsmitstReadOnly, TestGpuMetricsRead) {
   TestGpuMetricsRead tst;
   RunGenericTest(&tst);
 }
-TEST(rsmitstReadOnly, TestPerfDeterminism) {
+TEST(rsmitstReadWrite, TestPerfDeterminism) {
   TestPerfDeterminism tst;
   RunGenericTest(&tst);
 }