evalscope 0.15.1__py3-none-any.whl → 0.16.0__py3-none-any.whl

evalscope/models/adapters/server_adapter.py

@@ -43,7 +43,7 @@ class ServerModelAdapter(BaseModelAdapter):
         sig = signature(self.client.chat.completions.create)
         return list(sig.parameters.keys())
 
-    def predict(self, inputs: List[dict], infer_cfg: dict = None) -> List[dict]:
+    def predict(self, inputs: List[dict], infer_cfg: Optional[dict] = None) -> List[dict]:
         """
         Model prediction func.
 
@@ -65,23 +65,26 @@ class ServerModelAdapter(BaseModelAdapter):
 
     def process_single_input(self, input_item: dict, infer_cfg: dict) -> dict:
         """Process a single input item."""
-        data: list = input_item['data']
-        if isinstance(data[0], tuple):  # for truthful_qa and hellaswag
-            query = '\n'.join(''.join(item) for item in data)
-            system_prompt = input_item.get('system_prompt', None)
+        if input_item.get('messages', None):
+            content = input_item['messages']
         else:
-            query = data[0]
-            system_prompt = input_item.get('system_prompt', None)
-
-        content = self.make_request_content(query, system_prompt)
+            content = self.make_request_content(input_item)
         request_json = self.make_request(content, infer_cfg)
         response = self.send_request(request_json)
         return response
 
-    def make_request_content(self, query: str, system_prompt: Optional[str] = None) -> list:
+    def make_request_content(self, input_item: dict) -> list:
         """
         Make request content for OpenAI API.
         """
+        data: list = input_item['data']
+        if isinstance(data[0], tuple):  # for truthful_qa and hellaswag
+            query = '\n'.join(''.join(item) for item in data)
+            system_prompt = input_item.get('system_prompt', None)
+        else:
+            query = data[0]
+            system_prompt = input_item.get('system_prompt', None)
+
         messages = []
         if system_prompt:
             messages.append({'role': 'system', 'content': system_prompt})
@@ -90,16 +93,9 @@ class ServerModelAdapter(BaseModelAdapter):
 
         return messages
 
-    def make_request(self, content: list, infer_cfg: dict = {}) -> dict:
+    def make_request(self, content: list, infer_cfg: dict) -> dict:
         """Make request to remote API."""
         # Format request JSON according to OpenAI API format
-        from evalscope.config import DEFAULT_GENERATION_CONFIG
-        if infer_cfg == DEFAULT_GENERATION_CONFIG:
-            infer_cfg = {
-                'max_tokens': 2048,
-                'temperature': 0.0,
-            }
-
         request_json = {'model': self.model_id, 'messages': content, **infer_cfg}
 
         if self.timeout:
@@ -137,7 +133,7 @@ class ServerModelAdapter(BaseModelAdapter):
             return response.model_dump(exclude_unset=True)
         except Exception as e:
             logger.error(f'Error when calling remote API: {str(e)}')
-            raise
+            raise e
 
     def _collect_stream_response(self, response_stream: List[ChatCompletionChunk]) -> ChatCompletion:
         collected_chunks = []

evalscope/perf/arguments.py

@@ -3,7 +3,7 @@ import json
 import os
 import sys
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from evalscope.constants import DEFAULT_WORK_DIR
 
@@ -27,8 +27,8 @@ class Arguments:
     no_test_connection: bool = False  # Test the connection before starting the benchmark
 
     # Performance and parallelism
-    number: int = 1000  # Number of requests to be made
-    parallel: int = 1  # Number of parallel requests
+    number: Union[int, List[int]] = 1000  # Number of requests to be made
+    parallel: Union[int, List[int]] = 1  # Number of parallel requests
     rate: int = -1  # Rate limit for requests (default: -1, no limit)
 
     # Logging and debugging
@@ -98,6 +98,15 @@ class Arguments:
         if self.apply_chat_template is None:
             self.apply_chat_template = self.url.strip('/').endswith('chat/completions')
 
+        # Set number and parallel to lists if they are integers
+        if isinstance(self.number, int):
+            self.number = [self.number]
+        if isinstance(self.parallel, int):
+            self.parallel = [self.parallel]
+        assert len(self.number) == len(
+            self.parallel
+        ), f'The length of number and parallel should be the same, but got number: {self.number} and parallel: {self.parallel}'  # noqa: E501
+
     def __str__(self):
         return json.dumps(self.to_dict(), indent=4, default=str, ensure_ascii=False)
 
@@ -143,8 +152,8 @@ def add_argument(parser: argparse.ArgumentParser):
     parser.add_argument('--no-test-connection', action='store_false', default=False, help='Do not test the connection before starting the benchmark')  # noqa: E501
 
     # Performance and parallelism
-    parser.add_argument('-n', '--number', type=int, default=1000, help='How many requests to be made')
-    parser.add_argument('--parallel', type=int, default=1, help='Set number of concurrency requests, default 1')
+    parser.add_argument('-n', '--number', type=int, default=1000, nargs='+', help='How many requests to be made')
+    parser.add_argument('--parallel', type=int, default=1, nargs='+', help='Set number of concurrency requests, default 1')  # noqa: E501
     parser.add_argument('--rate', type=int, default=-1, help='Number of requests per second. default None')
 
     # Logging and debugging

evalscope/perf/benchmark.py

@@ -18,7 +18,6 @@ from evalscope.perf.utils.benchmark_util import BenchmarkData, BenchmarkMetrics
 from evalscope.perf.utils.db_util import create_result_table, get_result_db_path, insert_benchmark_data, summary_result
 from evalscope.perf.utils.handler import add_signal_handlers, exception_handler
 from evalscope.perf.utils.local_server import start_app
-from evalscope.perf.utils.log_utils import init_swanlab, init_wandb
 from evalscope.utils.logger import get_logger
 
 logger = get_logger()
@@ -116,11 +115,6 @@ async def statistic_benchmark_metric(benchmark_data_queue: asyncio.Queue, args:
 
     result_db_path = get_result_db_path(args)
 
-    if args.wandb_api_key:
-        init_wandb(args)
-    if args.swanlab_api_key:
-        init_swanlab(args)
-
     collected_benchmark_data = []
 
     with tqdm(desc='Processing', total=args.number) as pbar:

evalscope/perf/main.py

@@ -1,32 +1,32 @@
 import asyncio
+import copy
 import os
 import platform
+import time
 from argparse import Namespace
 
-from evalscope.perf.arguments import Arguments, parse_args
-from evalscope.perf.benchmark import benchmark
-from evalscope.perf.utils.db_util import get_output_path
-from evalscope.perf.utils.handler import add_signal_handlers
+from evalscope.perf.utils.log_utils import init_swanlab, init_wandb
 from evalscope.utils.logger import configure_logging, get_logger
 from evalscope.utils.utils import seed_everything
+from .arguments import Arguments, parse_args
+from .benchmark import benchmark
+from .utils.db_util import get_output_path
+from .utils.handler import add_signal_handlers
+from .utils.rich_display import print_summary
 
 logger = get_logger()
 
 
-def run_perf_benchmark(args):
-    if isinstance(args, dict):
-        args = Arguments(**args)
-    elif isinstance(args, Namespace):
-        args = Arguments.from_args(args)
-
-    if args.seed is not None:
-        seed_everything(args.seed)
+def run_one_benchmark(args: Arguments, output_path: str = None):
+    if isinstance(args.parallel, list):
+        args.parallel = args.parallel[0]
+    if isinstance(args.number, list):
+        args.number = args.number[0]
 
     # Setup logger and output
-    args.outputs_dir = get_output_path(args)
-    configure_logging(args.debug, os.path.join(args.outputs_dir, 'benchmark.log'))
+    args.outputs_dir = output_path
 
-    logger.info('Starting benchmark...')
+    logger.info('Starting benchmark with args: ')
     logger.info(args)
 
     if platform.system() == 'Windows':
@@ -39,6 +39,56 @@ def run_perf_benchmark(args):
     return loop.run_until_complete(benchmark(args))
 
 
+def run_multi_benchmark(args: Arguments, output_path: str = None):
+    results = []
+    number_list = copy.deepcopy(args.number)
+    parallel_list = copy.deepcopy(args.parallel)
+    for i, (number, parallel) in enumerate(zip(number_list, parallel_list)):
+        args.number = number
+        args.parallel = parallel
+        # Set up output path for each run
+        cur_output_path = os.path.join(output_path, f'parallel_{parallel}_number_{number}')
+        os.makedirs(cur_output_path, exist_ok=True)
+        # Start the benchmark
+        metrics_result = run_one_benchmark(args, output_path=cur_output_path)
+        # Save the results
+        results.append(metrics_result)
+        # Sleep between runs to avoid overwhelming the server
+        if i < len(number_list) - 1:
+            logger.info('Sleeping for 5 seconds before the next run...')
+            time.sleep(5)
+    # Analyze results
+    print_summary(results, args.model_id)
+    return results
+
+
+def run_perf_benchmark(args):
+    # Check if args is a dictionary or Namespace
+    if isinstance(args, dict):
+        args = Arguments(**args)
+    elif isinstance(args, Namespace):
+        args = Arguments.from_args(args)
+
+    if args.seed is not None:
+        seed_everything(args.seed)
+
+    # Initialize output directory
+    output_path = get_output_path(args)
+    configure_logging(args.debug, os.path.join(output_path, 'benchmark.log'))
+
+    # Initialize wandb and swanlab
+    if args.wandb_api_key:
+        init_wandb(args)
+    if args.swanlab_api_key:
+        init_swanlab(args)
+
+    # Start benchmark
+    if len(args.number) == 1:
+        return run_one_benchmark(args, output_path=output_path)
+    else:
+        return run_multi_benchmark(args, output_path=output_path)
+
+
 if __name__ == '__main__':
     args = Arguments.from_args(parse_args())
     metrics_result, percentile_result = run_perf_benchmark(args)

evalscope/perf/utils/benchmark_util.py

@@ -51,6 +51,24 @@ class BenchmarkData:
         self.max_gpu_memory_cost = max(self.max_gpu_memory_cost, total_memory)
 
 
+class Metrics:
+    TIME_TAKEN_FOR_TESTS = 'Time taken for tests (s)'
+    NUMBER_OF_CONCURRENCY = 'Number of concurrency'
+    TOTAL_REQUESTS = 'Total requests'
+    SUCCEED_REQUESTS = 'Succeed requests'
+    FAILED_REQUESTS = 'Failed requests'
+    OUTPUT_TOKEN_THROUGHPUT = 'Output token throughput (tok/s)'
+    TOTAL_TOKEN_THROUGHPUT = 'Total token throughput (tok/s)'
+    REQUEST_THROUGHPUT = 'Request throughput (req/s)'
+    AVERAGE_LATENCY = 'Average latency (s)'
+    AVERAGE_TIME_TO_FIRST_TOKEN = 'Average time to first token (s)'
+    AVERAGE_TIME_PER_OUTPUT_TOKEN = 'Average time per output token (s)'
+    AVERAGE_INPUT_TOKENS_PER_REQUEST = 'Average input tokens per request'
+    AVERAGE_OUTPUT_TOKENS_PER_REQUEST = 'Average output tokens per request'
+    AVERAGE_PACKAGE_LATENCY = 'Average package latency (s)'
+    AVERAGE_PACKAGE_PER_REQUEST = 'Average package per request'
+
+
 @dataclass
 class BenchmarkMetrics:
     concurrency: int = 0
@@ -125,20 +143,20 @@ class BenchmarkMetrics:
 
     def create_message(self, default_ndigits=4):
         message = {
-            'Time taken for tests (s)': round(self.total_time, default_ndigits),
-            'Number of concurrency': self.concurrency,
-            'Total requests': int(self.n_total_queries),
-            'Succeed requests': self.n_succeed_queries,
-            'Failed requests': self.n_failed_queries,
-            'Output token throughput (tok/s)': round(self.avg_output_token_per_seconds, default_ndigits),
-            'Total token throughput (tok/s)': round(self.avg_total_token_per_seconds, default_ndigits),
-            'Request throughput (req/s)': round(self.qps, default_ndigits),
-            'Average latency (s)': round(self.avg_latency, default_ndigits),
-            'Average time to first token (s)': round(self.avg_first_chunk_latency, default_ndigits),
-            'Average time per output token (s)': round(self.avg_time_per_token, default_ndigits),
-            'Average input tokens per request': round(self.avg_prompt_tokens, default_ndigits),
-            'Average output tokens per request': round(self.avg_completion_tokens, default_ndigits),
-            'Average package latency (s)': round(self.avg_chunk_time, default_ndigits),
-            'Average package per request': round(self.n_avg_chunks, default_ndigits),
+            Metrics.TIME_TAKEN_FOR_TESTS: round(self.total_time, default_ndigits),
+            Metrics.NUMBER_OF_CONCURRENCY: self.concurrency,
+            Metrics.TOTAL_REQUESTS: int(self.n_total_queries),
+            Metrics.SUCCEED_REQUESTS: self.n_succeed_queries,
+            Metrics.FAILED_REQUESTS: self.n_failed_queries,
+            Metrics.OUTPUT_TOKEN_THROUGHPUT: round(self.avg_output_token_per_seconds, default_ndigits),
+            Metrics.TOTAL_TOKEN_THROUGHPUT: round(self.avg_total_token_per_seconds, default_ndigits),
+            Metrics.REQUEST_THROUGHPUT: round(self.qps, default_ndigits),
+            Metrics.AVERAGE_LATENCY: round(self.avg_latency, default_ndigits),
+            Metrics.AVERAGE_TIME_TO_FIRST_TOKEN: round(self.avg_first_chunk_latency, default_ndigits),
+            Metrics.AVERAGE_TIME_PER_OUTPUT_TOKEN: round(self.avg_time_per_token, default_ndigits),
+            Metrics.AVERAGE_INPUT_TOKENS_PER_REQUEST: round(self.avg_prompt_tokens, default_ndigits),
+            Metrics.AVERAGE_OUTPUT_TOKENS_PER_REQUEST: round(self.avg_completion_tokens, default_ndigits),
+            Metrics.AVERAGE_PACKAGE_LATENCY: round(self.avg_chunk_time, default_ndigits),
+            Metrics.AVERAGE_PACKAGE_PER_REQUEST: round(self.n_avg_chunks, default_ndigits),
         }
         return message

evalscope/perf/utils/db_util.py

@@ -111,6 +111,18 @@ def get_result_db_path(args: Arguments):
     return result_db_path
 
 
+class PercentileMetrics:
+    TTFT = 'TTFT (s)'
+    ITL = 'ITL (s)'
+    TPOT = 'TPOT (s)'
+    LATENCY = 'Latency (s)'
+    INPUT_TOKENS = 'Input tokens'
+    OUTPUT_TOKENS = 'Output tokens'
+    OUTPUT_THROUGHPUT = 'Output (tok/s)'
+    TOTAL_THROUGHPUT = 'Total (tok/s)'
+    PERCENTILES = 'Percentiles'
+
+
 def calculate_percentiles(data: List[float], percentiles: List[int]) -> Dict[int, float]:
     """
     Calculate the percentiles for a specific list of data.
