[V1 Engine][Metrics] Add token-level KV cache metrics

This commit adds token-level KV cache metrics to the V1 engine,
enabling more granular monitoring of KV cache utilization beyond
the existing percentage-based metrics.

This PR addresses the V1 metrics initiative mentioned in #14101.

Currently, vLLM V1 engine only provides kv_cache_usage as a float
(0.0-1.0) representing percentage. While useful, this doesn't give
users absolute token counts, which are critical for:

- Capacity Planning: Knowing "65% used" doesn't tell you when you'll run out
- Cost Accounting: Token-based billing requires absolute counts
- Metrics Collection: Prometheus/Grafana dashboards need concrete numbers
- Debugging: Understanding exact cache state during issues

Add three new fields to SchedulerStats dataclass:
- kv_cache_total_tokens: int = 0
- kv_cache_used_tokens: int = 0
- kv_cache_free_tokens: int = 0

Add get_num_total_blocks() method to BlockPool:
- Returns total GPU blocks available for allocation
- Excludes 1 block reserved for system use (-1)
- Matches internal allocation behavior

Add three read-only properties to KVCacheManager:
- total_tokens: Total capacity (num_total_blocks × block_size)
- free_tokens: Available space (num_free_blocks × block_size)
- used_tokens: Occupied space (total_tokens - free_tokens)

Update make_stats() to populate new token metrics:
- kv_cache_total_tokens from kv_cache_manager.total_tokens
- kv_cache_used_tokens from kv_cache_manager.used_tokens
- kv_cache_free_tokens from kv_cache_manager.free_tokens

- Actionable Metrics: "28k tokens left" vs "35% free"
- Prometheus Export: Direct token counts for dashboards
- Cost Attribution: Token-based billing becomes trivial
- Capacity Planning: Know exactly when to scale
- Backward Compatible: Existing code continues to work
- Minimal Overhead: Simple arithmetic, no new allocations

Before (only percentage):
```
kv_cache_usage: 0.65
```

After (percentage + tokens):
```
kv_cache_usage: 0.65
kv_cache_total_tokens: 82448
kv_cache_used_tokens: 53591
kv_cache_free_tokens: 28857
```

Now operators can see: "We have ~29k tokens left before we need to scale"

- All modified files pass Python syntax check (py_compile)
- No breaking changes to existing metrics
- New fields have default values (backward compatible)

- Closes #12283 - Add KV Cache Metrics to Usage Object
- Addresses #26850 - Add new stats metrics for available_kv_cache_memory
- Supersedes #14101 - Frontend KV cache metrics PR

Signed-off-by: dlalstjd931203 <[email protected]>
Signed-off-by: Minsung-commit <[email protected]>

Author: Minsung-commit

vllm/v1/core/block_pool.py

@@ -422,6 +422,18 @@ def get_num_free_blocks(self) -> int:
         """
         return self.free_block_queue.num_free_blocks
 
+    def get_num_total_blocks(self) -> int:
+        """Get the total number of blocks in the pool.
+
+        Returns:
+            The total number of GPU blocks available for allocation.
+
+        Note:
+            Excludes 1 block reserved for system use to match
+            internal allocation behavior.
+        """
+        return self.num_gpu_blocks - 1
+
     def get_usage(self) -> float:
         """Get the KV cache usage.
 

vllm/v1/core/kv_cache_manager.py

@@ -104,6 +104,7 @@ def __init__(
         pcp_world_size: int = 1,
     ) -> None:
         self.max_model_len = max_model_len
+        self.block_size = hash_block_size
 
         self.enable_caching = enable_caching
         self.use_eagle = use_eagle
@@ -145,6 +146,40 @@ def usage(self) -> float:
         """
         return self.block_pool.get_usage()
 
+    @property
+    def total_tokens(self) -> int:
+        """Get the total KV cache capacity in tokens.
+
+        Returns:
+            Total number of tokens that can be stored in the KV cache.
+            Calculated as: num_total_blocks × block_size
+        """
+        return self.block_pool.get_num_total_blocks() * self.block_size
+
+    @property
+    def free_tokens(self) -> int:
+        """Get the number of available tokens in the KV cache.
+
+        Returns:
+            Number of free tokens available for allocation.
+            Calculated as: num_free_blocks × block_size
+        """
+        return self.block_pool.get_num_free_blocks() * self.block_size
+
+    @property
+    def used_tokens(self) -> int:
+        """Get the number of currently used tokens in the KV cache.
+
+        Returns:
+            Number of tokens currently occupied in the KV cache.
+            Calculated as: total_tokens - free_tokens
+
+        Note:
+            This is a derived metric. The actual allocation is tracked
+            at the block level by BlockPool.
+        """
+        return self.total_tokens - self.free_tokens
+
     def make_prefix_cache_stats(self) -> PrefixCacheStats | None:
         """Get (and reset) the prefix cache stats.
 

vllm/v1/core/sched/scheduler.py

@@ -1352,6 +1352,9 @@ def make_stats(
             num_running_reqs=len(self.running),
             num_waiting_reqs=len(self.waiting),
             kv_cache_usage=self.kv_cache_manager.usage,
+            kv_cache_total_tokens=self.kv_cache_manager.total_tokens,
+            kv_cache_used_tokens=self.kv_cache_manager.used_tokens,
+            kv_cache_free_tokens=self.kv_cache_manager.free_tokens,
             prefix_cache_stats=prefix_cache_stats,
             connector_prefix_cache_stats=connector_prefix_cache_stats,
             spec_decoding_stats=spec_decoding_stats,

vllm/v1/metrics/stats.py

@@ -162,6 +162,9 @@ class SchedulerStats:
     current_wave: int = 0
 
     kv_cache_usage: float = 0.0
+    kv_cache_total_tokens: int = 0
+    kv_cache_used_tokens: int = 0
+    kv_cache_free_tokens: int = 0
 
     prefix_cache_stats: PrefixCacheStats = field(default_factory=PrefixCacheStats)
     connector_prefix_cache_stats: PrefixCacheStats | None = None