tui, gui, smi: UiArgs

add "--hide-fdinfo" option for TUI mode

Resolved: #108

crates/amdgpu_top_gui/src/lib.rs

@@ -18,7 +18,9 @@ use libamdgpu_top::{
     },
     AppDeviceInfo,
     DevicePath,
+    GuiWgpuBackend,
     Sampling,
+    UiArgs,
     PCI,
 };
 
@@ -61,22 +63,20 @@ static PCI_BUS_ID: LazyLock<egui::Id> = LazyLock::new(|| {
     egui::Id::new("pci_bus")
 });
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum GuiWgpuBackend {
-    Gl,
-    Vulkan,
-}
-
 pub fn run(
     app_name: &str,
     title_with_version: &str,
-    device_path_list: &[DevicePath],
-    selected_pci_bus: PCI::BUS_INFO,
-    update_process_index_interval: u64,
-    no_pc: bool,
-    is_dark_mode: Option<bool>,
-    gui_wgpu_backend: GuiWgpuBackend,
+    UiArgs {
+        selected_device_path,
+        device_path_list,
+        update_process_index,
+        no_pc,
+        is_dark_mode,
+        gui_wgpu_backend,
+        ..
+    }: UiArgs,
 ) {
+    let selected_pci_bus = selected_device_path.pci;
     let localizer = localizer();
     let requested_languages = DesktopLanguageRequester::requested_languages();
 
@@ -85,7 +85,7 @@ pub fn run(
     }
 
     let (mut vec_app, mut suspended_devices) = AppAmdgpuTop::create_app_and_suspended_list(
-        device_path_list,
+        &device_path_list,
         &Default::default(),
     );
 
@@ -104,7 +104,7 @@ pub fn run(
             device_paths.push(xdna_device_path.clone());
         }
 
-        stat::spawn_update_index_thread(device_paths, update_process_index_interval);
+        stat::spawn_update_index_thread(device_paths, update_process_index);
     }
 
     let mut vec_data: Vec<_> = vec_app.iter().map(GuiAppData::new).collect();

crates/amdgpu_top_tui/src/lib.rs

@@ -3,7 +3,7 @@ use cursive::view::{Nameable, Scrollable};
 use cursive::{event::Key, menu, traits::With};
 use cursive::theme::{BorderStyle, Theme, Palette};
 
-use libamdgpu_top::{app::AppAmdgpuTop, DevicePath, Sampling};
+use libamdgpu_top::{app::AppAmdgpuTop, DevicePath, Sampling, UiArgs};
 use libamdgpu_top::stat::{self, FdInfoSortType, PCType};
 
 mod view;