@@ -157,10 +169,6 @@ def get_percentile_results(result_db_path: str) -> Dict[str, List[float]]:
     with sqlite3.connect(result_db_path) as con:
         rows = con.execute(query_sql).fetchall()
 
-    if len(rows) < len(percentiles):
-        logger.info('Too little data to calculate quantiles!')
-        return {}
-
     # Define index variables for columns
     CHUNK_TIMES_INDEX = 1
     LATENCY_INDEX = 4
@@ -175,24 +183,25 @@ def get_percentile_results(result_db_path: str) -> Dict[str, List[float]]:
         inter_token_latencies_all.extend(inter_token_latencies(row[CHUNK_TIMES_INDEX]))
 
     metrics = {
-        'TTFT (s)': [row[FIRST_CHUNK_LATENCY_INDEX] for row in rows],
-        'ITL (s)':
+        PercentileMetrics.TTFT: [row[FIRST_CHUNK_LATENCY_INDEX] for row in rows],
+        PercentileMetrics.ITL:
         inter_token_latencies_all,
-        'TPOT (s)':
+        PercentileMetrics.TPOT:
         [(row[CHUNK_TIME_INDEX] / row[COMPLETION_TOKENS_INDEX]) if row[COMPLETION_TOKENS_INDEX] > 0 else float('nan')
          for row in rows],
-        'Latency (s)': [row[LATENCY_INDEX] for row in rows],
-        'Input tokens': [row[PROMPT_TOKENS_INDEX] for row in rows],
-        'Output tokens': [row[COMPLETION_TOKENS_INDEX] for row in rows],
-        'Output throughput(tok/s)':
+        PercentileMetrics.LATENCY: [row[LATENCY_INDEX] for row in rows],
+        PercentileMetrics.INPUT_TOKENS: [row[PROMPT_TOKENS_INDEX] for row in rows],
+        PercentileMetrics.OUTPUT_TOKENS: [row[COMPLETION_TOKENS_INDEX] for row in rows],
+        PercentileMetrics.OUTPUT_THROUGHPUT:
         [(row[COMPLETION_TOKENS_INDEX] / row[LATENCY_INDEX]) if row[LATENCY_INDEX] > 0 else float('nan')
          for row in rows],
-        'Total throughput(tok/s)': [((row[PROMPT_TOKENS_INDEX] + row[COMPLETION_TOKENS_INDEX])
-                                     / row[LATENCY_INDEX]) if row[LATENCY_INDEX] > 0 else float('nan') for row in rows]
+        PercentileMetrics.TOTAL_THROUGHPUT: [((row[PROMPT_TOKENS_INDEX] + row[COMPLETION_TOKENS_INDEX])
+                                              / row[LATENCY_INDEX]) if row[LATENCY_INDEX] > 0 else float('nan')
+                                             for row in rows]
     }
 
     # Calculate percentiles for each metric
