amd-debug-tools 0.2.2__py3-none-any.whl → 0.2.12__py3-none-any.whl

amd_debug/sleep_report.py

@@ -1,10 +1,10 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
 import os
 import re
 import math
 from datetime import datetime, timedelta
+import numpy as np
 from tabulate import tabulate
 from jinja2 import Environment, FileSystemLoader
 import pandas as pd
@@ -73,6 +73,8 @@ def format_percent(val):
 
 def format_timedelta(val):
     """Format seconds as a nicer format"""
+    if math.isnan(val):
+        val = 0
     return str(timedelta(seconds=val))
 
 
@@ -97,8 +99,23 @@ class SleepReport(AmdTool):
         self.debug = report_debug
         self.format = fmt
         self.failures = []
-        self.df = self.db.report_summary_dataframe(self.since, self.until)
-        self.pre_process_dataframe()
+        if since and until:
+            self.df = self.db.report_summary_dataframe(self.since, self.until)
+            self.pre_process_dataframe()
+        else:
+            self.df = pd.DataFrame(
+                columns=[
+                    "t0",
+                    "t1",
+                    "requested",
+                    "hw",
+                    "b0",
+                    "b1",
+                    "full",
+                    "wake_irq",
+                    "gpio",
+                ]
+            )
         self.battery_svg = None
         self.hwsleep_svg = None
 
@@ -136,6 +153,7 @@ class SleepReport(AmdTool):
         self.df["Duration"] = self.df["t1"].apply(format_as_seconds) - self.df[
             "t0"
         ].apply(format_as_seconds)
+        self.df["Duration"] = self.df["Duration"].replace(0, np.nan)
         self.df["Hardware Sleep"] = (self.df["hw"] / self.df["Duration"]).apply(
             parse_hw_sleep
         )
@@ -187,7 +205,8 @@ class SleepReport(AmdTool):
                 format_watts
             )
 
-    def convert_gpio_dataframe(self, content):
+    def convert_table_dataframe(self, content):
+        """Convert a table like dataframe to an HTML table"""
         header = False
         rows = []
         for line in content.split("\n"):
@@ -196,17 +215,25 @@ class SleepReport(AmdTool):
                 if header:
                     continue
                 header = True
+            line = line.strip("│")
+            line = line.replace("├─", "└─")
             if "|" in line:
                 # first column missing '|'
                 rows.append(line.replace("\t", "|"))
         columns = [row.split("|") for row in rows]
         df = pd.DataFrame(columns[1:], columns=columns[0])
-        return df.to_html(index=False, table_id="gpio")
+        return df.to_html(index=False, justify="center", col_space=30)
 
     def get_prereq_data(self):
         """Get the prereq data"""
         prereq = []
         prereq_debug = []
+        tables = [
+            "int|active",
+            "ACPI name",
+            "PCI Slot",
+            "DMI|value",
+        ]
         ts = self.db.get_last_prereq_ts()
         if not ts:
             return [], "", []
@@ -216,23 +243,24 @@ class SleepReport(AmdTool):
         if self.debug:
             for row in self.db.report_debug(t0):
                 content = row[0]
-                if self.format == "html" and "int|active" in content:
-                    content = self.convert_gpio_dataframe(content)
-                prereq_debug.append(
-                    {"data": "{message}".format(message=content.strip())}
-                )
+                if self.format == "html" and [
+                    table for table in tables if table in content
+                ]:
+                    content = self.convert_table_dataframe(content)
+                prereq_debug.append({"data": f"{content.strip()}"})
         return prereq, t0, prereq_debug
 
     def get_cycle_data(self):
         """Get the cycle data"""
         cycles = []
         debug = []
+        tables = ["Wakeup Source"]
         num = 0
         for cycle in self.df["Start Time"]:
             if self.format == "html":
                 data = ""
                 for line in self.db.report_cycle_data(cycle).split("\n"):
-                    data += "<p>{line}</p>".format(line=line)
+                    data += f"<p>{line}</p>"
                 cycles.append({"cycle_num": num, "data": data})
             else:
                 cycles.append([num, self.db.report_cycle_data(cycle)])
@@ -240,7 +268,12 @@ class SleepReport(AmdTool):
                 messages = []
                 priorities = []
                 for row in self.db.report_debug(cycle):
-                    messages.append(row[0])
+                    content = row[0]
+                    if self.format == "html" and [
+                        table for table in tables if table in content
+                    ]:
+                        content = self.convert_table_dataframe(content)
+                    messages.append(content)
                     priorities.append(get_log_priority(row[1]))
                 debug.append(
                     {"cycle_num": num, "messages": messages, "priorities": priorities}
@@ -265,58 +298,69 @@ class SleepReport(AmdTool):
             prereq, prereq_date, prereq_debug = self.get_prereq_data()
 
         # Load the cycle and/or debug data
-        cycles, debug = self.get_cycle_data()
-
-        self.post_process_dataframe()
-        failures = None
-        if self.format == "md":
-            summary = self.df.to_markdown(floatfmt=".02f")
-            cycle_data = tabulate(cycles, headers=["Cycle", "data"], tablefmt="pipe")
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="pipe",
+        if not self.df.empty:
+            cycles, debug = self.get_cycle_data()
+
+            self.post_process_dataframe()
+            failures = None
+            if self.format == "md":
+                summary = self.df.to_markdown(floatfmt=".02f")
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="pipe"
                 )
