guidellm 0.4.0a18__py3-none-any.whl → 0.4.0a155__py3-none-any.whl

guidellm/benchmark/progress.py

@@ -1,8 +1,25 @@
-import math
-import time
+"""
+Benchmark progress tracking and console display abstractions.
+
+Provides progress tracking interfaces and implementations for monitoring benchmark
+execution, displaying real-time statistics, and managing UI updates during
+generative benchmarking operations.
+
+Classes:
+    BenchmarkerProgress: Abstract base for benchmark progress tracking.
+    BenchmarkerProgressGroup: Composite progress handler for multiple instances.
+    GenerativeConsoleBenchmarkerProgress: Console-based progress display.
+
+Type Variables:
+    BenchmarkT: Generic benchmark object type.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Generic, Optional, TypeVar, Union
+from typing import Any, Generic, Literal
 
 from rich.console import Group
 from rich.live import Live
@@ -10,7 +27,6 @@ from rich.panel import Panel
 from rich.progress import (
     BarColumn,
     Progress,
-    ProgressColumn,
     SpinnerColumn,
     TaskID,
     TaskProgressColumn,
@@ -19,145 +35,392 @@ from rich.progress import (
     TimeRemainingColumn,
 )
 
-from guidellm.benchmark.aggregator import (
-    BenchmarkAggregator,
-    GenerativeBenchmarkAggregator,
+from guidellm.benchmark.profile import Profile
+from guidellm.benchmark.schemas import (
+    BenchmarkT,
+    EstimatedBenchmarkState,
+    GenerativeBenchmark,
 )
-from guidellm.benchmark.benchmark import Benchmark, GenerativeBenchmark
-from guidellm.benchmark.benchmarker import BenchmarkerResult
-from guidellm.scheduler import (
-    SchedulingStrategy,
-    StrategyType,
-    strategy_display_str,
-)
-from guidellm.utils import Colors
+from guidellm.scheduler import SchedulerState, SchedulingStrategy, StrategyType
+from guidellm.utils import Colors, format_value_display
 
-__all__ = [
-    "BenchmarkerProgressDisplay",
-    "BenchmarkerTaskProgressState",
-    "GenerativeTextBenchmarkerProgressDisplay",
-    "GenerativeTextBenchmarkerTaskProgressState",
-]
+__all__ = ["BenchmarkerProgress", "GenerativeConsoleBenchmarkerProgress"]
 
 
-@dataclass
-class BenchmarkerTaskProgressState:
-    display_scheduler_stats: bool
-
-    task_id: TaskID
-    strategy: Union[StrategyType, SchedulingStrategy]
-    started: bool = False
-    compiling: bool = False
-    ended: bool = False
-
-    start_time: Optional[float] = None
-    max_number: Optional[float] = None
-    max_duration: Optional[float] = None
-    in_warmup: bool = False
-    in_cooldown: bool = False
-
-    requests_rate: float = 0
-    request_latency: float = 0
-    requests_processing: float = 0
-    requests_successful: float = 0
-    requests_incomplete: float = 0
-    requests_errored: float = 0
+class BenchmarkerProgress(Generic[BenchmarkT], ABC):
+    """
+    Abstract base class for tracking and displaying benchmark progress.
+
+    Provides lifecycle hooks for monitoring benchmark execution stages including
+    initialization, start, updates, completion, and finalization. Supports
+    enable/disable functionality for conditional progress tracking.
+    """
+
+    def __init__(self):
+        """
+        Initialize progress tracker.
+
+        :param enabled: Whether to enable progress tracking and display.
+        """
+        self.profile: Profile = None
+        self.current_strategy: SchedulingStrategy = None
+
+    @abstractmethod
+    async def on_initialize(self, profile: Profile):
+        """
+        Initialize progress tracking for benchmark profile.
+
+        :param profile: Benchmark profile configuration.
+        """
+
+    @abstractmethod
+    async def on_benchmark_start(self, strategy: SchedulingStrategy):
+        """
+        Handle start of new benchmark strategy execution.
+
+        :param strategy: Scheduling strategy being executed.
+        """
+
+    @abstractmethod
+    async def on_benchmark_update(
+        self, estimated_state: EstimatedBenchmarkState, scheduler_state: SchedulerState
+    ):
+        """
+        Handle benchmark execution progress update.
 
