blob: 6b77f9c987949fa2c3af44a8db4b4f955a8889f1 [file]
# SPDX-License-Identifier: MIT
"""CPPC triage script for AMD systems"""
import os
import argparse
import re
import sys
import pandas as pd
from tabulate import tabulate
from pyudev import Context
from amd_debug.common import (
AmdTool,
get_pretty_distro,
print_color,
read_file,
read_msr,
relaunch_sudo,
show_log_info,
version,
)
class MSR: # pylint: disable=too-few-public-methods
"""MSR addresses for CPPC
AMD's MSR-based implementation of ACPI CPPC (Collaborative Processor
Performance Control). Defined in Linux kernel at
arch/x86/include/asm/msr-index.h (commit 89aa94b4a218)
"""
MSR_AMD_CPPC_CAP1 = 0xC00102B0
MSR_AMD_CPPC_ENABLE = 0xC00102B1
MSR_AMD_CPPC_CAP2 = 0xC00102B2
MSR_AMD_CPPC_REQ = 0xC00102B3
MSR_AMD_CPPC_STATUS = 0xC00102B4
def amd_cppc_cap_lowest_perf(x):
"""Return the lowest performance value from the given input."""
return x & 0xFF
def amd_cppc_cap_lownonlin_perf(x):
"""Return the lowest nonlinear performance value from the given input."""
return (x >> 8) & 0xFF
def amd_cppc_cap_nominal_perf(x):
"""Return the nominal performance value from the given input."""
return (x >> 16) & 0xFF
def amd_cppc_cap_highest_perf(x):
"""Return the highest performance value from the given input."""
return (x >> 24) & 0xFF
def amd_cppc_max_perf(x):
"""Return the maximum performance value from the given input."""
return x & 0xFF
def amd_cppc_min_perf(x):
"""Return the minimum performance value from the given input."""
return (x >> 8) & 0xFF
def amd_cppc_des_perf(x):
"""Return the desired performance value from the given input."""
return (x >> 16) & 0xFF
def amd_cppc_epp_perf(x):
"""Return the energy performance preference value from the given input."""
return (x >> 24) & 0xFF
class AmdPstateTriage(AmdTool):
"""Class for handling the triage process"""
def __init__(self, logging):
log_prefix = "pstate" if logging else None
super().__init__(log_prefix)
relaunch_sudo()
pretty = get_pretty_distro()
print_color(f"{pretty}", "🐧")
self.context = Context()
def gather_amd_pstate_info(self):
"""Gather AMD Pstate global information"""
for f in ("status", "prefcore"):
p = os.path.join("/", "sys", "devices", "system", "cpu", "amd_pstate", f)
if os.path.exists(p):
print_color(f"'{f}':\t{read_file(p)}", "○")
def gather_kernel_info(self):
"""Gather kernel information"""
print_color(f"Kernel:\t{os.uname().release}", "🐧")
def gather_scheduler_info(self):
"""Gather information about the scheduler"""
procfs = os.path.join("/", "proc", "sys", "kernel", "sched_itmt_enabled")
debugfs = os.path.join(
"/", "sys", "kernel", "debug", "x86", "sched_itmt_enabled"
)
for p in [procfs, debugfs]:
if os.path.exists(p):
val = read_file(p)
print_color(f"ITMT:\t{val}", "🐧")
def gather_cpu_info(self):
"""Gather a dataframe of CPU information"""
df = pd.DataFrame(
columns=[
"CPU #",
"CPU Min Freq",
"CPU Nonlinear Freq",
"CPU Max Freq",
"Scaling Min Freq",
"Scaling Max Freq",
"Energy Performance Preference",
"Prefcore",
"Boost",
]
)
for device in self.context.list_devices(subsystem="cpu"):
p = os.path.join(device.sys_path, "cpufreq")
if not os.path.exists(p):
continue
row = [
int(re.findall(r"\d+", f"{device.sys_name}")[0]),
read_file(os.path.join(p, "cpuinfo_min_freq")),
read_file(os.path.join(p, "amd_pstate_lowest_nonlinear_freq")),
read_file(os.path.join(p, "cpuinfo_max_freq")),
read_file(os.path.join(p, "scaling_min_freq")),
read_file(os.path.join(p, "scaling_max_freq")),
read_file(os.path.join(p, "energy_performance_preference")),
read_file(os.path.join(p, "amd_pstate_prefcore_ranking")),
read_file(os.path.join(p, "boost")),
]
df = pd.concat(
[pd.DataFrame([row], columns=df.columns), df], ignore_index=True
)
cpuinfo = read_file("/proc/cpuinfo")
model = re.findall(r"model name\s+:\s+(.*)", cpuinfo)[0]
print_color(f"CPU:\t\t{model}", "💻")
df = df.sort_values(by="CPU #")
print_color(
"Per-CPU sysfs files\n%s"
% tabulate(df, headers="keys", tablefmt="psql", showindex=False),
"🔋",
)
def gather_msrs(self):
"""Gather MSR information"""
cpus = []
for device in self.context.list_devices(subsystem="cpu"):
cpu = int(re.findall(r"\d+", f"{device.sys_name}")[0])
cpus.append(cpu)
cpus.sort()
df = pd.DataFrame(
columns=[
"CPU #",
"Min Perf",
"Max Perf",
"Desired Perf",
"Energy Performance Perf",
]
)
msr_df = pd.DataFrame(
columns=[
"CPU #",
"Enable",
"Status",
"Cap 1",
"Cap 2",
"Request",
]
)
cap_df = pd.DataFrame(
columns=[
"CPU #",
"Lowest Perf",
"Nonlinear Perf",
"Nominal Perf",
"Highest Perf",
]
)
try:
for cpu in cpus:
enable = read_msr(MSR.MSR_AMD_CPPC_ENABLE, cpu)
status = read_msr(MSR.MSR_AMD_CPPC_STATUS, cpu)
cap1 = read_msr(MSR.MSR_AMD_CPPC_CAP1, cpu)
cap2 = read_msr(MSR.MSR_AMD_CPPC_CAP2, cpu)
req = read_msr(MSR.MSR_AMD_CPPC_REQ, cpu)
row = [
cpu,
amd_cppc_min_perf(req),
amd_cppc_max_perf(req),
amd_cppc_des_perf(req),
amd_cppc_epp_perf(req),
]
df = pd.concat(
[pd.DataFrame([row], columns=df.columns), df], ignore_index=True
)
row = [
cpu,
enable,
status,
hex(cap1),
hex(cap2),
hex(req),
]
msr_df = pd.concat(
[pd.DataFrame([row], columns=msr_df.columns), msr_df],
ignore_index=True,
)
row = [
cpu,
amd_cppc_cap_lowest_perf(cap1),
amd_cppc_cap_lownonlin_perf(cap1),
amd_cppc_cap_nominal_perf(cap1),
amd_cppc_cap_highest_perf(cap1),
]
cap_df = pd.concat(
[pd.DataFrame([row], columns=cap_df.columns), cap_df],
ignore_index=True,
)
except FileNotFoundError:
print_color("Unable to check MSRs: MSR kernel module not loaded", "❌")
return False
except PermissionError:
print_color("MSR checks unavailable", "🚦")
return
msr_df = msr_df.sort_values(by="CPU #")
print_color(
"CPPC MSRs\n%s"
% tabulate(msr_df, headers="keys", tablefmt="psql", showindex=False),
"🔋",
)
cap_df = cap_df.sort_values(by="CPU #")
print_color(
"MSR_AMD_CPPC_CAP1 (decoded)\n%s"
% tabulate(cap_df, headers="keys", tablefmt="psql", showindex=False),
"🔋",
)
df = df.sort_values(by="CPU #")
print_color(
"MSR_AMD_CPPC_REQ (decoded)\n%s"
% tabulate(df, headers="keys", tablefmt="psql", showindex=False),
"🔋",
)
def run(self):
"""Run the triage process"""
self.gather_kernel_info()
self.gather_amd_pstate_info()
self.gather_scheduler_info()
try:
self.gather_cpu_info()
except FileNotFoundError:
print_color("Unable to gather CPU information", "❌")
return False
self.gather_msrs()
return True
def parse_args():
"""Parse command line arguments."""
parser = argparse.ArgumentParser(
description="Collect useful information for debugging amd-pstate issues.",
epilog="Arguments are optional",
)
subparsers = parser.add_subparsers(help="Possible commands", dest="command")
triage_cmd = subparsers.add_parser("triage", help="Run amd-pstate triage")
triage_cmd.add_argument(
"--tool-debug",
action="store_true",
help="Enable tool debug logging",
)
parser.add_argument(
"--version", action="store_true", help="Show version information"
)
if len(sys.argv) == 1:
parser.print_help(sys.stderr)
sys.exit(1)
return parser.parse_args()
def main() -> None | int:
"""Main function"""
args = parse_args()
ret = False
if args.version:
print(version())
return
elif args.command == "triage":
triage = AmdPstateTriage(args.tool_debug)
ret = triage.run()
show_log_info()
if ret is False:
return 1
return