-        elif self.format == "txt":
-            summary = tabulate(self.df, headers=self.df.columns, tablefmt="fancy_grid")
-            cycle_data = tabulate(
-                cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
-            )
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="fancy_grid",
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="pipe",
+                    )
+            elif self.format == "txt":
+                summary = tabulate(
+                    self.df, headers=self.df.columns, tablefmt="fancy_grid"
+                )
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
                 )
-        elif self.format == "html":
-            summary = ""
-            row = 0
-            # we will use javascript to highlight the high values
-            for line in self.df.to_html(table_id="summary", render_links=True).split(
-                "\n"
-            ):
-                if "<tr>" in line:
-                    line = line.replace(
-                        "<tr>",
-                        '<tr class="row-low" onclick="pick_summary_cycle(%d)">' % row,
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="fancy_grid",
                     )
-                    row = row + 1
-                summary += line
-            cycle_data = cycles
-            failures = self.failures
-        # only show one cycle in stdout output even if we found more
-        else:
-            df = self.df.tail(1)
-            summary = tabulate(
-                df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
-            )
-            if cycles[-1][0] == df.index.start:
-                cycle_data = cycles[-1][-1]
+            elif self.format == "html":
+                summary = ""
+                row = 0
+                # we will use javascript to highlight the high values
+                for line in self.df.to_html(
+                    table_id="summary", render_links=True
+                ).split("\n"):
+                    if "<tr>" in line:
+                        line = line.replace(
+                            "<tr>",
+                            f'<tr class="row-low" onclick="pick_summary_cycle({row})">',
+                        )
+                        row = row + 1
+                    summary += line
+                cycle_data = cycles
+                failures = self.failures
+            # only show one cycle in stdout output even if we found more
             else:
-                cycle_data = None
-            if self.failures and self.failures[-1][0] == df.index.start:
-                failures = self.failures[-1][-1]
+                df = self.df.tail(1)
+                summary = tabulate(
+                    df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
+                )
+                if cycles[-1][0] == df.index.start:
+                    cycle_data = cycles[-1][-1]
+                else:
+                    cycle_data = None
+                if self.failures and self.failures[-1][0] == df.index.start:
+                    failures = self.failures[-1][-1]
+        else:
+            cycles = []
+            debug = []
+            cycle_data = []
+            summary = "No sleep cycles found in the database."
+            failures = None
 
         # let it burn
         context = {
@@ -333,7 +377,7 @@ class SleepReport(AmdTool):
             "failures": failures,
         }
         if self.fname:
-            with open(self.fname, "w") as f:
+            with open(self.fname, "w", encoding="utf-8") as f:
                 f.write(template.render(context))
             if "SUDO_UID" in os.environ:
                 os.chown(
@@ -345,30 +389,30 @@ class SleepReport(AmdTool):
 
     def build_battery_chart(self):
         """Build a battery chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         if "Battery Ave Rate" not in self.df.columns:
             return
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Battery Ave Rate"], color="green", label="Charge/Discharge Rate"
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Battery Delta"],
             color="grey",
             label="Battery Change",
             alpha=0.3,
         )
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Rate (Watts)")
         ax2.set_ylabel("Battery Change (%)")
@@ -385,20 +429,20 @@ class SleepReport(AmdTool):
 
     def build_hw_sleep_chart(self):
         """Build the hardware sleep chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Hardware Sleep"],
             color="red",
             label="Hardware Sleep",
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Duration"] / 60,
             color="grey",
@@ -406,9 +450,9 @@ class SleepReport(AmdTool):
             alpha=0.3,
         )
 
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Percent")
         ax2.set_yscale("log")
@@ -427,15 +471,13 @@ class SleepReport(AmdTool):
     def run(self, inc_prereq=True):
         """Run the report"""
 
-        if self.df.empty:
-            raise ValueError(f"No data found between {self.since} and {self.until}")
-
         characters = print_temporary_message("Building report, please wait...")
 
-        # Build charts in the page for html format
-        if len(self.df.index) > 1 and self.format == "html":
-            self.build_battery_chart()
-            self.build_hw_sleep_chart()
+        if not self.df.empty:
+            # Build charts in the page for html format
+            if len(self.df.index) > 1 and self.format == "html":
+                self.build_battery_chart()
+                self.build_hw_sleep_chart()
 
         # Render the template using jinja
         msg = self.build_template(inc_prereq)
@@ -445,7 +487,7 @@ class SleepReport(AmdTool):
             text = line.strip()
             if not text:
                 continue
-            for group in ["🗣️", "❌", "🚦", "🦟", "💯", "○"]:
+            for group in ["🗣️", "❌", "🚦", "🦟", "🚫", "○"]:
                 if line.startswith(group):
                     text = line.split(group)[-1]
                     color = get_group_color(group)

amd_debug/templates/html

