AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support checking for specific device-getter api support

Browse Source 
For device-getter functions, allow users to specify a nullptr
for the provided buffer. In those cases, the function will return
RSMI_STATUS_NOT_SUPPORTED if the hardware or system software does
not support the function. If the function is supported, then
RSMI_STATUS_INVALID_ARGS will be returned, unless a different
error is encountered.

Additionally, tests and documentation were updated to reflect
this change.

Change-Id: Ie7db3a4c8c66af97ebd7ee1e3b95cd331ace9d9c
This commit is contained in:
Chris Freehill
2019-09-23 17:43:58 -05:00
parent 2412dff6a2
commit 68d25e82fd
22 changed files with 1070 additions and 511 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/rocm_smi_test/functional/err_cnt_read.cc
+23
View File
@@ -98,9 +98,18 @@ void TestErrCntRead::Run(void) {
std::cout <<
"\t**Error Count Enabled Mask get is not supported on this machine"
<< std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_ecc_enabled_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
continue;
} else {
CHK_ERR_ASRT(err)
// Verify api support checking functionality is working
err = rsmi_dev_ecc_enabled_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
IF_VERB(STANDARD) {
std::cout << "Block Error Mask: 0x" << std::hex << enabled_mask <<
std::endl;
@@ -116,6 +125,10 @@ void TestErrCntRead::Run(void) {
GetBlockNameStr(static_cast<rsmi_gpu_block_t>(b)) <<
" block: " << GetErrStateNameStr(err_state) << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_ecc_status_get(i, static_cast<rsmi_gpu_block_t>(b),
nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
err = rsmi_dev_ecc_count_get(i, static_cast<rsmi_gpu_block_t>(b), &ec);
@@ -123,6 +136,11 @@ void TestErrCntRead::Run(void) {
std::cout << "\t**Error Count for " <<
GetBlockNameStr(static_cast<rsmi_gpu_block_t>(b)) <<
": Not supported for this device" << std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_ecc_count_get(i, static_cast<rsmi_gpu_block_t>(b),
nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
@@ -133,6 +151,11 @@ void TestErrCntRead::Run(void) {
<< std::endl;
std::cout << "\t\tUncorrectable errors: " << ec.uncorrectable_err
<< std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_ecc_count_get(i, static_cast<rsmi_gpu_block_t>(b),
nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
}
tests/rocm_smi_test/functional/fan_read.cc
+12
View File
@@ -99,12 +99,20 @@ void TestFanRead::Run(void) {
}
err = rsmi_dev_fan_speed_get(i, 0, &val_i64);
CHK_ERR_ASRT(err)
// Verify api support checking functionality is working
err = rsmi_dev_fan_speed_get(i, 0, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
err = rsmi_dev_fan_speed_max_get(i, 0, &val_ui64);
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << val_i64/static_cast<float>(val_ui64)*100;
std::cout << "% ("<< val_i64 << "/" << val_ui64 << ")" << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_fan_speed_max_get(i, 0, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
IF_VERB(STANDARD) {
std::cout << "\t**Current fan RPMs: ";
@@ -114,5 +122,9 @@ void TestFanRead::Run(void) {
IF_VERB(STANDARD) {
std::cout << val_i64 << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_fan_rpms_get(i, 0, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
tests/rocm_smi_test/functional/frequencies_read.cc
+14 -2
View File
@@ -113,15 +113,21 @@ void TestFrequenciesRead::Run(void) {
for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
auto freq_output = [&](rsmi_clk_type_t t, const char *name) {
err = rsmi_dev_gpu_clk_freq_get(i, t, &f);
if (err == RSMI_STATUS_NOT_SUPPORTED || err == RSMI_STATUS_FILE_ERROR) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\t**Get " << name << ": Not supported on this machine"
<< std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_gpu_clk_freq_get(i, t, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Supported " << name << " clock frequencies: ";
std::cout << f.num_supported << std::endl;
print_frequencies(&f);
// Verify api support checking functionality is working
err = rsmi_dev_gpu_clk_freq_get(i, t, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
};
@@ -135,15 +141,21 @@ void TestFrequenciesRead::Run(void) {
freq_output(RSMI_CLK_TYPE_SOC, "SOC Clock");
err = rsmi_dev_pci_bandwidth_get(i, &b);
if (err == RSMI_STATUS_NOT_SUPPORTED || err == RSMI_STATUS_FILE_ERROR) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\t**Get PCIE Bandwidth: Not supported on this machine"
<< std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_pci_bandwidth_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Supported PCIe bandwidths: ";
std::cout << b.transfer_rate.num_supported << std::endl;
print_frequencies(&b.transfer_rate, b.lanes);
// Verify api support checking functionality is working
err = rsmi_dev_pci_bandwidth_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
}
tests/rocm_smi_test/functional/frequencies_read_write.cc
+1 -2
View File
@@ -106,8 +106,7 @@ void TestFrequenciesReadWrite::Run(void) {
auto freq_read = [&]() -> bool {
ret = rsmi_dev_gpu_clk_freq_get(dv_ind, rsmi_clk, &f);
if (ret == RSMI_STATUS_NOT_SUPPORTED ||
ret == RSMI_STATUS_FILE_ERROR) {
if (ret == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\t**Set " << FreqEnumToStr(rsmi_clk) <<
": Not supported on this machine" << std::endl;
return false;
tests/rocm_smi_test/functional/id_info_read.cc
+100 -28
View File
@@ -101,130 +101,202 @@ void TestIdInfoRead::Run(void) {
// Get the device ID, name, vendor ID and vendor name for the device
err = rsmi_dev_id_get(i, &id);
if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
if (err == RSMI_STATUS_NOT_SUPPORTED) {
rsmi_status_t ret;
// Verify api support checking functionality is working
ret = rsmi_dev_id_get(i, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Device ID: 0x" << std::hex << id << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_name_get(i, buffer, kBufferLen);
if (err == RSMI_STATUS_NOT_FOUND) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\t**Device Marketing name not found on this system." <<
std::endl;
} else if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
// Verify api support checking functionality is working
err = rsmi_dev_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Device Marketing name: " << buffer << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_brand_get(i, buffer, kBufferLen);
if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
if (err == RSMI_STATUS_NOT_SUPPORTED) {
// Verify api support checking functionality is working
err = rsmi_dev_brand_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Device Brand name: " << buffer << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_brand_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_vram_vendor_get(i, buffer, kBufferLen);
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout <<
"\t**Vram Vendor string not supported on this system." << std::endl;
} else if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
err = rsmi_dev_vram_vendor_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Device Vram Vendor name: " << buffer << std::endl;
}
err = rsmi_dev_brand_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_vendor_id_get(i, &id);
if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
if (err == RSMI_STATUS_NOT_SUPPORTED) {
// Verify api support checking functionality is working
err = rsmi_dev_vendor_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Vendor ID: 0x" << std::hex << id << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_vendor_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_drm_render_minor_get(i, &drm_render_minor);
if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
if (err == RSMI_STATUS_NOT_SUPPORTED) {
// Verify api support checking functionality is working
err = rsmi_dev_drm_render_minor_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**DRM Render Minor: " << drm_render_minor << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_drm_render_minor_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_vendor_name_get(i, buffer, kBufferLen);
if (err == RSMI_STATUS_NOT_FOUND) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\t**Device Vendor name string not found on this system." <<
std::endl;
} else if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
// Verify api support checking functionality is working
err = rsmi_dev_vendor_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Device Vendor name: " << buffer << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_vendor_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
// Get the device ID, name, vendor ID and vendor name for the sub-device
err = rsmi_dev_subsystem_id_get(i, &id);
if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
if (err == RSMI_STATUS_NOT_SUPPORTED) {
// Verify api support checking functionality is working
err = rsmi_dev_subsystem_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Subsystem ID: 0x" << std::hex << id << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_subsystem_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_subsystem_name_get(i, buffer, kBufferLen);
if (err == RSMI_STATUS_NOT_FOUND) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\t**Subsystem name string not found on this system." <<
std::endl;
} else if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
// Verify api support checking functionality is working
err = rsmi_dev_subsystem_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Subsystem name: " << buffer << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_subsystem_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_subsystem_vendor_id_get(i, &id);
if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
if (err == RSMI_STATUS_NOT_SUPPORTED) {
// Verify api support checking functionality is working
err = rsmi_dev_subsystem_vendor_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Sub-system Vendor ID: 0x" << std::hex <<
id << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_subsystem_vendor_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_vendor_name_get(i, buffer, kBufferLen);
if (err == RSMI_STATUS_NOT_FOUND) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout <<
"\t**Subsystem Vendor name string not found on this system." <<
std::endl;
} else if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
// Verify api support checking functionality is working
err = rsmi_dev_vendor_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Subsystem Vendor name: " << buffer << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_vendor_name_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_dev_pci_id_get(i, &val_ui64);
// Don't check for RSMI_STATUS_NOT_SUPPORTED since this should always be
// supported. It is not based on a sysfs file.
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**PCI ID (BDFID): 0x" << std::hex << val_ui64;
std::cout << " (" << std::dec << val_ui64 << ")" << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_pci_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
err = rsmi_dev_serial_number_get(i, buffer, kBufferLen);
if (err == RSMI_STATUS_NOT_SUPPORTED) {
// Verify api support checking functionality is working
err = rsmi_dev_serial_number_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
std::cout <<
"\t**Serial Number string not supported on this system." << std::endl;
} else if (err != RSMI_STATUS_SUCCESS) {
CHK_ERR_ASRT(err)
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**Device Serial Number:" << buffer << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_serial_number_get(i, nullptr, kBufferLen);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
}
tests/rocm_smi_test/functional/mem_page_info_read.cc
+8
View File
@@ -98,6 +98,11 @@ void TestMemPageInfoRead::Run(void) {
std::cout <<
"\t**Memory page information is not supported for this device"
<< std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_memory_reserved_pages_get(i, nullptr, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
continue;
} else {
CHK_ERR_ASRT(err)
@@ -105,6 +110,9 @@ void TestMemPageInfoRead::Run(void) {
std::cout << "\tNumber of memory page records: " << num_pages <<
std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_memory_reserved_pages_get(i, nullptr, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
if (num_pages > 0) {
tests/rocm_smi_test/functional/overdrive_read.cc
+3
View File
@@ -98,6 +98,9 @@ void TestOverdriveRead::Run(void) {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**OverDrive Level:" << val_ui32 << std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_overdrive_level_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
}
tests/rocm_smi_test/functional/pci_read_write.cc
+17
View File
@@ -102,11 +102,18 @@ void TestPciReadWrite::Run(void) {
std::cout <<
"\t**rsmi_dev_pci_replay_counter_get() is not supported"
" on this machine" << std::endl;
// Verify api support checking functionality is working
ret = rsmi_dev_pci_replay_counter_get(dv_ind, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(ret)
IF_VERB(STANDARD) {
std::cout << "\tPCIe Replay Counter: " << u64int << std::endl;
}
// Verify api support checking functionality is working
ret = rsmi_dev_pci_replay_counter_get(dv_ind, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_INVALID_ARGS);
}
ret = rsmi_dev_pci_throughput_get(dv_ind, &sent, &received, &max_pkt_sz);
@@ -114,6 +121,9 @@ void TestPciReadWrite::Run(void) {
std::cout << "TEST FAILURE: Current PCIe throughput is not detected. "
"This is likely because it is not indicated in the pcie_bw sysfs "
"file. Aborting test." << std::endl;
// We don't need to verify api support checking functionality is working
// as the user may choose to have any of the input parameters as 0.
return;
}
CHK_ERR_ASRT(ret)
@@ -133,6 +143,10 @@ void TestPciReadWrite::Run(void) {
std::cout << "TEST FAILURE: Current PCIe bandwidth is not detected. "
"This is likely because it is not indicated in the pp_dpm_pcie sysfs "
"file. Aborting test." << std::endl;
// Verify api support checking functionality is working
ret = rsmi_dev_pci_bandwidth_get(dv_ind, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_NOT_SUPPORTED);
return;
}
CHK_ERR_ASRT(ret)
@@ -141,6 +155,9 @@ void TestPciReadWrite::Run(void) {
std::cout << "\tInitial PCIe BW index is " << bw.transfer_rate.current <<
std::endl;
}
// Verify api support checking functionality is working
ret = rsmi_dev_pci_bandwidth_get(dv_ind, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_INVALID_ARGS);
// First set the bitmask to all supported bandwidths
freq_bitmask = ~(~0 << bw.transfer_rate.num_supported);
tests/rocm_smi_test/functional/perf_cntr_read_write.cc
+7 -1
View File
@@ -139,6 +139,13 @@ TestPerfCntrReadWrite::testEventsIndividually(uint32_t dv_ind) {
static_cast<rsmi_event_type_t>(evnt), &evt_handle);
CHK_ERR_ASRT(ret)
// Note that rsmi_dev_counter_create() should never return
// RSMI_STATUS_NOT_SUPPORTED. It will return RSMI_STATUS_OUT_OF_RESOURCES
// if it is unable to create a counter.
ret = rsmi_dev_counter_create(dv_ind,
static_cast<rsmi_event_type_t>(evnt), nullptr);
ASSERT_EQ(ret, RSMI_STATUS_INVALID_ARGS);
IF_VERB(STANDARD) {
std::cout << "\t\tStart Counting..." << std::endl;
}
@@ -202,7 +209,6 @@ TestPerfCntrReadWrite::testEventsSimultaneously(uint32_t dv_ind) {
std::cout << "****************************" << std::endl;
for (PerfCntrEvtGrp grp : s_event_groups) {
ret = rsmi_dev_counter_group_supported(dv_ind, grp.group());
if (ret == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\tEvent Group " << grp.name() <<
tests/rocm_smi_test/functional/perf_level_read.cc
+3
View File
@@ -100,5 +100,8 @@ void TestPerfLevelRead::Run(void) {
std::cout << "\t**Performance Level:" << std::dec << (uint32_t)pfl <<
std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_perf_level_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
tests/rocm_smi_test/functional/power_cap_read_write.cc
+6
View File
@@ -98,9 +98,15 @@ void TestPowerCapReadWrite::Run(void) {
ret = rsmi_dev_power_cap_range_get(dv_ind, 0, &max, &min);
CHK_ERR_ASRT(ret)
// Verify api support checking functionality is working
ret = rsmi_dev_power_cap_range_get(dv_ind, 0, nullptr, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_INVALID_ARGS);
ret = rsmi_dev_power_cap_get(dv_ind, 0, &orig);
CHK_ERR_ASRT(ret)
// Verify api support checking functionality is working
ret = rsmi_dev_power_cap_get(dv_ind, 0, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_INVALID_ARGS);
new_cap = (max + min)/2;
tests/rocm_smi_test/functional/power_read.cc
+3
View File
@@ -113,6 +113,9 @@ void TestPowerRead::Run(void) {
if (err == RSMI_STATUS_SUCCESS) {
std::cout << static_cast<float>(val_ui64)/1000 << " mW" << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_power_ave_get(i, 0, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
}
tests/rocm_smi_test/functional/power_read_write.cc
+4
View File
@@ -121,6 +121,10 @@ void TestPowerReadWrite::Run(void) {
ret = rsmi_dev_power_profile_presets_get(dv_ind, 0, &status);
CHK_ERR_ASRT(ret)
// Verify api support checking functionality is working
ret = rsmi_dev_power_profile_presets_get(dv_ind, 0, nullptr);
ASSERT_EQ(ret, RSMI_STATUS_INVALID_ARGS);
IF_VERB(STANDARD) {
std::cout << "The available power profiles are:" << std::endl;
uint64_t tmp = 1;
tests/rocm_smi_test/functional/sys_info_read.cc
+25 -1
View File
@@ -105,7 +105,14 @@ void TestSysInfoRead::Run(void) {
std::cout << "\t**VBIOS read: Not supported on this machine"
<< std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_vbios_version_get(i, nullptr, 80);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
// Verify api support checking functionality is working
err = rsmi_dev_vbios_version_get(i, nullptr, 80);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
CHK_ERR_ASRT(err)
}
} else {
@@ -120,18 +127,27 @@ void TestSysInfoRead::Run(void) {
std::cout << "\t**PCI ID (BDFID): 0x" << std::hex << val_ui64;
std::cout << " (" << std::dec << val_ui64 << ")" << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_pci_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
err = rsmi_dev_unique_id_get(i, &val_ui64);
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout <<
"\t**rsmi_dev_unique_id() is not supported"
" on this machine" << std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_unique_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**GPU Unique ID : " << std::hex << val_ui64 <<
std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_unique_id_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
err = rsmi_version_get(&ver);
@@ -148,15 +164,23 @@ void TestSysInfoRead::Run(void) {
for (int x = RSMI_FW_BLOCK_FIRST; x <= RSMI_FW_BLOCK_LAST; ++x) {
rsmi_fw_block_t block = static_cast<rsmi_fw_block_t>(x);
err = rsmi_dev_firmware_version_get(i, block, &val_ui64);
if (err) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
std::cout << "\t**No FW block " << NameFromFWEnum(block) <<
" available on this system" << std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_firmware_version_get(i, block, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
continue;
}
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**FW VERSION for " << NameFromFWEnum(block) <<
": " << val_ui64 << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_firmware_version_get(i, block, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
}
}
}
tests/rocm_smi_test/functional/temp_read.cc
+7
View File
@@ -112,12 +112,19 @@ void TestTempRead::Run(void) {
IF_VERB(STANDARD) {
std::cout << "\t**" << label << ": " <<
"Not supported on this machine" << std::endl;
// Verify api support checking functionality is working
err = rsmi_dev_temp_metric_get(i, type, met, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
return;
}
} else {
CHK_ERR_ASRT(err)
}
}
// Verify api support checking functionality is working
err = rsmi_dev_temp_metric_get(i, type, met, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
IF_VERB(STANDARD) {
std::cout << "\t**" << label << ": " << val_i64/1000 <<
tests/rocm_smi_test/functional/volt_freq_curv_read.cc
+7 -2
View File
@@ -154,15 +154,20 @@ void TestVoltCurvRead::Run(void) {
PrintDeviceHeader(i);
err = rsmi_dev_od_volt_info_get(i, &odv);
if (err == RSMI_STATUS_FILE_ERROR ||
err == RSMI_STATUS_NOT_SUPPORTED) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
IF_VERB(STANDARD) {
std::cout <<
"\t**rsmi_dev_od_volt_info_get: Not supported on this machine"
<< std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_od_volt_info_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
} else {
CHK_ERR_ASRT(err)
// Verify api support checking functionality is working
err = rsmi_dev_od_volt_info_get(i, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
}
if (err == RSMI_STATUS_SUCCESS) {
tests/rocm_smi_test/functional/xgmi_read_write.cc
+16 -13
View File
@@ -95,22 +95,25 @@ void TestXGMIReadWrite::Run(void) {
err = rsmi_dev_xgmi_error_status(dv_ind, &err_stat);
if (err != RSMI_STATUS_SUCCESS) {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
IF_VERB(STANDARD) {
std::cout << "\t**XGMI Error Status: Not supported on this machine"
<< std::endl;
return;
}
} else {
CHK_ERR_ASRT(err)
}
} else {
if (err == RSMI_STATUS_NOT_SUPPORTED) {
IF_VERB(STANDARD) {
std::cout << "\t**XGMI Error Status: " <<
static_cast<uint32_t>(err_stat) << std::endl;
std::cout << "\t**XGMI Error Status: Not supported on this machine"
<< std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_xgmi_error_status(dv_ind, nullptr);
ASSERT_EQ(err, RSMI_STATUS_NOT_SUPPORTED);
continue;
}
CHK_ERR_ASRT(err)
IF_VERB(STANDARD) {
std::cout << "\t**XGMI Error Status: " <<
static_cast<uint32_t>(err_stat) << std::endl;
}
// Verify api support checking functionality is working
err = rsmi_dev_xgmi_error_status(dv_ind, nullptr);
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
// TODO(cfree) We need to find a way to generate xgmi errors so this
// test won't be meaningless