From e2a13d7ba85fbbd49ec8c595e2ae69a3268ddb13 Mon Sep 17 00:00:00 2001 From: Maryam Tahhan Date: Wed, 21 Jan 2026 14:27:42 +0000 Subject: [PATCH 1/6] Fix sweep profile saturation handling for CPU deployments MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CPU deployments saturate at much lower concurrency rates than GPU deployments (e.g., 8 vs 512), causing sweep tests to continue measuring beyond saturation. This creates misleading performance graphs with "knee bend" artifacts and wasted benchmark time. This commit adds three configurable parameters to handle saturation: 1. exclude_throughput_target (default: false) - Stops constant-rate tests before reaching throughput level - Prevents generating tests at rates the system cannot sustain - Eliminates "elbow" artifacts in graphs 2. exclude_throughput_result (default: false) - Excludes throughput benchmark from saved results - Removes anomalous burst-capacity data points that create visual artifacts (TTFT spikes from ~70ms to 244ms, inter-token latency anomalies) in performance graphs 3. saturation_threshold (default: 0.98) - Automatically stops sweep when achieved rate < target × threshold - Detects saturation (e.g., system achieves 2.63 req/s when targeting 2.68 req/s = 98% efficiency) - Saves time by skipping unnecessary over-saturated tests Parameters are configurable via CLI flags (--exclude-throughput-target) or environment variables (GUIDELLM__EXCLUDE_THROUGHPUT_TARGET). Defaults remain GPU-friendly (all disabled). CPU deployments should enable both exclusion flags and tune saturation threshold as needed. Signed-off-by: Maryam Tahhan Co-Authored-By: Claude Sonnet 4.5 --- docs/getting-started/benchmark.md | 51 +++++++++ src/guidellm/benchmark/entrypoints.py | 9 +- src/guidellm/benchmark/profiles.py | 105 ++++++++++++++++-- .../schemas/generative/entrypoints.py | 27 +++++ src/guidellm/data/builders.py | 11 +- src/guidellm/settings.py | 5 + 6 files changed, 192 insertions(+), 16 deletions(-) diff --git a/docs/getting-started/benchmark.md b/docs/getting-started/benchmark.md index 6173907f6..238851187 100644 --- a/docs/getting-started/benchmark.md +++ b/docs/getting-started/benchmark.md @@ -166,6 +166,57 @@ guidellm benchmark --profile sweep | `--rate` | Number of strategies to run in the sweep (including synchronous and throughput). | `--rate 10` | | `--rampup` | Rate rampup duration in seconds for throughput and constant strategy steps. | `--rampup 10` | +##### Sweep Profile Configuration + +The sweep profile includes advanced configuration options for optimizing benchmarks on CPU-based deployments. These parameters help manage saturation detection and prevent graph artifacts: + +**Available Parameters:** + +| Parameter | Description | Default | Environment Variable | +| ------------------------------- | ----------------------------------------------------- | ------- | ---------------------------------------- | +| `--exclude-throughput-target` | Stop constant-rate tests before throughput level | `false` | `GUIDELLM__EXCLUDE_THROUGHPUT_TARGET` | +| `--exclude-throughput-result` | Exclude throughput benchmark from saved results | `false` | `GUIDELLM__EXCLUDE_THROUGHPUT_RESULT` | +| `--saturation-threshold` | Efficiency threshold for stopping sweep (0.0-1.0) | `0.98` | `GUIDELLM__SATURATION_THRESHOLD` | + +**When to Use:** + +- **CPU Deployments**: Enable `exclude-throughput-target` and `exclude-throughput-result` to prevent anomalous data points in performance graphs (TTFT spikes, inter-token latency anomalies) +- **GPU Deployments**: Use default settings (all disabled) + +**Example for CPU-optimized benchmarking:** + +```bash +guidellm benchmark \ + --target "http://localhost:8000" \ + --profile sweep \ + --exclude-throughput-target true \ + --exclude-throughput-result true \ + --saturation-threshold 0.98 \ + --data "prompt_tokens=256,output_tokens=128" \ + --max-seconds 300 +``` + +**Using Environment Variables:** + +```bash +export GUIDELLM__EXCLUDE_THROUGHPUT_TARGET=true +export GUIDELLM__EXCLUDE_THROUGHPUT_RESULT=true +export GUIDELLM__SATURATION_THRESHOLD=0.98 + +guidellm benchmark \ + --target "http://localhost:8000" \ + --profile sweep \ + --data "prompt_tokens=256,output_tokens=128" +``` + +**How It Works:** + +- `exclude-throughput-target`: Prevents generating a constant-rate test at the throughput level, avoiding "elbow" artifacts in graphs +- `exclude-throughput-result`: Removes the throughput benchmark from saved results, eliminating visual anomalies caused by burst capacity measurements +- `saturation-threshold`: Automatically stops the sweep when achieved rate falls below this percentage of target rate (e.g., 0.98 = 98%) + +These parameters are particularly useful for CPU deployments where saturation occurs at lower rates than burst capacity, creating misleading graph patterns if throughput measurements are included. + ## Data Options ### Synthetic Data Options diff --git a/src/guidellm/benchmark/entrypoints.py b/src/guidellm/benchmark/entrypoints.py index 1f0ed3043..f70a5664c 100644 --- a/src/guidellm/benchmark/entrypoints.py +++ b/src/guidellm/benchmark/entrypoints.py @@ -565,7 +565,14 @@ async def benchmark_generative_text( prefer_response_metrics=args.prefer_response_metrics, ): if benchmark: - report.benchmarks.append(benchmark) + # Check if we should exclude the throughput benchmark + should_exclude = ( + hasattr(profile, "exclude_throughput_result") + and profile.exclude_throughput_result + and benchmark.config.strategy.type_ == "throughput" + ) + if not should_exclude: + report.benchmarks.append(benchmark) output_format_results = {} for key, output in output_formats.items(): diff --git a/src/guidellm/benchmark/profiles.py b/src/guidellm/benchmark/profiles.py index 054356c10..903ce0414 100644 --- a/src/guidellm/benchmark/profiles.py +++ b/src/guidellm/benchmark/profiles.py @@ -595,6 +595,35 @@ class SweepProfile(Profile): default=42, description="Random seed for Poisson distribution strategy", ) + exclude_throughput_target: bool = Field( + default=False, + description=( + "Exclude constant-rate test at throughput level. " + "When True, constant-rate tests stop before reaching throughput rate, " + "preventing 'elbow' artifacts in performance graphs. " + "Recommended for CPU-based deployments." + ), + ) + exclude_throughput_result: bool = Field( + default=False, + description=( + "Exclude throughput benchmark from saved results. " + "When True, the throughput benchmark is not saved to the report, " + "preventing anomalous data points in graphs. " + "Recommended for CPU-based deployments when saturation is detected." + ), + ) + saturation_threshold: float = Field( + default=0.98, + ge=0.0, + le=1.0, + description=( + "Efficiency threshold for saturation detection (achieved/target rate). " + "Sweep stops when efficiency drops below this value. " + "Default 0.98 (98%) is recommended for CPU deployments. " + "Use 0.95 (95%) for noisier systems, 0.99 (99%) for very stable systems." + ), + ) synchronous_rate: float = Field( default=-1.0, description="Measured rate from synchronous strategy execution", @@ -634,6 +663,24 @@ def resolve_args( kwargs["random_seed"] = random_seed if rate_type in ["constant", "poisson"]: kwargs["strategy_type"] = rate_type + + # Resolve sweep profile parameters from settings if not provided + if ( + "exclude_throughput_target" not in kwargs + or kwargs["exclude_throughput_target"] is None + ): + kwargs["exclude_throughput_target"] = settings.exclude_throughput_target + if ( + "exclude_throughput_result" not in kwargs + or kwargs["exclude_throughput_result"] is None + ): + kwargs["exclude_throughput_result"] = settings.exclude_throughput_result + if ( + "saturation_threshold" not in kwargs + or kwargs["saturation_threshold"] is None + ): + kwargs["saturation_threshold"] = settings.saturation_threshold + return kwargs @property @@ -645,7 +692,7 @@ def strategy_types(self) -> list[str]: types += [self.strategy_type] * (self.sweep_size - len(types)) return types - def next_strategy( + def next_strategy( # noqa: C901 self, prev_strategy: SchedulingStrategy | None, prev_benchmark: Benchmark | None, @@ -685,13 +732,55 @@ def next_strategy( "Invalid rates in sweep; aborting. " "Were there any successful requests?" ) - self.measured_rates = list( - np.linspace( - self.synchronous_rate, - self.throughput_rate, - self.sweep_size - 1, - ) - )[1:] # don't rerun synchronous + + # Generate interpolated rates between synchronous and throughput. + # The behavior depends on exclude_throughput_target setting: + # + # When exclude_throughput_target=False (default, GPU mode): + # - Generate (sweep_size - 1) points from sync to throughput + # - Remove sync (already tested), keep throughput-level test + # - Example: sweep_size=10 -> 9 points, remove 1 = 8 async tests + # - Last async test targets throughput_rate + # + # When exclude_throughput_target=True (CPU mode): + # - Generate (sweep_size) points from sync to throughput + # - Remove sync AND throughput-level test + # - Example: sweep_size=10 -> 10 points, remove 2 = 8 async tests + # - Last async test stops before throughput_rate + # - Prevents "elbow" artifact in graphs + if self.exclude_throughput_target: + # CPU mode: stop before throughput level + self.measured_rates = list( + np.linspace( + self.synchronous_rate, + self.throughput_rate, + self.sweep_size, + ) + )[1:-1] + else: + # GPU mode: include throughput level + self.measured_rates = list( + np.linspace( + self.synchronous_rate, + self.throughput_rate, + self.sweep_size - 1, + ) + )[1:] + + # Check for saturation: if the previous constant-rate test couldn't + # achieve its target rate, the system has saturated + if ( + prev_strategy + and prev_strategy.type_ in ["constant", "poisson"] + and prev_benchmark + ): + target_rate = prev_strategy.rate + achieved_rate = prev_benchmark.metrics.requests_per_second.successful.mean + + # If achieved rate is below threshold, system is saturated + if achieved_rate < (target_rate * self.saturation_threshold): + # System saturated - don't test higher rates + return None next_index = ( len(self.completed_strategies) - 1 - 1 diff --git a/src/guidellm/benchmark/schemas/generative/entrypoints.py b/src/guidellm/benchmark/schemas/generative/entrypoints.py index f04365992..c8b0de0b1 100644 --- a/src/guidellm/benchmark/schemas/generative/entrypoints.py +++ b/src/guidellm/benchmark/schemas/generative/entrypoints.py @@ -235,6 +235,33 @@ def get_default(cls: type[BenchmarkGenerativeTextArgs], field: str) -> Any: default=None, description="Additional dataloader configuration arguments" ) random_seed: int = Field(default=42, description="Random seed for reproducibility") + # Sweep profile configuration + exclude_throughput_target: bool | None = Field( + default=None, + description=( + "Exclude constant-rate test at throughput level. " + "When True, constant-rate tests stop before reaching throughput rate. " + "Recommended for CPU-based deployments." + ), + ) + exclude_throughput_result: bool | None = Field( + default=None, + description=( + "Exclude throughput benchmark from saved results. " + "When True, throughput benchmark is not saved to the report. " + "Recommended for CPU-based deployments when saturation is detected." + ), + ) + saturation_threshold: float | None = Field( + default=None, + ge=0.0, + le=1.0, + description=( + "Efficiency threshold for saturation detection (achieved/target rate). " + "Sweep stops when efficiency drops below this value. " + "Default 0.98 (98%) is recommended for CPU deployments." + ), + ) # Output configuration outputs: list[str] | tuple[str] = Field( default_factory=lambda: ["json", "csv"], diff --git a/src/guidellm/data/builders.py b/src/guidellm/data/builders.py index a75513cbd..b902d6510 100644 --- a/src/guidellm/data/builders.py +++ b/src/guidellm/data/builders.py @@ -320,13 +320,10 @@ def _extract_column_names( except (KeyError, IndexError): prefix_column = None - try: - output_mappings = column_mapper.datasets_column_mappings[ - ("output_tokens_count_column", 0) - ] - output_column = output_mappings[0][1] - except (KeyError, IndexError): - output_column = "output_tokens_count" + output_mappings = column_mapper.datasets_column_mappings.get( + ("output_tokens_count_column", 0), [] + ) + output_column = output_mappings[0][1] if output_mappings else "output_tokens_count" return prompt_column, prefix_column, output_column diff --git a/src/guidellm/settings.py b/src/guidellm/settings.py index f16ac5b6c..74a209a98 100644 --- a/src/guidellm/settings.py +++ b/src/guidellm/settings.py @@ -105,6 +105,11 @@ class Settings(BaseSettings): constraint_error_window_size: float = 30 constraint_error_min_processed: float = 30 + # Sweep profile settings + exclude_throughput_target: bool = False + exclude_throughput_result: bool = False + saturation_threshold: float = 0.98 + # Data settings dataset: DatasetSettings = DatasetSettings() From 9af169dcbef9a397112985ecf568ad01433a8886 Mon Sep 17 00:00:00 2001 From: Maryam Tahhan Date: Thu, 22 Jan 2026 12:45:34 +0000 Subject: [PATCH 2/6] docs: Add warning about max_concurrency in sweep tests Add important note explaining why max_concurrency should not be set when running sweep profile tests. When max_concurrency is artificially limited, the throughput test underestimates server capacity, causing constant-rate tests to run at rates far below actual capacity. This prevents proper saturation detection and can produce misleading results where TTFT decreases instead of increases. Signed-off-by: Maryam Tahhan --- docs/getting-started/benchmark.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/getting-started/benchmark.md b/docs/getting-started/benchmark.md index 238851187..d24455e38 100644 --- a/docs/getting-started/benchmark.md +++ b/docs/getting-started/benchmark.md @@ -217,6 +217,10 @@ guidellm benchmark \ These parameters are particularly useful for CPU deployments where saturation occurs at lower rates than burst capacity, creating misleading graph patterns if throughput measurements are included. +**Important Note:** + +Do not set `--max-concurrency` or `GUIDELLM__MAX_CONCURRENCY` when running sweep tests. The sweep profile uses the throughput test to discover the server's true capacity, and artificially limiting concurrency will result in an underestimated throughput measurement. This causes the constant-rate tests to run at rates far below the actual server capacity, preventing proper saturation detection and producing misleading results where TTFT may decrease instead of increase. + ## Data Options ### Synthetic Data Options From a85ce6b1c5a9d95102f3f87765f0b29ac5785c97 Mon Sep 17 00:00:00 2001 From: Maryam Tahhan Date: Thu, 22 Jan 2026 12:59:35 +0000 Subject: [PATCH 3/6] docs: Enhance sweep profile parameter explanations Expand the "How It Works" section to provide: - Clear explanation of test execution order - Detailed rationale for each parameter (why + effect) - Explanation of how all three parameters work together - Real-world example of throughput test outliers (23+ sec TTFT) This helps users understand why all three parameters are recommended for CPU deployments and how they complement each other to produce clean, efficient benchmarks. Signed-off-by: Maryam Tahhan --- docs/getting-started/benchmark.md | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-) diff --git a/docs/getting-started/benchmark.md b/docs/getting-started/benchmark.md index d24455e38..de9cb7cd8 100644 --- a/docs/getting-started/benchmark.md +++ b/docs/getting-started/benchmark.md @@ -211,11 +211,33 @@ guidellm benchmark \ **How It Works:** -- `exclude-throughput-target`: Prevents generating a constant-rate test at the throughput level, avoiding "elbow" artifacts in graphs -- `exclude-throughput-result`: Removes the throughput benchmark from saved results, eliminating visual anomalies caused by burst capacity measurements -- `saturation-threshold`: Automatically stops the sweep when achieved rate falls below this percentage of target rate (e.g., 0.98 = 98%) +The sweep profile runs tests in this order: +1. **Synchronous test**: Measures baseline single-request performance +2. **Throughput test**: Discovers maximum server capacity with parallel requests +3. **Constant-rate tests**: Tests at interpolated rates between synchronous and throughput -These parameters are particularly useful for CPU deployments where saturation occurs at lower rates than burst capacity, creating misleading graph patterns if throughput measurements are included. +Each parameter optimizes a different aspect: + +- **`exclude-throughput-target`**: Prevents generating a constant-rate test at the throughput level itself + - **Why**: The highest constant-rate test would target the same rate as the throughput test, creating redundant "elbow" artifacts in graphs + - **Effect**: Stops constant-rate tests just before reaching throughput rate + +- **`exclude-throughput-result`**: Removes the throughput benchmark from saved results + - **Why**: Throughput tests measure burst capacity with severe queuing (e.g., 23+ second TTFT), creating extreme outliers in graphs + - **Effect**: Graphs only show sustainable performance metrics from constant-rate tests + +- **`saturation-threshold`**: Stops the sweep when efficiency drops below threshold + - **Why**: Once saturation is detected (achieved rate < target rate × threshold), further tests provide diminishing returns + - **Effect**: Saves time by stopping early when the server can no longer meet target rates + +**Why use all three together?** + +For CPU deployments, all three parameters work synergistically: +- `saturation-threshold` stops the sweep efficiently when saturation is detected +- `exclude-throughput-target` prevents testing at the unsustainable throughput rate +- `exclude-throughput-result` removes the anomalous throughput spike from graphs + +This combination produces clean, efficient benchmarks that focus on sustainable performance ranges. **Important Note:** From da14caa852d3546223fc6292b270dbb101acbbd7 Mon Sep 17 00:00:00 2001 From: Maryam Tahhan Date: Fri, 23 Jan 2026 10:01:15 +0000 Subject: [PATCH 4/6] docs: Apply mdformat formatting to benchmark.md Signed-off-by: Maryam Tahhan --- docs/getting-started/benchmark.md | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/docs/getting-started/benchmark.md b/docs/getting-started/benchmark.md index de9cb7cd8..94fc05d1d 100644 --- a/docs/getting-started/benchmark.md +++ b/docs/getting-started/benchmark.md @@ -172,11 +172,11 @@ The sweep profile includes advanced configuration options for optimizing benchma **Available Parameters:** -| Parameter | Description | Default | Environment Variable | -| ------------------------------- | ----------------------------------------------------- | ------- | ---------------------------------------- | -| `--exclude-throughput-target` | Stop constant-rate tests before throughput level | `false` | `GUIDELLM__EXCLUDE_THROUGHPUT_TARGET` | -| `--exclude-throughput-result` | Exclude throughput benchmark from saved results | `false` | `GUIDELLM__EXCLUDE_THROUGHPUT_RESULT` | -| `--saturation-threshold` | Efficiency threshold for stopping sweep (0.0-1.0) | `0.98` | `GUIDELLM__SATURATION_THRESHOLD` | +| Parameter | Description | Default | Environment Variable | +| ----------------------------- | ------------------------------------------------- | ------- | ------------------------------------- | +| `--exclude-throughput-target` | Stop constant-rate tests before throughput level | `false` | `GUIDELLM__EXCLUDE_THROUGHPUT_TARGET` | +| `--exclude-throughput-result` | Exclude throughput benchmark from saved results | `false` | `GUIDELLM__EXCLUDE_THROUGHPUT_RESULT` | +| `--saturation-threshold` | Efficiency threshold for stopping sweep (0.0-1.0) | `0.98` | `GUIDELLM__SATURATION_THRESHOLD` | **When to Use:** @@ -212,6 +212,7 @@ guidellm benchmark \ **How It Works:** The sweep profile runs tests in this order: + 1. **Synchronous test**: Measures baseline single-request performance 2. **Throughput test**: Discovers maximum server capacity with parallel requests 3. **Constant-rate tests**: Tests at interpolated rates between synchronous and throughput @@ -219,20 +220,24 @@ The sweep profile runs tests in this order: Each parameter optimizes a different aspect: - **`exclude-throughput-target`**: Prevents generating a constant-rate test at the throughput level itself + - **Why**: The highest constant-rate test would target the same rate as the throughput test, creating redundant "elbow" artifacts in graphs - **Effect**: Stops constant-rate tests just before reaching throughput rate - **`exclude-throughput-result`**: Removes the throughput benchmark from saved results + - **Why**: Throughput tests measure burst capacity with severe queuing (e.g., 23+ second TTFT), creating extreme outliers in graphs - **Effect**: Graphs only show sustainable performance metrics from constant-rate tests - **`saturation-threshold`**: Stops the sweep when efficiency drops below threshold + - **Why**: Once saturation is detected (achieved rate < target rate × threshold), further tests provide diminishing returns - **Effect**: Saves time by stopping early when the server can no longer meet target rates **Why use all three together?** For CPU deployments, all three parameters work synergistically: + - `saturation-threshold` stops the sweep efficiently when saturation is detected - `exclude-throughput-target` prevents testing at the unsustainable throughput rate - `exclude-throughput-result` removes the anomalous throughput spike from graphs From 1054ed3173b17f34b3930014959e4779ff422010 Mon Sep 17 00:00:00 2001 From: Maryam Tahhan Date: Fri, 23 Jan 2026 10:07:42 +0000 Subject: [PATCH 5/6] fix: Add type guards for mypy in saturation detection Signed-off-by: Maryam Tahhan --- src/guidellm/benchmark/profiles.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/guidellm/benchmark/profiles.py b/src/guidellm/benchmark/profiles.py index 903ce0414..69ec9ddf4 100644 --- a/src/guidellm/benchmark/profiles.py +++ b/src/guidellm/benchmark/profiles.py @@ -773,9 +773,11 @@ def next_strategy( # noqa: C901 prev_strategy and prev_strategy.type_ in ["constant", "poisson"] and prev_benchmark + and hasattr(prev_strategy, "rate") + and hasattr(prev_benchmark, "metrics") ): - target_rate = prev_strategy.rate - achieved_rate = prev_benchmark.metrics.requests_per_second.successful.mean + target_rate = prev_strategy.rate # type: ignore[attr-defined] + achieved_rate = prev_benchmark.metrics.requests_per_second.successful.mean # type: ignore[attr-defined] # If achieved rate is below threshold, system is saturated if achieved_rate < (target_rate * self.saturation_threshold): From 49900f8fe4573e564b9511112f8849d1a6dbc9c3 Mon Sep 17 00:00:00 2001 From: Maryam Tahhan Date: Fri, 23 Jan 2026 10:12:09 +0000 Subject: [PATCH 6/6] docs: Update terminology to 'CPU based system under test' Signed-off-by: Maryam Tahhan --- docs/getting-started/benchmark.md | 6 +++--- src/guidellm/benchmark/profiles.py | 4 ++-- src/guidellm/benchmark/schemas/generative/entrypoints.py | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/getting-started/benchmark.md b/docs/getting-started/benchmark.md index 94fc05d1d..fb5792dc5 100644 --- a/docs/getting-started/benchmark.md +++ b/docs/getting-started/benchmark.md @@ -180,8 +180,8 @@ The sweep profile includes advanced configuration options for optimizing benchma **When to Use:** -- **CPU Deployments**: Enable `exclude-throughput-target` and `exclude-throughput-result` to prevent anomalous data points in performance graphs (TTFT spikes, inter-token latency anomalies) -- **GPU Deployments**: Use default settings (all disabled) +- **CPU based system under test**: Enable `exclude-throughput-target` and `exclude-throughput-result` to prevent anomalous data points in performance graphs (TTFT spikes, inter-token latency anomalies) +- **GPU based system under test**: Use default settings (all disabled) **Example for CPU-optimized benchmarking:** @@ -236,7 +236,7 @@ Each parameter optimizes a different aspect: **Why use all three together?** -For CPU deployments, all three parameters work synergistically: +For CPU based system under test, all three parameters work synergistically: - `saturation-threshold` stops the sweep efficiently when saturation is detected - `exclude-throughput-target` prevents testing at the unsustainable throughput rate diff --git a/src/guidellm/benchmark/profiles.py b/src/guidellm/benchmark/profiles.py index 69ec9ddf4..68cfa0362 100644 --- a/src/guidellm/benchmark/profiles.py +++ b/src/guidellm/benchmark/profiles.py @@ -610,7 +610,7 @@ class SweepProfile(Profile): "Exclude throughput benchmark from saved results. " "When True, the throughput benchmark is not saved to the report, " "preventing anomalous data points in graphs. " - "Recommended for CPU-based deployments when saturation is detected." + "Recommended for CPU based system under test when saturation is detected." ), ) saturation_threshold: float = Field( @@ -620,7 +620,7 @@ class SweepProfile(Profile): description=( "Efficiency threshold for saturation detection (achieved/target rate). " "Sweep stops when efficiency drops below this value. " - "Default 0.98 (98%) is recommended for CPU deployments. " + "Default 0.98 (98%) is recommended for CPU based system under test. " "Use 0.95 (95%) for noisier systems, 0.99 (99%) for very stable systems." ), ) diff --git a/src/guidellm/benchmark/schemas/generative/entrypoints.py b/src/guidellm/benchmark/schemas/generative/entrypoints.py index c8b0de0b1..6a21d603d 100644 --- a/src/guidellm/benchmark/schemas/generative/entrypoints.py +++ b/src/guidellm/benchmark/schemas/generative/entrypoints.py @@ -259,7 +259,7 @@ def get_default(cls: type[BenchmarkGenerativeTextArgs], field: str) -> Any: description=( "Efficiency threshold for saturation detection (achieved/target rate). " "Sweep stops when efficiency drops below this value. " - "Default 0.98 (98%) is recommended for CPU deployments." + "Default 0.98 (98%) is recommended for CPU based system under test." ), ) # Output configuration