Merge pull request #196 from jacek-kurlit/statup_performance

improved startup performance and refresh speed

Author: jacek-kurlit

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pik"
-version = "0.26.0"
+version = "0.26.1"
 edition = "2024"
 authors = ["Jacek Kurlit"]
 keywords = ["terminal", "process", "linux", "system", "kill"]

Cargo.toml

@@ -1,5 +1,5 @@
 Name: pik
-Version: 0.26.0
+Version: 0.26.1
 Release: 1%{?dist}
 License: MIT
 Summary: Process Interactive Kill is a tool that helps to find and kill process

pik.spec

@@ -1,12 +1,13 @@
 use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet};
+use std::str::FromStr;
 use std::time::SystemTime;
 
-use anyhow::Result;
+use anyhow::{Ok, Result};
 use itertools::Itertools;
 use listeners::Listener;
+use sysinfo::ProcessRefreshKind;
 use sysinfo::{Pid, System, Uid, Users};
-use sysinfo::{ProcessRefreshKind, RefreshKind};
 
 mod daemon;
 mod filters;
@@ -130,22 +131,41 @@ impl ProcessSearchResults {
 
 impl ProcessManager {
     pub fn new() -> Result<Self> {
-        let sys = System::new_with_specifics(
-            RefreshKind::default().with_processes(process_refresh_kind()),
-        );
-        let users = Users::new_with_refreshed_list();
-        let process_ports = refresh_ports();
-        let current_user_id = find_current_process_user(&sys)?;
+        let sys = System::new();
+        let users = Users::new();
+        let process_ports = Default::default();
         Ok(Self {
             sys,
             users,
             process_ports,
-            current_user_id,
+            current_user_id: Uid::from_str("0")?,
         })
     }
 
-    pub fn find_processes(&mut self, query: &str, ignore: &IgnoreOptions) -> ProcessSearchResults {
+    /// Initializes the process manager by refreshing system information and finding processes.
+    /// This also sets the current user id which is used to filter processes.
+    /// To be honest this method only exits so we don't try to find current user id on every search
+    /// but only once at the beginning.
+    pub fn inital_search(
+        &mut self,
+        query: &str,
+        ignore: &IgnoreOptions,
+    ) -> Result<ProcessSearchResults> {
+        self.refresh();
+        self.current_user_id = find_current_process_user(&self.sys)?;
+        Ok(self.find_processes(query, ignore))
+    }
+
+    pub fn refresh_and_find_processes(
+        &mut self,
+        query: &str,
+        ignore: &IgnoreOptions,
+    ) -> ProcessSearchResults {
         self.refresh();
+        self.find_processes(query, ignore)
+    }
+
+    fn find_processes(&mut self, query: &str, ignore: &IgnoreOptions) -> ProcessSearchResults {
         let query_filter = QueryFilter::new(query);
         let ignored_processes_filter = IgnoreProcessesFilter::new(ignore, &self.current_user_id);
 
@@ -169,15 +189,18 @@ impl ProcessManager {
         ProcessSearchResults { items }
     }
 
+    /// Refreshes the system information, including processes and their associated ports.
+    /// This method spawns a separate thread to refresh the ports, as it speeds up the overall refresh process.
     fn refresh(&mut self) {
+        let ports_refresh = std::thread::spawn(refresh_ports);
         self.sys.refresh_processes_specifics(
             sysinfo::ProcessesToUpdate::All,
             true,
             process_refresh_kind(),
         );
-        // TODO: do we really need to refresh users?
+
         self.users.refresh();
-        self.process_ports = refresh_ports();
+        self.process_ports = ports_refresh.join().unwrap_or_default();
     }
 
     fn create_process_info(&self, prc: &impl ProcessInfo, ports: Option<&String>) -> Process {
@@ -235,12 +258,12 @@ fn process_refresh_kind() -> ProcessRefreshKind {
 
 fn refresh_ports() -> HashMap<u32, String> {
     let ports = listeners::get_all()
-        //NOTE: we ignore errors comming from listeners
+        //NOTE: we ignore errors coming from listeners
         .unwrap_or_default();
     create_sorted_process_ports(ports)
 }
 
-//NOTE: we sort this so order of ports is deterministic and doesn't change durig refresh
+//NOTE: we sort this so order of ports is deterministic and doesn't change during refresh
 fn create_sorted_process_ports(ports: HashSet<Listener>) -> ProcessPorts {
     ports
         .into_iter()

src/processes.rs

@@ -54,14 +54,15 @@ fn process_loop(
         for operation in operations.unwrap() {
             match operation {
                 Operations::Search(query) => {
-                    let result = process_manager.find_processes(&query, &ignore_options);
+                    let result =
+                        process_manager.refresh_and_find_processes(&query, &ignore_options);
                     send_result(OperationResult::SearchCompleted(result), &result_sender);
                     last_query = query;
                 }
                 Operations::KillProcess(pid) => {
                     if process_manager.kill_process(pid) {
-                        let mut search_results =
-                            process_manager.find_processes(&last_query, &ignore_options);
+                        let mut search_results = process_manager
+                            .refresh_and_find_processes(&last_query, &ignore_options);
                         //NOTE: cache refresh takes time and process may reappear in list!
                         search_results.remove(pid);
                         send_result(

src/processes/daemon.rs

@@ -42,12 +42,13 @@ impl ProcessesViewComponent {
         ignore_options: IgnoreOptions,
         initial_query: String,
     ) -> Result<Self> {
-        let (ops_sender, results_receiver) = start(ProcessManager::new()?, ignore_options);
-        ops_sender.send(Operations::Search(initial_query.clone()))?;
+        let mut process_manager = ProcessManager::new()?;
+        let initial_results = process_manager.inital_search(&initial_query, &ignore_options)?;
+        let (ops_sender, results_receiver) = start(process_manager, ignore_options);
         let mut component = Self {
             ops_sender,
             results_receiver,
-            search_results: ProcessSearchResults::empty(),
+            search_results: initial_results,
             process_table_component: ProcessTableComponent::new(
                 ui_config.icons.get_icons(),
                 // cloning for sake of simplicity
@@ -62,7 +63,7 @@ impl ProcessesViewComponent {
                 ui_config.icons.get_icons().search_prompt.as_str(),
             ),
         };
-        component.search_for_processess();
+        component.update_process_table_state();
         Ok(component)
     }
 

src/tui/components/processes_view.rs

@@ -7,7 +7,9 @@ use fuzzy_matcher::{FuzzyMatcher, skim::SkimMatcherV2};
 #[test]
 fn should_find_cargo_process_by_cmd_name() {
     let mut process_manager = ProcessManager::new().unwrap();
-    let results = process_manager.find_processes("cargo", &IgnoreOptions::default());
+    let results = process_manager
+        .inital_search("cargo", &IgnoreOptions::default())
+        .unwrap();
     assert!(!results.is_empty());
     assert!(
         results
@@ -20,7 +22,9 @@ fn should_find_cargo_process_by_cmd_name() {
 #[test]
 fn should_find_cargo_process_by_cmd_path() {
     let mut process_manager = ProcessManager::new().unwrap();
-    let results = process_manager.find_processes("/cargo", &IgnoreOptions::default());
+    let results = process_manager
+        .inital_search("/cargo", &IgnoreOptions::default())
+        .unwrap();
     assert!(!results.is_empty());
     assert!(
         results
@@ -33,7 +37,9 @@ fn should_find_cargo_process_by_cmd_path() {
 #[test]
 fn should_find_cargo_process_by_name_path_or_args() {
     let mut process_manager = ProcessManager::new().unwrap();
-    let results = process_manager.find_processes("~cargo", &IgnoreOptions::default());
+    let results = process_manager
+        .inital_search("~cargo", &IgnoreOptions::default())
+        .unwrap();
     assert!(!results.is_empty());
     assert!(results.iter().all(|item| fuzzy_matches(
         item.process.cmd_path.as_ref().unwrap(),
@@ -46,7 +52,9 @@ fn should_find_cargo_process_by_name_path_or_args() {
 #[test]
 fn should_find_cargo_process_by_args() {
     let mut process_manager = ProcessManager::new().unwrap();
-    let results = process_manager.find_processes("-test", &IgnoreOptions::default());
+    let results = process_manager
+        .inital_search("-test", &IgnoreOptions::default())
+        .unwrap();
     assert!(!results.is_empty());
     assert!(
         results
@@ -64,7 +72,9 @@ fn should_find_cargo_process_by_port() {
     // NOTE: Sometimes system needs time to notice the port is in use
     thread::sleep(Duration::from_millis(250));
     let mut process_manager = ProcessManager::new().unwrap();
-    let results = process_manager.find_processes(&format!(":{}", port), &IgnoreOptions::default());
+    let results = process_manager
+        .inital_search(&format!(":{}", port), &IgnoreOptions::default())
+        .unwrap();
     assert!(!results.is_empty());
     assert!(results.iter().all(|item| {
         fuzzy_matches(
@@ -78,13 +88,17 @@ fn should_find_cargo_process_by_port() {
 #[test]
 fn should_find_cargo_process_by_pid() {
     let mut process_manager = ProcessManager::new().unwrap();
-    let results = process_manager.find_processes("cargo", &IgnoreOptions::default());
+    let results = process_manager
+        .inital_search("cargo", &IgnoreOptions::default())
+        .unwrap();
     let cargo_process_pid = results.nth(Some(0)).map(|r| r.pid).unwrap();
 
-    let restults = process_manager.find_processes(
-        &format!("!{}", cargo_process_pid),
-        &IgnoreOptions::default(),
-    );
+    let restults = process_manager
+        .inital_search(
+            &format!("!{}", cargo_process_pid),
+            &IgnoreOptions::default(),
+        )
+        .unwrap();
     assert_eq!(restults.len(), 1);
     assert_eq!(restults.nth(Some(0)).unwrap().pid, cargo_process_pid);
     assert!(results_are_sorted_by_match_type(results));
@@ -93,13 +107,17 @@ fn should_find_cargo_process_by_pid() {
 #[test]
 fn should_find_cargo_process_by_process_family() {
     let mut process_manager = ProcessManager::new().unwrap();
-    let results = process_manager.find_processes("cargo", &IgnoreOptions::default());
+    let results = process_manager
+        .inital_search("cargo", &IgnoreOptions::default())
+        .unwrap();
     let cargo_process_pid = results.nth(Some(0)).map(|r| r.pid).unwrap();
 
-    let results = process_manager.find_processes(
-        &format!("@{}", cargo_process_pid),
-        &IgnoreOptions::default(),
-    );
+    let results = process_manager
+        .inital_search(
+            &format!("@{}", cargo_process_pid),
+            &IgnoreOptions::default(),
+        )
+        .unwrap();
     assert!(!results.is_empty());
     assert!(
         results
@@ -120,7 +138,7 @@ fn should_ignore_processes_in_usr_dir() {
         paths: vec![Regex::new("/usr/*").unwrap()],
         ..Default::default()
     };
-    let results = process_manager.find_processes("", &ignore);
+    let results = process_manager.inital_search("", &ignore).unwrap();
     assert!(!results.is_empty());
     assert!(results.iter().all(|item| {
         item.process