memory tracking

Author: mangelajo

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fls"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2021"
 
 [dependencies]

src/fls/from_url.rs

@@ -84,7 +84,7 @@ pub async fn flash_from_url(
     let error_processor = tokio::spawn(process_error_messages(error_rx));
 
     // Main download loop with retry logic
-    let mut progress = ProgressTracker::new(options.newline_progress);
+    let mut progress = ProgressTracker::new(options.newline_progress, options.show_memory);
     // Set whether we're actually decompressing (not using cat for uncompressed files)
     progress.set_is_compressed(decompressor_name != "cat");
     let update_interval = Duration::from_secs_f64(options.progress_interval_secs);

src/fls/memory.rs

@@ -0,0 +1,140 @@
+#[cfg(target_os = "linux")]
+use std::fs;
+
+#[derive(Debug, Clone)]
+pub struct MemoryStats {
+    pub process_rss_mb: f64,
+    pub process_swap_mb: f64,
+    pub system_free_mb: f64,
+    pub system_total_mb: f64,
+    pub system_cached_mb: f64,
+}
+
+impl MemoryStats {
+    /// Format memory stats in a compact format for display
+    /// Example: "Mem: 1.2G/4G (proc: 250M+50Msw cache: 1.5G)"
+    pub fn format_compact(&self) -> String {
+        let system_used_mb = self.system_total_mb - self.system_free_mb - self.system_cached_mb;
+
+        format!(
+            "Mem: {}/{}  (proc: {}{}  cache: {})",
+            format_mb(system_used_mb),
+            format_mb(self.system_total_mb),
+            format_mb(self.process_rss_mb),
+            if self.process_swap_mb > 0.0 {
+                format!("+{}sw", format_mb(self.process_swap_mb))
+            } else {
+                String::new()
+            },
+            format_mb(self.system_cached_mb),
+        )
+    }
+}
+
+/// Format MB value to human-readable format (M or G)
+fn format_mb(mb: f64) -> String {
+    if mb >= 1024.0 {
+        format!("{:.1}G", mb / 1024.0)
+    } else {
+        format!("{:.0}M", mb)
+    }
+}
+
+/// Get memory statistics from the system
+/// Returns None if reading fails or not on Linux
+pub fn get_memory_stats() -> Option<MemoryStats> {
+    #[cfg(target_os = "linux")]
+    {
+        get_memory_stats_linux()
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    {
+        None
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn get_memory_stats_linux() -> Option<MemoryStats> {
+    // Read process memory from /proc/self/status
+    let (process_rss_mb, process_swap_mb) = read_process_memory()?;
+
+    // Read system memory from /proc/meminfo
+    let (system_total_mb, system_free_mb, system_cached_mb) = read_system_memory()?;
+
+    Some(MemoryStats {
+        process_rss_mb,
+        process_swap_mb,
+        system_free_mb,
+        system_total_mb,
+        system_cached_mb,
+    })
+}
+
+#[cfg(target_os = "linux")]
+fn read_process_memory() -> Option<(f64, f64)> {
+    let status = fs::read_to_string("/proc/self/status").ok()?;
+
+    let mut rss_kb = 0u64;
+    let mut swap_kb = 0u64;
+
+    for line in status.lines() {
+        if line.starts_with("VmRSS:") {
+            // VmRSS: 123456 kB
+            rss_kb = line.split_whitespace().nth(1)?.parse().ok()?;
+        } else if line.starts_with("VmSwap:") {
+            // VmSwap: 12345 kB
+            swap_kb = line.split_whitespace().nth(1)?.parse().ok()?;
+        }
+    }
+
+    let rss_mb = rss_kb as f64 / 1024.0;
+    let swap_mb = swap_kb as f64 / 1024.0;
+
+    Some((rss_mb, swap_mb))
+}
+
+#[cfg(target_os = "linux")]
+fn read_system_memory() -> Option<(f64, f64, f64)> {
+    let meminfo = fs::read_to_string("/proc/meminfo").ok()?;
+
+    let mut total_kb = 0u64;
+    let mut free_kb = 0u64;
+    let mut available_kb = 0u64;
+    let mut cached_kb = 0u64;
+    let mut buffers_kb = 0u64;
+
+    for line in meminfo.lines() {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        if parts.len() < 2 {
+            continue;
+        }
+
+        let value: u64 = parts[1].parse().ok()?;
+
+        match parts[0] {
+            "MemTotal:" => total_kb = value,
+            "MemFree:" => free_kb = value,
+            "MemAvailable:" => available_kb = value,
+            "Cached:" => cached_kb = value,
+            "Buffers:" => buffers_kb = value,
+            _ => {}
+        }
+    }
+
+    // Use MemAvailable if present (more accurate), otherwise use MemFree
+    let effective_free_kb = if available_kb > 0 {
+        available_kb
+    } else {
+        free_kb
+    };
+
+    // Cache includes buffers and cached
+    let effective_cached_kb = cached_kb + buffers_kb;
+
+    let total_mb = total_kb as f64 / 1024.0;
+    let free_mb = effective_free_kb as f64 / 1024.0;
+    let cached_mb = effective_cached_kb as f64 / 1024.0;
+
+    Some((total_mb, free_mb, cached_mb))
+}

src/fls/mod.rs

@@ -5,6 +5,7 @@ mod download_error;
 mod error_handling;
 mod from_url;
 mod http;
+mod memory;
 mod options;
 mod progress;
 

src/fls/options.rs

@@ -12,6 +12,7 @@ pub struct BlockFlashOptions {
     pub headers: Vec<(String, String)>,
     pub progress_interval_secs: f64,
     pub newline_progress: bool,
+    pub show_memory: bool,
 }
 
 impl Default for BlockFlashOptions {
@@ -28,6 +29,7 @@ impl Default for BlockFlashOptions {
             headers: Vec::new(),
             progress_interval_secs: 0.1,
             newline_progress: false,
+            show_memory: false,
         }
     }
 }

src/fls/progress.rs

@@ -1,6 +1,8 @@
 use std::io::{self, Write};
 use std::time::{Duration, Instant};
 
+use crate::fls::memory;
+
 pub struct FinalStats {
     pub mb_received: f64,
     pub mb_decompressed: f64,
@@ -34,10 +36,12 @@ pub(crate) struct ProgressTracker {
     is_compressed: bool,
     // Whether to print on new lines instead of clearing and rewriting
     newline_progress: bool,
+    // Whether to show memory statistics
+    show_memory: bool,
 }
 
 impl ProgressTracker {
-    pub(crate) fn new(newline_progress: bool) -> Self {
+    pub(crate) fn new(newline_progress: bool, show_memory: bool) -> Self {
         let now = Instant::now();
         Self {
             bytes_received: 0,
@@ -55,6 +59,7 @@ impl ProgressTracker {
             content_length: None,
             is_compressed: true,
             newline_progress,
+            show_memory,
         }
     }
 
@@ -147,17 +152,26 @@ impl ProgressTracker {
                 "Progress"
             };
 
+            // Get memory stats if enabled
+            let memory_suffix = if self.show_memory {
+                memory::get_memory_stats()
+                    .map(|stats| format!(" | {}", stats.format_compact()))
+                    .unwrap_or_default()
+            } else {
+                String::new()
+            };
+
             if self.newline_progress {
                 // Print on a new line
                 println!(
-                    "Download: {} | {}: {} | Written: {}",
-                    download_status, progress_label, decompress_status, write_status
+                    "Download: {} | {}: {} | Written: {}{}",
+                    download_status, progress_label, decompress_status, write_status, memory_suffix
                 );
             } else {
                 // Use carriage return and clear line
                 print!(
-                    "\r\x1b[KDownload: {} | {}: {} | Written: {}",
-                    download_status, progress_label, decompress_status, write_status
+                    "\r\x1b[KDownload: {} | {}: {} | Written: {}{}",
+                    download_status, progress_label, decompress_status, write_status, memory_suffix
                 );
                 io::stdout().flush()?;
             }

src/main.rs

@@ -49,6 +49,9 @@ enum Commands {
         /// Print progress on new lines instead of clearing and rewriting the same line
         #[arg(short = 'n', long)]
         newline_progress: bool,
+        /// Show memory statistics in progress display
+        #[arg(long)]
+        show_memory: bool,
     },
 }
 
@@ -70,6 +73,7 @@ async fn main() {
             headers,
             progress_interval,
             newline_progress,
+            show_memory,
         } => {
             println!("Block flash command:");
             println!("  URL: {}", url);
@@ -118,6 +122,7 @@ async fn main() {
                 headers: parsed_headers,
                 progress_interval_secs: progress_interval,
                 newline_progress,
+                show_memory,
             };
 
             match fls::flash_from_url(&url, options).await {