@@ -42,12 +42,14 @@
         table,
         th,
         td {
-            border-width: 0;
+            border-width: 1;
+            border-collapse: collapse;
             table-layout: fixed;
             font-family: sans-serif;
             letter-spacing: 0.02em;
             color: #000000;
-            margin-bottom: 10px;
+            text-align: left;
+            padding: 3px;
         }
 
         .○ {

amd_debug/ttm.py

@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: MIT
+"""TTM configuration tool"""
+
+import asyncio
+import os
+import argparse
+from amd_debug.common import (
+    AmdTool,
+    bytes_to_gb,
+    gb_to_pages,
+    get_system_mem,
+    relaunch_sudo,
+    print_color,
+    reboot,
+    version,
+)
+
+TTM_PARAM_PATH = "/sys/module/ttm/parameters/pages_limit"
+MODPROBE_CONF_PATH = "/etc/modprobe.d/ttm.conf"
+# Maximum percentage of total system memory to allow for TTM
+MAX_MEMORY_PERCENTAGE = 90
+
+
+def maybe_reboot() -> bool:
+    """Prompt to reboot system"""
+    response = input("Would you like to reboot the system now? (y/n): ").strip().lower()
+    if response in ("y", "yes"):
+        return reboot()
+    return True
+
+
+class AmdTtmTool(AmdTool):
+    """Class for handling TTM page configuration"""
+
+    def __init__(self, logging):
+        log_prefix = "ttm" if logging else None
+        super().__init__(log_prefix)
+
+    def get(self) -> bool:
+        """Read current page limit"""
+        try:
+            with open(TTM_PARAM_PATH, "r", encoding="utf-8") as f:
+                pages = int(f.read().strip())
+                gb_value = bytes_to_gb(pages)
+                print_color(
+                    f"Current TTM pages limit: {pages} pages ({gb_value:.2f} GB)", "💻"
+                )
+        except FileNotFoundError:
+            print_color(f"Error: Could not find {TTM_PARAM_PATH}", "❌")
+            return False
+
+        total = get_system_mem()
+        if total > 0:
+            print_color(f"Total system memory: {total:.2f} GB", "💻")
+
+        return True
+
+    def set(self, gb_value) -> bool:
+        """Set a new page limit"""
+        relaunch_sudo()
+
+        # Check against system memory
+        total = get_system_mem()
+        if total > 0:
+            max_recommended_gb = total * MAX_MEMORY_PERCENTAGE / 100
+
+            if gb_value > total:
+                print_color(
+                    f"{gb_value:.2f} GB is greater than total system memory ({total:.2f} GB)",
+                    "❌",
+                )
+                return False
+
+            if gb_value > max_recommended_gb:
+                print_color(
+                    f"Warning: The requested value ({gb_value:.2f} GB) exceeds {MAX_MEMORY_PERCENTAGE}% of your system memory ({max_recommended_gb:.2f} GB).",
+                    "🚦",
+                )
+                response = (
+                    input(
+                        "This could cause system instability. Continue anyway? (y/n): "
+                    )
+                    .strip()
+                    .lower()
+                )
+                if response not in ("y", "yes"):
+                    print_color("Operation cancelled.", "🚦")
+                    return False
+
+        pages = gb_to_pages(gb_value)
+
+        with open(MODPROBE_CONF_PATH, "w", encoding="utf-8") as f:
+            f.write(f"options ttm pages_limit={pages}\n")
+        print_color(
+            f"Successfully set TTM pages limit to {pages} pages ({gb_value:.2f} GB)",
+            "🐧",
+        )
+        print_color(f"Configuration written to {MODPROBE_CONF_PATH}", "🐧")
+        print_color("NOTE: You need to reboot for changes to take effect.", "○")
+
+        return maybe_reboot()
+
+    def clear(self) -> bool:
+        """Clears the page limit"""
+        if not os.path.exists(MODPROBE_CONF_PATH):
+            print_color(f"{MODPROBE_CONF_PATH} doesn't exist", "❌")
+            return False
+
+        relaunch_sudo()
+
+        os.remove(MODPROBE_CONF_PATH)
+        print_color(f"Configuration {MODPROBE_CONF_PATH} removed", "🐧")
+
+        return maybe_reboot()
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Manage TTM pages limit")
+    parser.add_argument("--set", type=float, help="Set pages limit in GB")
+    parser.add_argument(
+        "--clear", action="store_true", help="Clear a previously set page limit"
+    )
+    parser.add_argument(
+        "--version", action="store_true", help="Show version information"
+    )
+    parser.add_argument(
+        "--tool-debug",
+        action="store_true",
+        help="Enable tool debug logging",
+    )
+
+    return parser.parse_args()
+
+
+def main() -> None | int:
+    """Main function"""
+
+    args = parse_args()
+    tool = AmdTtmTool(args.tool_debug)
+    ret = False
+
+    if args.version:
+        print(version())
+        return
+    elif args.set is not None:
+        if args.set <= 0:
+            print("Error: GB value must be greater than 0")
+            return 1
+        ret = tool.set(args.set)
+    elif args.clear:
+        ret = tool.clear()
+    else:
+        ret = tool.get()
+    if ret is False:
+        return 1
+    return