pax_global_header 0000666 0000000 0000000 00000000064 13546003346 0014516 g ustar 00root root 0000000 0000000 52 comment=7f02f6e90a00b2f8058e762fc40f80c3571ea610
amdgpu-utils-2.6.0/ 0000775 0000000 0000000 00000000000 13546003346 0014136 5 ustar 00root root 0000000 0000000 amdgpu-utils-2.6.0/GPUmodules/ 0000775 0000000 0000000 00000000000 13546003346 0016162 5 ustar 00root root 0000000 0000000 amdgpu-utils-2.6.0/GPUmodules/GPUmodule.py 0000775 0000000 0000000 00000161166 13546003346 0020413 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
"""GPUmodules - classes used in amdgpu-utils
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['Craig Echt - Testing, Debug, and Verification']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-utils'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import re
import subprocess
import shlex
import os
import sys
from pathlib import Path
from uuid import uuid4
import glob
import shutil
try:
from GPUmodules import env
except:
import env
try:
from GPUmodules import PCImodule
except:
import PCImodule
class GPU_ITEM:
"""An object to store GPU details."""
# GPU Frequency/Voltage Control Type: 0 = None, 1 = P-states, 2 = Curve
def __init__(self, item_id):
self.uuid = item_id
self.card_num = -1
self.card_path = ''
self.hwmon_path = ''
self.compatible = True
time_0 = env.gut_const.now(env.gut_const.USELTZ)
self.energy = {'t0': time_0, 'tn': time_0, 'cummulative': 0.0}
self.hwmon_disabled = []
self.params = {'uuid': item_id,
'card_num': '',
'pcie_id': '',
'driver': '',
'gpu_type': 0,
'id': {'vendor': '', 'device': '', 'subsystem_vendor': '', 'subsystem_device': ''},
'model_device_decode': 'UNDETERMINED',
'model': '',
'model_short': '',
'model_display': '',
'card_path': '',
'hwmon_path': '',
'energy': 0.0,
'power': -1,
'power_cap': -1,
'power_cap_range': [-1, -1],
'fan_enable': -1,
'pwm_mode': [-1, 'UNK'],
'fan_pwm': -1,
'fan_speed': -1,
'fan_speed_range': [-1, -1],
'fan_pwm_range': [-1, -1],
'fan_target': -1,
'temp': -1,
'temp_crit': -1,
'vddgfx': -1,
'vddc_range': ['', ''],
'loading': -1,
'mclk_ps': -1,
'mclk_f': '',
'mclk_f_range': ['', ''],
'sclk_ps': -1,
'sclk_f': '',
'sclk_f_range': ['', ''],
'link_spd': '',
'link_wth': '',
'ppm': '',
'power_dpm_force': '',
'vbios': ''}
self.clinfo = {'device_name': '',
'device_version': '',
'driver_version': '',
'opencl_version': '',
'pcie_id': '',
'max_cu': '',
'simd_per_cu': '',
'simd_width': '',
'simd_ins_width': '',
'max_mem_allocation': '',
'max_wi_dim': '',
'max_wi_sizes': '',
'max_wg_size': '',
'prf_wg_multiple': ''}
self.sclk_state = {} # {'1': ['Mhz', 'mV']}
self.mclk_state = {} # {'1': ['Mhz', 'mV']}
self.vddc_curve = {} # {'1': ['Mhz', 'mV']}
self.vddc_curve_range = {} # {'1': {SCLK:['val1', 'val2'], VOLT: ['val1', 'val2']}
self.ppm_modes = {} # {'1': ['Name', 'Description']}
def set_params_value(self, name, value):
# update params dictionary
self.params[name] = value
if name == 'driver' and value != 'amdgpu':
self.compatible = False
if name == 'card_num':
self.card_num = value
if name == 'card_path':
self.card_path = value
if name == 'hwmon_path':
self.hwmon_path = value
def get_params_value(self, name):
# reads params dictionary
return self.params[name]
def set_clinfo_value(self, name, value):
# update clinfo dictionary
self.clinfo[name] = value
def get_clinfo_value(self, name):
# reads clinfo dictionary
return self.clinfo[name]
def copy_clinfo_values(self, gpu_item):
for k, v in gpu_item.clinfo.items():
self.clinfo[k] = v
@staticmethod
def get_all_params_labels():
# Human friendly labels for params keys
GPU_Param_Labels = {'uuid': 'UUID',
'id': 'Device ID',
'gpu_type': 'GPU Frequency/Voltage Control Type',
'model_device_decode': 'Decoded Device ID',
'model': 'Card Model',
'model_short': 'Short Card Model',
'model_display': 'Display Card Model',
'card_num': 'Card Number',
'card_path': 'Card Path',
'pcie_id': 'PCIe ID',
'driver': 'Driver',
'vbios': 'vBIOS Version',
'hwmon_path': 'HWmon',
'power': 'Current Power (W)',
'power_cap': 'Power Cap (W)',
'power_cap_range': 'Power Cap Range (W)'}
if env.gut_const.show_fans:
GPU_Param_Labels.update({'fan_enable': 'Fan Enable',
'pwm_mode': 'Fan PWM Mode',
'fan_pwm': 'Current Fan PWM (%)',
'fan_speed': 'Current Fan Speed (rpm)',
'fan_target': 'Fan Target Speed (rpm)',
'fan_speed_range': 'Fan Speed Range (rpm)',
'fan_pwm_range': 'Fan PWM Range (%)'})
GPU_Param_Labels.update({'temp': 'Current Temp (C)',
'temp_crit': 'Critical Temp (C)',
'vddgfx': 'Current VddGFX (mV)',
'vddc_range': 'Vddc Range',
'loading': 'Current Loading (%)',
'link_spd': 'Link Speed',
'link_wth': 'Link Width',
'sclk_ps': 'Current SCLK P-State',
'sclk_f': 'Current SCLK',
'sclk_f_range': 'SCLK Range',
'mclk_ps': 'Current MCLK P-State',
'mclk_f': 'Current MCLK',
'mclk_f_range': 'MCLK Range',
'ppm': 'Power Performance Mode',
'power_dpm_force': 'Power Force Performance Level'})
return GPU_Param_Labels
def get_all_clinfo_labels(self):
# Human friendly labels for clinfo keys
GPU_CLINFO_Labels = {'device_name': 'Device Name',
'device_version': 'Device Version',
'driver_version': 'Driver Version',
'opencl_version': 'Device OpenCL C Version',
'max_cu': 'Max Compute Units',
'simd_per_cu': 'SIMD per CU',
'simd_width': 'SIMD Width',
'simd_ins_width': 'SIMD Instruction Width',
'max_mem_allocation': 'CL Max Memory Allocation',
'max_wi_dim': 'Max Work Item Dimensions',
'max_wi_sizes': 'Max Work Item Sizes',
'max_wg_size': 'Max Work Group Size',
'prf_wg_multiple': 'Preferred Work Group Multiple'}
return GPU_CLINFO_Labels
def is_valid_power_cap(self, power_cap):
power_cap_range = self.get_params_value('power_cap_range')
# if power_cap >= power_cap_range[0] and power_cap <= power_cap_range[1]:
if power_cap_range[0] <= power_cap <= power_cap_range[1]:
return True
elif power_cap < 0:
# negative values will be interpreted as reset request
return True
else:
return False
def is_valid_fan_pwm(self, pwm_value):
pwm_range = self.get_params_value('fan_pwm_range')
# if pwm_value >= pwm_range[0] and pwm_value <= pwm_range[1]:
if pwm_range[0] <= pwm_value <= pwm_range[1]:
return True
elif pwm_value < 0:
# negative values will be interpreted as reset request
return True
else:
return False
def is_valid_mclk_pstate(self, pstate):
mclk_range = self.get_params_value('mclk_f_range')
mclk_min = int(re.sub(r'[a-z,A-Z]*', '', str(mclk_range[0])))
mclk_max = int(re.sub(r'[a-z,A-Z]*', '', str(mclk_range[1])))
if pstate[1] < mclk_min or pstate[1] > mclk_max:
return False
if self.get_params_value('gpu_type') != 2:
vddc_range = self.get_params_value('vddc_range')
vddc_min = int(re.sub(r'[a-z,A-Z]*', '', str(vddc_range[0])))
vddc_max = int(re.sub(r'[a-z,A-Z]*', '', str(vddc_range[1])))
if pstate[2] < vddc_min or pstate[2] > vddc_max:
return False
return True
def is_valid_sclk_pstate(self, pstate):
sclk_range = self.get_params_value('sclk_f_range')
sclk_min = int(re.sub(r'[a-z,A-Z]*', '', str(sclk_range[0])))
sclk_max = int(re.sub(r'[a-z,A-Z]*', '', str(sclk_range[1])))
if pstate[1] < sclk_min or pstate[1] > sclk_max:
return False
if self.get_params_value('gpu_type') != 2:
vddc_range = self.get_params_value('vddc_range')
vddc_min = int(re.sub(r'[a-z,A-Z]*', '', str(vddc_range[0])))
vddc_max = int(re.sub(r'[a-z,A-Z]*', '', str(vddc_range[1])))
if pstate[2] < vddc_min or pstate[2] > vddc_max:
return False
return True
def is_changed_sclk_pstate(self, pstate):
if int(re.sub(r'[a-z,A-Z]*', '', self.sclk_state[pstate[0]][0])) != pstate[1]:
return True
if self.get_params_value('gpu_type') != 2:
if int(re.sub(r'[a-z,A-Z]*', '', self.sclk_state[pstate[0]][1])) != pstate[2]:
return True
return False
def is_changed_mclk_pstate(self, pstate):
if int(re.sub(r'[a-z,A-Z]*', '', self.mclk_state[pstate[0]][0])) != pstate[1]:
return True
if self.get_params_value('gpu_type') != 2:
if int(re.sub(r'[a-z,A-Z]*', '', self.mclk_state[pstate[0]][1])) != pstate[2]:
return True
return False
def is_changed_vddc_curve_pt(self, pstate):
if int(re.sub(r'[a-z,A-Z]*', '', self.vddc_curve[pstate[0]][0])) != pstate[1]:
return True
if int(re.sub(r'[a-z,A-Z]*', '', self.vddc_curve[pstate[0]][1])) != pstate[2]:
return True
return False
def is_valid_vddc_curve_pts(self, curve_pts):
sclk_min = int(re.sub(r'[a-z,A-Z]*', '', str(self.vddc_curve_range[str(curve_pts[0])]['SCLK'][0])))
sclk_max = int(re.sub(r'[a-z,A-Z]*', '', str(self.vddc_curve_range[str(curve_pts[0])]['SCLK'][1])))
if curve_pts[1] < sclk_min or curve_pts[1] > sclk_max:
return False
#vddc_min = int(re.sub(r'[a-z,A-Z]*', '', str(self.vddc_curve_range[str(curve_pts[0])]['VOLT'][0])))
vddc_min = int(re.sub(r'[a-z,A-Z]*', '', str('650mV')))
vddc_max = int(re.sub(r'[a-z,A-Z]*', '', str(self.vddc_curve_range[str(curve_pts[0])]['VOLT'][1])))
if curve_pts[2] < vddc_min or curve_pts[2] > vddc_max:
return False
return True
def is_valid_pstate_list_str(self, ps_str, clk_name):
if ps_str == '':
return True
for ps in ps_str.split():
ps_list = self.get_pstate_list(clk_name)
try:
ps_list.index(int(ps))
except:
print('Error: Invalid pstate %s for %s.' % (ps, clk_name), file=sys.stderr)
return False
return True
def get_pstate_list_str(self, clk_name):
"""Get list of pstate numbers and return as a string."""
ps_list = self.get_pstate_list(clk_name)
return ','.join(str(ps) for ps in ps_list)
def get_pstate_list(self, clk_name):
"""Get list of pstate numbers and return as a list."""
if clk_name == 'SCLK':
return list(self.sclk_state.keys())
elif clk_name == 'MCLK':
return list(self.mclk_state.keys())
return []
def get_current_ppm_mode(self):
"""Read GPU ppm definitions and current settings from driver files."""
if self.get_params_value('power_dpm_force').lower() == 'auto':
return [-1, 'AUTO']
ppm_item = self.get_params_value('ppm').split('-')
return [int(ppm_item[0]), ppm_item[1]]
def read_gpu_ppm_table(self):
if not os.path.isfile(self.card_path + 'pp_power_profile_mode'):
print('Error getting power profile modes: ', self.card_path, file=sys.stderr)
sys.exit(-1)
with open(self.card_path + 'pp_power_profile_mode') as card_file:
for line in card_file:
linestr = line.strip()
# Check for mode name: begins with '[ ]+[0-9].*'
if re.fullmatch(r'[ ]+[0-9].*', line[0:3]):
linestr = re.sub(r'[ ]*[*]*:', ' ', linestr)
lineItems = linestr.split()
if env.gut_const.DEBUG: print('Debug: ppm line: %s' % linestr, file=sys.stderr)
if len(lineItems) < 2:
print('Error: invalid ppm: %s' % linestr, file=sys.stderr)
continue
if env.gut_const.DEBUG: print('Debug: valid ppm: %s' % linestr, file=sys.stderr)
self.ppm_modes[lineItems[0]] = lineItems[1:]
self.ppm_modes['-1'] = ['AUTO', 'Auto']
card_file.close()
if os.path.isfile(self.card_path + 'power_dpm_force_performance_level'):
with open(self.card_path + 'power_dpm_force_performance_level') as card_file:
self.set_params_value('power_dpm_force', card_file.readline().strip())
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'power_dpm_force_performance_level'),
file=sys.stderr)
self.compatible = False
def read_gpu_pstates(self):
"""Read GPU pstate definitions and parameter ranges from driver files.
Set card type based on pstate configuration"""
range_mode = False
type_unknown = True
if not os.path.isfile(self.card_path + 'pp_od_clk_voltage'):
print('Error getting pstates: ', self.card_path, file=sys.stderr)
self.compatible = False
return
if not os.path.isfile(self.card_path + 'power_dpm_state'):
print('Error: Looks like DPM is not enabled: %s does not exist' % (self.card_path + 'power_dpm_state'),
file=sys.stderr)
self.compatible = False
return
with open(self.card_path + 'pp_od_clk_voltage') as card_file:
for line in card_file:
line = line.strip()
if re.fullmatch('OD_.*:$', line):
if re.fullmatch('OD_.CLK:$', line):
clk_name = line.strip()
elif re.fullmatch('OD_VDDC_CURVE:$', line):
clk_name = line.strip()
elif re.fullmatch('OD_RANGE:$', line):
clk_name = ''
range_mode = True
continue
lineitems = line.split()
lineitems_len = len(lineitems)
if type_unknown:
if len(lineitems) == 3:
# type 1 GPU
self.set_params_value('gpu_type', 1)
elif len(lineitems) == 2:
self.set_params_value('gpu_type', 2)
type_unknown = False
if lineitems_len < 2 or lineitems_len > 3:
print('Error: Invalid pstate entry: %s' % (self.card_path + 'pp_od_clk_voltage'), file=sys.stderr)
#self.compatible = False
continue
if not range_mode:
lineitems[0] = int(re.sub(':', '', lineitems[0]))
if self.get_params_value('gpu_type') == 0 or self.get_params_value('gpu_type') == 1:
if clk_name == 'OD_SCLK:':
self.sclk_state[lineitems[0]] = [lineitems[1], lineitems[2]]
elif clk_name == 'OD_MCLK:':
self.mclk_state[lineitems[0]] = [lineitems[1], lineitems[2]]
else:
# Type 2
if clk_name == 'OD_SCLK:':
self.sclk_state[lineitems[0]] = [lineitems[1], '-']
elif clk_name == 'OD_MCLK:':
self.mclk_state[lineitems[0]] = [lineitems[1], '-']
elif clk_name == 'OD_VDDC_CURVE:':
self.vddc_curve[lineitems[0]] = [lineitems[1], lineitems[2]]
else:
if lineitems[0] == 'SCLK:':
self.set_params_value('sclk_f_range', [lineitems[1], lineitems[2]])
elif lineitems[0] == 'MCLK:':
self.set_params_value('mclk_f_range', [lineitems[1], lineitems[2]])
elif lineitems[0] == 'VDDC:':
self.set_params_value('vddc_range', [lineitems[1], lineitems[2]])
elif re.fullmatch('VDDC_CURVE_.*', line):
if len(lineitems) == 3:
index = re.sub(r'VDDC_CURVE_.*\[', '', lineitems[0])
index = re.sub(r'\].*','', index)
param = re.sub(r'VDDC_CURVE_', '', lineitems[0])
param = re.sub(r'\[[0-9]\]:', '', param)
if env.gut_const.DEBUG:
print('Curve: index: %s param: %s, val1 %s, val2: %s' %
(index, param, lineitems[1], lineitems[2]))
if index in self.vddc_curve_range.keys():
self.vddc_curve_range[index].update({param: [lineitems[1], lineitems[2]]})
else:
self.vddc_curve_range[index] = {}
self.vddc_curve_range[index].update({param: [lineitems[1], lineitems[2]]})
else:
print('Error: Invalid CURVE entry: %s' % (self.card_path + 'pp_od_clk_voltage'),
file=sys.stderr)
card_file.close()
def read_gpu_sensor_static_data(self):
"""Read GPU static data from HWMON path."""
try:
if os.path.isfile(self.hwmon_path + 'power1_cap_max'):
with open(self.hwmon_path + 'power1_cap_max') as hwmon_file:
power1_cap_max_value = int(int(hwmon_file.readline())/1000000)
hwmon_file.close()
if os.path.isfile(self.hwmon_path + 'power1_cap_min'):
with open(self.hwmon_path + 'power1_cap_min') as hwmon_file:
power1_cap_min_value = int(int(hwmon_file.readline())/1000000)
self.set_params_value('power_cap_range', [power1_cap_min_value, power1_cap_max_value])
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'power1_cap_min'), file=sys.stderr)
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'power1_cap_max'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.hwmon_path + 'temp1_crit'):
with open(self.hwmon_path + 'temp1_crit') as hwmon_file:
self.set_params_value('temp_crit', int(hwmon_file.readline())/1000)
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'temp1_crit'), file=sys.stderr)
self.compatible = False
# Get fan data if --no_fan flag is not set
if env.gut_const.show_fans:
if os.path.isfile(self.hwmon_path + 'fan1_max'):
with open(self.hwmon_path + 'fan1_max') as hwmon_file:
fan1_max_value = int(hwmon_file.readline())
hwmon_file.close()
if os.path.isfile(self.hwmon_path + 'fan1_min'):
with open(self.hwmon_path + 'fan1_min') as hwmon_file:
fan1_min_value = int(hwmon_file.readline())
self.set_params_value('fan_speed_range', [fan1_min_value, fan1_max_value])
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'fan1_min'), file=sys.stderr)
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'fan1_max'), file=sys.stderr)
#self.compatible = False
if os.path.isfile(self.hwmon_path + 'pwm1_max'):
with open(self.hwmon_path + 'pwm1_max') as hwmon_file:
pwm1_max_value = int(100*(int(hwmon_file.readline())/255))
hwmon_file.close()
if os.path.isfile(self.hwmon_path + 'pwm1_min'):
with open(self.hwmon_path + 'pwm1_min') as hwmon_file:
pwm1_pmin_value = int(100*(int(hwmon_file.readline())/255))
self.set_params_value('fan_pwm_range', [pwm1_pmin_value, pwm1_max_value])
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'pwm1_min'), file=sys.stderr)
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'pwm1_max'), file=sys.stderr)
self.compatible = False
except:
print('Error: problem reading static data from GPU HWMON: %s' % self.hwmon_path, file=sys.stderr)
self.compatible = False
def read_gpu_sensor_data(self):
"""Read GPU sensor data from HWMON path."""
try:
if os.path.isfile(self.hwmon_path + 'power1_cap'):
with open(self.hwmon_path + 'power1_cap') as hwmon_file:
self.set_params_value('power_cap', int(hwmon_file.readline())/1000000)
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'power1_cap'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.hwmon_path + 'power1_average'):
with open(self.hwmon_path + 'power1_average') as hwmon_file:
power_uw = int(hwmon_file.readline())
time_n = env.gut_const.now(env.gut_const.USELTZ)
self.set_params_value('power', int(power_uw)/1000000)
delta_hrs = ((time_n - self.energy['tn']).total_seconds())/3600
self.energy['tn'] = time_n
self.energy['cummulative'] += delta_hrs * power_uw/1000000000
self.set_params_value('energy', round(self.energy['cummulative'], 6))
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'power1_average'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.hwmon_path + 'temp1_input'):
with open(self.hwmon_path + 'temp1_input') as hwmon_file:
self.set_params_value('temp', int(hwmon_file.readline())/1000)
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'temp1_input'), file=sys.stderr)
self.compatible = False
except:
print('Error: Problem reading sensor [power/temp] from GPU HWMON: %s' % self.hwmon_path, file=sys.stderr)
self.compatible = False
# Get fan data if --no_fan flag is not set
if env.gut_const.show_fans:
# First non-critical fan data
# On error will be disabled, but still compatible
name_hwfile = ('fan1_enable', 'fan1_target', 'fan1_input')
name_param = ('fan_enable', 'fan_target', 'fan_speed')
for nh, np in zip(name_hwfile, name_param):
if not (nh in self.hwmon_disabled):
if os.path.isfile(self.hwmon_path + nh):
try:
with open(self.hwmon_path + nh) as hwmon_file:
self.set_params_value(np, hwmon_file.readline().strip())
hwmon_file.close()
except:
print('Warning: problem reading sensor [%s] data from GPU HWMON: %s' %
(nh, self.hwmon_path), file=sys.stderr)
self.hwmon_disabled.append(nh)
else:
print('Warning: HW file does not exist: %s' % (self.hwmon_path + nh), file=sys.stderr)
self.hwmon_disabled.append(nh)
# Now critical fan data
try:
if os.path.isfile(self.hwmon_path + 'pwm1_enable'):
with open(self.hwmon_path + 'pwm1_enable') as hwmon_file:
pwm_mode_value = int(hwmon_file.readline().strip())
if pwm_mode_value == 0:
pwm_mode_name = 'None'
elif pwm_mode_value == 1:
pwm_mode_name = 'Manual'
elif pwm_mode_value == 2:
pwm_mode_name = 'Dynamic'
self.set_params_value('pwm_mode', [pwm_mode_value, pwm_mode_name])
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'pwm1_enable'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.hwmon_path + 'pwm1'):
with open(self.hwmon_path + 'pwm1') as hwmon_file:
self.set_params_value('fan_pwm', int(100*(int(hwmon_file.readline())/255)))
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'pwm1'), file=sys.stderr)
self.compatible = False
except:
print('Error: problem reading sensor [pwm] data from GPU HWMON: %s' % self.hwmon_path, file=sys.stderr)
print('Try running with --no_fan option', file=sys.stderr)
self.compatible = False
try:
if os.path.isfile(self.hwmon_path + 'in0_label'):
with open(self.hwmon_path + 'in0_label') as hwmon_file:
if hwmon_file.readline().rstrip() == 'vddgfx':
with open(self.hwmon_path + 'in0_input') as hwmon_file2:
self.set_params_value('vddgfx', int(hwmon_file2.readline()))
hwmon_file.close()
else:
print('Error: HW file does not exist: %s' % (self.hwmon_path + 'in0_label'), file=sys.stderr)
self.compatible = False
except:
print('Error: problem reading sensor [in0_label] data from GPU HWMON: %s' % self.hwmon_path,
file=sys.stderr)
self.compatible = False
def read_gpu_driver_info(self):
"""Read GPU current driver information from card path directory."""
try:
# get all device ID information
if os.path.isfile(self.card_path + 'device'):
with open(self.card_path + 'device') as card_file:
device_id = card_file.readline().strip()
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'device'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'vendor'):
with open(self.card_path + 'vendor') as card_file:
vendor_id = card_file.readline().strip()
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'vendor'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'subsystem_device'):
with open(self.card_path + 'subsystem_device') as card_file:
subsystem_device_id = card_file.readline().strip()
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'subsystem_device'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'subsystem_vendor'):
with open(self.card_path + 'subsystem_vendor') as card_file:
subsystem_vendor_id = card_file.readline().strip()
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'subsystem_vendor'), file=sys.stderr)
self.compatible = False
# store device_id information
self.set_params_value('id', {'vendor': vendor_id,
'device': device_id,
'subsystem_vendor': subsystem_vendor_id,
'subsystem_device': subsystem_device_id})
# use device info to set model
if self.get_params_value('model_device_decode') == 'UNDETERMINED':
pcid = PCImodule.PCI_ID()
self.set_params_value('model_device_decode', pcid.get_model(self.get_params_value('id')))
# set display model to model_device_decode if shorter than model short
if (self.get_params_value('model_device_decode') != 'UNDETERMINED' and
len(self.get_params_value('model_device_decode')) < 1.2*len(self.get_params_value('model_short'))):
self.set_params_value('model_display', self.get_params_value('model_device_decode'))
else:
self.set_params_value('model_display', self.get_params_value('model_short'))
if os.path.isfile(self.card_path + 'vbios_version'):
with open(self.card_path + 'vbios_version') as card_file:
self.set_params_value('vbios', card_file.readline().strip())
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'vbios_version'), file=sys.stderr)
self.compatible = False
except:
print('Error: problem reading GPU driver information for Card Path: %s' % self.card_path, file=sys.stderr)
self.compatible = False
def read_gpu_state_data(self):
"""Read GPU current state information from card path directory."""
try:
if os.path.isfile(self.card_path + 'gpu_busy_percent'):
with open(self.card_path + 'gpu_busy_percent') as card_file:
self.set_params_value('loading', int(card_file.readline()))
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'gpu_busy_percent'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'current_link_speed'):
with open(self.card_path + 'current_link_speed') as card_file:
self.set_params_value('link_spd', card_file.readline().strip())
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'current_link_speed'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'current_link_width'):
with open(self.card_path + 'current_link_width') as card_file:
self.set_params_value('link_wth', card_file.readline().strip())
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'current_link_width'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'pp_dpm_sclk'):
with open(self.card_path + 'pp_dpm_sclk') as card_file:
for line in card_file:
if line[len(line)-2] == '*':
lineitems = line.split(sep=':')
self.set_params_value('sclk_ps', lineitems[0].strip())
self.set_params_value('sclk_f', lineitems[1].strip().strip('*'))
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'pp_dpm_sclk'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'pp_dpm_mclk'):
with open(self.card_path + 'pp_dpm_mclk') as card_file:
for line in card_file:
if line[len(line)-2] == '*':
lineitems = line.split(sep=':')
self.set_params_value('mclk_ps', lineitems[0].strip())
self.set_params_value('mclk_f', lineitems[1].strip().strip('*'))
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'pp_dpm_mclk'), file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'pp_power_profile_mode'):
with open(self.card_path + 'pp_power_profile_mode') as card_file:
for line in card_file:
linestr = line.strip()
searchObj = re.search(r'\*:', linestr)
if searchObj:
lineitems = linestr.split(sep='*:')
mode_str = lineitems[0].strip()
mode_str = re.sub(r'[ ]+', '-', mode_str)
self.set_params_value('ppm', mode_str)
break
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'pp_power_profile_mode'),
file=sys.stderr)
self.compatible = False
if os.path.isfile(self.card_path + 'power_dpm_force_performance_level'):
with open(self.card_path + 'power_dpm_force_performance_level') as card_file:
self.set_params_value('power_dpm_force', card_file.readline().strip())
card_file.close()
else:
print('Error: card file does not exist: %s' % (self.card_path + 'power_dpm_force_performance_level'),
file=sys.stderr)
self.compatible = False
except:
print('Error: getting data from GPU Card Path: %s' % self.card_path, file=sys.stderr)
self.compatible = False
def print_ppm_table(self):
"""print human friendly table of ppm parameters."""
print(f'Card: {self.card_path}')
print('Power Performance Mode: %s' % self.get_params_value('power_dpm_force'))
for k, v in self.ppm_modes.items():
print(str(k).rjust(3, ' ') + ': ' + v[0].rjust(15, ' '), end='')
for v_item in v[1:]:
print(str(v_item).rjust(18, ' '), end='')
print('')
print('')
def print_pstates(self):
"""print human friendly table of pstates."""
print(f'Card: {self.card_path}')
print('SCLK:' + ' '.ljust(19, ' ') + 'MCLK:')
for k, v in self.sclk_state.items():
print("{}: {} {}".format(str(k), v[0].ljust(8, ' '), v[1].ljust(8, ' ')), end='')
if k in self.mclk_state.keys():
print(" {}: {} {}".format(str(k), self.mclk_state[k][0].ljust(8, ' '),
self.mclk_state[k][1].ljust(8, ' ')))
else:
print('')
if self.get_params_value('gpu_type') == 2:
print('VDDC_CURVE')
for k, v in self.vddc_curve.items():
print('{}: {}'.format(str(k), v))
print('')
def print(self, clflag=False):
"""ls like listing function for GPU parameters."""
for i, (k, v) in enumerate(self.get_all_params_labels().items()):
if i == 1:
if self.compatible:
print(f'{__program_name__} Compatibility: Yes')
else:
print(f'{__program_name__} Compatibility: NO')
print(v + ': ' + str(self.get_params_value(k)))
if clflag:
for k, v in self.get_all_clinfo_labels().items():
print(v + ': ' + str(self.get_clinfo_value(k)))
print('')
def get_plot_data(self, gpu_list):
"""return a dictionary of dynamic gpu parameters
used by amdgpu-plot to populate a df.
"""
gpu_state = {'Time': str(self.energy['tn'].strftime('%c')).strip(), 'Card#': int(self.card_num)}
for table_item in gpu_list.table_parameters:
gpu_state_str = str(re.sub('M[Hh]z', '', str(self.get_params_value(table_item)))).strip()
if gpu_state_str.isnumeric():
gpu_state[table_item] = int(gpu_state_str)
elif re.fullmatch(r'[0-9]+.[0-9]*', gpu_state_str) or re.fullmatch(r'[0-9]*.[0-9]+', gpu_state_str):
gpu_state[table_item] = float(gpu_state_str)
elif gpu_state_str == '' or gpu_state_str == '-1' or gpu_state_str == 'NA' or gpu_state_str is None:
# new_line_item.append('NA')
gpu_state[table_item] = 'NA'
else:
gpu_state[table_item] = gpu_state_str
return gpu_state
class GPU_LIST:
"""A list of GPU_ITEMS indexed with uuid. It also contains a table of parameters used for tabular printouts"""
def __init__(self):
self.list = {}
if env.gut_const.show_fans:
self.table_parameters = ['model_display', 'loading', 'power', 'power_cap', 'energy', 'temp', 'vddgfx',
'fan_pwm', 'sclk_f', 'sclk_ps', 'mclk_f', 'mclk_ps', 'ppm']
self.table_param_labels = {'model_display': 'Model',
'loading': 'Load %',
'power': 'Power (W)',
'power_cap': 'Power Cap (W)',
'energy': 'Energy (kWh)',
'temp': 'T (C)',
'vddgfx': 'VddGFX (mV)',
'fan_pwm': 'Fan Spd (%)',
'sclk_f': 'Sclk (MHz)',
'sclk_ps': 'Sclk Pstate',
'mclk_f': 'Mclk (MHz)',
'mclk_ps': 'Mclk Pstate',
'ppm': 'Perf Mode'}
else:
self.table_parameters = ['model_display', 'loading', 'power', 'power_cap', 'energy', 'temp', 'vddgfx',
'sclk_f', 'sclk_ps', 'mclk_f', 'mclk_ps', 'ppm']
self.table_param_labels = {'model_display': 'Model',
'loading': 'Load %',
'power': 'Power (W)',
'power_cap': 'Power Cap (W)',
'energy': 'Energy (kWh)',
'temp': 'T (C)',
'vddgfx': 'VddGFX (mV)',
'sclk_f': 'Sclk (MHz)',
'sclk_ps': 'Sclk Pstate',
'mclk_f': 'Mclk (MHz)',
'mclk_ps': 'Mclk Pstate',
'ppm': 'Perf Mode'}
def get_gpu_list(self):
""" This method should be the first called to popultate the list with potentially compatible GPUs
It doesn't read any driver files, just checks their existence and sets them in the GPU_ITEM object.
"""
for card_name in glob.glob(env.gut_const.card_root + 'card?/device/pp_od_clk_voltage'):
gpu_item = GPU_ITEM(uuid4().hex)
gpu_item.set_params_value('card_path', card_name.replace('pp_od_clk_voltage', ''))
gpu_item.set_params_value('card_num',
card_name.replace('/device/pp_od_clk_voltage', '').replace(env.gut_const.card_root + 'card', ''))
hw_file_srch = glob.glob(os.path.join(gpu_item.card_path, env.gut_const.hwmon_sub) + '?')
if len(hw_file_srch) > 1:
print('More than one hwmon file found: ', hw_file_srch)
gpu_item.set_params_value('hwmon_path', hw_file_srch[0] + '/')
self.list[gpu_item.uuid] = gpu_item
def list_compatible_gpus(self):
compatible_list = GPU_LIST()
for k, v in self.list.items():
if v.compatible:
compatible_list.list[k] = v
return compatible_list
def get_gpu_card_list(self):
com_list = []
for k, v in self.list.items():
if v.compatible:
com_list.append(v.card_num)
return com_list
def read_gpu_ppm_table(self):
for k, v in self.list.items():
if v.compatible:
v.read_gpu_ppm_table()
def print_ppm_table(self):
for k, v in self.list.items():
v.print_ppm_table()
def read_gpu_pstates(self):
for k, v in self.list.items():
if v.compatible:
v.read_gpu_pstates()
def print_pstates(self):
for k, v in self.list.items():
v.print_pstates()
def read_gpu_state_data(self):
"""Read dynamic state data from GPUs"""
for k, v in self.list.items():
if v.compatible:
v.read_gpu_state_data()
def read_gpu_sensor_static_data(self):
"""Read dynamic sensor data from GPUs"""
for k, v in self.list.items():
if v.compatible:
v.read_gpu_sensor_static_data()
def read_gpu_sensor_data(self):
"""Read dynamic sensor data from GPUs"""
for k, v in self.list.items():
if v.compatible:
v.read_gpu_sensor_data()
def read_gpu_driver_info(self):
"""Read data static driver information for GPUs"""
for k, v in self.list.items():
if v.compatible:
v.read_gpu_driver_info()
def read_allgpu_pci_info(self):
""" This function uses lspci to get details for GPUs in the current list and
populates the data structure of each GPU_ITEM in the list.
It gets GPU name variants and gets the pcie slot ID for each card ID.
Special incompatible cases are determined here, like the Fiji Pro Duo.
This is the first function that should be called after the intial list is populated.
"""
pcie_ids = subprocess.check_output(
'lspci | grep -E \'^.*(VGA|Display).*\[AMD\/ATI\].*$\' | grep -Eo \'^([0-9a-fA-F]+:[0-9a-fA-F]+.[0-9a-fA-F])\'',
shell=True).decode().split()
if env.gut_const.DEBUG: print('Found %s GPUs' % len(pcie_ids))
for pcie_id in pcie_ids:
if env.gut_const.DEBUG: print('GPU: ', pcie_id)
lspci_items = subprocess.check_output('lspci -k -s ' + pcie_id, shell=True).decode().split('\n')
if env.gut_const.DEBUG: print(lspci_items)
# Get Long GPU Name
gpu_name = ''
# Line 0 name
gpu_name_0 = ''
gpu_name_items = lspci_items[0].split('[AMD/ATI]')
if len(gpu_name_items) < 2:
gpu_name_0 = 'UNKNOWN'
else:
gpu_name_0 = gpu_name_items[1]
# Line 1 name
gpu_name_1 = ''
gpu_name_items = lspci_items[1].split('[AMD/ATI]')
if len(gpu_name_items) < 2:
gpu_name_1 = 'UNKNOWN'
else:
gpu_name_1 = gpu_name_items[1]
# Check for Fiji ProDuo
searchObj = re.search('Fiji', gpu_name_0)
if searchObj:
searchObj = re.search('Radeon Pro Duo', gpu_name_1)
if searchObj:
gpu_name = 'Radeon Fiji Pro Duo'
if len(gpu_name) == 0:
if len(gpu_name_0) > len(gpu_name_1):
gpu_name = gpu_name_0
else:
gpu_name = gpu_name_1
if env.gut_const.DEBUG: print('gpu_name: %s' % gpu_name)
# Get Driver Name
driver_module_items = lspci_items[2].split(':')
if len(driver_module_items) < 2:
driver_module = 'UNKNOWN'
else:
driver_module = driver_module_items[1].strip()
# Find matching card
device_dirs = glob.glob(env.gut_const.card_root + 'card?/device')
for device_dir in device_dirs:
sysfspath = str(Path(device_dir).resolve())
if env.gut_const.DEBUG: print('device_dir: ', device_dir)
if env.gut_const.DEBUG: print('sysfspath: ', sysfspath)
if env.gut_const.DEBUG: print('pcie_id: ', pcie_id)
if env.gut_const.DEBUG: print('sysfspath-7: ', sysfspath[-7:])
if pcie_id == sysfspath[-7:]:
for k, v in self.list.items():
if v.card_path == device_dir + '/':
if gpu_name == 'Radeon Fiji Pro Duo': v.compatible = False
v.set_params_value('pcie_id', pcie_id)
v.set_params_value('driver', driver_module)
v.set_params_value('model', gpu_name)
model_short = re.sub(r'^.*\[', '', gpu_name)
model_short = re.sub(r'\].*$', '', model_short)
model_short = re.sub(r'.*Radeon', '', model_short)
v.set_params_value('model_short', model_short)
break
break
def read_gpu_opencl_data(self):
# Check access to clinfo command
if not shutil.which('/usr/bin/clinfo'):
print('OS Command [clinfo] not found. Use sudo apt-get install clinfo to install', file=sys.stderr)
return -1
cmd = subprocess.Popen(shlex.split('/usr/bin/clinfo --raw'), shell=False, stdout=subprocess.PIPE)
for line in cmd.stdout:
linestr = line.decode('utf-8').strip()
if len(linestr) < 1:
continue
if linestr[0] != '[':
continue
linestr = re.sub(r' [ ]*', ':-:', linestr)
searchObj = re.search('CL_DEVICE_NAME', linestr)
if searchObj:
# Found a new device
tmp_gpu = GPU_ITEM(uuid4().hex)
lineItem = linestr.split(':-:')
dev_str = lineItem[0].split('/')[1]
dev_num = int(re.sub(']', '', dev_str))
tmp_gpu.set_clinfo_value('device_name', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_VERSION', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('device_version', lineItem[2].strip())
continue
searchObj = re.search('CL_DRIVER_VERSION', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('driver_version', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_OPENCL_C_VERSION', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('opencl_version', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_TOPOLOGY_AMD', linestr)
if searchObj:
lineItem = linestr.split(':-:')
pcie_id_str = (lineItem[2].split()[1]).strip()
if env.gut_const.DEBUG: print(f'CL PCIE ID: [{pcie_id_str}]')
tmp_gpu.set_clinfo_value('pcie_id', pcie_id_str)
continue
searchObj = re.search('CL_DEVICE_MAX_COMPUTE_UNITS', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('max_cu', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('simd_per_cu', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_SIMD_WIDTH_AMD', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('simd_width', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('simd_ins_width', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_MAX_MEM_ALLOC_SIZE', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('max_mem_allocation', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('max_wi_dim', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_MAX_WORK_ITEM_SIZES', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('max_wi_sizes', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_MAX_WORK_GROUP_SIZE', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('max_wg_size', lineItem[2].strip())
continue
searchObj = re.search('CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE', linestr)
if searchObj:
lineItem = linestr.split(':-:')
tmp_gpu.set_clinfo_value('prf_wg_multiple', lineItem[2].strip())
continue
searchObj = re.search('CL_DEVICE_EXTENSIONS', linestr)
if searchObj:
# End of Device
if env.gut_const.DEBUG: print('finding gpu with pcie ID: ', tmp_gpu.get_clinfo_value('pcie_id'))
target_gpu_uuid = self.find_gpu_by_pcie_id(tmp_gpu.get_clinfo_value('pcie_id'))
self.list[target_gpu_uuid].copy_clinfo_values(tmp_gpu)
return 0
def find_gpu_by_pcie_id(self, pcie_id):
for k, v in self.list.items():
if v.get_params_value('pcie_id') == pcie_id:
return v.uuid
return -1
def num_gpus(self):
cnt = 0
for _, _ in self.list.items():
cnt += 1
return cnt
def num_compatible_gpus(self):
cnt = 0
for k, v in self.list.items():
if v.compatible:
cnt += 1
return cnt
def print(self, clflag=False):
for k, v in self.list.items():
v.print(clflag)
def num_table_rows(self):
return len(self.table_parameters)
def print_table(self):
num_gpus = self.num_gpus()
if num_gpus < 1:
return -1
print('┌', '─'.ljust(13, '─'), sep='', end='')
for _, _ in self.list.items():
print('┬', '─'.ljust(16, '─'), sep='', end='')
print('┐')
print('│', '\x1b[1;36m' + 'Card #'.ljust(13, ' ') + '\x1b[0m', sep='', end='')
for k, v in self.list.items():
print('│', '\x1b[1;36m' + ('card'+ v.get_params_value('card_num')).ljust(16, ' ') + '\x1b[0m',
sep='', end='')
print('│')
print('├', '─'.ljust(13, '─'), sep='', end='')
for _, _ in self.list.items():
print('┼', '─'.ljust(16, '─'), sep='', end='')
print('┤')
for table_item in self.table_parameters:
print('│', '\x1b[1;36m' + self.table_param_labels[table_item].ljust(13, ' ')[:13] + '\x1b[0m',
sep='', end='')
for k, v in self.list.items():
print('│', str(v.get_params_value(table_item)).ljust(16, ' ')[:16], sep='', end='')
print('│')
print('└', '─'.ljust(13, '─'), sep='', end='')
for _, _ in self.list.items():
print('┴', '─'.ljust(16, '─'), sep='', end='')
print('┘')
def print_log_header(self, log_file_ptr):
num_gpus = self.num_gpus()
if num_gpus < 1:
return -1
# Print Header
print('Time|Card#', end='', file=log_file_ptr)
for table_item in self.table_parameters:
print('|' + table_item, end='', file=log_file_ptr)
print('', file=log_file_ptr)
def print_log(self, log_file_ptr):
num_gpus = self.num_gpus()
if num_gpus < 1:
return -1
# Print Data
for k, v in self.list.items():
print(str(v.energy['tn'].strftime('%c')).strip() + '|' + str(v.card_num),
sep='', end='', file=log_file_ptr)
for table_item in self.table_parameters:
print('|', re.sub('M[Hh]z', '', str(v.get_params_value(table_item)).strip()),
sep='', end='', file=log_file_ptr)
print('', file=log_file_ptr)
def print_plot_header(self, log_file_ptr):
num_gpus = self.num_gpus()
if num_gpus < 1:
return -1
# Print Header
line_str_item = ['Time|Card#']
for table_item in self.table_parameters:
line_str_item.append('|' + table_item)
line_str_item.append('\n')
line_str = ''.join(line_str_item)
log_file_ptr.write(line_str.encode('utf-8'))
log_file_ptr.flush()
def print_plot(self, log_file_ptr):
num_gpus = self.num_gpus()
if num_gpus < 1:
return -1
# Print Data
for k, v in self.list.items():
line_str_item = [str(v.energy['tn'].strftime('%c')).strip() + '|' + str(v.card_num)]
for table_item in self.table_parameters:
line_str_item.append('|' + str(re.sub('M[Hh]z', '', str(v.get_params_value(table_item)))).strip())
line_str_item.append('\n')
line_str = ''.join(line_str_item)
log_file_ptr.write(line_str.encode('utf-8'))
log_file_ptr.flush()
def about():
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
if __name__ == '__main__':
about()
amdgpu-utils-2.6.0/GPUmodules/PCImodule.py 0000775 0000000 0000000 00000016755 13546003346 0020376 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
"""PCImodules - classes to parse PCI ID Repository file https://pci-ids.ucw.cz/
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-utils'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import re
import os
import sys
from datetime import datetime
from pathlib import Path
import shutil
import urllib.request
class PCI_ID:
def __init__(self, file_name='amd_pci_id.txt'):
self.pciid_url = 'https://pci-ids.ucw.cz/v2.2/pci.ids'
self.pciid_file = 'pci.ids'
self.amdgpu_utils_file = os.path.join(os.path.dirname(str(Path(__file__).resolve())), file_name)
try:
self.pci_id_file_ptr = open(self.amdgpu_utils_file, 'r')
except FileNotFoundError:
print('File [%s] not found. Exiting...' %
os.path.join(os.path.dirname(str(Path(__file__).resolve())), file_name))
sys.exit(-1)
except OSError:
print('Can not open [%s] to read. Exiting...' %
os.path.join(os.path.dirname(str(Path(__file__).resolve())), file_name))
sys.exit(-1)
def get_pciid_version(self, filename=''):
""" Get version information of specified pci.ids file.
Look for these lines:
# Version: 2019.02.23
# Date: 2019-02-23 03:15:02
return version details as a string
"""
if filename == '':
get_file_ptr = self.pci_id_file_ptr
else:
get_file_ptr = open(filename, 'r')
file_version = 'Unknown'
file_date = 'Unknown'
for line in get_file_ptr:
if line[0] != '#':
break
searchObj = re.search('Version:', line.strip())
if searchObj:
lineItem = line.split(':', 1)
if len(lineItem) > 1:
file_version = lineItem[1].strip()
searchObj = re.search('Date:', line.strip())
if searchObj:
lineItem = line.split(':', 1)
if len(lineItem) > 1:
file_date = lineItem[1].strip()
break
return 'Version: ' + file_version + ', Date: ' + file_date
def download_pciid(self):
""" download from https://pci-ids.ucw.cz/v2.2/pci.ids
return the new downloaded data's filename as a string
"""
file_name = self.pciid_file + datetime.utcnow().strftime('%m%d_%H%M%S') + '.txt'
with urllib.request.urlopen(self.pciid_url) as response, open(file_name, 'wb') as out_file:
shutil.copyfileobj(response, out_file)
return file_name
def update_pci_id(self, in_file_name):
self.pci_id_file_ptr.close()
self.extract_vendor_from_pci_id('0x1002', in_file_name, self.amdgpu_utils_file)
return 0
@staticmethod
def extract_vendor_from_pci_id(vendor, in_file_name, out_file_name=''):
""" For a given vendor id, extract all relevant entries.
"""
try:
in_file_ptr = open(in_file_name, 'r')
except FileNotFoundError:
print('File [%s] not found. Exiting...' % in_file_name)
sys.exit(-1)
except OSError:
print('Can not open [%s] to read. Exiting...' % in_file_name)
sys.exit(-1)
if out_file_name == '':
file_ptr = sys.stdout
else:
shutil.copy2(out_file_name, out_file_name + datetime.utcnow().strftime('%m%d_%H%M%S'))
try:
file_ptr = open(out_file_name, 'w')
except OSError:
print('Can not open [%s] to write. Exiting...' % out_file_name)
sys.exit(-1)
level = -1
vendor_match = False
for line_item in in_file_ptr:
line = line_item.rstrip()
if level == -1:
if len(line) < 4:
print(line, file=file_ptr)
continue
if line[0] == '#':
print(line, file=file_ptr)
continue
if re.fullmatch(r'^[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F].*', line):
level = 0
if vendor_match:
break
if vendor_match:
print(line, file=file_ptr)
continue
if line[:4] == vendor.replace('0x', ''):
vendor_match = True
print(line, file=file_ptr)
continue
in_file_ptr.close()
return
def get_model(self, dev_id):
""" For a device id dict of the format:
{"vendor":"","device":"","subsystem_vendor":"","subsystem_device":""}
search a PCI ID file extract from the PCI ID Repository and return the
resultant Model Name as a string.
"""
self.pci_id_file_ptr = open(self.amdgpu_utils_file, 'r')
model_str = ''
level = 0
for line_item in self.pci_id_file_ptr:
line = line_item.rstrip()
if len(line) < 4:
continue
if line[0] == '#':
continue
if level == 0:
if re.fullmatch(r'^[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F].*', line):
if line[:4] == dev_id['vendor'].replace('0x', ''):
level += 1
continue
elif level == 1:
if re.fullmatch(r'^[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F].*', line):
break
if re.fullmatch(r'^\t[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F].*', line):
if line[1:5] == dev_id['device'].replace('0x', ''):
model_str = line[5:]
level += 1
continue
elif level == 2:
if re.fullmatch(r'^[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F].*', line):
break
if re.fullmatch(r'^\t[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F].*', line):
break
if re.fullmatch(r'^\t\t[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F].*', line):
if line[2:6] == dev_id['subsystem_vendor'].replace('0x', ''):
if line[7:11] == dev_id['subsystem_device'].replace('0x', ''):
model_str = line[11:]
break
return model_str.strip()
def about():
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
if __name__ == '__main__':
about()
amdgpu-utils-2.6.0/GPUmodules/__init__.py 0000664 0000000 0000000 00000001512 13546003346 0020272 0 ustar 00root root 0000000 0000000 # This file is part the amdgpu-util package
#
# Copyright (C) 2019 RueiKe
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
from GPUmodules import GPUmodule
from GPUmodules import env
from GPUmodules import PCImodule
amdgpu-utils-2.6.0/GPUmodules/amd_pci_id.txt 0000664 0000000 0000000 00000311654 13546003346 0021005 0 ustar 00root root 0000000 0000000 #
# List of PCI ID's
#
# Version: 2019.10.02
# Date: 2019-10-02 03:15:02
#
# Maintained by Albert Pool, Martin Mares, and other volunteers from
# the PCI ID Project at https://pci-ids.ucw.cz/.
#
# New data are always welcome, especially if they are accurate. If you have
# anything to contribute, please follow the instructions at the web site.
#
# This file can be distributed under either the GNU General Public License
# (version 2 or higher) or the 3-clause BSD License.
#
# Vendors, devices and subsystems. Please keep sorted.
# Syntax:
# vendor vendor_name
# device device_name <-- single tab
# subvendor subdevice subsystem_name <-- two tabs
1002 Advanced Micro Devices, Inc. [AMD/ATI]
1304 Kaveri
1305 Kaveri
1306 Kaveri
1307 Kaveri
1308 Kaveri HDMI/DP Audio Controller
1309 Kaveri [Radeon R6/R7 Graphics]
130a Kaveri [Radeon R6 Graphics]
130b Kaveri [Radeon R4 Graphics]
130c Kaveri [Radeon R7 Graphics]
130d Kaveri [Radeon R6 Graphics]
130e Kaveri [Radeon R5 Graphics]
130f Kaveri [Radeon R7 Graphics]
1310 Kaveri
1311 Kaveri
1312 Kaveri
1313 Kaveri [Radeon R7 Graphics]
1314 Wrestler HDMI Audio
174b 1001 PURE Fusion Mini
1315 Kaveri [Radeon R5 Graphics]
1316 Kaveri [Radeon R5 Graphics]
1317 Kaveri
1318 Kaveri [Radeon R5 Graphics]
131b Kaveri [Radeon R4 Graphics]
131c Kaveri [Radeon R7 Graphics]
131d Kaveri [Radeon R6 Graphics]
13e9 Ariel
154c Kryptos
154e Garfield
1551 Arlene
1552 Pooky
1561 Anubis
15d8 Picasso
15dd Raven Ridge [Radeon Vega Series / Radeon Vega Mobile Series]
103c 83c6 Radeon Vega 8 Mobile
1458 d000 Radeon RX Vega 11
15de Raven/Raven2/Fenghuang HDMI/DP Audio Controller
15df Raven/Raven2/Fenghuang/Renoir Cryptographic Coprocessor
15ff Fenghuang [Zhongshan Subor Z+]
1607 Arden
1636 Renoir
1714 BeaverCreek HDMI Audio [Radeon HD 6500D and 6400G-6600G series]
103c 168b ProBook 4535s
3150 RV380/M24 [Mobility Radeon X600]
103c 0934 nx8220
3151 RV380 GL [FireMV 2400]
3152 RV370/M22 [Mobility Radeon X300]
3154 RV380/M24 GL [Mobility FireGL V3200]
3155 RV380 GL [FireMV 2400]
3171 RV380 GL [FireMV 2400] (Secondary)
3e50 RV380 [Radeon X600]
3e54 RV380 GL [FireGL V3200]
3e70 RV380 [Radeon X600] (Secondary)
4136 RS100 [Mobility IGP 320M]
4137 RS200 [Radeon IGP 340]
4144 R300 [Radeon 9500]
4146 R300 [Radeon 9700 PRO]
4147 R300 GL [FireGL Z1]
4148 R350 [Radeon 9800/9800 SE]
4150 RV350 [Radeon 9550/9600/X1050 Series]
1002 0002 R9600 Pro primary (Asus OEM for HP)
1002 0003 R9600 Pro secondary (Asus OEM for HP)
1002 4722 All-in-Wonder 2006 AGP Edition
1458 4024 GV-R96128D
148c 2064 R96A-C3N
148c 2066 R96A-C3N
174b 7c19 Atlantis Radeon 9600 Pro
174b 7c29 GC-R9600PRO
17ee 2002 Radeon 9600 256Mb Primary
18bc 0101 GC-R9600PRO (Primary)
4151 RV350 [Radeon 9600 Series]
1043 c004 A9600SE
174b 7c37 Radeon 9600SE 128M DDR V/D/VO
4152 RV360 [Radeon 9600/X1050 Series]
1002 0002 Radeon 9600XT
1002 4772 All-in-Wonder 9600 XT
1043 c002 Radeon 9600 XT TVD
1043 c01a A9600XT/TD
1462 9510 RX9600XT (MS-8951)
174b 7c29 Radeon 9600XT
1787 4002 Radeon 9600 XT
4153 RV350 [Radeon 9550]
1043 010c A9550GE/TD
1462 932c RX9550SE-TD128 (MS-8932)
4154 RV350 GL [FireGL T2]
4155 RV350 [Radeon 9600]
4157 RV350 GL [FireGL T2]
4158 68800AX [Graphics Ultra Pro PCI]
4164 R300 [Radeon 9500 PRO] (Secondary)
4165 R300 [Radeon 9700 PRO] (Secondary)
4166 R300 [Radeon 9700 PRO] (Secondary)
4168 RV350 [Radeon 9800 SE] (Secondary)
4170 RV350 [Radeon 9550/9600/X1050 Series] (Secondary)
1002 0003 R9600 Pro secondary (Asus OEM for HP)
1002 4723 All-in-Wonder 2006 AGP Edition (Secondary)
1458 4025 GV-R96128D (Secondary)
148c 2067 R96A-C3N (Secondary)
174b 7c28 GC-R9600PRO (Secondary)
17ee 2003 Radeon 9600 256Mb (Secondary)
18bc 0100 GC-R9600PRO (Secondary)
4171 RV350 [Radeon 9600] (Secondary)
1043 c005 A9600SE (Secondary)
174b 7c36 Radeon 9600SE 128M DDR V/D/VO (secondary)
4172 RV350 [Radeon 9600/X1050 Series] (Secondary)
1002 0003 Radeon 9600XT (Secondary)
1002 4773 All-in-Wonder 9600 XT (Secondary)
1043 c003 A9600XT (Secondary)
1043 c01b A9600XT/TD (Secondary)
174b 7c28 Radeon 9600XT (Secondary)
1787 4003 Radeon 9600 XT (Secondary)
4173 RV350 [Radeon 9550] (Secondary)
1043 010d A9550GE/TD (Secondary)
4242 R200 [All-In-Wonder Radeon 8500 DV]
1002 02aa Radeon 8500 AIW DV Edition
4243 R200 PCI Bridge [All-in-Wonder Radeon 8500DV]
4336 RS100 [Radeon IGP 320M]
1002 4336 Pavilion ze4300 ATI Radeon Mobility U1 (IGP 320 M)
103c 0024 Pavilion ze4400 builtin Video
161f 2029 eMachines M5312 builtin Video
4337 RS200M [Radeon IGP 330M/340M/345M/350M]
1014 053a ThinkPad R40e
103c 0850 Radeon IGP 345M
4341 SB200 AC97 Audio Controller
4342 SB200 PCI to PCI Bridge
4345 SB200 EHCI USB Controller
4346 Crayola 6 [XENOS Parent Die (XBOX 360)]
4347 SB200 OHCI USB Controller #1
4348 SB200 OHCI USB Controller #2
4349 SB200 IDE Controller
434c SB200 PCI to LPC Bridge
434d SB200 AC97 Modem Controller
4353 SB200 SMBus Controller
4354 215CT [Mach64 CT PCI]
4358 Mach64 CX [Graphics Xpression]
4361 SB300 AC'97 Audio Controller
4362 SB300 PCI to PCI Bridge
4363 SB300 SMBus Controller
4365 SB300 USB Controller (EHCI)
4367 SB300 USB Controller (EHCI)
4368 SB300 USB Controller (EHCI)
4369 SB300 IDE Controller
436c SB300 PCI to LPC Bridge
436d SB300 AC97 Modem Controller
436e SB300 Serial ATA Controller
4370 IXP SB400 AC'97 Audio Controller
1025 0079 Aspire 5024WLMMi
1025 0091 Aspire 5032WXMi
103c 2a05 Pavilion t3030.de Desktop PC
103c 308b MX6125
105b 0c81 Realtek ALC 653
107b 0300 MX6421
1462 0131 MS-1013 Notebook
4371 IXP SB4x0 PCI-PCI Bridge
103c 308b MX6125
1462 7217 Aspire L250
4372 IXP SB4x0 SMBus Controller
1025 0080 Aspire 5024WLMMi
103c 2a20 Pavilion t3030.de Desktop PC
103c 308b MX6125
1462 0131 MS-1013 Notebook
1462 7217 Aspire L250
4373 IXP SB4x0 USB2 Host Controller
1025 0080 Aspire 5024WLMMi
103c 2a20 Pavilion t3030.de Desktop PC
103c 308b MX6125
1462 7217 Aspire L250
4374 IXP SB4x0 USB Host Controller
103c 2a20 Pavilion t3030.de Desktop PC
103c 308b MX6125
1462 7217 Aspire L250
4375 IXP SB4x0 USB Host Controller
1025 0080 Aspire 5024WLMMi
103c 2a20 Pavilion t3030.de Desktop PC
103c 308b MX6125
1462 7217 Aspire L250
4376 IXP SB4x0 IDE Controller
1025 0080 Aspire 5024WLMMi
103c 2a20 Pavilion t3030.de Desktop PC
103c 308b MX6125
1462 0131 MS-1013 Notebook
1462 7217 Aspire L250
4377 IXP SB4x0 PCI-ISA Bridge
1025 0080 Aspire 5024WLMi
103c 2a20 Pavilion t3030.de Desktop PC
103c 308b MX6125
1462 7217 Aspire L250
4378 IXP SB400 AC'97 Modem Controller
1025 0080 Aspire 5024WLMMi
103c 308b MX6125
1462 0131 MS-1013 Notebook
4379 IXP SB4x0 Serial ATA Controller
1462 7141 Aspire L250
437a IXP SB400 Serial ATA Controller
1002 4379 4379 Serial ATA Controller
1002 437a 437A Serial ATA Controller
1462 7141 Aspire L250
14f1 8800 Leadtek WinFast TV2000XP Expert
437b IXP SB4x0 High Definition Audio Controller
1002 437b IXP SB4x0 High Definition Audio Controller
10cf 1326 Fujitsu Lifebook A3040
1734 10b8 Realtek High Definition Audio
4380 SB600 Non-Raid-5 SATA
103c 2813 DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1458 b003 GA-MA790FX-DS5 (rev. 1.0)
1458 b005 Gigabyte GA-MA69G-S3H Motherboard
1462 7327 K9AG Neo2
17f2 5999 KI690-AM2 Motherboard
4381 SB600 SATA Controller (RAID 5 mode)
4382 SB600 AC97 Audio
4383 SBx00 Azalia (Intel HDA)
1019 2120 A785GM-M
103c 1611 Pavilion DM1Z-3000
103c 280a DC5750 Microtower
1043 8230 M3A78-EH Motherboard
1043 836c M4A785TD Motherboard
1043 8410 M4A89GTD PRO/USB3 Motherboard
1043 841b M5A88-V EVO
1043 8445 M5A78L LE
105b 0e13 N15235/A74MX mainboard / AMD SB700
1179 ff50 Satellite P305D-S8995E
1458 a022 GA-MA770-DS3rev2.0 Motherboard
17f2 5000 KI690-AM2 Motherboard
4384 SBx00 PCI to PCI Bridge
4385 SBx00 SMBus Controller
1019 2120 A785GM-M
103c 1611 Pavilion DM1Z-3000
103c 280a DC5750 Microtower
1043 82ef M3A78-EH Motherboard
1043 8389 M4A785TD Motherboard
105b 0e13 N15235/A74MX mainboard / AMD SB700
1179 ff50 Satellite P305D-S8995E
1458 4385 GA-MA770-DS3rev2.0 Motherboard
1462 7368 K9AG Neo2
15d9 a811 H8DGU
174b 1001 PURE Fusion Mini
17f2 5000 KI690-AM2 Motherboard
4386 SB600 USB Controller (EHCI)
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
4387 SB600 USB (OHCI0)
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
4388 SB600 USB (OHCI1)
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
4389 SB600 USB (OHCI2)
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
438a SB600 USB (OHCI3)
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
438b SB600 USB (OHCI4)
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
438c SB600 IDE
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1458 5002 Gigabyte GA-MA69G-S3H Motherboard
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
438d SB600 PCI to LPC Bridge
103c 280a DC5750 Microtower
1179 ff50 Satellite P305D-S8995E
1462 7368 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
438e SB600 AC97 Modem
4390 SB7x0/SB8x0/SB9x0 SATA Controller [IDE mode]
1043 82ef M3A78-EH Motherboard
1043 8389 M4A785TD Motherboard
105b 0e13 N15235/A74MX mainboard / AMD SB700
1458 b002 GA-MA770-DS3rev2.0 Motherboard
1849 4390 Motherboard (one of many)
4391 SB7x0/SB8x0/SB9x0 SATA Controller [AHCI mode]
103c 1611 Pavilion DM1Z-3000
1043 82ef M3A78-EH Motherboard
1043 8443 M5A88-V EVO
1043 84dd M5A99X EVO (R1.0) SB950
105b 0e13 N15235/A74MX mainboard / AMD SB700
174b 1001 PURE Fusion Mini
4392 SB7x0/SB8x0/SB9x0 SATA Controller [Non-RAID5 mode]
105b 0e13 N15235/A74MX mainboard / AMD SB700
4393 SB7x0/SB8x0/SB9x0 SATA Controller [RAID5 mode]
4394 SB7x0/SB8x0/SB9x0 SATA Controller [AHCI mode]
4395 SB8x0/SB9x0 SATA Controller [Storage mode]
4396 SB7x0/SB8x0/SB9x0 USB EHCI Controller
1019 2120 A785GM-M
103c 1611 Pavilion DM1Z-3000
1043 82ef M3A78-EH Motherboard
1043 8443 M5A88-V EVO
105b 0e13 N15235/A74MX mainboard / AMD SB700
15d9 a811 H8DGU
174b 1001 PURE Fusion Mini
4397 SB7x0/SB8x0/SB9x0 USB OHCI0 Controller
1019 2120 A785GM-M
103c 1611 Pavilion DM1Z-3000
1043 82ef M3A78-EH Motherboard
1043 8443 M5A88-V EVO
105b 0e13 N15235/A74MX mainboard / AMD SB700
15d9 a811 H8DGU
174b 1001 PURE Fusion Mini
4398 SB7x0 USB OHCI1 Controller
1019 2120 A785GM-M
1043 82ef M3A78-EH Motherboard
105b 0e13 N15235/A74MX mainboard / AMD SB700
15d9 a811 H8DGU
4399 SB7x0/SB8x0/SB9x0 USB OHCI2 Controller
1019 2120 A785GM-M
1043 82ef M3A78-EH Motherboard
1043 8443 M5A88-V EVO
105b 0e13 N15235/A74MX mainboard / AMD SB700
174b 1001 PURE Fusion Mini
439c SB7x0/SB8x0/SB9x0 IDE Controller
1002 4392 MSI MS-7713 motherboard
1019 2120 A785GM-M
1043 82ef M3A78-EH Motherboard
105b 0e13 N15235/A74MX mainboard / AMD SB700
439d SB7x0/SB8x0/SB9x0 LPC host controller
1019 2120 A785GM-M
103c 1611 Pavilion DM1Z-3000
1043 82ef M3A78-EH Motherboard
1043 8443 M5A88-V EVO
105b 0e13 N15235/A74MX mainboard / AMD SB700
174b 1001 PURE Fusion Mini
43a0 SB700/SB800/SB900 PCI to PCI bridge (PCIE port 0)
43a1 SB700/SB800/SB900 PCI to PCI bridge (PCIE port 1)
43a2 SB900 PCI to PCI bridge (PCIE port 2)
43a3 SB900 PCI to PCI bridge (PCIE port 3)
4437 RS250 [Mobility Radeon 7000 IGP]
4554 210888ET [Mach64 ET]
4630 XENOS Parent Die (XBOX 360)
4631 XENOS Daughter Die (XBOX 360)
4654 Mach64 VT
4742 Rage 3 [3D Rage PRO AGP 2X]
1002 0040 Rage Pro Turbo AGP 2X
1002 0044 Rage Pro Turbo AGP 2X
1002 0061 Rage Pro AIW AGP 2X
1002 0062 Rage Pro AIW AGP 2X
1002 0063 Rage Pro AIW AGP 2X
1002 0080 Rage Pro Turbo AGP 2X
1002 0084 Rage Pro Turbo AGP 2X
1002 4742 Rage Pro Turbo AGP 2X
1002 8001 Rage Pro Turbo AGP 2X
1028 0082 Rage Pro Turbo AGP 2X
1028 4082 Optiplex GX1 Onboard Display Adapter
1028 8082 Rage Pro Turbo AGP 2X
1028 c082 Rage Pro Turbo AGP 2X
8086 4152 Xpert 98D AGP 2X
8086 464a Rage Pro Turbo AGP 2X
4744 Rage 3 [3D Rage PRO AGP 1X]
1002 4744 Rage Pro Turbo AGP
8086 4d55 Rage 3D Pro AGP 1X [Intel MU440EX]
4749 3D Rage PRO PCI
1002 0061 Rage Pro AIW
1002 0062 Rage Pro AIW
474d Rage XL AGP 2X
1002 0004 Xpert 98 RXL AGP 2X
1002 0008 Xpert 98 RXL AGP 2X
1002 0080 Rage XL AGP 2X
1002 0084 Xpert 98 AGP 2X
1002 474d Rage XL AGP
1033 806a Rage XL AGP
474e Rage XC AGP
1002 474e Rage XC AGP
474f Rage XL
1002 0008 Rage XL
1002 474f Rage XL
4750 3D Rage Pro PCI
1002 0040 Rage Pro Turbo
1002 0044 Rage Pro Turbo
1002 0080 Rage Pro Turbo
1002 0084 Rage Pro Turbo
1002 4750 Rage Pro Turbo
4752 Rage 3 [Rage XL PCI]
0e11 001e Proliant Rage XL
1002 0008 Rage XL
1002 4752 Proliant Rage XL
1002 8008 Rage XL
1014 0240 eServer xSeries server mainboard
1028 00ce PowerEdge 1400
1028 00d1 PowerEdge 2550
1028 00d9 PowerEdge 2500
1028 0134 PowerEdge 600SC
1028 014a PowerEdge 1750
1028 0165 PowerEdge 750
103c 10e1 NetServer Rage XL
103c 3208 ProLiant DL140 G2
107b 6400 6400 Server
1734 007a PRIMERGY RX/TX series onboard VGA
1734 1073 Primergy Econel 200 D2020 mainboard
8086 3411 SDS2 Mainboard
8086 3427 S875WP1-E mainboard
8086 5744 S845WD1-E mainboard
4753 Rage XC
1002 4753 Rage XC
4754 Mach64 GT/GT-B [3D Rage I/II]
4755 Mach64 GT-B [3D Rage II+ DVD]
4756 Rage 2 [3D Rage IIC PCI]
1002 4756 Rage IIC
4757 Rage 2 [3D Rage IIC AGP]
1002 4757 Rage IIC AGP
1028 0089 Rage 3D IIC
1028 008e PowerEdge 1300 onboard video
1028 4082 Rage 3D IIC
1028 8082 Rage 3D IIC
1028 c082 Rage 3D IIC
4758 Mach64 GX [WinTurbo]
4759 Rage 3 [3D Rage IIC PCI]
475a 3D Rage IIC AGP
1002 0084 Rage 3D Pro AGP 2x XPERT 98
1002 0087 Rage 3D IIC
1002 475a Rage IIC AGP
4845 Xilleon 220 HBIU for HDTV2
4846 Xilleon 220 IDE for HDTV2
4847 Xilleon 220 USB for HDTV2
4848 Xilleon 220 DAIO-0 for HDTV2
4849 Xilleon 220 DAIO-1 for HDTV2
484a Xilleon 220 LPC for HDTV2
4850 Xilleon 215 HBIU for X215
4851 Xilleon 215 IDE for X215
4852 Xilleon 215 USB for X215
4853 Xilleon 215 DAIO-0 for X215
4854 Xilleon 215 DAIO-1 for X215
4855 Xilleon 225 HBIU for X225
4856 Xilleon 225 IDE for X225
4857 Xilleon 225 USB for X225
4858 Xilleon 225 DAIO-0 for X225
4859 Xilleon 225 DAIO-1 for X225
4860 Xilleon 210 HBIU for X210
4861 Xilleon 210 IDE for X210
4862 Xilleon 210 USB for X210
4863 Xilleon 210 DAIO-0 for X210
4864 Xilleon 210 DAIO-1 for X210
4865 Xilleon 226 HBIU for X226
4866 Xilleon 226 IDE for X226
4867 Xilleon 226 USB for X226
4868 Xilleon 226 DAIO-0 for X226
4869 Xilleon 226 DAIO-1 for X226
486a Xilleon 240S HBIU for X240S
486b Xilleon 240H HBIU for X240H
486c Xilleon 240S USB for X240S
486d Xilleon 240H USB for X240H
486e Xilleon 250 USB 1.1 for X250
486f Xilleon 260 USB 1.1 for X260
4870 Xilleon 250 HBIU for X250
4871 Xilleon 250 IDE for X250
4872 Xilleon 234/235 HBIU for X234/X235
4873 Xilleon 244/245 HBIU for X244/X245
4874 Xilleon 234/235 USB 1.1 for X234/X235
4875 Xilleon 260 HBIU for X260
4876 Xilleon 260 IDE for X260
4877 Xilleon 244/245 USB 1.1 for X244/X245
4878 Xilleon 270 HBIU for X270
487b Xilleon 242 HBIU for X242
487d Xilleon 242 USB 1.1 for X242
4880 Xilleon 254 HBIU for X254
4881 Xilleon 254 USB 1.1 for X254
4882 Xilleon 255 HBIU for X255
4883 Xilleon 255 USB 1.1 for X255
4884 Xilleon 243 HBIU for X243
4885 Xilleon 243 USB 1.1 for X243
4886 Xilleon 233 HBIU for X233
4887 Xilleon 233 USB 1.1 for X233
4888 Xilleon 143 HBIU for X143
4889 Xilleon 143 HBIU for X143L
488a Xilleon 143 HBIU for X143S
4966 RV250 [Radeon 9000 Series]
10f1 0002 RV250 If [Tachyon G9000 PRO]
148c 2039 RV250 If [Radeon 9000 Pro "Evil Commando"]
1509 9a00 RV250 If [Radeon 9000 "AT009"]
1681 0040 RV250 If [3D prophet 9000]
174b 7176 Radeon 9000 Pro
174b 7192 RV250 If [Radeon 9000 "Atlantis"]
17af 2005 RV250 If [Excalibur Radeon 9000 Pro]
17af 2006 RV250 If [Excalibur Radeon 9000]
496e RV250 [Radeon 9000] (Secondary)
4a49 R420 [Radeon X800 PRO/GTO AGP]
174b 2620 R420 [Radeon X800 GTO AGP]
4a4a R420 [Radeon X800 GT AGP]
4a4b R420 [Radeon X800 AGP Series]
4a4d R420 GL [FireGL X3-256]
4a4e RV420/M18 [Mobility Radeon 9800]
4a4f R420 [Radeon X850 AGP]
4a50 R420 [Radeon X800 XT Platinum Edition AGP]
4a54 R420 [Radeon X800 VE AGP]
1002 4422 All-In-Wonder X800 VE AGP
4a69 R420 [Radeon X800 PRO/GTO] (Secondary)
4a6a R420 [Radeon X800] (Secondary)
4a6b R420 [Radeon X800 XT AGP] (Secondary)
4a70 R420 [Radeon X800 XT Platinum Edition AGP] (Secondary)
4a74 R420 [Radeon X800 VE] (Secondary)
4b49 R481 [Radeon X850 XT AGP]
4b4b R481 [Radeon X850 PRO AGP]
4b4c R481 [Radeon X850 XT Platinum Edition AGP]
4b69 R481 [Radeon X850 XT AGP] (Secondary)
4b6b R481 [Radeon X850 PRO AGP] (Secondary)
4b6c R481 [Radeon X850 XT Platinum Edition AGP] (Secondary)
4c42 Mach64 LT [3D Rage LT PRO AGP]
0e11 b0e7 Rage LT Pro (Compaq Presario 5240)
0e11 b0e8 Rage 3D LT Pro
0e11 b10e 3D Rage LT Pro (Compaq Armada 1750)
1002 0040 Rage LT Pro AGP 2X
1002 0044 Rage LT Pro AGP 2X
1002 4c42 Rage LT Pro AGP 2X
1002 8001 Rage LT Pro AGP 2X
1028 0085 Rage 3D LT Pro
4c46 Rage Mobility 128 AGP 2X/Mobility M3
1002 0155 IBM Thinkpad A22p
1014 0155 Thinkpad A22p
1028 00b1 Latitude C600
4c47 3D Rage IIC PCI / Mobility Radeon 7500/7500C
4c49 3D Rage LT PRO PCI
1002 0004 Rage LT Pro
1002 0040 Rage LT Pro
1002 0044 Rage LT Pro
1002 4c49 Rage LT Pro
4c4d Rage Mobility AGP 2x Series
0e11 b111 Armada M700
0e11 b160 Armada E500
1002 0084 Xpert 98 AGP 2X (Mobility)
1014 0154 ThinkPad A20m/A21m
1028 00aa Latitude CPt
1028 00bb Latitude CPx
1179 ff00 Satellite 1715XCDS laptop
13bd 1019 PC-AR10
4c50 Rage 3 LT [3D Rage LT PRO PCI]
1002 4c50 Rage LT Pro
4c52 M1 [Rage Mobility-M1 PCI]
1033 8112 Versa Note VXi
4c54 264LT [Mach64 LT]
4c57 RV200/M7 [Mobility Radeon 7500]
1014 0517 ThinkPad T30
1014 0530 ThinkPad T4x Series
1028 00e6 Radeon Mobility M7 LW (Dell Inspiron 8100)
1028 012a Latitude C640
1043 1622 Mobility Radeon M7 (L3C/S)
144d c006 Radeon Mobility M7 LW in vpr Matrix 170B4
4c58 RV200/M7 GL [Mobility FireGL 7800]
4c59 RV100/M6 [Rage/Radeon Mobility Series]
0e11 b111 Evo N600c
1014 0235 ThinkPad A30/A30p (2652/2653)
1014 0239 ThinkPad X22/X23/X24
103c 0025 XE4500 Notebook
104d 80e7 VAIO PCG-GR214EP/GR214MP/GR215MP/GR314MP/GR315MP
104d 8140 PCG-Z1SP laptop
1509 1930 Medion MD9703
4c66 RV250/M9 GL [Mobility FireGL 9000/Radeon 9000]
1014 054d ThinkPad T41
4c6e RV250/M9 [Mobility Radeon 9000] (Secondary)
4d46 Rage Mobility 128 AGP 4X/Mobility M4
4d52 Theater 550 PRO PCI [ATI TV Wonder 550]
4d53 Theater 550 PRO PCIe
4e44 R300 [Radeon 9700/9700 PRO]
1002 515e Radeon ES1000
1002 5965 Radeon ES1000
4e45 R300 [Radeon 9500 PRO/9700]
1002 0002 Radeon R300 NE [Radeon 9500 Pro]
1681 0002 Hercules 3D Prophet 9500 PRO [Radeon 9500 Pro]
4e46 R300 [Radeon 9600 TX]
4e47 R300 GL [FireGL X1]
4e48 R350 [Radeon 9800 Series]
4e49 R350 [Radeon 9800]
4e4a R360 [Radeon 9800 XXL/XT]
1002 4e4a R360 [Radeon 9800 XT]
4e4b R350 GL [FireGL X2 AGP Pro]
4e50 RV350/M10 / RV360/M11 [Mobility Radeon 9600 (PRO) / 9700]
1025 005a TravelMate 290
1025 0064 Extensa 3000 series laptop: ATI RV360/M11 [Mobility Radeon 9700]
103c 088c NC8000 laptop
103c 0890 NC6000 laptop
144d c00c P35 notebook
1462 0311 MSI M510A
1734 1055 Amilo M1420W
4e51 RV350 [Radeon 9550/9600/X1050 Series]
4e52 RV350/M10 [Mobility Radeon 9500/9700 SE]
144d c00c P35 notebook
4e54 RV350/M10 GL [Mobility FireGL T2]
4e56 RV360/M12 [Mobility Radeon 9550]
4e64 R300 [Radeon 9700 PRO] (Secondary)
4e65 R300 [Radeon 9500 PRO] (Secondary)
1002 0003 Radeon R300 NE [Radeon 9500 Pro]
1681 0003 Hercules 3D Prophet 9500 PRO [Radeon 9500 Pro] (Secondary)
4e66 RV350 [Radeon 9600] (Secondary)
4e67 R300 GL [FireGL X1] (Secondary)
4e68 R350 [Radeon 9800 PRO] (Secondary)
4e69 R350 [Radeon 9800] (Secondary)
4e6a RV350 [Radeon 9800 XT] (Secondary)
1002 4e6a R360 [Radeon 9800 XT] (Secondary)
1002 4e71 M10 NQ [Radeon Mobility 9600]
4e71 RV350/M10 [Mobility Radeon 9600] (Secondary)
4f72 RV250 [Radeon 9000 Series]
4f73 RV250 [Radeon 9000 Series] (Secondary)
5044 All-In-Wonder 128 PCI
1002 0028 Rage 128 AIW
1002 0029 Rage 128 AIW
5046 Rage 4 [Rage 128 PRO AGP 4X TMDS]
1002 0004 Rage Fury Pro
1002 0008 Rage Fury Pro/Xpert 2000 Pro
1002 0014 Rage Fury Pro
1002 0018 Rage Fury Pro/Xpert 2000 Pro
1002 0028 Rage 128 Pro AIW AGP
1002 002a Rage 128 Pro AIW AGP
1002 0048 Rage Fury Pro
1002 2000 Rage Fury MAXX AGP 4x (TMDS) (VGA device)
1002 2001 Rage Fury MAXX AGP 4x (TMDS) (Extra device?!)
5050 Rage128 [Xpert 128 PCI]
1002 0008 Xpert 128
5052 Rage 128 PRO AGP 4X TMDS
5144 R100 [Radeon 7200 / All-In-Wonder Radeon]
1002 0008 Radeon 7000/Radeon VE
1002 0009 Radeon 7000/Radeon
1002 000a Radeon 7000/Radeon
1002 001a Radeon 7000/Radeon
1002 0029 Radeon AIW
1002 0038 Radeon 7000/Radeon
1002 0039 Radeon 7000/Radeon
1002 008a Radeon 7000/Radeon
1002 00ba Radeon 7000/Radeon
1002 0139 Radeon 7000/Radeon
1002 028a Radeon 7000/Radeon
1002 02aa Radeon AIW
1002 053a Radeon 7000/Radeon
5148 R200 GL [FireGL 8800]
1002 010a FireGL 8800 64Mb
1002 0152 FireGL 8800 128Mb
1002 0162 FireGL 8700 32Mb
1002 0172 FireGL 8700 64Mb
514c R200 [Radeon 8500/8500 LE]
1002 003a Radeon R200 QL [Radeon 8500 LE]
1002 013a Radeon 8500
148c 2026 R200 QL [Radeon 8500 Evil Master II Multi Display Edition]
1681 0010 Radeon 8500 [3D Prophet 8500 128Mb]
174b 7149 Radeon 8500 LE
1787 0f08 Radeon R200 QL [PowerMagic Radeon 8500]
514d R200 [Radeon 9100]
5157 RV200 [Radeon 7500/7500 LE]
1002 013a Radeon 7500
1002 0f2b ALL-IN-WONDER VE PCI
1002 103a Dell Optiplex GX260
1458 4000 RV200 QW [RADEON 7500 PRO MAYA AR]
148c 2024 RV200 QW [Radeon 7500LE Dual Display]
148c 2025 RV200 QW [Radeon 7500 Evil Master Multi Display Edition]
148c 2036 RV200 QW [Radeon 7500 PCI Dual Display]
174b 7146 RV200 QW [Radeon 7500 LE]
174b 7147 Radeon 7500 LE
174b 7161 Radeon RV200 QW [Radeon 7500 LE]
17af 0202 RV200 QW [Excalibur Radeon 7500LE]
5159 RV100 [Radeon 7000 / Radeon VE]
1002 000a Radeon 7000/Radeon VE
1002 000b Radeon 7000
1002 0038 Radeon 7000/Radeon VE
1002 003a Radeon 7000/Radeon VE
1002 00ba Radeon 7000/Radeon VE
1002 013a Radeon 7000/Radeon VE
1002 0908 XVR-100 (supplied by Sun)
# The IBM card doubles as an ATI PCI video adapter
1014 029a Remote Supervisor Adapter II (RSA2)
1014 02c8 eServer xSeries server mainboard
1028 016c PowerEdge 1850 Embedded Radeon 7000/VE
1028 016d PowerEdge 2850 Embedded Radeon 7000-M
1028 0170 PowerEdge 6850 Embedded Radeon 7000/VE
1028 019a PowerEdge SC1425
103c 1292 Radeon 7000
1043 c00a A7000/T/64M
1458 4002 RV100 QY [RADEON 7000 PRO MAYA AV Series]
148c 2003 RV100 QY [Radeon 7000 Multi-Display Edition]
148c 2023 RV100 QY [Radeon 7000 Evil Master Multi-Display]
148c 2081 RV6DE
174b 0280 Radeon RV100 QY [Radeon 7000/VE]
174b 7112 Radeon VE 7000
174b 7c28 Radeon VE 7000 DDR
1787 0202 RV100 QY [Excalibur Radeon 7000]
17ee 1001 Radeon 7000 64MB DDR + DVI
515e ES1000
1028 01bb PowerEdge 1955 Embedded ATI ES1000
1028 01df PowerEdge SC440
1028 01e6 PowerEdge 860
1028 01f0 PowerEdge R900 Embedded ATI ES1000
1028 0205 PowerEdge 2970 Embedded ATI ES1000
1028 020b PowerEdge T605 Embedded ATI ES1000
1028 020f PowerEdge R300 Embedded ATI ES1000
1028 0210 PowerEdge T300 Embedded ATI ES1000
1028 0221 PowerEdge R805 Embedded ATI ES1000
1028 0223 PowerEdge R905 Embedded ATI ES1000
1028 0225 PowerEdge T105 Embedded ATI ES1000
1028 023c PowerEdge R200 Embedded ATI ES1000
103c 1304 Integrity iLO2 Advanced KVM VGA [AD307A]
15d9 8680 X7DVL-E-O motherboard
15d9 9680 X7DBN Motherboard
8086 3476 S5000PSLSATA Server Board
5245 Rage 128 GL PCI
1002 0008 Xpert 128
1002 0028 Rage 128 AIW
1002 0029 Rage 128 AIW
1002 0068 Rage 128 AIW
5246 Rage 128 (Rage 4) series
1002 0004 Magnum/Xpert 128/Xpert 99
1002 0008 Rage 128 AGP 2x
1002 0028 Rage 128 AIW AGP
1002 0044 Rage Fury/Xpert 128/Xpert 2000
1002 0068 Rage 128 AIW AGP
1002 0448 Rage Fury
524b Rage 128 VR PCI
524c Rage 128 VR AGP
1002 0008 Xpert 99/Xpert 2000
1002 0088 Xpert 99
5346 Rage 128 SF/4x AGP 2x
1002 0048 RAGE 128 16MB VGA TVOUT AMC PAL
534d Rage 128 4X AGP 4x
1002 0008 Xpert 99/Xpert 2000
1002 0018 Xpert 2000
5354 Mach 64 VT
1002 5654 Mach 64 reference
5446 Rage 128 PRO Ultra AGP 4x
1002 0004 Rage Fury Pro
1002 0008 Rage Fury Pro/Xpert 2000 Pro
1002 0018 Rage Fury Pro/Xpert 2000 Pro
1002 0028 Rage 128 AIW Pro AGP
1002 0029 Rage 128 AIW
1002 002a Rage 128 AIW Pro AGP
1002 002b Rage 128 AIW
1002 0048 Xpert 2000 Pro
5452 Rage 128 PRO Ultra4XL VR-R AGP
1002 001c Rage 128 Pro 4XL
103c 1279 Rage 128 Pro 4XL
5460 RV370/M22 [Mobility Radeon X300]
1775 1100 CR11/VR11 Single Board Computer
5461 RV370/M22 [Mobility Radeon X300]
5462 RV380/M24C [Mobility Radeon X600 SE]
5464 RV370/M22 GL [Mobility FireGL V3100]
5549 R423 [Radeon X800 GTO]
554a R423 [Radeon X800 XT Platinum Edition]
554b R423 [Radeon X800 GT/SE]
1002 0302 Radeon X800 SE
554d R430 [Radeon X800 XL]
1002 0322 All-In-Wonder X800 XL
1458 2124 GV-R80L256V-B (AGP)
554e R430 [All-In-Wonder X800 GT]
554f R430 [Radeon X800]
5550 R423 GL [FireGL V7100]
5551 R423 GL [FireGL V5100]
5569 R423 [Radeon X800 PRO] (Secondary)
556b R423 [Radeon X800 GT] (Secondary)
556d R430 [Radeon X800 XL] (Secondary)
1458 2125 GV-R80L256V-B (AGP)
556f R430 [Radeon X800] (Secondary)
5571 R423 GL [FireGL V5100] (Secondary)
564b RV410/M26 GL [Mobility FireGL V5000]
564f RV410/M26 [Mobility Radeon X700 XL]
5652 RV410/M26 [Mobility Radeon X700]
5653 RV410/M26 [Mobility Radeon X700]
1025 0080 Aspire 5024WLMi
103c 0940 Compaq NW8240 Mobile Workstation
5654 Mach64 VT [Video Xpression]
1002 5654 Mach64VT Reference
5655 264VT3 [Mach64 VT3]
5656 Mach64 VT4 [Video Xpression+]
5657 RV410 [Radeon X550 XTX / X700]
5830 RS300 Host Bridge
5831 RS300 Host Bridge
5832 RS300 Host Bridge
5833 RS300 Host Bridge
5834 RS300 [Radeon 9100 IGP]
5835 RS300M [Mobility Radeon 9100 IGP]
5838 RS300 AGP Bridge
5854 RS480 [Radeon Xpress 200 Series] (Secondary)
5874 RS480 [Radeon Xpress 1150] (Secondary)
5940 RV280 [Radeon 9200 PRO] (Secondary)
17af 2021 Excalibur Radeon 9250 (Secondary)
5941 RV280 [Radeon 9200] (Secondary)
1458 4019 Radeon 9200
174b 7c12 Radeon 9200
17af 200d Excalibur Radeon 9200
18bc 0050 GC-R9200-C3 (Secondary)
5944 RV280 [Radeon 9200 SE PCI]
5950 RS480/RS482/RS485 Host Bridge
1025 0080 Aspire 5024WLMMi
103c 280a DC5750 Microtower
103c 2a20 Pavilion t3030.de Desktop PC
103c 308b MX6125
1462 0131 MS-1013 Notebook
1462 7217 Aspire L250
5951 RX480/RX482 Host Bridge
5952 RD580 Host Bridge
5954 RS480 [Radeon Xpress 200 Series]
1002 5954 RV370 [Radeon Xpress 200G Series]
5955 RS480M [Mobility Radeon Xpress 200]
1002 5955 RS480 0x5955 [Radeon XPRESS 200M 5955 (PCIE)]
103c 308b MX6125
1462 0131 MS-1013 Notebook
5956 RD790 Host Bridge
5957 RX780/RX790 Host Bridge
1849 5957 A770CrossFire Motherboard
5958 RD780 Host Bridge
5960 RV280 [Radeon 9200 PRO]
17af 2020 Excalibur Radeon 9250
5961 RV280 [Radeon 9200]
1002 2f72 All-in-Wonder 9200 Series
1019 4c30 Radeon 9200 VIVO
12ab 5961 YUAN SMARTVGA Radeon 9200
1458 4018 Radeon 9200
174b 7c13 Radeon 9200
17af 200c Excalibur Radeon 9200
18bc 0050 Radeon 9200 Game Buster
18bc 0051 GC-R9200-C3
18bc 0053 Radeon 9200 Game Buster VIVO
5962 RV280 [Radeon 9200]
5964 RV280 [Radeon 9200 SE]
1002 5964 Radeon 9200 SE, 64-bit 128MB DDR, 200/166MHz
1043 c006 Radeon 9200 SE / TD / 128M
1458 4018 Radeon 9200 SE
1458 4032 Radeon 9200 SE 128MB
147b 6191 R9200SE-DT
148c 2073 CN-AG92E
174b 7c13 Radeon 9200 SE
1787 5964 Excalibur 9200SE VIVO 128M
17af 2012 Radeon 9200 SE Excalibur
18bc 0170 Sapphire Radeon 9200 SE 128MB Game Buster
18bc 0173 GC-R9200L(SE)-C3H [Radeon 9200 Game Buster]
5965 RV280 GL [FireMV 2200 PCI]
5974 RS482/RS485 [Radeon Xpress 1100/1150]
103c 280a DC5750 Microtower
1462 7141 Aspire L250
5975 RS482M [Mobility Radeon Xpress 200]
5978 RX780/RD790 PCI to PCI bridge (external gfx0 port A)
1849 5957 A770CrossFire Motherboard
5979 RD790 PCI to PCI bridge (external gfx0 port B)
597a RD790 PCI to PCI bridge (PCI express gpp port A)
597b RX780/RD790 PCI to PCI bridge (PCI express gpp port B)
597c RD790 PCI to PCI bridge (PCI express gpp port C)
597d RX780/RD790 PCI to PCI bridge (PCI express gpp port D)
597e RD790 PCI to PCI bridge (PCI express gpp port E)
1849 5957 A770CrossFire Motherboard
597f RD790 PCI to PCI bridge (PCI express gpp port F)
1849 5957 A770CrossFire Motherboard
5980 RD790 PCI to PCI bridge (external gfx1 port A)
5981 RD790 PCI to PCI bridge (external gfx1 port B)
5982 RD790 PCI to PCI bridge (NB-SB link)
5a10 RD890 Northbridge only dual slot (2x16) PCI-e GFX Hydra part
5a11 RD890 Northbridge only single slot PCI-e GFX Hydra part
5a12 RD890 Northbridge only dual slot (2x8) PCI-e GFX Hydra part
15d9 a811 H8DGU
5a13 RD890S/SR5650 Host Bridge
5a14 RD9x0/RX980 Host Bridge
5a15 RD890 PCI to PCI bridge (PCI express gpp port A)
5a16 RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GFX port 0)
5a17 RD890/RD9x0 PCI to PCI bridge (PCI Express GFX port 1)
5a18 RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GPP Port 0)
15d9 a811 H8DGU
5a19 RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GPP Port 1)
5a1a RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GPP Port 2)
5a1b RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GPP Port 3)
5a1c RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GPP Port 4)
5a1d RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GPP Port 5)
5a1e RD890/RD9x0/RX980 PCI to PCI bridge (PCI Express GPP2 Port 0)
5a1f RD890/RD990 PCI to PCI bridge (PCI Express GFX2 port 0)
15d9 a811 H8DGU
5a20 RD890/RD990 PCI to PCI bridge (PCI Express GFX2 port 1)
5a23 RD890S/RD990 I/O Memory Management Unit (IOMMU)
5a31 RC410 Host Bridge
5a33 RS400 Host Bridge
5a34 RS4xx PCI Express Port [ext gfx]
5a36 RC4xx/RS4xx PCI Express Port 1
5a37 RC4xx/RS4xx PCI Express Port 2
5a38 RC4xx/RS4xx PCI Express Port 3
5a39 RC4xx/RS4xx PCI Express Port 4
5a3f RC4xx/RS4xx PCI Bridge [int gfx]
1462 7217 Aspire L250
5a41 RS400 [Radeon Xpress 200]
5a42 RS400M [Radeon Xpress 200M]
5a61 RC410 [Radeon Xpress 200/1100]
5a62 RC410M [Mobility Radeon Xpress 200M]
5b60 RV370 [Radeon X300]
1043 002a Extreme AX300SE-X
1043 032e Extreme AX300/TD
1458 2102 GV-RX30S128D (X300SE)
1462 0400 RX300SE-TD128E (MS-8940 REV:200)
1462 0402 RX300SE-TD128E (MS-8940)
174b 0500 Radeon X300 (PCIE)
196d 1086 X300SE HM
5b62 RV370 [Radeon X600/X600 SE]
5b63 RV370 [Radeon X300/X550/X1050 Series]
5b64 RV370 GL [FireGL V3100]
5b65 RV370 GL [FireMV 2200]
5b66 RV370X
5b70 RV370 [Radeon X300 SE]
# RX300SE-TD128E
1462 0403 Radeon X300 SE 128MB DDR
174b 0501 Radeon X300 SE
196d 1087 Radeon X300 SE HyperMemory
5b72 RV380 [Radeon X300/X550/X1050 Series] (Secondary)
5b73 RV370 [Radeon X300/X550/X1050 Series] (Secondary)
5b74 RV370 GL [FireGL V3100] (Secondary)
5b75 RV370 GL [FireMV 2200] (Secondary)
5c61 RV280/M9+ [Mobility Radeon 9200 AGP]
5c63 RV280/M9+ [Mobility Radeon 9200 AGP]
1002 5c63 Apple iBook G4 2004
144d c00c P30 notebook
5d44 RV280 [Radeon 9200 SE] (Secondary)
1458 4019 Radeon 9200 SE (Secondary)
1458 4032 Radeon 9200 SE 128MB
147b 6190 R9200SE-DT (Secondary)
174b 7c12 Radeon 9200 SE (Secondary)
1787 5965 Excalibur 9200SE VIVO 128M (Secondary)
17af 2013 Radeon 9200 SE Excalibur (Secondary)
18bc 0171 Radeon 9200 SE 128MB Game Buster (Secondary)
18bc 0172 GC-R9200L(SE)-C3H [Radeon 9200 Game Buster]
5d45 RV280 GL [FireMV 2200 PCI] (Secondary)
5d48 R423/M28 [Mobility Radeon X800 XT]
5d49 R423/M28 GL [Mobility FireGL V5100]
5d4a R423/M28 [Mobility Radeon X800]
5d4d R480 [Radeon X850 XT Platinum Edition]
5d4e R480 [Radeon X850 SE]
5d4f R480 [Radeon X800 GTO]
5d50 R480 GL [FireGL V7200]
5d52 R480 [Radeon X850 XT]
1002 0b12 PowerColor X850XT PCIe (Primary)
5d57 R423 [Radeon X800 XT]
5d6d R480 [Radeon X850 XT Platinum Edition] (Secondary)
5d6f R480 [Radeon X800 GTO] (Secondary)
5d72 R480 [Radeon X850 XT] (Secondary)
1002 0b13 PowerColor X850XT PCIe (Secondary)
5d77 R423 [Radeon X800 XT] (Secondary)
5e48 RV410 GL [FireGL V5000]
5e49 RV410 [Radeon X700 Series]
5e4a RV410 [Radeon X700 XT]
5e4b RV410 [Radeon X700 PRO]
5e4c RV410 [Radeon X700 SE]
5e4d RV410 [Radeon X700]
148c 2116 Bravo X700
5e4f RV410 [Radeon X700]
1569 1e4f Radeon X550 XT
5e6b RV410 [Radeon X700 PRO] (Secondary)
5e6d RV410 [Radeon X700] (Secondary)
148c 2117 Bravo X700 (Secondary)
5f57 R423 [Radeon X800 XT]
6600 Mars [Radeon HD 8670A/8670M/8750M]
103c 1952 ProBook 455 G1
6601 Mars [Radeon HD 8730M]
103c 2100 FirePro M4100
6604 Opal XT [Radeon R7 M265/M365X/M465]
1025 0776 Aspire V5 Radeon R7 M265
103c 8006 FirePro M4170
103c 814f Litho XT [Radeon R7 M365X]
103c 82aa Litho XT [Radeon R7 M465]
17aa 3643 Radeon R7 A360
6605 Opal PRO [Radeon R7 M260X]
103c 2259 FirePro M4150
6606 Mars XTX [Radeon HD 8790M]
1028 0684 FirePro W4170M
6607 Mars LE [Radeon HD 8530M / R5 M240]
6608 Oland GL [FirePro W2100]
13cc 3d28 MXRT-2600
6610 Oland XT [Radeon HD 8670 / R7 250/350]
1019 0030 Radeon HD 8670
1028 2120 Radeon R7 250
1028 2322 Radeon R7 250
1462 2910 Radeon HD 8670
1462 2911 Radeon HD 8670
148c 7350 Radeon R7 350
1642 3c81 Radeon HD 8670
1642 3c91 Radeon HD 8670
1642 3f09 Radeon R7 350
6611 Oland [Radeon HD 8570 / R7 240/340 OEM]
1028 210b Radeon R5 240 OEM
174b 4248 Radeon R7 240 OEM
174b a240 Radeon R7 240 OEM
174b d340 Radeon R7 340 OEM
1b0a 90d3 Radeon R7 240 OEM
6613 Oland PRO [Radeon R7 240/340]
148c 7340 Radeon R7 340
1682 7240 R7 240 2048 MB
6631 Oland
6640 Saturn XT [FirePro M6100]
106b 014b Tropo XT [Radeon R9 M380 Mac Edition]
6641 Saturn PRO [Radeon HD 8930M]
6646 Bonaire XT [Radeon R9 M280X]
6647 Saturn PRO/XT [Radeon R9 M270X/M280X]
1043 223d N551ZU laptop Radeon R9 M280X
6649 Bonaire [FirePro W5100]
1002 0b0c FirePro W4300
103c 0b0c Bonaire [FirePro W4300]
103c 230c FirePro W5100
13cc 3d2a MXRT-5600
6650 Bonaire
6651 Bonaire
6658 Bonaire XTX [Radeon R7 260X/360]
1043 04d3 AMD Radeon R7 260X
148c 0907 Radeon R7 360
1682 0907 Radeon R7 360
1682 7360 Radeon R7 360
665c Bonaire XT [Radeon HD 7790/8770 / R7 360 / R9 260/360 OEM]
1043 0452 Radeon HD 7790 DirectCU II OC
# R7790-1GD5/OC
1462 2930 Radeon HD 7790 OC
1462 2932 Radeon HD 8770
1462 2934 Radeon R9 260 OEM
1462 2938 Radeon R9 360 OEM
148c 0907 Radeon R7 360
148c 9260 Radeon R9 260 OEM
148c 9360 Radeon R9 360 OEM
1682 0907 Radeon R7 360
# FX-779A-CDB4 / FX-779A-CDBC
1682 3310 Radeon HD 7790 Black Edition 2 GB
# 100356OCL / 11210-01-20G
174b e253 Radeon HD 7790 Dual-X OC
1787 2329 Radeon HD 7790 TurboDuo
665d Bonaire [Radeon R7 200 Series]
665f Tobago PRO [Radeon R7 360 / R9 360 OEM]
1028 0b04 Radeon R9 360 OEM
1462 2938 Radeon R9 360 OEM
1462 3271 Radeon R9 360 OEM
1682 7360 Radeon R7 360
6660 Sun XT [Radeon HD 8670A/8670M/8690M / R5 M330 / M430 / Radeon 520 Mobile]
1028 05ea Radeon HD 8670M
1028 06bf Radeon R5 M335
103c 1970 Radeon HD 8670M
103c 80be Radeon R5 M330
103c 8136 Radeon R5 M330
103c 8329 Radeon R7 M520
17aa 3633 Radeon R5 A330
17aa 3804 Radeon R5 M330
17aa 3809 Radeon R5 M330
17aa 381a Radeon R5 M430
17aa 390c Radeon R5 M330
6663 Sun PRO [Radeon HD 8570A/8570M]
1025 0846 Radeon HD 8570A
17aa 3805 Radeon HD 8570M
6664 Jet XT [Radeon R5 M240]
6665 Jet PRO [Radeon R5 M230 / R7 M260DX / Radeon 520 Mobile]
17aa 1309 Radeon R7 M260DX
17aa 368f Radeon R5 A230
6667 Jet ULT [Radeon R5 M230]
666f Sun LE [Radeon HD 8550M / R5 M230]
66a0 Vega 20 [Radeon Instinct]
66a1 Vega 20
66a2 Vega 20
66a3 Vega 20
66a7 Vega 20 [Radeon Pro Vega 20]
66af Vega 20 [Radeon VII]
6704 Cayman PRO GL [FirePro V7900]
6707 Cayman LE GL [FirePro V5900]
6718 Cayman XT [Radeon HD 6970]
6719 Cayman PRO [Radeon HD 6950]
671c Antilles [Radeon HD 6990]
671d Antilles [Radeon HD 6990]
671f Cayman CE [Radeon HD 6930]
6720 Blackcomb [Radeon HD 6970M/6990M]
1028 048f Radeon HD 6990M
1028 0490 Alienware M17x R3 Radeon HD 6970M
1028 04a4 FirePro M8900
1028 04ba Radeon HD 6990M
1028 053f FirePro M8900
106b 0b00 Radeon HD 6970M
1558 5102 Radeon HD 6970M
1558 5104 Radeon HD 6990M
1558 7201 Radeon HD 6990M
174b e188 Radeon HD 6970M
6738 Barts XT [Radeon HD 6870]
# HD-687A-ZDFC
1682 3103 Radeon HD 8670
1787 201a Barts XT [Radeon HD 6870 X2]
1787 201b Barts XT [Radeon HD 6870 X2]
6739 Barts PRO [Radeon HD 6850]
1043 03b4 EAH6850 [Radeon HD 6850]
673e Barts LE [Radeon HD 6790]
148c 7720 Radeon HD 7720 OEM
6740 Whistler [Radeon HD 6730M/6770M/7690M XT]
1019 238c Radeon HD 6730M
1019 238e Radeon HD 6730M
1019 2391 Radeon HD 6730M
1019 2392 Radeon HD 6770M
1028 04a3 Precision M4600
1028 053e FirePro M5950
103c 1630 FirePro M5950
103c 1631 FirePro M5950
103c 164b Radeon HD 6730M
103c 164e Radeon HD 6730M
103c 1657 Radeon HD 6770M
103c 1658 Radeon HD 6770M
103c 165a Radeon HD 6770M
103c 165b Radeon HD 6770M
103c 1688 Radeon HD 6770M
103c 1689 Radeon HD 6770M
103c 168a Radeon HD 6770M
103c 185e Radeon HD 7690M XT
103c 3388 Radeon HD 6770M
103c 3389 Radeon HD 6770M
103c 3582 Radeon HD 6770M
103c 366c Radeon HD 6730M
1043 1d02 Radeon HD 6730M
1043 1d12 Radeon HD 6730M
104d 9084 Radeon HD 6730M
104d 9085 Radeon HD 6730M
144d b074 Radeon HD 6730M
144d b077 Radeon HD 6730M
144d b084 Radeon HD 6730M
144d b088 Radeon HD 6730M
17aa 3982 Radeon HD 6730M
6741 Whistler [Radeon HD 6630M/6650M/6750M/7670M/7690M]
1019 238e Radeon HD 6650M
1019 238f Radeon HD 6650M
1025 0379 Radeon HD 6650M
1025 037b Radeon HD 6650M
1025 037e Radeon HD 6650M
1025 0382 Radeon HD 6650M
1025 0384 Radeon HD 6650M
1025 0385 Radeon HD 6650M
1025 0386 Radeon HD 6650M
1025 0387 Radeon HD 6650M
1025 0388 Radeon HD 6650M
1025 0442 Radeon HD 6650M
1025 0451 Radeon HD 6650M
1025 0489 Radeon HD 6650M
1025 048b Radeon HD 6650M
1025 048c Radeon HD 6650M
1025 050a Radeon HD 6650M
1025 050b Radeon HD 6650M
1025 050c Radeon HD 6650M
1025 050e Radeon HD 6650M
1025 050f Radeon HD 6650M
1025 0513 Radeon HD 6650M
1025 0514 Radeon HD 6650M
1025 0515 Radeon HD 6650M
1025 0516 Radeon HD 6650M
1025 051e Radeon HD 6650M
1025 051f Radeon HD 6650M
1025 0520 Radeon HD 6650M
1025 0521 Radeon HD 6650M
1025 052a Radeon HD 6650M
1025 0555 Radeon HD 6650M
1025 0556 Radeon HD 6650M
1025 055d Radeon HD 6650M
1025 055e Radeon HD 6650M
1025 056d Radeon HD 6650M
1025 059a Radeon HD 6650M
1025 059b Radeon HD 6650M
1025 059e Radeon HD 6650M
1025 059f Radeon HD 6650M
1025 0600 Radeon HD 6650M
1025 0605 Radeon HD 6650M
1025 0606 Radeon HD 6650M
1025 0619 Radeon HD 6650M
1028 04c1 Radeon HD 6630M
1028 04c5 Radeon HD 6630M
1028 04cd Radeon HD 6630M
1028 04d7 Radeon HD 6630M
1028 04d9 Radeon HD 6630M
1028 052d Radeon HD 6630M
103c 1617 Radeon HD 6650M
103c 1646 Radeon HD 6750M
103c 1647 Radeon HD 6650M
103c 164b Radeon HD 6650M
103c 164e Radeon HD 6650M
103c 1688 Radeon HD 6750M
103c 1689 Radeon HD 6750M
103c 168a Radeon HD 6750M
103c 1860 Radeon HD 7690M
103c 3385 Radeon HD 6630M
103c 3560 Radeon HD 6750M
103c 358d Radeon HD 6750M
103c 3590 Radeon HD 6750M
103c 3593 Radeon HD 6750M
103c 366c Radeon HD 6650M
1043 1cd2 Radeon HD 6650M
1043 2121 Radeon HD 6650M
1043 2122 Radeon HD 6650M
1043 2123 Radeon HD 6650M
1043 2125 Radeon HD 7670M
1043 2127 Radeon HD 7670M
104d 907b Radeon HD 6630M
104d 9080 Radeon HD 6630M
104d 9081 Radeon HD 6630M
106b 00e2 MacBookPro8,2 [Core i7, 15", Late 2011]
1179 fd63 Radeon HD 6630M
1179 fd65 Radeon HD 6630M
144d c093 Radeon HD 6650M
144d c0ac Radeon HD 6650M
144d c0b3 Radeon HD 6750M
144d c539 Radeon HD 6630M
144d c609 Radeon HD 6630M
152d 0914 Radeon HD 6650M
17aa 21e1 Radeon HD 6630M
17aa 3970 Radeon HD 6650M
17aa 3976 Radeon HD 6650M
1854 0907 Radeon HD 6650M
6742 Whistler LE [Radeon HD 6610M/7610M]
1002 6570 Turks [Radeon HD 6570]
1019 2393 Radeon HD 6610M
1043 1d82 K53SK Laptop Radeon HD 7610M
1179 fb22 Radeon HD 7610M
1179 fb23 Radeon HD 7610M
1179 fb27 Radeon HD 7610M
1179 fb2a Radeon HD 7610M
1179 fb2c Radeon HD 7610M
1179 fb30 Radeon HD 7610M
1179 fb31 Radeon HD 7610M
1179 fb32 Radeon HD 7610M
1179 fb38 Radeon HD 7610M
1179 fb39 Radeon HD 7610M
1179 fb3a Radeon HD 7610M
1179 fb3b Radeon HD 7610M
1179 fb40 Radeon HD 7610M
1179 fb41 Radeon HD 7610M
1179 fb47 Radeon HD 7610M
1179 fb48 Radeon HD 7610M
1179 fb49 Radeon HD 7610M
1179 fb51 Radeon HD 7610M
1179 fb52 Radeon HD 7610M
1179 fb53 Radeon HD 7610M
1179 fb56 Radeon HD 7610M
1179 fb81 Radeon HD 7610M
1179 fb82 Radeon HD 7610M
1179 fb83 Radeon HD 7610M
1179 fc56 Radeon HD 7610M
1179 fcd4 Radeon HD 7610M
1179 fcee Radeon HD 7610M
1458 6570 Turks [Radeon HD 6570]
1462 6570 Turks [Radeon HD 6570]
148c 6570 Turks [Radeon HD 6570]
1682 6570 Turks [Radeon HD 6570]
174b 5570 Turks [Radeon HD 5570]
174b 6570 Turks [Radeon HD 6570]
174b 7570 Turks [Radeon HD 7570]
174b 8510 Turks [Radeon HD 8510]
174b 8570 Turks [Radeon HD 8570]
1787 6570 Turks [Radeon HD 6570]
17af 6570 Turks [Radeon HD 6570]
8086 2111 Radeon HD 6625M
6743 Whistler [Radeon E6760]
6749 Turks GL [FirePro V4900]
15c3 2b06 MED-X4900
674a Turks GL [FirePro V3900]
13cc 3d22 MXRT-2500
15c3 0106 MED-X3900
6750 Onega [Radeon HD 6650A/7650A]
1462 2670 Radeon HD 6670A
17aa 3079 Radeon HD 7650A
17aa 307a Radeon HD 6650A
17aa 3087 Radeon HD 7650A
17aa 3618 Radeon HD 6650A
17aa 3623 Radeon HD 6650A
17aa 3627 Radeon HD 6650A
6751 Turks [Radeon HD 7650A/7670A]
1028 0548 Radeon HD 7650A
1462 2671 Radeon HD 7670A
1462 2672 Radeon HD 7670A
1462 2680 Radeon HD 7650A
1462 2681 Radeon HD 7650A
17aa 3087 Radeon HD 7650A
6758 Turks XT [Radeon HD 6670/7670]
1028 0b0e Radeon HD 6670
103c 6882 Radeon HD 6670
1462 250a Radeon HD 7670
148c 7670 Radeon HD 7670
1545 7670 Radeon HD 7670
1682 3300 Radeon HD 7670
174b 7670 Radeon HD 7670
174b e181 Radeon HD 6670
1787 2309 Radeon HD 6670
6759 Turks PRO [Radeon HD 6570/7570/8550]
103c 3130 Radeon HD 6570
1043 0403 Radeon HD 6570
1462 2500 Radeon HD 6570
1462 2509 Radeon HD 7570
148c 7570 Radeon HD 7570
1642 3a67 Radeon HD 6570
1682 3280 Radeon HD 7570
1682 3530 Radeon HD 8550
174b 7570 Radeon HD 7570
174b e142 Radeon HD 6570
174b e181 Radeon HD 6570
1b0a 908f Radeon HD 6570
1b0a 9090 Radeon HD 6570
1b0a 9091 Radeon HD 6570
1b0a 9092 Radeon HD 6570
1b0a 909e Radeon HD 6570
1b0a 90b5 Radeon HD 7570
1b0a 90b6 Radeon HD 7570
675b Turks [Radeon HD 7600 Series]
675d Turks PRO [Radeon HD 7570]
675f Turks LE [Radeon HD 5570/6510/7510/8510]
148c 6510 Radeon HD 6510
148c 6530 Radeon HD 6530
148c 7510 Radeon HD 7510
1545 7570 Radeon HD 7570
174b 6510 Radeon HD 6510
174b 7510 Radeon HD 7510
174b 8510 Radeon HD 8510
1787 2012 Radeon HD 5570 2GB GDDR3
1787 2314 Radeon HD 5570 1GB DDR2/GDDR3
6760 Seymour [Radeon HD 6400M/7400M Series]
1002 0124 Radeon HD 6470M
1002 0134 Radeon HD 6470M
1019 238b Radeon HD 6470M
1019 238e Radeon HD 6470M
1019 2390 Radeon HD 6470M
1019 9985 Radeon HD 6470M
1028 04c1 Radeon HD 6470M
1028 04c3 Radeon HD 6470M
1028 04ca Radeon HD 6470M
1028 04cb Radeon HD 6470M
1028 04cc Vostro 3350
1028 04d1 Radeon HD 6470M
1028 04d3 Radeon HD 6470M
1028 04d7 Radeon HD 6470M
1028 0502 Radeon HD 6470M
1028 0503 Radeon HD 6470M
1028 0506 Radeon HD 6470M
1028 0507 Radeon HD 6470M
1028 0514 Radeon HD 6470M
1028 051c Radeon HD 6450M
1028 051d Radeon HD 6450M
103c 161a Radeon HD 6470M
103c 161b Radeon HD 6470M
103c 161e Radeon HD 6470M
103c 161f Radeon HD 6470M
103c 1622 Radeon HD 6450M
103c 1623 Radeon HD 6450M
103c 164a Radeon HD 6470M
103c 164d Radeon HD 6470M
103c 1651 Radeon HD 6470M
103c 1656 Radeon HD 6490M
103c 1658 Radeon HD 6490M
103c 1659 Radeon HD 6490M
103c 165b Radeon HD 6490M
103c 165d Radeon HD 6470M
103c 165f Radeon HD 6470M
103c 1661 Radeon HD 6470M
103c 1663 Radeon HD 6470M
103c 1665 Radeon HD 6470M
103c 1667 Radeon HD 6470M
103c 1669 Radeon HD 6470M
103c 166b Radeon HD 6470M
103c 166c Radeon HD 6470M
103c 166e Radeon HD 6470M
103c 1670 Radeon HD 6470M
103c 1672 Radeon HD 6470M
103c 167a Radeon HD 6470M
103c 167b Radeon HD 6470M
103c 167d Radeon HD 6490M
103c 167f Radeon HD 6490M
103c 168c Radeon HD 6470M
103c 168f Radeon HD 6470M
103c 1694 Radeon HD 6470M
103c 1696 Radeon HD 6470M
103c 1698 Radeon HD 6470M
103c 169a Radeon HD 6470M
103c 169c Radeon HD 6490M
103c 1855 Radeon HD 7450M
103c 1859 Radeon HD 7450M
103c 185c Radeon HD 7450M
103c 185d Radeon HD 7470M
103c 185f Radeon HD 7470M
103c 1863 Radeon HD 7450M
103c 355c Radeon HD 6490M
103c 355f Radeon HD 6490M
103c 3563 Radeon HD 6470M
103c 3565 Radeon HD 6470M
103c 3567 Radeon HD 6470M
103c 3569 Radeon HD 6470M
103c 3581 Radeon HD 6490M
103c 3584 Radeon HD 6470M
103c 358c Radeon HD 6490M
103c 358f Radeon HD 6490M
103c 3592 Radeon HD 6490M
103c 3596 Radeon HD 6490M
103c 366b Radeon HD 6470M
103c 3671 FirePro M3900
103c 3673 Radeon HD 6470M
1043 100a Radeon HD 7470M
1043 100c Radeon HD 6470M
1043 101b Radeon HD 6470M
1043 101c Radeon HD 6470M
1043 102a Radeon HD 7450M
1043 102c Radeon HD 6470M
1043 104b Radeon HD 7470M
1043 105d Radeon HD 7470M
1043 106b Radeon HD 7470M
1043 106d Radeon HD 7470M
1043 107d Radeon HD 7470M
1043 1cb2 Radeon HD 6470M
1043 1d22 Radeon HD 6470M
1043 1d32 Radeon HD 6470M
1043 2001 Radeon HD 6470M
1043 2002 Radeon HD 7470M
1043 2107 Radeon HD 7470M
1043 2108 Radeon HD 7470M
1043 2109 Radeon HD 7470M
1043 84a0 Radeon HD 6470M
1043 84e9 Radeon HD 6470M
1043 8515 Radeon HD 7470M
1043 8517 Radeon HD 7470M
1043 855a Radeon HD 7470M
104d 907b Radeon HD 6470M
104d 9081 Radeon HD 6470M
104d 9084 Radeon HD 6470M
104d 9085 Radeon HD 6470M
1179 0001 Radeon HD 6450M
1179 0003 Radeon HD 6450M
1179 0004 Radeon HD 6450M
1179 fb22 Radeon HD 7470M
1179 fb23 Radeon HD 7470M
1179 fb2c Radeon HD 7470M
1179 fb31 Radeon HD 7470M
1179 fb32 Radeon HD 7470M
1179 fb33 Radeon HD 7470M
1179 fb38 Radeon HD 7470M
1179 fb39 Radeon HD 7470M
1179 fb3a Radeon HD 7470M
1179 fb40 Radeon HD 7470M
1179 fb41 Radeon HD 7470M
1179 fb42 Radeon HD 7470M
1179 fb47 Radeon HD 7470M
1179 fb48 Radeon HD 7470M
1179 fb51 Radeon HD 7470M
1179 fb52 Radeon HD 7470M
1179 fb53 Radeon HD 7470M
1179 fb81 Radeon HD 7470M
1179 fb82 Radeon HD 7470M
1179 fb83 Radeon HD 7470M
1179 fc51 Radeon HD 6470M
1179 fc52 Radeon HD 7470M
1179 fc56 Radeon HD 7470M
1179 fcd3 Radeon HD 7470M
1179 fcd4 Radeon HD 7470M
1179 fcee Radeon HD 7470M
1179 fdee Radeon HD 7470M
144d b074 Radeon HD 6470M
144d b084 Radeon HD 6470M
144d c095 Radeon HD 6470M
144d c0b3 Radeon HD 6490M
144d c538 Radeon HD 6470M
144d c581 Radeon HD 6470M
144d c589 Radeon HD 6470M
144d c609 Radeon HD 7470M
144d c625 Radeon HD 7470M
144d c636 Radeon HD 7450M
1462 10ac Radeon HD 6470M
152d 0916 Radeon HD 6470M
17aa 21e5 Radeon HD 6470M
17aa 3900 Radeon HD 7450M
17aa 3902 Radeon HD 7450M
17aa 3969 Radeon HD 6470M
17aa 3970 Radeon HD 7450M
17aa 3976 Radeon HD 6470M
17aa 397b Radeon HD 6470M
17aa 397d Radeon HD 6470M
17aa 5101 Radeon HD 7470M
17aa 5102 Radeon HD 7450M
17aa 5103 Radeon HD 7450M
17aa 5106 Radeon HD 7450M
1854 0897 Radeon HD 6470M
1854 0900 Radeon HD 6470M
1854 0908 Radeon HD 6470M
1854 2015 Radeon HD 6470M
6761 Seymour LP [Radeon HD 6430M]
6763 Seymour [Radeon E6460]
6764 Seymour [Radeon HD 6400M Series]
6765 Seymour [Radeon HD 6400M Series]
6766 Caicos
6767 Caicos
6768 Caicos
6770 Caicos [Radeon HD 6450A/7450A]
17aa 308d Radeon HD 7450A
17aa 3623 Radeon HD 6450A
17aa 3627 Radeon HD 6450A
17aa 3629 Radeon HD 6450A
17aa 363c Radeon HD 6450A
17aa 3658 Radeon HD 7470A
6771 Caicos XTX [Radeon HD 8490 / R5 235X OEM]
6772 Caicos [Radeon HD 7450A]
6778 Caicos XT [Radeon HD 7470/8470 / R5 235/310 OEM]
1019 0024 Radeon HD 7470
1019 0027 Radeon HD 8470
1028 2120 Radeon HD 7470
1462 b491 Radeon HD 8470
1462 b492 Radeon HD 8470
1462 b493 Radeon HD 8470 OEM
1462 b499 Radeon R5 235 OEM
1642 3c65 Radeon HD 8470
1642 3c75 Radeon HD 8470
174b 8145 Radeon HD 8470
174b d145 Radeon R5 235 OEM
174b d335 Radeon R5 310 OEM
174b e145 Radeon HD 7470
17aa 3694 Radeon R5 A220
6779 Caicos [Radeon HD 6450/7450/8450 / R5 230 OEM]
1019 0016 Radeon HD 6450
1019 0017 Radeon HD 6450
1019 0018 Radeon HD 6450
1028 2120 Radeon HD 6450
103c 2128 Radeon HD 6450
103c 2aee Radeon HD 7450A
1092 6450 Radeon HD 6450
1462 2125 Radeon HD 6450
1462 2346 Radeon HD 7450
1462 2490 Radeon HD 6450
1462 2494 Radeon HD 6450
1462 2496 Radeon HD 7450
148c 7450 Radeon HD 7450
148c 8450 Radeon HD 8450 OEM
1545 7470 Radeon HD 7470
1642 3a65 Radeon HD 6450
1642 3a66 Radeon HD 7450
1642 3a75 Radeon HD 6450
1642 3a76 Radeon HD 7450
1682 3200 Radeon HD 7450
174b 7450 Radeon HD 7450
174b e127 Radeon HD 6450
174b e153 Radeon HD 6450
174b e164 Radeon HD 6450 1 GB DDR3
174b e180 Radeon HD 6450
174b e201 Radeon HD 6450
17af 8450 Radeon HD 8450 OEM
1b0a 9096 Radeon HD 6450
1b0a 9097 Radeon HD 6450
1b0a 90a8 Radeon HD 6450A
1b0a 90b1 Radeon HD 6450
1b0a 90b3 Radeon HD 7450A
1b0a 90bb Radeon HD 7450A
677b Caicos PRO [Radeon HD 7450]
6780 Tahiti XT GL [FirePro W9000]
6784 Tahiti [FirePro Series Graphics Adapter]
6788 Tahiti [FirePro Series Graphics Adapter]
678a Tahiti PRO GL [FirePro Series]
1002 030c FirePro W8000
1002 0310 FirePro S9000
1002 0420 Radeon Sky 700
1002 0422 Radeon Sky 900
1002 0710 FirePro S9050
1002 0b0e FirePro S10000 Passive
1002 0b2a FirePro S10000
1028 030c FirePro W8000
1028 0710 FirePro S9000
6798 Tahiti XT [Radeon HD 7970/8970 OEM / R9 280X]
1002 3000 Tahiti XT2 [Radeon HD 7970 GHz Edition]
1002 3001 Tahiti XTL [Radeon R9 280X]
1002 4000 Radeon HD 8970 OEM
1043 041c HD 7970 DirectCU II
1043 0420 HD 7970 DirectCU II TOP
1043 0444 HD 7970 DirectCU II TOP
1043 0448 HD 7970 DirectCU II TOP
1043 044a Tahiti XT2 [Matrix HD 7970]
1043 044c Tahiti XT2 [Matrix HD 7970 Platinum]
1043 3001 Tahiti XTL [ROG Matrix R9 280X]
1043 3006 Tahiti XTL [Radeon R9 280X DirectCU II TOP]
1043 9999 ARES II
106b 0127 FirePro D700
106b 0128 FirePro D700
1092 3000 Tahiti XT2 [Radeon HD 7970 GHz Edition]
1458 2261 Tahiti XT2 [Radeon HD 7970 GHz Edition OC]
# GV-R928XOC-3GD
1458 3001 Tahiti XTL [Radeon R9 280X OC]
1462 2774 HD 7970 TwinFrozr III Boost Edition OC
1682 3001 Tahiti XTL [Radeon R9 280X]
1682 3211 Double D HD 7970 Black Edition
# FX-797A-TNBC
1682 3213 HD 7970 Black Edition
1682 3214 Double D HD 7970
1787 201c HD 7970 IceQ X²
# Radeon HD 7970 X2
1787 2317 Radeon HD 7990
1787 3000 Tahiti XT2 [Radeon HD 7970 GHz Edition]
679a Tahiti PRO [Radeon HD 7950/8950 OEM / R9 280]
1002 0b01 Radeon HD 8950 OEM
1002 3000 Tahiti PRO2 [Radeon HD 7950 Boost]
1462 3000 Radeon HD 8950 OEM
174b a003 Radeon R9 280
679b Malta [Radeon HD 7990/8990 OEM]
1002 0b28 Radeon HD 8990 OEM
1002 0b2a Radeon HD 7990
1462 8036 Radeon HD 8990 OEM
148c 8990 Radeon HD 8990 OEM
679e Tahiti LE [Radeon HD 7870 XT]
106b 0125 FirePro D500
106b 0126 FirePro D500
1787 2328 Radeon HD 7870 Black Edition 2 GB GDDR5 [2GBD5-2DHV3E]
679f Tahiti
67a0 Hawaii XT GL [FirePro W9100]
1002 0335 FirePro S9150
1002 0735 FirePro S9170
1028 031f FirePro W9100
1028 0335 FirePro S9150
67a1 Hawaii PRO GL [FirePro W8100]
1002 0335 FirePro S9100
1028 0335 FirePro S9100
67a2 Hawaii GL
67a8 Hawaii
67a9 Hawaii
67aa Hawaii
67b0 Hawaii XT / Grenada XT [Radeon R9 290X/390X]
1028 0b00 Grenada XT [Radeon R9 390X]
103c 6566 Radeon R9 390X
1043 046a R9 290X DirectCU II
1043 046c R9 290X DirectCU II OC
1043 0474 Matrix R9 290X Platinum
1043 0476 ARES III
1043 04d7 Radeon R9 390X
1043 04db Radeon R9 390X
1043 04df Radeon R9 390X
1043 04e9 Radeon R9 390X
1458 227c R9 290X WindForce 3X OC
1458 2281 R9 290X WindForce 3X OC
1458 228c R9 290X WindForce 3X
1458 228d R9 290X WindForce 3X OC
1458 2290 R9 290X WindForce 3X
1458 22bc Radeon R9 390X
1458 22c1 Grenada PRO [Radeon R9 390]
1462 2015 Radeon R9 390X
1462 3070 R9 290X Lightning
1462 3071 R9 290X Lightning
1462 3072 R9 290X Lightning LE
1462 3080 R9 290X Gaming
1462 3082 R9 290X Gaming OC
148c 2347 Devil 13 Dual Core R9 290X
148c 2357 Grenada XT [Radeon R9 390X]
1682 9290 Double Dissipation R9 290X
1682 9395 Grenada XT [Radeon R9 390X]
174b 0e34 Radeon R9 390X
174b e282 Vapor-X R9 290X Tri-X OC
174b e285 R9 290X Tri-X OC
174b e324 Grenada XT2 [Radeon R9 390X]
1787 2020 R9 290X IceQ X² Turbo
1787 2357 Grenada XT [Radeon R9 390X]
67b1 Hawaii PRO [Radeon R9 290/390]
1043 04dd STRIX R9 390
148c 2358 Radeon R9 390
174b e324 Sapphire Nitro R9 390
67b9 Vesuvius [Radeon R9 295X2]
67be Hawaii LE
67c0 Ellesmere [Radeon Pro WX 7100 Mobile]
67c2 Ellesmere [Radeon Pro V7300X / V7350x2]
67c4 Ellesmere [Radeon Pro WX 7100]
1002 0336 Radeon Pro Duo
1002 1336 Radeon Pro Duo
67c7 Ellesmere [Radeon Pro WX 5100]
67ca Ellesmere [Polaris10]
67cc Ellesmere [Polaris10]
67cf Ellesmere [Polaris10]
67d0 Ellesmere [Radeon Pro V7300X / V7350x2]
67df Ellesmere [Radeon RX 470/480/570/570X/580/580X/590]
1002 0b37 Radeon RX 480
1028 1722 Radeon RX 570X
1028 1723 Radeon RX 580X
1043 04a8 Radeon RX 480
1043 04b0 Radeon RX 470
1043 04fb Radeon RX 480
1043 04fd Radeon RX 480 8GB
1043 056a Radeon RX 590
106b 0161 Radeon Pro 580
106b 0162 Radeon Pro 575
106b 0163 Radeon Pro 570
1458 22f0 Radeon RX 570
1458 22f7 Radeon RX 570 Gaming 4G
1462 3411 Radeon RX 470
1462 3413 Radeon RX 480 Gaming X 8GB
1462 3416 Radeon RX 570
1462 3418 Radeon RX 580 Armor 4G OC
1462 341e Radeon RX 570 Armor 4G OC
1462 8a92 Radeon RX 580
148c 2372 Radeon RX 480
148c 2373 Radeon RX 470
1682 9470 Radeon RX 470
1682 9480 Radeon RX 480
1682 9588 Radeon RX 580 XTR
1682 c570 Radeon RX 570
174b e347 Radeon RX 470/480
174b e349 Radeon RX 470
1787 a470 Radeon RX 470
1787 a480 Radeon RX 480
1849 5001 Phantom Gaming X RX 580 OC
1da2 e353 Radeon RX 570 Pulse 4GB
1da2 e366 Nitro+ Radeon RX 570/580
67e0 Baffin [Radeon Pro WX 4170]
103c 8270 Radeon Pro WX 4170
103c 8272 Radeon Pro WX 4170
67e1 Baffin [Polaris11]
67e3 Baffin [Radeon Pro WX 4100]
67e8 Baffin [Radeon Pro WX 4130/4150]
1028 075d Radeon Pro WX 4150
1028 07b0 Radeon Pro WX 4130/4150
1028 07b1 Radeon Pro WX 4130
1028 175d Radeon Pro WX 4150
1028 17b0 Radeon Pro WX 4130/4150
1028 17b1 Radeon Pro WX 4130
103c 8275 Radeon Pro WX 4150
103c 8277 Radeon Pro WX 4150
67e9 Baffin [Polaris11]
67eb Baffin [Radeon Pro V5300X]
67ef Baffin [Radeon RX 460/560D / Pro 450/455/460/555/555X/560/560X]
1028 1703 RX 560D OEM OC 2 GB
103c 3421 Radeon RX 460
106b 0160 Radeon Pro 460
106b 0166 Radeon Pro 455
106b 0167 Radeon Pro 450
106b 0179 Radeon Pro 560
106b 017a Radeon Pro 555
106b 018f Radeon Pro 560X
106b 0190 Radeon Pro 555X
1642 1727 Polaris 21 XL [Radeon RX 560D]
1682 956d Polaris 21 XL [Radeon RX 560D]
67ff Baffin [Radeon RX 550 640SP / RX 560/560X]
1002 0b04 Radeon RX 560
1028 1721 Radeon RX 560X
1028 1726 Radeon RX 560DX
103c 8479 Radeon RX 560X Mobile
1043 04bc Radeon RX 560
1043 052f Radeon RX 560
1458 22ed Radeon RX 560
148c 2381 Radeon RX 560
1682 9560 Radeon RX 560
1da2 e348 Radeon RX 560
1da2 e367 Radeon RX 550 640SP
6800 Wimbledon XT [Radeon HD 7970M]
1002 0124 Radeon HD 7970M
8086 2110 Radeon HD 7970M
8086 2111 Radeon HD 7970M
6801 Neptune XT [Radeon HD 8970M]
1002 0124 Radeon HD 8970M
1462 1117 Radeon R9 M290X
8086 2110 Radeon HD 8970M
8086 2111 Radeon HD 8970M
6802 Wimbledon
6806 Neptune
6808 Pitcairn XT GL [FirePro W7000]
1002 0310 FirePro S7000
1002 0420 Radeon Sky 500
103c 030c MED-X7000
13cc 3d25 MXRT-7500
15c3 030c MED-X7000
6809 Pitcairn LE GL [FirePro W5000]
13cc 3d23 MXRT-5500
13cc 3d24 MXRT-5550
15c3 0b06 MED-X5000
6810 Curacao XT / Trinidad XT [Radeon R7 370 / R9 270X/370X]
106b 012a FirePro D300
106b 012b FirePro D300
148c 0908 Radeon R9 370 OEM
1682 7370 Radeon R7 370
6811 Curacao PRO [Radeon R7 370 / R9 270/370 OEM]
1028 0b00 Trinidad PRO [Radeon R9 370 OEM]
1043 2016 Trinidad PRO [Radeon R9 370 OEM]
1458 2016 Trinidad PRO [Radeon R9 370 OEM]
1462 2016 Trinidad PRO [Radeon R9 370 OEM]
1462 3050 R9 270 Gaming OC
148c 2016 Trinidad PRO [Radeon R9 370 OEM]
1682 2015 Trinidad PRO [Radeon R7 370]
174b 2015 NITRO Radeon R7 370
174b 2016 Trinidad PRO [Radeon R9 370 OEM]
1787 2016 Trinidad PRO [Radeon R9 370 OEM]
6816 Pitcairn
6817 Pitcairn
6818 Pitcairn XT [Radeon HD 7870 GHz Edition]
1002 0b05 Radeon HD 8870 OEM
174b 8b04 Radeon HD 8860
6819 Pitcairn PRO [Radeon HD 7850 / R7 265 / R9 270 1024SP]
1043 042c Radeon HD 7850
1682 7269 Radeon R9 270 1024SP
1682 9278 Radeon R9 270 1024SP
174b a008 Radeon R9 270 1024SP
174b e221 Radeon HD 7850 2GB GDDR5 DVI-I/DVI-D/HDMI/DP
6820 Venus XTX [Radeon HD 8890M / R9 M275X/M375X]
103c 1851 Radeon HD 7750M
17aa 3643 Radeon R9 A375
17aa 3801 Radeon R9 M275
17aa 3824 Radeon R9 M375
6821 Venus XT [Radeon HD 8870M / R9 M270X/M370X]
1002 031e FirePro SX4000
1028 05cc FirePro M5100
1028 15cc FirePro M5100
106b 0149 Radeon R9 M370X Mac Edition
6822 Venus PRO [Radeon E8860]
6823 Venus PRO [Radeon HD 8850M / R9 M265X]
6825 Heathrow XT [Radeon HD 7870M]
1028 053f FirePro M6000
1028 05cd FirePro M6000
1028 15cd FirePro M6000
103c 176c FirePro M6000
8086 2111 Chelsea PRO
6826 Chelsea LP [Radeon HD 7700M Series]
6827 Heathrow PRO [Radeon HD 7850M/8850M]
6828 Cape Verde PRO [FirePro W600]
15c3 2b1e MED-X6000
6829 Cape Verde
682a Venus PRO
682b Cape Verde PRO / Venus LE / Tropo PRO-L [Radeon HD 8830M / R7 250 / R7 M465X]
0128 079c Radeon R7 465X
1462 3012 Radeon R7 250
682c Cape Verde GL [FirePro W4100]
682d Chelsea XT GL [FirePro M4000]
682f Chelsea LP [Radeon HD 7730M]
103c 1851 Radeon HD 7750M
6835 Cape Verde PRX [Radeon R9 255 OEM]
6837 Cape Verde LE [Radeon HD 7730/8730]
1462 2796 Radeon HD 8730
1462 8092 Radeon HD 8730
148c 8730 Radeon HD 8730
1787 3000 Radeon HD 6570
683d Cape Verde XT [Radeon HD 7770/8760 / R7 250X]
1002 0030 Radeon HD 8760 OEM
1019 0030 Radeon HD 8760 OEM
103c 6890 Radeon HD 8760 OEM
1043 8760 Radeon HD 8760 OEM
1462 2710 R7770-PMD1GD5
174b 8304 Radeon HD 8760 OEM
683f Cape Verde PRO [Radeon HD 7750/8740 / R7 250E]
1462 2790 Radeon HD 8740
1462 2791 Radeon HD 8740
1642 3b97 Radeon HD 8740
6840 Thames [Radeon HD 7500M/7600M Series]
1025 050e Radeon HD 7670M
1025 050f Radeon HD 7670M
1025 0513 Radeon HD 7670M
1025 0514 Radeon HD 7670M
1025 056d Radeon HD 7670M
1025 059a Radeon HD 7670M
1025 059b Radeon HD 7670M
1025 059e Radeon HD 7670M
1025 0600 Radeon HD 7670M
1025 0606 Radeon HD 7670M
1025 0696 Radeon HD 7650M
1025 0697 Radeon HD 7650M
1025 0698 Radeon HD 7650M
1025 0699 Radeon HD 7650M
1025 0757 Radeon HD 7670M
1028 056a Radeon HD 7670M
1028 056e Radeon HD 7670M
1028 0598 Radeon HD 7670M
1028 059d Radeon HD 7670M
1028 05a3 Radeon HD 7670M
1028 05b9 Radeon HD 7670M
1028 05bb Radeon HD 7670M
103c 1789 FirePro M2000
103c 17f1 Radeon HD 7570M
103c 17f4 Radeon HD 7650M
103c 1813 Radeon HD 7590M
103c 182f Radeon HD 7670M
103c 1830 Radeon HD 7670M
103c 1835 Radeon HD 7670M
103c 183a Radeon HD 7670M
103c 183c Radeon HD 7670M
103c 183e Radeon HD 7670M
103c 1840 Radeon HD 7670M
103c 1842 Radeon HD 7670M
103c 1844 Radeon HD 7670M
103c 1848 Radeon HD 7670M
103c 184a Radeon HD 7670M
103c 184c Radeon HD 7670M
103c 1895 Radeon HD 7670M
103c 1897 Radeon HD 7670M
103c 18a5 Radeon HD 7670M
103c 18a7 Radeon HD 7670M
103c 18f4 Radeon HD 7670M
1043 100a Radeon HD 7670M
1043 104b Radeon HD 7670M
1043 10dc Radeon HD 7670M
1043 2121 Radeon HD 7670M
1043 2122 Radeon HD 7670M
1043 2123 Radeon HD 7670M
1043 2125 Radeon HD 7670M
1043 2127 Radeon HD 7670M
1179 fb11 Radeon HD 7670M
1179 fb22 Radeon HD 7670M
1179 fb23 Radeon HD 7670M
1179 fb2c Radeon HD 7670M
1179 fb31 Radeon HD 7670M
1179 fb32 Radeon HD 7670M
1179 fb38 Radeon HD 7670M
1179 fb39 Radeon HD 7670M
1179 fb3a Radeon HD 7670M
1179 fb40 Radeon HD 7670M
1179 fb41 Radeon HD 7670M
1179 fb47 Radeon HD 7670M
1179 fb48 Radeon HD 7670M
1179 fb51 Radeon HD 7670M
1179 fb52 Radeon HD 7670M
1179 fb53 Radeon HD 7670M
1179 fb81 Radeon HD 7670M
1179 fb82 Radeon HD 7670M
1179 fb83 Radeon HD 7670M
1179 fc56 Radeon HD 7670M
1179 fcd4 Radeon HD 7670M
1179 fcee Radeon HD 7670M
144d c0c5 Radeon HD 7690M
144d c0ce Radeon HD 7670M
144d c0da Radeon HD 7670M
17aa 3970 Radeon HD 7670M
17aa 397b Radeon HD 7670M
17aa 5101 Radeon HD 7670M
17aa 5102 Radeon HD 7670M
17aa 5103 Radeon HD 7670M
6841 Thames [Radeon HD 7550M/7570M/7650M]
1028 0561 Radeon HD 7650M
1028 056c Radeon HD 7650M
1028 057f Radeon HD 7570M
103c 17f1 Radeon HD 7570M
103c 17f4 Radeon HD 7650M
103c 1813 Radeon HD 7570M
103c 183a Radeon HD 7650M
103c 183c Radeon HD 7650M
103c 183e Radeon HD 7650M
103c 1840 Radeon HD 7650M
103c 1842 Radeon HD 7650M
103c 1844 Radeon HD 7650M
1043 100a Radeon HD 7650M
1043 104b Radeon HD 7650M
1043 10dc Radeon HD 7650M
1043 2134 Radeon HD 7650M
1179 0001 Radeon HD 7570M
1179 0002 Radeon HD 7570M
1179 fb43 Radeon HD 7550M
1179 fb91 Radeon HD 7550M
1179 fb92 Radeon HD 7550M
1179 fb93 Radeon HD 7550M
1179 fba2 Radeon HD 7550M
1179 fba3 Radeon HD 7550M
144d c0c7 Radeon HD 7550M
6842 Thames LE [Radeon HD 7000M Series]
6843 Thames [Radeon HD 7670M]
6860 Vega 10 [Radeon Instinct MI25]
1002 0c35 Radeon PRO V320
1002 6c75 Radeon PRO V320
106b 017c Radeon Pro Vega 64
6861 Vega 10 XT [Radeon PRO WX 9100]
6862 Vega 10 XT [Radeon PRO SSG]
6863 Vega 10 XTX [Radeon Vega Frontier Edition]
6864 Vega
6867 Vega 10 XL [Radeon Pro Vega 56]
6868 Vega 10 [Radeon PRO WX 8100/8200]
686c Vega 10 [Radeon Instinct MI25 MxGPU]
687f Vega 10 XL/XT [Radeon RX Vega 56/64]
1002 0b36 RX Vega64
1002 6b76 RX Vega56
6880 Lexington [Radeon HD 6550M]
103c 163c Pavilion dv6 Radeon HD 6550M
6888 Cypress XT [FirePro V8800]
6889 Cypress PRO [FirePro V7800]
1002 0301 FirePro V7800P
13cc 3d1f MXRT-7400
688a Cypress XT [FirePro V9800]
1002 030c FirePro V9800P
688c Cypress XT GL [FireStream 9370]
688d Cypress PRO GL [FireStream 9350]
6898 Cypress XT [Radeon HD 5870]
1002 0b00 Radeon HD 5870 Eyefinity⁶ Edition
106b 00d0 Radeon HD 5870 Mac Edition
# R5870-PM2D1G
1462 8032 Radeon HD 5870 1 GB GDDR5
174b 6870 Radeon HD 6870 1600SP Edition
6899 Cypress PRO [Radeon HD 5850]
# EAH5850
1043 0330 Radeon HD 5850
174b 237b Radeon HD 5850 X2
174b 6850 Radeon HD 6850 1440SP Edition
689b Cypress PRO [Radeon HD 6800 Series]
689c Hemlock [Radeon HD 5970]
1043 0352 ARES
689d Hemlock [Radeon HD 5970]
689e Cypress LE [Radeon HD 5830]
68a0 Broadway XT [Mobility Radeon HD 5870]
1028 12ef FirePro M7820
103c 1520 FirePro M7820
68a1 Broadway PRO [Mobility Radeon HD 5850]
106b 00cc iMac MC511 Mobility Radeon HD 5850 MXM Module
68a8 Granville [Radeon HD 6850M/6870M]
1025 0442 Radeon HD 6850M
1025 0451 Radeon HD 6850M
1025 050a Radeon HD 6850M
1025 050b Radeon HD 6850M
1025 050c Radeon HD 6850M
1025 050e Radeon HD 6850M
1025 050f Radeon HD 6850M
1025 0513 Radeon HD 6850M
1025 0514 Radeon HD 6850M
1025 0515 Radeon HD 6850M
1025 0516 Radeon HD 6850M
1025 0525 Radeon HD 6850M
1025 0526 Radeon HD 6850M
1025 056d Radeon HD 6850M
1028 048f Radeon HD 6870M
1028 0490 Radeon HD 6870M
1028 04b9 Radeon HD 6870M
1028 04ba Radeon HD 6870M
103c 159b Radeon HD 6850M
144d c0ad Radeon HD 6850M
68a9 Juniper XT [FirePro V5800]
13cc 3d1e MXRT-5400
13cc 3d20 MXRT-5450
68b8 Juniper XT [Radeon HD 5770]
106b 00cf MacPro5,1 [Mac Pro 2.8GHz DDR3]
68b9 Juniper LE [Radeon HD 5670 640SP Edition]
68ba Juniper XT [Radeon HD 6770]
68be Juniper PRO [Radeon HD 5750]
148c 3000 Radeon HD 6750
68bf Juniper PRO [Radeon HD 6750]
174b 6750 Radeon HD 6750
68c0 Madison [Mobility Radeon HD 5730 / 6570M]
1019 2383 Mobility Radeon HD 5730
1028 02a2 Mobility Radeon HD 5730
1028 02fe Mobility Radeon HD 5730
1028 0419 Mobility Radeon HD 5730
103c 147d Mobility Radeon HD 5730
103c 1521 Madison XT [FirePro M5800]
103c 1593 Mobility Radeon HD 6570
103c 1596 Mobility Radeon HD 6570
103c 1599 Mobility Radeon HD 6570
1043 1c22 Mobility Radeon HD 5730
17aa 3927 Mobility Radeon HD 5730
17aa 3952 Mobility Radeon HD 5730
17aa 3978 Radeon HD 6570M
68c1 Madison [Mobility Radeon HD 5650/5750 / 6530M/6550M]
1025 0205 Mobility Radeon HD 5650
1025 0293 Mobility Radeon HD 5650
1025 0294 Mobility Radeon HD 5650
1025 0296 Mobility Radeon HD 5650
1025 0308 Mobility Radeon HD 5650
1025 030a Mobility Radeon HD 5650
1025 0311 Mobility Radeon HD 5650
1025 0312 Mobility Radeon HD 5650
1025 031c Mobility Radeon HD 5650
1025 031d Mobility Radeon HD 5650
1025 033d Mobility Radeon HD 5650
1025 033e Mobility Radeon HD 5650
1025 033f Mobility Radeon HD 5650
1025 0346 Mobility Radeon HD 5650
1025 0347 Aspire 7740G
1025 0348 Mobility Radeon HD 5650
1025 0356 Mobility Radeon HD 5650
1025 0357 Mobility Radeon HD 5650
1025 0358 Mobility Radeon HD 5650
1025 0359 Mobility Radeon HD 5650
1025 035a Mobility Radeon HD 5650
1025 035b Mobility Radeon HD 5650
1025 035c Mobility Radeon HD 5650
1025 035d Mobility Radeon HD 5650
1025 035e Mobility Radeon HD 5650
1025 0360 Mobility Radeon HD 5650
1025 0362 Mobility Radeon HD 5650
1025 0364 Mobility Radeon HD 5650
1025 0365 Mobility Radeon HD 5650
1025 0366 Mobility Radeon HD 5650
1025 0367 Mobility Radeon HD 5650
1025 0368 Mobility Radeon HD 5650
1025 036c Mobility Radeon HD 5650
1025 036d Mobility Radeon HD 5650
1025 036e Mobility Radeon HD 5650
1025 036f Mobility Radeon HD 5650
1025 0372 Mobility Radeon HD 5650
1025 0373 Mobility Radeon HD 5650
1025 0377 Mobility Radeon HD 5650
1025 0378 Mobility Radeon HD 5650
1025 0379 Mobility Radeon HD 5650
1025 037a Mobility Radeon HD 5650
1025 037b Mobility Radeon HD 5650
1025 037e Mobility Radeon HD 5650
1025 037f Mobility Radeon HD 5650
1025 0382 Mobility Radeon HD 5650
1025 0383 Mobility Radeon HD 5650
1025 0384 Mobility Radeon HD 5650
1025 0385 Mobility Radeon HD 5650
1025 0386 Mobility Radeon HD 5650
1025 0387 Mobility Radeon HD 5650
1025 0388 Mobility Radeon HD 5650
1025 038b Mobility Radeon HD 5650
1025 038c Mobility Radeon HD 5650
1025 039a Mobility Radeon HD 5650
1025 0411 Mobility Radeon HD 5650
1025 0412 Mobility Radeon HD 5650
1025 0418 Mobility Radeon HD 5650
1025 0419 Mobility Radeon HD 5650
1025 0420 Mobility Radeon HD 5650
1025 0421 Mobility Radeon HD 5650
1025 0425 Mobility Radeon HD 5650
1025 042a Mobility Radeon HD 5650
1025 042e Mobility Radeon HD 5650
1025 042f Mobility Radeon HD 5650
1025 0432 Mobility Radeon HD 5650
1025 0433 Mobility Radeon HD 5650
1025 0442 Mobility Radeon HD 5650
1025 044c Mobility Radeon HD 5650
1025 044e Mobility Radeon HD 5650
1025 0451 Mobility Radeon HD 5650
1025 0454 Mobility Radeon HD 5650
1025 0455 Mobility Radeon HD 5650
1025 0475 Mobility Radeon HD 5650
1025 0476 Mobility Radeon HD 5650
1025 0487 Mobility Radeon HD 5650
1025 0489 Mobility Radeon HD 5650
1025 0498 Mobility Radeon HD 5650
1025 0517 Radeon HD 6550M
1025 051a Radeon HD 6550M
1025 051b Radeon HD 6550M
1025 051c Radeon HD 6550M
1025 051d Radeon HD 6550M
1025 0525 Radeon HD 6550M
1025 0526 Radeon HD 6550M
1025 052b Radeon HD 6550M
1025 052c Radeon HD 6550M
1025 053c Radeon HD 6550M
1025 053d Radeon HD 6550M
1025 053e Radeon HD 6550M
1025 053f Radeon HD 6550M
1025 0607 Radeon HD 6550M
1028 041b Mobility Radeon HD 5650
1028 0447 Mobility Radeon HD 5650
1028 0448 Mobility Radeon HD 5650
1028 0456 Mobility Radeon HD 5650
1028 0457 Mobility Radeon HD 5650
103c 1436 Mobility Radeon HD 5650
103c 1437 Mobility Radeon HD 5650
103c 1440 Mobility Radeon HD 5650
103c 1448 Mobility Radeon HD 5650
103c 1449 Mobility Radeon HD 5650
103c 144a Mobility Radeon HD 5650
103c 144b Mobility Radeon HD 5650
103c 147b Mobility Radeon HD 5650
103c 149c Mobility Radeon HD 5650
103c 149e Mobility Radeon HD 5650
103c 1521 Madison Pro [FirePro M5800]
1043 1bc2 Mobility Radeon HD 5650
104d 9071 Mobility Radeon HD 5650
104d 9077 Mobility Radeon HD 5650
104d 9081 Mobility Radeon HD 5650
1179 fd00 Mobility Radeon HD 5650
1179 fd12 Mobility Radeon HD 5650
1179 fd1a Mobility Radeon HD 5650
1179 fd30 Mobility Radeon HD 5650
1179 fd31 Mobility Radeon HD 5650
1179 fd50 Mobility Radeon HD 5650
1179 fd52 Radeon HD 6530M
1179 fd63 Radeon HD 6530M
1179 fd65 Radeon HD 6530M
1179 fdd0 Mobility Radeon HD 5650
1179 fdd2 Radeon HD 6530M
144d c07e Mobility Radeon HD 5650
144d c085 Mobility Radeon HD 5650
14c0 0043 Mobility Radeon HD 5650
14c0 004d Mobility Radeon HD 5650
17aa 3928 Mobility Radeon HD 5650
17aa 3951 Mobility Radeon HD 5650
17aa 3977 Radeon HD 6550M
68c7 Pinewood [Mobility Radeon HD 5570/6550A]
1462 2241 Mobility Radeon HD 5570
1462 2243 Mobility Radeon HD 5570
1462 2244 Mobility Radeon HD 5570
1462 2245 Radeon HD 6550A
1462 2246 Radeon HD 6550A
68c8 Redwood XT GL [FirePro V4800]
68c9 Redwood PRO GL [FirePro V3800]
13cc 3d1d MXRT-2400
68d8 Redwood XT [Radeon HD 5670/5690/5730]
1028 68e0 Radeon HD 5670
174b 5690 Radeon HD 5690
174b 5730 Radeon HD 5730
174b e151 Radeon HD 5670
1787 3000 Radeon HD 5730
17af 3010 Radeon HD 5730
17af 3011 Radeon HD 5690
68d9 Redwood PRO [Radeon HD 5550/5570/5630/6510/6610/7570]
103c 6870 Radeon HD 5570
103c 6872 Radeon HD 5570
1043 03ce Radeon HD 5550
1462 2151 Radeon HD 5570
1462 2240 Radeon HD 5570
148c 3000 Radeon HD 6510
148c 3001 Radeon HD 6610
1545 5550 Radeon HD 5550
1545 7570 Radeon HD 7570
1642 3985 Radeon HD 5570
1642 3996 Radeon HD 5570
174b 3000 Radeon HD 6510
174b 6510 Radeon HD 6510
174b 6610 Radeon HD 6610
174b e142 Radeon HD 5570
1787 3000 Radeon HD 6510
17af 3000 Radeon HD 6510
17af 3010 Radeon HD 5630
68da Redwood LE [Radeon HD 5550/5570/5630/6390/6490/7570]
148c 3000 Radeon HD 6390
148c 3001 Radeon HD 6490
1545 7570 Radeon HD 7570
174b 3000 Radeon HD 6390
174b 5570 Radeon HD 5570
174b 5630 Radeon HD 5630
174b 6490 Radeon HD 6490
1787 3000 Radeon HD 5630
17af 3000 Radeon HD 6390
17af 3010 Radeon HD 5630
68de Redwood
68e0 Park [Mobility Radeon HD 5430/5450/5470]
1028 0404 Mobility Radeon HD 5450
1028 0414 Mobility Radeon HD 5450
1028 0434 Mobility Radeon HD 5450
103c 1433 Mobility Radeon HD 5450
103c 1434 Mobility Radeon HD 5450
103c 1469 Mobility Radeon HD 5450
103c 146b Mobility Radeon HD 5450
103c 1486 TouchSmart tm2-2050er discrete GPU (Mobility Radeon HD 5450)
103c 1622 Mobility Radeon HD 5450
103c 1623 Mobility Radeon HD 5450
103c eeee Mobility Radeon HD 5450
104d 9076 Mobility Radeon HD 5450
1682 304e Caicos [Radeon HD 5450]
1682 6000 Caicos [Radeon HD 5450]
17aa 9e52 FirePro M3800
17aa 9e53 FirePro M3800
68e1 Park [Mobility Radeon HD 5430]
1043 041f Caicos [Radeon HD 7350]
1043 3000 Caicos [Radeon HD 5450]
148c 3000 Caicos [Radeon HD 5450]
148c 3001 Caicos [Radeon HD 6230]
148c 3002 Caicos [Radeon HD 6250]
148c 3003 Caicos [Radeon HD 6350]
148c 7350 Caicos [Radeon HD 7350]
148c 8350 Caicos [Radeon HD 8350]
1545 5450 Caicos [Radeon HD 5450]
1545 7350 Caicos [Radeon HD 7350]
1682 3000 Caicos [Radeon HD 5450]
1682 6000 Caicos [Radeon HD 5450]
1682 7350 Caicos [Radeon HD 7350]
174b 3000 Caicos [Radeon HD 5450]
174b 5470 Caicos [Radeon HD 5470]
174b 6000 Caicos [Radeon HD 5450]
174b 6230 Caicos [Radeon HD 6230]
174b 6350 Caicos [Radeon HD 6350]
174b 7350 Caicos [Radeon HD 7350]
1787 3000 Caicos [Radeon HD 5450]
17af 3000 Caicos [Radeon HD 5450]
17af 3001 Caicos [Radeon HD 6230]
17af 3014 Caicos [Radeon HD 6350]
17af 3015 Caicos [Radeon HD 7350]
17af 8350 Caicos [Radeon HD 8350 OEM]
68e4 Robson CE [Radeon HD 6370M/7370M]
1019 2386 Radeon HD 6350M
1019 2387 Radeon HD 6350M
1019 238d Radeon HD 6370M
1019 238e Radeon HD 6370M
1025 0382 Radeon HD 6370M
1025 0489 Radeon HD 6370M
1025 048a Radeon HD 6370M
1025 048b Radeon HD 6370M
1025 048c Radeon HD 6370M
1028 04c1 Radeon HD 6370M
1028 04ca Radeon HD 6370M
1028 04cc Radeon HD 6370M
1028 04cd Radeon HD 6370M
1028 04d7 Radeon HD 6370M
103c 1411 Radeon HD 6370M
103c 1421 Radeon HD 6370M
103c 1426 Radeon HD 6370M
103c 1428 Radeon HD 6370M
103c 142a Radeon HD 6370M
103c 142b Radeon HD 6370M
103c 143a Radeon HD 6370M
103c 143c Radeon HD 6370M
103c 1445 Radeon HD 6370M
103c 162c Radeon HD 6370M
103c 162d Radeon HD 6370M
103c 162e Radeon HD 6370M
103c 162f Radeon HD 6370M
103c 1639 Radeon HD 6370M
103c 163a Radeon HD 6370M
103c 163b Radeon HD 6370M
103c 163c Radeon HD 6370M
103c 163d Radeon HD 6370M
103c 163e Radeon HD 6370M
103c 163f Radeon HD 6370M
103c 1641 Radeon HD 6370M
103c 1643 Radeon HD 6370M
103c 3578 Radeon HD 6370M
103c 357a Radeon HD 6370M
103c 3673 Radeon HD 6370M
103c 3675 Radeon HD 6370M
1043 1c92 Radeon HD 6370M
1043 84a1 Radeon HD 6370M
1043 84ad Radeon HD 6370M
104d 9081 Radeon HD 6370M
1545 7350 Cedar [Radeon HD 7350]
1558 4510 Radeon HD 6370M
1558 5505 Radeon HD 6370M
174b 5450 Cedar [Radeon HD 5450]
17aa 21dd Radeon HD 6370M
17aa 21e9 Radeon HD 6370M
17aa 3971 Radeon HD 6370M
17aa 3972 Radeon HD 7370M
17aa 397a Radeon HD 6370M/7370M
17aa 397b Radeon HD 6370M/7370M
17aa 397f Radeon HD 7370M
68e5 Robson LE [Radeon HD 6330M]
1179 fd3c Radeon HD 6330M
1179 fd50 Radeon HD 6330M
1179 fd52 Radeon HD 6330M
1179 fd63 Radeon HD 6330M
1179 fd65 Radeon HD 6330M
1179 fd73 Radeon HD 6330M
1179 fd75 Radeon HD 6330M
1179 fdd0 Radeon HD 6330M
1179 fdd2 Radeon HD 6330M
1179 fdea Radeon HD 6330M
1179 fdf8 Radeon HD 6330M
148c 5450 Cedar [Radeon HD 5450]
148c 6350 Cedar [Radeon HD 6350]
148c 7350 Cedar [Radeon HD 7350]
148c 8350 Cedar [Radeon HD 8350]
1545 7350 Cedar [Radeon HD 7350]
68e8 Cedar
68e9 Cedar [ATI FirePro (FireGL) Graphics Adapter]
68f1 Cedar GL [FirePro 2460]
68f2 Cedar GL [FirePro 2270]
68f8 Cedar [Radeon HD 7300 Series]
68f9 Cedar [Radeon HD 5000/6000/7350/8350 Series]
1019 0001 Radeon HD 5450
1019 0002 Radeon HD 5450
1019 0019 Radeon HD 6350
1025 0518 Radeon HD 5450
1025 0519 Radeon HD 5450
1028 010e XPS 8300
1028 2126 Radeon HD 6350
103c 2126 Radeon HD 6350
103c 2aac Radeon HD 5450
103c 2aae Radeon HD 5450
103c 3580 Radeon HD 5450
1043 0386 Radeon HD 5450
1043 03c2 EAH5450 SILENT/DI/512MD2 (LP)
1462 2130 Radeon HD 5450
1462 2131 Radeon HD 5450
1462 2133 Radeon HD 6350
1462 2180 Radeon HD 5450
1462 2181 Radeon HD 5450
1462 2182 Radeon HD 6350
1462 2183 Radeon HD 6350
1462 2230 Radeon HD 5450
1462 2231 Radeon HD 5450
1462 2495 Radeon HD 6350
148c 3001 Radeon HD 5530/6250
148c 3002 Radeon HD 6290
148c 3003 Radeon HD 6230
148c 3004 Radeon HD 6350
148c 7350 Radeon HD 7350
148c 8350 Radeon HD 8350
1545 7350 Radeon HD 7350
1642 3983 Radeon HD 5450
1642 3984 Radeon HD 6350
1642 3987 Radeon HD 6350
1642 3997 Radeon HD 5450
1642 3a05 Radeon HD 5450
1642 3b31 Radeon HD 6350A
1682 3270 Radeon HD 7350
174b 3000 Radeon HD 6230
174b 3987 Radeon HD 6350
174b 5470 Radeon HD 5470
174b 5490 Radeon HD 5490
174b 5530 Radeon HD 5530
174b 6230 Radeon HD 6230
174b 6250 Radeon HD 6250
174b 6290 Radeon HD 6290
174b 6350 Radeon HD 6350
174b 7350 Radeon HD 7350
174b 8350 Radeon HD 8350
174b e127 Radeon HD 5450
174b e145 Radeon HD 5450
174b e153 Radeon HD 5450
1787 3000 Radeon HD 5470
1787 3001 Radeon HD 5530
1787 3002 Radeon HD 5490
17aa 3602 Radeon HD 5450
17aa 3603 Radeon HD 5450
17aa 360f Radeon HD 5450
17aa 3619 Radeon HD 5450
17af 3000 Radeon HD 6250
17af 3001 Radeon HD 6230
17af 3002 Radeon HD 6290
17af 3011 Radeon HD 5470
17af 3012 Radeon HD 5490
17af 3013 Radeon HD 5470
17af 3014 Radeon HD 6350
68fa Cedar [Radeon HD 7350/8350 / R5 220]
1019 0019 Radeon HD 7350
1019 0021 Radeon HD 7350
1019 0022 Radeon HD 7350
1019 0026 Radeon HD 8350
103c 2adf Radeon HD 7350A
103c 2ae8 Radeon HD 7350A
1043 8350 Radeon HD 8350
1462 2128 Radeon HD 7350
1462 2184 Radeon HD 7350
1462 2186 Radeon HD 7350
1462 2495 Radeon HD 7350
1462 b490 Radeon HD 7350
1642 3985 Radeon HD 7350
174b 3510 Radeon HD 8350
174b 3521 Radeon R5 220
174b 3522 Radeon R5 220
174b 7350 Radeon HD 7350
174b 8153 Radeon HD 8350
174b e127 Radeon HD 7350
174b e153 Radeon HD 7350
174b e180 Radeon HD 7350
17af 3015 Radeon HD 7350
68fe Cedar LE
6900 Topaz XT [Radeon R7 M260/M265 / M340/M360 / M440/M445 / 530/535 / 620/625 Mobile]
1025 1056 Radeon R7 M360 / R8 M365DX
1028 0640 Radeon R7 M260/M265
1028 0643 Radeon R7 M260/M265
1028 067f Radeon R7 M260
1028 0767 Radeon R7 M445
1028 0810 Radeon 530
1028 130a Radeon R7 M260
103c 2263 Radeon R7 M260
103c 2269 Radeon R7 M260
103c 22c6 Radeon R7 M260
103c 22c8 Radeon R7 M260
103c 2b45 Radeon R7 A360
103c 808c Radeon R7 M260
103c 8099 Radeon R7 M360
103c 80b5 Radeon R7 M360
103c 80b9 Radeon R7 M360
103c 811c Radeon R7 M340
103c 8226 Radeon R7 M440
10cf 1906 Radeon R7 M260
1170 9979 Radeon R7 M360
1179 f903 Radeon R7 M260
1179 f922 Radeon R7 M260
1179 f923 Radeon R7 M260
1179 f934 Radeon R7 M260
17aa 3822 Radeon R7 M360
17aa 3824 Radeon R7 M360
17aa 5021 Radeon R7 M260
6901 Topaz PRO [Radeon R5 M255]
103c 1318 Radeon R6 M255DX
6907 Meso XT [Radeon R5 M315]
6921 Amethyst XT [Radeon R9 M295X]
6929 Tonga XT GL [FirePro S7150]
692b Tonga PRO GL [FirePro W7100]
13cc 3d2b MXRT-7600
692f Tonga XTV GL [FirePro S7150V]
6938 Tonga XT / Amethyst XT [Radeon R9 380X / R9 M295X]
1043 04f5 Radeon R9 380X
1043 04f7 Radeon R9 380X
106b 013a Radeon R9 M295X Mac Edition
1458 22c8 Radeon R9 380X
148c 2350 Radeon R9 380X
1682 9385 Radeon R9 380X
174b e308 Radeon R9 380X Nitro 4G D5
17af 2006 Radeon R9 380X
6939 Tonga PRO [Radeon R9 285/380]
148c 9380 Radeon R9 380
# Make naming scheme consistent
174b e308 Radeon R9 380 Nitro 4G D5
694c Polaris 22 XT [Radeon RX Vega M GH]
694e Polaris 22 XL [Radeon RX Vega M GL]
694f Polaris 22 MGL XL [Radeon Pro WX Vega M GL]
6980 Polaris12
6981 Lexa XT [Radeon PRO WX 3200]
6985 Lexa XT [Radeon PRO WX 3100]
6986 Polaris12
6987 Lexa [Radeon 540X/550X/630 / RX 640 / E9171 MCM]
6995 Lexa XT [Radeon PRO WX 2100]
699f Lexa PRO [Radeon 540/540X/550/550X / RX 540X/550/550X]
1028 1720 Radeon RX 550X
148c 2380 Lexa XL [Radeon RX 550]
1da2 e367 Lexa PRO [Radeon RX 550]
69a0 Vega 12
69a1 Vega 12
69a2 Vega 12
69a3 Vega 12
69af Vega 12 [Radeon Pro Vega 20]
6fdf Polaris 20 XL [Radeon RX 580 2048SP]
700f RS100 AGP Bridge
7010 RS200/RS250 AGP Bridge
7100 R520 [Radeon X1800 XT]
7101 R520/M58 [Mobility Radeon X1800 XT]
7102 R520/M58 [Mobility Radeon X1800]
7104 R520 GL [FireGL V7200]
13cc 3d0a MXRT-5100
7109 R520 [Radeon X1800 XL]
1002 0322 All-in-Wonder X1800XL
1002 0d02 Radeon X1800 CrossFire Edition
710a R520 [Radeon X1800 GTO]
1002 0b12 Radeon X1800 GTO²
710b R520 [Radeon X1800 GTO]
710e R520 GL [FireGL V7300]
13cc 3d0c MXRT-5150
710f R520 GL [FireGL V7350]
13cc 3d0e MXRT-7100
7120 R520 [Radeon X1800] (Secondary)
7124 R520 GL [FireGL V7200] (Secondary)
13cc 3d0b MXRT-5100 (Secondary)
7129 R520 [Radeon X1800] (Secondary)
1002 0323 All-In-Wonder X1800 XL (Secondary)
1002 0d03 Radeon X1800 CrossFire Edition (Secondary)
712e R520 GL [FireGL V7300] (Secondary)
13cc 3d0d MXRT-5150 (Secondary)
712f R520 GL [FireGL V7350] (Secondary)
13cc 3d0f MXRT-7100 (Secondary)
7140 RV515 [Radeon X1300/X1550/X1600 Series]
7142 RV515 PRO [Radeon X1300/X1550 Series]
1002 0322 All-in-Wonder 2006 PCI-E Edition
1043 0142 EAX1300PRO/TD/256M
7143 RV505 [Radeon X1300/X1550 Series]
7145 RV515/M54 [Mobility Radeon X1400]
17aa 2006 Thinkpad T60 model 2007
7146 RV515 [Radeon X1300/X1550]
1002 0322 All-in-Wonder 2006 PCI-E Edition
1545 1996 Radeon X1300 512MB PCI-e
7147 RV505 [Radeon X1550 64-bit]
7149 RV515/M52 [Mobility Radeon X1300]
714a RV515/M52 [Mobility Radeon X1300]
7152 RV515 GL [FireGL V3300]
7153 RV515 GL [FireGL V3350]
715f RV505 CE [Radeon X1550 64-bit]
7162 RV515 PRO [Radeon X1300/X1550 Series] (Secondary)
1002 0323 All-in-Wonder 2006 PCI-E Edition (Secondary)
7163 RV505 [Radeon X1550 Series] (Secondary)
7166 RV515 [Radeon X1300/X1550 Series] (Secondary)
1002 0323 All-in-Wonder 2006 PCI-E Edition (Secondary)
1545 1997 Radeon X1300 512MB PCI-e (Secondary)
7167 RV515 [Radeon X1550 64-bit] (Secondary)
7172 RV515 GL [FireGL V3300] (Secondary)
7173 RV515 GL [FireGL V3350] (Secondary)
7181 RV516 [Radeon X1600/X1650 Series]
7183 RV516 [Radeon X1300/X1550 Series]
7186 RV516/M64 [Mobility Radeon X1450]
7187 RV516 [Radeon X1300/X1550 Series]
7188 RV516/M64-S [Mobility Radeon X2300]
103c 30c1 6910p
718a RV516/M64 [Mobility Radeon X2300]
718b RV516/M62 [Mobility Radeon X1350]
1071 8209 Medion MIM 2240 Notebook PC [MD98100]
718c RV516/M62-CSP64 [Mobility Radeon X1350]
718d RV516/M64-CSP128 [Mobility Radeon X1450]
7193 RV516 [Radeon X1550 Series]
7196 RV516/M62-S [Mobility Radeon X1350]
719b RV516 GL [FireMV 2250]
13cc 3d12 MXRT-1150
13cc 3d14 MXRT-2150
719f RV516 [Radeon X1550 Series]
71a0 RV516 [Radeon X1300/X1550 Series] (Secondary)
71a1 RV516 [Radeon X1600/X1650 Series] (Secondary)
71a3 RV516 [Radeon X1300/X1550 Series] (Secondary)
71a7 RV516 [Radeon X1300/X1550 Series] (Secondary)
71bb RV516 GL [FireMV 2250] (Secondary)
13cc 3d13 MXRT-1150 (Secondary)
13cc 3d15 MXRT-2150 (Secondary)
71c0 RV530 [Radeon X1600 XT/X1650 GTO]
1002 e160 Radeon X1650 GTO
174b e160 Radeon X1650 GTO
71c1 RV535 [Radeon X1650 PRO]
174b 0880 Radeon X1700 FSC
71c2 RV530 [Radeon X1600 PRO]
71c4 RV530/M56 GL [Mobility FireGL V5200]
17aa 2007 ThinkPad T60p
71c5 RV530/M56-P [Mobility Radeon X1600]
103c 309f Compaq nx9420 Notebook
103c 30a3 Compaq NW8440
1043 10b2 A6J-Q008
106b 0080 MacBook Pro
71c6 RV530LE [Radeon X1600/X1650 PRO]
71c7 RV535 [Radeon X1650 PRO]
1787 3000 PowerColor X1650 PRO AGP
71ce RV530 [Radeon X1300 XT/X1600 PRO]
71d2 RV530 GL [FireGL V3400]
13cc 3d08 MXRT-2100
71d4 RV530/M66 GL [Mobility FireGL V5250]
71d5 RV530/M66-P [Mobility Radeon X1700]
71d6 RV530/M66-XT [Mobility Radeon X1700]
71de RV530/M66 [Mobility Radeon X1700/X2500]
71e0 RV530 [Radeon X1600] (Secondary)
174b e161 Radeon X1600 GTO (Secondary)
71e1 RV535 [Radeon X1650 PRO] (Secondary)
174b 0881 Radeon X1700 FSC (Secondary)
71e2 RV530 [Radeon X1600] (Secondary)
71e6 RV530 [Radeon X1650] (Secondary)
71e7 RV535 [Radeon X1650 PRO] (Secondary)
1787 3001 Radeon X1650 PRO AGP
71f2 RV530 GL [FireGL V3400] (Secondary)
13cc 3d09 MXRT-2100 (Secondary)
7210 RV550/M71 [Mobility Radeon HD 2300]
7211 RV550/M71 [Mobility Radeon X2300 HD]
7240 R580+ [Radeon X1950 XTX]
1002 0d02 Radeon X1950 CrossFire Edition
7244 R580+ [Radeon X1950 XT]
7248 R580 [Radeon X1950]
7249 R580 [Radeon X1900 XT]
1002 0412 All-In-Wonder X1900
1002 0b12 Radeon X1900 XT/XTX
1002 0d02 Radeon X1900 CrossFire Edition
1043 0160 Radeon X1900 XTX 512 MB GDDR3
724b R580 [Radeon X1900 GT]
1002 0b12 Radeon X1900 (Primary)
1002 0b13 Radeon X1900 (Secondary)
724e R580 GL [FireGL V7350]
7269 R580 [Radeon X1900 XT] (Secondary)
726b R580 [Radeon X1900 GT] (Secondary)
726e R580 [AMD Stream Processor] (Secondary)
7280 RV570 [Radeon X1950 PRO]
7288 RV570 [Radeon X1950 GT]
7291 RV560 [Radeon X1650 XT]
1462 0810 Radeon X1700 SE
7293 RV560 [Radeon X1650 GT]
72a0 RV570 [Radeon X1950 PRO] (Secondary)
72a8 RV570 [Radeon X1950 GT] (Secondary)
72b1 RV560 [Radeon X1650 XT] (Secondary)
72b3 RV560 [Radeon X1650 GT] (Secondary)
7300 Fiji [Radeon R9 FURY / NANO Series]
1002 0b36 Radeon R9 FURY X / NANO
1002 1b36 Radeon Pro Duo
1043 049e Radeon R9 FURY
1043 04a0 Radeon R9 FURY X
174b e329 Radeon R9 FURY
7310 Navi 10
731f Navi 10 [Radeon RX 5700 / 5700 XT]
7833 RS350 Host Bridge
7834 RS350 [Radeon 9100 PRO/XT IGP]
7835 RS350M [Mobility Radeon 9000 IGP]
7838 RS350 AGP Bridge
7910 RS690 Host Bridge
1179 ff50 Satellite P305D-S8995E
17f2 5000 KI690-AM2 Motherboard
7911 RS690/RS740 Host Bridge
1002 7910 RS690/RS740 Host Bridge
7912 RS690/RS740 PCI to PCI Bridge (Internal gfx)
7913 RS690 PCI to PCI Bridge (PCI Express Graphics Port 0)
7915 RS690 PCI to PCI Bridge (PCI Express Port 1)
7916 RS690 PCI to PCI Bridge (PCI Express Port 2)
7917 RS690 PCI to PCI Bridge (PCI Express Port 3)
1002 7910 RS690 PCI to PCI Bridge
7919 RS690 HDMI Audio [Radeon Xpress 1200 Series]
1179 7919 Satellite P305D-S8995E
17f2 5000 KI690-AM2 Motherboard
791e RS690 [Radeon X1200]
1462 7327 K9AG Neo2
17f2 5000 KI690-AM2 Motherboard
791f RS690M [Radeon Xpress 1200/1250/1270]
1179 ff50 Satellite P305D-S8995E
7930 RS600 Host Bridge
7932 RS600 PCI to PCI Bridge (Internal gfx)
7933 RS600 PCI to PCI Bridge (PCI Express Graphics Port 0)
7935 RS600 PCI to PCI Bridge (PCI Express Port 1)
7936 RS600 PCI to PCI Bridge (PCI Express Port 2)
7937 RS690 PCI to PCI Bridge (PCI Express Port 3)
793b RS600 HDMI Audio [Radeon Xpress 1250]
793f RS690M [Radeon Xpress 1200/1250/1270] (Secondary)
7941 RS600 [Radeon Xpress 1250]
7942 RS600M [Radeon Xpress 1250]
796e RS740 [Radeon 2100]
105b 0e13 N15235/A74MX mainboard
9400 R600 [Radeon HD 2900 PRO/XT]
1002 2552 Radeon HD 2900 XT
1002 3000 Radeon HD 2900 PRO
1002 3142 HIS Radeon HD 2900XT 512MB GDDR3 VIVO PCIe
9401 R600 [Radeon HD 2900 XT]
9403 R600 [Radeon HD 2900 PRO]
9405 R600 [Radeon HD 2900 GT]
940a R600 GL [FireGL V8650]
13cc 3d16 MXRT-7200
940b R600 GL [FireGL V8600]
940f R600 GL [FireGL V7600]
9440 RV770 [Radeon HD 4870]
9441 R700 [Radeon HD 4870 X2]
9442 RV770 [Radeon HD 4850]
1002 0502 MSI Radeon HD 4850 512MB GDDR3
174b e810 Radeon HD 4850 512MB GDDR3
9443 R700 [Radeon HD 4850 X2]
9444 RV770 GL [FirePro V8750]
9446 RV770 GL [FirePro V7760]
944a RV770/M98L [Mobility Radeon HD 4850]
944b RV770/M98 [Mobility Radeon HD 4850 X2]
944c RV770 LE [Radeon HD 4830]
944e RV770 CE [Radeon HD 4710]
174b 3261 Radeon HD 4810
9450 RV770 GL [FireStream 9270]
9452 RV770 GL [FireStream 9250]
9456 RV770 GL [FirePro V8700]
945a RV770/M98-XT [Mobility Radeon HD 4870]
9460 RV790 [Radeon HD 4890]
9462 RV790 [Radeon HD 4860]
946a RV770 GL [FirePro M7750]
9480 RV730/M96 [Mobility Radeon HD 4650/5165]
103c 3628 Mobility Radeon HD 4650 [dv6-1190en]
9488 RV730/M96-XT [Mobility Radeon HD 4670]
9489 RV730/M96 GL [Mobility FireGL V5725]
9490 RV730 XT [Radeon HD 4670]
174b e880 Radeon HD 4670 512MB GDDR3 Dual DVI-I/TVO
9491 RV730/M96-CSP [Radeon E4690]
9495 RV730 [Radeon HD 4600 AGP Series]
1002 0028 Radeon HD 4650/4670 AGP
1092 0028 Radeon HD 4670 AGP 512MB DDR2
1458 0028 Radeon HD 4650 AGP
1682 0028 Radeon HD 4650 AGP
174b 0028 Radeon HD 4650 AGP DDR2
9498 RV730 PRO [Radeon HD 4650]
949c RV730 GL [FirePro V7750]
13cc 3d1b MXRT-7300
949e RV730 GL [FirePro V5700]
949f RV730 GL [FirePro V3750]
94a0 RV740/M97 [Mobility Radeon HD 4830]
94a1 RV740/M97-XT [Mobility Radeon HD 4860]
94a3 RV740/M97 GL [FirePro M7740]
94b3 RV740 PRO [Radeon HD 4770]
94b4 RV740 PRO [Radeon HD 4750]
94c1 RV610 [Radeon HD 2400 PRO/XT]
1028 0211 Optiplex 755
1028 0d02 Optiplex 755
94c3 RV610 [Radeon HD 2400 PRO]
1028 0302 Radeon HD 2400 Pro
174b e400 Radeon HD 2400 PRO
18bc 3550 Radeon HD 2400 PRO
94c4 RV610 LE [Radeon HD 2400 PRO AGP]
94c5 RV610 [Radeon HD 2400 LE]
94c7 RV610 [Radeon HD 2350]
94c8 RV610/M74 [Mobility Radeon HD 2400 XT]
94c9 RV610/M72-S [Mobility Radeon HD 2400]
1002 94c9 Radeon HD2400
94cb RV610 [Radeon E2400]
94cc RV610 LE [Radeon HD 2400 PRO PCI]
9500 RV670 [Radeon HD 3850 X2]
9501 RV670 [Radeon HD 3870]
174b e620 Radeon HD 3870
9504 RV670/M88 [Mobility Radeon HD 3850]
9505 RV670 [Radeon HD 3690/3850]
148c 3000 Radeon HD 3850
174b 3000 Radeon HD 3690/3850
1787 3000 Radeon HD 3690
9506 RV670/M88 [Mobility Radeon HD 3850 X2]
9507 RV670 [Radeon HD 3830]
9508 RV670/M88-XT [Mobility Radeon HD 3870]
9509 RV670/M88 [Mobility Radeon HD 3870 X2]
950f R680 [Radeon HD 3870 X2]
9511 RV670 GL [FireGL V7700]
9513 RV670 [Radeon HD 3850 X2]
9515 RV670 PRO [Radeon HD 3850 AGP]
9519 RV670 GL [FireStream 9170]
9540 RV710 [Radeon HD 4550]
954f RV710 [Radeon HD 4350/4550]
1462 1618 R4350 MD512H (MS-V161)
9552 RV710/M92 [Mobility Radeon HD 4330/4350/4550]
1028 1103 M92 [Mobility Radeon HD 4330]
# GV-R435OC-512I/FF1
1458 21ac Radeon HD 4350
# GV-R455HM-512I/F41
1458 21ed Radeon HD 4550
# 113-100928-J01
148c 3000 Radeon HD 4350 Go! Green 512MB GDDR3
# 113-2E172001-003
174b 3000 Radeon HD 4350/4550 HyperMemory DDR2
9553 RV710/M92 [Mobility Radeon HD 4530/4570/545v]
1025 015e Mobility Radeon HD 4570
1025 017d Mobility Radeon HD 4570
1025 0205 Mobility Radeon HD 4570 / 545v
1025 0206 Mobility Radeon HD 4570
1025 0237 Mobility Radeon HD 4570
1028 02be Mobility Radeon HD 4570 / 545v
1028 02e8 Mobility Radeon HD 4530
103c 143c Mobility Radeon HD 545v
103c 1446 Mobility Radeon HD 545v
103c 3624 Mobility Radeon HD 4530
103c 3628 Mobility Radeon HD 4530
103c 3636 Mobility Radeon HD 4530
1043 1b32 Mobility Radeon HD 4570
1043 1b42 Mobility Radeon HD 4570
104d 9056 Mobility Radeon HD 4570
1179 ff82 Satellite L505-13T GPU (Mobility Radeon HD 5145)
144d c07f Mobility Radeon HD 545v
144d c571 Mobility Radeon HD 545v
1462 1006 Mobility Radeon HD 545v
17aa 2129 Mobility Radeon HD 545v
17aa 215b Mobility Radeon HD 545v
17aa 21bb Mobility Radeon HD 545v
9555 RV710/M92 [Mobility Radeon HD 4350/4550]
103c 1411 ProBook 4720s GPU (Mobility Radeon HD 4350)
9557 RV711 GL [FirePro RG220]
955f RV710/M92 [Mobility Radeon HD 4330]
9580 RV630 [Radeon HD 2600 PRO]
9581 RV630/M76 [Mobility Radeon HD 2600]
9583 RV630/M76 [Mobility Radeon HD 2600 XT/2700]
106b 0083 iMac 7,1
1734 1107 Mobility Radeon HD 2700
9586 RV630 XT [Radeon HD 2600 XT AGP]
9587 RV630 PRO [Radeon HD 2600 PRO AGP]
9588 RV630 XT [Radeon HD 2600 XT]
1458 216c Radeon HD 2600 XT, 256MB GDDR3, 2x DVI, TV-out, PCIe (GV-RX26T256H)
9589 RV630 PRO [Radeon HD 2600 PRO]
# Rebranded HD 2600 PRO
1787 3000 Radeon HD 3610
958a RV630 [Radeon HD 2600 X2]
958b RV630/M76 [Mobility Radeon HD 2600 XT]
958c RV630 GL [FireGL V5600]
13cc 3d18 MXRT-5200
958d RV630 GL [FireGL V3600]
9591 RV635/M86 [Mobility Radeon HD 3650]
1002 9591 Mobility Radeon HD 3650
9593 RV635/M86 [Mobility Radeon HD 3670]
9595 RV635/M86 GL [Mobility FireGL V5700]
9596 RV635 PRO [Radeon HD 3650 AGP]
1043 0028 EAH3650 SILENT/HTDI/512M/A
9597 RV635 PRO [Radeon HD 3650 AGP]
9598 RV635 [Radeon HD 3650/3750/4570/4580]
1002 9598 Mobility Radeon HD 3600
1043 01d6 EAH3650 Silent
1043 3001 Radeon HD 4570
174b 3001 Radeon HD 3750
174b 4580 RV635 PRO [Radeon HD 4580]
17af 3011 RV635 PRO [Radeon HD 4580]
9599 RV635 PRO [Radeon HD 3650 AGP]
95c0 RV620 PRO [Radeon HD 3470]
1002 95c0 Mobility Radeon HD 3470
95c2 RV620/M82 [Mobility Radeon HD 3410/3430]
95c4 RV620/M82 [Mobility Radeon HD 3450/3470]
1002 95c4 Mobility Radeon HD 3400
95c5 RV620 LE [Radeon HD 3450]
1028 0342 OptiPlex 980
95c6 RV620 LE [Radeon HD 3450 AGP]
95c9 RV620 LE [Radeon HD 3450 PCI]
95cc RV620 GL [FirePro V3700]
95cd RV620 GL [FirePro 2450]
95cf RV620 GL [FirePro 2260]
960f RS780 HDMI Audio [Radeon 3000/3100 / HD 3200/3300]
9610 RS780 [Radeon HD 3200]
1458 d000 GA-MA78GM-S2H Motherboard
9611 RS780C [Radeon 3100]
9612 RS780M [Mobility Radeon HD 3200]
9613 RS780MC [Mobility Radeon HD 3100]
9614 RS780D [Radeon HD 3300]
9616 RS780L [Radeon 3000]
9640 Sumo [Radeon HD 6550D]
9641 Sumo [Radeon HD 6620G]
9642 SuperSumo [Radeon HD 6370D]
9643 SuperSumo [Radeon HD 6380G]
9644 SuperSumo [Radeon HD 6410D]
9645 SuperSumo [Radeon HD 6410D]
9647 Sumo [Radeon HD 6520G]
9648 Sumo [Radeon HD 6480G]
9649 SuperSumo [Radeon HD 6480G]
964a Sumo [Radeon HD 6530D]
964b Sumo
964c Sumo
964e Sumo
964f Sumo
970f RS880 HDMI Audio [Radeon HD 4200 Series]
1019 2120 A785GM-M
1043 83a2 M4A785TD Motherboard
1043 843e M5A88-V EVO
9710 RS880 [Radeon HD 4200]
1019 2120 A785GM-M
1043 83a2 M4A785TD Motherboard
9712 RS880M [Mobility Radeon HD 4225/4250]
9713 RS880M [Mobility Radeon HD 4100]
9714 RS880 [Radeon HD 4290]
9715 RS880 [Radeon HD 4250]
1043 843e M5A88-V EVO
# Radeon HD 6250 too?
9802 Wrestler [Radeon HD 6310]
174b 1001 PURE Fusion Mini
9803 Wrestler [Radeon HD 6310]
9804 Wrestler [Radeon HD 6250]
9805 Wrestler [Radeon HD 6250]
9806 Wrestler [Radeon HD 6320]
9807 Wrestler [Radeon HD 6290]
9808 Wrestler [Radeon HD 7340]
9809 Wrestler [Radeon HD 7310]
980a Wrestler [Radeon HD 7290]
9830 Kabini [Radeon HD 8400 / R3 Series]
9831 Kabini [Radeon HD 8400E]
9832 Kabini [Radeon HD 8330]
9833 Kabini [Radeon HD 8330E]
9834 Kabini [Radeon HD 8210]
9835 Kabini [Radeon HD 8310E]
9836 Kabini [Radeon HD 8280 / R3 Series]
9837 Kabini [Radeon HD 8280E]
9838 Kabini [Radeon HD 8240 / R3 Series]
9839 Kabini [Radeon HD 8180]
983d Temash [Radeon HD 8250/8280G]
9840 Kabini HDMI/DP Audio
9850 Mullins [Radeon R3 Graphics]
9851 Mullins [Radeon R4/R5 Graphics]
1179 f928 Beema [Radeon R5 Graphics]
9852 Mullins [Radeon R2 Graphics]
9853 Mullins [Radeon R2 Graphics]
9854 Mullins [Radeon R3E Graphics]
9855 Mullins [Radeon R6 Graphics]
9856 Mullins [Radeon R1E/R2E Graphics]
9857 Mullins [Radeon APU XX-2200M with R2 Graphics]
9858 Mullins
9859 Mullins
985a Mullins
985b Mullins
985c Mullins
985d Mullins
985e Mullins
985f Mullins
9874 Wani [Radeon R5/R6/R7 Graphics]
1002 1871 Radeon R5 Graphics
1002 1e20 Radeon R7 Graphics
1028 06bd Radeon R6 Graphics
103c 2b44 Radeon R6 Graphics
103c 8221 Radeon R5 Graphics
103c 8223 Radeon R5 Graphics
103c 8238 Radeon R7 Graphics
103c 8353 Radeon R7 Graphics
1458 d000 Radeon R7 Graphics
17aa 5113 Radeon R6 Graphics
17aa 5116 Radeon R6 Graphics
17aa 5118 Radeon R5 Graphics
9890 Amur
98c0 Nolan
98e4 Stoney [Radeon R2/R3/R4/R5 Graphics]
9900 Trinity [Radeon HD 7660G]
103c 1985 Pavilion 17-e163sg Notebook PC
# AMD A10-5800K CPU
9901 Trinity [Radeon HD 7660D]
9902 Trinity HDMI Audio Controller
103c 194e ProBook 455 G1 Notebook
103c 1985 Pavilion 17-e163sg Notebook PC
9903 Trinity [Radeon HD 7640G]
103c 194e ProBook 455 G1 Notebook
103c 1952 ProBook 455 G1 Notebook
9904 Trinity [Radeon HD 7560D]
9905 Trinity GL [FirePro A300]
9906 Trinity GL [FirePro A320]
9907 Trinity [Radeon HD 7620G]
9908 Trinity [Radeon HD 7600G]
9909 Trinity [Radeon HD 7500G]
990a Trinity [Radeon HD 7500G]
990b Richland [Radeon HD 8650G]
990c Richland [Radeon HD 8670D]
990d Richland [Radeon HD 8550G]
990e Richland [Radeon HD 8570D]
990f Richland [Radeon HD 8610G]
9910 Trinity [Radeon HD 7660G]
9913 Trinity [Radeon HD 7640G]
9917 Trinity [Radeon HD 7620G]
9918 Trinity [Radeon HD 7600G]
9919 Trinity [Radeon HD 7500G]
991e Bishop
9920 Liverpool [Playstation 4 APU]
9921 Liverpool HDMI/DP Audio Controller
9922 Starshp
9923 Starsha2 [Kingston/Clayton]
9924 Gladius
9925 Kingston/Clayton/Jupiter/Gladius/Montego HDMI Controller
9926 Jupiter
9990 Trinity 2 [Radeon HD 7520G]
9991 Trinity 2 [Radeon HD 7540D]
9992 Trinity 2 [Radeon HD 7420G]
9993 Trinity 2 [Radeon HD 7480D]
9994 Trinity 2 [Radeon HD 7400G]
9995 Richland [Radeon HD 8450G]
9996 Richland [Radeon HD 8470D]
9997 Richland [Radeon HD 8350G]
9998 Richland [Radeon HD 8370D]
9999 Richland [Radeon HD 8510G]
999a Richland [Radeon HD 8410G]
999b Richland [Radeon HD 8310G]
999c Richland [Radeon HD 8650D]
# AMD Quad-Core A8-Series APU A8-6500T with Radeon HD 8550D
999d Richland [Radeon HD 8550D]
99a0 Trinity 2 [Radeon HD 7520G]
99a2 Trinity 2 [Radeon HD 7420G]
99a4 Trinity 2 [Radeon HD 7400G]
aa00 R600 HDMI Audio [Radeon HD 2900 GT/PRO/XT]
aa01 RV635 HDMI Audio [Radeon HD 3650/3730/3750]
aa08 RV630 HDMI Audio [Radeon HD 2600 PRO/XT / HD 3610]
aa10 RV610 HDMI Audio [Radeon HD 2350 PRO / 2400 PRO/XT / HD 3410]
174b aa10 Radeon HD 2400 PRO
18bc aa10 Radeon HD 2400 PRO
aa18 RV670/680 HDMI Audio [Radeon HD 3690/3800 Series]
aa20 RV635 HDMI Audio [Radeon HD 3650/3730/3750]
aa28 RV620 HDMI Audio [Radeon HD 3450/3470/3550/3570]
aa30 RV770 HDMI Audio [Radeon HD 4850/4870]
174b aa30 Radeon HD 4850 512MB GDDR3 PCI-E Dual Slot Fansink
aa38 RV710/730 HDMI Audio [Radeon HD 4000 series]
103c 3628 dv6-1190en
aa50 Cypress HDMI Audio [Radeon HD 5830/5850/5870 / 6850/6870 Rebrand]
aa58 Juniper HDMI Audio [Radeon HD 5700 Series]
# 5500, 5600 and mobile 5700 series
aa60 Redwood HDMI Audio [Radeon HD 5000 Series]
1025 033d Mobility Radeon HD 5650
1025 0347 Aspire 7740G
aa68 Cedar HDMI Audio [Radeon HD 5400/6300/7300 Series]
1028 aa68 XPS 8300
aa80 Cayman/Antilles HDMI Audio [Radeon HD 6930/6950/6970/6990]
aa88 Barts HDMI Audio [Radeon HD 6790/6850/6870 / 7720 OEM]
aa90 Turks HDMI Audio [Radeon HD 6500/6600 / 6700M Series]
1028 04a3 Precision M4600
aa98 Caicos HDMI Audio [Radeon HD 6450 / 7450/8450/8490 OEM / R5 230/235/235X OEM]
174b aa98 Radeon HD 6450 1GB DDR3
aaa0 Tahiti HDMI Audio [Radeon HD 7870 XT / 7950/7970]
aab0 Oland/Hainan/Cape Verde/Pitcairn HDMI Audio [Radeon HD 7000 Series]
aab8 Tiran HDMI Audio
aac0 Tobago HDMI Audio [Radeon R7 360 / R9 360 OEM]
aac8 Hawaii HDMI Audio [Radeon R9 290/290X / 390/390X]
aad8 Tonga HDMI Audio [Radeon R9 285/380]
174b aad8 Radeon R9 285/380 HDMI Audio
aae0 Baffin HDMI/DP Audio [Radeon RX 550 640SP / RX 560/560X]
aae8 Fiji HDMI/DP Audio [Radeon R9 Nano / FURY/FURY X]
aaf0 Ellesmere HDMI Audio [Radeon RX 470/480 / 570/580/590]
aaf8 Vega 10 HDMI Audio [Radeon Vega 56/64]
ab00 Baffin HDMI/DP Audio [Radeon RX 550 640SP / RX 560/560X]
ab08 Polaris 22 HDMI Audio
ab10 Lexa HDMI Audio
ab18 Vega 12 HDMI Audio
ab20 Vega 20 HDMI Audio [Radeon VII]
ab38 Navi 10 HDMI Audio
ac00 Theater 506 World-Wide Analog Decoder
ac01 Theater 506 World-Wide Analog Decoder
ac02 TV Wonder HD 600 PCIe
ac03 Theater 506 PCIe
ac04 Theater 506 USB
ac05 Theater 506 USB
ac06 Theater 506 External USB
ac07 Theater 506 External USB
ac08 Theater 506A World-Wide Analog Decoder + Demodulator
ac09 Theater 506A World-Wide Analog Decoder + Demodulator
ac0a Theater 506A PCIe
ac0b Theater 506A PCIe
ac0c Theater 506A USB
ac0d Theater 506A USB
ac0e Theater 506A External USB
ac0f Theater 506A External USB
ac12 Theater HD T507 (DVB-T) TV tuner/capture device
cab0 RS100 Host Bridge
cab2 RS200 Host Bridge
cab3 RS250 Host Bridge
cbb2 RS200 Host Bridge
amdgpu-utils-2.6.0/GPUmodules/env.py 0000775 0000000 0000000 00000015347 13546003346 0017341 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
"""env.py - sets environment for amdgpu-utils and establishes global variables
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['Craig Echt - Testing, Debug, and Verification']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-utils'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import re
import subprocess
import platform
import sys
import shlex
import shutil
import time
from datetime import datetime
class GUT_CONST:
def __init__(self):
self.featuremask = '/sys/module/amdgpu/parameters/ppfeaturemask'
self.card_root = '/sys/class/drm/'
self.hwmon_sub = 'hwmon/hwmon'
self.execute_pac = False
self.DEBUG = False
self.PDEBUG = False
self.SIMLOG = False
self.LOG = False
self.PLOT = False
self.log_file_ptr = ''
self.show_fans = True
self.write_delta_only = False
self.SLEEP = 2
self.PATH = '.'
self.amdfeaturemask = ''
self.USELTZ = False
self.LTZ = datetime.utcnow().astimezone().tzinfo
if self.DEBUG: print('Local TZ: %s' % str(self.LTZ))
@staticmethod
def now(ltz=False):
if ltz:
return datetime.now()
return datetime.utcnow()
@staticmethod
def utc2local(utc):
# from https://stackoverflow.com/questions/4770297/convert-utc-datetime-string-to-local-datetime
epoch = time.mktime(utc.timetuple())
offset = datetime.fromtimestamp(epoch) - datetime.utcfromtimestamp(epoch)
return utc + offset
def read_amdfeaturemask(self):
with open(gut_const.featuremask) as fm_file:
self.amdfeaturemask = int(fm_file.readline())
return self.amdfeaturemask
def check_env(self):
# Check python version
required_pversion = [3, 6]
(python_major, python_minor, python_patch) = platform.python_version_tuple()
if self.DEBUG: print('Using python ' + python_major + '.' + python_minor + '.' + python_patch)
if int(python_major) < required_pversion[0]:
print('Using python' + python_major + ', but ' + __program_name__ +
' requires python ' + str(required_pversion[0]) + '.' + str(required_pversion[1]) + ' or higher.',
file=sys.stderr)
return -1
elif int(python_major) == required_pversion[0] and int(python_minor) < required_pversion[1]:
print('Using python ' + python_major + '.' + python_minor + '.' + python_patch + ', but ' +
__program_name__ + ' requires python ' + str(required_pversion[0]) + '.' +
str(required_pversion[1]) + ' or higher.', file=sys.stderr)
return -1
# Check Linux Kernel version
required_kversion = [4, 8]
linux_version = platform.release()
if int(linux_version.split('.')[0]) < required_kversion[0]:
print('Using Linux Kernel ' + linux_version + ', but ' + __program_name__ + ' requires > ' +
str(required_kversion[0]) + '.' + str(required_kversion[1]), file=sys.stderr)
return -2
elif int(linux_version.split('.')[0]) == required_kversion[0] and \
int(linux_version.split('.')[1]) < required_kversion[1]:
print('Using Linux Kernel ' + linux_version + ', but ' + __program_name__ + ' requires > ' +
str(required_kversion[0]) + '.' + str(required_kversion[1]), file=sys.stderr)
return -2
# Check AMD GPU Driver Version
lshw_out = subprocess.check_output(shlex.split('lshw -c video'), shell=False,
stderr=subprocess.DEVNULL).decode().split('\n')
for lshw_line in lshw_out:
searchObj = re.search('configuration:', lshw_line)
if searchObj:
lineitems = lshw_line.split(sep=':')
driver_str = lineitems[1].strip()
searchObj = re.search('driver=amdgpu', driver_str)
if searchObj:
return 0
else:
print(f'amdgpu-utils non-compatible driver: {driver_str}')
print(f'amdgpu-utils requires AMD \'amdgpu\' driver package in order to function.')
return -3
return 0
def get_amd_driver_version(self):
if not shutil.which('/usr/bin/dpkg'):
print('can not determine amdgpu version')
return -1
version_ok = False
for pkgname in ['amdgpu', 'amdgpu-core', 'amdgpu-pro']:
try:
dpkg_out = subprocess.check_output(shlex.split(f'dpkg -l {pkgname}'), shell=False,
stderr=subprocess.DEVNULL).decode().split('\n')
for dpkg_line in dpkg_out:
searchObj = re.search('amdgpu', dpkg_line)
if searchObj:
if self.DEBUG: print('Debug: {}'.format(dpkg_line))
dpkg_items = dpkg_line.split()
if len(dpkg_items) > 2:
if re.fullmatch(r'.*none.*', dpkg_items[2]):
continue
else:
print(f'amdgpu version: {dpkg_items[2]}')
version_ok = True
break
if version_ok:
break
except subprocess.CalledProcessError:
pass
except OSError:
pass
if not version_ok:
print('amdgpu version: UNKNOWN')
return -1
return 0
gut_const = GUT_CONST()
def about():
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
if __name__ == '__main__':
about()
amdgpu-utils-2.6.0/LICENSE 0000664 0000000 0000000 00000104515 13546003346 0015151 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
amdgpu-utils-2.6.0/README.md 0000664 0000000 0000000 00000030403 13546003346 0015415 0 ustar 00root root 0000000 0000000 # amdgpu-utils
A set of utilities for monitoring AMD GPU performance and modifying control settings.
In order to use any of these utilities, you must have the *amdgpu* open source driver
package installed. You also must first set your Linux machine to boot with
amdgpu.ppfeaturemask=0xffff7fff or 0xfffd7fff. This can be accomplished by adding
amdgpu.ppfeaturemask=0xffff7fff to the GRUB_CMDLINE_LINUX_DEFAULT value in
/etc/default/grub and executing *sudo update-grub*
Check out the [User Guide](docs/USER_GUIDE.md)!
Download latest official release: [v2.6.0](https://github.com/Ricks-Lab/amdgpu-utils/releases/tag/v2.6.0)
Or use this development version from master branch.
## amdgpu-chk
This utility verifies if the environment is compatible with *amdgpu-util*s.
## amdgpu-ls
This utility displays most relevant parameters for installed and compatible AMD GPUs.
The default behavior is to list relevant parameters by GPU. OpenCL platform information
is added when the *--clinfo* option is used. The *--no_fan* can be used to ignore fan
settings. The *--pstate* option can be used to output the p-state table for each GPU
instead of the list of basic parameters. The *--ppm* option is used to output the table
of available power/performance modes instead of basic parameters.
## amdgpu-monitor
A utility to give the current state of all compatible AMD GPUs. The default behavior
is to continuously update a text based table in the current window until Ctrl-C is
pressed. With the *--gui* option, a table of relevant parameters will be updated
in a Gtk window. You can specify the delay between updates with the *--sleep N*
option where N is an integer > zero that specifies the number of seconds to sleep
between updates. The *--no_fan* option can be used to disable the reading and display
of fan information. The *--log* option is used to write all monitor data to a psv log
file. When writing to a log file, the utility will indicate this in red at the top of
the window with a message that includes the log file name. The *--plot* will display a
plot of critical GPU parameters which updates at the specified *--sleep N* interval. If
you need both the plot and monitor displays, then using the --plot option is preferred
over running both tools as a single read of the GPUs is used to update both displays.
The *--ltz* option results in the use of local time instead of UTC.
## amdgpu-plot
A utility to continuously plot the trend of critical GPU parameters for all compatible
AMD GPUs. The *--sleep N* can be used to specify the update interval. The *amdgpu-plot*
utility has 2 modes of operation. The default mode is to read the GPU driver details
directly, which is useful as a standalone utility. The *--stdin* option causes
*amdgpu-plot* to read GPU data from stdin. This is how *amdgpu-monitor* produces the
plot and can also be used to pipe your own data into the process. The *--simlog*
option can be used with the *--stdin* when a monitor log file is piped as stdin.
This is useful for troubleshooting and can be used to display saved log results.
The *--ltz* option results in the use of local time instead of UTC. If you plan
to run both *amdgpu-plot* and *amdgpu-monitor*, then the *--plot* option of the
*amdgpu-monitor* utility should be used instead of both utilities in order reduce
data reads by a factor of 2.
## amdgpu-pac
Program and Control compatible AMD GPUs with this utility. By default, the commands to
be written to a GPU are written to a bash file for the user to inspect and run. If you
have confidence, the *--execute_pac* option can be used to execute and then delete the
saved bash file. Since the GPU device files are writable only by root, sudo is used to
execute commands in the bash file, as a result, you will be prompted for credentials in the
terminal where you executed *amdgpu-pac*. The *--no_fan* option can be used to eliminate
fan details from the utility. The *--force_write* option can be used to force all configuration
parameters to be written to the GPU. The default behavior is to only write changes.
## amdgpu-pciid
This utility will display the version of the current pci.ids data extract
in use. With the *--download* option, the latest pci.ids file from
https://pci-ids.ucw.cz/ will be downloaded. With the *--install* option,
the latest pci.ids will be downloaded and filtered for AMD specific data
and written to the file used by amdgpu-utils to decode device names from the
driver provided device id. The *--force* option can be used to update this
file even if there is no change in version. If your GPU model is missing
from the pci.ids file, you can use the device id of your card found with
*amdgpu-ls* and make a request for the addition on the pci.ids website.
## New in this Release - [v2.6.0](https://github.com/Ricks-Lab/amdgpu-utils/releases/tag/v2.6.0)
* PEP8 style modifications
* Fixed a bug in monitor display.
* Implement requirements file for with and without a venv.
* Found and fixed a few minor bugs.
* Fixed issue with *amdgpu-plot* becoming corrupt over time.
* Implemented clean shutdown of monitor and better buffering to plot. This could have caused in problems in systems with many GPUs.
## Development Plans
* Enhance formatting in Gtk monitor tool. Need to improve my Gtk skills!
## Known Issues
* I/O error when selecting CUSTOM ppm. Maybe it requires arguments to specify the custom configuration.
* Doesn't work well with Fiji ProDuo cards.
* P-state mask gets intermittently reset for GPU used as display output.
* *amdgpu-pac* doesn't show what the current P-state mask is. Not sure if that can be read back.
* *amdgpu-pac* fan speed setting results in actual fan speeds a bit different from setting and pac interface shows actual values instead of set values.
## References
* Original inspiration for this project: Reddit
* Phoronix articles including these: Phoronix Power Cap, Phoronix HWMon
* Repositories: amdgpu-clocks, WattmanGTK, ROC-smi
* Relevant Kernel Details: Kernel Details
* PCI ID Decode Table: PCI IDs
* Radeon VII discussion on Reddit: Radeon VII Overclocking
## History
#### New in Previous Release - [v2.5.2](https://github.com/Ricks-Lab/amdgpu-utils/releases/tag/v2.5.2)
* Some preparation work for Debian package (@smoe).
* Added *--ltz* option to use local times instead of UTC for logging and plot data.
* Added 0xfffd7fff to valid amdgpu.ppfeaturemask values (@pastaq).
* Updates to User Guide to include instructions to apply PAC conditions on startup (@csecht).
#### New in Previous Release - [v2.5.1](https://github.com/Ricks-Lab/amdgpu-utils/releases/tag/v2.5.1)
* Fixed a compatibility issue with matplotlib 3.x. Converted time string to a datetime object.
* Display version information for pandas, matplotlib, and numpy with the *--about* option for *amdgpu-plot*
#### New in Previous Release - [v2.5.0](https://github.com/Ricks-Lab/amdgpu-utils/releases/tag/v2.5.0)
* Implemented the *--plot* option for amdgpu-monitor. This will display plots of critical GPU parameters that update at an interval defined by the *--sleep N* option.
* Errors in reading non-critical parameters will now show a warning the first time and are disabled for future reads.
* Fixed a bug in implementation of compatibility checks and improved usage of try/except.
#### New in Previous Release - [v2.4.0](https://github.com/Ricks-Lab/amdgpu-utils/releases/tag/v2.4.0)
* Implemented *amdgpu-pac* feature for type 2 Freq/Voltage controlled GPUs, which includes the Radeon VII.
* Implemented the *amdgpu-pac --force_write* option, which writes all configuration parameters to the GPU, even if unchanged. The default behavior is changed to now only write changed configuration parameters.
* Indicate number of changes to be written by PAC, and if no changes, don't execute bash file. Display execute complete message in terminal, and update messages in PAC message box.
* Implemented a new GPU type 0, which represent some older cards whose p-states can not be changed.
* Tuned *amdgpu-pac* window format.
#### New in Previous Release - [v2.3.1](https://github.com/Ricks-Lab/amdgpu-utils/releases/tag/v2.3.1)
* Fixed and improved Python/Kernel compatibility checks.
* Added Python2 compatible utility to check *amdgpu-utils* compatibility.
* Fixed confusing mode/level fileptr names.
* Removed CUSTOM PPM mode until I figure out syntax.
* Implemented classification of card type based on how it implements frequency/voltage control. This is reported by *amdgpu-ls* and alters the behavior of both *amdgpu-pac* and *amdgpu-monitor*.
* Changed dpkg error to a warning to handle custom driver installs.
* Initial [User Guide](docs/USER_GUIDE.md) - [Need contributors!](https://github.com/Ricks-Lab/amdgpu-utils/issues/13)
#### New in Previous Release - v2.3.0
* Implemented a message box in amdgpu-pac to indicate details of PAC execution and indicate if sudo is pending credential entry.
* Implement more robust classification of card compatibility and only use compatible GPUs in the utilities.
* Official release of amdgpu-pciid which updates a local list of GPU names from the official pci.ids website.
* Optimized refresh of data by moving static items to a different function and only read those that are dynamic.
* Power Cap and Fan parameters can be reset by setting to -1 in the *amdgpu-pac* interface.
* Initial basic functionality for Radeon VII GPU!
#### New in Previous Release - v2.2.0
* Major bug fix in the way HWMON directory was determined. This fixes an issue in not seeing sensor files correctly when a some other card is resident in a PCIe slot.
* Implemented logging option *--log* for amdgpu-monitor. A red indicator will indicate active logging and the target filename.
* Implemented energy meter in amdgpu-monitor.
* Implemented the ability to check the GPU extracted ID in a pci.ids file for correct model name. Implemented a function to extract only AMD information for the pci.ids file and store in the file amd_pci_id.txt which is included in this distribution.
* Optimized long, short, and decoded GPU model names.
* Alpha release of a utility to update device decode data from the pci.ids website.
#### New in Previous Release - v2.1.0
* Significant bug fixes and error proofing. Added messages to stderr for missing driver related files.
* Added fan monitor and control features.
* Implemented --no_fan option across all tools. This eliminates the reading and display of fan parameters and useful for those who have installed GPU waterblocks.
* Implemented P-state masking, which limits available P-states to those specified. Useful for power management.
* Fixed implementation of global variables that broke with implementation of modules in library.
* Added more validation checks before writing parameters to cards.
#### New in Previous Release - v2.0.0
* Many bug fixes!
* First release of amdgpu-pac.
* Add check of amdgpu driver in the check of environment for all utilities. Add display of amdgpu driver version.
* Split list functions of the original amdgpu-monitor into amdgpu-ls.
* Added --clinfo option to amdgpu-ls which will list openCL platform details for each GPU.
* Added --ppm option to amdgpu-ls which will display the table of available power/performance modes available for each GPU.
* Error messages are now output to stderr instead stdout.
* Added power cap and power/performance mode to the monitor utilities. I have also included them in the amdgpu-ls display in addtion to the power cap limits.
#### New in Previous Release - v1.1.0
* Added --pstates feature to display table of p-states instead of GPU details.
* Added more error checking and exit if no compatible AMD GPUs are found.
#### New in Previous Release - v1.0.0
* Completed implementation of the GPU Monitor tool.
amdgpu-utils-2.6.0/amdgpu-chk 0000775 0000000 0000000 00000016442 13546003346 0016113 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
""" amdgpu-chk - Checks OS/Python compatibility
This utility verifies if the environment is compatible with amdgpu-utils.
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['Craig Echt - Testing, Debug, Verification, and Documentation']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-chk'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import argparse
import re
import subprocess
import os
import shlex
import platform
import sys
import shutil
import warnings
warnings.filterwarnings('ignore')
class GUT_CONST:
def __init__(self):
self.DEBUG = False
@staticmethod
def check_env():
ret_val = [0, 0, 0]
# Check python version
required_pversion = [3, 6]
(python_major, python_minor, python_patch) = platform.python_version_tuple()
print('Using python ' + python_major + '.' + python_minor + '.' + python_patch)
if int(python_major) < required_pversion[0]:
print(' ' + '\x1b[1;37;41m' + ' but amdgpu-utils requires python ' +
str(required_pversion[0]) + '.' + str(required_pversion[1]) + ' or newer.' + '\x1b[0m')
ret_val[0] = -1
elif int(python_major) == required_pversion[0] and int(python_minor) < required_pversion[1]:
print(' ' + '\x1b[1;37;41m' + ' but amdgpu-utils requires python ' +
str(required_pversion[0]) + '.' + str(required_pversion[1]) + ' or newer.' + '\x1b[0m')
ret_val[0] = -1
else:
print(' ' + '\x1b[1;37;42m' + ' Python version OK. ' + '\x1b[0m')
ret_val[0] = 0
# Check Linux Kernel version
required_kversion = [4, 8]
linux_version = platform.release()
print('Using Linux Kernel ' + str(linux_version))
if int(linux_version.split('.')[0]) < required_kversion[0]:
print(' ' + '\x1b[1;37;41m' + ' but amdgpu-util requires ' +
str(required_kversion[0]) + '.' + str(required_kversion[1]) + ' or newer.' + '\x1b[0m')
ret_val[1] = -2
elif int(linux_version.split('.')[0]) == required_kversion[0] and \
int(linux_version.split('.')[1]) < required_kversion[1]:
print(' ' + '\x1b[1;37;41m' + ' but amdgpu-util requires ' +
str(required_kversion[0]) + '.' + str(required_kversion[1]) + ' or newer.' + '\x1b[0m')
ret_val[1] = -2
else:
print(' ' + '\x1b[1;37;42m' + ' OS kernel OK. ' + '\x1b[0m')
ret_val[1] = 0
# Check for amdgpu driver
required_aversion = 'driver=amdgpu'
lshw_out = subprocess.check_output(shlex.split('lshw -c video'), shell=False,
stderr=subprocess.DEVNULL).decode().split('\n')
config_found = False
driver_str = ''
for lshw_line in lshw_out:
searchObj = re.search('configuration:', lshw_line)
if searchObj:
config_found = True
lineitems = lshw_line.split(sep=':')
driver_str = lineitems[1].strip()
searchObj = re.search(required_aversion, driver_str)
break
if not config_found:
driver_str = 'not detected'
print('AMD GPU driver not detected')
print(' ' + '\x1b[1;37;41m' + ' AMD\'s \'amdgpu\' driver package is required. ' + '\x1b[0m')
ret_val[2] = -3
if searchObj:
print('AMD GPU driver is ' + driver_str)
print(' ' + '\x1b[1;37;42m' + ' AMD driver OK. ' + '\x1b[0m')
ret_val[2] = 0
else:
print('AMD GPU driver is ' + driver_str)
print(' ' + '\x1b[1;37;41m' + ' AMD\'s \'amdgpu\' driver package is required. ' + '\x1b[0m')
ret_val[2] = -3
return ret_val
gut_const = GUT_CONST()
def is_venv_installed():
cmdstr = 'python3 -m venv -h > /dev/null'
try:
p = subprocess.Popen(shlex.split(cmdstr), shell=False, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, error = p.communicate()
# print('subprocess output: ', output.decode(), 'subprocess error: ', error.decode())
if not re.fullmatch(r'.*No module named.*', output.decode()):
print('python3 venv is installed')
print(' ' + '\x1b[1;37;42m' + ' python3-venv OK. ' + '\x1b[0m')
return True
except:
pass
print('python3 venv is NOT installed')
print(' ' + '\x1b[1;30;43m' + ' Python3 venv package \'python3-venv\' package is recommended. ' +
'\x1b[0m')
return False
def does_amdgpu_utils_env_exist():
env_name = './amdgpu-utils-env/bin/activate'
if os.path.isfile(env_name):
print('amdgpu-utils-env available')
print(' ' + '\x1b[1;37;42m' + ' amdgpu-utils-env OK. ' + '\x1b[0m')
return True
print('amdgpu-utils-env is NOT available')
print(' ' + '\x1b[1;30;43m' + ' amdgpu-utils-env should be configured per User Guide. ' + '\x1b[0m')
return False
def is_in_venv():
python_path = shutil.which('python')
if re.fullmatch(r'.*amdgpu-utils-env.*', python_path):
print('In amdgpu-utils-env')
print(' ' + '\x1b[1;37;42m' + ' amdgpu-utils-env is activated. ' + '\x1b[0m')
return True
print('Not in amdgpu-utils-env')
print(' ' + '\x1b[1;30;43m' + ' amdgpu-utils-env should be activated per User Guide. ' + '\x1b[0m')
return False
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--about', help='README', action='store_true', default=False)
parser.add_argument('-d', '--debug', help='Debug output', action='store_true', default=False)
args = parser.parse_args()
# About me
if args.about:
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
gut_const.DEBUG = args.debug
if gut_const.check_env() != [0, 0, 0]:
print('Error in environment. Exiting...')
sys.exit(-1)
if not is_venv_installed() or not does_amdgpu_utils_env_exist():
print('Environment not configured. WARNING')
if not is_in_venv():
print('Virtual Environment not activated. WARNING')
if __name__ == '__main__':
main()
amdgpu-utils-2.6.0/amdgpu-ls 0000775 0000000 0000000 00000012466 13546003346 0015766 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
""" amdgpu-ls - Displays details about installed AMD GPUs
This utility displays most relevant parameters for installed and compatible AMD GPUs.
The default behavior is to list relevant parameters by GPU. OpenCL platform information
is added when the *--clinfo* option is used. The *--no_fan* can be used to ignore fan
settings. The *--pstate* option can be used to output the p-state table for each GPU
instead of the list of basic parameters. The *--ppm* option is used to output the table
of available power/performance modes instead of basic parameters.
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['Craig Echt - Testing, Debug, Verification, and Documentation']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-ls'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import argparse
import os
import sys
from GPUmodules import GPUmodule as GPU
from GPUmodules import env
from pathlib import Path
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--about', help='README',
action='store_true', default=False)
parser.add_argument('--pstates', help='Output pstate tables instead of GPU details',
action='store_true', default=False)
parser.add_argument('--ppm', help='Output power/performance mode tables instead of GPU details',
action='store_true', default=False)
parser.add_argument('--clinfo', help='Include openCL with card details',
action='store_true', default=False)
parser.add_argument('--no_fan', help='do not include fan setting options',
action='store_true', default=False)
parser.add_argument('-d', '--debug', help='Debug output',
action='store_true', default=False)
args = parser.parse_args()
# About me
if args.about:
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
env.gut_const.PATH = os.path.dirname(str(Path(__file__).resolve()))
env.gut_const.DEBUG = args.debug
if args.no_fan:
env.gut_const.show_fans = False
if env.gut_const.check_env() < 0:
print('Error in environment. Exiting...')
sys.exit(-1)
# Check value of AMD Feature mask
try:
featuremask = env.gut_const.read_amdfeaturemask()
except FileNotFoundError:
print('Cannot read ppfeaturemask. Exiting...')
sys.exit(-1)
if featuremask == int(0xffff7fff) or featuremask == int(0xffffffff) or featuremask == int(0xfffd7fff):
print('AMD Wattman features enabled: %s' % hex(featuremask))
else:
print('AMD Wattman features not enabled: %s, See README file.' % hex(featuremask))
sys.exit(-1)
env.gut_const.get_amd_driver_version()
# Get list of AMD GPUs and get basic non-driver details
gpu_list = GPU.GPU_LIST()
gpu_list.get_gpu_list()
gpu_list.read_allgpu_pci_info()
# Check list of AMD GPUs
num_amd_gpus = gpu_list.num_gpus()
num_com_gpus = gpu_list.num_compatible_gpus()
if num_amd_gpus == 0:
print('No AMD GPUs detected, exiting...')
sys.exit(-1)
else:
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
print(f'{num_amd_gpus} AMD GPUs detected, {num_com_gpus} may be compatible, checking...')
# Read data static driver information for GPUs
gpu_list.read_gpu_driver_info()
gpu_list.read_gpu_sensor_static_data()
# Read dynamic sensor and state data from GPUs
gpu_list.read_gpu_sensor_data()
gpu_list.read_gpu_state_data()
# Check number of compatible GPUs again
num_com_gpus = gpu_list.num_compatible_gpus()
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
else:
print(f'{num_com_gpus} are confirmed compatible.')
print('')
# Read report specific details
if args.clinfo:
if gpu_list.read_gpu_opencl_data() < 0:
args.clinfo = False
gpu_list.read_gpu_pstates()
gpu_list.read_gpu_ppm_table()
# Print out user requested details
if args.pstates:
gpu_list.print_pstates()
if args.ppm:
gpu_list.print_ppm_table()
if not args.pstates and not args.ppm:
gpu_list.print(args.clinfo)
sys.exit(0)
if __name__ == '__main__':
main()
amdgpu-utils-2.6.0/amdgpu-monitor 0000775 0000000 0000000 00000032665 13546003346 0017042 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
""" amdgpu-monitor - Displays current status of all active GPUs
A utility to give the current state of all compatible AMD GPUs. The default behavior
is to continuously update a text based table in the current window until Ctrl-C is
pressed. With the *--gui* option, a table of relevant parameters will be updated
in a Gtk window. You can specify the delay between updates with the *--sleep N*
option where N is an integer > zero that specifies the number of seconds to sleep
between updates. The *--no_fan* option can be used to disable the reading and display
of fan information. The *--log* option is used to write all monitor data to a psv log
file. When writing to a log file, the utility will indicate this in red at the top of
the window with a message that includes the log file name. The *--plot* will display a
plot of critical GPU parameters which updates at the specified *--sleep N* interval. If
you need both the plot and monitor displays, then using the --plot option is preferred
over running both tools as a single read of the GPUs is used to update both displays.
The *--ltz* option results in the use of local time instead of UTC.
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['Craig Echt - Testing, Debug, Verification, and Documentation']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-monitor'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import argparse
import subprocess
import threading
import os
import sys
import shlex
import time
from pathlib import Path
try:
import gi
except ModuleNotFoundError as error:
print('gi import error: {}'.format(error))
print('gi is required for %s', __program_name__)
print(' In a venv, first install vext: pip install --no-cache-dir vext')
print(' Then install vext.gi: pip install --no-cache-dir vext.gi')
sys.exit(0)
gi.require_version('Gtk', '3.0')
from gi.repository import GLib, Gtk, Gdk
from GPUmodules import GPUmodule as GPU
from GPUmodules import env
class MonitorWindow(Gtk.Window):
def __init__(self, gpu_list, devices):
self.quit = False
Gtk.Window.__init__(self, title='amdgpu-monitor')
self.set_border_width(1)
icon_file = os.path.join(env.gut_const.PATH, 'icons', 'amdgpu-monitor.icon.png')
if os.path.isfile(icon_file):
self.set_icon_from_file(icon_file)
grid = Gtk.Grid()
grid.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1, 1, 1, 1))
self.add(grid)
col = 0
row = 0
num_amd_gpus = gpu_list.num_gpus()
if env.gut_const.LOG:
log_label = Gtk.Label()
log_label.set_markup(' Logging to: ' + env.gut_const.log_file + '')
log_label.override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.60, .20, .20, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(log_label, True, True, 0)
grid.attach(lbox, 0, row, num_amd_gpus+1, 1)
row += 1
row_start = row
row = row_start
row_labels = {'card_num': Gtk.Label()}
row_labels['card_num'].set_markup('Card #')
row_labels['card_num'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
for k, v in gpu_list.table_param_labels.items():
row_labels[k] = Gtk.Label()
row_labels[k].set_markup('' + str(v) + '')
row_labels[k].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
for k, v in row_labels.items():
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.20, .40, .60, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
v.set_property('margin-top', 1)
v.set_property('margin-bottom', 1)
v.set_property('margin-right', 4)
v.set_property('margin-left', 4)
lbox.pack_start(v, True, True, 0)
grid.attach(lbox, col, row, 1, 1)
v.set_alignment(0, 0.5)
row += 1
for k, v in gpu_list.list.items():
devices[v.uuid] = {'card_num': Gtk.Label(label='card' + v.get_params_value('card_num'))}
for cv in gpu_list.table_param_labels:
devices[v.uuid][cv] = Gtk.Label(label=v.get_params_value(str(cv)))
devices[v.uuid][cv].set_width_chars(10)
for dk, dv in devices.items():
col += 1
row = row_start
for lk, lv in dv.items():
lv.set_text('')
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lv.set_property('margin-top', 1)
lv.set_property('margin-bottom', 1)
lv.set_property('margin-right', 3)
lv.set_property('margin-left', 3)
lv.set_width_chars(17)
lbox.pack_start(lv, True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
def set_quit(self, _arg2, _arg3):
self.quit = True
def updateData(gpu_list, devices, cmd):
gpu_list.read_gpu_sensor_data()
gpu_list.read_gpu_state_data()
if env.gut_const.LOG:
gpu_list.print_log(env.gut_const.log_file_ptr)
if env.gut_const.PLOT:
try:
gpu_list.print_plot(cmd.stdin)
except:
print('amdgpu-plot has closed')
env.gut_const.PLOT = False
# update gui
for dk, dv in devices.items():
for lk, lv in dv.items():
if lk == 'card_num':
data_value = 'card'+gpu_list.list[dk].get_params_value('card_num')[:16]
else:
data_value = str(gpu_list.list[dk].get_params_value(lk))[:16]
if data_value == '-1':
data_value = ''
lv.set_text(data_value)
lv.set_width_chars(17)
while Gtk.events_pending():
Gtk.main_iteration_do(True)
def refresh(refreshtime, updateData, gpu_list, devices, cmd, gmonitor):
while True:
if gmonitor.quit:
print('Quitting...')
Gtk.main_quit()
sys.exit(0)
GLib.idle_add(updateData, gpu_list, devices, cmd)
time.sleep(refreshtime)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--about', help='README', action='store_true', default=False)
parser.add_argument('--gui', help='Display GTK Version of Monitor', action='store_true', default=False)
parser.add_argument('--log', help='Write all monitor data to logfile', action='store_true', default=False)
parser.add_argument('--plot', help='Open and write to amdgpu-plot', action='store_true', default=False)
parser.add_argument('--ltz', help='Use local time zone instead of UTC', action='store_true', default=False)
parser.add_argument('--sleep', help='Number of seconds to sleep between updates', type=int, default=2)
parser.add_argument('--no_fan', help='do not include fan setting options', action='store_true', default=False)
parser.add_argument('-d', '--debug', help='Debug output', action='store_true', default=False)
parser.add_argument('--pdebug', help='Plot debug output', action='store_true', default=False)
args = parser.parse_args()
# About me
if args.about:
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
env.gut_const.PATH = os.path.dirname(str(Path(__file__).resolve()))
env.gut_const.DEBUG = args.debug
env.gut_const.PDEBUG = args.pdebug
if args.ltz:
env.gut_const.USELTZ = True
if args.no_fan:
env.gut_const.show_fans = False
if int(args.sleep) > 0:
env.gut_const.SLEEP = int(args.sleep)
else:
print('Invalid value for sleep specified. Must be an integer great than zero')
sys.exit(-1)
if env.gut_const.check_env() < 0:
print('Error in environment. Exiting...')
sys.exit(-1)
# Check value of AMD Feature mask
try:
featuremask = env.gut_const.read_amdfeaturemask()
except FileNotFoundError:
print('Cannot read ppfeaturemask. Exiting...')
sys.exit(-1)
if featuremask == int(0xffff7fff) or featuremask == int(0xffffffff) or featuremask == int(0xfffd7fff) :
print('AMD Wattman features enabled: %s' % hex(featuremask))
else:
print('AMD Wattman features not enabled: %s, See README file.' % hex(featuremask))
sys.exit(-1)
env.gut_const.get_amd_driver_version()
# Get list of AMD GPUs and get basic non-driver details
gpu_list = GPU.GPU_LIST()
gpu_list.get_gpu_list()
gpu_list.read_allgpu_pci_info()
# Check list of AMD GPUs
num_amd_gpus = gpu_list.num_gpus()
num_com_gpus = gpu_list.num_compatible_gpus()
if num_amd_gpus == 0:
print('No AMD GPUs detected, exiting...')
sys.exit(-1)
else:
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
print(f'{num_amd_gpus} AMD GPUs detected, {num_com_gpus} may be compatible, checking...')
# Read data static driver information for GPUs
gpu_list.read_gpu_driver_info()
gpu_list.read_gpu_sensor_static_data()
# Read dynamic sensor and state data from GPUs
gpu_list.read_gpu_sensor_data()
gpu_list.read_gpu_state_data()
# Check number of compatible GPUs again
num_com_gpus = gpu_list.num_compatible_gpus()
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
else:
print(f'{num_com_gpus} are confirmed compatible.')
print('')
# Generate a new list of only compatible GPUs
com_gpu_list = gpu_list.list_compatible_gpus()
if args.log:
env.gut_const.LOG = True
env.gut_const.log_file = './log_monitor_{}.txt'.format(
env.gut_const.now(ltz=env.gut_const.USELTZ).strftime('%m%d_%H%M%S'))
env.gut_const.log_file_ptr = open(env.gut_const.log_file, 'w', 1)
gpu_list.print_log_header(env.gut_const.log_file_ptr)
if args.plot:
args.gui = True
if args.gui:
# Display Gtk style Monitor
devices = {}
gmonitor = MonitorWindow(com_gpu_list, devices)
#gmonitor.connect('delete-event', Gtk.main_quit)
gmonitor.connect('delete-event', gmonitor.set_quit)
gmonitor.show_all()
cmd = None
if args.plot:
env.gut_const.PLOT = True
plot_util = os.path.join(env.gut_const.PATH, 'amdgpu-plot')
if os.path.isfile(plot_util):
if env.gut_const.PDEBUG:
cmd_str = plot_util + ' --debug --stdin --sleep ' + str(env.gut_const.SLEEP)
else:
cmd_str = plot_util + ' --stdin --sleep ' + str(env.gut_const.SLEEP)
cmd = subprocess.Popen(shlex.split(cmd_str), bufsize=-1, shell=False, stdin=subprocess.PIPE)
gpu_list.print_plot_header(cmd.stdin)
# Start thread to update Monitor
monthread = threading.Thread(target=refresh, daemon=True, args=[env.gut_const.SLEEP,
updateData, gpu_list, devices, cmd, gmonitor]).start()
Gtk.main()
else:
# Display text style Monitor
try:
while True:
com_gpu_list.read_gpu_sensor_data()
com_gpu_list.read_gpu_state_data()
if not env.gut_const.DEBUG: os.system('clear')
if env.gut_const.LOG:
print('%sLogging to: %s%s' % ('\033[31m \033[01m', env.gut_const.log_file, '\033[0m'))
com_gpu_list.print_log(env.gut_const.log_file_ptr)
com_gpu_list.print_table()
time.sleep(env.gut_const.SLEEP)
except KeyboardInterrupt:
if env.gut_const.LOG:
env.gut_const.log_file_ptr.close()
sys.exit(0)
if __name__ == '__main__':
main()
amdgpu-utils-2.6.0/amdgpu-pac 0000775 0000000 0000000 00000261273 13546003346 0016115 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
""" amdgpu-pac - A utility program and control compatible AMD GPUs
Program and Control compatible AMD GPUs with this utility. By default, the commands to
be written to a GPU are written to a bash file for the user to inspect and run. If you
have confidence, the *--execute_pac* option can be used to execute and then delete the
saved bash file. Since the GPU device files are writable only by root, sudo is used to
execute commands in the bash file, as a result, you will be prompted for credentials in the
terminal where you executed *amdgpu-pac*. The *--no_fan* option can be used to eliminate
fan details from the utility. The *--force_write* option can be used to force all configuration
parameters to be written to the GPU. The default behavior is to only write changes.
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['Craig Echt - Testing, Debug, Verification, and Documentation']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-pac'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import argparse
import re
import subprocess
import os
import sys
import time
from uuid import uuid4
try:
import gi
except ModuleNotFoundError as error:
print('gi import error: {}'.format(error))
print('gi is required for %s', __program_name__)
print(' In a venv, first install vext: pip install --no-cache-dir vext')
print(' Then install vext.gi: pip install --no-cache-dir vext.gi')
sys.exit(0)
gi.require_version('Gtk', '3.0')
from gi.repository import GLib, Gtk, Gdk
from GPUmodules import GPUmodule as GPU
from GPUmodules import env
class PACWindow(Gtk.Window):
def __init__(self, gpu_list, devices):
Gtk.Window.__init__(self, title='amdgpu-pac')
self.set_border_width(1)
icon_file = os.path.join(env.gut_const.PATH, 'icons', 'amdgpu-pac.icon.png')
if os.path.isfile(icon_file):
self.set_icon_from_file(icon_file)
grid = Gtk.Grid()
grid.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1, 1, 1, 1))
self.add(grid)
MAX_CHAR = 54
CHAR_WIDTH = 8
num_com_amd_gpus = gpu_list.num_compatible_gpus()
max_rows = 0
col = 0
for k, v in gpu_list.list.items():
row = 0
# Card Number in top center of box
devices[v.uuid] = {'card_num': Gtk.Label()}
devices[v.uuid]['card_num'].set_markup('Card ' + v.get_params_value(str('card_num')) + ': '
+ v.get_params_value('model_display') + '')
devices[v.uuid]['card_num'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
devices[v.uuid]['card_num'].set_property('margin-top', 1)
devices[v.uuid]['card_num'].set_property('margin-bottom', 1)
devices[v.uuid]['card_num'].set_property('margin-right', 4)
devices[v.uuid]['card_num'].set_property('margin-left', 4)
devices[v.uuid]['card_num'].set_alignment(0.5, 0.5)
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.20, .40, .60, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['card_num'], True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Card Path
devices[v.uuid]['card_path'] = Gtk.Label()
devices[v.uuid]['card_path'].set_markup('Device: ' + v.get_params_value('card_path'))
devices[v.uuid]['card_path'].set_property('width-request', MAX_CHAR*CHAR_WIDTH)
devices[v.uuid]['card_path'].set_property('margin-top', 1)
devices[v.uuid]['card_path'].set_property('margin-bottom', 1)
devices[v.uuid]['card_path'].set_property('margin-right', 4)
devices[v.uuid]['card_path'].set_property('margin-left', 4)
devices[v.uuid]['card_path'].set_alignment(0, 0.5)
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['card_path'], True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Card Power Cap
power_cap_range = v.get_params_value('power_cap_range')
devices[v.uuid]['power_cap'] = Gtk.Label()
devices[v.uuid]['power_cap'].set_markup('Power Cap: ' + 'Range (' + str(power_cap_range[0]) +
' - ' + str(power_cap_range[1]) + ' W)')
devices[v.uuid]['power_cap'].set_property('margin-top', 1)
devices[v.uuid]['power_cap'].set_property('margin-bottom', 1)
devices[v.uuid]['power_cap'].set_property('margin-right', 2)
devices[v.uuid]['power_cap'].set_property('margin-left', 2)
devices[v.uuid]['power_cap'].set_alignment(0, 0.5)
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['power_cap'], True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Card Power Cap Value and Entry
devices[v.uuid]['power_cap_cur'] = Gtk.Label()
devices[v.uuid]['power_cap_cur'].set_property('margin-top', 1)
devices[v.uuid]['power_cap_cur'].set_property('margin-bottom', 1)
devices[v.uuid]['power_cap_cur'].set_property('margin-right', 2)
devices[v.uuid]['power_cap_cur'].set_property('margin-left', 2)
devices[v.uuid]['power_cap_ent'] = Gtk.Entry()
devices[v.uuid]['power_cap_ent'].set_width_chars(4)
devices[v.uuid]['power_cap_ent'].set_max_length(4)
devices[v.uuid]['power_cap_ent'].set_alignment(xalign=1)
devices[v.uuid]['power_cap_ent'].set_property('margin-top', 1)
devices[v.uuid]['power_cap_ent'].set_property('margin-bottom', 1)
devices[v.uuid]['power_cap_ent'].set_property('margin-right', 0)
devices[v.uuid]['power_cap_ent'].set_property('margin-left', 2)
devices[v.uuid]['power_cap_ent_unit'] = Gtk.Label()
devices[v.uuid]['power_cap_ent_unit'].set_text('W (-1 to reset)')
devices[v.uuid]['power_cap_ent_unit'].set_property('margin-top', 1)
devices[v.uuid]['power_cap_ent_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['power_cap_ent_unit'].set_property('margin-right', 0)
devices[v.uuid]['power_cap_ent_unit'].set_property('margin-left', 0)
devices[v.uuid]['power_cap_ent_unit'].set_alignment(0, 0.5)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, 0, spacing=2)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['power_cap_cur'], False, False, 0)
lbox.pack_start(devices[v.uuid]['power_cap_ent'], False, False, 0)
lbox.pack_start(devices[v.uuid]['power_cap_ent_unit'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
if env.gut_const.show_fans:
# Fan PWM Value
fan_pwm_range = v.get_params_value('fan_pwm_range')
devices[v.uuid]['fan_pwm_range'] = Gtk.Label()
devices[v.uuid]['fan_pwm_range'].set_markup('Fan PWM: ' + 'Range (' + str(fan_pwm_range[0])
+ ' - ' + str(fan_pwm_range[1]) + ' %)')
devices[v.uuid]['fan_pwm_range'].set_property('margin-top', 1)
devices[v.uuid]['fan_pwm_range'].set_property('margin-bottom', 1)
devices[v.uuid]['fan_pwm_range'].set_property('margin-right', 2)
devices[v.uuid]['fan_pwm_range'].set_property('margin-left', 2)
devices[v.uuid]['fan_pwm_range'].set_alignment(0, 0.5)
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['fan_pwm_range'], True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Card Fan PWM Value and Entry
devices[v.uuid]['fan_pwm_cur'] = Gtk.Label()
devices[v.uuid]['fan_pwm_cur'].set_property('margin-top', 1)
devices[v.uuid]['fan_pwm_cur'].set_property('margin-bottom', 1)
devices[v.uuid]['fan_pwm_cur'].set_property('margin-right', 2)
devices[v.uuid]['fan_pwm_cur'].set_property('margin-left', 2)
devices[v.uuid]['fan_pwm_ent'] = Gtk.Entry()
devices[v.uuid]['fan_pwm_ent'].set_width_chars(4)
devices[v.uuid]['fan_pwm_ent'].set_max_length(4)
devices[v.uuid]['fan_pwm_ent'].set_alignment(xalign=1)
devices[v.uuid]['fan_pwm_ent'].set_property('margin-top', 1)
devices[v.uuid]['fan_pwm_ent'].set_property('margin-bottom', 1)
devices[v.uuid]['fan_pwm_ent'].set_property('margin-right', 0)
devices[v.uuid]['fan_pwm_ent'].set_property('margin-left', 2)
devices[v.uuid]['fan_pwm_ent_unit'] = Gtk.Label()
devices[v.uuid]['fan_pwm_ent_unit'].set_text('% (-1 to reset)')
devices[v.uuid]['fan_pwm_ent_unit'].set_property('margin-top', 1)
devices[v.uuid]['fan_pwm_ent_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['fan_pwm_ent_unit'].set_property('margin-right', 0)
devices[v.uuid]['fan_pwm_ent_unit'].set_property('margin-left', 0)
devices[v.uuid]['fan_pwm_ent_unit'].set_alignment(0, 0.5)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, 0, spacing=2)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['fan_pwm_cur'], False, False, 0)
lbox.pack_start(devices[v.uuid]['fan_pwm_ent'], False, False, 0)
lbox.pack_start(devices[v.uuid]['fan_pwm_ent_unit'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
if v.get_params_value('gpu_type') == 1:
# Sclk P-States
devices[v.uuid]['sclk_range'] = Gtk.Label()
devices[v.uuid]['sclk_range'].set_markup('Sclk P-States: ' + 'Ranges ' +
str(v.get_params_value('sclk_f_range')[0]) + '-' +
str(v.get_params_value('sclk_f_range')[1]) + ', ' +
str(v.get_params_value('vddc_range')[0]) + '-' +
str(v.get_params_value('vddc_range')[1]) + ' ')
devices[v.uuid]['sclk_range'].set_property('margin-top', 1)
devices[v.uuid]['sclk_range'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_range'].set_property('margin-right', 2)
devices[v.uuid]['sclk_range'].set_property('margin-left', 2)
devices[v.uuid]['sclk_range'].set_alignment(0, 0.5)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['sclk_range'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Sclk P-State Values and Entry
devices[v.uuid]['sclk_pstate'] = {}
for ps, psd in v.sclk_state.items():
devices[v.uuid]['sclk_pstate'][ps] = {}
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'] = Gtk.Label()
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_width_chars(20)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_alignment(0, 0.5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-right', 2)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-left', 2)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'] = Gtk.Entry()
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_width_chars(5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_max_length(5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_alignment(xalign=1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-right', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-left', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'] = Gtk.Label()
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-right', 4)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-left', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'] = Gtk.Entry()
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_width_chars(5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_max_length(5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_alignment(xalign=1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-right', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-left', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'] = Gtk.Label()
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-right', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-left', 0)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'], False, False, 0)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# SCLK P-State Mask
devices[v.uuid]['sclk_pst_mask_cur'] = Gtk.Label()
devices[v.uuid]['sclk_pst_mask_cur'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pst_mask_cur'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pst_mask_cur'].set_property('margin-right', 2)
devices[v.uuid]['sclk_pst_mask_cur'].set_property('margin-left', 2)
devices[v.uuid]['sclk_pst_mask_ent'] = Gtk.Entry()
devices[v.uuid]['sclk_pst_mask_ent'].set_width_chars(15)
devices[v.uuid]['sclk_pst_mask_ent'].set_max_length(15)
devices[v.uuid]['sclk_pst_mask_ent'].set_alignment(xalign=0)
devices[v.uuid]['sclk_pst_mask_ent'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pst_mask_ent'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pst_mask_ent'].set_property('margin-right', 0)
devices[v.uuid]['sclk_pst_mask_ent'].set_property('margin-left', 1)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, 0, spacing=2)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['sclk_pst_mask_cur'], False, False, 0)
lbox.pack_start(devices[v.uuid]['sclk_pst_mask_ent'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
elif v.get_params_value('gpu_type') == 2:
# Sclk Curve End Points
devices[v.uuid]['sclk_range'] = Gtk.Label()
devices[v.uuid]['sclk_range'].set_markup('Sclk Curve End Points: ' + 'Ranges ' +
str(v.get_params_value('sclk_f_range')[0]) + '-' +
str(v.get_params_value('sclk_f_range')[1]) + ' ')
devices[v.uuid]['sclk_range'].set_property('margin-top', 1)
devices[v.uuid]['sclk_range'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_range'].set_property('margin-right', 2)
devices[v.uuid]['sclk_range'].set_property('margin-left', 2)
devices[v.uuid]['sclk_range'].set_alignment(0, 0.5)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['sclk_range'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Sclk Curve End Points Values and Entry
devices[v.uuid]['sclk_pstate'] = {}
for ps, psd in v.sclk_state.items():
devices[v.uuid]['sclk_pstate'][ps] = {}
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'] = Gtk.Label()
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_width_chars(20)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_alignment(0, 0.5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-right', 2)
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-left', 2)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'] = Gtk.Entry()
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_width_chars(5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_max_length(5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_alignment(xalign=1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-right', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-left', 0)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'] = Gtk.Label()
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-right', 4)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-left', 0)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
if v.get_params_value('gpu_type') == 1:
# Mclk P-States
devices[v.uuid]['mclk_range'] = Gtk.Label()
devices[v.uuid]['mclk_range'].set_markup('Mclk P-States: ' + 'Ranges ' +
str(v.get_params_value('mclk_f_range')[0]) + '-' +
str(v.get_params_value('mclk_f_range')[1]) + ', ' +
str(v.get_params_value('vddc_range')[0]) + '-' +
str(v.get_params_value('vddc_range')[1]))
devices[v.uuid]['mclk_range'].set_property('margin-top', 1)
devices[v.uuid]['mclk_range'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_range'].set_property('margin-right', 2)
devices[v.uuid]['mclk_range'].set_property('margin-left', 2)
devices[v.uuid]['mclk_range'].set_alignment(0, 0.5)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['mclk_range'], True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Mclk P-State Values and Entry
devices[v.uuid]['mclk_pstate'] = {}
for ps, psd in v.mclk_state.items():
devices[v.uuid]['mclk_pstate'][ps] = {}
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'] = Gtk.Label()
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_width_chars(20)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_alignment(0, 0.5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-right', 2)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-left', 2)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'] = Gtk.Entry()
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_width_chars(5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_max_length(5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_alignment(xalign=1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-right', 0)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-left', 0)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'] = Gtk.Label()
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-right', 4)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-left', 0)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'] = Gtk.Entry()
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_width_chars(5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_max_length(5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_alignment(xalign=1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-right', 0)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_property('margin-left', 0)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'] = Gtk.Label()
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-right', 4)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_property('margin-left', 0)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'], False, False, 0)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# MCLK P-State Mask
devices[v.uuid]['mclk_pst_mask_cur'] = Gtk.Label()
devices[v.uuid]['mclk_pst_mask_cur'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pst_mask_cur'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pst_mask_cur'].set_property('margin-right', 2)
devices[v.uuid]['mclk_pst_mask_cur'].set_property('margin-left', 2)
devices[v.uuid]['mclk_pst_mask_ent'] = Gtk.Entry()
devices[v.uuid]['mclk_pst_mask_ent'].set_width_chars(15)
devices[v.uuid]['mclk_pst_mask_ent'].set_max_length(15)
devices[v.uuid]['mclk_pst_mask_ent'].set_alignment(xalign=0)
devices[v.uuid]['mclk_pst_mask_ent'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pst_mask_ent'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pst_mask_ent'].set_property('margin-right', 0)
devices[v.uuid]['mclk_pst_mask_ent'].set_property('margin-left', 1)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, 0, spacing=2)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['mclk_pst_mask_cur'], False, False, 0)
lbox.pack_start(devices[v.uuid]['mclk_pst_mask_ent'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
elif v.get_params_value('gpu_type') == 2:
# Mclk Curve End points
devices[v.uuid]['mclk_range'] = Gtk.Label()
devices[v.uuid]['mclk_range'].set_markup('Mclk Curve End Points: ' + 'Ranges ' +
str(v.get_params_value('mclk_f_range')[0]) + '-' +
str(v.get_params_value('mclk_f_range')[1]))
devices[v.uuid]['mclk_range'].set_property('margin-top', 1)
devices[v.uuid]['mclk_range'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_range'].set_property('margin-right', 2)
devices[v.uuid]['mclk_range'].set_property('margin-left', 2)
devices[v.uuid]['mclk_range'].set_alignment(0, 0.5)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['mclk_range'], True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Mclk Curve End Points Values and Entry
devices[v.uuid]['mclk_pstate'] = {}
for ps, psd in v.mclk_state.items():
devices[v.uuid]['mclk_pstate'][ps] = {}
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'] = Gtk.Label()
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_width_chars(20)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_alignment(0, 0.5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-right', 2)
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_property('margin-left', 2)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'] = Gtk.Entry()
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_width_chars(5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_max_length(5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_alignment(xalign=1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-right', 0)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_property('margin-left', 0)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'] = Gtk.Label()
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-right', 4)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_property('margin-left', 0)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
if v.get_params_value('gpu_type') == 2:
# VDDC Curve Points
devices[v.uuid]['vddc_curve_range'] = Gtk.Label()
devices[v.uuid]['vddc_curve_range'].set_markup('VDDC Curve Points: ' + 'Ranges ' +
str(v.vddc_curve_range['0']['SCLK'][0]) + '-' +
str(v.vddc_curve_range['0']['SCLK'][1]) + ', ' +
str(v.vddc_curve_range['0']['VOLT'][0]) + '-' +
str(v.vddc_curve_range['0']['VOLT'][1]) + ' ')
devices[v.uuid]['vddc_curve_range'].set_property('margin-top', 1)
devices[v.uuid]['vddc_curve_range'].set_property('margin-bottom', 1)
devices[v.uuid]['vddc_curve_range'].set_property('margin-right', 2)
devices[v.uuid]['vddc_curve_range'].set_property('margin-left', 2)
devices[v.uuid]['vddc_curve_range'].set_alignment(0, 0.5)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['vddc_curve_range'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# VDDC CURVE Points Values and Entry
devices[v.uuid]['vddc_curve_pt'] = {}
for ps, psd in v.vddc_curve.items():
devices[v.uuid]['vddc_curve_pt'][ps] = {}
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'] = Gtk.Label()
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'].set_width_chars(20)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'].set_alignment(0, 0.5)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'].set_property('margin-top', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'].set_property('margin-right', 2)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'].set_property('margin-left', 2)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'] = Gtk.Entry()
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_width_chars(5)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_max_length(5)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_alignment(xalign=1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_property('margin-top', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_property('margin-right', 0)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_property('margin-left', 0)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'] = Gtk.Label()
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'].set_property('margin-right', 4)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'].set_property('margin-left', 0)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'] = Gtk.Entry()
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_width_chars(5)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_max_length(5)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_alignment(xalign=1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_property('margin-top', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_property('margin-bottom', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_property('margin-right', 0)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_property('margin-left', 0)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'] = Gtk.Label()
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'].set_alignment(0, 0.5)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'].set_property('margin-top', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'].set_property('margin-bottom', 1)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'].set_property('margin-right', 0)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'].set_property('margin-left', 0)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'], False, False, 0)
lbox.pack_start(devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'], False, False, 0)
lbox.pack_start(devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Power Performance Mode Selection
devices[v.uuid]['ppm'] = Gtk.Label()
devices[v.uuid]['ppm'].set_markup('Power Performance Modes:')
devices[v.uuid]['ppm'].set_property('margin-top', 1)
devices[v.uuid]['ppm'].set_property('margin-bottom', 1)
devices[v.uuid]['ppm'].set_property('margin-right', 2)
devices[v.uuid]['ppm'].set_property('margin-left', 2)
devices[v.uuid]['ppm'].set_alignment(0, 0.5)
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .12))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['ppm'], True, True, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
devices[v.uuid]['ppm_modes'] = Gtk.ListStore(int, str)
devices[v.uuid]['ppm_mode_items'] = {}
item_num = 0
for mode_num, mode in v.ppm_modes.items():
if mode_num == 'NUM':
continue
if mode[0] == 'CUSTOM':
continue
devices[v.uuid]['ppm_modes'].append([int(mode_num), mode[0]])
devices[v.uuid]['ppm_mode_items'][int(mode_num)] = item_num
item_num += 1
lbox = Gtk.Box(spacing=6)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.06, .06, .06, .06))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
devices[v.uuid]['ppm_modes_combo'] = Gtk.ComboBox.new_with_model_and_entry(devices[v.uuid]['ppm_modes'])
devices[v.uuid]['ppm_modes_combo'].connect('changed', ppm_select, devices[v.uuid])
devices[v.uuid]['ppm_modes_combo'].set_entry_text_column(1)
lbox.pack_start(devices[v.uuid]['ppm_modes_combo'], False, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Save/Reset Card Buttons
devices[v.uuid]['save_button'] = Gtk.Button('')
for child in devices[v.uuid]['save_button'].get_children():
child.set_label('Save')
child.set_use_markup(True)
devices[v.uuid]['save_button'].connect('clicked', self.save_card, gpu_list, devices, v.uuid)
devices[v.uuid]['save_button'].set_property('width-request', 90)
devices[v.uuid]['reset_button'] = Gtk.Button('')
for child in devices[v.uuid]['reset_button'].get_children():
child.set_label('Reset')
child.set_use_markup(True)
devices[v.uuid]['reset_button'].connect('clicked', self.reset_card, gpu_list, devices, v.uuid)
devices[v.uuid]['reset_button'].set_property('width-request', 90)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.6, .6, .6, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['save_button'], True, False, 0)
lbox.pack_start(devices[v.uuid]['reset_button'], True, False, 0)
grid.attach(lbox, col, row, 1, 1)
row += 1
# Increment column before going to next Device
if max_rows < row:
max_rows = row
col += 1
if num_com_amd_gpus > 1:
# Save/Reset/Update ALL Card Buttons
devices[v.uuid]['save_all_button'] = Gtk.Button('')
for child in devices[v.uuid]['save_all_button'].get_children():
child.set_label('Save All')
child.set_use_markup(True)
devices[v.uuid]['save_all_button'].connect('clicked', self.save_all_cards, gpu_list, devices, v.uuid)
devices[v.uuid]['save_all_button'].set_property('width-request', 100)
devices[v.uuid]['reset_all_button'] = Gtk.Button('')
for child in devices[v.uuid]['reset_all_button'].get_children():
child.set_label('Reset All')
child.set_use_markup(True)
devices[v.uuid]['reset_all_button'].connect('clicked', self.reset_all_cards, gpu_list, devices, v.uuid)
devices[v.uuid]['reset_all_button'].set_property('width-request', 100)
devices[v.uuid]['refresh_all_button'] = Gtk.Button('')
for child in devices[v.uuid]['refresh_all_button'].get_children():
child.set_label('Refresh All')
child.set_use_markup(True)
devices[v.uuid]['refresh_all_button'].connect('clicked', self.refresh_all_cards, gpu_list,
devices, v.uuid, True)
devices[v.uuid]['refresh_all_button'].set_property('width-request', 100)
lbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
lbox.set_homogeneous(False)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.6, .6, .6, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(devices[v.uuid]['save_all_button'], True, False, 0)
lbox.pack_start(devices[v.uuid]['reset_all_button'], True, False, 0)
lbox.pack_start(devices[v.uuid]['refresh_all_button'], True, False, 0)
grid.attach(lbox, 0, max_rows, col, 1)
row += 1
max_rows += 1
# Initialize message box
devices['message_label'] = Gtk.Label()
devices['message_box'] = Gtk.Box(Gtk.Orientation.HORIZONTAL, spacing=6)
devices['message_label'].set_alignment(0, 0.5)
devices['message_label'].set_max_width_chars(num_com_amd_gpus * MAX_CHAR)
devices['message_label'].set_property('width-request', num_com_amd_gpus * MAX_CHAR * CHAR_WIDTH)
devices['message_label'].set_line_wrap(True)
devices['message_box'].set_homogeneous(False)
devices['message_label'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
devices['message_box'].override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.6, .6, .6, 1.0))
devices['message_box'].set_property('margin-top', 1)
devices['message_box'].set_property('margin-bottom', 1)
devices['message_box'].set_property('margin-right', 1)
devices['message_box'].set_property('margin-left', 1)
devices['message_box'].pack_start(devices['message_label'], True, True, 1)
grid.attach(devices['message_box'], 0, max_rows, col, 1)
row += 1
self.update_message(devices, '', 'gray')
self.refresh_PAC(gpu_list, devices)
def update_message(self, devices, message, color='gray'):
#set default message if no message specified
if message == '':
if env.gut_const.execute_pac == True:
message = "Using the --execute_pac option. Changes will be written to the GPU without confirmation.\nSudo will be used, so you may be prompted for credentials in the window where amdgpu-pac was executed from."
else:
message = "Using amdgpu-pac without --execute_pac option.\nYou must manually run bash file with sudo to execute changes."
if color == 'red':
devices['message_box'].override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.60, .20, .20, 1.0))
devices['message_label'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
elif color == 'yellow':
devices['message_box'].override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.50, .50, .00, 1.0))
devices['message_label'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
elif color == 'white':
devices['message_box'].override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
devices['message_label'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(0.0, 0.0, 0.0, 1.0))
else:
devices['message_box'].override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.6,.6,.6,1.0))
devices['message_label'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
devices['message_label'].set_text(message)
#devices['message_label'].set_markup('' + message + '')
while Gtk.events_pending():
Gtk.main_iteration_do(True)
return
def refresh_all_cards(self, parent, gpu_list, devices, uuid, reset_message=False):
self.refresh_PAC(gpu_list, devices, reset_message)
return
def refresh_PAC(self, gpu_list, devices, reset_message=False):
# Read dynamic sensor and state data from GPUs
gpu_list.read_gpu_sensor_data()
gpu_list.read_gpu_state_data()
# Read pstate and ppm table data
gpu_list.read_gpu_pstates()
gpu_list.read_gpu_ppm_table()
for k, v in gpu_list.list.items():
devices[v.uuid]['power_cap_cur'].set_text(' Current: ' + str(v.get_params_value('power_cap')) +
'W Set: ')
devices[v.uuid]['power_cap_ent'].set_text(str(int(v.get_params_value('power_cap'))))
if env.gut_const.show_fans:
devices[v.uuid]['fan_pwm_cur'].set_text(' Current: ' + str(v.get_params_value('fan_pwm')) +
'% Set: ')
devices[v.uuid]['fan_pwm_ent'].set_text(str(int(v.get_params_value('fan_pwm'))))
#SCLK
if v.get_params_value('gpu_type') == 1:
for ps, psd in v.sclk_state.items():
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_text(' ' + (str(ps)+': ' +
str(psd[0]) + ', ' + str(psd[1])))
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[0]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[0]))
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_text(item_value)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_text(item_unit + ' ')
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[1]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[1]))
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj'].set_text(str(item_value))
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_text(item_unit)
devices[v.uuid]['sclk_pst_mask_cur'].set_text(' SCLK Default: ' +
v.get_pstate_list_str('SCLK') + ' Set Mask: ')
devices[v.uuid]['sclk_pst_mask_ent'].set_text(v.get_pstate_list_str('SCLK'))
elif v.get_params_value('gpu_type') == 2:
for ps, psd in v.sclk_state.items():
devices[v.uuid]['sclk_pstate'][ps]['gtk_cur_obj'].set_text(' ' + (str(ps) + ': ' + str(psd[0])))
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[0]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[0]))
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj'].set_text(item_value)
devices[v.uuid]['sclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_text(item_unit + ' ')
#MCLK
if v.get_params_value('gpu_type') == 1:
for ps, psd in v.mclk_state.items():
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_text(' ' + (str(ps) + ': ' +
str(psd[0]) + ', ' + str(psd[1])))
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[0]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[0]))
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_text(item_value)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_text(item_unit + ' ')
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[1]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[1]))
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj'].set_text(str(item_value))
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_v_obj_unit'].set_text(item_unit)
devices[v.uuid]['mclk_pst_mask_cur'].set_text(' MCLK Default: ' +
v.get_pstate_list_str('MCLK') + ' Set Mask: ')
devices[v.uuid]['mclk_pst_mask_ent'].set_text(v.get_pstate_list_str('MCLK'))
elif v.get_params_value('gpu_type') == 2:
for ps, psd in v.mclk_state.items():
devices[v.uuid]['mclk_pstate'][ps]['gtk_cur_obj'].set_text(' ' + (str(ps) + ': ' + str(psd[0])))
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[0]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[0]))
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj'].set_text(item_value)
devices[v.uuid]['mclk_pstate'][ps]['gtk_ent_f_obj_unit'].set_text(item_unit + ' ')
#VDDC CURVE
if v.get_params_value('gpu_type') == 2:
for ps, psd in v.vddc_curve.items():
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_cur_obj'].set_text(' ' + (str(ps) + ': ' +
str(psd[0]) + ', ' + str(psd[1])))
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[0]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[0]))
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj'].set_text(item_value)
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_f_obj_unit'].set_text(item_unit + ' ')
item_value = re.sub(r'[a-z,A-Z]*', '', str(psd[1]))
item_unit = re.sub(r'[0-9][.]*[0-9]*', '', str(psd[1]))
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj'].set_text(str(item_value))
devices[v.uuid]['vddc_curve_pt'][ps]['gtk_ent_v_obj_unit'].set_text(item_unit)
# refresh active mode item
devices[v.uuid]['ppm_modes_combo'].set_active(
devices[v.uuid]['ppm_mode_items'][v.get_current_ppm_mode()[0]])
if reset_message:
self.update_message(devices, '', 'gray')
while Gtk.events_pending():
Gtk.main_iteration_do(True)
return
def save_all_cards(self, parent, gpu_list, devices, uuid):
changed = 0
# Write start message
if env.gut_const.execute_pac:
message = 'Using the --execute_pac option. Changes will be written to the GPU without confirmation.\nSudo will be used, so you may be prompted for credentials in the window where amdgpu-pac was executed from.'
else:
message = 'Writing PAC command bash file.\n'
self.update_message(devices, message, 'red')
# save each card
for gk in gpu_list.list.keys():
#for dk in devices.keys():
changed += self.save_card(parent, gpu_list, devices, gk, refresh=False)
# Write finish message
time.sleep(1.0)
if env.gut_const.execute_pac:
if changed:
message = ('Write ' + str(changed) +
' PAC commands to card complete.\nConfirm changes with amdgpu-monitor.')
else:
message = 'No PAC commands to write to card.\nNo changes specified.'
else:
if changed:
message = ('Writing ' + str(changed) +
' PAC commands to bash file complete.\nRun bash file with sudo to execute changes.')
else:
message = 'No PAC commands to write to bash file.\nNo changes specified.'
self.update_message(devices, message, 'yellow')
self.refresh_all_cards(parent, gpu_list, devices, uuid)
return
def save_card(self, parent, gpu_list, devices, uuid, refresh=True):
if refresh:
# Write message
if env.gut_const.execute_pac:
message = 'Using the --execute_pac option. Changes will be written to the GPU without confirmation.\nSudo will be used, so you may be prompted for credentials in the window where amdgpu-pac was executed from.'
else:
message = 'Writing PAC commands to bash file.\n'
self.update_message(devices, message, 'red')
# specify output batch file name
out_filename = os.getcwd() + '/' + 'pac_writer_' + str(uuid4().hex) + '.sh'
fileptr = open(out_filename, 'x')
# output header
print('#!/bin/sh', file=fileptr)
print('###########################################################################', file=fileptr)
print('## amdgpu-pac generated script to modify GPU configuration/settings', file=fileptr)
print('###########################################################################', file=fileptr)
print('', file=fileptr)
print('###########################################################################', file=fileptr)
print('## WARNING - Do not execute this script without completely', file=fileptr)
print('## understanding appropriate value to write to your specific GPUs', file=fileptr)
print('###########################################################################', file=fileptr)
print('#', file=fileptr)
print('# Copyright (C) 2019 RueiKe', file=fileptr)
print('#', file=fileptr)
print('# This program is free software: you can redistribute it and/or modify', file=fileptr)
print('# it under the terms of the GNU General Public License as published by', file=fileptr)
print('# the Free Software Foundation, either version 3 of the License, or', file=fileptr)
print('# (at your option) any later version.', file=fileptr)
print('#', file=fileptr)
print('# This program is distributed in the hope that it will be useful,', file=fileptr)
print('# but WITHOUT ANY WARRANTY; without even the implied warranty of', file=fileptr)
print('# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the', file=fileptr)
print('# GNU General Public License for more details.', file=fileptr)
print('#', file=fileptr)
print('# You should have received a copy of the GNU General Public License', file=fileptr)
print('# along with this program. If not, see .', file=fileptr)
print('###########################################################################', file=fileptr)
changed = 0
v = gpu_list.list[uuid]
print('# ', file=fileptr)
print('# Card' + v.card_num + ' ' + v.get_params_value('model'), file=fileptr)
print('# ' + v.card_path, file=fileptr)
print('# ', file=fileptr)
print('set -x', file=fileptr)
# Power Cap
power_cap_file = v.hwmon_path + 'power1_cap'
old_power_cap = int(v.get_params_value('power_cap'))
new_power_cap_str = devices[uuid]['power_cap_ent'].get_text()
if re.fullmatch(r'^[-]*[0-9]+', new_power_cap_str):
new_power_cap = int(new_power_cap_str)
else:
new_power_cap = old_power_cap
if new_power_cap < 0:
print('# Powercap Old: %s, Resetting to default' % str(old_power_cap), file=fileptr)
else:
power_cap_range = v.get_params_value('power_cap_range')
print('# Powercap Old: ', str(old_power_cap), end='', file=fileptr)
print(' New: ', str(new_power_cap), end='', file=fileptr)
print(' Min: %d' % power_cap_range[0], end='', file=fileptr)
print(' Max: %d' % power_cap_range[1], end='', file=fileptr)
print('', file=fileptr)
if new_power_cap == old_power_cap and env.gut_const.write_delta_only:
print('# No changes, skipped', file=fileptr)
else:
if v.is_valid_power_cap(new_power_cap):
changed += 1
if new_power_cap < 0:
# reset
print('# Resetting Power Cap to default', file=fileptr)
print("sudo sh -c \"echo \'0\' > %s\"" % power_cap_file, file=fileptr)
else:
print("sudo sh -c \"echo \'%d\' > %s\"" % ((int(1000000 * new_power_cap)), power_cap_file),
file=fileptr)
else:
print('# Invalid parameter values', file=fileptr)
if env.gut_const.show_fans:
# Fan PWM
pwm_enable_file = v.hwmon_path + 'pwm1_enable'
pwm_file = v.hwmon_path + 'pwm1'
old_pwm = int(v.get_params_value('fan_pwm'))
new_pwm_str = devices[uuid]['fan_pwm_ent'].get_text()
if re.fullmatch(r'^[-]*[0-9]+', new_pwm_str):
new_pwm = int(new_pwm_str)
else:
new_pwm = old_pwm
if new_power_cap < 0:
print('# Fan PWM Old: %s, Resetting to default' % str(old_pwm), file=fileptr)
else:
print('# Fan PWM Old: ', str(old_pwm), end='', file=fileptr)
print(' New: ', str(new_pwm), end='', file=fileptr)
pwm_range = v.get_params_value('fan_pwm_range')
print(' Min: ', pwm_range[0], end='', file=fileptr)
print(' Max: ', pwm_range[1], end='', file=fileptr)
print('', file=fileptr)
if new_pwm == old_pwm and env.gut_const.write_delta_only:
print('# No changes, skipped', file=fileptr)
else:
if v.is_valid_fan_pwm(new_pwm):
changed += 1
if new_pwm < 0:
# reset
print('# Resetting fans to Dynamic mode', file=fileptr)
print("sudo sh -c \"echo \'2\' > %s\"" % (pwm_enable_file), file=fileptr)
else:
new_pwm_value = int(255 * new_pwm / 100)
print("sudo sh -c \"echo \'1\' > %s\"" % (pwm_enable_file), file=fileptr)
print("sudo sh -c \"echo \'%d\' > %s\"" % (new_pwm_value, pwm_file), file=fileptr)
else:
print('# Invalid parameter values', file=fileptr)
device_file = v.card_path + 'pp_od_clk_voltage'
commit_needed = False
if v.get_params_value('gpu_type') == 1:
# Sclk P-states
for pk, pv in devices[uuid]['sclk_pstate'].items():
if not pv['gtk_ent_f_obj'].get_text().isnumeric():
print('# Invalid sclk pstate entry: %s' % pv['gtk_ent_f_obj'].get_text(), file=fileptr)
print('# Invalid sclk pstate entry: %s' % pv['gtk_ent_f_obj'].get_text())
continue
if not pv['gtk_ent_v_obj'].get_text().isnumeric():
print('# Invalid sclk pstate entry: %s' % pv['gtk_ent_v_obj'].get_text(), file=fileptr)
print('# Invalid sclk pstate entry: %s' % pv['gtk_ent_v_obj'].get_text())
pstate = [pk, int(pv['gtk_ent_f_obj'].get_text()), int(pv['gtk_ent_v_obj'].get_text())]
print('#sclk p-state: %s : %s MHz, %s mV' % (pstate[0], pstate[1], pstate[2]), file=fileptr)
if v.is_valid_sclk_pstate(pstate):
if v.is_changed_sclk_pstate(pstate) or not env.gut_const.write_delta_only:
changed += 1
commit_needed = True
print("sudo sh -c \"echo \'s %s %s %s\' > %s\"" %
(pstate[0], pstate[1], pstate[2], device_file), file=fileptr)
else:
print('# Sclk pstate %d unchanged, skipping' % pk, file=fileptr)
else:
print('# Invalid sclk pstate values', file=fileptr)
# Mclk P-states
for pk, pv in devices[uuid]['mclk_pstate'].items():
if not pv['gtk_ent_f_obj'].get_text().isnumeric():
print('# Invalid mclk pstate entry: %s' % pv['gtk_ent_f_obj'].get_text(), file=fileptr)
print('# Invalid mclk pstate entry: %s' % pv['gtk_ent_f_obj'].get_text())
continue
if not pv['gtk_ent_v_obj'].get_text().isnumeric():
print('# Invalid mclk pstate entry: %s' % pv['gtk_ent_v_obj'].get_text(), file=fileptr)
print('# Invalid mclk pstate entry: %s' % pv['gtk_ent_v_obj'].get_text())
continue
pstate = [pk, int(pv['gtk_ent_f_obj'].get_text()), int(pv['gtk_ent_v_obj'].get_text())]
print('#mclk p-state: %s : %s MHz, %s mV' % (pstate[0], pstate[1], pstate[2]), file=fileptr)
if v.is_valid_mclk_pstate(pstate):
if v.is_changed_mclk_pstate(pstate) or not env.gut_const.write_delta_only:
changed += 1
commit_needed = True
print("sudo sh -c \"echo \'m %s %s %s\' > %s\"" %
(pstate[0], pstate[1], pstate[2], device_file), file=fileptr)
else:
print('# Mclk pstate %d unchanged, skipping' % pk, file=fileptr)
else:
print('# Invalid mclk pstate values', file=fileptr)
elif v.get_params_value('gpu_type') == 2:
# Sclk Curve End Points
for pk, pv in devices[uuid]['sclk_pstate'].items():
if not pv['gtk_ent_f_obj'].get_text().isnumeric():
print('# Invalid sclk curve end point entry: %s' % pv['gtk_ent_f_obj'].get_text(), file=fileptr)
print('# Invalid sclk curve end point entry: %s' % pv['gtk_ent_f_obj'].get_text())
continue
pstate = [pk, int(pv['gtk_ent_f_obj'].get_text()), '-']
print('#sclk curve end point: %s : %s MHz' % (pstate[0], pstate[1]), file=fileptr)
if v.is_valid_sclk_pstate(pstate):
if v.is_changed_sclk_pstate(pstate) or not env.gut_const.write_delta_only:
changed += 1
commit_needed = True
print("sudo sh -c \"echo \'s %s %s\' > %s\"" % (pstate[0], pstate[1], device_file),
file=fileptr)
else:
print('# Sclk curve point %d unchanged, skipping' % pk, file=fileptr)
else:
print('# Invalid sclk curve end point values', file=fileptr)
# Mclk Curve End Points
for pk, pv in devices[uuid]['mclk_pstate'].items():
if not pv['gtk_ent_f_obj'].get_text().isnumeric():
print('# Invalid mclk curve end point entry: %s' % pv['gtk_ent_f_obj'].get_text(), file=fileptr)
print('# Invalid mclk curve end point entry: %s' % pv['gtk_ent_f_obj'].get_text())
continue
pstate = [pk, int(pv['gtk_ent_f_obj'].get_text()), '-']
print('#mclk curve end point: %s : %s MHz' % (pstate[0], pstate[1]), file=fileptr)
if v.is_valid_mclk_pstate(pstate):
if v.is_changed_mclk_pstate(pstate) or not env.gut_const.write_delta_only:
changed += 1
commit_needed = True
print("sudo sh -c \"echo \'m %s %s\' > %s\"" % (pstate[0], pstate[1], device_file),
file=fileptr)
else:
print('# Mclk curve point %d unchanged, skipping' % pk, file=fileptr)
else:
print('# Invalid mclk curve end point values', file=fileptr)
# VDDC Curve Points
for pk, pv in devices[uuid]['vddc_curve_pt'].items():
if not pv['gtk_ent_f_obj'].get_text().isnumeric():
print('# Invalid vddc curve point entry: %s' % pv['gtk_ent_f_obj'].get_text(), file=fileptr)
print('# Invalid vddc curve point entry: %s' % pv['gtk_ent_f_obj'].get_text())
continue
if not pv['gtk_ent_v_obj'].get_text().isnumeric():
print('# Invalid vddc curve point entry: %s' % pv['gtk_ent_v_obj'].get_text(), file=fileptr)
print('# Invalid vddc curve point entry: %s' % pv['gtk_ent_v_obj'].get_text())
continue
curve_pts = [pk, int(pv['gtk_ent_f_obj'].get_text()), int(pv['gtk_ent_v_obj'].get_text())]
print('#vddc curve point: %s : %s MHz, %s mV' % (curve_pts[0], curve_pts[1], curve_pts[2]),
file=fileptr)
if v.is_valid_vddc_curve_pts(curve_pts):
if v.is_changed_vddc_curve_pt(curve_pts) or not env.gut_const.write_delta_only:
changed += 1
commit_needed = True
print("sudo sh -c \"echo \'vc %s %s %s\' > %s\"" %
(curve_pts[0], curve_pts[1], curve_pts[2], device_file), file=fileptr)
else:
print('# Vddc curve point %d unchanged, skipping' % pk, file=fileptr)
else:
print('# Invalid vddc curve point values', file=fileptr)
# PPM
ppm_level_file = v.card_path + 'power_dpm_force_performance_level'
ppm_mode_file = v.card_path + 'pp_power_profile_mode'
tree_iter = devices[uuid]['ppm_modes_combo'].get_active_iter()
if tree_iter is not None:
model = devices[uuid]['ppm_modes_combo'].get_model()
row_id, name = model[tree_iter][:2]
selected_mode = devices[uuid]['new_ppm'][0]
print('# Selected: ID=%d, name=%s' % (devices[uuid]['new_ppm'][0], devices[uuid]['new_ppm'][1]),
file=fileptr)
if v.get_current_ppm_mode()[0] != devices[uuid]['new_ppm'][0] or not env.gut_const.write_delta_only:
changed += 1
if (devices[uuid]['new_ppm'][1]).lower() == 'auto':
print("sudo sh -c \"echo \'auto\' > %s\"" % ppm_level_file, file=fileptr)
else:
print("sudo sh -c \"echo \'manual\' > %s\"" % ppm_level_file, file=fileptr)
print("sudo sh -c \"echo \'%d\' > %s\"" % (devices[uuid]['new_ppm'][0], ppm_mode_file), file=fileptr)
else:
print('# PPM mode %s unchanged, skipping' % devices[uuid]['new_ppm'][1], file=fileptr)
# Commit changes
device_file = v.card_path + 'pp_od_clk_voltage'
if commit_needed:
changed += 1
print("sudo sh -c \"echo \'c\' > %s\"" % (device_file), file=fileptr)
else:
print('# No clock changes made, commit skipped', file=fileptr)
if v.get_params_value('gpu_type') == 1:
# Writes of pstate Masks must come after commit of pstate changes
# Sclk Mask
sclk_mask_file = v.card_path + 'pp_dpm_sclk'
old_sclk_mask = v.get_pstate_list_str('SCLK').replace(',', ' ')
new_sclk_mask = devices[uuid]['sclk_pst_mask_ent'].get_text().replace(',', ' ').strip()
print('# Sclk P-State Mask Default: ', old_sclk_mask, end='', file=fileptr)
print(' New: ', new_sclk_mask, file=fileptr)
if new_sclk_mask == old_sclk_mask and env.gut_const.write_delta_only:
print('# No changes, skipped', file=fileptr)
else:
if v.is_valid_pstate_list_str(new_sclk_mask, 'SCLK'):
changed += 1
if new_sclk_mask == '':
# reset
print('# Resetting SCLK Mask to default', file=fileptr)
print("sudo sh -c \"echo \'%s\' > %s\"" % (old_sclk_mask, sclk_mask_file), file=fileptr)
else:
print("sudo sh -c \"echo \'%s\' > %s\"" % (new_sclk_mask, sclk_mask_file), file=fileptr)
else:
print('# Invalid parameter values', file=fileptr)
# Mclk Mask
mclk_mask_file = v.card_path + 'pp_dpm_mclk'
old_mclk_mask = v.get_pstate_list_str('MCLK').replace(',', ' ')
new_mclk_mask = devices[uuid]['mclk_pst_mask_ent'].get_text().replace(',', ' ').strip()
print('# Mclk P-State Mask Default: ', old_mclk_mask, end='', file=fileptr)
print(' New: ', new_mclk_mask, file=fileptr)
if new_mclk_mask == old_mclk_mask and env.gut_const.write_delta_only:
print('# No changes, skipped', file=fileptr)
else:
if v.is_valid_pstate_list_str(new_mclk_mask, 'MCLK'):
changed += 1
if new_mclk_mask == '':
# reset
print('# Resetting MCLK Mask to default', file=fileptr)
print("sudo sh -c \"echo \'%s\' > %s\"" % (old_mclk_mask, mclk_mask_file), file=fileptr)
else:
print("sudo sh -c \"echo \'%s\' > %s\"" % (new_mclk_mask, mclk_mask_file), file=fileptr)
else:
print('# Invalid parameter values', file=fileptr)
# Close file and Set permissions and Execute it --execute_pac
fileptr.close()
os.chmod(out_filename, 0o744)
print('Batch file completed: %s' % out_filename)
if env.gut_const.execute_pac:
# Execute bash file
print('Writing %d changes to GPU %s' % (changed, v.card_path))
cmd = subprocess.Popen(out_filename, shell=True)
cmd.wait()
print('PAC execution complete.')
if refresh:
# dismiss execute_pac message
time.sleep(0.5)
if changed:
message = ('Write of ' + str(changed) +
' PAC commands to card complete.\nConfirm changes with amdgpu-monitor.')
else:
message = 'No PAC commands to write to card.\nNo changes specified.'
self.update_message(devices, message, 'yellow')
if refresh:
self.refresh_PAC(gpu_list, devices)
os.remove(out_filename)
else:
if refresh:
# dismiss execute_pac message
if changed:
message = ('Write of ' + str(changed) +
' PAC commands to bash file complete.\nManually run bash file with sudo to execute changes.')
else:
message = 'No PAC commands to write bash file.\nNo changes specified.'
self.update_message(devices, message, 'yellow')
print('Execute to write changes to GPU %s' % v.card_path)
print('')
return changed
def reset_all_cards(self, parent, gpu_list, devices, uuid):
# Write start message
if env.gut_const.execute_pac:
message = 'Using the --execute_pac option Reset commands will be written to the GPU without confirmation.\nSudo will be used, so you may be prompted for credentials in the window where amdgpu-pac was executed from.'
else:
message = 'Writing reset commands to bash file.\n'
self.update_message(devices, message, 'red')
# reset each card
for gk in gpu_list.list.keys():
self.reset_card(parent, gpu_list, devices, gk, refresh=False)
# Write finish message
if env.gut_const.execute_pac:
message = 'Write reset commands to card complete.\nConfirm changes with amdgpu-monitor.'
else:
message = 'Write reset commands to bash file complete.\nRun bash file with sudo to execute changes.'
self.update_message(devices, message, 'yellow')
self.refresh_all_cards(parent, gpu_list, devices, uuid)
return
def reset_card(self, parent, gpu_list, devices, uuid, refresh=True):
if refresh:
# Write message
if env.gut_const.execute_pac:
message = 'Using the --execute_pac option Reset commands will be written to the GPU without confirmation.\nSudo will be used, so you may be prompted for credentials in the window where amdgpu-pac was executed from.'
else:
message = 'Writing reset commands to bash file.\n'
self.update_message(devices, message, 'red')
# specify output batch file name
out_filename = os.getcwd() + '/' + 'pac_resetter_' + str(uuid4().hex) + '.sh'
fileptr = open(out_filename, 'x')
# output header
print('#!/bin/sh', file=fileptr)
print('###########################################################################', file=fileptr)
print('## amdgpu-pac generated script to modify GPU configuration/settings', file=fileptr)
print('###########################################################################', file=fileptr)
print('', file=fileptr)
print('###########################################################################', file=fileptr)
print('## WARNING - Do not execute this script without completely', file=fileptr)
print('## understanding appropriate value to write to your specific GPUs', file=fileptr)
print('###########################################################################', file=fileptr)
print('#', file=fileptr)
print('# Copyright (C) 2019 RueiKe', file=fileptr)
print('#', file=fileptr)
print('# This program is free software: you can redistribute it and/or modify', file=fileptr)
print('# it under the terms of the GNU General Public License as published by', file=fileptr)
print('# the Free Software Foundation, either version 3 of the License, or', file=fileptr)
print('# (at your option) any later version.', file=fileptr)
print('#', file=fileptr)
print('# This program is distributed in the hope that it will be useful,', file=fileptr)
print('# but WITHOUT ANY WARRANTY; without even the implied warranty of', file=fileptr)
print('# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the', file=fileptr)
print('# GNU General Public License for more details.', file=fileptr)
print('#', file=fileptr)
print('# You should have received a copy of the GNU General Public License', file=fileptr)
print('# along with this program. If not, see .', file=fileptr)
print('###########################################################################', file=fileptr)
v = gpu_list.list[uuid]
print('# ', file=fileptr)
print('# Card' + v.card_num + ' ' + v.get_params_value('model'), file=fileptr)
print('# ' + v.card_path, file=fileptr)
print('# ', file=fileptr)
print('set -x', file=fileptr)
# Commit changes
power_cap_file = v.hwmon_path + 'power1_cap'
pwm_enable_file = v.hwmon_path + 'pwm1_enable'
device_file = v.card_path + 'pp_od_clk_voltage'
ppm_level_file = v.card_path + 'power_dpm_force_performance_level'
print("sudo sh -c \"echo \'0\' > %s\"" % power_cap_file, file=fileptr)
if env.gut_const.show_fans == True:
print("sudo sh -c \"echo \'2\' > %s\"" % (pwm_enable_file), file=fileptr)
print("sudo sh -c \"echo \'auto\' > %s\"" % ppm_level_file, file=fileptr)
print("sudo sh -c \"echo \'r\' > %s\"" % (device_file), file=fileptr)
print("sudo sh -c \"echo \'c\' > %s\"" % (device_file), file=fileptr)
# No need to reset clk pstate masks as commit to pp_od_clk_voltage will reset
# Close file and Set permissions and Execute it --execute_pac
fileptr.close()
os.chmod(out_filename, 0o744)
print('Batch file completed: %s' % out_filename)
if env.gut_const.execute_pac:
print('Writing changes to GPU %s' % v.card_path)
cmd = subprocess.Popen(out_filename, shell=True)
cmd.wait()
print('')
if refresh:
# dismiss execute_pac message
message = 'Write reset commands to card complete.\nConfirm changes with amdgpu-monitor.'
self.update_message(devices, message, 'yellow')
self.refresh_PAC(gpu_list, devices)
os.remove(out_filename)
else:
print('Execute to write changes to GPU %s' % v.card_path)
print('')
if refresh:
# dismiss execute_pac message
message = 'Write reset commands to bash file complete.\nRun bash file with sudo to execute changes.'
self.update_message(devices, message, 'yellow')
return
def ppm_select(self, device):
tree_iter = device['ppm_modes_combo'].get_active_iter()
if tree_iter is not None:
model = device['ppm_modes_combo'].get_model()
row_id, name = model[tree_iter][:2]
device['new_ppm'] = [row_id, name]
return
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--about', help='README', action='store_true', default=False)
parser.add_argument('--execute_pac', help='execute pac bash script without review',
action='store_true', default=False)
parser.add_argument('--no_fan', help='do not include fan setting options', action='store_true', default=False)
parser.add_argument('--force_write', help='write all parameters, even if unchanged',
action='store_true', default=False)
parser.add_argument('-d', '--debug', help='Debug output', action='store_true', default=False)
args = parser.parse_args()
# About me
if args.about:
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
env.gut_const.DEBUG = args.debug
if args.no_fan:
env.gut_const.show_fans = False
if args.force_write:
env.gut_const.write_delta_only = False
else:
env.gut_const.write_delta_only = True
env.gut_const.execute_pac = args.execute_pac
if env.gut_const.check_env() < 0:
print('Error in environment. Exiting...')
sys.exit(-1)
# Check value of AMD Feature mask
try:
featuremask = env.gut_const.read_amdfeaturemask()
except FileNotFoundError:
print('Cannot read ppfeaturemask. Exiting...')
sys.exit(-1)
if featuremask == int(0xffff7fff) or featuremask == int(0xffffffff) or featuremask == int(0xfffd7fff):
print('AMD Wattman features enabled: %s' % hex(featuremask))
else:
print('AMD Wattman features not enabled: %s, See README file.' % hex(featuremask))
sys.exit(-1)
env.gut_const.get_amd_driver_version()
# Get list of AMD GPUs and get basic non-driver details
gpu_list = GPU.GPU_LIST()
gpu_list.get_gpu_list()
gpu_list.read_allgpu_pci_info()
# Check list of AMD GPUs
num_amd_gpus = gpu_list.num_gpus()
num_com_gpus = gpu_list.num_compatible_gpus()
if num_amd_gpus == 0:
print('No AMD GPUs detected, exiting...')
sys.exit(-1)
else:
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
print(f'{num_amd_gpus} AMD GPUs detected, {num_com_gpus} may be compatible, checking...')
# Read data static driver information for GPUs
gpu_list.read_gpu_driver_info()
gpu_list.read_gpu_sensor_static_data()
# Read dynamic sensor and state data from GPUs
gpu_list.read_gpu_sensor_data()
gpu_list.read_gpu_state_data()
# Read pstate and ppm table data
gpu_list.read_gpu_pstates()
gpu_list.read_gpu_ppm_table()
# Check number of compatible GPUs again
num_com_gpus = gpu_list.num_compatible_gpus()
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
else:
print(f'{num_com_gpus} are confirmed compatible.')
print('')
# Generate a new list of only compatible GPUs
com_gpu_list = gpu_list.list_compatible_gpus()
# Display Gtk style Monitor
devices = {}
global gmonitor
gmonitor = PACWindow(com_gpu_list, devices)
gmonitor.connect('delete-event', Gtk.main_quit)
gmonitor.show_all()
Gtk.main()
if __name__ == '__main__':
main()
amdgpu-utils-2.6.0/amdgpu-pciid 0000775 0000000 0000000 00000010647 13546003346 0016437 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
""" amdgpu-pciid - Manages the local pci id lookup table
This utility will display the version of the current pci.ids data extract
in use. With the *--download* option, the latest pci.ids file from
https://pci-ids.ucw.cz/ will be downloaded. With the *--install* option,
the latest pci.ids will be downloaded and filtered for AMD specific data
and written to the file used by amdgpu-utils to decode device names from the
driver provided device id. The *--force* option can be used to update this
file even if there is no change in version. If your GPU model is missing
from the pci.ids file, you can use the device id of your card found with
*amdgpu-ls* and make a request for the addition on the pci.ids website.
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-pciid'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import argparse
import os
import sys
from GPUmodules import PCImodule as PCI
from GPUmodules import env
from pathlib import Path
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--about', help='README', action='store_true', default=False)
parser.add_argument('--download', help='download pci decode table from https://pci-ids.ucw.cz/v2.2/pci.ids',
action='store_true', default=False)
parser.add_argument('--install', help='download, parse amd entries, and install a new decode file',
action='store_true', default=False)
parser.add_argument('--force', help='force install of new pci.ids data even if revision is unchanged',
action='store_true', default=False)
parser.add_argument('-d', '--debug', help='Debug output', action='store_true', default=False)
args = parser.parse_args()
# About me
if args.about:
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
sys.exit(0)
env.gut_const.PATH = os.path.dirname(str(Path(__file__).resolve()))
env.gut_const.DEBUG = args.debug
if env.gut_const.check_env() < 0:
print('Error in environment. Exiting...')
sys.exit(-1)
pciid = PCI.PCI_ID()
# display info about pci.ids
if not args.download and not args.install:
original_amd_file = os.path.join(env.gut_const.PATH, 'GPUmodules', pciid.amdgpu_utils_file)
original_file_version = pciid.get_pciid_version()
print('Current pci.ids version %s : %s' % (original_file_version, original_amd_file))
sys.exit(0)
if args.download or args.install:
pciid_filename_new = pciid.download_pciid()
print('Download complete: %s' % pciid_filename_new)
new_file_version = pciid.get_pciid_version(pciid_filename_new)
print(' Download %s : %s' % (new_file_version, pciid_filename_new))
if args.install:
original_amd_file = os.path.join(env.gut_const.PATH, 'GPUmodules', pciid.amdgpu_utils_file)
original_file_version = pciid.get_pciid_version()
print(' Original %s : %s' % (original_file_version, original_amd_file))
if original_file_version == new_file_version and not args.force:
print('No updates, skipping install')
else:
pciid.update_pci_id(pciid_filename_new)
print('Completed update to %s' % new_file_version)
# remove downloaded file
os.remove(pciid_filename_new)
sys.exit(0)
if __name__ == '__main__':
main()
amdgpu-utils-2.6.0/amdgpu-plot 0000775 0000000 0000000 00000105271 13546003346 0016323 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
""" amdgpu-plot - Plot GPU parameter curves
A utility to continuously plot the trend of critical GPU parameters for all compatible
AMD GPUs. The *--sleep N* can be used to specify the update interval. The *amdgpu-plot*
utility has 2 modes of operation. The default mode is to read the GPU driver details
directly, which is useful as a standalone utility. The *--stdin* option causes
*amdgpu-plot* to read GPU data from stdin. This is how *amdgpu-monitor* produces the
plot and can also be used to pipe your own data into the process. The *--simlog*
option can be used with the *--stdin* when a monitor log file is piped as stdin.
This is useful for troubleshooting and can be used to display saved log results.
The *--ltz* option results in the use of local time instead of UTC. If you plan
to run both *amdgpu-plot* and *amdgpu-monitor*, then the *--plot* option of the
*amdgpu-monitor* utility should be used instead of both utilities in order reduce
data reads by a factor of 2.
Copyright (C) 2019 RueiKe
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
"""
__author__ = 'RueiKe'
__copyright__ = 'Copyright (C) 2019 RueiKe'
__credits__ = ['Craig Echt - Testing, Debug, Verification, and Documentation']
__license__ = 'GNU General Public License'
__program_name__ = 'amdgpu-plot'
__version__ = 'v2.6.0'
__maintainer__ = 'RueiKe'
__status__ = 'Stable Release'
import sys
import gc as garbcollect
import argparse
import re
import threading
import os
import time
from pathlib import Path
import numpy as np
try:
from matplotlib.ticker import AutoLocator
from matplotlib.backends.backend_gtk3cairo import FigureCanvasGTK3Cairo as FigureCanvas
from matplotlib.figure import Figure
import matplotlib.pyplot as plt
#import matplotlib.dates as mdates
except ModuleNotFoundError as error:
print('matplotlib import error: {}'.format(error))
print('matplotlib is required for %s', __program_name__)
print('Use \'sudo apt-get install python3-matplotlib\' to install')
sys.exit(0)
try:
import pandas as pd
except ModuleNotFoundError as error:
print('Pandas import error: {}'.format(error))
print('Pandas is required for %s', __program_name__)
print('Install pip3 if needed: \'sudo apt install python3-pip\'')
print('Then pip install pandas: \'pip3 install pandas\'')
sys.exit(0)
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
try:
import gi
except ModuleNotFoundError as error:
print('gi import error: {}'.format(error))
print('gi is required for %s', __program_name__)
print(' In a venv, first install vext: pip install --no-cache-dir vext')
print(' Then install vext.gi: pip install --no-cache-dir vext.gi')
sys.exit(0)
gi.require_version('Gtk', '3.0')
from gi.repository import GLib, Gtk, Gdk
from GPUmodules import GPUmodule as GPU
from GPUmodules import env
# SEMAPHORE ############
pd_sem = threading.Semaphore()
########################
def hex_to_rgba(value):
# Code copied from Stack Overflow
value = value.lstrip('#')
if len(value) == 3:
value = ''.join([v*2 for v in list(value)])
(r1, g1, b1, a1) = tuple(int(value[i:i+2], 16) for i in range(0, 6, 2))+(1,)
(r1, g1, b1, a1) = (r1/255.00000, g1/255.00000, b1/255.00000, a1)
return r1, g1, b1, a1
def get_stack_size():
"""Get stack size for caller's frame.
Code copied from Stack Overflow
"""
size = 2 # current frame and caller's frame always exist
while True:
try:
sys._getframe(size)
size += 1
except ValueError:
return size - 1 # subtract current frame
class PlotData:
def __init__(self):
self.df = pd.DataFrame()
self.gui_comp = None
self.gui_ready = False
self.length = 200
self.quit = False
self.writer = False
self.reader = False
self.consec_writer = 0
self.consec_reader = 0
self.gpu_list = ''
self.num_gpus = 1
self.com_gpu_list = GPU.GPU_LIST()
def set_gpus(self):
self.num_gpus = self.df['Card#'].nunique()
self.gpu_list = self.df['Card#'].unique()
def get_plot_data(self):
# get deep copy of plot data df
# This may have contention issues
# SEMAPHORE ############
pd_sem.acquire()
########################
ndf = self.df.copy()
# SEMAPHORE ############
pd_sem.release()
########################
return ndf
def kill_thread(self):
self.reader = False
self.quit = True
print('Stopping reader thread')
time.sleep(0.2)
class GuiComponents:
def __init__(self, plot_data):
plot_data.gui_comp = self
self.ready = False
self.gpu_list = plot_data.gpu_list
self.num_gpus = plot_data.num_gpus
self.gui_components = {}
self.gpu_color = {}
self.colors = {'plotface': '#404040', 'figface': '#909090', 'sclk_f': '#BED661', 'mclk_f': '#89E894',
'loading': '#1E90FF', 'power': '#E12B06', 'power_cap': '#800000', 'vddgfx': '#778899',
'temp': '#E0E0E0'}
self.font_colors = {'plotface': '#000000', 'figface': '#000000', 'sclk_f': '#000000', 'mclk_f': '#000000',
'loading': '#FFFFFF', 'power': '#FFFFFF', 'power_cap': '#FFFFFF', 'vddgfx': '#000000',
'temp': '#000000'}
gpu_color_list = ['#B52735', '#EBB035', '#06A2CB', '#218559', '#D0C6B1', '#E18A07', '#336688', '#7C821E']
plot_item_list = ['loading', 'power', 'power_cap', 'temp', 'vddgfx', 'sclk_f', 'mclk_f']
self.plot_items = {'loading': True, 'power': True, 'power_cap': True,
'temp': True, 'vddgfx': True,'sclk_f': True, 'mclk_f': True}
self.gui_components['info_bar'] = {}
self.gui_components['legend'] = {}
self.gui_components['legend']['buttons'] = {}
self.gui_components['legend']['plot_items'] = {}
for plotitem in plot_item_list:
self.gui_components['legend']['plot_items'][plotitem] = True
self.gui_components['sclk_pstate_status'] = {}
self.gui_components['sclk_pstate_status']['df_name'] = 'sclk_ps'
self.gui_components['mclk_pstate_status'] = {}
self.gui_components['mclk_pstate_status']['df_name'] = 'mclk_ps'
self.gui_components['temp_status'] = {}
self.gui_components['temp_status']['df_name'] = 'temp'
self.gui_components['card_plots'] = {}
for i, gpu in enumerate(self.gpu_list):
self.gui_components['card_plots'][gpu] = {}
self.gui_components['card_plots'][gpu]['color'] = gpu_color_list[i]
self.gpu_color[gpu] = gpu_color_list[i]
return
def set_ready(self, mode):
self.ready = mode
def is_ready(self):
return self.ready
class GPUPlotWindow(Gtk.Window):
def __init__(self, gc, plot_data):
box_spacing_val = 5
num_bar_plots = 3
if gc.num_gpus > 4:
def_gp_y_size = 150
def_bp_y_size = 200
elif gc.num_gpus == 4:
def_gp_y_size = 200
def_bp_y_size = 200
else:
def_gp_y_size = 250
def_bp_y_size = 250
def_gp_x_size = 600
def_bp_x_size = 250
def_lab_y_size = 28
if gc.num_gpus > num_bar_plots:
tot_y_size = gc.num_gpus * (def_gp_y_size + def_lab_y_size)
gp_y_size = def_gp_y_size
bp_y_size = (tot_y_size - (num_bar_plots * def_lab_y_size))/num_bar_plots
elif gc.num_gpus < num_bar_plots:
tot_y_size = num_bar_plots * (def_bp_y_size + def_lab_y_size)
bp_y_size = def_bp_y_size
gp_y_size = (tot_y_size - (gc.num_gpus * def_lab_y_size))/gc.num_gpus
else:
gp_y_size = def_gp_y_size
bp_y_size = def_bp_y_size
Gtk.Window.__init__(self, title='amdgpu-plot')
self.set_border_width(1)
icon_file = os.path.join(env.gut_const.PATH, 'icons', 'amdgpu-plot.icon.png')
if os.path.isfile(icon_file):
self.set_icon_from_file(icon_file)
grid = Gtk.Grid()
grid.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(0.7, 0.7, 0.7, 1))
self.add(grid)
# Get deep copy of current df
ldf = plot_data.get_plot_data()
row = 0
# Top Bar - info
gc.gui_components['info_bar']['gtk_obj'] = Gtk.Label()
gc.gui_components['info_bar']['gtk_obj'].set_markup('' + 'amdgpu-util Plot' + '' + '')
gc.gui_components['info_bar']['gtk_obj'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
gc.gui_components['info_bar']['gtk_obj'].set_property('margin-top', 1)
gc.gui_components['info_bar']['gtk_obj'].set_property('margin-bottom', 1)
gc.gui_components['info_bar']['gtk_obj'].set_property('margin-right', 4)
gc.gui_components['info_bar']['gtk_obj'].set_property('margin-left', 4)
gc.gui_components['info_bar']['gtk_obj'].set_alignment(0.5, 0.5)
lbox = Gtk.Box(spacing=box_spacing_val)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.20, .40, .60, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(gc.gui_components['info_bar']['gtk_obj'], True, True, 0)
grid.attach(lbox, 1, row, 4, 1)
row += 1
# Legend
gc.gui_components['legend']['gtk_obj'] = Gtk.Label()
gc.gui_components['legend']['gtk_obj'].set_markup('' + 'Plot Items' + '' + '')
gc.gui_components['legend']['gtk_obj'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
gc.gui_components['legend']['gtk_obj'].set_property('margin-top', 1)
gc.gui_components['legend']['gtk_obj'].set_property('margin-bottom', 1)
gc.gui_components['legend']['gtk_obj'].set_property('margin-right', 4)
gc.gui_components['legend']['gtk_obj'].set_property('margin-left', 4)
gc.gui_components['legend']['gtk_obj'].set_alignment(0.5, 0.5)
lbox = Gtk.Box(spacing=box_spacing_val)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.40, .40, .40, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(gc.gui_components['legend']['gtk_obj'], True, True, 0)
for k, v in gc.gui_components['legend']['plot_items'].items():
but_color = hex_to_rgba(gc.colors[k])
but_font_color = hex_to_rgba(gc.font_colors[k])
gc.gui_components['legend']['buttons'][k] = Gtk.Button('')
for child in gc.gui_components['legend']['buttons'][k].get_children():
child.set_label('' + k + '')
child.set_use_markup(True)
child.override_color(
Gtk.StateFlags.NORMAL,
Gdk.RGBA(but_font_color[0], but_font_color[1], but_font_color[2], but_font_color[3]))
child.override_background_color(
Gtk.StateFlags.NORMAL,
Gdk.RGBA(but_color[0], but_color[1], but_color[2], but_color[3]))
gc.gui_components['legend']['buttons'][k].override_color(
Gtk.StateFlags.NORMAL,
Gdk.RGBA(but_font_color[0], but_font_color[1], but_font_color[2], but_font_color[3]))
gc.gui_components['legend']['buttons'][k].override_background_color(
Gtk.StateFlags.NORMAL,
Gdk.RGBA(but_color[0], but_color[1], but_color[2], but_color[3]))
gc.gui_components['legend']['buttons'][k].connect('clicked', self.toggle_plot_item, gc, k)
gc.gui_components['legend']['buttons'][k].set_property('width-request', 90)
gc.gui_components['legend']['buttons'][k].set_property('margin-top', 1)
gc.gui_components['legend']['buttons'][k].set_property('margin-bottom', 1)
gc.gui_components['legend']['buttons'][k].set_property('margin-right', 1)
gc.gui_components['legend']['buttons'][k].set_property('margin-left', 1)
lbox.pack_start(gc.gui_components['legend']['buttons'][k], True, True, 0)
grid.attach(lbox, 1, row, 4, 1)
row += 1
main_last_row = row
# Set up bar plots
grid_bar = Gtk.Grid()
grid_bar.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(0.7, 0.7, 0.7, 1))
grid.attach(grid_bar, 1, main_last_row, 1, 1)
brow = 0
fig_num = 0
# plot_top_row = row
for v in [gc.gui_components['sclk_pstate_status'],
gc.gui_components['mclk_pstate_status'],
gc.gui_components['temp_status']]:
# Add Bar Plots Titles
v['title_obj'] = Gtk.Label()
v['title_obj'].set_markup('Card ' + v['df_name'] + '' + '')
v['title_obj'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
v['title_obj'].set_property('margin-top', 1)
v['title_obj'].set_property('margin-bottom', 1)
v['title_obj'].set_property('margin-right', 4)
v['title_obj'].set_property('margin-left', 4)
v['title_obj'].set_alignment(0.5, 0.5)
lbox = Gtk.Box(spacing=box_spacing_val)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(.20, .40, .60, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(v['title_obj'], True, True, 0)
grid_bar.attach(lbox, 1, brow, 1, 1)
brow += 1
# Add Bar Plots
# Set up plot figure and canvas
v['figure_num'] = 100 + fig_num
fig_num += 1
v['figure'], v['ax1'] = plt.subplots(num=v['figure_num'])
v['figure'].set_facecolor(gc.colors['figface'])
plt.figure(v['figure_num'])
plt.subplots_adjust(left=0.13, right=0.97, top=0.97, bottom=0.1)
v['ax1'].set_facecolor(gc.colors['plotface'])
if v['df_name'] == 'temp':
plt.yticks(np.arange(20, 91, 10))
else:
plt.yticks(np.arange(0, 9, 1))
v['canvas'] = FigureCanvas(v['figure']) # a Gtk.DrawingArea
v['canvas'].set_size_request(def_bp_x_size, bp_y_size)
lbox = Gtk.Box(spacing=box_spacing_val)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(0.5, 0.5, 0.5, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(v['canvas'], True, True, 0)
grid_bar.attach(lbox, 1, brow, 1, 1)
brow += 1
# Set up gpu plots
grid_plot = Gtk.Grid()
grid_plot.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(0.7, 0.7, 0.7, 1))
grid.attach(grid_plot, 2, main_last_row, 3, 1)
prow = 0
# row = plot_top_row
for k, v in gc.gui_components['card_plots'].items():
data_val = ldf[ldf['Card#'].isin([k])]['energy'].iloc[-1]
model_val = ldf[ldf['Card#'].isin([k])]['model_display'].iloc[-1]
# Add GPU Plots Titles
v['title_obj'] = Gtk.Label()
v['title_obj'].set_markup('Card ' + str(k) + ' ' + str(model_val) +
' Energy: ' + str(data_val) + '' + '')
v['title_obj'].override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(1.0, 1.0, 1.0, 1.0))
v['title_obj'].set_property('margin-top', 1)
v['title_obj'].set_property('margin-bottom', 1)
v['title_obj'].set_property('margin-right', 4)
v['title_obj'].set_property('margin-left', 4)
v['title_obj'].set_alignment(0.5, 0.5)
lbox = Gtk.Box(spacing=box_spacing_val)
rgba_col = hex_to_rgba(v['color'])
lbox.override_background_color(Gtk.StateType.NORMAL,
Gdk.RGBA(rgba_col[0], rgba_col[1], rgba_col[2], rgba_col[3]))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(v['title_obj'], True, True, 0)
grid_plot.attach(lbox, 1, prow, 1, 1)
prow += 1
# Add GPU Plots
# Set up plot figure and canvas
v['figure_num'] = 500 + k
v['figure'], v['ax1'] = plt.subplots(num=v['figure_num'])
v['figure'].set_facecolor(gc.colors['figface'])
plt.figure(v['figure_num'])
plt.subplots_adjust(left=0.1, right=0.9, top=0.97, bottom=0.03)
v['ax1'].set_facecolor(gc.colors['plotface'])
v['ax1'].set_xticks([])
v['ax1'].set_xticklabels([])
v['ax1'].set_yticks(np.arange(0, 250, 20))
v['ax1'].tick_params(axis='y', which='major', labelsize=8)
v['ax2'] = v['ax1'].twinx()
v['ax2'].set_xticks([])
v['ax2'].set_xticklabels([])
v['ax2'].set_yticks(np.arange(500, 1500, 100))
v['ax2'].tick_params(axis='y', which='major', labelsize=8)
v['canvas'] = FigureCanvas(v['figure']) # a Gtk.DrawingArea
v['canvas'].set_size_request(def_gp_x_size, gp_y_size)
lbox = Gtk.Box(spacing=box_spacing_val)
lbox.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1, 1, 1, 1.0))
lbox.set_property('margin-top', 1)
lbox.set_property('margin-bottom', 1)
lbox.set_property('margin-right', 1)
lbox.set_property('margin-left', 1)
lbox.pack_start(v['canvas'], True, True, 0)
grid_plot.attach(lbox, 1, prow, 1, 1)
prow += 1
def toggle_plot_item(self, parent, gc, k):
if gc.plot_items[k]:
gc.plot_items[k] = False
else:
gc.plot_items[k] = True
def updateData(gc, plot_data):
# SEMAPHORE ###########
pd_sem.acquire()
#######################
ldf = plot_data.df
try:
time_val = ldf[ldf['Card#'].isin([plot_data.gpu_list[0]])]['Time'].iloc[-1]
gc.gui_components['info_bar']['gtk_obj'].set_markup('Time ' + str(time_val) + '')
# Update Bar Plots
for v in [gc.gui_components['sclk_pstate_status'],
gc.gui_components['mclk_pstate_status'],
gc.gui_components['temp_status']]:
data_val = []
label_val = []
bar_col = []
# Set Plot Parameters
for k in plot_data.gpu_list:
l, d = ldf[ldf['Card#'].isin([k])][['Card#', v['df_name']]].iloc[-1]
label_val.append(int(l))
data_val.append(float(d))
bar_col.append(gc.gpu_color[l])
ind = np.arange(gc.num_gpus) # the x locations for the groups
width = 0.65 # the width of the bars
# Do bar plot
plt.figure(v['figure_num'])
v['ax1'].clear()
rects1 = v['ax1'].bar(ind, data_val, width, color=bar_col, tick_label=label_val)
if v['df_name'] == 'temp':
for a, b in zip(ind, data_val):
v['ax1'].text(x=float(a)-(float(width)/1.8), y=0.90*b, s=' '+str(b), fontsize=8)
plt.ylim((20, 91))
#v['ax1'].set_ylabel('Temp (C)', color='k')
else:
data_val = list(map(int, data_val))
for a, b in zip(ind, data_val):
if b == 0:
y_val = b + width
else:
y_val = b - width
v['ax1'].text(x=a-width/4.0, y=y_val, s=str(b), fontsize=10)
plt.ylim((0, 8))
v['canvas'].draw()
v['canvas'].flush_events()
# Update GPU Plots
y1lim_max_val = 10*(ldf.loc[:, ['loading', 'power_cap', 'power', 'temp']].max().max() // 10) + 5
y1lim_min_val = 10*(ldf.loc[:, ['loading', 'power_cap', 'power', 'temp']].min().min() // 10) - 5
y2lim_max_val = 100*(ldf.loc[:, ['vddgfx', 'sclk_f', 'mclk_f']].max().max() // 100) + 300
y2lim_min_val = 100*(ldf.loc[:, ['vddgfx', 'sclk_f', 'mclk_f']].min().min() // 100) - 100
for k, v in gc.gui_components['card_plots'].items():
data_val = ldf[ldf['Card#'].isin([k])]['energy'].iloc[-1]
model_val = ldf[ldf['Card#'].isin([k])]['model_display'].iloc[-1]
v['title_obj'].set_markup('Card ' + str(k) + ' ' + str(model_val) +
' Energy: ' + str(data_val) + '' + '')
# Plot GPUs
plt.figure(v['figure_num'])
v['ax1'].set_xticklabels([])
v['ax1'].clear()
v['ax1'].set_ylabel('Loading/Power/Temp', color='k', fontsize=10)
for plot_item in ['loading', 'power_cap', 'power', 'temp']:
if gc.plot_items[plot_item]:
v['ax1'].plot(ldf[ldf['Card#'].isin([k])]['datetime'],
ldf[ldf['Card#'].isin([k])][plot_item],
color=gc.colors[plot_item], linewidth=0.5)
v['ax1'].text(x=ldf[ldf['Card#'].isin([k])]['datetime'].iloc[-1],
y=ldf[ldf['Card#'].isin([k])][plot_item].iloc[-1],
s=str(int(ldf[ldf['Card#'].isin([k])][plot_item].iloc[-1])),
bbox=dict(boxstyle='round,pad=0.2', facecolor=gc.colors[plot_item]), fontsize=6)
v['ax2'].clear()
v['ax2'].set_xticklabels([])
v['ax2'].set_ylabel('MHz/mV', color='k', fontsize=10)
for plot_item in ['vddgfx', 'sclk_f', 'mclk_f']:
if gc.plot_items[plot_item]:
v['ax2'].plot(ldf[ldf['Card#'].isin([k])]['datetime'],
ldf[ldf['Card#'].isin([k])][plot_item],
color=gc.colors[plot_item], linewidth=0.5)
v['ax2'].text(x=ldf[ldf['Card#'].isin([k])]['datetime'].iloc[-1],
y=ldf[ldf['Card#'].isin([k])][plot_item].iloc[-1],
s=str(int(ldf[ldf['Card#'].isin([k])][plot_item].iloc[-1])),
bbox=dict(boxstyle='round,pad=0.2', facecolor=gc.colors[plot_item]), fontsize=6)
v['ax1'].set_yticks(np.arange(y1lim_min_val, y1lim_max_val, 10))
v['ax2'].set_yticks(np.arange(y2lim_min_val, y2lim_max_val, 100))
v['canvas'].draw()
v['canvas'].flush_events()
except:
print('matplotlib error, stack size is %d' % get_stack_size())
plot_data.kill_thread()
# SEMAPHORE ###########
pd_sem.release()
#######################
def read_from_stdin(refreshtime, plot_data):
# this should continuously from from stdin and populate df and call plot/gui update
first_update = True
header = True
sync_add = 0
while not plot_data.quit:
if env.gut_const.SIMLOG: time.sleep(refreshtime/4.0)
ndf = pd.DataFrame()
# Process a set of GPUs at a time
skip_update = False
read_time = 0.0
for gpu_index in range(0, plot_data.num_gpus + sync_add):
tb = env.gut_const.now(env.gut_const.USELTZ)
line = sys.stdin.readline()
tmp_read_time = (env.gut_const.now(env.gut_const.USELTZ) - tb).total_seconds()
if tmp_read_time > read_time:
read_time = tmp_read_time
if line == '':
if env.gut_const.DEBUG: print('Error: Null input line')
plot_data.kill_thread()
break
if header:
header_item = list(line.strip().split('|'))
header = False
continue
line = line.strip()
line_item = list(line.strip().split('|'))
new_line_item = []
for l in line_item:
ll = l.strip()
if ll.isnumeric():
new_line_item.append(int(ll))
elif re.fullmatch(r'[0-9]+.[0-9]*', ll) or re.fullmatch(r'[0-9]*.[0-9]+', ll):
new_line_item.append(float(ll))
elif ll == '' or ll == '-1' or ll == 'NA' or ll is None:
new_line_item.append(np.nan)
else:
new_line_item.append(ll)
line_item = tuple(new_line_item)
rdf = pd.DataFrame.from_records([line_item], columns=header_item)
rdf['datetime'] = pd.to_datetime(rdf['Time'])
ndf = pd.concat([ndf, rdf], ignore_index=True)
del rdf
if ndf['Time'].tail(plot_data.num_gpus).nunique() > 1:
sync_add = 1
else:
sync_add = 0
if env.gut_const.DEBUG:
print(env.gut_const.now(env.gut_const.USELTZ).strftime('%c'))
print(ndf)
if not env.gut_const.SIMLOG:
if read_time < 0.003:
skip_update = True
if env.gut_const.DEBUG: print('skipping update')
# SEMAPHORE ############
pd_sem.acquire()
########################
# Concatenate new data on plot_data dataframe and truncate
plot_data.df = pd.concat([plot_data.df, ndf], ignore_index=True)
plot_data.df.reset_index(drop=True, inplace=True)
# Truncate df in place
plot_length = int(len(plot_data.df.index) / plot_data.num_gpus)
#print('df length: {}, plot_data.length: {}'.format(plot_length, plot_data.length))
if plot_length > plot_data.length:
trun_index = plot_length - plot_data.length
plot_data.df.drop(np.arange(0, trun_index), inplace=True)
plot_data.df.reset_index(drop=True, inplace=True)
# SEMAPHORE ############
pd_sem.release()
########################
del ndf
#########################
# Update plots
#########################
if skip_update:
continue
if plot_data.gui_comp is None:
continue
if plot_data.gui_comp.is_ready():
if first_update:
time.sleep(refreshtime)
first_update = False
GLib.idle_add(updateData, plot_data.gui_comp, plot_data)
while Gtk.events_pending():
Gtk.main_iteration_do(True)
# SEMAPHORE ############
time.sleep(0.01)
pd_sem.acquire()
pd_sem.release()
########################
garbcollect.collect()
if env.gut_const.DEBUG: print('update stack size: ', get_stack_size())
# Quit
print('exit stack size: ', get_stack_size())
sys.exit(0)
def read_from_gpus(refreshtime, plot_data):
# This should continuously from from gpus and populate df and call plot/gui update
first_update = True
while not plot_data.quit:
ndf = pd.DataFrame()
plot_data.com_gpu_list.read_gpu_sensor_data()
plot_data.com_gpu_list.read_gpu_state_data()
# Process a set of GPUs at a time
skip_update = False
for k, v in plot_data.com_gpu_list.list.items():
gpu_plot_data = v.get_plot_data(plot_data.com_gpu_list)
if env.gut_const.DEBUG: print('gpu_plot_data: ', gpu_plot_data)
rdf = pd.DataFrame.from_records([tuple(gpu_plot_data.values())], columns=tuple(gpu_plot_data.keys()))
rdf['datetime'] = pd.to_datetime(rdf['Time'])
ndf = pd.concat([ndf, rdf], ignore_index=True)
del rdf
# SEMAPHORE ############
pd_sem.acquire()
########################
# Concatenate new data on plot_data dataframe and truncate
plot_data.df = pd.concat([plot_data.df, ndf], ignore_index=True)
plot_data.df.reset_index(drop=True, inplace=True)
# Truncate df in place
plot_length = int(len(plot_data.df.index) / plot_data.num_gpus)
#print('df length: {}, plot_data.length: {}'.format(plot_length, plot_data.length))
if plot_length > plot_data.length:
trun_index = plot_length - plot_data.length
plot_data.df.drop(np.arange(0, trun_index), inplace=True)
plot_data.df.reset_index(drop=True, inplace=True)
# SEMAPHORE ############
pd_sem.release()
########################
del ndf
#########################
# Update plots
#########################
if skip_update:
continue
if plot_data.gui_comp is None:
time.sleep(refreshtime)
continue
if plot_data.gui_comp.is_ready():
if first_update:
time.sleep(refreshtime)
first_update = False
GLib.idle_add(updateData, plot_data.gui_comp, plot_data)
while Gtk.events_pending():
Gtk.main_iteration_do(True)
# SEMAPHORE ############
time.sleep(0.01)
pd_sem.acquire()
pd_sem.release()
########################
garbcollect.collect()
if env.gut_const.DEBUG: print('update stack size: ', get_stack_size())
time.sleep(refreshtime)
# Quit
print('exit stack size: ', get_stack_size())
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--about', help='README', action='store_true', default=False)
parser.add_argument('--stdin', help='Read from stdin', action='store_true', default=False)
parser.add_argument('--simlog', help='Simulate with piped log file', action='store_true', default=False)
parser.add_argument('--ltz', help='Use local time zone instead of UTC', action='store_true', default=False)
parser.add_argument('--sleep', help='Number of seconds to sleep between updates', type=int, default=3)
parser.add_argument('-d', '--debug', help='Debug output', action='store_true', default=False)
args = parser.parse_args()
# About me
if args.about:
print(__doc__)
print('Author: ', __author__)
print('Copyright: ', __copyright__)
print('Credits: ', __credits__)
print('License: ', __license__)
print('Version: ', __version__)
print('Maintainer: ', __maintainer__)
print('Status: ', __status__)
import matplotlib
print('matplotlib version: ', matplotlib.__version__)
print('pandas version: ', pd.__version__)
print('numpy version: ', np.__version__)
sys.exit(0)
env.gut_const.PATH = os.path.dirname(str(Path(__file__).resolve()))
env.gut_const.DEBUG = args.debug
env.gut_const.SIMLOG = args.simlog
if args.ltz:
env.gut_const.USELTZ = True
if env.gut_const.check_env() < 0:
print('Error in environment. Exiting...')
sys.exit(-1)
# Define graph gui and data components
plot_data = PlotData()
if not args.stdin:
# Check value of AMD Feature mask
try:
featuremask = env.gut_const.read_amdfeaturemask()
except FileNotFoundError:
print('Cannot read ppfeaturemask. Exiting...')
sys.exit(-1)
if featuremask == int(0xffff7fff) or featuremask == int(0xffffffff) or featuremask == int(0xfffd7fff):
print('AMD Wattman features enabled: %s' % hex(featuremask))
else:
print('AMD Wattman features not enabled: %s, See README file.' % hex(featuremask))
sys.exit(-1)
env.gut_const.get_amd_driver_version()
# Get list of AMD GPUs and get basic non-driver details
gpu_list = GPU.GPU_LIST()
gpu_list.get_gpu_list()
gpu_list.read_allgpu_pci_info()
# Check list of AMD GPUs
num_amd_gpus = gpu_list.num_gpus()
num_com_gpus = gpu_list.num_compatible_gpus()
if num_amd_gpus == 0:
print('No AMD GPUs detected, exiting...')
sys.exit(-1)
else:
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
print(f'{num_amd_gpus} AMD GPUs detected, {num_com_gpus} may be compatible, checking...')
# Read data static driver information for GPUs
gpu_list.read_gpu_driver_info()
gpu_list.read_gpu_sensor_static_data()
# Read dynamic sensor and state data from GPUs
gpu_list.read_gpu_sensor_data()
gpu_list.read_gpu_state_data()
# Check number of compatible GPUs again
num_com_gpus = gpu_list.num_compatible_gpus()
if num_com_gpus == 0:
print('None are compatible, exiting...')
sys.exit(-1)
else:
print(f'{num_com_gpus} are confirmed compatible.')
print('')
# Generate a new list of only compatible GPUs
plot_data.com_gpu_list = gpu_list.list_compatible_gpus()
plot_data.num_gpus = num_com_gpus
# end of if args.stdin == False
if args.stdin or args.simlog:
readthread = threading.Thread(target=read_from_stdin, daemon=True, args=[args.sleep, plot_data]).start()
else:
readthread = threading.Thread(target=read_from_gpus, daemon=True, args=[args.sleep, plot_data]).start()
print('%s waiting for initial data' % __program_name__, end='', flush=True)
while len(plot_data.df.index) < 9:
print('.', end='', flush=True)
time.sleep(args.sleep/4.0)
print('')
# After reading initial data, set gpus
plot_data.set_gpus()
gc = GuiComponents(plot_data)
gplot = GPUPlotWindow(gc, plot_data)
gplot.connect('delete-event', Gtk.main_quit)
gplot.show_all()
gc.set_ready(True)
Gtk.main()
plot_data.kill_thread()
if __name__ == '__main__':
main()
amdgpu-utils-2.6.0/docs/ 0000775 0000000 0000000 00000000000 13546003346 0015066 5 ustar 00root root 0000000 0000000 amdgpu-utils-2.6.0/docs/Type1vsType2.png 0000664 0000000 0000000 00000046064 13546003346 0020105 0 ustar 00root root 0000000 0000000 PNG
IHDR e eIy sRGB gAMA a pHYs od KIDATx^ŕg