-    worker_overheads_time_ms: float = 0.0
-    backend_overheads_time_ms: float = 0.0
-    requests_sleep_time_ms: float = 0.0
-    requests_targeted_start_time_delay_ms: float = 0.0
+        :param estimated_state: Current benchmark metrics and statistics.
+        :param scheduler_state: Current scheduler execution state.
+        """
+
+    @abstractmethod
+    async def on_benchmark_complete(self, benchmark: BenchmarkT):
+        """
+        Handle completion of benchmark strategy execution.
+
+        :param benchmark: Completed benchmark results.
+        """
+
+    @abstractmethod
+    async def on_finalize(self):
+        """Finalize progress tracking and cleanup resources."""
+
+
+class GenerativeConsoleBenchmarkerProgress(
+    BenchmarkerProgress[GenerativeBenchmark], Live
+):
+    """
+    Console-based progress display for generative benchmarks.
+
+    Provides real-time visual progress tracking using Rich library components,
+    displaying benchmark execution statistics, timing information, and progress
+    bars in a structured console interface.
+    """
+
+    def __init__(self, display_scheduler_stats: bool = False):
+        """
+        Initialize console progress display.
+
+        :param enabled: Whether to enable progress tracking and display.
+        :param display_scheduler_stats: Whether to display scheduler statistics.
+        """
+        BenchmarkerProgress.__init__(self)
+        Live.__init__(
+            self,
+            refresh_per_second=4,
+            auto_refresh=True,
+            redirect_stdout=True,
+            redirect_stderr=True,
+        )
+        self.display_scheduler_stats: bool = display_scheduler_stats
+        self.run_progress: Progress = None
+        self.run_progress_task: TaskID = None
+        self.tasks_progress: _GenerativeProgressTasks = None
+
+    async def on_initialize(self, profile: Profile):
+        """
+        Initialize console display components and start rendering.
+
+        :param profile: Benchmark profile configuration.
+        """
+        self.tasks_progress = _GenerativeProgressTasks(
+            profile=profile, display_scheduler_stats=self.display_scheduler_stats
+        )
+        self.run_progress = Progress(
+            TextColumn("Generating...", style=f"italic {Colors.progress}"),
+            BarColumn(
+                bar_width=None,
+                complete_style=Colors.progress,
+                finished_style=Colors.success,
+            ),
+            TextColumn(
+                "({task.fields[completed_benchmarks]}/{task.fields[total_benchmarks]})",
+                style=Colors.progress,
+            ),
+            TextColumn("["),
+            TimeElapsedColumn(),
+            TextColumn("<"),
+            TimeRemainingColumn(),
+            TextColumn("]"),
+        )
+        self.run_progress_task = self.run_progress.add_task("")
+        self._sync_run_progress()
+        self.update(
+            Group(
+                Panel(
+                    self.tasks_progress,
+                    title="Benchmarks",
+                    title_align="left",
+                    expand=True,
+                ),
+                self.run_progress,
+            )
+        )
+        self.start()
+
+    async def on_benchmark_start(self, strategy: SchedulingStrategy):
+        """
+        Update display for new benchmark strategy start.
+
+        :param strategy: Scheduling strategy being executed.
+        """
+        self.tasks_progress.start_benchmark(strategy)
+        self._sync_run_progress()
+
+    async def on_benchmark_update(
+        self,
+        aggregator_update: EstimatedBenchmarkState | None,
+        scheduler_state: SchedulerState,
+    ):
+        """
+        Update display with current benchmark progress.
+
+        :param aggregator_update: Current benchmark metrics and statistics.
+        :param scheduler_state: Current scheduler execution state.
+        """
+        self.tasks_progress.update_benchmark(aggregator_update, scheduler_state)
+        self._sync_run_progress()
+
+    async def on_benchmark_complete(self, benchmark: GenerativeBenchmark):
+        """
+        Update display for completed benchmark.
+
+        :param benchmark: Completed benchmark results.
+        """
+        self.tasks_progress.complete_benchmark(benchmark)
+        self._sync_run_progress()
+
+    async def on_finalize(self):
+        """Stop display rendering and cleanup resources."""
+        self.tasks_progress.finalize()
+        self._sync_run_progress()
+        self.run_progress.stop_task(self.run_progress_task)
+        self.stop()
+        self.run_progress = None
+        self.run_progress_task = None
+        self.tasks_progress = None
+
+    def _sync_run_progress(self):
+        """Synchronize overall progress display with task progress."""
+        self.run_progress.update(
+            self.run_progress_task,
+            total=self.tasks_progress.steps_total,
+            completed=self.tasks_progress.steps_progress,
+            completed_benchmarks=self.tasks_progress.tasks_progress,
+            total_benchmarks=self.tasks_progress.tasks_total,
+        )
+
+
+# Scaling factor for progress calculations to provide granular progress updates
+_PROGRESS_SCALE = 1000
+
+
+class _GenerativeProgressTasks(Progress):
+    def __init__(self, profile: Profile, display_scheduler_stats: bool):
+        self.profile: Profile = profile
+        self.display_scheduler_stats: bool = display_scheduler_stats
+        self.benchmark_task_states: list[_GenerativeProgressTaskState] = []
+        self.current_index: int = -1
+
+        summary_text = "{task.fields[requests_summary]}\n{task.fields[tokens_summary]}"
+        if self.display_scheduler_stats:
+            summary_text += "\n{task.fields[scheduler_stats]}"
+        super().__init__(
+            TextColumn("[{task.fields[start_time]}]"),
+            SpinnerColumn(style=Colors.progress),
+            TaskProgressColumn(style=Colors.progress),
+            TextColumn("{task.description}"),
+            TextColumn("({task.fields[progress_status]})"),
+            TextColumn(" "),
+            TextColumn(summary_text),
+        )
+
+        for strategy_type in profile.strategy_types:
+            task_state = _GenerativeProgressTaskState(
+                strategy_type=strategy_type,
+            )
+            task_id = self.add_task(**task_state.current)
+            task_state.task_id = task_id
+            self.benchmark_task_states.append(task_state)
 
     @property
-    def description(self) -> str:
-        return strategy_display_str(self.strategy)
+    def tasks_total(self) -> int:
+        return len(self.benchmark_task_states)
 
     @property
-    def total(self) -> Optional[float]:
-        if self.max_number is None and self.max_duration is None:
-            return None
+    def tasks_progress(self) -> int:
+        return self.current_index + 1
 
-        return 1000
+    @property
+    def steps_total(self) -> int:
+        return _PROGRESS_SCALE * len(self.benchmark_task_states)
 
     @property
-    def completed(self) -> int:
-        if self.ended:
-            return 1000
+    def steps_progress(self) -> int:
+        progress_current_task = (
+            self.benchmark_task_states[self.current_index].progress
+            if self.current_index < len(self.benchmark_task_states)
+            else 0
+        )
+        progress_total = self.current_index + (progress_current_task or 0)
 
-        if self.max_number is None and self.max_duration is None:
-            return 0
+        return progress_total * _PROGRESS_SCALE
+
+    def start_benchmark(self, strategy: SchedulingStrategy):
+        self.current_index += 1
+        if self.current_index >= len(self.benchmark_task_states):
+            # New task past initially estimated, append it to the end
+            task_state = _GenerativeProgressTaskState(strategy_type=strategy.type_)
+            task_id = self.add_task(**task_state.current)
+            task_state.task_id = task_id
+            self.benchmark_task_states.append(task_state)
 
-        number = self.requests_successful + self.requests_errored
-        number_percent = (
-            number / float(self.max_number) * 1000 if self.max_number else -math.inf
+        self.benchmark_task_states[self.current_index].start(strategy)
+        self.update(
+            self.benchmark_task_states[self.current_index].task_id,
+            start=True,
+            **self.benchmark_task_states[self.current_index].current,
         )
-        duration_percent = (
-            (time.time() - self.start_time) / self.max_duration * 1000
-            if self.max_duration and self.start_time
-            else -math.inf
+
+    def update_benchmark(
+        self,
+        aggregator_update: EstimatedBenchmarkState,
+        scheduler_state: SchedulerState,
+    ):
+        self.benchmark_task_states[self.current_index].update(
+            aggregator_update, scheduler_state
+        )
+        self.update(
+            self.benchmark_task_states[self.current_index].task_id,
+            **self.benchmark_task_states[self.current_index].current,
+        )
+
+    def complete_benchmark(self, benchmark: GenerativeBenchmark):
+        self.benchmark_task_states[self.current_index].complete(benchmark)
+        self.update(
+            self.benchmark_task_states[self.current_index].task_id,
+            **self.benchmark_task_states[self.current_index].current,
         )
 
-        return min(int(max(number_percent, duration_percent)), 1000)
+    def finalize(self):
+        self.stop()
+
+
+@dataclass
+class _GenerativeProgressTaskState:
+    strategy_type: StrategyType
+    task_id: TaskID = None
+    strategy: SchedulingStrategy | None = None
+    benchmark_status: Literal[
+        "pending", "in_warmup", "in_progress", "in_cooldown", "completed"
+    ] = "pending"
+    progress: float | None = None
+    start_time: float = -1.0
+    successful_requests: int = 0
+    cancelled_requests: int = 0
+    errored_requests: int = 0
+    request_concurrency: int = 0
+    requests_per_second: float = 0
+    request_latency: float = 0
+    output_tokens: int = 0
+    output_tokens_rate: float = 0
+    prompt_tokens: int = 0
+    total_tokens_rate: float = 0
+    time_to_first_token: float = 0
+    inter_token_latency: float = 0
+    queued_time: float = 0
+    request_targeted_start_delay: float = 0
+    scheduler_overheads_time: float = 0
 
     @property
-    def fields(self) -> dict[str, str]:
-        fields = {
+    def current(self) -> dict[str, Any]:
+        return {
             "start_time": self.formatted_start_time,
+            "description": str(self.strategy or self.strategy_type),
             "progress_status": self.formatted_progress_status,
             "requests_summary": self.formatted_requests_summary,
+            "tokens_summary": self.formatted_tokens_summary,
+            "scheduler_stats": self.formatted_scheduler_stats,
+            "completed": self.completed,
+            "total": self.total,
         }
 
-        if self.display_scheduler_stats:
-            fields["scheduler_stats"] = self.formatted_scheduler_stats
+    @property
+    def completed(self) -> float:
+        if self.benchmark_status == "pending":
+            return 0
+
+        if self.benchmark_status == "completed":
+            return _PROGRESS_SCALE
 
-        return fields
+        return self.progress * _PROGRESS_SCALE if self.progress is not None else None
+
+    @property
+    def total(self) -> float:
+        return _PROGRESS_SCALE
 
     @property
     def formatted_start_time(self) -> str:
-        if self.start_time is None:
+        if self.start_time < 0.0:
             return "--:--:--"
 
         return datetime.fromtimestamp(self.start_time).strftime("%H:%M:%S")
 
     @property
     def formatted_progress_status(self) -> str:
-        if self.ended:
-            status = "complete"
-            color = Colors.SUCCESS
-        elif self.compiling:
-            status = "compiling"
-            color = Colors.PROGRESS
-        elif self.started and self.in_warmup:
+        if self.benchmark_status == "in_warmup":
             status = "warmup"
-            color = Colors.PROGRESS
-        elif self.started and self.in_cooldown:
-            status = "cooldown"
-            color = Colors.PROGRESS
-        elif self.started:
+            color = Colors.progress
+        elif self.benchmark_status == "in_progress":
             status = "running"
-            color = Colors.PROGRESS
+            color = Colors.progress
+        elif self.benchmark_status == "in_cooldown":
+            status = "cooldown"
+            color = Colors.progress
+        elif self.benchmark_status == "completed":
+            status = "complete"
+            color = Colors.success
         else:
             status = "pending"
-            color = Colors.INFO
+            color = Colors.info
 
         return f"[{color}]{status.ljust(8)}[/{color}]"
 
     @property
     def formatted_requests_summary(self) -> str:
-        if not self.started:
+        if self.benchmark_status == "pending":
             return " "
 
         return (
-            f"[{Colors.INFO}]Req:[/{Colors.INFO}] "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.requests_rate,
+            f"[{Colors.info}]Req:[/{Colors.info}] "
+            + format_value_display(
+                value=self.requests_per_second,
                 label="req/s",
                 total_characters=12,
                 digits_places=4,
                 decimal_places=1,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
+            + format_value_display(
                 value=self.request_latency,
                 label="Lat",
                 units="s",
@@ -166,32 +429,32 @@ class BenchmarkerTaskProgressState:
                 decimal_places=2,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.requests_processing,
+            + format_value_display(
+                value=self.request_concurrency,
                 label="Conc",
                 total_characters=12,
                 digits_places=4,
                 decimal_places=1,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.requests_successful,
+            + format_value_display(
+                value=self.successful_requests,
                 label="Comp",
                 total_characters=12,
                 digits_places=5,
                 decimal_places=0,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.requests_incomplete,
+            + format_value_display(
+                value=self.cancelled_requests,
                 label="Inc",
                 total_characters=12,
                 digits_places=5,
                 decimal_places=0,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.requests_errored,
+            + format_value_display(
+                value=self.errored_requests,
                 label="Err",
                 total_characters=12,
                 digits_places=5,
@@ -199,101 +462,14 @@ class BenchmarkerTaskProgressState:
             )
         )
 
-    @property
-    def formatted_scheduler_stats(self) -> str:
-        if not self.started:
-            return " "
-
-        return (
-            f"[{Colors.INFO}]Sys:[/{Colors.INFO}] "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.worker_overheads_time_ms,
-                label="Work OH",
-                units="ms",
-                total_characters=18,
-                digits_places=3,
-                decimal_places=1,
-            )
-            + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.backend_overheads_time_ms,
-                label="Back OH",
-                units="ms",
-                total_characters=18,
-                digits_places=3,
-                decimal_places=1,
-            )
-            + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.requests_sleep_time_ms,
-                label="Req Sleep",
-                units="ms",
-                total_characters=18,
-                digits_places=5,
-                decimal_places=0,
-            )
-            + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.requests_targeted_start_time_delay_ms,
-                label="Start Del",
-                units="ms",
-                total_characters=18,
-                digits_places=5,
-                decimal_places=0,
-            )
-        )
-
-    @staticmethod
-    def format_progress_display(
-        value: float,
-        label: str,
-        units: str = "",
-        total_characters: Optional[int] = None,
-        digits_places: Optional[int] = None,
-        decimal_places: Optional[int] = None,
-    ) -> str:
-        if decimal_places is None and digits_places is None:
-            formatted_number = f"{value}:.0f"
-        elif digits_places is None:
-            formatted_number = f"{value:.{decimal_places}f}"
-        elif decimal_places is None:
-            formatted_number = f"{value:>{digits_places}f}"
-        else:
-            formatted_number = f"{value:>{digits_places}.{decimal_places}f}"
-
-        result = f"{formatted_number}{units} [{Colors.INFO}]{label}[/{Colors.INFO}]"
-
-        if total_characters is not None:
-            total_characters += len(Colors.INFO) * 2 + 5
-
-            if len(result) < total_characters:
-                result = result.rjust(total_characters)
-
-        return result
-
-
-class GenerativeTextBenchmarkerTaskProgressState(BenchmarkerTaskProgressState):
-    output_tokens: float = 0
-    prompt_tokens: float = 0
-    output_tokens_rate: float = 0
-    total_tokens_rate: float = 0
-    tokens_ttft: float = 0
-    tokens_itl: float = 0
-
-    @property
-    def fields(self) -> dict[str, str]:
-        fields = super().fields
-        fields["tokens_summary"] = self.formatted_tokens_summary
-        return fields
-
     @property
     def formatted_tokens_summary(self) -> str:
-        if not self.started:
+        if self.benchmark_status == "pending":
             return " "
 
         return (
-            f"[{Colors.INFO}]Tok:[/{Colors.INFO}] "
-            + BenchmarkerTaskProgressState.format_progress_display(
+            f"[{Colors.info}]Tok:[/{Colors.info}] "
+            + format_value_display(
                 value=self.output_tokens_rate,
                 label="gen/s",
                 total_characters=12,
@@ -301,7 +477,7 @@ class GenerativeTextBenchmarkerTaskProgressState(BenchmarkerTaskProgressState):
                 decimal_places=1,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
+            + format_value_display(
                 value=self.total_tokens_rate,
                 label="tot/s",
                 total_characters=12,
@@ -309,8 +485,8 @@ class GenerativeTextBenchmarkerTaskProgressState(BenchmarkerTaskProgressState):
                 decimal_places=1,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.tokens_ttft,
+            + format_value_display(
+                value=self.time_to_first_token,
                 label="TTFT",
                 units="ms",
                 total_characters=12,
@@ -318,8 +494,8 @@ class GenerativeTextBenchmarkerTaskProgressState(BenchmarkerTaskProgressState):
                 decimal_places=1,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
-                value=self.tokens_itl,
+            + format_value_display(
+                value=self.inter_token_latency,
                 label="ITL",
                 units="ms",
                 total_characters=12,
@@ -327,7 +503,7 @@ class GenerativeTextBenchmarkerTaskProgressState(BenchmarkerTaskProgressState):
                 decimal_places=1,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
+            + format_value_display(
                 value=self.prompt_tokens,
                 label="Prompt",
                 total_characters=12,
@@ -335,7 +511,7 @@ class GenerativeTextBenchmarkerTaskProgressState(BenchmarkerTaskProgressState):
                 decimal_places=0,
             )
             + ", "
-            + BenchmarkerTaskProgressState.format_progress_display(
+            + format_value_display(
                 value=self.output_tokens,
                 label="Gen",
                 total_characters=12,
@@ -344,377 +520,220 @@ class GenerativeTextBenchmarkerTaskProgressState(BenchmarkerTaskProgressState):
             )
         )
 
+    @property
+    def formatted_scheduler_stats(self) -> str:
+        if self.benchmark_status == "pending":
+            return " "
 
-BTPS = TypeVar("BTPS", bound=BenchmarkerTaskProgressState)
-
-
-class BenchmarkerProgressDisplay(Generic[BTPS]):
-    def __init__(self, display_scheduler_stats: bool):
-        self.display_scheduler_stats = display_scheduler_stats
-        self.started = False
-        self.benchmarker_tasks_progress = Progress(*self.create_task_progress_columns())
-        self.benchmarker_tasks_panel = Panel(
-            self.benchmarker_tasks_progress,
-            title="Benchmarks",
-            title_align="left",
-            expand=True,
-        )
-        self.benchmarker_progress = Progress(
-            TextColumn("Generating...", style=f"italic {Colors.PROGRESS}"),
-            BarColumn(
-                bar_width=None,
-                complete_style=Colors.PROGRESS,
-                finished_style=Colors.SUCCESS,
-            ),
-            TextColumn(
-                "({task.fields[completed_benchmarks]}/{task.fields[total_benchmarks]})",
-                style=Colors.PROGRESS,
-            ),
-            TextColumn("["),
-            TimeElapsedColumn(),
-            TextColumn("<"),
-            TimeRemainingColumn(),
-            TextColumn("]"),
-        )
-        self.benchmarker_live = Live(
-            Group(
-                self.benchmarker_tasks_panel,
-                self.benchmarker_progress,
-            ),
-            redirect_stdout=True,
-            redirect_stderr=True,
-        )
-        self.active_task: Optional[TaskID] = None
-        self.benchmarker_tasks: list[BTPS] = []
-        self.progress_task: Optional[TaskID] = None
-
-    def update(self, result: BenchmarkerResult):
-        if result.type_ == "run_start":
-            if self.started:
-                raise RuntimeError("Progress display already started.")
-
-            self.handle_start(result)
-            self.started = True
-        elif result.type_ == "run_complete":
-            if not self.started:
-                raise RuntimeError("Progress display not started.")
-
-            self.handle_end(result)
-            self.started = False
-        else:
-            if not self.started:
-                raise RuntimeError("Progress display not started.")
-
-            self.handle_update(result)
-
-    def handle_start(self, result: BenchmarkerResult):
-        self.benchmarker_live.start()
-
-        for index, strategy_type in enumerate(result.profile.strategy_types):
-            task_id = self.benchmarker_tasks_progress.add_task(
-                description=strategy_type,
-                start=False,
-                total=None,
-                completed=0,
-                visible=False,
+        return (
+            f"[{Colors.info}]Sys:[/{Colors.info}] , "
+            + format_value_display(
+                value=self.request_targeted_start_delay,
+                label="Start Del",
+                units="ms",
+                total_characters=18,
+                digits_places=5,
+                decimal_places=0,
             )
-            task_progress_state = self.create_task_progress_state(
-                task_id=task_id,
-                index=index,
-                strategy_type=strategy_type,
-                result=result,
+            + format_value_display(
+                value=self.scheduler_overheads_time,
+                label="Sched OH",
+                units="ms",
+                total_characters=18,
+                digits_places=3,
+                decimal_places=1,
             )
-            self.benchmarker_tasks.append(task_progress_state)
-            self.benchmarker_tasks_progress.update(
-                task_id,
-                description=task_progress_state.description,
-                visible=True,
-                **task_progress_state.fields,  # type: ignore[arg-type]
+            + ", "
+            + format_value_display(
+                value=self.queued_time,
+                label="Queued",
+                units="ms",
+                total_characters=18,
+                digits_places=5,
+                decimal_places=0,
             )
-
-        self.progress_task = self.benchmarker_progress.add_task(
-            "",
-            total=len(self.benchmarker_tasks) * 1000,
-            completed_benchmarks=0,
-            total_benchmarks=len(self.benchmarker_tasks),
-        )
-
-    def handle_update(self, result: BenchmarkerResult):
-        current_state: BTPS = self.benchmarker_tasks[result.current_index]
-
-        if result.type_ == "scheduler_start":
-            self.handle_update_scheduler_start(current_state, result)
-            self.active_task = current_state.task_id
-        elif result.type_ == "scheduler_update":
-            self.handle_update_scheduler_update(current_state, result)
-        elif result.type_ == "scheduler_complete":
-            self.handle_update_scheduler_complete(current_state, result)
-        elif result.type_ == "benchmark_compiled":
-            self.handle_update_benchmark_compiled(current_state, result)
-        else:
-            raise ValueError(f"Unknown result type: {result.type_}")
-
-        if self.progress_task is None:
-            raise RuntimeError("Progress task not set.")
-
-        self.benchmarker_tasks_progress.update(
-            current_state.task_id,
-            description=current_state.description,
-            completed=current_state.completed,
-            total=current_state.total,
-            **current_state.fields,  # type: ignore[arg-type]
-        )
-        self.benchmarker_progress.update(
-            self.progress_task,
-            completed=(result.current_index * 1000) + current_state.completed,
-            total=1000 * len(self.benchmarker_tasks),
-            completed_benchmarks=(
-                result.current_index + (1 if current_state.ended else 0)
-            ),
-            total_benchmarks=len(self.benchmarker_tasks),
-        )
-
-        if current_state.ended:
-            self.benchmarker_tasks_progress.stop_task(current_state.task_id)
-            self.active_task = None
-
-    def handle_update_scheduler_start(
-        self, progress_state: BTPS, result: BenchmarkerResult
-    ):
-        if self.active_task is not None:
-            raise RuntimeError("Active task already set.")
-
-        progress_state.strategy = result.current_strategy  # type: ignore[assignment]
-        progress_state.started = True
-        current_aggregator: BenchmarkAggregator = result.current_aggregator  # type: ignore[assignment]
-        progress_state.start_time = (
-            current_aggregator.requests_stats.totals.total.start_time
         )
-        progress_state.max_number = current_aggregator.args.max_number
-        progress_state.max_duration = current_aggregator.args.max_duration
-
-    def handle_update_scheduler_update(
-        self, progress_state: BTPS, result: BenchmarkerResult
-    ):
-        if self.active_task is None:
-            raise RuntimeError("Active task not set.")
 
-        if self.active_task != progress_state.task_id:
-            raise RuntimeError("Active task does not match current task.")
+    def start(self, strategy: SchedulingStrategy):
+        self.strategy = strategy
+        self.strategy_type = strategy.type_
 
-        current_aggregator: BenchmarkAggregator = result.current_aggregator  # type: ignore[assignment]
-        progress_state.in_warmup = current_aggregator.in_warmup
-        progress_state.in_cooldown = current_aggregator.in_cooldown
-        progress_state.requests_rate = (
-            current_aggregator.requests_stats.totals.successful.rate
-        )
-        progress_state.request_latency = (
-            current_aggregator.requests_stats.request_time.mean
-        )
-        progress_state.requests_processing = (
-            current_aggregator.scheduler_stats.processing_requests.last
-        )
-        progress_state.requests_successful = (
-            current_aggregator.requests_stats.totals.successful.total
-        )
-        progress_state.requests_incomplete = (
-            current_aggregator.requests_stats.totals.incomplete.total
-        )
-        progress_state.requests_errored = (
-            current_aggregator.requests_stats.totals.errored.total
-        )
-        progress_state.worker_overheads_time_ms = (
-            current_aggregator.requests_stats.scheduled_time_delay.mean_ms
-            + current_aggregator.requests_stats.worker_start_delay.mean_ms
-        )
-        progress_state.backend_overheads_time_ms = (
-            current_aggregator.requests_stats.request_time_delay.mean_ms
-        )
-        progress_state.requests_sleep_time_ms = (
-            current_aggregator.requests_stats.scheduled_time_sleep.mean_ms
-        )
-        progress_state.requests_targeted_start_time_delay_ms = (
-            current_aggregator.requests_stats.request_start_time_targeted_delay.mean_ms
-        )
-
-    def handle_update_scheduler_complete(
+    def update(
         self,
-        progress_state: BTPS,
-        result: BenchmarkerResult,  # noqa: ARG002
-    ):
-        if self.active_task is None:
-            raise RuntimeError("Active task not set.")
-
-        if self.active_task != progress_state.task_id:
-            raise RuntimeError("Active task does not match current task.")
-
-        progress_state.in_warmup = False
-        progress_state.in_cooldown = False
-        progress_state.compiling = True
-
-    def handle_update_benchmark_compiled(
-        self, progress_state: BTPS, result: BenchmarkerResult
+        estimated_state: EstimatedBenchmarkState,
+        scheduler_state: SchedulerState,
     ):
-        if self.active_task is None:
-            raise RuntimeError("Active task not set.")
-
-        if self.active_task != progress_state.task_id:
-            raise RuntimeError("Active task does not match current task.")
-
-        current_benchmark: Benchmark = result.current_benchmark  # type: ignore[assignment]
-        progress_state.compiling = False
-        progress_state.ended = True
-        progress_state.requests_rate = (
-            current_benchmark.metrics.requests_per_second.successful.mean
-        )
-        progress_state.requests_processing = (
-            current_benchmark.metrics.request_concurrency.successful.mean
+        self.progress = (
+            (1.0 - scheduler_state.remaining_fraction)
+            if scheduler_state.remaining_fraction is not None
+            else 0.0
+        )
+        self._update_processing_states(
+            benchmark_status=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_state_group,
+                key="status",
+                default=None,
+            ),
+            start_time=scheduler_state.start_time,
+            successful_requests=scheduler_state.successful_requests,
+            cancelled_requests=scheduler_state.cancelled_requests,
+            errored_requests=scheduler_state.errored_requests,
+        )
+        self._update_request_stats(
+            request_concurrency=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="concurrency_requests",
+            ),
+            requests_per_second=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_requests_per_second",
+            ),
+            request_latency=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_request_latency",
+            ),
         )
-
-    def handle_end(self, result: BenchmarkerResult):  # noqa: ARG002
-        if self.progress_task is None:
-            raise RuntimeError("Progress task not set.")
-
-        self.benchmarker_progress.update(
-            self.progress_task,
-            completed=len(self.benchmarker_tasks) * 1000,
-            total=len(self.benchmarker_tasks) * 1000,
-            completed_benchmarks=len(self.benchmarker_tasks),
-            total_benchmarks=len(self.benchmarker_tasks),
+        self._update_token_stats(
+            output_tokens=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_output_tokens_total",
+            ),
+            output_tokens_rate=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_output_tokens",
+            ),
+            prompt_tokens=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_input_tokens_total",
+            ),
+            total_tokens_rate=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_total_tokens",
+            ),
+            time_to_first_token=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_time_to_first_token",
+            ),
+            inter_token_latency=estimated_state.get_metric(
+                group=EstimatedBenchmarkState.benchmark_metrics_group,
+                key="completed_inter_token_latency",
+            ),
         )
-        self.benchmarker_progress.stop_task(self.progress_task)
-        self.benchmarker_live.stop()
-        self.active_task = None
-        self.benchmarker_tasks = []
-        self.progress_task = None
-
-    def create_task_progress_columns(self) -> list[ProgressColumn]:
-        columns = [
-            TextColumn("[{task.fields[start_time]}]"),
-            SpinnerColumn(style=Colors.PROGRESS),
-            TaskProgressColumn(style=Colors.PROGRESS),
-            TextColumn("{task.description}"),
-            TextColumn("({task.fields[progress_status]})"),
-            TextColumn(" "),
-        ]
-
-        if not self.display_scheduler_stats:
-            columns += [
-                TextColumn("{task.fields[requests_summary]}\n"),
-            ]
-        else:
-            columns += [
-                TextColumn(
-                    "{task.fields[requests_summary]}\n{task.fields[scheduler_stats]}\n"
+        if estimated_state.get("updated_scheduler_stats"):
+            self._update_system_stats(
+                request_targeted_start_delay=estimated_state.get_metric(
+                    group=EstimatedBenchmarkState.scheduler_state_group,
+                    key="request_targeted_start_delay",
                 ),
-            ]
-
-        return columns
+                queued_time=estimated_state.get_metric(
+                    group=EstimatedBenchmarkState.scheduler_state_group,
+                    key="queued_time",
+                ),
+                scheduler_overheads_time=0.0,  # Need to add up metrics here
+            )
 
-    def create_task_progress_state(
-        self,
-        task_id: TaskID,
-        index: int,  # noqa: ARG002
-        strategy_type: StrategyType,
-        result: BenchmarkerResult,  # noqa: ARG002
-    ) -> BTPS:
-        return BenchmarkerTaskProgressState(  # type: ignore[return-value]
-            display_scheduler_stats=self.display_scheduler_stats,
-            task_id=task_id,
-            strategy=strategy_type,
+    def complete(self, benchmark: GenerativeBenchmark):
+        self._update_processing_states(
+            benchmark_status="completed",
+            start_time=benchmark.start_time,
+            successful_requests=benchmark.request_totals.successful,
+            cancelled_requests=benchmark.request_totals.incomplete,
+            errored_requests=benchmark.request_totals.errored,
+        )
+        self._update_request_stats(
+            request_concurrency=benchmark.metrics.request_concurrency.successful.mean,
+            requests_per_second=benchmark.metrics.requests_per_second.successful.mean,
+            request_latency=benchmark.metrics.request_latency.successful.mean,
+        )
+        self._update_token_stats(
+            output_tokens=benchmark.metrics.output_token_count.successful.mean,
+            output_tokens_rate=benchmark.metrics.output_tokens_per_second.successful.mean,
+            prompt_tokens=benchmark.metrics.prompt_token_count.successful.mean,
+            total_tokens_rate=benchmark.metrics.tokens_per_second.successful.mean,
+            time_to_first_token=(
+                benchmark.metrics.time_to_first_token_ms.successful.mean
+            ),
+            inter_token_latency=(
+                benchmark.metrics.inter_token_latency_ms.successful.mean
+            ),
+            converted=True,
         )
 
-
-class GenerativeTextBenchmarkerProgressDisplay(
-    BenchmarkerProgressDisplay[GenerativeTextBenchmarkerTaskProgressState]
-):
-    def handle_update_scheduler_update(
+    def _update_processing_states(
         self,
-        progress_state: GenerativeTextBenchmarkerTaskProgressState,
-        result: BenchmarkerResult,
+        benchmark_status: Literal[
+            "pending", "in_warmup", "in_progress", "in_cooldown", "completed"
+        ],
+        start_time: float | None = None,
+        successful_requests: int | None = None,
+        cancelled_requests: int | None = None,
+        errored_requests: int | None = None,
     ):
-        super().handle_update_scheduler_update(progress_state, result)
-        current_aggregator: GenerativeBenchmarkAggregator = result.current_aggregator  # type: ignore[assignment]
-        progress_state.output_tokens = (
-            current_aggregator.requests_stats.output_tokens.mean
-        )
-        progress_state.prompt_tokens = (
-            current_aggregator.requests_stats.prompt_tokens.mean
-        )
-        progress_state.output_tokens_rate = (
-            current_aggregator.requests_stats.output_tokens.rate
-        )
-        progress_state.total_tokens_rate = (
-            current_aggregator.requests_stats.total_tokens.rate
-        )
-        progress_state.tokens_ttft = (
-            current_aggregator.requests_stats.time_to_first_token.mean_ms
-        )
-        progress_state.tokens_itl = (
-            current_aggregator.requests_stats.inter_token_latency.mean_ms
-        )
-
-    def handle_update_benchmark_compiled(
+        if benchmark_status is not None:
+            self.benchmark_status = benchmark_status
+        if start_time is not None:
+            self.start_time = start_time
+        if successful_requests is not None:
+            self.successful_requests = successful_requests
+        if cancelled_requests is not None:
+            self.cancelled_requests = cancelled_requests
+        if errored_requests is not None:
+            self.errored_requests = errored_requests
+
+    def _update_request_stats(
         self,
-        progress_state: GenerativeTextBenchmarkerTaskProgressState,
-        result: BenchmarkerResult,
+        request_concurrency: int | None = None,
+        requests_per_second: float | None = None,
+        request_latency: float | None = None,
     ):
-        super().handle_update_benchmark_compiled(progress_state, result)
-
-        current_benchmark: GenerativeBenchmark = result.current_benchmark  # type: ignore[assignment]
-        progress_state.request_latency = (
-            current_benchmark.metrics.request_latency.successful.mean
-        )
-        progress_state.requests_successful = current_benchmark.request_totals.successful
-        progress_state.requests_errored = current_benchmark.request_totals.errored
-        progress_state.requests_incomplete = current_benchmark.request_totals.incomplete
-        progress_state.output_tokens = (
-            current_benchmark.metrics.output_token_count.successful.mean
-        )
-        progress_state.prompt_tokens = (
-            current_benchmark.metrics.prompt_token_count.successful.mean
-        )
-        progress_state.output_tokens_rate = (
-            current_benchmark.metrics.output_tokens_per_second.successful.mean
-        )
-        progress_state.total_tokens_rate = (
-            current_benchmark.metrics.tokens_per_second.successful.mean
-        )
-        progress_state.tokens_ttft = (
-            current_benchmark.metrics.time_to_first_token_ms.successful.mean
-        )
-        progress_state.tokens_itl = (
-            current_benchmark.metrics.inter_token_latency_ms.successful.mean
-        )
-
-    def create_task_progress_state(
+        if request_concurrency is not None:
+            self.request_concurrency = request_concurrency
+        if requests_per_second is not None:
+            self.requests_per_second = requests_per_second
+        if request_latency is not None:
+            self.request_latency = request_latency
+
+    def _update_token_stats(
         self,
-        task_id: TaskID,
-        index: int,  # noqa: ARG002
-        strategy_type: StrategyType,
-        result: BenchmarkerResult,  # noqa: ARG002
-    ) -> GenerativeTextBenchmarkerTaskProgressState:
-        return GenerativeTextBenchmarkerTaskProgressState(
-            display_scheduler_stats=self.display_scheduler_stats,
-            task_id=task_id,
-            strategy=strategy_type,
-        )
-
-    def create_task_progress_columns(self) -> list[ProgressColumn]:
-        columns = super().create_task_progress_columns()
-        columns = columns[:-1]  # remove the last display info column
-
-        if not self.display_scheduler_stats:
-            columns += [
-                TextColumn(
-                    "{task.fields[requests_summary]}\n{task.fields[tokens_summary]}",
-                ),
-            ]
-        else:
-            columns += [
-                TextColumn(
-                    "{task.fields[requests_summary]}\n{task.fields[tokens_summary]}\n{task.fields[scheduler_stats]}",
-                ),
-            ]
+        output_tokens: int | None = None,
+        output_tokens_rate: float | None = None,
+        prompt_tokens: int | None = None,
+        total_tokens_rate: float | None = None,
+        time_to_first_token: float | None = None,
+        inter_token_latency: float | None = None,
+        converted: bool = False,
+    ):
+        if output_tokens is not None:
+            self.output_tokens = output_tokens
+        if output_tokens_rate is not None:
+            self.output_tokens_rate = output_tokens_rate
+        if prompt_tokens is not None:
+            self.prompt_tokens = prompt_tokens
+        if total_tokens_rate is not None:
+            self.total_tokens_rate = total_tokens_rate
+        if time_to_first_token is not None:
+            self.time_to_first_token = time_to_first_token * (
+                1000 if not converted else 1
+            )
+        if inter_token_latency is not None:
+            self.inter_token_latency = inter_token_latency * (
+                1000 if not converted else 1
+            )
 
-        return columns
+    def _update_system_stats(
+        self,
+        request_targeted_start_delay: float | None = None,
+        queued_time: float | None = None,
+        scheduler_overheads_time: float | None = None,
+        converted: bool = False,
+    ):
+        if request_targeted_start_delay is not None:
+            self.request_targeted_start_delay = request_targeted_start_delay * (
+                1000 if not converted else 1
+            )
+        if queued_time is not None:
+            self.queued_time = queued_time * (1000 if not converted else 1)
+        if scheduler_overheads_time is not None:
+            self.scheduler_overheads_time = scheduler_overheads_time * (
+                1000 if not converted else 1
+            )