-    results = {'Percentile': [f'{p}%' for p in percentiles]}
+    results = {PercentileMetrics.PERCENTILES: [f'{p}%' for p in percentiles]}
     for metric_name, data in metrics.items():
         metric_percentiles = calculate_percentiles(data, percentiles)
         results[metric_name] = [metric_percentiles[p] for p in percentiles]
@@ -205,7 +214,6 @@ def summary_result(args: Arguments, metrics: BenchmarkMetrics, result_db_path: s
     write_json_file(args.to_dict(), os.path.join(result_path, 'benchmark_args.json'))
 
     metrics_result = metrics.create_message()
-    metrics_result.update({'Expected number of requests': args.number, 'Result DB path': result_db_path})
     write_json_file(metrics_result, os.path.join(result_path, 'benchmark_summary.json'))
 
     # Print summary in a table
@@ -223,6 +231,8 @@ def summary_result(args: Arguments, metrics: BenchmarkMetrics, result_db_path: s
     if args.dataset.startswith('speed_benchmark'):
         speed_benchmark_result(result_db_path)
 
+    logger.info(f'Save the summary to: {result_path}')
+
     return metrics_result, percentile_result
 
 

evalscope/perf/utils/log_utils.py

@@ -35,7 +35,7 @@ def init_swanlab(args: Arguments) -> None:
     name = args.name if args.name else f'{args.model_id}_{current_time}'
     swanlab.config.update({'framework': '📏evalscope'})
     swanlab.init(
-        project='perf_benchmark',
+        project=os.getenv('SWANLAB_PROJ_NAME', 'perf_benchmark'),
         name=name,
         config=args.to_dict(),
         mode='local' if args.swanlab_api_key == 'local' else None)

evalscope/perf/utils/rich_display.py

@@ -0,0 +1,186 @@
+# the following code is largely adapted from https://github.com/lework/llm-benchmark
+
+import numpy as np
+from rich.console import Console
+from rich.panel import Panel
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+
+from evalscope.utils.logger import get_logger
+from .benchmark_util import Metrics
+from .db_util import PercentileMetrics
+
+logger = get_logger()
+
+
+def analyze_results(all_results):
+    """Analyze all test results and generate a summary report"""
+    summary = []
+    total_tokens = 0
+    total_time = 0
+
+    for result in all_results:
+        total_metrics = result[0]
+        percentile_metrics = result[1]
+        percentiles = percentile_metrics[PercentileMetrics.PERCENTILES]
+        try:
+            concurrency = total_metrics.get(Metrics.NUMBER_OF_CONCURRENCY, 0)
+            rps = total_metrics.get(Metrics.REQUEST_THROUGHPUT, 0)
+            avg_latency = total_metrics.get(Metrics.AVERAGE_LATENCY, 0)
+            p99_latency = percentile_metrics.get(PercentileMetrics.LATENCY)[percentiles.index('99%')]
+            avg_tps = total_metrics.get(Metrics.OUTPUT_TOKEN_THROUGHPUT, 0)
+            avg_ttft = total_metrics.get(Metrics.AVERAGE_TIME_TO_FIRST_TOKEN, 0)
+            p99_ttft = percentile_metrics.get(PercentileMetrics.TTFT)[percentiles.index('99%')]
+            success_rate = (total_metrics.get(Metrics.SUCCEED_REQUESTS, 0)
+                            / total_metrics.get(Metrics.TOTAL_REQUESTS, 1)) * 100
+            avg_tpot = total_metrics.get(Metrics.AVERAGE_TIME_PER_OUTPUT_TOKEN, 0)
+            p99_tpot = percentile_metrics.get(PercentileMetrics.TPOT)[percentiles.index('99%')]
+
+            # Ensure all values are valid numbers
+            if any(x is None for x in [concurrency, rps, avg_latency, p99_latency, avg_tps, avg_ttft]):
+                logger.warning(f'Warning: Test results for concurrency {concurrency} contain invalid data, skipped')
+                continue
+
+            summary.append([
+                concurrency,
+                f'{rps:.2f}' if rps is not None else 'N/A',
+                f'{avg_latency:.3f}' if avg_latency is not None else 'N/A',
+                f'{p99_latency:.3f}' if p99_latency is not None else 'N/A',
+                f'{avg_tps:.2f}' if avg_tps is not None else 'N/A',
+                f'{avg_ttft:.3f}' if avg_ttft is not None else 'N/A',
+                f'{success_rate:.1f}%' if success_rate is not None else 'N/A',
+                f'{p99_ttft:.3f}' if p99_ttft is not None else 'N/A',
+                f'{avg_tpot:.3f}' if avg_tpot is not None else 'N/A',
+                f'{p99_tpot:.3f}' if p99_tpot is not None else 'N/A',
+            ])
+
+            total_tokens += total_metrics.get(Metrics.AVERAGE_OUTPUT_TOKENS_PER_REQUEST, 0) * total_metrics.get(
+                Metrics.SUCCEED_REQUESTS, 0)
+            total_time += total_metrics.get(Metrics.TIME_TAKEN_FOR_TESTS, 0)
+        except Exception as e:
+            logger.warning(
+                f"Warning: Error processing results for concurrency {result.get('concurrency', 'unknown')}: {str(e)}")
+            continue
+
+    if not summary:
+        logger.warning('Error: No valid test result data')
+        return [], 0, 0
+
+    return summary, total_tokens, total_time
+
+
+def print_summary(all_results, model_name):
+    """Print test results summary"""
+    summary, total_tokens, total_time = analyze_results(all_results)
+
+    if not summary:
+        logger.warning('No available test result data to display')
+        return
+
+    console = Console(width=100)  # Set fixed width
+
+    # Create title panel
+    title = Text('Performance Test Summary Report', style='bold')
+    console.print(Panel(title, width=60))
+
+    # Print basic information
+    basic_info = Table(show_header=False, width=60)
+    basic_info.add_column('Name', style='cyan', width=25)
+    basic_info.add_column('Value', style='green', width=35)
+
+    basic_info.add_row('Model', model_name)
+    basic_info.add_row('Total Generated', f'{total_tokens:,} tokens')
+    basic_info.add_row('Total Test Time', f'{total_time:.2f} seconds')
+    basic_info.add_row('Avg Output Rate', f'{total_tokens/total_time:.2f} tokens/sec')
+
+    console.print('\nBasic Information:')
+    console.print(basic_info)
+
+    # Create detailed performance metrics table
+    table = Table(
+        title='Detailed Performance Metrics',
+        show_header=True,
+        header_style='bold cyan',
+        border_style='blue',
+        width=100,  # Set total table width
+        pad_edge=False,  # Reduce edge padding
+        min_width=60,  # Minimum width
+    )
+
+    # Add columns (set fixed column widths)
+    table.add_column('Conc.', justify='right', style='cyan')
+    table.add_column('RPS', justify='right')
+    table.add_column('Avg Lat.(s)', justify='right')
+    table.add_column('P99 Lat.(s)', justify='right')
+    table.add_column('Gen. toks/s', justify='right')
+    table.add_column('Avg TTFT(s)', justify='right')
+    table.add_column('P99 TTFT(s)', justify='right')
+    table.add_column('Avg TPOT(s)', justify='right')
+    table.add_column('P99 TPOT(s)', justify='right')
+    table.add_column('Success Rate', justify='right', style='green')
+
+    # Add data rows
+    for row in summary:
+        try:
+            # Set row style based on success rate
+            success_rate = float(row[6].rstrip('%'))
+            row_style = 'green' if success_rate >= 95 else 'yellow' if success_rate >= 80 else 'red'
+
+            table.add_row(
+                str(row[0]),  # Concurrency
+                f'{float(row[1]):.2f}',  # RPS
+                f'{float(row[2]):.3f}',  # Average Latency
+                f'{float(row[3]):.3f}',  # P99 Latency
+                f'{float(row[4]):.2f}',  # Average TPS
+                f'{float(row[5]):.3f}',  # First Token Latency
+                f'{float(row[7]):.3f}',  # P99 TTFT
+                f'{float(row[8]):.3f}',  # Average TPOT
+                f'{float(row[9]):.3f}',  # P99 TPOT
+                row[6],  # Success Rate
+                style=row_style)
+        except ValueError as e:
+            console.print(f'Warning: Error processing row data: {str(e)}', style='bold red')
+            continue
+
+    console.print('\n')
+    console.print(table)
+
+    # Calculate and display best performance configuration
+    try:
+        best_rps_idx = np.argmax([float(row[1]) if row[1] != 'N/A' else -1 for row in summary])
+        best_latency_idx = np.argmin([float(row[2]) if row[2] != 'N/A' else float('inf') for row in summary])
+
+        perf_info = Table(title='Best Performance Configuration', show_header=False, box=None, width=60)
+        perf_info.add_column('Metric', style='cyan', width=20)
+        perf_info.add_column('Value', style='green', width=40)
+
+        perf_info.add_row('Highest RPS', f'Concurrency {summary[best_rps_idx][0]} ({summary[best_rps_idx][1]} req/sec)')
+        perf_info.add_row('Lowest Latency',
+                          f'Concurrency {summary[best_latency_idx][0]} ({summary[best_latency_idx][2]} seconds)')
+
+        console.print('\n')
+        console.print(perf_info)
+
+        # Performance recommendations
+        recommendations = []
+        if best_rps_idx == len(summary) - 1:
+            recommendations.append(
+                'The system seems not to have reached its performance bottleneck, try higher concurrency')
+        elif best_rps_idx == 0:
+            recommendations.append('Consider lowering concurrency, current load may be too high')
+        else:
+            recommendations.append(f'Optimal concurrency range is around {summary[best_rps_idx][0]}')
+
+        success_rate = float(summary[-1][6][:-1])
+        if success_rate < 95:
+            recommendations.append(
+                'Success rate is low at high concurrency, check system resources or reduce concurrency')
+
+        recommend_text = Text('\nPerformance Recommendations:', style='bold cyan')
+        console.print(recommend_text)
+        for rec in recommendations:
+            console.print(f'• {rec}', style='yellow')
+
+    except Exception as e:
+        console.print(f'Warning: Error generating performance analysis: {str(e)}', style='bold red')