Merge amd-staging into amd-master 20240216
Change-Id: Id3e41507ab6143d08cb052710aa19c6f2e402fed Signed-off-by: Charis Poag <Charis.Poag@amd.com>
This commit is contained in:
Charis Poag
@@ -14,6 +14,9 @@ endif()
|
||||
## Include common cmake modules
|
||||
include(utils)
|
||||
|
||||
# Default libdir to "lib", this skips GNUInstallDirs from trying to take a guess if it's unset:
|
||||
set(CMAKE_INSTALL_LIBDIR "lib" CACHE STRING "Library install directory")
|
||||
|
||||
if (NOT DEFINED CPACK_RESOURCE_FILE_LICENSE)
|
||||
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/License.txt")
|
||||
endif()
|
||||
|
||||
+52
-1050
File diff suppressed because it is too large
Load Diff
@@ -86,6 +86,10 @@ class KFDNode {
|
||||
|
||||
// Get gfx target version from kfd
|
||||
int get_gfx_target_version(uint64_t* gfx_target_version);
|
||||
// Get gpu_id (AKA GUID) version from kfd
|
||||
int get_gpu_id(uint64_t *gpu_id);
|
||||
// Get node id from kfd
|
||||
int get_node_id(uint32_t *node_id);
|
||||
|
||||
private:
|
||||
uint32_t node_indx_;
|
||||
|
||||
@@ -162,7 +162,8 @@ std::string print_unsigned_hex_and_int(T i, std::string heading="") {
|
||||
}
|
||||
ss << "Hex (MSB): " << print_int_as_hex(i) << ", "
|
||||
<< "Unsigned int: " << print_unsigned_int(i) << ", "
|
||||
<< "Byte Size: " << sizeof(T);
|
||||
<< "Byte Size: " << sizeof(T) << ", "
|
||||
<< "Bits: " << sizeof(T) * 8; // 8 bits per 1 byte
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
|
||||
+186
-162
@@ -254,7 +254,7 @@ def getGpuUse(device, silent=False):
|
||||
return -1
|
||||
|
||||
|
||||
def getId(device, silent=False):
|
||||
def getDRMDeviceId(device, silent=False):
|
||||
""" Return the hexadecimal value of a device's ID
|
||||
|
||||
@param device: DRM device identifier
|
||||
@@ -263,8 +263,10 @@ def getId(device, silent=False):
|
||||
"""
|
||||
dv_id = c_short()
|
||||
ret = rocmsmi.rsmi_dev_id_get(device, byref(dv_id))
|
||||
device_id_ret = "N/A"
|
||||
if rsmi_ret_ok(ret, device, 'get_device_id', silent):
|
||||
return hex(dv_id.value)
|
||||
device_id_ret = hex(dv_id.value)
|
||||
return device_id_ret
|
||||
|
||||
|
||||
def getRev(device, silent=False):
|
||||
@@ -276,9 +278,103 @@ def getRev(device, silent=False):
|
||||
"""
|
||||
dv_rev = c_short()
|
||||
ret = rocmsmi.rsmi_dev_revision_get(device, byref(dv_rev))
|
||||
if rsmi_ret_ok(ret, device, 'get_device_rev', silent):
|
||||
return hex(dv_rev.value)
|
||||
revision_ret = "N/A"
|
||||
if rsmi_ret_ok(ret, device, 'get_device_rev', silent=silent):
|
||||
revision_ret = padHexValue(hex(dv_rev.value), 2)
|
||||
return revision_ret
|
||||
|
||||
def getSubsystemId(device, silent=False):
|
||||
""" Return the a device's subsystem id
|
||||
|
||||
@param device: DRM device identifier
|
||||
@param silent=Turn on to silence error output
|
||||
(you plan to handle manually). Default is off.
|
||||
"""
|
||||
model = create_string_buffer(MAX_BUFF_SIZE)
|
||||
ret = rocmsmi.rsmi_dev_subsystem_name_get(device, model, MAX_BUFF_SIZE)
|
||||
device_model = "N/A"
|
||||
if rsmi_ret_ok(ret, device, 'get_subsystem_name', silent=silent):
|
||||
device_model = model.value.decode()
|
||||
# padHexValue is used for applications that expect 4-digit card models
|
||||
device_model = padHexValue(device_model, 4)
|
||||
return device_model
|
||||
|
||||
def getVendor(device, silent=False):
|
||||
""" Return the a device's vendor id
|
||||
|
||||
@param device: DRM device identifier
|
||||
@param silent=Turn on to silence error output
|
||||
(you plan to handle manually). Default is off.
|
||||
"""
|
||||
vendor = create_string_buffer(MAX_BUFF_SIZE)
|
||||
device_vendor = "N/A"
|
||||
# Retrieve card vendor
|
||||
ret = rocmsmi.rsmi_dev_vendor_name_get(device, vendor, MAX_BUFF_SIZE)
|
||||
# Only continue if GPU vendor is AMD
|
||||
if rsmi_ret_ok(ret, device, 'get_vendor_name', silent) and isAmdDevice(device):
|
||||
device_vendor = vendor.value.decode()
|
||||
return device_vendor
|
||||
|
||||
def getGUID(device, silent=False):
|
||||
""" Return the uint64 value of device's GUID,
|
||||
also referred as GPU ID - reported by KFD.
|
||||
|
||||
@param device: DRM device identifier
|
||||
@param silent=Turn on to silence error output
|
||||
(you plan to handle manually). Default is off.
|
||||
"""
|
||||
guid = c_uint64()
|
||||
ret = rocmsmi.rsmi_dev_guid_get(device, byref(guid))
|
||||
guid_ret = "N/A"
|
||||
if rsmi_ret_ok(ret, device, 'get_gpu_id_kfd', silent=silent):
|
||||
guid_ret = guid.value
|
||||
return guid_ret
|
||||
|
||||
def getTargetGfxVersion(device, silent=False):
|
||||
""" Return the uint64 value of device's target
|
||||
graphics version as reported by KFD
|
||||
|
||||
@param device: DRM device identifier
|
||||
@param silent=Turn on to silence error output
|
||||
(you plan to handle manually). Default is off.
|
||||
"""
|
||||
gfx_version = c_uint64()
|
||||
gfx_ver_ret = "N/A"
|
||||
ret = rocmsmi.rsmi_dev_target_graphics_version_get(device, byref(gfx_version))
|
||||
if rsmi_ret_ok(ret, device, 'get_target_gfx_version', silent=silent):
|
||||
gfx_ver_ret = "gfx" + str(gfx_version.value)
|
||||
return gfx_ver_ret
|
||||
|
||||
def getNodeId(device, silent=False):
|
||||
""" Return the uint32 value of device's node id
|
||||
reported by KFD.
|
||||
|
||||
@param device: DRM device identifier
|
||||
@param silent=Turn on to silence error output
|
||||
(you plan to handle manually). Default is off.
|
||||
"""
|
||||
node_id = c_uint32()
|
||||
ret = rocmsmi.rsmi_dev_node_id_get(device, byref(node_id))
|
||||
node_id_ret = "N/A"
|
||||
if rsmi_ret_ok(ret, device, 'get_node_id_kfd', silent=silent):
|
||||
node_id_ret = node_id.value
|
||||
return node_id_ret
|
||||
|
||||
def getDeviceName(device, silent=False):
|
||||
""" Return the uint64 value of device's target
|
||||
graphics version as reported by KFD
|
||||
|
||||
@param device: DRM device identifier
|
||||
@param silent=Turn on to silence error output
|
||||
(you plan to handle manually). Default is off.
|
||||
"""
|
||||
# Retrieve the device series
|
||||
series = create_string_buffer(MAX_BUFF_SIZE)
|
||||
device_name_ret = "N/A"
|
||||
ret = rocmsmi.rsmi_dev_name_get(device, series, MAX_BUFF_SIZE)
|
||||
if rsmi_ret_ok(ret, device, 'get_name', silent=silent):
|
||||
device_name_ret = series.value.decode()
|
||||
return device_name_ret
|
||||
|
||||
def getMaxPower(device, silent=False):
|
||||
""" Return the maximum power cap of a given device
|
||||
@@ -515,10 +611,12 @@ def getVbiosVersion(device, silent=False):
|
||||
"""
|
||||
vbios = create_string_buffer(256)
|
||||
ret = rocmsmi.rsmi_dev_vbios_version_get(device, vbios, 256)
|
||||
if ret == rsmi_status_t.RSMI_STATUS_NOT_SUPPORTED:
|
||||
return "Unsupported"
|
||||
elif rsmi_ret_ok(ret, device, silent=silent):
|
||||
return vbios.value.decode()
|
||||
vbios_ret = "N/A"
|
||||
if rsmi_ret_ok(ret, device, silent=silent):
|
||||
vbios_ret = vbios.value.decode()
|
||||
if vbios_ret == "":
|
||||
vbios_ret = "N/A"
|
||||
return vbios_ret
|
||||
|
||||
|
||||
def getVersion(deviceList, component, silent=False):
|
||||
@@ -1784,9 +1882,9 @@ def showAllConcise(deviceList):
|
||||
deviceList.sort()
|
||||
available_temp_type = getTemperatureLabel(deviceList)
|
||||
temp_type = "(" + available_temp_type.capitalize() + ")"
|
||||
header=['Device', '[Model : Revision]', 'Temp', 'Power', 'Partitions',
|
||||
header=['Device', 'Node','IDs','', 'Temp', 'Power', 'Partitions',
|
||||
'SCLK', 'MCLK', 'Fan', 'Perf', 'PwrCap', 'VRAM%', 'GPU%']
|
||||
subheader = ['', 'Name (20 chars)', temp_type, getPowerLabel(deviceList),
|
||||
subheader = ['', '','(DID, ', 'GUID)', temp_type, getPowerLabel(deviceList),
|
||||
'(Mem, Compute)', '', '', '', '', '', '', '']
|
||||
# add additional spaces to match header
|
||||
for idx, item in enumerate(subheader):
|
||||
@@ -1804,8 +1902,6 @@ def showAllConcise(deviceList):
|
||||
values = {}
|
||||
degree_sign = u'\N{DEGREE SIGN}'
|
||||
for device in deviceList:
|
||||
gpu_dev_product_info = getDevProductInfo(device, silent)
|
||||
gpu_dev_product_info_names = list(gpu_dev_product_info[device])
|
||||
temp_val = str(getTemp(device, available_temp_type, silent))
|
||||
if temp_val != 'N/A':
|
||||
temp_val += degree_sign + 'C'
|
||||
@@ -1838,19 +1934,19 @@ def showAllConcise(deviceList):
|
||||
if vram_used is None:
|
||||
mem_use_pct='Unsupported'
|
||||
if vram_used != None and vram_total != None and float(vram_total) != 0:
|
||||
mem_use_pct = '% 3.0f%%' % (100 * (float(vram_used) / float(vram_total)))
|
||||
mem_use_pct = float(100 * (float(vram_used) / float(vram_total)))
|
||||
mem_use_pct = '{:<.0f}%'.format(mem_use_pct) # left aligned
|
||||
# values with no precision
|
||||
|
||||
gpu_dev_product_info_top_name = gpu_dev_product_info_names[0]
|
||||
if (len(gpu_dev_product_info_names) > 1):
|
||||
values['card%s_Info' % (str(device))] = ['', gpu_dev_product_info_names[0], '', '', '',
|
||||
'', '', '',
|
||||
'', '', '', '']
|
||||
gpu_dev_product_info_top_name = gpu_dev_product_info_names[1]
|
||||
|
||||
values['card%s' % (str(device))] = [device, gpu_dev_product_info_top_name, temp_val,
|
||||
powerVal, combined_partition, sclk, mclk,
|
||||
fan, str(perf).lower(), pwrCap, mem_use_pct,
|
||||
gpu_busy]
|
||||
# Top Row - per device data
|
||||
values['card%s' % (str(device))] = [device, getNodeId(device),
|
||||
str(getDRMDeviceId(device)) + ", ",
|
||||
str(getGUID(device)),
|
||||
temp_val, powerVal, combined_partition,
|
||||
sclk, mclk, fan, str(perf).lower(),
|
||||
str(pwrCap),
|
||||
str(mem_use_pct),
|
||||
str(gpu_busy)]
|
||||
|
||||
val_widths = {}
|
||||
for device in deviceList:
|
||||
@@ -1874,18 +1970,13 @@ def showAllConcise(deviceList):
|
||||
for device in deviceList:
|
||||
printLog(None, "".join(str(word).ljust(max_widths[col]) for col, word in
|
||||
zip(range(len(max_widths)), values['card%s' % (str(device))])), None)
|
||||
gpu_dev_product_info = getDevProductInfo(device, silent)
|
||||
gpu_dev_product_info_names = list(gpu_dev_product_info[device])
|
||||
if (len(gpu_dev_product_info_names) > 1):
|
||||
printLog(None, "".join(str(word).ljust(max_widths[col]) for col, word in
|
||||
zip(range(len(max_widths)), values['card%s_Info' % (str(device))])), None)
|
||||
|
||||
printLogSpacer(contentSizeToFit=len(header_output))
|
||||
printLogSpacer(footerString, contentSizeToFit=len(header_output))
|
||||
|
||||
|
||||
def showAllConciseHw(deviceList):
|
||||
""" Display critical Hardware info for all devices in a concise format
|
||||
""" Display critical Hardware info
|
||||
|
||||
@param deviceList: List of DRM devices (can be a single-item list)
|
||||
"""
|
||||
@@ -1893,25 +1984,22 @@ def showAllConciseHw(deviceList):
|
||||
if PRINT_JSON:
|
||||
print('ERROR: Cannot print JSON/CSV output for concise hardware output')
|
||||
sys.exit(1)
|
||||
printLogSpacer(' Concise Hardware Info ')
|
||||
header = ['GPU', 'DID', 'DREV', 'GFX RAS', 'SDMA RAS', 'UMC RAS', 'VBIOS', 'BUS']
|
||||
header = ['GPU', 'NODE', 'DID', 'GUID', 'GFX VER', 'GFX RAS', 'SDMA RAS', 'UMC RAS', 'VBIOS', 'BUS']
|
||||
head_widths = [len(head) + 2 for head in header]
|
||||
values = {}
|
||||
silent = True
|
||||
for device in deviceList:
|
||||
gpuid = getId(device, silent)
|
||||
if str(gpuid).startswith('0x'):
|
||||
gpuid = str(gpuid)[2:]
|
||||
gpurev = getRev(device, silent)
|
||||
if str(gpurev).startswith('0x'):
|
||||
gpurev = str(gpurev)[2:]
|
||||
|
||||
did = getDRMDeviceId(device, silent)
|
||||
nodeid = getNodeId(device, silent)
|
||||
guid = getGUID(device, silent)
|
||||
gfxVer = getTargetGfxVersion(device, silent)
|
||||
gfxRas = getRasEnablement(device, 'GFX', silent)
|
||||
sdmaRas = getRasEnablement(device, 'SDMA', silent)
|
||||
umcRas = getRasEnablement(device, 'UMC', silent)
|
||||
vbios = getVbiosVersion(device, silent)
|
||||
bus = getBus(device, silent)
|
||||
values['card%s' % (str(device))] = [device, gpuid, gpurev, gfxRas, sdmaRas, umcRas, vbios, bus]
|
||||
values['card%s' % (str(device))] = [device, nodeid, did, guid, gfxVer, gfxRas, sdmaRas,
|
||||
umcRas, vbios, bus]
|
||||
val_widths = {}
|
||||
for device in deviceList:
|
||||
val_widths[device] = [len(str(val)) + 2 for val in values['card%s' % (str(device))]]
|
||||
@@ -1919,11 +2007,25 @@ def showAllConciseHw(deviceList):
|
||||
for device in deviceList:
|
||||
for col in range(len(val_widths[device])):
|
||||
max_widths[col] = max(max_widths[col], val_widths[device][col])
|
||||
printLog(None, "".join(word.ljust(max_widths[col]) for col, word in zip(range(len(max_widths)), header)), None)
|
||||
device_output=""
|
||||
for device in deviceList:
|
||||
printLog(None, "".join(str(word).ljust(max_widths[col]) for col, word in
|
||||
zip(range(len(max_widths)), values['card%s' % (str(device))])), None)
|
||||
printLogSpacer()
|
||||
if (device + 1 != len(deviceList)):
|
||||
device_output += "".join(str(word).ljust(max_widths[col]) for col, word in
|
||||
zip(range(len(max_widths)), values['card%s' % (str(device))])) + "\n"
|
||||
else:
|
||||
device_output += "".join(str(word).ljust(max_widths[col]) for col, word in
|
||||
zip(range(len(max_widths)), values['card%s' % (str(device))]))
|
||||
|
||||
#################################
|
||||
# Display concise hardware info #
|
||||
#################################
|
||||
header_output = "".join(word.ljust(max_widths[col]) for col, word in zip(range(len(max_widths)), header))
|
||||
printLogSpacer(headerString, contentSizeToFit=len(header_output))
|
||||
printLogSpacer(' Concise Hardware Info ', contentSizeToFit=len(header_output))
|
||||
printLog(None, header_output, None)
|
||||
printLog(None, device_output, None)
|
||||
printLogSpacer(fill='=', contentSizeToFit=len(header_output))
|
||||
printLogSpacer(footerString, contentSizeToFit=len(header_output))
|
||||
|
||||
|
||||
def showBus(deviceList):
|
||||
@@ -2275,14 +2377,17 @@ def showEnergy(deviceList):
|
||||
|
||||
|
||||
def showId(deviceList):
|
||||
""" Display the device ID for a list of devices
|
||||
""" Display the device IDs for a list of devices
|
||||
|
||||
@param deviceList: List of DRM devices (can be a single-item list)
|
||||
"""
|
||||
printLogSpacer(' ID ')
|
||||
for device in deviceList:
|
||||
printLog(device, 'Device ID', getId(device))
|
||||
printLog(device, 'Device Rev', getRev(device))
|
||||
printLog(device, 'Device Name', '\t\t' + str(getDeviceName(device)))
|
||||
printLog(device, 'Device ID', '\t\t' + str(getDRMDeviceId(device)))
|
||||
printLog(device, 'Device Rev', '\t\t' + str(getRev(device)))
|
||||
printLog(device, 'Subsystem ID', '\t' + str(getSubsystemId(device)))
|
||||
printLog(device, 'GUID', '\t\t' + str(getGUID(device)))
|
||||
printLogSpacer()
|
||||
|
||||
|
||||
@@ -2475,6 +2580,7 @@ def showPids(verbose):
|
||||
vramUsage = 'UNKNOWN'
|
||||
sdmaUsage = 'UNKNOWN'
|
||||
cuOccupancy = 'UNKNOWN'
|
||||
cuOccupancyInvalid = 0xFFFFFFFF
|
||||
dv_indices = (c_uint32 * num_devices.value)()
|
||||
ret = rocmsmi.rsmi_compute_process_gpus_get(int(pid), None, byref(num_devices))
|
||||
if rsmi_ret_ok(ret, metric='get_gpu_compute_process'):
|
||||
@@ -2490,7 +2596,8 @@ def showPids(verbose):
|
||||
if rsmi_ret_ok(ret, metric='get_compute_process_info_by_pid'):
|
||||
vramUsage = proc.vram_usage
|
||||
sdmaUsage = proc.sdma_usage
|
||||
cuOccupancy = proc.cu_occupancy
|
||||
if proc.cu_occupancy != cuOccupancyInvalid:
|
||||
cuOccupancy = proc.cu_occupancy
|
||||
else:
|
||||
logging.debug('Unable to fetch process info by PID')
|
||||
dataArray.append([pid, getProcessName(pid), str(gpuNumber), str(vramUsage), str(sdmaUsage), str(cuOccupancy)])
|
||||
@@ -2499,7 +2606,8 @@ def showPids(verbose):
|
||||
if rsmi_ret_ok(ret, metric='get_compute_process_info_by_pid'):
|
||||
vramUsage = proc.vram_usage
|
||||
sdmaUsage = proc.sdma_usage
|
||||
cuOccupancy = proc.cu_occupancy
|
||||
if proc.cu_occupancy != cuOccupancyInvalid:
|
||||
cuOccupancy = proc.cu_occupancy
|
||||
else:
|
||||
logging.debug('Unable to fetch process info by PID')
|
||||
dataArray.append([pid, getProcessName(pid), str(gpuNumber), str(vramUsage), str(sdmaUsage), str(cuOccupancy)])
|
||||
@@ -2578,126 +2686,41 @@ def showPowerPlayTable(deviceList):
|
||||
printLogSpacer()
|
||||
|
||||
|
||||
def showProductName(deviceList):
|
||||
""" Show the requested product name for a list of devices
|
||||
def showProduct(deviceList):
|
||||
""" Show the requested product information for a list of devices
|
||||
|
||||
@param deviceList: List of DRM devices (can be a single-item list)
|
||||
"""
|
||||
series = create_string_buffer(256)
|
||||
model = create_string_buffer(256)
|
||||
vendor = create_string_buffer(256)
|
||||
vbios = create_string_buffer(256)
|
||||
# sku = create_string_buffer(256)
|
||||
printLogSpacer(' Product Info ')
|
||||
for device in deviceList:
|
||||
# Retrieve card vendor
|
||||
ret = rocmsmi.rsmi_dev_vendor_name_get(device, vendor, 256)
|
||||
# Only continue if GPU vendor is AMD
|
||||
if rsmi_ret_ok(ret, device, 'get_vendor_name') and isAmdDevice(device):
|
||||
try:
|
||||
device_vendor = vendor.value.decode()
|
||||
except UnicodeDecodeError:
|
||||
printErrLog(device, "Unable to read device vendor")
|
||||
device_vendor = "N/A"
|
||||
# Retrieve the device series
|
||||
ret = rocmsmi.rsmi_dev_name_get(device, series, 256)
|
||||
if rsmi_ret_ok(ret, device, 'get_name'):
|
||||
try:
|
||||
device_series = series.value.decode()
|
||||
printLog(device, 'Card series', '\t\t' + device_series)
|
||||
except UnicodeDecodeError:
|
||||
printErrLog(device, "Unable to read card series")
|
||||
# Retrieve the device model
|
||||
ret = rocmsmi.rsmi_dev_subsystem_name_get(device, model, 256)
|
||||
if rsmi_ret_ok(ret, device, 'get_subsystem_name'):
|
||||
try:
|
||||
device_model = model.value.decode()
|
||||
# padHexValue is used for applications that expect 4-digit card models
|
||||
printLog(device, 'Card model', '\t\t' + padHexValue(device_model, 4))
|
||||
except UnicodeDecodeError:
|
||||
printErrLog(device, "Unable to read device model")
|
||||
printLog(device, 'Card vendor', '\t\t' + device_vendor)
|
||||
if isAmdDevice(device):
|
||||
# TODO: Retrieve the SKU using 'rsmi_dev_sku_get' from the LIB
|
||||
# ret = rocmsmi.rsmi_dev_sku_get(device, sku, 256)
|
||||
# if rsmi_ret_ok(ret, device) and sku.value.decode():
|
||||
# device_sku = sku.value.decode()
|
||||
# Retrieve the device SKU as a substring from VBIOS
|
||||
device_sku = ""
|
||||
ret = rocmsmi.rsmi_dev_vbios_version_get(device, vbios, 256)
|
||||
if ret == rsmi_status_t.RSMI_STATUS_NOT_SUPPORTED:
|
||||
device_sku = "Unsupported"
|
||||
printLog(device, 'Card SKU', '\t\t' + device_sku)
|
||||
elif rsmi_ret_ok(ret, device, 'get_vbios_version') and vbios.value.decode():
|
||||
# Device SKU is just the characters in between the two '-' in vbios_version
|
||||
if vbios.value.decode().count('-') == 2 and len(str(vbios.value.decode().split('-')[1])) > 1:
|
||||
device_sku = vbios.value.decode().split('-')[1]
|
||||
else:
|
||||
device_sku = 'unknown'
|
||||
printLog(device, 'Card SKU', '\t\t' + device_sku)
|
||||
else:
|
||||
printErrLog(device, "Unable to decode VBIOS value for device SKU")
|
||||
# Device SKU is just the characters in between the two '-' in vbios_version
|
||||
vbios = getVbiosVersion(device, True)
|
||||
device_sku = "N/A"
|
||||
if vbios.count('-') == 2 and len(str(vbios.split('-')[1])) > 1:
|
||||
device_sku = vbios.split('-')[1]
|
||||
|
||||
printLog(device, 'Card Series', '\t\t' + str(getDeviceName(device)))
|
||||
# Retrieve device ID from DRM and KFD
|
||||
printLog(device, 'Card Model', str('\t\t' + getDRMDeviceId(device)))
|
||||
printLog(device, 'Card Vendor', '\t\t' + getVendor(device))
|
||||
printLog(device, 'Card SKU', '\t\t' + device_sku)
|
||||
printLog(device, 'Subsystem ID', str('\t' + getSubsystemId(device)))
|
||||
printLog(device, 'Device Rev', str('\t\t' + getRev(device)))
|
||||
printLog(device, 'Node ID', str('\t\t' + str(getNodeId(device))))
|
||||
printLog(device, 'GUID', str('\t\t' + str(getGUID(device))))
|
||||
printLog(device, 'GFX Version', str('\t\t' + getTargetGfxVersion(device)))
|
||||
|
||||
else:
|
||||
vendor = getVendor(device)
|
||||
printLog(device, 'Incompatible device.\n' \
|
||||
'GPU[%s]\t\t: Expected vendor name: Advanced Micro Devices, Inc. [AMD/ATI]\n' \
|
||||
'GPU[%s]\t\t: Actual vendor name' % (device, device), vendor.value.decode())
|
||||
'GPU[%s]\t\t: Actual vendor name' % (device, device), vendor)
|
||||
printLogSpacer()
|
||||
|
||||
|
||||
def getDevProductInfo(device, silent=False):
|
||||
""" Show the requested product name for the device requested
|
||||
|
||||
@param device: Device we want to get the info for
|
||||
@param silent=Turn on to silence error output
|
||||
(you plan to handle manually). Default is off.
|
||||
"""
|
||||
|
||||
# Retrieve card vendor
|
||||
MAX_DESC_SIZE = 20
|
||||
device_series = "N/A"
|
||||
device_model = "N/A"
|
||||
gpu_revision = "N/A"
|
||||
device_list = {}
|
||||
vendor = create_string_buffer(MAX_BUFF_SIZE)
|
||||
ret = rocmsmi.rsmi_dev_vendor_name_get(device, vendor, MAX_BUFF_SIZE)
|
||||
# Only continue if GPU vendor is AMD
|
||||
if rsmi_ret_ok(ret, device, 'get_vendor_name', silent) and isAmdDevice(device):
|
||||
# Retrieve the device series
|
||||
series = create_string_buffer(MAX_BUFF_SIZE)
|
||||
ret = rocmsmi.rsmi_dev_name_get(device, series, MAX_BUFF_SIZE)
|
||||
if rsmi_ret_ok(ret, device, 'get_name', silent):
|
||||
try:
|
||||
device_series = series.value.decode()
|
||||
except UnicodeDecodeError:
|
||||
if not silent:
|
||||
printErrLog(device, "Unable to read card series")
|
||||
|
||||
# Retrieve the device model
|
||||
model = create_string_buffer(MAX_BUFF_SIZE)
|
||||
ret = rocmsmi.rsmi_dev_subsystem_name_get(device, model, MAX_BUFF_SIZE)
|
||||
if rsmi_ret_ok(ret, device, 'get_subsystem_name', silent):
|
||||
try:
|
||||
device_model = model.value.decode()
|
||||
device_model = padHexValue(device_model, 4)
|
||||
except UnicodeDecodeError:
|
||||
if not silent:
|
||||
printErrLog(device, "Unable to read device model")
|
||||
|
||||
try:
|
||||
gpu_revision = padHexValue(getRev(device), 2)
|
||||
except Exception as exc:
|
||||
if not silent:
|
||||
printErrLog(device, "Unable to read card revision %s" % (exc))
|
||||
|
||||
device_series_str = str(device_series[:MAX_DESC_SIZE])
|
||||
device_series_str = device_series_str.ljust(MAX_DESC_SIZE, ' ')
|
||||
device_model_str = str(('[' + device_model + ' : ' + gpu_revision + ']'))
|
||||
device_model_str = str(device_model_str[:MAX_DESC_SIZE])
|
||||
device_model_str = device_model_str.ljust(MAX_DESC_SIZE, ' ')
|
||||
device_list = {device : [device_series_str, device_model_str]}
|
||||
|
||||
return device_list
|
||||
|
||||
|
||||
def showProfile(deviceList):
|
||||
""" Display available Power Profiles for a list of devices.
|
||||
|
||||
@@ -3709,9 +3732,10 @@ def save(deviceList, savefilepath):
|
||||
|
||||
# The code below is for when this script is run as an executable instead of when imported as a module
|
||||
def isConciseInfoRequested(args):
|
||||
return len(sys.argv) == 1 or \
|
||||
is_concise_req = len(sys.argv) == 1 or \
|
||||
len(sys.argv) == 2 and (args.alldevices or (args.json or args.csv)) or \
|
||||
len(sys.argv) == 3 and (args.alldevices and (args.json or args.csv))
|
||||
return is_concise_req
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(
|
||||
@@ -3737,7 +3761,7 @@ if __name__ == '__main__':
|
||||
groupDisplayOpt.add_argument('--showhw', help='Show Hardware details', action='store_true')
|
||||
groupDisplayOpt.add_argument('-a', '--showallinfo', help='Show Temperature, Fan and Clock values',
|
||||
action='store_true')
|
||||
groupDisplayTop.add_argument('-i', '--showid', help='Show DEVICE ID', action='store_true')
|
||||
groupDisplayTop.add_argument('-i', '--showid', help='Show DEVICE IDs', action='store_true')
|
||||
groupDisplayTop.add_argument('-v', '--showvbios', help='Show VBIOS version', action='store_true')
|
||||
groupDisplayTop.add_argument('-e', '--showevents', help='Show event list', metavar='EVENT', type=str, nargs='*')
|
||||
groupDisplayTop.add_argument('--showdriverversion', help='Show kernel driver version', action='store_true')
|
||||
@@ -3746,7 +3770,7 @@ if __name__ == '__main__':
|
||||
groupDisplayTop.add_argument('--showmclkrange', help='Show mclk range', action='store_true')
|
||||
groupDisplayTop.add_argument('--showmemvendor', help='Show GPU memory vendor', action='store_true')
|
||||
groupDisplayTop.add_argument('--showsclkrange', help='Show sclk range', action='store_true')
|
||||
groupDisplayTop.add_argument('--showproductname', help='Show SKU/Vendor name', action='store_true')
|
||||
groupDisplayTop.add_argument('--showproductname', help='Show product details', action='store_true')
|
||||
groupDisplayTop.add_argument('--showserial', help='Show GPU\'s Serial Number', action='store_true')
|
||||
groupDisplayTop.add_argument('--showuniqueid', help='Show GPU\'s Unique ID', action='store_true')
|
||||
groupDisplayTop.add_argument('--showvoltagerange', help='Show voltage range', action='store_true')
|
||||
@@ -3929,7 +3953,7 @@ if __name__ == '__main__':
|
||||
|
||||
if not PRINT_JSON:
|
||||
print('\n')
|
||||
if not isConciseInfoRequested(args):
|
||||
if not isConciseInfoRequested(args) and args.showhw == False:
|
||||
printLogSpacer(headerString)
|
||||
|
||||
if args.showallinfo:
|
||||
@@ -4056,7 +4080,7 @@ if __name__ == '__main__':
|
||||
if args.showfwinfo or str(args.showfwinfo) == '[]':
|
||||
showFwInfo(deviceList, args.showfwinfo)
|
||||
if args.showproductname:
|
||||
showProductName(deviceList)
|
||||
showProduct(deviceList)
|
||||
if args.showxgmierr:
|
||||
showXgmiErr(deviceList)
|
||||
if args.shownodesbw:
|
||||
@@ -4193,7 +4217,7 @@ if __name__ == '__main__':
|
||||
devCsv = formatCsv(deviceList)
|
||||
print(devCsv)
|
||||
|
||||
if not isConciseInfoRequested(args):
|
||||
if not isConciseInfoRequested(args) and args.showhw == False:
|
||||
printLogSpacer(footerString)
|
||||
|
||||
rsmi_ret_ok(rocmsmi.rsmi_shut_down())
|
||||
|
||||
@@ -796,6 +796,20 @@ int main() {
|
||||
ret = rsmi_dev_target_graphics_version_get(i, &val_ui64);
|
||||
std::cout << "\t**Target Graphics Version: " << std::dec
|
||||
<< static_cast<uint64_t>(val_ui64) << "\n";
|
||||
ret = rsmi_dev_guid_get(i, &val_ui64);
|
||||
std::cout << "\t**GUID: " << std::dec
|
||||
<< static_cast<uint64_t>(val_ui64) << "\n";
|
||||
ret = rsmi_dev_node_id_get(i, &val_ui32);
|
||||
std::cout << "\t**Node ID: " << std::dec
|
||||
<< static_cast<uint32_t>(val_ui32) << "\n";
|
||||
char vbios_version[256];
|
||||
ret = rsmi_dev_vbios_version_get(i, vbios_version, 256);
|
||||
if (ret == RSMI_STATUS_SUCCESS) {
|
||||
std::cout << "\t**VBIOS Version: " << vbios_version << "\n";
|
||||
} else {
|
||||
std::cout << "\t**VBIOS Version: "
|
||||
<< amd::smi::getRSMIStatusString(ret, false) << "\n";
|
||||
}
|
||||
|
||||
char current_compute_partition[256];
|
||||
current_compute_partition[0] = '\0';
|
||||
@@ -988,18 +1002,10 @@ int main() {
|
||||
}
|
||||
std::cout << " ** Note: Values MAX'ed out (UINTX MAX are unsupported for the version in question) ** " << "\n";
|
||||
|
||||
|
||||
std::cout << "\n\n";
|
||||
print_test_header("GPU METRICS: Using direct APIs (newer)", i);
|
||||
metrics_table_header_t header_values;
|
||||
GPUMetricTempHbm_t hbm_values;
|
||||
GPUMetricVcnActivity_t vcn_values;
|
||||
GPUMetricJpegActivity_t jpeg_values;
|
||||
GPUMetricXgmiReadDataAcc_t xgmi_read_values;
|
||||
GPUMetricXgmiWriteDataAcc_t xgmi_write_values;
|
||||
GPUMetricCurrGfxClk_t curr_gfxclk_values;
|
||||
GPUMetricCurrSocClk_t curr_socclk_values;
|
||||
GPUMetricCurrVClk0_t curr_vclk0_values;
|
||||
GPUMetricCurrDClk0_t curr_dclk0_values;
|
||||
|
||||
ret = rsmi_dev_metrics_header_info_get(i, &header_values);
|
||||
std::cout << "\t[Metrics Header]" << "\n";
|
||||
@@ -1007,152 +1013,12 @@ int main() {
|
||||
std::cout << "\t -> content_revision : " << print_unsigned_int(header_values.content_revision) << "\n";
|
||||
std::cout << "\t--------------------" << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Temperature]" << "\n";
|
||||
ret = rsmi_dev_metrics_temp_edge_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_edge(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_hotspot_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_hotspot(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_mem_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_mem(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_vrgfx_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_vrgfx(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_vrsoc_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_vrsoc(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_vrmem_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_vrmem(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_hbm_get(i, &hbm_values);
|
||||
std::cout << "\t -> temp_hbm(): " << print_error_or_value(ret, hbm_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Power/Energy]" << "\n";
|
||||
ret = rsmi_dev_metrics_curr_socket_power_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_socket_power(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_energy_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> energy_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_socket_power_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_socket_power(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Utilization]" << "\n";
|
||||
ret = rsmi_dev_metrics_avg_gfx_activity_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_gfx_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_umc_activity_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_umc_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_mm_activity_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_mm_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_vcn_activity_get(i, &vcn_values);
|
||||
std::cout << "\t -> vcn_activity(): " << print_error_or_value(ret, vcn_values) << "\n";
|
||||
ret = rsmi_dev_metrics_jpeg_activity_get(i, &jpeg_values);
|
||||
std::cout << "\t -> jpeg_activity(): " << print_error_or_value(ret, jpeg_values) << "\n";
|
||||
ret = rsmi_dev_metrics_mem_activity_acc_get(i, &val_ui32);
|
||||
std::cout << "\t -> mem_activity_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
ret = rsmi_dev_metrics_gfx_activity_acc_get(i, &val_ui32);
|
||||
std::cout << "\t -> gfx_activity_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Average Clock]" << "\n";
|
||||
ret = rsmi_dev_metrics_avg_gfx_clock_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_gfx_clock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_soc_clock_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_soc_clock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_uclock_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_uclock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_vclock0_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_vclock0_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_dclock0_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_dclock0_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_vclock1_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_vclock1_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_dclock1_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_dclock1_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Clock]" << "\n";
|
||||
ret = rsmi_dev_metrics_curr_vclk1_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_vclock1(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_dclk1_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_dclock1(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_uclk_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_uclock(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_dclk0_get(i, &curr_dclk0_values);
|
||||
std::cout << "\t -> current_dclk0(): " << print_error_or_value(ret, curr_dclk0_values) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_gfxclk_get(i, &curr_gfxclk_values);
|
||||
std::cout << "\t -> current_gfxclk(): " << print_error_or_value(ret, curr_gfxclk_values) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_socclk_get(i, &curr_socclk_values);
|
||||
std::cout << "\t -> current_soc_clock(): " << print_error_or_value(ret, curr_socclk_values) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_vclk0_get(i, &curr_vclk0_values);
|
||||
std::cout << "\t -> current_vclk0(): " << print_error_or_value(ret, curr_vclk0_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Throttle]" << "\n";
|
||||
ret = rsmi_dev_metrics_indep_throttle_status_get(i, &val_ui64);
|
||||
std::cout << "\t -> indep_throttle_status(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_throttle_status_get(i, &val_ui32);
|
||||
std::cout << "\t -> throttle_status(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Gfx Clock Lock]" << "\n";
|
||||
ret = rsmi_dev_metrics_gfxclk_lock_status_get(i, &val_ui32);
|
||||
std::cout << "\t -> gfxclk_lock_status(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Fan Speed]" << "\n";
|
||||
ret = rsmi_dev_metrics_curr_fan_speed_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_fan_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_link_width_get(i, &val_ui16);
|
||||
std::cout << "\t -> pcie_link_width(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_link_speed_get(i, &val_ui16);
|
||||
std::cout << "\t -> pcie_link_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_bandwidth_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_bandwidth_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_bandwidth_inst_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_bandwidth_inst(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_l0_recov_count_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_l0_recov_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_replay_count_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_replay_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_replay_rover_count_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_replay_rollover_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_link_width_get(i, &val_ui16);
|
||||
std::cout << "\t -> xgmi_link_width(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_link_speed_get(i, &val_ui16);
|
||||
std::cout << "\t -> xgmi_link_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_read_data_get(i, &xgmi_read_values);
|
||||
std::cout << "\t -> xgmi_read_data(): " << print_error_or_value(ret, xgmi_read_values) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_write_data_get(i, &xgmi_write_values);
|
||||
std::cout << "\t -> xgmi_write_data(): " << print_error_or_value(ret, xgmi_write_values) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_nak_sent_count_acc_get(i, &val_ui32);
|
||||
std::cout << "\t -> pcie_nak_sent_count_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get(i, &val_ui32);
|
||||
std::cout << "\t -> pcie_nak_rcvd_count_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Voltage]" << "\n";
|
||||
ret = rsmi_dev_metrics_volt_soc_get(i, &val_ui16);
|
||||
std::cout << "\t -> voltage_soc(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_volt_gfx_get(i, &val_ui16);
|
||||
std::cout << "\t -> voltage_gfx(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_volt_mem_get(i, &val_ui16);
|
||||
std::cout << "\t -> voltage_mem(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Timestamp]" << "\n";
|
||||
ret = rsmi_dev_metrics_system_clock_counter_get(i, &val_ui64);
|
||||
std::cout << "\t -> system_clock_counter(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_firmware_timestamp_get(i, &val_ui64);
|
||||
std::cout << "\t -> firmware_timestamp(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[XCD CounterVoltage]" << "\n";
|
||||
ret = rsmi_dev_metrics_xcd_counter_get(i, &val_ui16);
|
||||
std::cout << "\t -> xcd_counter(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
std::cout << "\n\n";
|
||||
|
||||
|
||||
ret = rsmi_dev_perf_level_get(i, &pfl);
|
||||
CHK_AND_PRINT_RSMI_ERR_RET(ret)
|
||||
std::cout << "\t**Performance Level:" <<
|
||||
|
||||
+74
-1554
File diff suppressed because it is too large
Load Diff
@@ -2680,7 +2680,6 @@ rsmi_status_t Device::dev_read_gpu_metrics_header_data()
|
||||
LOG_TRACE(ostrstream);
|
||||
|
||||
// Check if/when metrics table needs to be refreshed.
|
||||
auto now_ts = actual_timestamp_in_secs();
|
||||
if ((!m_gpu_metrics_header.m_structure_size) ||
|
||||
(!m_gpu_metrics_header.m_format_revision) ||
|
||||
(!m_gpu_metrics_header.m_content_revision)) {
|
||||
|
||||
@@ -507,7 +507,9 @@ int GetProcessInfoForPID(uint32_t pid, rsmi_process_info_t *proc,
|
||||
// Collect count of compute units
|
||||
cu_count += kfd_node_map[gpu_id]->cu_count();
|
||||
} else {
|
||||
return err;
|
||||
//Some GFX revisions do not provide cu_occupancy debugfs method
|
||||
proc->cu_occupancy = CU_OCCUPANCY_INVALID;
|
||||
cu_count = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -982,15 +984,72 @@ int KFDNode::get_gfx_target_version(uint64_t *gfx_target_version) {
|
||||
*gfx_target_version = gfx_version;
|
||||
ss << __PRETTY_FUNCTION__
|
||||
<< " | File: " << properties_path
|
||||
<< " | Successfully read node #" << std::to_string(this->node_indx_)
|
||||
<< " | Read node: " << std::to_string(this->node_indx_)
|
||||
<< " for gfx_target_version"
|
||||
<< " | Data (gfx_target_version) *gfx_target_version = "
|
||||
<< " | Data (*gfx_target_version): "
|
||||
<< std::to_string(*gfx_target_version)
|
||||
<< " | return = " << std::to_string(ret)
|
||||
<< getRSMIStatusString(amd::smi::ErrnoToRsmiStatus(ret), false)
|
||||
<< " | ";
|
||||
LOG_DEBUG(ss);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Public interface for device
|
||||
// /sys/class/kfd/kfd/topology/nodes/*/gpu_id
|
||||
int KFDNode::get_gpu_id(uint64_t *gpu_id) {
|
||||
std::ostringstream ss;
|
||||
std::string gpuid_path = "/sys/class/kfd/kfd/topology/nodes/"
|
||||
+ std::to_string(this->node_indx_) + "/gpu_id";
|
||||
const uint64_t undefined_gpu_id = std::numeric_limits<uint64_t>::max();
|
||||
std::string gpu_id_string = "";
|
||||
*gpu_id = undefined_gpu_id;
|
||||
int ret = ReadSysfsStr(gpuid_path, &gpu_id_string);
|
||||
if (ret != 0 || gpu_id_string.empty()) {
|
||||
ss << __PRETTY_FUNCTION__
|
||||
<< " | File: " << gpuid_path
|
||||
<< " | Data (*gpu_id): empty or nullptr"
|
||||
<< " | Issue: Could not read node #" << std::to_string(this->node_indx_)
|
||||
<< ". KFD node was an unsupported node or value read was empty."
|
||||
<< " | Return: "
|
||||
<< getRSMIStatusString(amd::smi::ErrnoToRsmiStatus(ret), false)
|
||||
<< " | ";
|
||||
LOG_ERROR(ss);
|
||||
return ret;
|
||||
}
|
||||
*gpu_id = std::stoull(gpu_id_string);
|
||||
if (*gpu_id == 0) { // CPU node - return not supported
|
||||
*gpu_id = undefined_gpu_id;
|
||||
ret = ENOENT; // map to RSMI_STATUS_NOT_SUPPORTED
|
||||
}
|
||||
ss << __PRETTY_FUNCTION__
|
||||
<< " | File: " << gpuid_path
|
||||
<< " | Read node #: " << std::to_string(this->node_indx_)
|
||||
<< " | Data (*gpu_id): " << std::to_string(*gpu_id)
|
||||
<< " | Return: "
|
||||
<< getRSMIStatusString(amd::smi::ErrnoToRsmiStatus(ret), false)
|
||||
<< " | ";
|
||||
LOG_DEBUG(ss);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Public interface for device
|
||||
// /sys/class/kfd/kfd/topology/nodes/<node_id>
|
||||
int KFDNode::get_node_id(uint32_t *node_id) {
|
||||
std::ostringstream ss;
|
||||
int ret = 0;
|
||||
std::string nodeid_path = "/sys/class/kfd/kfd/topology/nodes/"
|
||||
+ std::to_string(this->node_indx_);
|
||||
ss << __PRETTY_FUNCTION__
|
||||
<< " | File: " << nodeid_path
|
||||
<< " | Read node #: " << std::to_string(this->node_indx_)
|
||||
<< " | Data (*node_id): " << std::to_string(*node_id)
|
||||
<< " | Return: "
|
||||
<< getRSMIStatusString(amd::smi::ErrnoToRsmiStatus(ret), false)
|
||||
<< " | ";
|
||||
*node_id = this->node_indx_;
|
||||
LOG_DEBUG(ss);
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace smi
|
||||
} // namespace amd
|
||||
|
||||
@@ -47,6 +47,7 @@
|
||||
#include <stddef.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
||||
@@ -119,6 +120,13 @@ auto print_error_or_value(std::string title, std::string func_name, const T& met
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
std::string print_unsigned_int(T value) {
|
||||
std::stringstream ss;
|
||||
ss << static_cast<uint64_t>(value | 0);
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
void TestGpuMetricsRead::Run(void) {
|
||||
rsmi_status_t err;
|
||||
@@ -133,8 +141,19 @@ void TestGpuMetricsRead::Run(void) {
|
||||
PrintDeviceHeader(i);
|
||||
|
||||
IF_VERB(STANDARD) {
|
||||
std::cout << "\n\n";
|
||||
std::cout << "\t**GPU METRICS: Using static struct (Backwards Compatibility):\n";
|
||||
|
||||
metrics_table_header_t header_values;
|
||||
auto ret = rsmi_dev_metrics_header_info_get(i, &header_values);
|
||||
if (ret == rsmi_status_t::RSMI_STATUS_SUCCESS) {
|
||||
std::cout << "\t[Metrics Header]" << "\n";
|
||||
std::cout << "\t -> format_revision : " << print_unsigned_int(header_values.format_revision) << "\n";
|
||||
std::cout << "\t -> content_revision : " << print_unsigned_int(header_values.content_revision) << "\n";
|
||||
std::cout << "\t--------------------" << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
rsmi_gpu_metrics_t smu;
|
||||
err = rsmi_dev_gpu_metrics_info_get(i, &smu);
|
||||
if (err != RSMI_STATUS_SUCCESS) {
|
||||
@@ -243,491 +262,11 @@ void TestGpuMetricsRead::Run(void) {
|
||||
// Verify api support checking functionality is working
|
||||
err = rsmi_dev_gpu_metrics_info_get(i, nullptr);
|
||||
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
auto val_ui16 = uint16_t(0);
|
||||
auto val_ui32 = uint32_t(0);
|
||||
auto val_ui64 = uint64_t(0);
|
||||
auto status_code(rsmi_status_t::RSMI_STATUS_SUCCESS);
|
||||
|
||||
std::cout << "\n\t**GPU METRICS: Using direct APIs (newer):\n";
|
||||
for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
|
||||
PrintDeviceHeader(i);
|
||||
|
||||
auto temp_edge_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_edge_get(i, &temp_edge_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_temp_edge_get", status_code);
|
||||
|
||||
auto temp_hotspot_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_hotspot_get(i, &temp_hotspot_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_temp_hotspot_get", status_code);
|
||||
|
||||
auto temp_mem_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_mem_get(i, &temp_mem_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_temp_mem_get", status_code);
|
||||
|
||||
auto temp_vrgfx_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_vrgfx_get(i, &temp_vrgfx_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_temp_vrgfx_get", status_code);
|
||||
|
||||
auto temp_vrsoc_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_vrsoc_get(i, &temp_vrsoc_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_temp_vrsoc_get", status_code);
|
||||
|
||||
auto temp_vrmem_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_vrmem_get(i, &temp_vrmem_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_temp_vrmem_get", status_code);
|
||||
|
||||
GPUMetricTempHbm_t temp_hbm_values{};
|
||||
status_code = rsmi_dev_metrics_temp_hbm_get(i, &temp_hbm_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_temp_hbm_get", status_code);
|
||||
|
||||
auto temp_curr_socket_power_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_socket_power_get(i, &temp_curr_socket_power_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_socket_power_get", status_code);
|
||||
|
||||
auto temp_energy_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_energy_acc_get(i, &temp_energy_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_energy_acc_get", status_code);
|
||||
|
||||
auto temp_avg_socket_power_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_socket_power_get(i, &temp_avg_socket_power_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_socket_power_get", status_code);
|
||||
|
||||
auto temp_avg_gfx_activity_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_gfx_activity_get(i, &temp_avg_gfx_activity_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_gfx_activity_get", status_code);
|
||||
|
||||
auto temp_avg_umc_activity_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_umc_activity_get(i, &temp_avg_umc_activity_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_umc_activity_get", status_code);
|
||||
|
||||
auto temp_avg_mm_activity_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_mm_activity_get(i, &temp_avg_mm_activity_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_mm_activity_get", status_code);
|
||||
|
||||
GPUMetricVcnActivity_t temp_vcn_values{};
|
||||
status_code = rsmi_dev_metrics_vcn_activity_get(i, &temp_vcn_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_vcn_activity_get", status_code);
|
||||
|
||||
GPUMetricJpegActivity_t temp_jpeg_values{};
|
||||
status_code = rsmi_dev_metrics_jpeg_activity_get(i, &temp_jpeg_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_jpeg_activity_get", status_code);
|
||||
|
||||
auto temp_mem_activity_accum_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_mem_activity_acc_get(i, &temp_mem_activity_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_mem_activity_acc_get", status_code);
|
||||
|
||||
auto temp_gfx_activity_accum_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_gfx_activity_acc_get(i, &temp_gfx_activity_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_gfx_activity_acc_get", status_code);
|
||||
|
||||
auto temp_avg_gfx_clock_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_gfx_clock_frequency_get(i, &temp_avg_gfx_clock_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_gfx_clock_frequency_get", status_code);
|
||||
|
||||
auto temp_avg_soc_clock_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_soc_clock_frequency_get(i, &temp_avg_soc_clock_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_soc_clock_frequency_get", status_code);
|
||||
|
||||
auto temp_avg_uclock_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_uclock_frequency_get(i, &temp_avg_uclock_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_uclock_frequency_get", status_code);
|
||||
|
||||
auto temp_avg_vclock0_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_vclock0_frequency_get(i, &temp_avg_vclock0_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_vclock0_frequency_get", status_code);
|
||||
|
||||
auto temp_avg_dclock0_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_dclock0_frequency_get(i, &temp_avg_dclock0_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_dclock0_frequency_get", status_code);
|
||||
|
||||
auto temp_avg_vclock1_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_vclock1_frequency_get(i, &temp_avg_vclock1_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_vclock1_frequency_get", status_code);
|
||||
|
||||
auto temp_avg_dclock1_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_dclock1_frequency_get(i, &temp_avg_dclock1_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_avg_dclock1_frequency_get", status_code);
|
||||
|
||||
auto temp_curr_vclk1_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_vclk1_get(i, &temp_curr_vclk1_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_vclk1_get", status_code);
|
||||
|
||||
auto temp_curr_dclk1_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_dclk1_get(i, &temp_curr_dclk1_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_dclk1_get", status_code);
|
||||
|
||||
auto temp_curr_uclk_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_uclk_get(i, &temp_curr_uclk_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_uclk_get", status_code);
|
||||
|
||||
GPUMetricCurrDClk0_t temp_curr_dclk0_values{};
|
||||
status_code = rsmi_dev_metrics_curr_dclk0_get(i, &temp_curr_dclk0_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_dclk0_get", status_code);
|
||||
|
||||
GPUMetricCurrGfxClk_t temp_curr_gfxclk_values{};
|
||||
status_code = rsmi_dev_metrics_curr_gfxclk_get(i, &temp_curr_gfxclk_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_gfxclk_get", status_code);
|
||||
|
||||
GPUMetricCurrSocClk_t temp_curr_socclk_values{};
|
||||
status_code = rsmi_dev_metrics_curr_socclk_get(i, &temp_curr_socclk_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_socclk_get", status_code);
|
||||
|
||||
GPUMetricCurrVClk0_t temp_curr_vclk0_values{};
|
||||
status_code = rsmi_dev_metrics_curr_vclk0_get(i, &temp_curr_vclk0_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_vclk0_get", status_code);
|
||||
|
||||
auto temp_indep_throttle_status_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_indep_throttle_status_get(i, &temp_indep_throttle_status_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_indep_throttle_status_get", status_code);
|
||||
|
||||
auto temp_throttle_status_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_throttle_status_get(i, &temp_throttle_status_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_throttle_status_get", status_code);
|
||||
|
||||
auto temp_gfxclk_lock_status_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_gfxclk_lock_status_get(i, &temp_gfxclk_lock_status_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_gfxclk_lock_status_get", status_code);
|
||||
|
||||
auto temp_curr_fan_speed_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_fan_speed_get(i, &temp_curr_fan_speed_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_curr_fan_speed_get", status_code);
|
||||
|
||||
auto temp_pcie_link_width_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_pcie_link_width_get(i, &temp_pcie_link_width_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_link_width_get", status_code);
|
||||
|
||||
auto temp_pcie_link_speed_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_pcie_link_speed_get(i, &temp_pcie_link_speed_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_link_speed_get", status_code);
|
||||
|
||||
auto temp_pcie_bandwidth_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_acc_get(i, &temp_pcie_bandwidth_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_bandwidth_acc_get", status_code);
|
||||
|
||||
auto temp_pcie_bandwidth_inst_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_inst_get(i, &temp_pcie_bandwidth_inst_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_bandwidth_inst_get", status_code);
|
||||
|
||||
auto temp_pcie_l0_recov_count_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_l0_recov_count_acc_get(i, &temp_pcie_l0_recov_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_l0_recov_count_acc_get", status_code);
|
||||
|
||||
auto temp_pcie_replay_count_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_replay_count_acc_get(i, &temp_pcie_replay_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_replay_count_acc_get", status_code);
|
||||
|
||||
auto temp_pcie_replay_rover_count_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_replay_rover_count_acc_get(i, &temp_pcie_replay_rover_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_replay_rover_count_acc_get", status_code);
|
||||
|
||||
auto temp_pcie_nak_sent_count_accum_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_pcie_nak_sent_count_acc_get(i, &temp_pcie_nak_sent_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_nak_sent_count_acc_get", status_code);
|
||||
|
||||
auto temp_pcie_nak_rcvd_count_accum_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get(i, &temp_pcie_nak_rcvd_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get", status_code);
|
||||
|
||||
auto temp_xgmi_link_width_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_xgmi_link_width_get(i, &temp_xgmi_link_width_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_xgmi_link_width_get", status_code);
|
||||
|
||||
auto temp_xgmi_link_speed_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_xgmi_link_speed_get(i, &temp_xgmi_link_speed_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_xgmi_link_speed_get", status_code);
|
||||
|
||||
GPUMetricXgmiReadDataAcc_t temp_xgmi_read_values{};
|
||||
status_code = rsmi_dev_metrics_xgmi_read_data_get(i, &temp_xgmi_read_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_xgmi_read_data_get", status_code);
|
||||
|
||||
GPUMetricXgmiWriteDataAcc_t temp_xgmi_write_values{};
|
||||
status_code = rsmi_dev_metrics_xgmi_write_data_get(i, &temp_xgmi_write_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_xgmi_write_data_get", status_code);
|
||||
|
||||
auto temp_voltage_soc_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_volt_soc_get(i, &temp_voltage_soc_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_volt_soc_get", status_code);
|
||||
|
||||
auto temp_voltage_gfx_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_volt_gfx_get(i, &temp_voltage_gfx_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_volt_gfx_get", status_code);
|
||||
|
||||
auto temp_voltage_mem_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_volt_mem_get(i, &temp_voltage_mem_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_volt_mem_get", status_code);
|
||||
|
||||
auto temp_system_clock_counter_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_system_clock_counter_get(i, &temp_system_clock_counter_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_system_clock_counter_get", status_code);
|
||||
|
||||
auto temp_firmware_timestamp_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_firmware_timestamp_get(i, &temp_firmware_timestamp_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_firmware_timestamp_get", status_code);
|
||||
|
||||
auto temp_xcd_counter_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_xcd_counter_get(i, &temp_xcd_counter_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
MetricResults.emplace("rsmi_dev_metrics_xcd_counter_get", status_code);
|
||||
|
||||
IF_VERB(STANDARD) {
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Temperature]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> temp_edge(): ", "rsmi_dev_metrics_temp_edge_get", temp_edge_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> temp_hotspot(): ", "rsmi_dev_metrics_temp_hotspot_get", temp_hotspot_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> temp_mem(): ", "rsmi_dev_metrics_temp_mem_get", temp_mem_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> temp_vrgfx(): ", "rsmi_dev_metrics_temp_vrgfx_get", temp_vrgfx_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> temp_vrsoc(): ", "rsmi_dev_metrics_temp_vrsoc_get", temp_vrsoc_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> temp_vrmem(): ", "rsmi_dev_metrics_temp_vrmem_get", temp_vrmem_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> temp_hbm[]: ", "rsmi_dev_metrics_temp_hbm_get", temp_hbm_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Power/Energy]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_socket_power(): ", "rsmi_dev_metrics_curr_socket_power_get", temp_curr_socket_power_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> energy_accum(): ", "rsmi_dev_metrics_energy_acc_get", temp_energy_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_socket_power(): ", "rsmi_dev_metrics_avg_socket_power_get", temp_avg_socket_power_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Utilization]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_gfx_activity(): ", "rsmi_dev_metrics_avg_gfx_activity_get", temp_avg_gfx_activity_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_umc_activity(): ", "rsmi_dev_metrics_avg_umc_activity_get", temp_avg_umc_activity_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_mm_activity(): ", "rsmi_dev_metrics_avg_mm_activity_get", temp_avg_mm_activity_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> vcn_activity[]: ", "rsmi_dev_metrics_vcn_activity_get", temp_vcn_values) << "\n";
|
||||
std::cout << print_error_or_value("\t -> jpeg_activity[]: ", "rsmi_dev_metrics_jpeg_activity_get", temp_jpeg_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << print_error_or_value("\t -> mem_activity_accum(): ", "rsmi_dev_metrics_mem_activity_acc_get", temp_mem_activity_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> gfx_activity_accum(): ", "rsmi_dev_metrics_gfx_activity_acc_get", temp_gfx_activity_accum_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Average Clock]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_gfx_clock_frequency(): ", "rsmi_dev_metrics_avg_gfx_clock_frequency_get", temp_avg_gfx_clock_freq_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_soc_clock_frequency(): ", "rsmi_dev_metrics_avg_soc_clock_frequency_get", temp_avg_soc_clock_freq_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_uclock_frequency(): ", "rsmi_dev_metrics_avg_uclock_frequency_get", temp_avg_uclock_freq_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_vclock0_frequency(): ", "rsmi_dev_metrics_avg_vclock0_frequency_get", temp_avg_vclock0_freq_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_dclock0_frequency(): ", "rsmi_dev_metrics_avg_dclock0_frequency_get", temp_avg_dclock0_freq_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_vclock1_frequency(): ", "rsmi_dev_metrics_avg_vclock1_frequency_get", temp_avg_vclock1_freq_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> average_dclock1_frequency(): ", "rsmi_dev_metrics_avg_dclock1_frequency_get", temp_avg_dclock1_freq_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Clock]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_vclock1(): ", "rsmi_dev_metrics_curr_vclk1_get", temp_curr_vclk1_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_dclock1(): ", "rsmi_dev_metrics_curr_dclk1_get", temp_curr_dclk1_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_uclock(): ", "rsmi_dev_metrics_curr_uclk_get", temp_curr_uclk_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_dclk0[]: ", "rsmi_dev_metrics_curr_dclk0_get", temp_curr_dclk0_values) << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_gfxclk[]: ", "rsmi_dev_metrics_curr_gfxclk_get", temp_curr_gfxclk_values) << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_soc_clock[]: ", "rsmi_dev_metrics_curr_socclk_get", temp_curr_socclk_values) << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_vclk0[]: ", "rsmi_dev_metrics_curr_vclk0_get", temp_curr_vclk0_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Throttle]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> indep_throttle_status(): ", "rsmi_dev_metrics_indep_throttle_status_get", temp_indep_throttle_status_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> throttle_status(): ", "rsmi_dev_metrics_throttle_status_get", temp_throttle_status_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Gfx Clock Lock]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> gfxclk_lock_status(): ", "rsmi_dev_metrics_gfxclk_lock_status_get", temp_gfxclk_lock_status_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Fan Speed]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> current_fan_speed(): ", "rsmi_dev_metrics_curr_fan_speed_get", temp_curr_fan_speed_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_link_width(): ", "rsmi_dev_metrics_pcie_link_width_get", temp_pcie_link_width_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_link_speed(): ", "rsmi_dev_metrics_pcie_link_speed_get", temp_pcie_link_speed_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_bandwidth_accum(): ", "rsmi_dev_metrics_pcie_bandwidth_acc_get", temp_pcie_bandwidth_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_bandwidth_inst(): ", "rsmi_dev_metrics_pcie_bandwidth_inst_get", temp_pcie_bandwidth_inst_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_l0_recov_count_accum(): ", "rsmi_dev_metrics_pcie_l0_recov_count_acc_get", temp_pcie_l0_recov_count_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_replay_count_accum(): ", "rsmi_dev_metrics_pcie_replay_count_acc_get", temp_pcie_replay_count_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_replay_rollover_count_accum(): ", "rsmi_dev_metrics_pcie_replay_rover_count_acc_get", temp_pcie_replay_rover_count_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_nak_sent_count_accum(): ", "rsmi_dev_metrics_pcie_nak_sent_count_acc_get", temp_pcie_nak_sent_count_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> pcie_nak_rcvd_count_accum(): ", "rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get", temp_pcie_nak_rcvd_count_accum_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> xgmi_link_width(): ", "rsmi_dev_metrics_xgmi_link_width_get", temp_xgmi_link_width_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> xgmi_link_speed(): ", "rsmi_dev_metrics_xgmi_link_speed_get", temp_xgmi_link_speed_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> xgmi_read_data[]: ", "rsmi_dev_metrics_xgmi_read_data_get", temp_xgmi_read_values) << "\n";
|
||||
std::cout << print_error_or_value("\t -> xgmi_write_data[]: ", "rsmi_dev_metrics_xgmi_write_data_get", temp_xgmi_write_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Voltage]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> voltage_soc(): ", "rsmi_dev_metrics_volt_soc_get", temp_voltage_soc_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> voltage_gfx(): ", "rsmi_dev_metrics_volt_gfx_get", temp_voltage_gfx_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> voltage_mem(): ", "rsmi_dev_metrics_volt_mem_get", temp_voltage_mem_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Timestamp]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> system_clock_counter(): ", "rsmi_dev_metrics_system_clock_counter_get", temp_system_clock_counter_value) << "\n";
|
||||
std::cout << print_error_or_value("\t -> firmware_timestamp(): ", "rsmi_dev_metrics_firmware_timestamp_get", temp_firmware_timestamp_value) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[XCD CounterVoltage]" << "\n";
|
||||
std::cout << print_error_or_value("\t -> xcd_counter(): ", "rsmi_dev_metrics_xcd_counter_get", temp_xcd_counter_value) << "\n";
|
||||
std::cout << "\n\n";
|
||||
auto temp_xcd_counter_value = uint16_t(0);
|
||||
err = rsmi_dev_metrics_xcd_counter_get(i, &temp_xcd_counter_value);
|
||||
if (err != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(err);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -167,930 +167,14 @@ void TestMeasureApiExecutionTime::Run(void) {
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
//Test execution time for each individual gpu metric
|
||||
auto val_ui16 = uint16_t(0);
|
||||
auto val_ui32 = uint32_t(0);
|
||||
auto val_ui64 = uint64_t(0);
|
||||
GPUMetricTempHbm_t temp_hbm_values;
|
||||
GPUMetricVcnActivity_t temp_vcn_values;
|
||||
GPUMetricJpegActivity_t temp_jpeg_values;
|
||||
GPUMetricCurrDClk0_t temp_curr_dclk0_values;
|
||||
GPUMetricCurrGfxClk_t temp_curr_gfxclk_values;
|
||||
GPUMetricCurrSocClk_t temp_curr_socclk_values;
|
||||
GPUMetricCurrVClk0_t temp_curr_vclk0_values;
|
||||
GPUMetricXgmiReadDataAcc_t temp_xgmi_read_values;
|
||||
GPUMetricXgmiWriteDataAcc_t temp_xgmi_write_values;
|
||||
auto status_code(rsmi_status_t::RSMI_STATUS_SUCCESS);
|
||||
|
||||
start = std::chrono::high_resolution_clock::now();
|
||||
auto start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_edge_get(dv_ind, &val_ui16);
|
||||
}
|
||||
auto stop_api = std::chrono::high_resolution_clock::now();
|
||||
auto duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_edge_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_hotspot_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_hotspot_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_mem_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_mem_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_vrgfx_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_vrgfx_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_vrsoc_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_vrsoc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_vrmem_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_vrmem_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_hbm_get(dv_ind, &temp_hbm_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_hbm_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_socket_power_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_socket_power_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_energy_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_energy_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_socket_power_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_socket_power_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_gfx_activity_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_gfx_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_umc_activity_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_umc_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_mm_activity_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_mm_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_vcn_activity_get(dv_ind, &temp_vcn_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_vcn_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_jpeg_activity_get(dv_ind, &temp_jpeg_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_jpeg_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_mem_activity_acc_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_mem_activity_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_gfx_activity_acc_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_gfx_activity_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_gfx_clock_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_gfx_clock_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_soc_clock_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_soc_clock_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_uclock_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_uclock_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_vclock0_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_vclock0_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_dclock0_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_dclock0_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_vclock1_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_vclock1_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_dclock1_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_dclock1_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_vclk1_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_vclk1_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_dclk1_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_dclk1_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_uclk_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_uclk_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_dclk0_get(dv_ind, &temp_curr_dclk0_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_dclk0_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_gfxclk_get(dv_ind, &temp_curr_gfxclk_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_gfxclk_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_socclk_get(dv_ind, &temp_curr_socclk_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_socclk_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_vclk0_get(dv_ind, &temp_curr_vclk0_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_vclk0_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_indep_throttle_status_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_indep_throttle_status_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_throttle_status_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_throttle_status_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_gfxclk_lock_status_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_gfxclk_lock_status_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_fan_speed_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_fan_speed_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_link_width_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_link_width_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_link_speed_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_link_speed_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_bandwidth_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_inst_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_bandwidth_inst_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_l0_recov_count_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_l0_recov_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_replay_count_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_replay_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_replay_rover_count_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_replay_rover_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_nak_sent_count_acc_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_nak_sent_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_link_width_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_link_width_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_link_speed_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_link_speed_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_read_data_get(dv_ind, &temp_xgmi_read_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_read_data_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_write_data_get(dv_ind, &temp_xgmi_write_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_write_data_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_volt_soc_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_volt_soc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_volt_gfx_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_volt_gfx_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_volt_mem_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_volt_mem_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_system_clock_counter_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_system_clock_counter_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_firmware_timestamp_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_firmware_timestamp_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xcd_counter_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
auto stop_api = std::chrono::high_resolution_clock::now();
|
||||
auto duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
@@ -1105,10 +189,9 @@ void TestMeasureApiExecutionTime::Run(void) {
|
||||
stop = std::chrono::high_resolution_clock::now();
|
||||
duration = std::chrono::duration_cast<std::chrono::microseconds>(stop - start);
|
||||
if (!skip) {
|
||||
const auto kTOTAL_GPU_METRICS_APIS = uint16_t(57);
|
||||
std::cout << "\rTotal execution time (All APIs): "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * (repeat * kTOTAL_GPU_METRICS_APIS));
|
||||
EXPECT_LT(duration_api.count(), (500 * repeat));
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "============================================================================" << std::endl;
|
||||
|
||||
@@ -206,12 +206,33 @@ void TestSysInfoRead::Run(void) {
|
||||
|
||||
err = rsmi_dev_target_graphics_version_get(i, &val_ui64);
|
||||
IF_VERB(STANDARD) {
|
||||
std::cout << "\t**Graphics Target version: " << std::dec
|
||||
std::cout << "\t**Target GFX version: " << std::dec
|
||||
<< val_ui64 << "\n";
|
||||
}
|
||||
EXPECT_EQ(err, RSMI_STATUS_SUCCESS);
|
||||
EXPECT_NE(val_ui64, std::numeric_limits<uint64_t>::max());
|
||||
err = rsmi_dev_target_graphics_version_get(i, nullptr);
|
||||
EXPECT_EQ(err, RSMI_STATUS_INVALID_ARGS);
|
||||
|
||||
err = rsmi_dev_guid_get(i, &val_ui64);
|
||||
IF_VERB(STANDARD) {
|
||||
std::cout << "\t**GUID: " << std::dec
|
||||
<< val_ui64 << "\n";
|
||||
}
|
||||
EXPECT_EQ(err, RSMI_STATUS_SUCCESS);
|
||||
EXPECT_NE(val_ui64, std::numeric_limits<uint64_t>::max());
|
||||
err = rsmi_dev_guid_get(i, nullptr);
|
||||
EXPECT_EQ(err, RSMI_STATUS_INVALID_ARGS);
|
||||
|
||||
err = rsmi_dev_node_id_get(i, &val_ui32);
|
||||
IF_VERB(STANDARD) {
|
||||
std::cout << "\t**Node ID: " << std::dec
|
||||
<< val_ui32 << "\n";
|
||||
}
|
||||
EXPECT_EQ(err, RSMI_STATUS_SUCCESS);
|
||||
EXPECT_NE(val_ui32, std::numeric_limits<uint32_t>::max());
|
||||
err = rsmi_dev_node_id_get(i, nullptr);
|
||||
EXPECT_EQ(err, RSMI_STATUS_INVALID_ARGS);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
Viittaa uudesa ongelmassa
Block a user