diff --git a/projects/rocm-smi-lib/include/rocm_smi/rocm_smi.h b/projects/rocm-smi-lib/include/rocm_smi/rocm_smi.h index 24ec69e5d2..a113655e36 100755 --- a/projects/rocm-smi-lib/include/rocm_smi/rocm_smi.h +++ b/projects/rocm-smi-lib/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. diff --git a/projects/rocm-smi-lib/python_smi_tools/rocm_smi.py b/projects/rocm-smi-lib/python_smi_tools/rocm_smi.py index 28f441c30b..087a223c17 100755 --- a/projects/rocm-smi-lib/python_smi_tools/rocm_smi.py +++ b/projects/rocm-smi-lib/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 diff --git a/projects/rocm-smi-lib/src/rocm_smi.cc b/projects/rocm-smi-lib/src/rocm_smi.cc index 525311a568..9e8d3cdd4a 100755 --- a/projects/rocm-smi-lib/src/rocm_smi.cc +++ b/projects/rocm-smi-lib/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) { diff --git a/projects/rocm-smi-lib/src/rocm_smi_device.cc b/projects/rocm-smi-lib/src/rocm_smi_device.cc index 5207be3a64..5377964c02 100755 --- a/projects/rocm-smi-lib/src/rocm_smi_device.cc +++ b/projects/rocm-smi-lib/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 kDevAttribNameMap = { @@ -380,7 +380,7 @@ static const std::map 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}, {}}}, diff --git a/projects/rocm-smi-lib/tests/rocm_smi_test/functional/perf_determinism.cc b/projects/rocm-smi-lib/tests/rocm_smi_test/functional/perf_determinism.cc index 93c93b6df9..48ca727ed1 100644 --- a/projects/rocm-smi-lib/tests/rocm_smi_test/functional/perf_determinism.cc +++ b/projects/rocm-smi-lib/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(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) diff --git a/projects/rocm-smi-lib/tests/rocm_smi_test/main.cc b/projects/rocm-smi-lib/tests/rocm_smi_test/main.cc index 9077b862b0..47f1b1b873 100755 --- a/projects/rocm-smi-lib/tests/rocm_smi_test/main.cc +++ b/projects/rocm-smi-lib/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); }