use sampling rate in progress bar

Author: pablogsal

Lib/profiling/sampling/live_collector.py

@@ -347,6 +347,15 @@ def draw_header_info(self, line, width, elapsed):
                 col += len(text)
         return line + 1
 
+    def format_rate_with_units(self, rate_hz):
+        """Format a rate in Hz with appropriate units (Hz, KHz, MHz)."""
+        if rate_hz >= 1_000_000:
+            return f"{rate_hz / 1_000_000:.1f}MHz"
+        elif rate_hz >= 1_000:
+            return f"{rate_hz / 1_000:.1f}KHz"
+        else:
+            return f"{rate_hz:.1f}Hz"
+
     def draw_sample_stats(self, line, width, elapsed):
         """Draw sample statistics with visual progress bar."""
         sample_rate = (
@@ -373,15 +382,29 @@ def draw_sample_stats(self, line, width, elapsed):
         col += 23
 
         # Draw sample rate bar
-        max_label = f" max: {self.collector._max_sample_rate:>7.1f}/s"
-        available_width = width - col - len(max_label) - 3
+        target_rate = MICROSECONDS_PER_SECOND / self.collector.sample_interval_usec
+
+        # Show current/target ratio with percentage
+        if sample_rate > 0 and target_rate > 0:
+            percentage = min((sample_rate / target_rate) * 100, 100)
+            current_formatted = self.format_rate_with_units(sample_rate)
+            target_formatted = self.format_rate_with_units(target_rate)
+
+            if percentage >= 99.5:  # Show 100% when very close
+                rate_label = f" {current_formatted}/{target_formatted} (100%)"
+            else:
+                rate_label = f" {current_formatted}/{target_formatted} ({percentage:>4.1f}%)"
+        else:
+            target_formatted = self.format_rate_with_units(target_rate)
+            rate_label = f" target: {target_formatted}"
+
+        available_width = width - col - len(rate_label) - 3
 
         if available_width >= MIN_BAR_WIDTH:
             bar_width = min(MAX_SAMPLE_RATE_BAR_WIDTH, available_width)
-            max_rate = max(
-                self.collector._max_sample_rate, MIN_SAMPLE_RATE_FOR_SCALING
-            )
-            normalized_rate = min(sample_rate / max_rate, 1.0)
+            # Use target rate as the reference, with a minimum for scaling
+            reference_rate = max(target_rate, MIN_SAMPLE_RATE_FOR_SCALING)
+            normalized_rate = min(sample_rate / reference_rate, 1.0)
             bar_fill = int(normalized_rate * bar_width)
 
             bar = "["
@@ -391,8 +414,8 @@ def draw_sample_stats(self, line, width, elapsed):
             self.add_str(line, col, bar, self.colors["green"])
             col += len(bar)
 
-            if col + len(max_label) < width - 1:
-                self.add_str(line, col + 1, max_label, curses.A_DIM)
+            if col + len(rate_label) < width - 1:
+                self.add_str(line, col + 1, rate_label, curses.A_DIM)
         return line + 1
 
     def draw_efficiency_bar(self, line, width):

Lib/test/test_profiling/test_live_collector.py

@@ -839,6 +839,77 @@ def test_draw_sample_stats(self):
         self.assertEqual(line, 1)
         self.assertGreater(self.collector._max_sample_rate, 0)
 
+    def test_progress_bar_uses_target_rate(self):
+        """Test that progress bar uses target rate instead of max rate."""
+        # Set up collector with specific sampling interval
+        collector = LiveStatsCollector(10000, pid=12345, display=self.mock_display)  # 10ms = 100Hz target
+        collector.start_time = time.perf_counter()
+        collector.total_samples = 500
+        collector._max_sample_rate = 150  # Higher than target to test we don't use this
+
+        colors = {"cyan": curses.A_BOLD, "green": curses.A_BOLD}
+        collector._initialize_widgets(colors)
+
+        # Clear the display buffer to capture only our progress bar content
+        self.mock_display.buffer.clear()
+
+        # Draw sample stats with a known elapsed time that gives us a specific sample rate
+        elapsed = 10.0  # 500 samples in 10 seconds = 50 samples/second
+        line = collector._header_widget.draw_sample_stats(0, 160, elapsed)
+
+        # Verify display was updated
+        self.assertEqual(line, 1)
+        self.assertGreater(len(self.mock_display.buffer), 0)
+
+        # Verify the label shows current/target format with units instead of "max"
+        found_current_target_label = False
+        found_max_label = False
+        for (line_num, col), (text, attr) in self.mock_display.buffer.items():
+            # Should show "50.0Hz/100.0Hz (50.0%)" since we're at 50% of target (50/100)
+            if "50.0Hz/100.0Hz" in text and "50.0%" in text:
+                found_current_target_label = True
+            if "max:" in text:
+                found_max_label = True
+
+        self.assertTrue(found_current_target_label, "Should display current/target rate with percentage")
+        self.assertFalse(found_max_label, "Should not display max rate label")
+
+    def test_progress_bar_different_intervals(self):
+        """Test that progress bar adapts to different sampling intervals."""
+        test_cases = [
+            (1000, "1.0KHz", "100.0Hz"),    # 1ms interval -> 1000Hz target (1.0KHz), 100Hz current
+            (5000, "200.0Hz", "100.0Hz"),   # 5ms interval -> 200Hz target, 100Hz current
+            (20000, "50.0Hz", "100.0Hz"),   # 20ms interval -> 50Hz target, 100Hz current
+            (100000, "10.0Hz", "100.0Hz"),  # 100ms interval -> 10Hz target, 100Hz current
+        ]
+
+        for interval_usec, expected_target_formatted, expected_current_formatted in test_cases:
+            with self.subTest(interval=interval_usec):
+                collector = LiveStatsCollector(interval_usec, display=MockDisplay())
+                collector.start_time = time.perf_counter()
+                collector.total_samples = 100
+
+                colors = {"cyan": curses.A_BOLD, "green": curses.A_BOLD}
+                collector._initialize_widgets(colors)
+
+                # Clear buffer
+                collector.display.buffer.clear()
+
+                # Draw with 1 second elapsed time (gives us current rate of 100Hz)
+                collector._header_widget.draw_sample_stats(0, 160, 1.0)
+
+                # Check that the current/target format appears in the display with proper units
+                found_current_target_format = False
+                for (line_num, col), (text, attr) in collector.display.buffer.items():
+                    # Looking for format like "100.0Hz/1.0KHz" or "100.0Hz/200.0Hz"
+                    expected_format = f"{expected_current_formatted}/{expected_target_formatted}"
+                    if expected_format in text and "%" in text:
+                        found_current_target_format = True
+                        break
+
+                self.assertTrue(found_current_target_format,
+                    f"Should display current/target rate format with units for {interval_usec}µs interval")
+
     def test_draw_efficiency_bar(self):
         """Test drawing efficiency bar."""
         self.collector._successful_samples = 900