feat: more frequently update.

src/meta/progress.rs

@@ -13,6 +13,7 @@ pub struct ProgressTracker {
     iops: Arc<AtomicU64>,
     start_time: Instant,
     last_update: Arc<AtomicU64>,
+    last_bytes: Arc<AtomicU64>,
 }
 
 impl ProgressTracker {
@@ -38,6 +39,7 @@ impl ProgressTracker {
             iops: Arc::new(AtomicU64::new(0)),
             start_time: Instant::now(),
             last_update: Arc::new(AtomicU64::new(0)),
+            last_bytes: Arc::new(AtomicU64::new(0)),
         }
     }
 
@@ -81,10 +83,48 @@ impl ProgressTracker {
     }
 
     /// 获取字节读取回调（可 move）
+    /// 在读取过程中定期更新消息，提供更高粒度的进度反馈
     pub fn bytes_callback(&self) -> impl FnMut(u64) {
         let bytes_read = self.bytes_read.clone();
+        let last_bytes = self.last_bytes.clone();
+        let last_update = self.last_update.clone();
+        let start_time = self.start_time;
+        let progress_bar = self.progress_bar.clone();
+        let bytes_read_clone = self.bytes_read.clone();
+        let iops = self.iops.clone();
+
         move |bytes| {
             bytes_read.fetch_add(bytes, Ordering::Relaxed);
+
+            // 每读取 16MB（约4次缓冲区读取）或每 200ms 更新一次消息，提供更细粒度的反馈
+            let total_bytes = bytes_read.load(Ordering::Relaxed);
+            let last_bytes_value = last_bytes.load(Ordering::Relaxed);
+            let now = start_time.elapsed().as_millis() as u64;
+            let last_update_value = last_update.load(Ordering::Relaxed);
+
+            // 检查是否需要更新：每 16MB（缓冲区为4MB，约4次读取）或每 200ms
+            let bytes_diff = total_bytes.saturating_sub(last_bytes_value);
+            let time_diff = now.saturating_sub(last_update_value);
+            const UPDATE_BYTES_THRESHOLD: u64 = 16 * 1024 * 1024; // 16MB
+            const UPDATE_TIME_THRESHOLD: u64 = 200; // 200ms
+
+            if bytes_diff >= UPDATE_BYTES_THRESHOLD || time_diff >= UPDATE_TIME_THRESHOLD {
+                if let Some(pb) = &progress_bar {
+                    let elapsed = start_time.elapsed().as_secs_f64();
+                    let total_bytes = bytes_read_clone.load(Ordering::Relaxed);
+                    let total_ops = iops.load(Ordering::Relaxed);
+
+                    if total_bytes > 0 && elapsed > 0.0 {
+                        let speed_bytes_per_sec = total_bytes as f64 / elapsed;
+                        let speed_str = friendly_size(speed_bytes_per_sec as u64);
+                        let iops_value = total_ops as f64 / elapsed;
+                        pb.set_message(format!("IO速度: {}/s | IOPS: {:.0}", speed_str, iops_value));
+                    }
+                }
+
+                last_bytes.store(total_bytes, Ordering::Relaxed);
+                last_update.store(now, Ordering::Relaxed);
+            }
         }
     }