chore: import upstream snapshot with attribution

python/ray/llm/_internal/serve/benchmark/turn.py

@@ -0,0 +1,75 @@
+"""Single-turn execution primitive for the benchmark.
+
+This module provides the pure core of turn execution: send an HTTP request,
+build a TurnMetric, and inject the response. It has NO side effects — callers
+are responsible for inflight tracking, metric recording, and queue management.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+import aiohttp
+
+from ray.llm._internal.serve.benchmark.http_client import send_chat_completion
+from ray.llm._internal.serve.benchmark.models import TurnMetric, TurnResult
+from ray.llm._internal.serve.benchmark.text_gen import Conversation
+
+
+@dataclass
+class TurnOutcome:
+    """Result of executing a single benchmark turn."""
+
+    metric: TurnMetric
+    result: TurnResult
+
+
+async def execute_single_turn(
+    http_session: aiohttp.ClientSession,
+    conv: Conversation,
+    turn_idx: int,
+    base_url: str,
+    model: str,
+    max_tokens: int,
+    bench_start_ns: int,
+    first_chunk_threshold: int = 16,
+    api_key: Optional[str] = None,
+) -> TurnOutcome:
+    """Execute a single benchmark turn: HTTP call, build metric, inject response.
+
+    This is the pure core shared by all three benchmark engines (concurrency,
+    rate-based, interactive). The caller handles inflight tracking, warmup
+    filtering, measurement windows, and queue re-enqueue.
+    """
+    messages = conv.get_turn_messages(turn_idx)
+    req_start_ns = time.perf_counter_ns()
+
+    result = await send_chat_completion(
+        session=http_session,
+        base_url=base_url,
+        model=model,
+        messages=messages,
+        session_id=conv.session_id,
+        max_tokens=max_tokens,
+        first_chunk_threshold=first_chunk_threshold,
+        api_key=api_key,
+    )
+
+    metric = TurnMetric(
+        session_id=conv.session_id,
+        turn=turn_idx,
+        ttft_ms=result.ttft_ms,
+        fc_ms=result.fc_ms,
+        itl_ms=result.itl_ms,
+        e2e_latency_ms=result.e2e_latency_ms,
+        input_tokens=result.input_tokens,
+        output_tokens=result.output_tokens,
+        start_time_ms=(req_start_ns - bench_start_ns) / 1e6,
+        itl_ms_list=result.itl_ms_list,
+    )
+
+    conv.inject_assistant_response(turn_idx, result.generated_text)
+
+    return TurnOutcome(metric=metric, result=result)