@@ -56,17 +56,22 @@ type Opt = Arc<Mutex<ToggleOptions>>;
 
 pub fn run(
     title: &str,
-    selected_device_path: DevicePath,
-    device_path_list: &[DevicePath],
-    interval: u64,
-    no_pc: bool,
-    is_dark_mode: bool,
+    UiArgs {
+        selected_device_path,
+        device_path_list,
+        update_process_index,
+        no_pc,
+        is_dark_mode,
+        hide_fdinfo,
+        ..
+    }: UiArgs,
 ) {
+    let is_dark_mode = is_dark_mode == Some(true); // The default theme for TUI is light.
     let title = title.to_string();
-    let mut toggle_opt = ToggleOptions { is_dark_mode, ..Default::default() };
+    let mut toggle_opt = ToggleOptions { is_dark_mode, fdinfo: !hide_fdinfo, ..Default::default() };
 
     let (vec_app, suspended_devices) = AppAmdgpuTop::create_app_and_suspended_list(
-        device_path_list,
+        &device_path_list,
         &Default::default(),
     );
     let mut vec_app: Vec<_> = vec_app
@@ -88,7 +93,7 @@ pub fn run(
     toggle_opt.indexes = vec_app.iter().map(|app| app.index).collect();
 
     {
-        let mut device_paths: Vec<DevicePath> = device_path_list.to_vec();
+        let mut device_paths: Vec<DevicePath> = device_path_list;
 
         if let Some(xdna_device_path) = vec_app
             .iter()
@@ -97,7 +102,7 @@ pub fn run(
             device_paths.push(xdna_device_path.clone());
         }
 
-        stat::spawn_update_index_thread(device_paths, interval);
+        stat::spawn_update_index_thread(device_paths, update_process_index);
     }
 
     let mut siv = cursive::default();

crates/amdgpu_top_tui/src/smi.rs

@@ -4,7 +4,7 @@ use cursive::view::{Nameable, Scrollable};
 use cursive::views::{HideableView, LinearLayout, TextContent, TextView, Panel};
 
 use libamdgpu_top::AMDGPU::MetricsInfo;
-use libamdgpu_top::{stat, DevicePath, Sampling};
+use libamdgpu_top::{stat, DevicePath, Sampling, UiArgs};
 use stat::{GfxoffMonitor, GfxoffStatus, FdInfoSortType};
 
 use crate::{Text, AppTextView};
@@ -271,10 +271,17 @@ impl SuspendedSmiApp {
     }
 }
 
-pub fn run_smi(title: &str, device_path_list: &[DevicePath], interval: u64) {
+pub fn run_smi(
+    title: &str,
+    UiArgs {
+        device_path_list,
+        update_process_index,
+        ..
+    }: UiArgs,
+) {
     let sample = Sampling::low();
     let (vec_app, suspended) = AppAmdgpuTop::create_app_and_suspended_list(
-        device_path_list,
+        &device_path_list,
         &Default::default(),
     );
     let mut vec_app: Vec<_> = vec_app
@@ -331,7 +338,7 @@ pub fn run_smi(title: &str, device_path_list: &[DevicePath], interval: u64) {
 
     {
         let device_paths: Vec<DevicePath> = device_path_list.to_vec();
-        stat::spawn_update_index_thread(device_paths, interval);
+        stat::spawn_update_index_thread(device_paths, update_process_index);
     }
 
     siv.add_global_callback('q', cursive::Cursive::quit);

crates/libamdgpu_top/src/lib.rs

@@ -24,6 +24,23 @@ pub use drm_mode::*;
 mod ppfeaturemask;
 pub use ppfeaturemask::*;
 
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum GuiWgpuBackend {
+    Gl,
+    Vulkan,
+}
+
+#[derive(Debug, Clone)]
+pub struct UiArgs {
+    pub selected_device_path: DevicePath,
+    pub device_path_list: Vec<DevicePath>,
+    pub update_process_index: u64,
+    pub no_pc: bool,
+    pub is_dark_mode: Option<bool>, // TUI, GUI
+    pub hide_fdinfo: bool, // TUI
+    pub gui_wgpu_backend: GuiWgpuBackend,
+}
+
 pub struct Sampling {
     pub count: usize,
     pub delay: Duration,

docs/amdgpu_top.1

@@ -122,6 +122,10 @@ Set to the dark mode.
 Set to the light mode.
 (TUI/GUI)
 .TP
+\f[B]--hide-fdinfo\f[R]
+Hide fdinfo panel and launch.
+(TUI)
+.TP
 \f[B]--gl\f[R], \f[B]--opengl\f[R]
 Use OpenGL API to the GUI backend.
 .TP

docs/man.amdgpu_top.md

@@ -83,6 +83,9 @@ The tool displays information gathered from performance counters (GRBM, GRBM2),
 **\-\-light**, **\-\-light-mode**
 :   Set to the light mode. (TUI/GUI)
 
+**\-\-hide-fdinfo**
+:   Hide fdinfo panel and launch. (TUI)
+
 **\-\-gl**, **\-\-opengl**
 :   Use OpenGL API to the GUI backend.
 

src/args.rs

@@ -1,6 +1,4 @@
-use libamdgpu_top::PCI;
-#[cfg(feature = "gui")]
-use amdgpu_top_gui::GuiWgpuBackend;
+use libamdgpu_top::{GuiWgpuBackend, PCI};
 
 pub struct MainOpt {
     pub instance: Option<usize>, // index
@@ -16,7 +14,7 @@ pub struct MainOpt {
     pub no_pc: bool,
     pub is_dark_mode: Option<bool>,
     pub decode_gpu_metrics: Option<String>,
-    #[cfg(feature = "gui")]
+    pub hide_fdinfo: bool,
     pub wgpu_backend: GuiWgpuBackend,
 }
 
@@ -36,7 +34,7 @@ impl Default for MainOpt {
             no_pc: false,
             is_dark_mode: None,
             decode_gpu_metrics: None,
-            #[cfg(feature = "gui")]
+            hide_fdinfo: false,
             wgpu_backend: GuiWgpuBackend::Gl,
         }
     }
@@ -120,6 +118,8 @@ const HELP_MSG: &str = concat!(
     "       Set to the dark mode. (TUI/GUI)\n",
     "   --light, --light-mode\n",
     "       Set to the light mode. (TUI/GUI)\n",
+    "   --hide-fdinfo\n",
+    "       Hide fdinfo panel and launch. (TUI)\n",
     "   --gl, --opengl\n",
     "       Use OpenGL API to the GUI backend.\n",
     "   --vk, --vulkan\n",
@@ -343,9 +343,8 @@ impl MainOpt {
                 "--light" | "--light-mode" => {
                     opt.is_dark_mode = Some(false);
                 },
-                #[cfg(feature = "gui")]
+                "--hide-fdinfo" => opt.hide_fdinfo = true,
                 "--gl" | "--opengl" => opt.wgpu_backend = GuiWgpuBackend::Gl,
-                #[cfg(feature = "gui")]
                 "--vk" | "--vulkan" => opt.wgpu_backend = GuiWgpuBackend::Vulkan,
                 "--xdna" => {
                     opt.dump_mode = DumpMode::Xdna;

src/main.rs

@@ -1,4 +1,4 @@
-use libamdgpu_top::DevicePath;
+use libamdgpu_top::{DevicePath, UiArgs};
 
 #[cfg(feature = "gui")]
 const APP_NAME: &str = env!("CARGO_PKG_NAME");
@@ -133,36 +133,30 @@ fn main() {
         },
     }
 
+    let ui_args = UiArgs {
+        selected_device_path: device_path,
+        device_path_list,
+        update_process_index: main_opt.update_process_index,
+        no_pc: main_opt.no_pc,
+        is_dark_mode: main_opt.is_dark_mode,
+        hide_fdinfo: main_opt.hide_fdinfo,
+        gui_wgpu_backend: main_opt.wgpu_backend,
+    };
+
     match main_opt.app_mode {
         AppMode::TUI => {
             #[cfg(feature = "tui")]
             {
-                amdgpu_top_tui::run(
-                    TITLE,
-                    device_path,
-                    &device_path_list,
-                    main_opt.update_process_index,
-                    main_opt.no_pc,
-                    main_opt.is_dark_mode == Some(true), // The default theme for TUI is light.
-                )
+                amdgpu_top_tui::run(TITLE, ui_args)
             }
             #[cfg(not(feature = "tui"))]
             {
                 eprintln!("\"tui\" feature is not enabled for this build.");
-                dump_info::dump(&device_path, main_opt.opt_dump_mode);
+                dump_info::dump(&ui_args.device_path, main_opt.opt_dump_mode);
             }
         },
         #[cfg(feature = "gui")]
-        AppMode::GUI => amdgpu_top_gui::run(
-            APP_NAME,
-            TITLE,
-            &device_path_list,
-            device_path.pci,
-            main_opt.update_process_index,
-            main_opt.no_pc,
-            main_opt.is_dark_mode,
-            main_opt.wgpu_backend,
-        ),
+        AppMode::GUI => amdgpu_top_gui::run(APP_NAME, TITLE, ui_args),
         #[cfg(feature = "json")]
         AppMode::JSON => unreachable!(),
         #[cfg(feature = "json")]
@@ -189,21 +183,17 @@ fn main() {
 
             let mut j = amdgpu_top_json::JsonApp::new(
                 TITLE,
-                &device_path_list,
+                &ui_args.device_path_list,
                 main_opt.refresh_period,
-                main_opt.update_process_index,
+                ui_args.update_process_index,
                 main_opt.json_iterations,
-                main_opt.no_pc,
+                ui_args.no_pc,
             );
 
             j.run_fifo(path);
         },
         #[cfg(feature = "tui")]
-        AppMode::SMI => amdgpu_top_tui::run_smi(
-            TITLE,
-            &device_path_list,
-            main_opt.update_process_index,
-        ),
+        AppMode::SMI => amdgpu_top_tui::run_smi(TITLE, ui_args),
     }
 }