Add files using upload-large-folder tool

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__init__.py

@@ -0,0 +1,29 @@
+# Copyright 2025 The HuggingFace Inc. team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .cache import PagedAttentionCache
+from .continuous_api import ContinuousBatchingManager, ContinuousMixin
+from .requests import RequestState, RequestStatus
+from .scheduler import FIFOScheduler, PrefillFirstScheduler, Scheduler
+
+
+__all__ = [
+    "ContinuousBatchingManager",
+    "ContinuousMixin",
+    "FIFOScheduler",
+    "PagedAttentionCache",
+    "PrefillFirstScheduler",
+    "RequestState",
+    "RequestStatus",
+    "Scheduler",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache.py

@@ -0,0 +1,704 @@
+# Copyright 2025 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import inspect
+from math import floor, gcd, sqrt
+from typing import Any
+
+import torch
+
+from ...configuration_utils import PreTrainedConfig
+from ...generation.configuration_utils import ContinuousBatchingConfig
+from ...utils.generic import is_flash_attention_requested
+from ...utils.metrics import attach_tracer, traced
+from .cache_manager import BlockManager, CacheAllocator, FullAttentionCacheAllocator, SlidingAttentionCacheAllocator
+from .requests import RequestState, RequestStatus, get_device_and_memory_breakdown, logger
+
+
+def group_layers_by_attn_type(config: PreTrainedConfig) -> tuple[list[list[int]], list[str]]:
+    """
+    Group layers depending on the attention mix, according to VLLM's hybrid allocator rules:
+        - Layers in each group need to have the same type of attention
+        - All groups have the same number of layers
+
+    For a model with the following layer types: ["sliding", "full", "full", "sliding", "full", "full", "full", "full"]
+    We would get four groups: [0, 3], [1, 2], [4,5] and [6,7].
+    """
+    # If the config has no layer_type attribute, it means all layers are the same attention type
+    layer_types = getattr(config, "layer_types", None)
+    if layer_types is None:
+        attn_type = "sliding_attention" if getattr(config, "sliding_window", None) is not None else "full_attention"
+        layer_types = [attn_type for _ in range(config.num_hidden_layers)]
+
+    # We then count the number of layers of each type
+    layer_counts = {}
+    for i, layer_type in enumerate(layer_types):
+        layer_counts[layer_type] = layer_counts.get(layer_type, []) + [i]
+
+    # The size of all groups is the greatest common divisor of the number of layers of each type
+    group_size = gcd(*[len(indices) for indices in layer_counts.values()])
+
+    # We then group the layers by type
+    layer_groups = []
+    for layer_type, indices in layer_counts.items():
+        for i in range(0, len(indices), group_size):
+            layer_groups.append(indices[i : i + group_size])
+    # And note the layer types
+    group_types = [layer_types[lg[0]] for lg in layer_groups]
+    return layer_groups, group_types
+
+
+@attach_tracer()
+class PagedAttentionCache:
+    """
+    Manages the cache for a paged attention mechanism, inspired by VLLM's hybrid allocator. The cache relies on making
+    groups of layers to reduce the complexity of cache management and fragmentation.
+
+    The cache uses a three-level hierarchy:
+    - Pages: The smallest unit of cache, a page has a size of [num_heads, head_size], which is the space needed to
+        store the key or value states for one token and one layer. For a model with only full-attention layers, to store
+        the KV cache of one token, we need `2 * num_layers` pages: key and values each take `num_layers` pages.
+        Pages are grouped into blocks:
+    - Blocks: A block is a collection of `block_size` pages, serving as the allocation unit to reduce management
+        complexity and fragmentation. Cache is allocated and freed block by block, not page by page. One block is
+        allocated to one layer group, which only has one attention type, like full-attention or sliding-attention.
+        If all layers in the model have the same attention type, then all layers will be in the same group. There is
+        more than one group if and only if the model has a mixed attention types, like layers with full-attention and
+        layers with sliding-attention.
+    - Cache tensors: The physical supports for the cache. There are as many cache tensors as there are layer in a
+        layer group, and the shape of the cache tensor is `[num_blocks * block_size, num_heads, head_size]`.
+
+    Grouping layers into groups is useful because when we allocate one block to a group N, the block allocated is the
+        same for all layers in group N, equivalently it is allocated across all cache tensors. This allows us to
+        efficiently allocate and free blocks, and to efficiently read and write key and value states.
+
+    For instance, imagine we have 8 blocks of cache and a model with two layer groups: a full-attention group with 3
+    layers and a sliding-attention group with 3 layers. At creation time, the physical cache tensors look like this:
+
+    cache_tensor_0: □ □ □ □ □ □ □ □
+    cache_tensor_1: □ □ □ □ □ □ □ □
+    cache_tensor_2: □ □ □ □ □ □ □ □
+
+    where □ means the blocks is not allocated to any layer group yet. We have 3 cache tensors because there are
+    3 layers per group.
+    We allocate 1 block to each group, after allocation, the cache tensors look like this:
+
+    cache_tensor_0: ✖ ◉ □ □ □ □ □ □
+    cache_tensor_1: ✖ ◉ □ □ □ □ □ □
+    cache_tensor_2: ✖ ◉ □ □ □ □ □ □
+
+    where ✖ means the block is allocated to the full-attention group, and ◉ means the block is allocated to the
+    sliding-attention group.
+    Now, if we continue to generate, and the sliding window has been reached, we only need to allocate a new block
+    for the full-attention group, and the cache tensors look like this:
+
+    cache_tensor_0: ✖ ◉ ✖ □ □ □ □ □
+    cache_tensor_1: ✖ ◉ ✖ □ □ □ □ □
+    cache_tensor_2: ✖ ◉ ✖ □ □ □ □ □
+
+    And after further generation, when we need a new block allocated:
+
+    cache_tensor_0: ✖ ◉ ✖ ✖ □ □ □ □
+    cache_tensor_1: ✖ ◉ ✖ ✖ □ □ □ □
+    cache_tensor_2: ✖ ◉ ✖ ✖ □ □ □ □
+
+    This would not have been possible if all layers were in the same group: we would have had to allocate a new block
+    for the sliding-attention group, although it is not needed.
+    """
+
+    def __init__(
+        self,
+        config: PreTrainedConfig,
+        continuous_batching_config: ContinuousBatchingConfig,
+        device: torch.device | str,
+        dtype: torch.dtype = torch.float16,
+        tp_size: int | None = None,
+    ) -> None:
+        """Initialize a paged attention cache for efficient memory usage. Also turns in prefix sharing if the model has
+        only full attention layers.
+
+        Args:
+            config: Model configuration
+            continuous_batching_config: Continuous batching configuration containing cache parameters
+            device: Device for the cache tensors
+            dtype: Data type of the cache
+            tp_size: Tensor parallelism size
+        """
+        self.config = config
+        self.dtype = dtype
+        self.device = device
+
+        # Extract model dimensions
+        kv_heads = getattr(config, "num_key_value_heads", None)
+        self.num_key_value_heads: int = kv_heads if kv_heads is not None else config.num_attention_heads
+        head_dim = getattr(config, "head_dim", None)
+        self.head_dim: int = head_dim if head_dim is not None else config.hidden_size // config.num_attention_heads
+
+        # Extract cache dimensions. Default used to be 32, now it's 256 to be compatible with flash_with_kvcache.
+        self.block_size = continuous_batching_config.block_size
+        if self.block_size <= 0:
+            raise ValueError(f"Block size must be positive, but got {self.block_size}")
+
+        # Group layers depending on the attention mix
+        layer_groups, group_types = group_layers_by_attn_type(config)
+        group_size = len(layer_groups[0])
+        self.num_groups = len(layer_groups)
+
+        self.sliding_windows = {}
+        self.layer_index_to_group_indices = {}
+        for i, group in enumerate(layer_groups):
+            sliding_window = config.sliding_window if group_types[i] == "sliding_attention" else 1
+            for j, layer in enumerate(group):
+                self.layer_index_to_group_indices[layer] = (i, j)
+                self.sliding_windows[layer] = sliding_window
+
+        # Handle TP (or dont)
+        if tp_size is not None and tp_size > 1:
+            if self.num_key_value_heads % tp_size != 0:
+                raise ValueError(
+                    f"Number of key value heads {self.num_key_value_heads} must be divisible by tensor parallel size {tp_size}."
+                )
+            # If the model is using tensor parallelism, we need to adjust the number of heads accordingly.
+            # self.num_key_value_heads //= tp_size # TODO: why is this commented out?
+
+        # Infer number of blocks and max batch tokens
+        page_size = self.head_dim * self.num_key_value_heads
+
+        if is_flash_attention_requested(self.config):
+            num_attention_masks = 0  # only used to compute the default memory footprint args
+        elif "sliding_attention" in group_types:
+            # TODO: when we generalize to allow for block-attn, we can use `num_attention_masks=sum(set(group_types))`
+            num_attention_masks = 2
+        else:
+            num_attention_masks = 1
+
+        # Peak activations coefficients (for number of blocks and number of batch tokens)
+        q_bytes_per_token = config.num_attention_heads * self.head_dim
+        lm_head_peak = (
+            0,  # number of blocks does not affect the LM head peak activation
+            config.hidden_size + 2 * config.vocab_size,  # hidden states + logits
+        )
+        attention_peak = (
+            2 * page_size,  # old K and V, read from cache (in the worst case scenario: whole cache is read)
+            config.hidden_size + q_bytes_per_token + 2 * page_size,  # hidden state + Q + new K and V
+        )
+
+        memory_handler = PagedAttentionMemoryHandler(
+            continuous_batching_config=continuous_batching_config,
+            page_size=page_size,
+            num_groups=self.num_groups,
+            group_size=group_size,
+            activation_peaks=[lm_head_peak, attention_peak],
+            num_attention_masks=num_attention_masks,
+        )
+
+        # If somehow the max memory percent is not yet resolved, resolve it conservatively
+        if continuous_batching_config.max_memory_percent is None:
+            continuous_batching_config.resolve_max_memory_percent(has_logit_processors=True)
+
+        num_blocks, max_batch_tokens = memory_handler.infer_num_blocks_and_max_batch_tokens(
+            num_blocks=continuous_batching_config.num_blocks,
+            max_batch_tokens=continuous_batching_config.max_batch_tokens,
+            max_memory_percent=continuous_batching_config.max_memory_percent,
+            cache_dtype=self.dtype,
+        )
+
+        # Add the inferred attributes to the class
+        self.num_blocks = num_blocks
+        self.max_batch_tokens = max_batch_tokens
+        self.num_pages = self.num_blocks * self.block_size
+        logger.info(
+            f"PagedAttentionCache initialized with {self.num_blocks = }, {self.block_size = }, {page_size = }, "
+            f"{self.max_batch_tokens = } {num_attention_masks = }"
+        )
+
+        # If max_blocks_per_request is not set, the default value is 16 max blocks. With default block size of 256, this
+        # means a max sequence length of 4096 tokens for the fast decode path.
+        max_blocks_per_request = continuous_batching_config.max_blocks_per_request
+        if max_blocks_per_request is None:
+            max_blocks_per_request = 0
+            # logger.info( TODO: uncomment when we have good defaults
+            #     f"max_blocks_per_request was not set, using {max_blocks_per_request}. This means max sequence "
+            #     f"length for the decode fast path is {max_blocks_per_request * self.block_size}."
+            # )
+        self.max_blocks_per_request = max_blocks_per_request
+
+        # Initialize the cache
+        self.key_cache: list[torch.Tensor] = []
+        self.value_cache: list[torch.Tensor] = []
+        # We add two extra blocks to the cache as a padding zone that no BlockManager ever allocates from: one for the
+        # sentinel index (marks the spot of a new token in the read indices) and one for the trash index (for padding,
+        # block is never used so writes are silently discarded)
+        self.cache_shape = ((num_blocks + 2) * self.block_size, self.num_key_value_heads, self.head_dim)
+        self.sentinel_index = self.cache_shape[0] - 1
+        self.trash_index = self.sentinel_index - 1
+        for _ in range(group_size):
+            new_layer_key_cache = torch.empty(self.cache_shape, dtype=self.dtype, device=self.device)
+            new_layer_value_cache = torch.empty(self.cache_shape, dtype=self.dtype, device=self.device)
+            torch._dynamo.mark_static_address(new_layer_key_cache)
+            torch._dynamo.mark_static_address(new_layer_value_cache)
+            self.key_cache.append(new_layer_key_cache)
+            self.value_cache.append(new_layer_value_cache)
+        logger.info(f"{self.cache_shape = } {self.key_cache[0].shape = } {self.key_cache[0].numel() = }")
+
+        # Block management data structures
+        self.allow_block_sharing = continuous_batching_config.allow_block_sharing
+        self.group_cache_managers: list[CacheAllocator] = []
+        self.num_full_attention_groups = 0
+        self.num_sliding_attention_groups = 0
+        self.max_sliding_window_blocks_per_request = 0
+
+        for i, group_type in enumerate(group_types):
+            if group_type == "full_attention":
+                cm = FullAttentionCacheAllocator(i, self.block_size, allow_block_sharing=self.allow_block_sharing)
+                self.num_full_attention_groups += 1
+            elif group_type == "sliding_attention":
+                cm = SlidingAttentionCacheAllocator(
+                    i, self.block_size, config.sliding_window, self.sentinel_index, self.trash_index
+                )
+                self.num_sliding_attention_groups += 1
+                self.max_sliding_window_blocks_per_request = cm._max_blocks_per_request
+            else:
+                raise ValueError(f"Invalid group type: {group_type}")
+            self.group_cache_managers.append(cm)
+
+        # We only use prefix sharing if the whole model has only full attention layers and block sharing is allowed
+        self.use_prefix_sharing = self.allow_block_sharing and group_types == ["full_attention"]
+        self._block_manager = BlockManager(num_blocks, self.block_size)
+        self._total_prefix_length: int = 0  # a counter to measure the impact of prefix sharing, also used in tests
+
+        # For block table support, we lazy init the name of the block table key
+        self._block_table_key = None
+
+    def will_allocation_be_successful(self, num_requested_blocks: int, allocated_blocks: int) -> bool:
+        """Returns a boolean indicating if the allocation of (num_requested_blocks) blocks will be successful. The
+        number of newly allocated blocks needed is predicted by the following rules:
+        - for full attention groups: since there is no sliding window for full attention layers, one requested block is
+            always equivalent to one newly allocated block for EACH full attention group
+        - for sliding window groups: because of the sliding window, the number of blocks allocated to a request is
+            capped. Using the number of already (allocated_blocks) we can compute the number of new blocks to actually
+            allocate to the request, which can be lower than the number of requested blocks. That number is the same for
+            all sliding window groups, as only one sliding window size is supported.
+        """
+        # This is not in a branch, because it is very rare to have zero full attention layer
+        needed_blocks = num_requested_blocks * self.num_full_attention_groups
+        # Only take this branch if the model has sliding window attention layers
+        if self.num_sliding_attention_groups:
+            blocks_left = max(self.max_sliding_window_blocks_per_request - allocated_blocks, 0)
+            needed_blocks += min(blocks_left, num_requested_blocks) * self.num_sliding_attention_groups
+        return needed_blocks <= self.get_num_free_blocks()
+
+    @traced
+    def allocate_blocks(self, n_blocks: int, request_id: str, allocated_blocks: int) -> int | None:
+        """Allocate cache blocks across all layer groups for a given request. Actual allocation is done by the cache
+        managers, and this method only returns the maximum number of blocks actually allocated across all managers."""
+        # First check allocation will be successful before starting, to avoid partial allocations
+        if not self.will_allocation_be_successful(n_blocks, allocated_blocks):
+            return None
+        # Allocate blocks across all cache managers
+        max_allocated = 0
+        for cm in self.group_cache_managers:
+            num_allocated_blocks = cm.allocate_blocks(n_blocks, request_id, self._block_manager)
+            if num_allocated_blocks is None:
+                raise ValueError(f"Failed to allocate {n_blocks} blocks for request {request_id}")
+            max_allocated = max(max_allocated, num_allocated_blocks)
+        return max_allocated
+
+    @traced
+    def free_blocks(self, request_id: str) -> None:
+        """Free all allocated cache blocks for a given request across all layer groups. Actual deallocation is done
+        by the cache managers."""
+        for cm in self.group_cache_managers:
+            cm.free_blocks(request_id, self._block_manager)
+
+    def get_num_free_blocks(self) -> int:
+        """Get the current number of unallocated blocks available for new requests."""
+        return self._block_manager.num_free_blocks
+
+    @traced
+    def extend_read_and_write_indices(
+        self,
+        request_id: str,
+        past_length: int,
+        query_length: int,
+        read_index: list[list[int]] | None,
+        write_index: list[list[int]],
+    ) -> None:
+        """Retrieve physical cache indices for reading KV states in the cache across all layer groups. This method
+        coordinates with all cache managers to build the complete set of read indices needed for attention computation.
+        When read_index is None, the batch has no cache reads and we only compute the write indices.
+        """
+        # Write indices are always computed
+        for cm, write_indices in zip(self.group_cache_managers, write_index):
+            write_indices.extend(cm.get_write_indices(request_id, past_length, query_length))
+        # Read indices are only computed if there are cache indices
+        if read_index is not None:
+            for cm, read_indices in zip(self.group_cache_managers, read_index):
+                read_indices.extend(cm.get_read_indices(request_id, past_length, query_length))
+
+    def fill_block_table(
+        self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor
+    ) -> None:
+        for i, cm in enumerate(self.group_cache_managers):
+            cm.fill_block_table(request_id, past_length, query_length, block_table[i])
+
+    @traced
+    def get_seqlens_k(self, past_length: int, query_length: int) -> dict[str, int]:
+        """Retrieve the key sequence length for the given request_id across all layer types. Returns a dictionary of
+        layer types to their corresponding key sequence lengths."""
+        seqlens_k = {}
+        if self.num_full_attention_groups > 0:
+            seqlens_k["full_attention"] = past_length + query_length
+        if self.num_sliding_attention_groups > 0:
+            seqlens_k["sliding_attention"] = query_length + min(past_length, self.config.sliding_window - 1)
+        # NOTE: when we add more attention types / different sliding windows, we can go back to looping over CMs
+        return seqlens_k
+
+    @traced
+    def update(
+        self,
+        key_states: torch.Tensor,  # shape [1, num_kv_heads, seqlen_kv, head_dim]
+        value_states: torch.Tensor,  # shape [1, num_kv_heads, seqlen_kv, head_dim]
+        layer_idx: int,
+        read_index: list[torch.Tensor],  # shape [num_layer_groups, seqlen_kv + past_length]
+        write_index: list[torch.Tensor],  # shape [num_layer_groups, seqlen_q]
+    ) -> tuple[torch.Tensor, torch.Tensor]:  # shape [seqlen_kv + past_length, num_kv_heads, head_dim]
+        """Update the cache with new key-value states for a specific layer, and retrieves the relevant KV states from
+        the cache for attention computation. The behavior differs based on the layer's attention type:
+
+        - Full attention: New KV states are written to cache, then complete sequence is read from cache
+        - Sliding window: Old KV is read from cache along with extra spaces for the new KV, then new KV is written to
+            cache. This is because new KV might overwrite the old KV, so we need to read the old KV first.
+
+        When the layer's read index is empty, the batch has no cache reads (all requests are non-chunked prefills): we
+        only write to the cache and return the input KV states directly, skipping the index_select read-back.
+
+        Returns the complete KV states (cached + new) for attention computation.
+        """
+        # Retrieve the layer write index and the relevant cache tensors
+        group_idx, layer_idx_in_group = self.layer_index_to_group_indices[layer_idx]
+        layer_read_index = read_index[group_idx]
+        layer_write_index = write_index[group_idx]
+        k_cache = self.key_cache[layer_idx_in_group]
+        v_cache = self.value_cache[layer_idx_in_group]
+        # Transpose the key and value states to match the cache shape, after which shape is [seqlen_kv, num_kv_heads, head_dim]
+        key_states = key_states.transpose(1, 2).squeeze(0)
+        value_states = value_states.transpose(1, 2).squeeze(0)
+
+        # Case: write-only, no cache read. The input KV states already contain everything the attention needs.
+        if layer_read_index.numel() == 0:
+            k_cache.index_copy_(0, layer_write_index, key_states)
+            v_cache.index_copy_(0, layer_write_index, value_states)
+            return key_states, value_states
+
+        # Case: full attention
+        sliding_window = self.sliding_windows[layer_idx]
+        if sliding_window == 1:
+            k_cache.index_copy_(0, layer_write_index, key_states)
+            v_cache.index_copy_(0, layer_write_index, value_states)
+            key_states_with_cache = torch.index_select(k_cache, 0, layer_read_index)
+            value_states_with_cache = torch.index_select(v_cache, 0, layer_read_index)
+
+        # Case: sliding window -- we  need to be careful of read/write order because of chunked prefill, because it's
+        # the only case where you may write over cache you need to use
+        else:
+            # Sentinel positions in read_index mark new-token slots; index_select reads garbage there,
+            # then masked_scatter_ overwrites them with the actual new key/value states.
+            mask = (layer_read_index == self.sentinel_index).unsqueeze(-1).unsqueeze(-1)
+            key_states_with_cache = torch.index_select(k_cache, 0, layer_read_index)
+            key_states_with_cache.masked_scatter_(mask, key_states)
+            value_states_with_cache = torch.index_select(v_cache, 0, layer_read_index)
+            value_states_with_cache.masked_scatter_(mask, value_states)
+            # Write new KV values to the cache (padding slots in write_index point to the trash position)
+            k_cache.index_copy_(0, layer_write_index, key_states)
+            v_cache.index_copy_(0, layer_write_index, value_states)
+
+        # Return the new KV values
+        return key_states_with_cache, value_states_with_cache
+
+    def get_block_table_key(self, flash_attn_with_kvcache_fn: Any) -> str:
+        """A function to get the name of the block table key for the given flash_attn_with_kvcache_fn. The function's
+        signature is only inspected once. This is necessary because different version of flash have different names for
+        the block table key."""
+        if self._block_table_key is None:
+            kwarg_names = inspect.signature(flash_attn_with_kvcache_fn).parameters.keys()
+            if "block_table" in kwarg_names:
+                self._block_table_key = "block_table"
+            elif "page_table" in kwarg_names:
+                self._block_table_key = "page_table"
+            else:
+                raise ValueError(
+                    f"flash_attn_with_kvcache_fn does not have a block_table or page_table argument: {inspect.signature(flash_attn_with_kvcache_fn)}"
+                )
+        return self._block_table_key
+
+    def search_prefix_match(self, request_id: str, prompt_ids: list[int]) -> int:
+        """Searches for a prefix match in the cache for the given (prompts_ids). If one is found, we reference the
+        matching blocks in the (request_id), increase the reference count of the blocks and return the number of blocks
+        that match. If no prefix match is found, we return 0."""
+        current_hash = None
+        allocated_blocks = []
+        for b in range(len(prompt_ids) // self.block_size):
+            tokens = prompt_ids[b * self.block_size : (b + 1) * self.block_size]
+            # Prefix sharing is only supported when there is only one full attention layer group, so group_id=0.
+            current_hash = self._block_manager.compute_hash(current_hash, tokens, group_id=0)
+            block_id = self._block_manager._hash_to_id.get(current_hash)
+            if block_id is not None:
+                allocated_blocks.append(block_id)
+                self._block_manager.increase_ref_count(block_id)
+            else:
+                break
+        # If we found a matching prefix, we reference the blocks in the request
+        if allocated_blocks:
+            logger.debug(f"Found prefix match for request {request_id} with {len(allocated_blocks)} blocks")
+            cm = self.group_cache_managers[0]
+            cm.block_table[request_id] = allocated_blocks
+
+        prefix_length = len(allocated_blocks) * self.block_size
+        self._total_prefix_length += prefix_length
+        return prefix_length
+
+    def mark_shareable_blocks_as_complete(self, state: RequestState, num_complete_blocks: int) -> None:
+        """Marks the blocks allocated to a request (state) as complete if they are shareable and they have been computed
+        in the forward pass. A complete block is a block where the KV cache has been fully computed: if the block has
+        enough space to hold the cache for N tokens, the block is marked as complete when the cache data is present for
+        the N tokens. If block sharing is off, this is a no-op."""
+        # The status can be FINISHED in async mode, because batch N+1 offloaded the request before batch N was over. So
+        # we need to check for this case to avoid looking in the block table for blocks that no longer exist.
+        if num_complete_blocks == 0 or state.status == RequestStatus.FINISHED:
+            return None
+        for cm in self.group_cache_managers:
+            if cm.uses_block_sharing:
+                self._block_manager.mark_shareable_blocks_as_complete(
+                    num_complete_blocks=num_complete_blocks,
+                    allocated_blocks=cm.block_table[state.request_id],
+                    prompt_ids=(state.initial_tokens + state.generated_tokens),
+                )
+
+    def copy_cache(self, list_source_blocks: list[int], list_forked_blocks: list[int]) -> None:
+        """Copy the cache from the source blocks to the forked blocks."""
+        source_blocks = torch.tensor(list_source_blocks, device=self.device, dtype=torch.int32)
+        forked_blocks = torch.tensor(list_forked_blocks, device=self.device, dtype=torch.int32)
+        for key_cache, value_cache in zip(self.key_cache, self.value_cache):
+            key_cache = key_cache.view(-1, self.block_size, self.num_key_value_heads, self.head_dim)
+            value_cache = value_cache.view(-1, self.block_size, self.num_key_value_heads, self.head_dim)
+            key_cache[forked_blocks] = key_cache[source_blocks]
+            value_cache[forked_blocks] = value_cache[source_blocks]
+        # FIXME: consolidate the cache into a single tensor of shape (group_size, 2, *self.k_or_v_cache_shape)
+        # This will allow for  better .update and a single copy instead of one per cache tensor
+
+    def fork_request(self, source_request_id: str, destination_request_ids: list[str]) -> tuple[list[int], list[int]]:
+        """Fork the cache of a request (state) into the one of a list of requests with the given (dst_request_ids)."""
+        # These lists will be the accumulators for the source and destination blocks for the cache copy
+        source_blocks, destination_blocks = [], []
+        # Main fork loop
+        for cm in self.group_cache_managers:
+            src_blocks, dst_blocks = cm.fork_blocks(source_request_id, destination_request_ids, self._block_manager)
+            source_blocks.extend(src_blocks)
+            destination_blocks.extend(dst_blocks)
+        return source_blocks, destination_blocks
+
+    def free_all_requests(self) -> None:
+        """Free all blocks allocated to requests across all cache managers. This preserves prefix hashes in the block
+        manager (blocks become initialized rather than uninitialized if they were complete), allowing prefix sharing
+        to work across generation sessions."""
+        all_request_ids = set()
+        for cm in self.group_cache_managers:
+            all_request_ids.update(cm.block_table.keys())
+        for request_id in all_request_ids:
+            self.free_blocks(request_id)
+
+
+# TODO: rework computation with the groups and their sizes
+class PagedAttentionMemoryHandler:
+    """Determines the optimal number of pages (N) and max batch tokens (M) for the paged attention cache, given
+    available GPU memory. The relation between N and number of blocks is: num_blocks = N // block_size.
+
+    The memory footprint is a polynomial in N and M, where each term maps to a tensor allocated in
+    ``ContinuousBatchingIOs._setup_static_tensors`` or ``PagedAttentionCache.__init__``:
+
+        memory(N, M)  =  coeff_n · N  +  coeff_m · M  +  coeff_nm · N·M  +  coeff_mm · M²
+
+    See ``_equation_coefficients`` for the breakdown.  All three solving modes (auto, fixed-N, fixed-M) reduce to
+    solving this equation, which is at most quadratic in one variable.
+    """
+
+    _activation_dtype = torch.bfloat16
+    _input_dtype = torch.int32
+    _upper_bound_max_batch_tokens = 1024
+    _upper_bound_num_blocks = 4096
+
+    def __init__(
+        self,
+        continuous_batching_config: ContinuousBatchingConfig,
+        page_size: int,
+        num_groups: int,
+        group_size: int,
+        activation_peaks: list[tuple[int, int]],
+        num_attention_masks: int,
+    ) -> None:
+        """Initialize the memory handler. `activation_peaks` is a list of `(Δcn, Δcm)` pairs giving the activation memory
+        contributions proportional to N (pages) and M (batch tokens) for each peak. Memory must satisfy the constraint
+        at every peak, so we solve each polynomial independently and take the most restrictive result."""
+        self.block_size = continuous_batching_config.block_size
+        self.page_size = page_size
+        self.num_groups = num_groups
+        self.group_size = group_size
+        self.activation_peaks = activation_peaks
+        self.num_attention_masks = num_attention_masks
+        self.max_blocks_per_request = continuous_batching_config.max_blocks_per_request
+        if self.max_blocks_per_request is None:
+            self.max_blocks_per_request = continuous_batching_config.fallback_max_blocks_per_request
+        # This is the number of output rows for the output_ids tensor
+        self.num_output_rows = 2 if continuous_batching_config.return_logprobs else 1
+        # This account for the set of 2 IOs if async batching is used
+        self.io_multiplier = 2 if continuous_batching_config.use_async_batching else 1
+
+    @staticmethod
+    def get_available_memory(max_memory_percent: float = 1.0) -> int:
+        """Calculate available GPU memory for cache allocation, accounting for already allocated tensors."""
+        _, total, reserved, allocated = get_device_and_memory_breakdown()
+        available_memory = total - max(allocated, reserved)
+        available_memory = int(available_memory * max_memory_percent)
+        return available_memory
+
+    # Formatting is disabled because of comment indentation, which improves readability.
+    # fmt: off
+    def _equation_coefficients(
+        self, peak: tuple[int, int], cache_dtype: torch.dtype
+    ) -> tuple[int, int, int, int]:
+        """Returns `(coeff_n, coeff_m, coeff_nm, coeff_mm)` for the memory polynomial of a single activation peak.
+        `peak = (Δcn, Δcm)` is the peak-specific activation contribution; the rest of the coefficients are shared
+        across peaks. Each addend is annotated with the tensor it corresponds to in
+        `ContinuousBatchingIOs._setup_static_tensors` (or the forward pass, for activation terms).
+        """
+        i = self._input_dtype.itemsize       # int32
+        a = self._activation_dtype.itemsize  # bfloat16
+        c = cache_dtype.itemsize
+        k = self.io_multiplier               # 1 sync, 2 async (IO tensors only)
+        delta_n, delta_m = peak
+
+        # -- N terms: cost per cache page --------------------------------------------------
+        coeff_n = (
+            2 * self.group_size * self.page_size * c   # kv_cache: 2 * group_size * [N, page_size] * cache_dtype
+            + k * self.num_groups * 8                  # read_index: [num_groups, N + M]  (N part only, int64)
+            + delta_n * a                              # activation peak: N-proportional part
+        )
+        # -- M terms: cost per batch token -------------------------------------------------
+        coeff_m = (
+            delta_m * a                                # activation peak: M-proportional part
+            + k * 7 * i                                # bulk_input: [7, M] int32, packed as 7 rows
+            + k * self.num_output_rows * i             # output_ids: [num_output_rows, M] int32
+            + k * self.num_groups                      # block_table: [bt_groups, M, max_blocks_per_req] int32
+            * self.max_blocks_per_request * i          #   (zero when fast-decode is off)
+            + k * self.num_groups * 8                  # write_index: [num_groups, M] int64
+            + k * self.num_groups * 8                  # read_index: [num_groups, N + M] (M part only, int64)
+        )
+        # -- N·M terms: cost per (page × batch token) --------------------------------------
+        coeff_nm = k * self.num_attention_masks * a    # attention_mask: [1, 1, M, N + M] (N·M part only)
+        # -- M² terms: cost per (batch token squared) --------------------------------------
+        coeff_mm = k * self.num_attention_masks * a    # attention_mask: [1, 1, M, N + M] (M² part only)
+
+        return coeff_n, coeff_m, coeff_nm, coeff_mm
+    # fmt: on
+
+    @staticmethod
+    def _solve_quadratic(a: float, b: float, c: float) -> float:
+        """Largest positive root of a·x² + b·x + c = 0. Falls back to linear when a == 0."""
+        if a == 0:
+            return -c / b
+        discriminant = b**2 - 4 * a * c
+        if discriminant < 0:
+            raise ValueError(f"No real solution (discriminant = {discriminant})")
+        root = (-b + sqrt(discriminant)) / (2 * a)
+        if root < 0:
+            raise ValueError(f"No positive solution (root = {root})")
+        return root
+
+    def _solve_for_peak(
+        self,
+        peak: tuple[int, int],
+        available: int,
+        num_blocks: int | None,
+        max_batch_tokens: int | None,
+        cache_dtype: torch.dtype,
+    ) -> tuple[int, int]:
+        """Solve for `(num_blocks, max_batch_tokens)` against one activation peak's memory polynomial. Clamps to upper
+        bounds. Either input may be None; whichever is None is solved for."""
+        cn, cm, cnm, cmm = self._equation_coefficients(peak, cache_dtype)
+
+        if num_blocks is None and max_batch_tokens is None:
+            # Substitute M = m·N → (coeff_nm·m + coeff_mm·m²)·N² + (coeff_n + coeff_m·m)·N − avail = 0
+            m = 0.01
+            num_pages = self._solve_quadratic(cnm * m + cmm * m**2, cn + cm * m, -available)
+            max_batch_tokens = int(num_pages * m)
+            if max_batch_tokens > self._upper_bound_max_batch_tokens:
+                max_batch_tokens = self._upper_bound_max_batch_tokens
+                # If max_batch_tokens is clamped, we recompute num_blocks below to get a higher value
+                num_blocks = None
+            else:
+                num_blocks = min(floor(num_pages) // self.block_size, self._upper_bound_num_blocks)
+
+        if num_blocks is None:
+            # M given → linear in N: (coeff_n + coeff_nm·M)·N = avail − coeff_m·M − coeff_mm·M²
+            M = max_batch_tokens
+            num_pages = floor((available - cm * M - cmm * M**2) / (cn + cnm * M))
+            num_blocks = min(num_pages // self.block_size, self._upper_bound_num_blocks)
+        elif max_batch_tokens is None:
+            # N given → quadratic in M: coeff_mm·M² + (coeff_m + coeff_nm·N)·M + (coeff_n·N − avail) = 0
+            N = num_blocks * self.block_size
+            M = self._solve_quadratic(cmm, cm + cnm * N, cn * N - available)
+            max_batch_tokens = min(floor(M), self._upper_bound_max_batch_tokens)
+
+        return num_blocks, max_batch_tokens
+
+    def infer_num_blocks_and_max_batch_tokens(
+        self,
+        num_blocks: int | None = None,
+        max_batch_tokens: int | None = None,
+        max_memory_percent: float = 0.9,
+        cache_dtype: torch.dtype = torch.float16,
+    ) -> tuple[int, int]:
+        """Solve for the missing variable(s) in the memory polynomial (see ``_equation_coefficients``). There is one
+        polynomial per activation peak; we solve each independently and take the most restrictive (smallest) result.
+        When both `N` and `M` are unknown, assumes `M = m·N` (m = 0.01, i.e. one batch fills ~1 % of the cache) and
+        solves the resulting quadratic in N.
+        """
+        available = self.get_available_memory(max_memory_percent)
+        logger.info(f"Cache memory: {available}")
+        # Solve each peak independently, then take the element-wise min (tightest constraint wins)
+        acc_num_blocks = float("inf")
+        acc_max_batch_tokens = float("inf")
+        for peak in self.activation_peaks:
+            n_blocks, m_batch_tokens = self._solve_for_peak(peak, available, num_blocks, max_batch_tokens, cache_dtype)
+            acc_num_blocks = min(acc_num_blocks, n_blocks)
+            acc_max_batch_tokens = min(acc_max_batch_tokens, m_batch_tokens)
+        # Now update the value (cannot update in loop, it would overwrite the user-passed values)
+        num_blocks, max_batch_tokens = acc_num_blocks, acc_max_batch_tokens
+        # Validate
+        memory_footprint = self.compute_memory_footprint(num_blocks, max_batch_tokens, cache_dtype)
+        if memory_footprint > available:
+            raise MemoryError(f"Memory footprint {memory_footprint} is more than available memory {available}")
+        return num_blocks, max_batch_tokens
+
+    def compute_memory_footprint(self, num_blocks: int, max_batch_tokens: int, cache_dtype: torch.dtype) -> int:
+        """Evaluate the memory polynomial at concrete (N, M) values, taking the max across activation peaks."""
+        N = num_blocks * self.block_size
+        M = max_batch_tokens
+
+        max_memory_footprint = 0
+        for peak in self.activation_peaks:
+            cn, cm, cnm, cmm = self._equation_coefficients(peak, cache_dtype)
+            memory_footprint = cn * N + cm * M + cnm * N * M + cmm * M * M
+            max_memory_footprint = max(max_memory_footprint, memory_footprint)
+        return max_memory_footprint

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache_manager.py

@@ -0,0 +1,533 @@
+# Copyright 2025 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from abc import ABC, abstractmethod
+from collections import deque
+from collections.abc import Iterator
+from math import ceil
+from typing import TypeVar
+
+import torch
+
+from .requests import logger
+
+
+T = TypeVar("T")
+
+
+def reverse_enumerate(xs: list[T]) -> Iterator[tuple[int, T]]:
+    index = len(xs) - 1
+    for x in xs[::-1]:
+        yield index, x
+        index -= 1
+
+
+class Block:  # TODO: rename to ShareableBlock and update the docs
+    """A class to represent a block managed by the block manager. We say that a block is complete when the physical KV
+    cache it points to is fully computed. A block can have a parent, which is the block that came before in the
+    sequence. Once a block is complete, it is given a hash, which takes into account the tokens ids of the block, the
+    layer (group_id) it belong to and its parent's hash (if there is a parent)."""
+
+    def __init__(self, id_: int, parent_id: int | None, group_id: int) -> None:
+        self.id: int = id_
+        self.parent_id: int | None = parent_id
+        self.group_id: int = group_id
+        self.hash: int | None = None
+        self.ref_count: int = 1
+
+    def __repr__(self) -> str:
+        return f"Block(id={self.id}, parent_id={self.parent_id}, group_id={self.group_id}, hash={self.hash}, ref_count={self.ref_count})"
+
+    @property
+    def is_complete(self) -> bool:
+        return self.hash is not None
+
+
+class BlockManager:
+    """A class to manage the number of free blocks and block re-use. When a block becomes in use, a flag is passed to
+    determine if the block is shareable or not. If it is, then a Block object is created and kept track of internally.
+    It can have the following states:
+      - in use: one or more requests references this block, thus it cannot be written over. The number of requests
+        referencing this block is stored as ref_count in the Block object.
+      - un-initialized: the block points to a space in the KV cache tensor that contains no data yet. Those blocks can
+        be given as free blocks to new requests without any overhead.
+      - initialized: the block is complete and was used by one or more request that are finished. It contains KV cache
+        data and its hash is stored in the hash table. If a new request needs a block with the same hash, we increase
+        the ref_count of the block and remove it from the list of initialized blocks, because it is now in use.
+        Still, the block can be freed if no un-initialized blocks are left. In that case, we remove its hash from the
+        hash table.
+    If the block is not shareable, we just use the block manager as a FIFO structure where blocks are either free or in
+    use. Sharability is determined by the type of cache allocator: blocks created for full attention layers are
+    shareable, while blocks created for sliding window attention layers are not.
+    There is no structure to keep track of the blocks in use: if a block is neither un-initialized nor initialized,
+    it is in use.
+    """
+
+    def __init__(self, num_blocks: int, block_size: int) -> None:
+        """Initializes the block manager with a given number of blocks (num_blocks) of size (block_size)."""
+        self.num_blocks = num_blocks
+        self.block_size = block_size
+        self._uninit_block_ids = deque(range(num_blocks))
+        self._init_block_ids: dict[int, None] = {}  # effectively act as an ordered set
+        self._hash_to_id: dict[int, int] = {}
+        self._id_to_block: dict[int, Block] = {}
+
+    @property
+    def num_free_blocks(self) -> int:
+        """Returns the number of free blocks left. Both initialized and uninitialized blocks are considered free."""
+        return len(self._uninit_block_ids) + len(self._init_block_ids)
+
+    def has_enough_free_blocks(self, n_blocks: int) -> bool:
+        """Checks if there are enough free blocks to allocate the requested number of blocks (n_blocks). If there are
+        not enough uninitialized blocks, we uninitialize the required number of initialized blocks."""
+        # Exit early if there are enough uninitialized blocks
+        if len(self._uninit_block_ids) >= n_blocks:
+            return True
+        # Exit early if even after uninitializing all initialized blocks, there are not enough free blocks
+        block_to_uninitialize = n_blocks - len(self._uninit_block_ids)
+        if len(self._init_block_ids) < block_to_uninitialize:
+            return False
+        # Uninitialize the required amount of blocks
+        for _ in range(block_to_uninitialize):
+            id_to_uninitialize = self._init_block_ids.popitem()[0]
+            block = self._id_to_block[id_to_uninitialize]
+            # Since the block is initialized it must have a hash, thus no need to check .hash is not None
+            self._hash_to_id.pop(block.hash)  # ty:ignore[invalid-argument-type]
+            self._uninit_block_ids.append(id_to_uninitialize)
+        return True
+
+    def get_free_blocks(
+        self, n_blocks: int, last_block_id: int | None, shareable: bool, group_id: int
+    ) -> list[int] | None:
+        """Returns a list of (n_blocks) free block and mark them as no longuer free in the internal data structures.
+        If the (shareable) flag is set to True, a Block object is created to keep track of the block, with the
+        (last_block_id) to indicate the last block id in the sequence, also named the parent block. If the manager
+        cannot find enough free blocks, it returns None."""
+        if not self.has_enough_free_blocks(n_blocks):
+            return None
+        allocated_block_ids = [self._uninit_block_ids.popleft() for _ in range(n_blocks)]
+        # If the block is shareable, we keep track of the allocated blocks as partial blocks
+        if shareable:
+            for block_id in allocated_block_ids:
+                block = Block(block_id, last_block_id, group_id)
+                self._id_to_block[block_id] = block
+                last_block_id = block_id
+        # In both cases, we return the allocated block ids
+        return allocated_block_ids
+
+    def fork_blocks(
+        self, parent_blocks: list[int], num_forks: int, shareable: bool, group_id: int
+    ) -> tuple[list[list[int]] | None, list[int], list[int]]:
+        """Fork a given list of (parent_blocks) as many times as (num_forks). If the blocks are (shareable), we use
+        reference on the blocks that are complete. Otherwise, we allocate new blocks and keep track of their indices to
+        later copy the physical cache. For instance, when forking 4 blocks for 2 children:
+
+        Parent blocks: [0, 1, 2, 3], with all blocks being complete except the last one (block 3).
+
+        ----------------------------------------- IF BLOCKS ARE NOT SHAREABLE -----------------------------------------
+
+        Forked blocks lists: [[5, 6, 7, 8], [9, 10, 11, 12]]
+        Copy source:          [0, 1, 2, 3,   0,  1,  2,  3]
+                               ↓  ↓  ↓  ↓    ↓   ↓   ↓   ↓
+        Copy destination:     [5, 6, 7, 8,   9, 10, 11, 12]  → 8 blocks are newly allocated and copied
+
+        ----------------------------------------- IF BLOCKS ARE SHAREABLE ---------------------------------------------
+
+        Forked blocks lists: [[0, 1, 2, 5], [0, 1, 2, 6]]
+        Copy source:          [         3,            3]     (block 3 is not complete so it's copied, not referenced)
+                                        ↓             ↓
+        Copy destination:     [         5,            6]     → only 2 blocks are newly allocated and copied
+        """
+        # First phase: reference all complete blocks
+        forked_by_reference = []
+
+        if shareable:
+            for block_id in parent_blocks:
+                block = self._id_to_block[block_id]
+                if block.is_complete:
+                    forked_by_reference.append(block.id)
+                    block.ref_count += num_forks
+                else:
+                    break
+
+        # Early return if we have forked all blocks by reference
+        blocks_to_copy = len(parent_blocks) - len(forked_by_reference)
+        if blocks_to_copy == 0:
+            return [forked_by_reference[:] for _ in range(num_forks)], [], []
+
+        # From now on, each child will have its own list of blocks
+        forked_blocks_lists = []
+        copy_src = []
+        copy_dst = []
+
+        # Second phase: allocate new blocks if needed
+        parent_id = forked_by_reference[-1] if forked_by_reference else None
+        for _ in range(num_forks):
+            allocated_block_ids = self.get_free_blocks(blocks_to_copy, parent_id, shareable, group_id)
+            if allocated_block_ids is None:
+                return None, [], []
+            forked_blocks_lists.append(forked_by_reference + allocated_block_ids)
+            copy_src.extend(parent_blocks[-blocks_to_copy:])
+            copy_dst.extend(allocated_block_ids)
+        return forked_blocks_lists, copy_src, copy_dst
+
+    def increase_ref_count(self, block_id: int) -> None:
+        """Increases the reference count of a given (block_id)."""
+        block = self._id_to_block[block_id]
+        block.ref_count += 1
+        if block.ref_count == 1:
+            self._init_block_ids.pop(block_id)
+
+    def decrease_ref_count(self, block_id: int) -> None:
+        """Decreases the reference count of a given (block_id). If the reference count reaches 0, the block is no longer
+        in use, and becomes initialized (if it was complete) or uninitialized (if it was incomplete)."""
+        block = self._id_to_block[block_id]
+        block.ref_count -= 1
+        if block.ref_count == 0:
+            if block.is_complete:
+                self._init_block_ids[block_id] = None
+            else:
+                self._id_to_block.pop(block_id)
+                self._uninit_block_ids.append(block_id)
+
+    def free_blocks(self, blocks: list[int], shareable: bool) -> None:
+        """Marks a list of (blocks) as free. If the blocks were not (shareable), we simply add them to the uninitialized
+        blocks queue. Otherwise, their new state depends on whether they are complete."""
+        if shareable:
+            for block_id in blocks:
+                self.decrease_ref_count(block_id)
+        else:
+            self._uninit_block_ids.extend(blocks)
+
+    def uninitialize_unshared_block(self, block_id: int) -> None:
+        """Marks a block as uninitialized. Raises an error if the block has more than one reference."""
+        # Make sure the block has only one reference and remove it from the block table
+        block = self._id_to_block.pop(block_id)
+        if block.ref_count > 1:
+            raise RuntimeError(f"Block {block_id} has more than one reference: {block.ref_count = }")
+        # Add the block to the uninitialized blocks queue
+        self._uninit_block_ids.append(block_id)
+
+    def mark_shareable_blocks_as_complete(
+        self, num_complete_blocks: int, allocated_blocks: list[int], prompt_ids: list[int]
+    ) -> None:
+        """Among the list of (allocated_blocks), mark (num_complete_blocks) incomplete blocks as now complete. The list
+        of (prompt_ids) is used to compute the hash of the new block."""
+        # Look for the first complete block, starting from the last block in the sequence
+        parent_hash = None
+        incomplete_blocks: list[tuple[int, Block]] = []
+        for i, block_id in reverse_enumerate(allocated_blocks):
+            block = self._id_to_block[block_id]
+            if block.is_complete:
+                parent_hash = block.hash
+                break
+            incomplete_blocks.append((i, block))
+
+        # Now go through the incomplete blocks and updated them
+        new_parent_id = None
+        while incomplete_blocks:
+            i, block = incomplete_blocks.pop()
+
+            # If the parent id has been updated, we apply the change
+            if new_parent_id is not None:
+                block.parent_id = new_parent_id
+                new_parent_id = None
+
+            # If we have set the hash for all complete blocks, we can stop
+            if num_complete_blocks == 0:
+                break
+
+            # Otherwise, we compute the hash
+            num_complete_blocks -= 1
+            tokens = prompt_ids[i * self.block_size : (i + 1) * self.block_size]
+            block.hash = self.compute_hash(parent_hash, tokens, block.group_id)
+
+            existing_block_id = self._hash_to_id.get(block.hash)
+            # If their was a different block with the same hash, we reference the existing block instead
+            if existing_block_id is not None:
+                if existing_block_id == block.id:
+                    # This should not happen, but is not a problem in itself, so we just log a warning
+                    logger.warning(f"Block {block.id} was marked as complete more than once")
+                else:
+                    logger.debug(f"Found existing block {existing_block_id} for block {block.id}")
+                    allocated_blocks[i] = existing_block_id
+                    new_parent_id = existing_block_id
+                    self.increase_ref_count(existing_block_id)
+                    self.uninitialize_unshared_block(block.id)
+
+            # Otherwise, we add the completed block to the hash table
+            else:
+                logger.debug(f"Adding new block {block.id} (group {block.group_id}) with hash {block.hash}")
+                self._hash_to_id[block.hash] = block.id
+
+            # Update loop variables
+            parent_hash = block.hash
+
+    def compute_hash(self, parent_hash: int | None, tokens: list[int], group_id: int) -> int:
+        """Computes the hash of a block identified by the (tokens) it contains, its (parent_hash) and the layer
+        (group_id) it belong to. If the block has no parent, the parent hash is None."""
+        return hash((parent_hash, tuple(tokens), group_id))
+
+
+class CacheAllocator(ABC):
+    """Abstract base class for cache managers. Cache managers keep track of per-request cache allocations, determine
+    when a new physical block needs to be allocated and compute physical indices for reading or writing to the cache."""
+
+    _index: int
+    block_table: dict[str, list[int]]  # request_id -> list of block_ids allocated to the request
+    uses_block_sharing: bool  # flag to determine if the blocks are shareable
+
+    @abstractmethod
+    def allocate_blocks(self, n_blocks: int, request_id: str, block_manager: BlockManager) -> int | None:
+        """Allocates (n_blocks) for a given (request_id) using the (block_manager). Returns the num of blocks allocated
+        if successful and None otherwise."""
+
+    def free_blocks(self, request_id: str, block_manager: BlockManager) -> None:
+        """Frees all blocks associated with a (request_id) using the (block_manager)."""
+        if request_id in self.block_table:
+            blocks_to_free = self.block_table.pop(request_id)
+            block_manager.free_blocks(blocks_to_free, shareable=self.uses_block_sharing)
+        else:
+            logger.warning(
+                f"CacheAllocator {self._index} attempted to free blocks for non-existent request_id: {request_id}"
+            )
+
+    @abstractmethod
+    def get_read_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]:
+        """Returns the physical indices of where to read request_id's cache in the cache tensor."""
+
+    @abstractmethod
+    def get_write_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]:
+        """Returns the physical indices of where to write request_id's cache in the cache tensor."""
+
+    @abstractmethod
+    def fill_block_table(
+        self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor
+    ) -> None:
+        """Fills the block table for a given request_id, past_length and query_length."""
+
+    def fork_blocks(
+        self, parent_request_id: str, children_request_ids: list[str], block_manager: BlockManager
+    ) -> tuple[list[int], list[int]]:
+        """Forks the cache blocks of a (parent_request_id) to a list of (children_request_ids). To manage the blocks,
+        the (block_manager) is used. When forking, the child's block are either shared with the parent, or they need to
+        be copied from the parent. Hence we return two lists of blocks that need to be copied: one for the source and
+        one for the destination."""
+
+        # Sanity checks
+        if parent_request_id not in self.block_table:
+            raise ValueError(f"No block table found for request {parent_request_id}")
+
+        # Actual forking
+        parent_blocks = self.block_table[parent_request_id]
+        list_forked_blocks, copy_src, copy_dst = block_manager.fork_blocks(
+            parent_blocks=parent_blocks,
+            num_forks=len(children_request_ids),
+            shareable=self.uses_block_sharing,
+            group_id=self._index,
+        )
+        if list_forked_blocks is None:
+            raise ValueError(f"Failed to fork blocks for request {parent_request_id}")
+
+        # Update the block table for all children requests
+        for children_request_id, forked_blocks in zip(children_request_ids, list_forked_blocks):
+            if children_request_id in self.block_table:
+                raise ValueError(f"Block table already exists for request {children_request_id}")
+            self.block_table[children_request_id] = forked_blocks
+        return copy_src, copy_dst
+
+
+class FullAttentionCacheAllocator(CacheAllocator):
+    """Cache manager for a group of full attention layers."""
+
+    def __init__(self, index: int, block_size: int, allow_block_sharing: bool) -> None:
+        """Initializes the cache manager for a group of full attention layers.
+        Args:
+            - index: the index of the associated layer group
+            - block_size: the size of the blocks in the cache
+        """
+        self._index = index
+        self.uses_block_sharing = allow_block_sharing
+        self.block_size = block_size
+        self.block_table = {}
+
+    def allocate_blocks(self, n_blocks: int, request_id: str, block_manager: BlockManager) -> int | None:
+        """Allocate (n_blocks) for a given (request_id) using the (block_manager). Returns the number of blocks
+        allocated if successful and None otherwise. For group of full attention layers, we always allocate the number of
+        requested blocks."""
+        # Make sure the request_id is in the block table and get the first block id
+        block_table = self.block_table.get(request_id, [])
+        if block_table:
+            last_block_id = block_table[-1]
+        else:
+            self.block_table[request_id] = block_table  # TODO: check the impact of making this a deque
+            last_block_id = None
+        # Actual allocation, return early if failed
+        allocated_blocks = block_manager.get_free_blocks(n_blocks, last_block_id, self.uses_block_sharing, self._index)
+        if allocated_blocks is None:
+            return None
+        block_table.extend(allocated_blocks)
+        return n_blocks
+
+    def get_read_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]:
+        """Returns the physical indices of where to read request_id's cache. For a group of full attention layers, we
+        first write the new cache to the cache tensor and then read the entire cache from the beginning to the end."""
+        # Retrieve the block table for the request and raise an error if it doesn't exist
+        block_table = self.block_table.get(request_id)
+        if block_table is None:
+            raise ValueError(f"No block table found for request {request_id}")
+        # Compute auxiliary variable so we can perform only two loops
+        total_length = past_length + query_length
+        num_full_blocks = total_length // self.block_size
+        remainder = total_length % self.block_size
+        # Compute the physical indices
+        physical_indices = []
+        for b in range(num_full_blocks):
+            start = block_table[b] * self.block_size
+            physical_indices.extend(range(start, start + self.block_size))
+        if remainder:
+            start = block_table[num_full_blocks] * self.block_size
+            physical_indices.extend(range(start, start + remainder))
+        return physical_indices
+
+    def get_write_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]:
+        """Returns the physical indices for writing to the cache. For a group of full attention layers, we write the new
+        cache as a continuation of the existing cache for the same request."""
+        block_table = self.block_table.get(request_id)
+        if block_table is None:
+            raise ValueError(f"No block table found for request {request_id}")
+        # Compute auxiliary variables so we can perform only one loop
+        start_block = past_length // self.block_size
+        start_offset = past_length % self.block_size
+        end_pos = past_length + query_length
+        end_block = (end_pos - 1) // self.block_size  # -1 because if end_pos == block_size, we still end on block 0
+        # Compute the physical indices
+        physical_indices = []
+        for b in range(start_block, end_block + 1):
+            block_start = block_table[b] * self.block_size
+            # First block may start mid-block, last block may end mid-block
+            local_start = start_offset if b == start_block else 0
+            local_end = (end_pos - 1) % self.block_size + 1 if b == end_block else self.block_size
+            physical_indices.extend(range(block_start + local_start, block_start + local_end))
+        return physical_indices
+
+    def fill_block_table(
+        self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor
+    ) -> None:
+        """Fills the block table for a given request_id, past_length and query_length."""
+        request_blocks = self.block_table.get(request_id)
+        if request_blocks is None:
+            raise ValueError(f"No block table found for request {request_id}")
+        total_length = past_length + query_length
+        # Use ceiling division to include the partial block at the end
+        num_blocks_needed = (total_length + self.block_size - 1) // self.block_size
+        block_table[:num_blocks_needed] = torch.tensor(
+            request_blocks[:num_blocks_needed], device=block_table.device, dtype=block_table.dtype
+        )
+        # TODO: this creates a lot of H2D transfers when not using async batching, but we will update to always using
+        # an IO pair in the future or a CPU-side block table. This also entails a small memory allocation.
+
+
+class SlidingAttentionCacheAllocator(CacheAllocator):
+    """Cache manager for sliding window attention layers."""
+
+    def __init__(
+        self, index: int, block_size: int, sliding_window: int, sentinel_index: int, trash_index: int
+    ) -> None:
+        """Initializes the cache manager for a group of sliding window attention layers. ``sentinel_index`` and
+        ``trash_index`` are valid cache positions in the padding zone, used instead of -1 in read and write indices
+        respectively so that index_select/index_copy_ never receive negative values.
+        """
+        self._index = index
+        self.uses_block_sharing = False
+        self.block_size = block_size
+        self.sliding_window = sliding_window
+        self.sentinel_index = sentinel_index
+        self.trash_index = trash_index
+        self._max_blocks_per_request = ceil(self.sliding_window / self.block_size)
+        self.block_table = {}
+
+    def allocate_blocks(self, n_blocks: int, request_id: str, block_manager: BlockManager) -> int | None:
+        """Allocate (n_blocks) for a given (request_id) using the (block_manager). Returns the number of blocks
+        allocated otherwise. For group of sliding window attention layers, we only allocate up to the point where we can
+        fit an entire sliding window in the cache tensor."""
+        if request_id not in self.block_table:
+            self.block_table[request_id] = []
+        # Early return if we are already at the max number of blocks per request
+        already_allocated = len(self.block_table[request_id])
+        if already_allocated == self._max_blocks_per_request:
+            return 0
+        # Compute actual number of blocks to allocate
+        after_allocation = min(already_allocated + n_blocks, self._max_blocks_per_request)
+        actual_n_blocks = after_allocation - already_allocated
+        # Classic allocation
+        allocated_blocks = block_manager.get_free_blocks(
+            actual_n_blocks, None, self.uses_block_sharing, self._index
+        )  # no block sharing w/ sliding window
+        if allocated_blocks is None:
+            return None
+        self.block_table[request_id].extend(allocated_blocks)
+        return actual_n_blocks
+
+    def get_read_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]:
+        """Returns the physical indices of where to read request_id's cache in the cache tensor.
+        For a group of sliding window attention layers, we read from the cache tensor before writing on it, because the
+        new cache can overwrite the old one. To form the cache + new key / values states, we read the at most
+        sliding_window - 1 cache page and then manually add the new key / values states after. Hence the sentinel
+        indices which indicate where to store the new key or values indices."""
+        # Retrieve the block table for the request and raise an error if it doesn't exist
+        block_table = self.block_table.get(request_id)
+        if block_table is None:
+            raise ValueError(f"No block table found for request {request_id}")
+        # Apply sliding window
+        start_index = 0 if past_length < self.sliding_window else past_length % self.sliding_window
+        cache_length = min(past_length, self.sliding_window - 1)
+        # Compute the physical indices
+        physical_indices = []
+        for i in range(start_index, start_index + cache_length):
+            i %= self.sliding_window
+            block_idx = i // self.block_size
+            block_offset = i % self.block_size
+            physical_index = block_table[block_idx] * self.block_size + block_offset
+            physical_indices.append(physical_index)
+        return physical_indices + [self.sentinel_index] * query_length
+
+    def get_write_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]:
+        """Returns the physical indices of where to write request_id's cache in the cache tensor. For a group of
+        sliding window attention layers, we write the new cache in rolling-buffer kind of way: if we reach the end of
+        the allocated physical cache, we start writing from the beginning of the physical cache again."""
+        # Retrieve the block table for the request and raise an error if it doesn't exist
+        block_table = self.block_table.get(request_id)
+        if block_table is None:
+            raise ValueError(f"No block table found for request {request_id}")
+        # Apply sliding window
+        start_index = past_length % self.sliding_window
+        cache_length = min(query_length, self.sliding_window)
+        padding_length = query_length - cache_length
+        # Compute the physical indices
+        physical_indices = []
+        for i in range(start_index, start_index + cache_length):
+            i %= self.sliding_window
+            block_idx = i // self.block_size
+            block_offset = i % self.block_size
+            physical_index = block_table[block_idx] * self.block_size + block_offset
+            physical_indices.append(physical_index)
+        if padding_length > 0:
+            physical_indices = [self.trash_index] * padding_length + physical_indices
+        return physical_indices
+
+    # TODO: implement this
+    def fill_block_table(
+        self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor
+    ) -> None:
+        raise NotImplementedError("Sliding window attention layers do not support block table")

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cb_logits_processors.py

@@ -0,0 +1,325 @@
+# Copyright 2025 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from abc import ABC, abstractmethod
+
+import torch
+
+from ..logits_process import (
+    LogitsProcessorList,
+    TemperatureLogitsWarper,
+    TopKLogitsWarper,
+    TopPLogitsWarper,
+)
+from .requests import FutureRequestState, logger
+
+
+# Abstract base class for all continuous batching logits processors
+class ContinuousBatchingLogitsProcessor(ABC):
+    # Kwargs that this processor uses, mapped to their expected type. Only the type is checked at runtime, value-range
+    # validation (e.g. temperature > 0) is not performed to keep a light API. You can open a PR if this is needed.
+    supported_kwargs: dict[str, type]
+    # Kwargs that this processor recognizes but ignores
+    ignored_kwargs: tuple[str, ...]
+
+    @abstractmethod
+    def fill_defaults(self, int32_tensor: torch.Tensor) -> None:
+        """Fills the given tensor int32 tensor with the default values for this processor."""
+        pass
+
+    @abstractmethod
+    def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor:
+        pass
+
+    @abstractmethod
+    def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor:
+        """Applies the logits processor in a per-token manner.
+        Args:
+            - scores (torch.FloatTensor): The scores to process, with shape [num_tokens, vocab_size]
+            - tensor_arg (torch.Tensor): The tensor argument to use for the logits processor, with shape
+                [max_num_tokens] and dtype torch.int32. The dtype might not be representative of the actual data, for
+                instance it's common to have a float32 tensor viewed as int32 (eg. temperature)
+        Returns:
+            - torch.FloatTensor: The processed scores, with shape [num_tokens, vocab_size]
+        """
+        pass
+
+
+# Main class for managing a list of processors (CB version or not) for batched generation
+class ContinuousBatchingLogitsProcessorList:
+    """A class to hold logits processors for continuous batching (CB).
+
+    Each processor has a base class, which is the one used in regular `generate` and some have a per-request version
+    adapted for CB. The list of logits processors present is generated using  the `_get_logits_processor` method from
+    the model, which will only include processors if their presence is required by the generation config. For instance,
+    if you want to use temperature scaling, you need to specify a temperature that's neither None nor 1.0. Otherwise
+    no processors will be created for temperature, and per-request temperature scaling will not be available.
+
+    On support of base processors:
+        Some base processors are not supported by CB and will be dropped when this class is instantiated. Some
+        processors have not yet been categorized as supported or not and will be kept but with a warning. All processors
+        can be kept by setting the flag `drop_unsupported_processors` to False.
+    On per-request processors:
+        Some base processors have a per-request version adapted for CB and will be converted to their per-request
+        version when this class is instantiated. This is the default behavior unless the flag `per_request_processors`
+        is set to False.
+    """
+
+    def __init__(
+        self,
+        logits_processor: LogitsProcessorList,
+        per_request_processors: bool = False,
+        drop_unsupported_processors: bool = True,
+    ) -> None:
+        self.logits_processor = logits_processor
+        self.tensors_required = 0  # number of tensors required to store CB logits processors arguments
+        # If needed, convert compatible logits processors to their per-request versions
+        if per_request_processors:
+            self._convert_to_per_request_processors()
+        # Validate and optionally filter processors based on their CB support
+        self._validate_processors(drop_unsupported_processors)
+        self._retrieve_processors_kwargs()
+        # Static boolean to know if there is any logits processing to do. Helps with torch.compile().
+        self.do_processing = len(self.logits_processor) > 0
+
+    def __repr__(self) -> str:
+        return f"ContinuousBatchingLogitsProcessorList(logits_processor={self.logits_processor}, tensors_required={self.tensors_required})"
+
+    def clear(self) -> None:
+        self.logits_processor = LogitsProcessorList()
+        self.tensors_required = 0
+        self.supported_keys = {}
+        self.ignored_keys = set()
+        self.do_processing = False
+
+    def _convert_to_per_request_processors(self) -> None:
+        """Replaces the compatible logits processors with their per-request versions."""
+        for i, processor in enumerate(self.logits_processor):
+            for regular_cls, cb_cls in CLASSIC_TO_CB_PROCESSORS_MAP.items():
+                if isinstance(processor, regular_cls):
+                    self.logits_processor[i] = cb_cls(processor)
+                    self.tensors_required += 1  # in the future, this might be more than 1 (will be stored in mapping)
+                    break
+
+    def _validate_processors(self, drop_unsupported: bool) -> None:
+        """Validates the logits processors and optionally removes unsupported ones. When drop_unsupported is True,
+        processors explicitly marked as unsupported are removed. Otherwise, all processors are kept but warnings are
+        logged for unsupported or unknown ones.
+        """
+        filtered_processors = []
+        for processor in self.logits_processor:
+            class_name = processor.__class__.__name__
+            supported = getattr(processor, "supports_continuous_batching", None)
+
+            # Keep all ContinuousBatchingLogitsProcessor or supported processors
+            if isinstance(processor, ContinuousBatchingLogitsProcessor) or supported:
+                filtered_processors.append(processor)
+            # Keep processors with support status unknown
+            elif supported is None:
+                logger.warning(f"Processor {class_name} might not be supported by CB.")
+                filtered_processors.append(processor)
+            # Otherwise, processor is not supported, then behavior depends on the flag drop_unsupported
+            elif drop_unsupported:
+                logger.warning(f"Processor {class_name} isn't supported by CB. Dropping it.")
+            else:
+                logger.warning(f"Processor {class_name} isn't supported by CB. Kept it because {drop_unsupported = }.")
+                filtered_processors.append(processor)
+
+        # Update the list of logits processors (preserve LogitsProcessorList type)
+        self.logits_processor = LogitsProcessorList(filtered_processors)
+
+    def _retrieve_processors_kwargs(self) -> None:
+        """Retrieves the supported (with types) and ignored kwargs from continuous batching processors."""
+        self.supported_keys: dict[str, type] = {}
+        self.ignored_keys = set()
+        for processor in self.logits_processor:
+            if isinstance(processor, ContinuousBatchingLogitsProcessor):
+                self.supported_keys.update(processor.supported_kwargs)
+                self.ignored_keys.update(processor.ignored_kwargs)
+
+    def check_kwargs(self, kwargs: dict) -> None:
+        """Checks that the provided kwargs are compatible with the current CB processors. Warn for ignored kwargs."""
+        if not kwargs:
+            return None
+        # Validate types for supported keys, detect unsupported keys
+        problematic_keys = set()
+        for key, value in kwargs.items():
+            if key not in self.supported_keys:
+                problematic_keys.add(key)
+            else:
+                expected_type = self.supported_keys[key]
+                if not isinstance(value, expected_type):
+                    raise TypeError(
+                        f"logit_processor_kwargs['{key}'] has type {type(value).__name__}, expected {expected_type.__name__}"
+                    )
+        # Stop if there are only supported keys
+        if not problematic_keys:
+            return
+        # Check if there are unknown keys
+        unknown_keys = problematic_keys - self.ignored_keys
+        if unknown_keys:
+            raise ValueError(
+                f"Unknown logit_processor_kwargs: {unknown_keys}. {self.supported_keys = } and {self.ignored_keys = }"
+                "If you expect a key to not be ignored, make sure its default value (in the generation config) is not "
+                "None. Eg. if temperature is None or 1.0 at creation time, no processor will be created for temperature"
+            )
+        # If there are none, throw a warning about the ignored keys
+        logger.warning(
+            f"Ignored logit_processor_kwargs: {problematic_keys}. {self.supported_keys = } and {self.ignored_keys = }"
+        )
+
+    def fill_defaults(self, int32_tensor: torch.Tensor) -> None:
+        """Fills the given tensor int32 tensor with the default values for this processor."""
+        i = 0
+        for processor in self.logits_processor:
+            if isinstance(processor, ContinuousBatchingLogitsProcessor):
+                processor.fill_defaults(int32_tensor[i])
+                i += 1
+
+    def prepare_tensor_args(
+        self, requests_in_batch: list[FutureRequestState], arg_storage: torch.Tensor
+    ) -> torch.Tensor:
+        current_arg_id = 0
+        for processor in self.logits_processor:
+            if isinstance(processor, ContinuousBatchingLogitsProcessor):
+                tensorized_arg = processor.prepare_tensor_args(requests_in_batch)
+                arg_storage[current_arg_id, : tensorized_arg.size(0)] = tensorized_arg.to(arg_storage.device)
+                current_arg_id += 1
+        return arg_storage
+
+    def __call__(
+        self, input_ids: torch.LongTensor, scores: torch.FloatTensor, logits_processor_args: torch.Tensor
+    ) -> torch.FloatTensor:
+        current_arg_id = 0
+        for processor in self.logits_processor:
+            if isinstance(processor, ContinuousBatchingLogitsProcessor):
+                scores = processor(scores, logits_processor_args[current_arg_id])
+                current_arg_id += 1
+            else:
+                scores = processor(input_ids, scores)
+        return scores
+
+
+# Here are all the continuous batching logits processors that are supported
+class ContinuousBatchingTemperatureLogitsWarper(ContinuousBatchingLogitsProcessor):
+    supported_kwargs: dict[str, type] = {"temperature": float}
+    ignored_kwargs: tuple[str, ...] = ()
+
+    def __init__(self, temperature_processor: TemperatureLogitsWarper) -> None:
+        self.temperature = temperature_processor.temperature
+
+    def fill_defaults(self, int32_tensor: torch.Tensor) -> None:
+        """Fills the given tensor int32 tensor with the default temperature."""
+        default = torch.empty_like(int32_tensor, dtype=torch.float32)
+        default.fill_(self.temperature)
+        int32_tensor.copy_(default.view(dtype=torch.int32))
+
+    def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor:
+        data = []
+        for request in requests_in_batch:
+            temp = request.state.logit_processor_kwargs.get("temperature", self.temperature)
+            data.extend([temp] * request.query_length)
+        tensorized = torch.tensor(data, dtype=torch.float32, device="cpu")
+        # View the output with the bulk storage dtype (int32) but keeps the underlying data the same
+        return tensorized.view(dtype=torch.int32)
+
+    def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor:
+        temperatures = tensor_arg[: scores.size(0)].view(dtype=torch.float32)  # shape [N]
+        return scores / temperatures.unsqueeze(-1)  # broadcast [N, 1] over [N, V]
+
+
+class ContinuousBatchingTopKLogitsWarper(ContinuousBatchingLogitsProcessor):
+    supported_kwargs: dict[str, type] = {"top_k": int}
+    ignored_kwargs: tuple[str, ...] = ("filter_value", "min_tokens_to_keep")
+
+    def __init__(self, top_k_processor: TopKLogitsWarper):
+        self.top_k = top_k_processor.top_k
+        self.filter_value = top_k_processor.filter_value
+        self.min_tokens_to_keep = top_k_processor.min_tokens_to_keep
+
+    def fill_defaults(self, int32_tensor: torch.Tensor) -> None:
+        """Fills the given tensor int32 tensor with the default top_k."""
+        int32_tensor.fill_(self.top_k)
+
+    def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor:
+        top_ks = []
+        for request in requests_in_batch:
+            top_k = request.state.logit_processor_kwargs.get("top_k", self.top_k)
+            top_k = max(top_k, self.min_tokens_to_keep)
+            top_ks.extend([top_k] * request.query_length)
+        # Prepare tensor arg with int32 as the main type
+        tensor_args = torch.tensor(top_ks, dtype=torch.int32, device="cpu")
+        return tensor_args
+
+    def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor:
+        """Applies top-k selection to the scores tensor (shape [N, V])."""
+        top_k = tensor_arg[: scores.size(0)]  # shape [N]
+        # Sort descending, get threshold at position (top_k - 1) which is the k-th largest
+        sorted_scores = torch.sort(scores, dim=-1, descending=True)[0]  # [N, V]
+        top_k_indices = (top_k - 1).unsqueeze(-1).to(dtype=torch.int64)  # [N, 1]
+        thresholds = sorted_scores.gather(dim=-1, index=top_k_indices)  # [N, 1]
+        return scores.masked_fill(scores < thresholds, self.filter_value)
+
+
+class ContinuousBatchingTopPLogitsWarper(ContinuousBatchingLogitsProcessor):
+    supported_kwargs: dict[str, type] = {"top_p": float}
+    ignored_kwargs: tuple[str, ...] = ("filter_value", "min_tokens_to_keep")
+
+    def __init__(self, top_p_processor: TopPLogitsWarper):
+        self.top_p = top_p_processor.top_p
+        self.filter_value = top_p_processor.filter_value
+        self.min_tokens_to_keep = top_p_processor.min_tokens_to_keep
+
+    def fill_defaults(self, int32_tensor: torch.Tensor) -> None:
+        """Fills the given tensor int32 tensor with the default top_p."""
+        default = torch.empty_like(int32_tensor, dtype=torch.float32)
+        default.fill_(self.top_p)
+        int32_tensor.copy_(default.view(dtype=torch.int32))
+
+    def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor:
+        top_ps = []
+        for request in requests_in_batch:
+            # Retrieve config for this request
+            top_p = request.state.logit_processor_kwargs.get("top_p", self.top_p)
+            top_ps.extend([top_p] * request.query_length)
+        # Store top_p as float32 viewed as int32 to match the bulk storage dtype
+        tensorized = torch.tensor(top_ps, dtype=torch.float32, device="cpu")
+        return tensorized.view(dtype=torch.int32)
+
+    def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor:
+        """Applies top-p (nucleus) sampling to the scores tensor (shape [N, V])."""
+        top_p = tensor_arg[: scores.size(0)].view(dtype=torch.float32)  # shape [N]
+
+        # Sort logits in ascending order
+        sorted_logits, sorted_indices = torch.sort(scores, descending=False, dim=-1)  # [N, V]
+        cumulative_probs = sorted_logits.softmax(dim=-1).cumsum(dim=-1)  # [N, V]
+
+        # Remove tokens with cumulative probability <= (1 - top_p)
+        threshold = (1 - top_p).unsqueeze(-1)  # [N, 1]
+        sorted_indices_to_remove = cumulative_probs <= threshold  # [N, V]
+
+        # Keep at least min_tokens_to_keep (always keep the last tokens in sorted order = highest prob)
+        sorted_indices_to_remove[..., -self.min_tokens_to_keep :] = False
+
+        # Scatter sorted mask back to original indexing
+        indices_to_remove = sorted_indices_to_remove.scatter(-1, sorted_indices, sorted_indices_to_remove)
+        return scores.masked_fill(indices_to_remove, self.filter_value)
+
+
+# TODO: add non-per-request CB variants so the memory-efficient warpers work when `per_request_processors=False`.
+# TODO: fuse temperature + top-k + top-p into a single pass to reuse the softmax/sort and cut activation peak.
+CLASSIC_TO_CB_PROCESSORS_MAP = {
+    TemperatureLogitsWarper: ContinuousBatchingTemperatureLogitsWarper,
+    TopKLogitsWarper: ContinuousBatchingTopKLogitsWarper,
+    TopPLogitsWarper: ContinuousBatchingTopPLogitsWarper,
+}

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/continuous_api.py

@@ -0,0 +1,1387 @@
+# Copyright 2024 The HuggingFace Inc. team.
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import asyncio
+import gc
+import queue
+import threading
+from abc import abstractmethod
+from collections.abc import Callable, Generator
+from contextlib import contextmanager, nullcontext
+from math import ceil
+from time import perf_counter
+from typing import Any
+
+import torch
+from torch import nn
+from tqdm import tqdm
+from tqdm.contrib.logging import logging_redirect_tqdm
+
+from ...configuration_utils import PretrainedConfig
+from ...generation.configuration_utils import ContinuousBatchingConfig, GenerationConfig
+from ...modeling_flash_attention_utils import lazy_import_paged_flash_attention
+from ...utils.generic import is_flash_attention_requested
+from ...utils.logging import logging
+from ...utils.metrics import ContinuousBatchProcessorMetrics, attach_tracer, traced
+from ..logits_process import LogitsProcessorList
+from .cache import PagedAttentionCache
+from .cb_logits_processors import ContinuousBatchingLogitsProcessorList
+from .input_outputs import ContinuousBatchingAsyncIOs, ContinuousBatchingIOs
+from .offloading_manager import OffloadingManager
+from .requests import GenerationOutput, RequestState, RequestStatus, logger
+from .scheduler import SCHEDULER_MAPPING, FIFOScheduler, Scheduler
+from .utils import WorkloadHints, attn_mask_is_needed, create_warmup_future_states, pad_to_interval, pad_to_pow2
+
+
+"""
+To enable cuda graphs, we need the dimensions of all tensors to be static, which is counter-intuitive for CB. In CB, as
+generation goes on, there are two dimensions that change:
+- the number of queries tokens (Q), which can vary from batch to batch
+- the number of keys/values tokens (KV), which grows as the cache does
+
+To solve this, we slice along those dimensions to fixed lengths. The size of the slices is controlled by interval sizes:
+- q_padding_interval_size: the padding granularity for queries (in tokens)
+- kv_padding_interval_size: the padding granularity for KV cache (in tokens)
+
+For example, with q_padding_interval_size=64 and an actual query length of 100, we pad to 128 tokens.
+
+Smaller intervals mean finer granularity and thus less padding, but more unique graph signatures. Since graphs take
+memory and time to create, we use an LRU cache with a fixed size to limit memory usage. Good defaults:
+- Q: 64 tokens gives ~4 graphs for max_batch_tokens=256, which is a good balance
+- KV: 8192 tokens (256 blocks at block_size=32) gives reasonable granularity for large caches
+
+The maximum number of cached graphs is controlled by max_cached_graphs (default 32), which uses LRU eviction.
+All defaults are stored in ContinuousBatchingConfig.resolve_sentinel_values().
+"""
+
+
+# We cannot use `PreTrainedModel` for circular import reasons, so this helps keep track of the basic types
+class ProtoPretrainedModel(nn.Module):
+    config: PretrainedConfig
+    dtype: torch.dtype
+    device: torch.device
+
+    @abstractmethod
+    def set_attn_implementation(self, attn_implementation: str) -> None:
+        pass
+
+    @abstractmethod
+    def _get_logits_processor(self, generation_config: GenerationConfig) -> LogitsProcessorList:
+        pass
+
+
+class OutputRouter:
+    """Dedicated object for routing generation outputs to the right destination.
+
+    When an async handler is registered for a request, the output is forwarded
+    to that handler via ``call_soon_threadsafe``. Otherwise the output is placed
+    on the shared ``output_queue``.
+    """
+
+    def __init__(self) -> None:
+        self.output_queue = queue.Queue()
+        self.result_handlers: dict[str, tuple[Callable, asyncio.AbstractEventLoop]] = {}
+        self._lock = threading.Lock()
+
+    def deliver(self, output: GenerationOutput) -> None:
+        """Route a single output to its registered handler or the output_queue."""
+        with self._lock:
+            entry = self.result_handlers.get(output.request_id)
+        if entry is not None:
+            callback, loop = entry
+            loop.call_soon_threadsafe(callback, output)
+        else:
+            self.output_queue.put(output)
+
+    def deliver_batch(self, outputs: list[GenerationOutput]) -> None:
+        """Route a batch of outputs, using a single ``call_soon_threadsafe`` to minimize cross-thread overhead.
+
+        Outputs without a registered handler fall back to the shared ``output_queue``.
+        """
+        callbacks: list[tuple[Callable, GenerationOutput]] = []
+        loop = None
+        with self._lock:
+            for output in outputs:
+                entry = self.result_handlers.get(output.request_id)
+                if entry is not None:
+                    callback, loop = entry
+                    callbacks.append((callback, output))
+                else:
+                    self.output_queue.put(output)
+        if callbacks and loop is not None:
+
+            def _run_batch(batch=callbacks):
+                for cb, out in batch:
+                    cb(out)
+
+            loop.call_soon_threadsafe(_run_batch)
+
+
+# Continuous Batch Processor (Internal Logic)
+@attach_tracer()
+class ContinuousBatchProcessor:
+    inputs_and_outputs: ContinuousBatchingIOs | ContinuousBatchingAsyncIOs
+    scheduler: Scheduler
+
+    def __init__(
+        self,
+        cache: PagedAttentionCache,
+        config: PretrainedConfig,
+        generation_config: GenerationConfig,
+        continuous_batching_config: ContinuousBatchingConfig,
+        logit_processor: ContinuousBatchingLogitsProcessorList,
+        input_queue: queue.Queue,
+        output_router: OutputRouter,
+        stop_event: threading.Event,
+        model_device: torch.device,
+        model_dtype: torch.dtype,
+        scheduler: Scheduler,
+    ) -> None:
+        """Initialize the continuous batch processor.
+
+        Args:
+            cache: A [`PagedAttentionCache`] object
+            config: The model configuration
+            generation_config: The generation configuration
+            continuous_batching_config: The continuous batching configuration
+            logit_processor: The [`ContinuousBatchingLogitsProcessorList`] object used to process the logits.
+            input_queue: Queue for incoming requests
+            output_router: An [`OutputRouter`] object that routes outputs to handlers or the output queue.
+            stop_event: Event to signal processing should stop
+            model_device: Device for model inputs/outputs
+            model_dtype: Data type for model inputs/outputs
+            scheduler: The [`Scheduler`] to use
+        """
+        self.cache = cache
+        self.config = config
+        self.cb_config = continuous_batching_config
+        self.logit_processor = logit_processor
+        self.input_queue = input_queue
+        self.output_router = output_router
+        self.stop_event = stop_event
+        self.model_device = model_device
+        self.model_dtype = model_dtype
+        self.scheduler = scheduler
+
+        # Generation-related attributes
+        self.do_sample = getattr(generation_config, "do_sample", True)
+        self.return_logprobs = continuous_batching_config.return_logprobs
+
+        # Retrieve the size of the sliding window if there is one
+        self.sliding_window = 1 if getattr(config, "sliding_window", None) is None else config.sliding_window
+        # Cuda graphs for the generation step
+        self.q_padding_interval_size = self.cb_config.q_padding_interval_size
+        self.kv_padding_interval_size = self.cb_config.kv_padding_interval_size
+        self.use_cuda_graph_varlen, self.use_cuda_graph_decode = self.cb_config.get_cuda_graph_booleans()
+
+        # Set up metrics collector
+        self.max_batch_tokens = cache.max_batch_tokens
+        self.metrics = ContinuousBatchProcessorMetrics(cache.max_batch_tokens)
+
+        # If the user turned on the decode fast path (ie. using a block table), check if it is available
+        self._ensure_decode_fast_path_is_available()  # this needs to happen before self.inputs_and_outputs is created
+
+        # Resolve compile behavior
+        self.cb_config.resolve_compile_configs(
+            fallback_compile_config=getattr(generation_config, "compile_config", None),
+            is_flash_attn=is_flash_attention_requested(config=config),
+            decode_fast_path_available=self.cache.max_blocks_per_request > 0,
+        )
+        varlen_config, decode_config = self.cb_config.varlen_compile_config, self.cb_config.decode_compile_config
+
+        # Compile the varlen path if config provided
+        self._compiled_varlen = None
+        if varlen_config is not None:
+            self._compiled_varlen = torch.compile(self._forward_process_and_sample, **varlen_config.to_dict())
+
+        # Compile the decode path if config provided
+        self._compiled_decode = None
+        if decode_config is not None:
+            self._compiled_decode = torch.compile(self._forward_process_and_sample, **decode_config.to_dict())
+
+        # Padding is turned on when either cuda graphs or compile is used
+        use_cuda_graphs = self.use_cuda_graph_varlen or self.use_cuda_graph_decode
+        self._pad_inputs = use_cuda_graphs or (varlen_config is not None or decode_config is not None)
+        # Set up the graph pool. This allows all graphs to share the same memory pool, greatly saving memory.
+        self.graph_pool = torch.cuda.graph_pool_handle() if use_cuda_graphs else None
+
+        # Setup inputs and outputs
+        io_kwargs = {
+            "cache": cache,
+            "config": config,
+            "device": model_device,
+            "model_dtype": model_dtype,
+            "return_logprobs": self.return_logprobs,
+            "logit_processor": self.logit_processor,
+            "use_cuda_graph_varlen": self.use_cuda_graph_varlen,
+        }
+        self.use_async_batching = self.cb_config.use_async_batching
+
+        if self.use_async_batching:
+            # Since in async there are 2 IO pairs, there are also 2 graph buffers: we divide the max_cached_graphs by 2
+            io_kwargs["max_graphs"] = ceil(self.cb_config.max_cached_graphs / 2)
+            self.inputs_and_outputs = ContinuousBatchingAsyncIOs(**io_kwargs)
+        else:
+            io_kwargs["max_graphs"] = self.cb_config.max_cached_graphs
+            self.inputs_and_outputs = ContinuousBatchingIOs(**io_kwargs)
+
+        # Offloading manager: handles CPU offloading, soft reset, and restoration
+        self.offloading_manager = OffloadingManager(
+            cache=cache,
+            scheduler=scheduler,
+            cpu_offload_space_gib=continuous_batching_config.cpu_offload_space,
+            safety_threshold=continuous_batching_config.cpu_offload_space_safety_threshold,
+            compute_stream=self.inputs_and_outputs.compute_stream,
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f"ContinuousBatchProcessor(input_queue={self.input_queue}, "
+            f"active_requests={self.scheduler.active_requests}, waiting_requests={self.scheduler.waiting_requests})"
+            + self.inputs_and_outputs.get_model_kwargs().__repr__()
+        )
+
+    def __del__(self) -> None:
+        self.inputs_and_outputs = None  # clean up CUDA graphs in priority
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    def _ensure_decode_fast_path_is_available(self) -> None:
+        """Ensures the decode fast path is available. If it is not, set the max blocks per request to 0. If it is
+        available, and no user-provided max blocks per request, set it to the fallback default."""
+        # First, set max blocks per request to 32 if it needs to be auto-inferred
+        user_requested = self.cb_config.max_blocks_per_request is not None
+        if not user_requested:
+            self.cache.max_blocks_per_request = self.cb_config.fallback_max_blocks_per_request
+            logger_warning = lambda x: x  # silences warning for user_requested=False  # noqa: E731
+        else:
+            logger_warning = logger.warning
+
+        # Then, if the decode fast path is not turned off, check if it is available
+        if self.cache.max_blocks_per_request != 0:
+            # NOTE: block table should be available with FA2 and FA3, but there seems to be an issue with FA2 atm
+            if is_flash_attention_requested(self.config, version=3):
+                flash_attn_with_kvcache = lazy_import_paged_flash_attention(self.config._attn_implementation)[1]
+                conditions = [
+                    self.cache.num_sliding_attention_groups == 0,  # TODO: add support for sliding window layers
+                    torch.cuda.is_available(),  # Block table is only supported on CUDA
+                    flash_attn_with_kvcache is not None,  # The `flash_attn_with_kvcache` fn is needed
+                ]
+                # Throw a warning only if the decode fast path was requested by the user
+                if not all(conditions):
+                    logger_warning(
+                        f"Although {self.cache.max_blocks_per_request = }, the decode fast path is not available "
+                        f"because the one condition is not met: {conditions}."
+                    )
+                    self.cache.max_blocks_per_request = 0
+            # Specific warning for attn implementation other than FA3
+            else:
+                logger_warning(
+                    f"Although {self.cache.max_blocks_per_request = }, the decode fast path is not available "
+                    f"because the attention implementation is not FA3. Got {self.config._attn_implementation = }."
+                )
+                self.cache.max_blocks_per_request = 0
+
+    def reset(self) -> None:
+        """Reset the batch processor for a new generation loop."""
+        self.offloading_manager.reset()
+        self.scheduler.reset()
+        self.inputs_and_outputs.reset()
+        self.cache.free_all_requests()
+        self.metrics = ContinuousBatchProcessorMetrics(self.cache.max_batch_tokens)
+
+    @traced
+    def _get_new_requests(self) -> None:
+        """Pull new requests from the input queue and add to waiting list."""
+        while not self.input_queue.empty():
+            try:
+                state = self.input_queue.get_nowait()
+                if state is None:  # Sentinel value
+                    continue
+                self.logit_processor.check_kwargs(state.logit_processor_kwargs)
+                self.scheduler.add_waiting_request(state)
+
+            except queue.Empty:
+                break
+            except Exception as e:
+                logger.error(f"Error processing new request: {e}", exc_info=True)
+                state: RequestState = locals().get("state")
+                if state is not None:
+                    self._handle_request_error(e, state)
+
+    @traced
+    def _handle_request_error(self, error: Exception, state: RequestState) -> None:
+        """Handle general request processing error."""
+        state.status = RequestStatus.FAILED
+        state.error = str(error)
+
+        # Include any generated tokens if this is an active request
+        if isinstance(state.request_id, str):
+            state.generated_tokens = self.scheduler.get_active_request_static_outputs(state.request_id)
+        else:
+            state.generated_tokens = []
+
+        self.metrics.record_request_completion(state.created_time, state.request_id)
+        self.output_router.deliver(state.to_generation_output())
+
+    def maybe_pad_inputs(self, num_q_tokens: int, max_kv_read: int, use_decode_fast_path: bool) -> tuple[int, int]:
+        """Pads the inputs sizes for the next batch if it is needed. Often it is, for max performance."""
+        if self._pad_inputs:
+            # For varlen batches, we pad using interval sizes
+            if not use_decode_fast_path:
+                num_q_tokens = pad_to_interval(num_q_tokens, self.q_padding_interval_size, self.max_batch_tokens)
+                max_kv_read = pad_to_interval(max_kv_read, self.kv_padding_interval_size, self.cache.num_pages)
+            # For decode fast path batches, we pad using powers of 2 and use no KV
+            else:
+                num_q_tokens = pad_to_pow2(num_q_tokens, self.max_batch_tokens)
+                max_kv_read = 0
+        return num_q_tokens, max_kv_read
+
+    @traced
+    def prepare_next_batch(self) -> bool:
+        """Prepare tensors and metadata for the next model forward pass. Returns True if there are requests to process,
+        False otherwise."""
+
+        # Get new requests from the queue, stop if there are no pending requests
+        self._get_new_requests()
+        cancelled_states = self.scheduler.clear_cancelled_requests()
+        # Also free CPU-offloaded cache for cancelled states. This is CPU-only, so it isn't batched like D2H transfers
+        for state in cancelled_states:
+            self.offloading_manager.free_request_cpu_cache(state)
+        if not self.scheduler.has_pending_requests():
+            return False
+        self.metrics.record_queue_metrics(len(self.scheduler.active_requests), len(self.scheduler.waiting_requests))
+
+        # Schedule the next batch of requests
+        requests_in_batch, use_decode_fast_path, num_q_tokens, max_kv_read = self.scheduler.schedule_batch(
+            self.max_batch_tokens, self.cache.num_pages
+        )
+        # If requests_in_batch is None, it means we need to offload some requests if possible
+        if requests_in_batch is None:
+            if len(self.scheduler.active_requests) > 1:
+                self.offloading_manager.offload_one_request()
+                return False
+            else:
+                raise RuntimeError("No requests can be scheduled and no request can be offloaded.")
+        # If it's an empty list, it means we have no requests to process
+        if not requests_in_batch:
+            return False
+
+        # Restore any CPU-offloaded requests that were just scheduled
+        self.offloading_manager.restore_scheduled_requests(requests_in_batch)
+
+        # Otherwise, we can continue with the non-empty batch and log in the dimensions before padding
+        self.metrics.record_batch_metrics(requests_in_batch)
+        logger.debug(
+            f"Scheduled: {len(requests_in_batch)}, Waiting: {len(self.scheduler.waiting_requests)}, "
+            f"Active: {len(self.scheduler.active_requests)}. cum Q: {num_q_tokens}. "
+            f"cum KV: {max_kv_read}, free blocks: {self.cache.get_num_free_blocks()}"
+        )
+
+        # If inputs are static sized, eg. for compile, we find the padded sizes of the queries and keys/values
+        num_q_tokens, max_kv_read = self.maybe_pad_inputs(num_q_tokens, max_kv_read, use_decode_fast_path)
+
+        self.inputs_and_outputs.prepare_batch_tensors(
+            requests_in_batch, self.logit_processor, use_decode_fast_path, num_q_tokens, max_kv_read
+        )
+        self.metrics.record_kv_cache_memory_metrics(self.cache)
+        return True
+
+    @traced
+    def update_batch(self) -> None:
+        """Update request states based on generated tokens."""
+        requests_in_batch, new_tokens, logprobs = self.inputs_and_outputs.prepare_batch_update()
+        current_logits_index = 0
+        pending_outputs = []
+        for future_state in requests_in_batch:
+            state = future_state.state
+            # Early return if the request was finished or offloaded between scheduling and update (async mode)
+            if state.status in (RequestStatus.FINISHED, RequestStatus.PENDING):
+                if self.use_async_batching:
+                    # Skip this request, but still consume its token from new_tokens if it had one
+                    if future_state.has_new_token:
+                        current_logits_index += 1
+                    continue
+                raise RuntimeError(f"Tried to update {state.status.name} request {state.request_id} in sync mode.")
+            # If the request has a new token, it means prefill has already ended or just finished
+            if future_state.has_new_token:
+                # If there is just one temporary token, it means prefill just ended
+                if state.generated_len() == 0:
+                    self.metrics.record_ttft_metric(state.created_time, state.request_id)
+                    state.status = RequestStatus.DECODING
+
+                token = new_tokens[current_logits_index]
+                logprob = logprobs[current_logits_index] if logprobs is not None else None
+                current_logits_index += 1
+
+                # Update the request and stop if it is complete
+                is_finished = state.update_and_check_completion(token, logprob)
+                # We mark the completed blocks as such
+                self.cache.mark_shareable_blocks_as_complete(state, future_state.complete_blocks)
+                if is_finished:
+                    self.metrics.record_request_completion(state.created_time, state.request_id)
+                    self.scheduler.finish_request(state.request_id)
+                    self.scheduler.block_new_requests = False
+                if state.streaming or state.status == RequestStatus.FINISHED:
+                    pending_outputs.append(state.to_generation_output())
+            #  Otherwise, the request is still prefilling, but the prefill has been split
+            elif state.status == RequestStatus.PREFILLING:
+                self.cache.mark_shareable_blocks_as_complete(state, future_state.complete_blocks)
+
+        if pending_outputs:
+            self.output_router.deliver_batch(pending_outputs)
+
+        # If some requests need to be forked, we do it now
+        copy_source, copy_destination = [], []
+        while self.scheduler._requests_to_fork:
+            # Get the number of children and reset it so it's not forked again
+            state_to_fork = self.scheduler._requests_to_fork.pop()
+            num_children = state_to_fork.num_children
+            state_to_fork.num_children = 0
+            # Create the new request and add them to the scheduler
+            new_request_ids = [f"{state_to_fork.request_id}__child#{i}" for i in range(num_children)]
+            for new_request_id in new_request_ids:
+                self.scheduler.active_requests[new_request_id] = state_to_fork.fork(new_request_id)
+            # Fork the cache
+            copy_src, copy_dst = self.cache.fork_request(state_to_fork.request_id, new_request_ids)
+            copy_source.extend(copy_src)
+            copy_destination.extend(copy_dst)
+            # FIXME: if fork cant be done, create a new pending request without forking instead of crashing everything
+
+        # The copy induced by the fork is done in one go (if it's even needed)
+        if copy_source:
+            # FIXME: this will avoid any race condition, but it can cause issue when using async batching with a sliding
+            # window model. Fix will be fixed in a PR in the near future (tempfix, v5.3)
+            compute_stream = self.inputs_and_outputs.compute_stream
+            maybe_stream = torch.cuda.stream(compute_stream) if compute_stream is not None else nullcontext()
+            with maybe_stream:
+                self.cache.copy_cache(copy_source, copy_destination)
+
+    @traced
+    def has_pending_requests(self) -> bool:
+        """Check if there are any active or waiting requests."""
+        return self.scheduler.has_pending_requests()
+
+    @traced
+    def handle_batch_error(self, error):
+        """Handle errors during batch processing."""
+        failed_future_states = self.inputs_and_outputs.prepare_batch_update()[0]
+        for future_state in failed_future_states:
+            self._handle_request_error(error, future_state.state)
+            self.scheduler.finish_request(future_state.state.request_id)
+
+    @traced
+    def fail_all_requests(self, error: Exception) -> None:
+        """Fail all active requests with the given error."""
+
+        requests = list(self.scheduler.active_requests.values())
+        for state in requests:
+            self._handle_request_error(error, state)
+            self.scheduler.finish_request(state.request_id)
+
+        # Also fail any requests in the waiting queue
+        self.offloading_manager.free_all_waiting_cpu_caches()
+        for req_id in list(self.scheduler.waiting_requests.keys()):
+            state = self.scheduler.waiting_requests.pop(req_id)
+            self._handle_request_error(error, state)
+
+        # Clear the ordering queue
+        self.scheduler.waiting_requests_order.clear()
+
+    @traced
+    @torch.no_grad()
+    def _generation_step(self, model: nn.Module) -> None:
+        """Perform a single generation step."""
+
+        # Retrieve the model kwargs with or without padding
+        batch_data = self.inputs_and_outputs.get_model_kwargs(use_padding=self._pad_inputs)
+        carry_over_ids, prev_output_ids, output_ids = self.inputs_and_outputs.get_cb_kwargs()
+        compute_stream = self.inputs_and_outputs.compute_stream
+
+        # Get the appropriate forward function (compiled or not, based on current path)
+        if self.inputs_and_outputs.use_block_table:
+            forward_fn = self._forward_process_and_sample if self._compiled_decode is None else self._compiled_decode
+            use_cuda_graph = self.use_cuda_graph_decode
+        else:
+            forward_fn = self._forward_process_and_sample if self._compiled_varlen is None else self._compiled_varlen
+            use_cuda_graph = self.use_cuda_graph_varlen
+
+        # If we are not using cuda graphs, we perform the generation step and return
+        if not use_cuda_graph:
+            maybe_stream = torch.cuda.stream(compute_stream) if compute_stream is not None else nullcontext()
+            with maybe_stream:
+                forward_fn(model, batch_data, carry_over_ids, prev_output_ids, output_ids)
+
+        # Otherwise, we use create or replay the graph (cuda is available in this path)
+        else:
+            graph = self.inputs_and_outputs.get_graph()
+            # Case: the graph already exists, so we replay it
+            if graph is not None:
+                with torch.cuda.stream(compute_stream):
+                    graph.replay()
+            # Otherwise, the graph does not exist, so we create it
+            else:
+                args = (model, batch_data, carry_over_ids, prev_output_ids, output_ids)
+                self.capture_graph(forward_fn, compute_stream, *args)
+
+        # In any case, we transfer the outputs to the host
+        self.inputs_and_outputs.retrieve_device_outputs()
+
+    def capture_graph(self, forward_fn: Any, compute_stream: torch.cuda.Stream, *args) -> None:
+        # Warmup (ensures the right result is computed before capturing the graph)
+        with torch.cuda.stream(compute_stream):
+            forward_fn(*args)
+        # Capture
+        graph = torch.cuda.CUDAGraph()
+        # Continuous batching can run multiple manager threads concurrently in one process, but PyTorch's
+        # default capture mode ("global") errors on CUDA actions from other threads. This means capture can be
+        # invalidated even when each manager uses a different device. To avoid this, we use "thread_local" mode.
+        with torch.cuda.graph(graph, stream=compute_stream, pool=self.graph_pool, capture_error_mode="thread_local"):
+            forward_fn(*args)
+        # Store
+        self.inputs_and_outputs.set_graph(graph)
+
+    @traced
+    def _forward_process_and_sample(
+        self,
+        model: nn.Module,
+        batch_data: dict,
+        carry_over_ids: torch.Tensor,
+        prev_output_ids: torch.Tensor,
+        output_ids: torch.Tensor,
+    ) -> None:
+        """This function performs the forward pass, logits processing, and sampling; which are broken down into smaller
+        function to be easier to trace with OpenTelemetry."""
+        self.inputs_and_outputs.carry_over_tokens(batch_data["input_ids"], carry_over_ids, prev_output_ids)
+        logits = self._model_forward(model, batch_data).float()  # convert to fp32 to match generate
+        scores = self._process_logit(batch_data, logits) if self.logit_processor.do_processing else logits
+        self._sample(scores, batch_data["logits_indices"], output_ids)
+
+    @traced(span_name="model_forward")
+    def _model_forward(self, model: nn.Module, batch_data: dict) -> torch.Tensor:
+        return model(**batch_data).logits
+
+    @traced(span_name="logit_processing")
+    def _process_logit(self, batch_data: dict, logits: torch.Tensor) -> torch.Tensor:
+        # Handle shape compatibility: logit processors expect 2D tensors [batch_size, vocab_size]
+        # but continuous batching always produces 3D tensors [batch_size, seq_len, vocab_size]
+        batch_size, seq_len, vocab_size = logits.shape
+        logits_2d = logits.view(batch_size * seq_len, vocab_size)
+        input_ids_2d = batch_data["input_ids"].view(batch_size * seq_len)
+        # Process with 2D tensors
+        processed_logits_2d = self.logit_processor(input_ids_2d, logits_2d, batch_data["logits_processor_args"])
+        # Reshape back to 3D
+        return processed_logits_2d.view(batch_size, seq_len, vocab_size)
+
+    @traced(span_name="sampling")
+    def _sample(self, scores: torch.Tensor, logits_indices: torch.Tensor, output_ids: torch.Tensor) -> None:
+        # Apply softmax if we are sampling or if we are generating log probabilities
+        if self.do_sample or self.return_logprobs:
+            probs = nn.functional.softmax(scores[0], dim=-1)  # shape [seq_len, vocab_size]
+        # Otherwise just remove the batch size dimension, which is always 1
+        else:
+            probs = scores.squeeze(0)  # shape [seq_len, vocab_size]
+
+        # Retrieve next tokens through sampling or argmax
+        if self.do_sample:
+            next_tokens = torch.multinomial(probs, num_samples=1)  # shape [seq_len, 1]
+        else:
+            next_tokens = torch.argmax(probs, dim=-1, keepdim=True)  # shape [seq_len, 1]
+
+        # Maybe retrieve log probabilities
+        if self.return_logprobs:
+            per_token_probs = probs.gather(dim=1, index=next_tokens).squeeze(-1)
+            logprobs = per_token_probs.log()  # shape [seq_len]
+        # And always remove the extra dimension for the gather
+        next_tokens = next_tokens.squeeze(-1)  # shape [seq_len]
+
+        # Get seq_len dimension to slice the logits indices
+        tokens = next_tokens.size(0)
+        # Shuffle the next tokens to match the order of the batch's requests
+        indices = logits_indices[:tokens]
+        next_tokens = next_tokens[indices]
+        # Copy the next tokens and maybe their logprobs to the static output tensor
+        output_ids[0, :tokens].copy_(next_tokens)
+        if self.return_logprobs:
+            # Shuffle the logprobs the same way as the next tokens
+            logprobs = logprobs[indices]
+            # In order to match the dtype of output_ids, we cast the fp32 logprobs as int32 without changing the
+            # underlying data. It's just a trick to use the same storage for both tensors.
+            output_ids[1, :tokens].copy_(logprobs.view(dtype=torch.int32))
+
+    @torch.inference_mode()
+    def warmup(self, model: nn.Module) -> None:
+        """Pre-capture CUDA graphs (or trigger compile warmup) for varlen and decode paths. In async mode, both IO
+        pairs are warmed up since each has its own graph buffer and static tensors. The varlen path is warmed up at
+        the largest possible `(q, kv)` sizes so subsequent captures fit inside it without growing the pool."""
+
+        if not self._pad_inputs:
+            logger.info("CUDA graphs and compile are disabled, skipping warmup.")
+            return None
+
+        num_query_tokens = self.max_batch_tokens
+        num_pages = self.cache.num_blocks * self.cache.block_size
+        num_cache_tokens = num_pages - num_query_tokens
+        compute_stream = self.inputs_and_outputs.compute_stream
+
+        # In async mode, each IO pair has its own graph buffer and static tensors, so we warm up both
+        num_io_pairs = 2 if self.use_async_batching else 1
+
+        for pair_idx in range(num_io_pairs):
+            if self.use_async_batching:
+                self.inputs_and_outputs.current_pair = pair_idx
+                logger.info(f"Warming up IO pair {pair_idx + 1}/2...")
+
+            # --- Varlen path ---
+            padded_q, padded_kv = self.maybe_pad_inputs(
+                num_q_tokens=num_query_tokens,
+                max_kv_read=num_cache_tokens + num_query_tokens,
+                use_decode_fast_path=False,
+            )
+            logger.info(f"Warming up varlen path ({padded_q} Q tokens, {padded_kv} KV tokens)...")
+
+            future_states = create_warmup_future_states(
+                1, RequestStatus.PREFILLING, num_query_tokens, num_cache_tokens, self.cache
+            )
+            try:
+                start = perf_counter()
+                self.inputs_and_outputs.prepare_batch_tensors(
+                    future_states, self.logit_processor, False, padded_q, padded_kv - padded_q
+                )
+                batch_data = self.inputs_and_outputs.get_model_kwargs(use_padding=True)
+                carry_over_ids, prev_output_ids, output_ids = self.inputs_and_outputs.get_cb_kwargs()
+                forward_fn = self._compiled_varlen or self._forward_process_and_sample
+                forward_fn_args = (model, batch_data, carry_over_ids, prev_output_ids, output_ids)
+                if self.use_cuda_graph_varlen:
+                    self.capture_graph(forward_fn, compute_stream, *forward_fn_args)
+                else:
+                    with torch.cuda.stream(compute_stream):
+                        forward_fn(*forward_fn_args)
+                logger.info(f"Varlen warmup completed in {perf_counter() - start:.2f}s")
+            except Exception as e:
+                logger.warning(f"Failed to warm up varlen path: {e}. Graph pool may fragment and OOM under load.")
+            finally:
+                for fs in future_states:
+                    self.cache.free_blocks(fs.state.request_id)
+
+            # Exit here if the decode fast path is not available
+            if self.cache.max_blocks_per_request == 0:
+                continue
+
+            # --- Decode fast path ---
+            logger.info("Warming up decode fast path...")
+            decode_graphs = 0
+            start = perf_counter()
+
+            num_requests = 1
+            while True:
+                future_states = create_warmup_future_states(
+                    num_requests, RequestStatus.DECODING, 1, self.cache.block_size, self.cache
+                )
+                if not future_states:
+                    break
+                try:
+                    padded_q, _ = self.maybe_pad_inputs(
+                        num_q_tokens=num_requests, max_kv_read=0, use_decode_fast_path=True
+                    )
+                    self.inputs_and_outputs.prepare_batch_tensors(
+                        future_states, self.logit_processor, True, padded_q, 0
+                    )
+                    batch_data = self.inputs_and_outputs.get_model_kwargs(use_padding=True)
+                    carry_over_ids, prev_output_ids, output_ids = self.inputs_and_outputs.get_cb_kwargs()
+                    forward_fn = self._compiled_decode or self._forward_process_and_sample
+                    forward_fn_args = (model, batch_data, carry_over_ids, prev_output_ids, output_ids)
+                    if self.use_cuda_graph_decode:
+                        self.capture_graph(forward_fn, compute_stream, *forward_fn_args)
+                    else:
+                        with torch.cuda.stream(compute_stream):
+                            forward_fn(*forward_fn_args)
+                    decode_graphs += 1
+                except Exception as e:
+                    logger.warning(f"Failed to warm up decode path for {num_requests} requests: {e}")
+                finally:
+                    for fs in future_states:
+                        self.cache.free_blocks(fs.state.request_id)
+                if num_requests >= self.max_batch_tokens:
+                    break
+                num_requests = min(2 * num_requests, self.max_batch_tokens)
+            logger.info(f"Decode warmup completed ({decode_graphs} graphs) in {perf_counter() - start:.2f}s.")
+
+        # If using async batching, reset to pair 0 for the generation loop
+        if self.use_async_batching:
+            self.inputs_and_outputs.current_pair = 0
+
+
+# Manager Class (User Interface)
+@attach_tracer()
+class ContinuousBatchingManager:
+    """Manager for handling continuous batching of generation requests. It provides a user interface for submitting
+    generation requests, retrieving results, and managing the background generation thread. This class should not be
+    created directly, but through one of the following entry points (all methods of the `ContinuousMixin` mixin):
+    - `init_continuous_batching`
+    - `continuous_batching_context_manager`
+    - `generate_batch`
+    """
+
+    def __init__(
+        self,
+        model: ProtoPretrainedModel,
+        generation_config: GenerationConfig,
+        continuous_batching_config: ContinuousBatchingConfig,
+    ) -> None:
+        """Initialize the continuous batching manager.
+
+        Args:
+            model: The language model for generation
+            generation_config: Configuration for generation parameters
+            continuous_batching_config: Configuration for continuous batching parameters
+        """
+        # Reload paged version of the attention implementation if necessary
+        if "paged|" not in model.config._attn_implementation:
+            model.set_attn_implementation(f"paged|{model.config._attn_implementation}")
+
+        # Internal arguments
+        self.model = model.eval()
+        self.generation_config = generation_config
+        self.continuous_batching_config = continuous_batching_config
+        self.warmed_up = False  # Set to True after warmup is completed. Useful for persistent managers.
+        # This is an approximation until the cache is created: it will infer the correct value in cache.__init__
+        self._use_prefix_sharing = self.continuous_batching_config.allow_block_sharing
+
+        self.input_queue = queue.Queue(maxsize=self.continuous_batching_config.max_queue_size)
+        self._has_new_requests = threading.Event()
+        self.output_router = OutputRouter()
+        self.stop_event = threading.Event()
+        self.batch_processor: ContinuousBatchProcessor | None = None
+        self._generation_thread = None
+        self._request_counter = 0
+        self._request_lock = threading.Lock()
+        self.fatal_error: Exception | None = None
+
+        # Generation config related arguments
+        num_return_sequences = getattr(generation_config, "num_return_sequences", None)
+        self.num_return_sequences = num_return_sequences if num_return_sequences is not None else 1
+
+        self.logit_processor = ContinuousBatchingLogitsProcessorList(
+            logits_processor=self.model._get_logits_processor(generation_config),
+            per_request_processors=self.continuous_batching_config.per_request_processors,
+            drop_unsupported_processors=self.continuous_batching_config.drop_unsupported_processors,
+        )
+
+        # Cuda graph behavior is determined below using either user-specified arguments or heuristics
+        is_attn_mask_needed = attn_mask_is_needed(self.model.config)
+        self.continuous_batching_config.decide_use_cuda_graphs(
+            compile_config=getattr(generation_config, "compile_config", None),
+            is_attn_mask_needed=is_attn_mask_needed,
+        )
+        # Same for asynchronous batching behavior
+        self.use_async_batching = self.continuous_batching_config.decide_use_async_batching(is_attn_mask_needed)
+
+        # Resolve default parameters for Q and KV interval sizes, and max cached graphs. If one of those parameters is
+        # not specified (set to 0) then we use the default value and change its value in the config.
+        self.continuous_batching_config.resolve_sentinel_values()
+        self.q_padding_interval_size = self.continuous_batching_config.q_padding_interval_size
+        self.kv_padding_interval_size = self.continuous_batching_config.kv_padding_interval_size
+        self.max_cached_graphs = self.continuous_batching_config.max_cached_graphs
+
+    @traced
+    def start(self) -> None:
+        """Start the background generation thread."""
+        if self._generation_thread is not None and self._generation_thread.is_alive():
+            logger.warning("Manager thread is already running.")
+            return
+        self.stop_event.clear()
+        self.fatal_error = None
+        self._generation_thread = threading.Thread(target=self._run_generation_loop)
+        self._generation_thread.start()
+
+    def is_running(self) -> bool:
+        """Check if the background generation thread is running."""
+        return self._generation_thread is not None and self._generation_thread.is_alive()
+
+    def warmup(self) -> None:
+        """Pre-capture CUDA graphs for varlen and decode paths by running dummy batches. Initializes the batch
+        processor if not already done."""
+        if self.batch_processor is None:
+            self.batch_processor = self._create_batch_processor()
+        self.batch_processor.warmup(self.model)
+        self.warmed_up = True
+
+    # NOTE: don't forget to update `continuous_batching_context_manager` when changing this method's definition
+    def stop(self, block: bool = True, timeout: float | None = None, keep_for_next_session: bool = False) -> None:
+        """Signal the background thread to stop.
+
+        Args:
+            block: Whether to wait for the thread to stop
+            timeout: Maximum time to wait for the thread to stop
+            keep_for_next_session: Whether to cache this on the model for future use
+        """
+        if self.batch_processor is None:
+            logger.warning("\nBatch processor was not initialized.")
+        elif self.batch_processor.cache.use_prefix_sharing:
+            logger.info(
+                f"\nPrefix sharing was on. Total prefix length: {self.batch_processor.cache._total_prefix_length}"
+            )
+
+        if self._generation_thread is None:
+            suffix = " Hence the unstarted manager will not be kept for next session." if keep_for_next_session else ""
+            logger.warning("Manager not started." + suffix)
+            return
+
+        stop_trigger_time = perf_counter()
+        if not self.stop_event.is_set():
+            self.stop_event.set()
+            logger.info("Stopping continuous batching manager...")
+
+        if block:
+            self.join(stop_trigger_time, timeout)
+
+        # If the manager is not being kept for next session, we clear the batch processor
+        if not keep_for_next_session:
+            self.batch_processor = None
+        # Otherwise, we keep the batch processor and cache the manager as a model attribute
+        else:
+            logger.info("Continuous batching manager will be kept for next session.")
+            self.model._cached_continuous_batching_manager = self
+        # In all cases, a little cleanup is good
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    def join(self, stop_trigger_time: float, timeout: float | None = None) -> None:
+        """Wait for the background thread to finish.
+
+        Args:
+            timeout: Maximum time to wait for the thread to stop
+        """
+        if self._generation_thread is not None:
+            self._generation_thread.join(timeout=timeout)
+            if self._generation_thread.is_alive():
+                logger.warning(f"Generation thread did not exit after join timeout ({timeout}).")
+            else:
+                end = perf_counter()
+                logger.info(f"Continuous Batching Manager stopped after {end - stop_trigger_time:.2f}s.")
+                self._generation_thread = None
+
+    def add_request(
+        self,
+        input_ids: list[int],
+        request_id: str | None = None,
+        max_new_tokens: int | None = None,
+        streaming: bool = False,
+        record_timestamps: bool = False,
+        eos_token_id: int | list[int] | None = None,
+        **logit_processor_kwargs: Any,
+    ) -> str:
+        """Add a new generation request to the queue.
+
+        Args:
+            input_ids: Input token IDs to use as prompt
+            request_id: Optional custom request ID (auto-generated if None)
+            max_new_tokens: Maximum number of new tokens to generate
+            streaming: Whether to stream tokens as they're generated
+            record_timestamps: Whether to record timestamps for each generated token
+            eos_token_id: End-of-sequence token ID(s)
+            logit_processor_kwargs: Keyword arguments for the logits processor.
+
+        Returns:
+            str: The request ID
+        """
+        if request_id is None:
+            with self._request_lock:
+                request_id = f"req_{self._request_counter}"
+                self._request_counter += 1
+
+        max_new_tokens = self.generation_config.max_new_tokens if max_new_tokens is None else max_new_tokens
+        eos_token_id = self.generation_config.eos_token_id if eos_token_id is None else eos_token_id
+
+        # NOTE: do we want to handle a case when the user wants token ids returned instead of decoded text?
+        state = RequestState(
+            request_id=request_id,
+            initial_tokens=list(input_ids),
+            num_children=self.num_return_sequences - 1,
+            record_timestamps=record_timestamps,
+            max_new_tokens=max_new_tokens,
+            eos_token_id=eos_token_id,
+            streaming=streaming,
+            logit_processor_kwargs=logit_processor_kwargs,
+        )
+
+        # Use block=True with timeout to handle backpressure if queue is full
+        self.input_queue.put(state, block=True, timeout=10)
+        self._has_new_requests.set()
+        return request_id
+
+    def add_requests(
+        self,
+        inputs: list[list[int]],
+        max_new_tokens: int | None = None,
+        streaming: bool = False,
+        record_timestamps: bool = False,
+        **logit_processor_kwargs: Any,
+    ) -> None:
+        # Infer the request ids of all incoming requests
+        with self._request_lock:
+            request_ids = [f"req_{i}" for i in range(self._request_counter, self._request_counter + len(inputs))]
+            self._request_counter += len(inputs)
+        # If there is prefix sharing, we sort the inputs to maximize cache hits but keep the order of the requests
+        ids_and_inputs = list(zip(request_ids, inputs))
+        if self._use_prefix_sharing:
+            ids_and_inputs = sorted(ids_and_inputs, key=lambda x: x[1], reverse=True)
+        # Look for an EOS token ID in the generation config and then in the model config. If no EOS is found, we set it
+        # to -1 to avoid looking for it in each add_request call
+        eos_token_id = self.generation_config.eos_token_id
+        eos_token_id = self.model.config.eos_token_id if eos_token_id is None else eos_token_id
+        eos_token_id = -1 if eos_token_id is None else eos_token_id
+        # Add requests in order
+        for request_id, input_ids in ids_and_inputs:
+            self.add_request(
+                input_ids=input_ids,
+                request_id=request_id,
+                max_new_tokens=max_new_tokens,
+                streaming=streaming,
+                record_timestamps=record_timestamps,
+                eos_token_id=eos_token_id,
+                **logit_processor_kwargs,
+            )
+
+    def cancel_request(self, request_id: str) -> None:
+        """Cancel a request by its ID.
+
+        Args:
+            request_id: The ID of the request to cancel
+        """
+        if self.batch_processor is not None:
+            self.batch_processor.scheduler.set_request_cancellation(request_id)
+
+    # TODO:handle benchmarking properly when updating / fixing the requeue logic
+    def get_result(self, request_id: str | None = None, timeout: float | None = None) -> GenerationOutput | None:
+        """Retrieve one result from the output queue.
+
+        Args:
+            request_id: If set, only return results matching this ID (others are requeued).
+            timeout: Maximum time to wait for a result.
+
+        Returns:
+            Optional[GenerationOutput]: The result data or None if timeout.
+        """
+        if self._generation_thread is None and self.output_router.output_queue.empty():
+            return None
+        try:
+            result = self.output_router.output_queue.get(block=True, timeout=timeout)
+            if request_id is not None and result.request_id != request_id:
+                self.output_router.output_queue.put(result)
+                return None
+            return result
+        except queue.Empty:
+            return None
+
+    def __iter__(self):
+        """Iterate over results as they become available."""
+        while self._generation_thread is not None and self._generation_thread.is_alive():
+            result = self.get_result(timeout=0.1)
+            if result is not None:
+                yield result
+
+    def request_id_iter(self, request_id: str) -> Generator[GenerationOutput]:
+        """Iterate over results matching a specific request id (blocking).
+
+        Uses the shared output queue with requeue. For high-concurrency serving,
+        use :meth:`register_result_handler` instead.
+        """
+        while self._generation_thread is not None and self._generation_thread.is_alive():
+            result = self.get_result(request_id=request_id, timeout=0.1)
+            if result is not None:
+                yield result
+                if result.is_finished():
+                    return
+
+    def register_result_handler(self, request_id: str, callback: Callable) -> None:
+        """Register a callback for result delivery (streaming or non-streaming).
+
+        The callback is invoked on the event loop via ``call_soon_threadsafe``
+        each time a result is produced for this request. For streaming requests,
+        this happens on every token; for non-streaming, only on completion.
+
+        The handler is automatically cleaned up when the request finishes.
+
+        Args:
+            request_id (`str`): The request ID to receive outputs for.
+            callback (`callable`): Called with a ``GenerationOutput`` for each result.
+        """
+        loop = asyncio.get_running_loop()
+
+        def _auto_cleanup(result):
+            callback(result)
+            if result.is_finished():
+                with self.output_router._lock:
+                    self.output_router.result_handlers.pop(request_id, None)
+
+        with self.output_router._lock:
+            self.output_router.result_handlers[request_id] = (_auto_cleanup, loop)
+
+    @traced
+    def _generation_step(self) -> None:
+        """Perform a single generation step. This is mostly cuda graphed"""
+        if self.batch_processor is None:
+            raise RuntimeError("Tried to perform a generation step before the batch processor was initialized.")
+        self.batch_processor._generation_step(self.model)
+
+    def _create_batch_processor(self) -> ContinuousBatchProcessor:
+        # Resolve max_memory_percent now that we know whether any logit processors are active.
+        self.continuous_batching_config.resolve_max_memory_percent(self.logit_processor.do_processing)
+        # Create the PagedAttentionCache
+        paged_attention_cache = PagedAttentionCache(
+            self.model.config,
+            self.continuous_batching_config,
+            self.model.device,
+            self.model.dtype,
+            tp_size=getattr(self.model, "_tp_size", None),  # Use model's actual TP setting
+        )
+        self._use_prefix_sharing = paged_attention_cache.use_prefix_sharing  # update the approximation
+
+        # Create the scheduler
+        scheduler_type = self.continuous_batching_config.scheduler_type
+        scheduler = SCHEDULER_MAPPING.get(scheduler_type, None)
+        if scheduler is None:
+            logger.warning(f"Scheduler '{scheduler_type}' not found. Defaulting to FIFO.")
+            scheduler = FIFOScheduler
+
+        # Create the batch processor
+        batch_processor = ContinuousBatchProcessor(
+            cache=paged_attention_cache,
+            config=self.model.config,
+            generation_config=self.generation_config,
+            continuous_batching_config=self.continuous_batching_config,
+            logit_processor=self.logit_processor,
+            input_queue=self.input_queue,
+            output_router=self.output_router,
+            stop_event=self.stop_event,
+            model_device=self.model.device,
+            model_dtype=self.model.dtype,
+            scheduler=scheduler(paged_attention_cache),
+        )
+        return batch_processor
+
+    @torch.inference_mode()
+    def _run_generation_loop(self) -> None:
+        """Main processing loop running in the background thread."""
+        try:
+            # Try to retrieve an already initialized batch processor
+            batch_processor = getattr(self, "batch_processor", None)
+            # If the batch processor already exists, we just reset it for a new generation loop
+            if isinstance(batch_processor, ContinuousBatchProcessor):
+                batch_processor.reset()
+            # Otherwise, we create a new batch processor
+            else:
+                batch_processor = self._create_batch_processor()
+
+            # Start the generation loop
+            self.batch_processor = batch_processor
+            self.current_batch = 0
+
+            # If using the async API, we bootstrap the first batch w/out update
+            if batch_processor.use_async_batching:
+                if not batch_processor.prepare_next_batch():
+                    raise RuntimeError("Failed to bootstrap the first batch.")
+                self._generation_step()
+                self.current_batch += 1
+
+            while (not self.stop_event.is_set()) or batch_processor.has_pending_requests():
+                self._inner_generation_loop(batch_processor)
+                self.current_batch += 1
+
+            # In async mode, the last batch's results are still in flight - process them now
+            # We need to switch back to the pair that has the last batch's D2H pending
+            if isinstance(batch_processor.inputs_and_outputs, ContinuousBatchingAsyncIOs):
+                batch_processor.inputs_and_outputs.current_pair = 1 - batch_processor.inputs_and_outputs.current_pair
+                batch_processor.update_batch()
+
+        except Exception as e:
+            logger.error(f"Error in generation loop: {e}", exc_info=True)
+            self._handle_critical_error(e, batch_processor)
+        finally:
+            logger.info("Generation loop finished.")
+
+    @traced(span_name="generation_loop")
+    def _inner_generation_loop(self, batch_processor: ContinuousBatchProcessor) -> None:
+        # Loop body ends if there is no requests in the batch
+        if not batch_processor.prepare_next_batch():
+            # Wait for new requests instead of busy-spinning.
+            self._has_new_requests.wait(timeout=0.1)
+            self._has_new_requests.clear()
+            return
+        self._generation_step()
+        batch_processor.update_batch()
+
+    @traced
+    def _handle_critical_error(self, error: Exception, batch_processor: ContinuousBatchProcessor | None) -> None:
+        """Handle critical errors that terminate the generation loop."""
+        # Record so callers (e.g. the serving layer) can fail fast on subsequent requests
+        # instead of enqueuing into a worker that will never drain.
+        self.fatal_error = error
+        # Signal stop
+        self.stop_event.set()
+
+        # Fail pending requests in input queue
+        try:
+            while True:
+                req_data = self.input_queue.get_nowait()
+                if batch_processor is not None:
+                    batch_processor._handle_request_error(error, req_data)
+        except queue.Empty:
+            pass
+
+        # Fail active requests
+        if batch_processor is not None:
+            batch_processor.fail_all_requests(error)
+
+
+class ContinuousMixin:
+    """Mixin class for models to add continuous batching capabilities. Continuous batching has three entry points:
+    - `init_continuous_batching`, which is the actual entry point for continuous batching
+    - `continuous_batching_context_manager`, which itself is a wrapper around `init_continuous_batching`
+    - `generate_batch`, which is really a wrapper around `continuous_batching_context_manager`
+
+    They are defined in this order. Any change made to any of those three entry points should be reflected in the other
+    two.
+    """
+
+    generation_config: GenerationConfig
+
+    @torch.inference_mode()
+    def init_continuous_batching(
+        self,
+        generation_config: GenerationConfig | None = None,
+        continuous_batching_config: ContinuousBatchingConfig | None = None,
+        workload_hints: WorkloadHints | None = None,
+        **deprecated_kwargs,
+    ) -> ContinuousBatchingManager:
+        """Initialize a manager for continuous batching inference.
+
+        Args:
+            generation_config: An optional generation configuration, which may contain a CompileConfig object
+            continuous_batching_config: An optional continuous batching configuration
+            workload_hints: Optional WorkloadHints to help the continuous batching manager make better decisions for
+                default values
+            **deprecated_kwargs: Deprecated arguments that are now passed in the continuous_batching_config. Those are:
+                max_queue_size, q_padding_interval_size, kv_padding_interval_size, allow_block_sharing,
+                use_async_batching, max_cached_graphs
+        Returns:
+            `ContinuousBatchingManager`: The manager instance to add requests and retrieve results.
+        """
+        # Mandatory attributes
+        if not hasattr(self, "config") or not hasattr(self, "device") or not hasattr(self, "dtype"):
+            raise AttributeError("Model must have 'config', 'device', and 'dtype' attributes.")
+
+        # If a persistent manager is found we return it
+        cached_manager = getattr(self, "_cached_continuous_batching_manager", None)
+        if isinstance(cached_manager, ContinuousBatchingManager):
+            logger.info(
+                "Cached continuous batching manager found: it will be re-used instead of creating a new one. If you"
+                " want to create a new manager, you should call `destroy_cached_continuous_batching_manager` first."
+            )
+            return cached_manager
+
+        # Retrieve generation config
+        gen_config = generation_config if generation_config is not None else self.generation_config
+        if gen_config is None:
+            raise ValueError("A GenerationConfig must be provided or set in the model.")
+        # Warn about EOS
+        if gen_config.eos_token_id is None:
+            logger.warning("`eos_token_id` not set in GenerationConfig. Setting to -1 (disabled).")
+            gen_config.eos_token_id = -1
+
+        # Retrieve continuous batching config, or create it if none is provided
+        if continuous_batching_config is None:
+            if isinstance(getattr(gen_config, "continuous_batching_config", None), ContinuousBatchingConfig):
+                continuous_batching_config = gen_config.continuous_batching_config
+            else:
+                continuous_batching_config = ContinuousBatchingConfig()
+        continuous_batching_config.account_for_cb_deprecated_arguments(**deprecated_kwargs)
+        if workload_hints is not None:
+            workload_hints.resolve_using_hints(continuous_batching_config)
+
+        # Create and return the manager
+        return ContinuousBatchingManager(
+            model=self, generation_config=gen_config, continuous_batching_config=continuous_batching_config
+        )
+
+    def destroy_cached_continuous_batching_manager(self) -> None:
+        """Destroy the cached continuous batching manager and free GPU resources."""
+        cached_manager = getattr(self, "_cached_continuous_batching_manager", None)
+        if isinstance(cached_manager, ContinuousBatchingManager):
+            cached_manager.stop(block=True, timeout=None, keep_for_next_session=False)
+            delattr(self, "_cached_continuous_batching_manager")
+
+    @contextmanager
+    @torch.inference_mode()
+    def continuous_batching_context_manager(
+        self,
+        generation_config: GenerationConfig | None = None,
+        block: bool = True,
+        timeout: float | None = None,
+        continuous_batching_config: ContinuousBatchingConfig | None = None,
+        persistent_manager: bool = False,
+        warmup: bool = True,
+        workload_hints: WorkloadHints | None = None,
+        **deprecated_kwargs,
+    ) -> Generator[ContinuousBatchingManager]:
+        """A context manager to safely use the continuous batching manager. Arguments are similar to the ones of
+        `init_continuous_batching`, except for:
+            - block: whether to block the thread when stopping the manager. Default is True.
+            - timeout: maximum time to wait for the thread to stop. Default is None (no timeout).
+            - warmup: whether to pre-capture CUDA graphs at the largest sizes before running. Default is True.
+        """
+        manager = self.init_continuous_batching(
+            generation_config=generation_config,
+            continuous_batching_config=continuous_batching_config,
+            workload_hints=workload_hints,
+            **deprecated_kwargs,
+        )
+        if warmup and not manager.warmed_up:
+            # Warmup is long (~30 sec): best to signal the user it's happening than let them think the manager is stuck
+            logger.warning("Warming up for continuous batching...")
+            start = perf_counter()
+            manager.warmup()
+            logger.warning(f"Warming up completed in {perf_counter() - start:.2f}s.")
+        manager.start()
+        try:
+            yield manager
+        finally:
+            # This is a dummy log needed for the logs of stop to show. It won't show.
+            logger.debug("Continuous batching loop finished")
+            manager.stop(block=block, timeout=timeout, keep_for_next_session=persistent_manager)
+
+    # TODO: support streaming
+    @traced
+    @torch.inference_mode()
+    def generate_batch(
+        self,
+        inputs: list[list[int]],
+        generation_config: GenerationConfig | None = None,
+        continuous_batching_config: ContinuousBatchingConfig | None = None,
+        record_timestamps: bool = False,
+        progress_bar: bool = True,
+        persistent_manager: bool = False,
+        warmup: bool = True,
+        **kwargs,
+    ) -> dict[str, GenerationOutput]:
+        """Generate sequences for a batch of prompts using continuous batching.
+
+        Args:
+            inputs: List of input token sequences (prompts)
+            generation_config: Optional generation configuration
+            continuous_batching_config: Optional continuous batching configuration
+            record_timestamps: If set to true, the requests will have a timestamp for each token generated
+            progress_bar: If set to true, a progress bar will be displayed
+            persistent_manager: whether to persist the manager after the generation is finished. Default is False.
+            warmup: whether to pre-capture CUDA graphs before processing requests. Default is True.
+            **kwargs: Additional generation parameters. Only max_new_tokens is used, but other deprecated arguments
+                are extracted and passed to the continuous_batching_config object.
+        Returns:
+            `dict[str, GenerationOutput]`: a dictionary of request ids to GenerationOutput objects
+        """
+        # If no input are provided, return an empty dictionary
+        if not inputs:
+            return {}
+
+        # If the logger level is less than DEBUG, disable the progress bar
+        if logger.getEffectiveLevel() <= logging.DEBUG:
+            logger.warning("Progress bar is disabled when logger level is less than DEBUG")
+            progress_bar = False
+
+        # Extract deprecated arguments from regular kwargs (deprecated in v5.3). These args are now expected in the
+        # continuous_batching_config object.
+        deprecated_kwargs = {}
+        deprecated_keys = [
+            "q_padding_interval_size",
+            "kv_padding_interval_size",
+            "allow_block_sharing",
+            "use_async_batching",
+            "max_cached_graphs",
+            "max_queue_size",
+        ]
+        for depr_key in deprecated_keys:
+            if depr_key in kwargs:
+                deprecated_kwargs[depr_key] = kwargs.pop(depr_key)
+
+        # Compute the total number of requests
+        gen_cfg = self.generation_config if generation_config is None else generation_config
+        num_return_sequences = gen_cfg.num_return_sequences if gen_cfg.num_return_sequences is not None else 1
+        num_requests = len(inputs) * num_return_sequences
+
+        # Extract max_new_tokens from kwargs because it's the only expected kwarg
+        max_new_tokens = kwargs.pop("max_new_tokens", None)
+        max_new_tokens = gen_cfg.max_new_tokens if max_new_tokens is None else max_new_tokens
+
+        # Compute workload hints
+        workload_hints = WorkloadHints(
+            max_prompt_length=max(len(input_ids) for input_ids in inputs),
+            max_generated_length=max_new_tokens if max_new_tokens is not None else 0,
+        )
+
+        # Prepare context managers for the main loop
+        manager_cm = self.continuous_batching_context_manager(
+            generation_config=generation_config,
+            continuous_batching_config=continuous_batching_config,
+            block=True,
+            timeout=5,
+            persistent_manager=persistent_manager,
+            warmup=warmup,
+            workload_hints=workload_hints,
+            **deprecated_kwargs,
+        )
+        logging_cm = logging_redirect_tqdm([logger])
+        pbar_cm = tqdm(
+            total=num_requests,
+            disable=(not progress_bar),
+            desc=f"Solving {num_requests} requests",
+            unit="request",
+        )
+
+        # Main loop
+        results = {}
+        finished_count = 0
+        with manager_cm as manager, logging_cm, pbar_cm as pbar:
+            try:
+                manager.add_requests(inputs=inputs, max_new_tokens=max_new_tokens, record_timestamps=record_timestamps)
+                while finished_count < num_requests:
+                    result = manager.get_result(timeout=1)
+                    if result:
+                        req_id = result.request_id
+                        if result.is_finished():
+                            results[req_id] = result
+                            finished_count += 1
+                            pbar.update(1)
+                    elif not manager.is_running():
+                        logger.error("Generation thread terminated unexpectedly.")
+                        # This helps get some information in stdout
+                        print("Returning results of generate_batch despite unexpected termination.")
+                        break
+
+            except Exception as e:
+                logger.error(f"Error during batch generation: {e}", exc_info=True)
+
+        # Re-order requests to match the order of the inputs
+        reordered_results = {}
+        for i in range(len(inputs)):
+            # We cannot guarantee generation success for all requests, so check if the request is in the results
+            result = results.get(f"req_{i}")
+            if result is not None:
+                reordered_results[f"req_{i}"] = result
+            else:
+                logger.error(f"Request req_{i} not found in results.")
+        return reordered_results

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/input_outputs.py

@@ -0,0 +1,821 @@
+# Copyright 2026 The HuggingFace Inc. team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from contextlib import nullcontext
+from dataclasses import dataclass
+from functools import partial
+from typing import Any
+
+import torch
+
+from transformers.configuration_utils import PretrainedConfig
+
+from ...utils import get_available_devices
+from ...utils.metrics import traced
+from .cache import PagedAttentionCache
+from .cb_logits_processors import ContinuousBatchingLogitsProcessorList
+from .requests import TMP_TOKEN_ID, FutureRequestState, logger
+from .utils import CudaGraphBuffer, aligned_divide, attn_mask_is_needed, build_attention_mask, pad_to_pow2
+
+
+@dataclass
+class PagedAttentionArgs:
+    """Dataclass containing the keyword arguments for a forward pass using paged attention.
+
+    Attributes:
+        input_ids: Input token IDs tensor of shape `(1, total_query_tokens)`.
+        attention_mask: Attention mask tensor or dictionary mapping layer types to masks. Can be `None` if the
+            attention implementation doesn't require explicit masks.
+        position_ids: Position IDs tensor of shape `(1, total_query_tokens)`.
+        cu_seq_lens_q: Cumulative sequence lengths for queries, used for variable-length batching.
+        cu_seq_lens_k: Cumulative sequence lengths for keys/values. Can be a tensor or dictionary mapping layer
+            types (e.g., "full_attention", "sliding_attention") to tensors for hybrid models.
+        max_seqlen_q: Maximum query sequence length in the batch.
+        max_seqlen_k: Maximum key/value sequence length. Can be an int or dictionary for hybrid models.
+        write_index: List of tensors indicating where to write new KV states in the cache, one per attention group.
+        read_index: List of tensors indicating which cache positions to read from, one per attention group.
+        logits_indices: Tensor indicating which positions in the output should be used for next-token prediction.
+        cache: The [`PagedAttentionCache`] instance managing the KV cache.
+        block_table: Block table for paged KV cache. If provided, uses `flash_attn_with_kvcache` for fused attention +
+            cache update. More information in src/transformers/integrations/flash_paged.py
+        logits_processor_args: List of tensors containing the arguments for the logits processors, one per request.
+        use_cache: Whether to use caching (always `False` in continuous batching as the cache is managed externally).
+    """
+
+    input_ids: torch.Tensor
+    attention_mask: torch.Tensor | dict[str, torch.Tensor] | None
+    position_ids: torch.Tensor
+    cu_seq_lens_q: torch.Tensor
+    cu_seq_lens_k: torch.Tensor | dict[str, torch.Tensor]
+    max_seqlen_q: int
+    max_seqlen_k: int | dict[str, int]
+    write_index: list[torch.Tensor]
+    read_index: list[torch.Tensor]
+    logits_indices: torch.Tensor
+    cache: PagedAttentionCache
+    block_table: torch.Tensor | None
+    logits_processor_args: torch.Tensor
+    use_cache: bool = False
+
+    def asdict(self) -> dict[str, Any]:
+        return {
+            "input_ids": self.input_ids,
+            "attention_mask": self.attention_mask,
+            "position_ids": self.position_ids,
+            "cu_seq_lens_q": self.cu_seq_lens_q,
+            "cu_seq_lens_k": self.cu_seq_lens_k,
+            "max_seqlen_q": self.max_seqlen_q,
+            "max_seqlen_k": self.max_seqlen_k,
+            "write_index": self.write_index,
+            "read_index": self.read_index,
+            "logits_indices": self.logits_indices,
+            "cache": self.cache,
+            "block_table": self.block_table,
+            "logits_processor_args": self.logits_processor_args,
+            "use_cache": self.use_cache,
+        }
+
+
+class ContinuousBatchingIOs:
+    """A class to hold inputs and outputs for a continuous batching forward pass, using static tensors as storage. The
+    class is meant to be self-contained, so once a set of inputs have been created, the class can be used to update the
+    batch alone.
+    """
+
+    static_inputs: int = 7  # Number of static inputs always present in the bulk tensor
+
+    def __init__(
+        self,
+        cache: PagedAttentionCache,
+        config: PretrainedConfig,
+        device: torch.device,
+        model_dtype: torch.dtype,
+        max_graphs: int,
+        return_logprobs: bool,
+        logit_processor: ContinuousBatchingLogitsProcessorList,
+        use_cuda_graph_varlen: bool = False,
+    ) -> None:
+        """Initialize the continuous batching I/O manager. Args:
+        - cache: The [`PagedAttentionCache`] instance managing the KV cache. Meant to be unique.
+        - config: The model's pretrained configuration.
+        - device: The device to allocate tensors on. If the device is CPU, then the memory is pinned.
+        - model_dtype: The data type for model computations.
+        - max_graphs: Maximum number of CUDA graphs to cache. Uses LRU eviction when full.
+        - return_logprobs: Whether to return log probabilities along with the token IDs.
+        - logit_processor: The [`ContinuousBatchingLogitsProcessorList`] object used to process the logits.
+        - use_cuda_graph_varlen: Whether CUDA graphs are enabled for the varlen (prefill) path.
+        """
+        # Memoize attributes
+        self.cache = cache
+        self.device = device
+        self.config = config
+        self.model_dtype = model_dtype
+        self.use_cuda_graph_varlen = use_cuda_graph_varlen
+        self.sliding_window = 1 if getattr(config, "sliding_window", None) is None else config.sliding_window
+        self.return_logprobs = return_logprobs
+        # Setup input-related accumulators
+        self.num_q_tokens = 0  # number of query tokens in the batch. Can be padded.
+        self.max_kv_read = 0  # number of KV tokens read from cache (maxed across all groups). Can be padded.
+        self.true_batch_size = 0
+        self.true_read_sizes = [0 for _ in range(cache.num_groups)]
+        self.true_write_sizes = [0 for _ in range(cache.num_groups)]
+        self.use_block_table = False  # True if all requests in batch have query_length == 1
+        # Setup other accumulators
+        self.requests_in_batch: list[FutureRequestState] = []
+        self.req_id_to_new_token_position: dict[str, int] = {}  # only used for async API
+        self.graphs: CudaGraphBuffer = CudaGraphBuffer(max_graphs)
+        self._trash_index = cache.trash_index
+        # Setup static tensors and compute stream
+        self._setup_static_tensors(logit_processor=logit_processor)
+        self._reset_static_tensors(full_reset=True)
+        self.compute_stream = torch.cuda.Stream(device=self.device) if device.type == "cuda" else None
+
+    @traced(standalone=True)
+    def _setup_static_tensors(self, logit_processor: ContinuousBatchingLogitsProcessorList) -> None:
+        """Allocates static tensors for generation inputs and outputs. This is called only once at init time, to avoid
+        repeated allocations and enable CUDA graphs. All tensors are allocated with maximum possible sizes.
+        The allocated tensors are:
+
+        - `_bulk_input_tensor`: Storage for all the small inputs: `input_ids`, `position_ids`, `cumulative_seqlens_q`,
+          `logits_indices`, `cumulative_seqlens_k`, `carry_over_ids`.
+        - `attention_mask`: Optional attention masks (only for eager/SDPA implementations)
+        - `write_index` and `read_index` storage: Cache indexing tensors for each attention group
+        - `output_ids`: Storage for generated token IDs and maybe log probabilities if return_logprobs is True
+        """
+        num_groups = self.cache.num_groups
+        max_batch_tokens = self.cache.max_batch_tokens
+        num_pages = self.cache.num_blocks * self.cache.block_size
+        # Pin memory on CPU only when an accelerator is available, to speed up H2D transfers
+        pin_memory = self.device.type == "cpu" and len(get_available_devices()) > 1
+
+        # Small inputs are allocated as slices in a larget tensor aligned to 128 bytes (32 * 4b). This reduces the
+        # reduces fragmentation, so it lowers the number of D2H transfers and speeds up transfers.
+        bulk_lines = self.static_inputs + logit_processor.tensors_required
+        bulk_columns = aligned_divide(max_batch_tokens + 1, 1, 32)
+        self._bulk_input_tensor = torch.empty(
+            (bulk_lines, bulk_columns), dtype=torch.int32, device=self.device, pin_memory=pin_memory
+        )
+        # Prepare a tensor to hold the default values for the logits processors
+        self.logits_processors_defaults = torch.empty(
+            (logit_processor.tensors_required, 1), dtype=torch.int32, device=self.device
+        )
+        logit_processor.fill_defaults(self.logits_processors_defaults)
+
+        self.input_ids = self._bulk_input_tensor[0, :max_batch_tokens]
+        self.position_ids = self._bulk_input_tensor[1, :max_batch_tokens]
+        self.cumulative_seqlens_q = self._bulk_input_tensor[2, : max_batch_tokens + 1]
+        self.logits_indices = self._bulk_input_tensor[3, :max_batch_tokens]
+        full_attention_cumulative_seqlens_k = self._bulk_input_tensor[4, : max_batch_tokens + 1]
+        sliding_attention_cumulative_seqlens_k = self._bulk_input_tensor[5, : max_batch_tokens + 1]
+        self.carry_over_ids = self._bulk_input_tensor[6, :max_batch_tokens]  # only used for async API
+
+        # For sequence length of KV, the entries in the dict depend on the model
+        self.cumulative_seqlens_k: dict[str, torch.Tensor] = {}
+        if self.cache.num_full_attention_groups:
+            self.cumulative_seqlens_k["full_attention"] = full_attention_cumulative_seqlens_k
+        if self.cache.num_sliding_attention_groups:
+            self.cumulative_seqlens_k["sliding_attention"] = sliding_attention_cumulative_seqlens_k
+
+        # Output tensor and scalars
+        num_output_rows = 2 if self.return_logprobs else 1
+        self.output_ids = torch.empty(
+            (num_output_rows, max_batch_tokens + 1), dtype=torch.int32, device=self.device, pin_memory=pin_memory
+        )
+        # Last output token is never changed and set to 0 for async carry on purpose
+        self.output_ids.zero_()
+        self.total_seqlen_q = 0
+        self.max_seqlen_q = 0
+        self.max_seqlen_k = dict.fromkeys(self.cumulative_seqlens_k.keys(), 0)
+
+        # If the attention mask is needed, it is allocated separately
+        if attn_mask_is_needed(self.config):
+            self.attention_mask = {}
+            for layer_type in self.cumulative_seqlens_k.keys():
+                self.attention_mask[layer_type] = torch.empty(
+                    size=(1, 1, max_batch_tokens, num_pages + max_batch_tokens),
+                    dtype=self.model_dtype,
+                    device=self.device,
+                    pin_memory=pin_memory,
+                )
+        else:
+            self.attention_mask = None
+
+        # No block table == No elements in the block table tensor
+        n = num_groups if self.cache.max_blocks_per_request > 0 else 0
+        self.block_table = torch.empty(
+            (n, max_batch_tokens, self.cache.max_blocks_per_request),
+            dtype=torch.int32,
+            device=self.device,
+            pin_memory=pin_memory,
+        )
+
+        # For other kwargs, we need a list of tensors with as many tensors as there are groups
+        self.write_index_storage = torch.empty(
+            (num_groups, max_batch_tokens), dtype=torch.int64, device=self.device, pin_memory=pin_memory
+        )
+        self.read_index_storage = torch.empty(
+            (num_groups, num_pages + max_batch_tokens), dtype=torch.int64, device=self.device, pin_memory=pin_memory
+        )
+        # For read index, the +T is because there are sentinel indices for seqlen_q when model uses a sliding window
+
+    def _transfer_inputs(
+        self, other: "ContinuousBatchingIOs", stream: torch.cuda.Stream, non_blocking: bool = False
+    ) -> None:
+        # Transfer accumulators
+        other.num_q_tokens = self.num_q_tokens
+        other.max_kv_read = self.max_kv_read
+        other.true_batch_size = self.true_batch_size
+        other.true_read_sizes = self.true_read_sizes[:]
+        other.true_write_sizes = self.true_write_sizes[:]
+        other.use_block_table = self.use_block_table
+        # Transfer scalar attributes
+        other.total_seqlen_q = self.total_seqlen_q
+        other.max_seqlen_q = self.max_seqlen_q
+        other.max_seqlen_k = dict(self.max_seqlen_k.items())
+        # Transfer static tensors
+        maybe_stream = torch.cuda.stream(stream) if stream is not None else nullcontext()
+        with maybe_stream:
+            other._bulk_input_tensor.copy_(self._bulk_input_tensor, non_blocking=non_blocking)  # fast bulk transfer
+            # Only transfer block_table for decode-only batches (when it's actually used)
+            if self.use_block_table:
+                other.block_table.copy_(self.block_table, non_blocking=non_blocking)
+            # Otherwise, we transfer the write indices (and read indices if the batch uses any cache reads)
+            else:
+                other.write_index_storage.copy_(self.write_index_storage, non_blocking=non_blocking)
+                if self.max_kv_read > 0:
+                    other.read_index_storage.copy_(self.read_index_storage, non_blocking=non_blocking)
+            # Transfer the attention masks if needed
+            if self.attention_mask is not None and other.attention_mask is not None:
+                for layer_type in self.attention_mask.keys():
+                    other.attention_mask[layer_type].copy_(self.attention_mask[layer_type], non_blocking=non_blocking)
+
+    @traced
+    @torch.no_grad()
+    def _reset_static_tensors(self, full_reset: bool = False) -> None:
+        """Reset static tensors for the next batch. For efficiency, this only resets the portions of tensors that were
+        actually used in the previous batch, using the attributes num_q_tokens and max_kv_read. If a (full_reset)
+        is requested, the entire tensor storage is reset.
+        """
+        # Compute the slice to reset
+        q_len = self.write_index_storage.size(-1) if full_reset else self.num_q_tokens
+        kv_len = self.read_index_storage.size(-1) if full_reset else self.max_kv_read
+
+        # Reset the attributes part of the bulk input tensor in one kernel
+        self._bulk_input_tensor[: self.static_inputs, : q_len + 1].zero_()
+        if full_reset:
+            self._bulk_input_tensor[self.static_inputs :] = self.logits_processors_defaults
+        self.max_seqlen_q = 0
+
+        # Reset the logits indices and output ids
+        self.logits_indices[:q_len].zero_()
+        self.output_ids[:, :q_len].zero_()
+
+        # Reset the attributes that are either tensors or dict of tensors
+        for layer_type in self.cumulative_seqlens_k:
+            self.max_seqlen_k[layer_type] = 0
+            if self.attention_mask is not None:
+                self.attention_mask[layer_type][:, :, :q_len, : q_len + kv_len].fill_(
+                    torch.finfo(self.model_dtype).min
+                )
+
+        # If this is a full reset, we reset every tensors
+        if full_reset:
+            self.block_table[:, :q_len].fill_(-1)
+            self.write_index_storage[:, :q_len].fill_(self._trash_index)
+            self.read_index_storage[:, : q_len + kv_len].fill_(self._trash_index)
+        # If this is not a full reset, and we are going to use the block table, we only reset it
+        elif self.use_block_table:
+            self.block_table[:, :q_len].fill_(-1)
+        # Otherwise, the read and write indices are the ones used, so we reset them
+        else:
+            self.write_index_storage[:, :q_len].fill_(self._trash_index)
+            self.read_index_storage[:, : q_len + kv_len].fill_(self._trash_index)
+
+    def reset(self) -> None:
+        """Reset all relevant states for a new generation loop."""
+        self._reset_static_tensors(full_reset=True)
+        self.requests_in_batch = []
+        self.req_id_to_new_token_position = {}
+        if self.compute_stream is not None:
+            self.compute_stream.synchronize()
+
+    # These getter function help create a common interface for the sync and async IOs
+    def get_cumulative_seqlens(self) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        """Get the cumulative sequence lengths for the current batch."""
+        return self.cumulative_seqlens_q, self.cumulative_seqlens_k
+
+    def carry_over_tokens(
+        self, input_ids: torch.Tensor, carry_over_ids: torch.Tensor, prev_output_ids: torch.Tensor
+    ) -> None:
+        pass
+
+    def retrieve_device_outputs(self) -> None:
+        if self.compute_stream is not None:
+            self.compute_stream.synchronize()
+
+    def prepare_batch_update(self) -> tuple[list[FutureRequestState], list[int], list[float] | None]:
+        requests_in_batch = self.requests_in_batch
+        new_tokens = self.output_ids[0, : len(self.requests_in_batch)].tolist()
+        # If logprobs are generated, we retrieve them from the output tensor and cast them to the right dtype
+        if self.return_logprobs:
+            logprobs = self.output_ids[1, : len(self.requests_in_batch)].view(dtype=torch.float32).tolist()
+        # Otherwise, we can return an empty list because they wont be used
+        else:
+            logprobs = None
+        return requests_in_batch, new_tokens, logprobs
+
+    @traced
+    def prepare_batch_tensors(
+        self,
+        requests_in_batch: list[FutureRequestState],
+        logits_processors: ContinuousBatchingLogitsProcessorList,
+        use_decode_fast_path: bool,
+        num_q_tokens: int,
+        max_kv_read: int,
+    ) -> None:
+        """Prepare tensors and metadata for the next model forward pass, using the given requests as data. This method:
+
+        1. Resets the static tensors from the previous batch
+        2. Iterates through requests to accumulate input_ids, position_ids, and sequence lengths
+        3. Extends read/write indices for cache management
+        4. Builds attention masks if needed (for eager/SDPA implementations)
+        5. Converts accumulated lists to tensors and copies them to static storage
+
+        This method also modifies the `position_offset` attribute of each request to track progress and adds a
+        temporary token at the end of the requests for which there will a new token.
+        """
+        # Keep track of this requests in the batch, which will be useful to update the batch later
+        if not requests_in_batch:
+            raise ValueError("No requests in batch")
+
+        # Determine if the block table is used before we start to prepare the batch, to avoid useless preparation
+        self.use_block_table = use_decode_fast_path and self.block_table.numel() > 0
+        # Memoize the length of Q and KV
+        self.num_q_tokens = num_q_tokens
+        self.max_kv_read = 0 if self.use_block_table else max_kv_read  # No need to track KV read for decode-fast-path
+        self.true_batch_size = len(requests_in_batch)
+        # Reset the static storage that is going to be used for the next batch
+        self._reset_static_tensors()
+
+        # Reset accumulators
+        self.true_read_sizes = [0 for _ in range(self.cache.num_groups)]
+        self.true_write_sizes = [0 for _ in range(self.cache.num_groups)]
+        self.requests_in_batch = []
+        self.req_id_to_new_token_position = {}
+
+        # Prepare accumulators. For batches with no past cache to read, we leave read_index empty: the cache.update
+        # will detect the 0-size indices and skip the read.
+        input_ids = []
+        position_ids = []
+        cumulative_seqlens_q = [0]
+        logits_indices = []
+        cumulative_seqlens_k = {layer_type: [0] for layer_type in self.cumulative_seqlens_k.keys()}
+        write_index = [[] for _ in range(self.cache.num_groups)]
+        read_index = None if self.max_kv_read == 0 else [[] for _ in range(self.cache.num_groups)]
+
+        # Go through all the requests in the batch
+        for i, future_state in enumerate(requests_in_batch):
+            # First we retrieve the lengths related to the request
+            state = future_state.state
+            past_length = state.position_offset
+            query_length = future_state.query_length
+            seqlens_k = self.cache.get_seqlens_k(past_length, query_length)
+
+            # Update the internal state of the request
+            state.position_offset += query_length
+
+            # Then we accumulate for the object used in the kwargs
+            input_ids.extend(state.tokens_to_process)
+            position_ids.extend(range(past_length, past_length + query_length))
+            cumulative_seqlens_q.append(cumulative_seqlens_q[-1] + query_length)
+            self.max_seqlen_q = max(self.max_seqlen_q, query_length)
+
+            # Accumulate the key sequence lengths for the current request
+            for layer_type, layer_type_seqlen_k in seqlens_k.items():
+                cumulative_seqlens_k[layer_type].append(cumulative_seqlens_k[layer_type][-1] + layer_type_seqlen_k)
+                self.max_seqlen_k[layer_type] = max(self.max_seqlen_k[layer_type], layer_type_seqlen_k)
+
+            # We extend the read and write indices for the cache, or fill the block table for decode-only batches
+            if self.use_block_table:
+                self.cache.fill_block_table(state.request_id, past_length, query_length, self.block_table[:, i])
+            else:
+                self.cache.extend_read_and_write_indices(
+                    state.request_id, past_length, query_length, read_index, write_index
+                )
+
+            # If the request has no remaining prefill tokens, it means the next token prediction is relevant
+            if future_state.has_new_token:
+                logits_indices.append(cumulative_seqlens_q[-1] - 1)
+                state.tokens_to_process = [TMP_TOKEN_ID]
+                self.req_id_to_new_token_position[state.request_id] = logits_indices[-1]
+
+            self.requests_in_batch.append(future_state)
+
+        # Also prepare the tensor arguments for the logits processors
+        logits_processors.prepare_tensor_args(
+            requests_in_batch=requests_in_batch,
+            arg_storage=self._bulk_input_tensor[self.static_inputs :],
+        )
+
+        # When looping over request is done, we can build the actual tensors. This is faster than modifying the static
+        # tensors inside the loop.
+        to_tensor = partial(torch.tensor, dtype=torch.int32, device=self.device)
+
+        # Those kwargs always have the same type regardless of the model
+        self.input_ids[: len(input_ids)] = to_tensor(input_ids)
+        self.position_ids[: len(position_ids)] = to_tensor(position_ids)
+        self.cumulative_seqlens_q[: len(cumulative_seqlens_q)] = to_tensor(cumulative_seqlens_q)
+        self.logits_indices[: len(logits_indices)] = to_tensor(logits_indices)
+        self.total_seqlen_q = cumulative_seqlens_q[-1]
+
+        # Those kwargs are either dict of tensors or tensors, so we need to handle both cases
+        for layer_type, layer_type_seqlens_k in cumulative_seqlens_k.items():
+            self.cumulative_seqlens_k[layer_type][: len(layer_type_seqlens_k)] = to_tensor(layer_type_seqlens_k)
+            if self.attention_mask is not None:
+                build_attention_mask(
+                    attention_mask=self.attention_mask[layer_type],
+                    cumulative_seqlens_q=cumulative_seqlens_q,
+                    cumulative_seqlens_k=layer_type_seqlens_k,
+                    sliding_window=self.sliding_window if layer_type == "sliding_attention" else 1,
+                )
+
+        # If we are not using the block table, we populate the write indices (and maybe the read indices)
+        if not self.use_block_table:
+            to_index_tensor = partial(torch.tensor, dtype=torch.int64, device=self.device)
+            for i, group_write_indices in enumerate(write_index):
+                self.write_index_storage[i, : len(group_write_indices)] = to_index_tensor(group_write_indices)
+                self.true_write_sizes[i] = len(group_write_indices)
+            if read_index is not None:
+                for i, group_read_indices in enumerate(read_index):
+                    self.read_index_storage[i, : len(group_read_indices)] = to_index_tensor(group_read_indices)
+                    self.true_read_sizes[i] = len(group_read_indices)
+
+    def get_model_kwargs(self, use_padding: bool = False) -> dict[str, Any]:
+        """Get model keyword arguments for the current batch, eventually padding the query dimension and KV dimensions
+        if use_padding is True. The padding is only useful if we want static shapes, like when using cuda graphs."""
+        q_size = self.num_q_tokens
+        kv_size = self.max_kv_read + self.num_q_tokens
+        batch_size = self.num_q_tokens if use_padding else self.true_batch_size
+
+        # Prepare the kwargs, the attributes that are either tensors or dict of tensors are initialized to empty dicts.
+        kwargs = PagedAttentionArgs(
+            input_ids=self.input_ids[:q_size].unsqueeze(0),
+            position_ids=self.position_ids[:q_size].unsqueeze(0),
+            cu_seq_lens_q=self.cumulative_seqlens_q[: batch_size + 1],
+            max_seqlen_q=self.max_seqlen_q,
+            logits_indices=self.logits_indices[:q_size],
+            logits_processor_args=self._bulk_input_tensor[self.static_inputs :, :q_size],
+            cu_seq_lens_k={},
+            max_seqlen_k={},
+            attention_mask=None if self.attention_mask is None else {},
+            read_index=[],
+            write_index=[],
+            cache=self.cache,
+            block_table=self.block_table[:, :batch_size] if self.use_block_table else None,
+            use_cache=False,
+        )
+
+        # If there is padding, make sure the padding sequences have length 0 (ie. cumulative lengths plateau)
+        if use_padding:
+            kwargs.cu_seq_lens_q[self.true_batch_size + 1 :] = self.total_seqlen_q
+            # Additionally, if there are CUDA graphs, we need to pad max_seqlen so graph capture will work regardless of
+            # the future Q / KV lengths of the next batches
+            if not self.use_block_table and self.use_cuda_graph_varlen:
+                self.max_seqlen_q = q_size
+                self.max_seqlen_k = {
+                    layer_type: pad_to_pow2(self.max_seqlen_k[layer_type], self.cache.num_pages, 1024)
+                    for layer_type in self.max_seqlen_k.keys()
+                }
+
+        # When using block table, max_seqlen_q and max_seqlen_k are not used by flash_attn_with_kvcache, so we set them
+        # to constant `1` to avoid dynamo guards on these changing integer values. This applies throughout this method.
+        kwargs.max_seqlen_q = 1 if self.use_block_table else self.max_seqlen_q
+
+        # For the attributes that are lists of tensors, we construct list of tensor references
+        for i in range(self.cache.num_groups):
+            write_index_size = q_size if use_padding else self.true_write_sizes[i]
+            kwargs.write_index.append(self.write_index_storage[i, :write_index_size])
+            # If there is no cache to read, pass a list of empty tensors so `cache.update` uses the write-only fast path
+            if self.max_kv_read == 0:
+                read_index_size = 0
+            else:
+                read_index_size = kv_size if use_padding else self.true_read_sizes[i]
+            kwargs.read_index.append(self.read_index_storage[i, :read_index_size])
+
+        # For the attributes that are dict of tensors, we first fill the dict with the actual values
+        for layer_type, seqlens_k in self.cumulative_seqlens_k.items():
+            kwargs.cu_seq_lens_k[layer_type] = seqlens_k[: batch_size + 1]
+            if use_padding:
+                kwargs.cu_seq_lens_k[layer_type][self.true_batch_size + 1 :] = seqlens_k[self.true_batch_size]
+            kwargs.max_seqlen_k[layer_type] = 1 if self.use_block_table else self.max_seqlen_k[layer_type]
+            if self.attention_mask is not None:
+                k_len = kv_size if use_padding else seqlens_k[batch_size]
+                kwargs.attention_mask[layer_type] = self.attention_mask[layer_type][..., :q_size, :k_len]
+
+        # If there is only one layer type, we remove the dicts around some attributes to avoid unnecessary overhead
+        if len(self.cumulative_seqlens_k.keys()) == 1:
+            kwargs.cu_seq_lens_k = kwargs.cu_seq_lens_k.popitem()[1]  # type: ignore
+            kwargs.max_seqlen_k = kwargs.max_seqlen_k.popitem()[1]  # type: ignore
+            if self.attention_mask is not None:
+                kwargs.attention_mask = kwargs.attention_mask.popitem()[1]  # type: ignore
+
+        return kwargs.asdict()  # TODO: this is imperfect, check if there is no better way to juggle dict / dataclass
+
+    def get_cb_kwargs(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Returns the tensors used inside the generation step that are not inputs to the model forward pass. In
+        synchronous batching, there is no carry over, so the only tensor that will be used is output_ids, but we still
+        return 3 tensors to have the same interface as when using async batching."""
+        return self.carry_over_ids, self.output_ids, self.output_ids
+
+    def _get_graph_key(self) -> tuple[int, ...]:
+        # Keys for decode fast path
+        if self.use_block_table:
+            return (self.num_q_tokens,)
+        # Keys for varlen path
+        return (self.num_q_tokens, self.max_kv_read, *self.max_seqlen_k.values())
+
+    def get_graph(self) -> torch.cuda.CUDAGraph | None:
+        key = self._get_graph_key()
+        graph = self.graphs.get_graph(key)
+        # If this point is reached, it means the next step will be a new graph capture
+        if graph is None:
+            self.graphs.plan_for_new_graph()
+            logger.info(f"Creating graph for {key = }")
+        return graph
+
+    def set_graph(self, graph: torch.cuda.CUDAGraph) -> None:
+        key = self._get_graph_key()
+        self.graphs.set_graph(key, graph)
+        logger.info(f"Setting graph for {key = }")
+
+
+class HostDeviceIOPair:
+    def __init__(
+        self,
+        cache: PagedAttentionCache,
+        config: PretrainedConfig,
+        device: torch.device,
+        model_dtype: torch.dtype,
+        max_graphs: int,
+        return_logprobs: bool,
+        logit_processor: ContinuousBatchingLogitsProcessorList,
+        use_cuda_graph_varlen: bool = False,
+    ) -> None:
+        # The host IO has automatic pinned memory because it is created on the CPU
+        self.host_io = ContinuousBatchingIOs(
+            cache,
+            config,
+            torch.device("cpu"),
+            model_dtype,
+            max_graphs,
+            return_logprobs,
+            logit_processor,
+            use_cuda_graph_varlen,
+        )
+        self.device_io = ContinuousBatchingIOs(
+            cache,
+            config,
+            device,
+            model_dtype,
+            max_graphs,
+            return_logprobs,
+            logit_processor,
+            use_cuda_graph_varlen,
+        )
+        # Create events only on CUDA devices
+        self.h2d_over = torch.cuda.Event() if torch.cuda.is_available() else None
+        self.compute_over = torch.cuda.Event() if torch.cuda.is_available() else None
+        self.d2h_over = torch.cuda.Event() if torch.cuda.is_available() else None
+
+    def reset(self) -> None:
+        self.host_io.reset()
+        self.device_io.reset()
+        for event in [self.h2d_over, self.compute_over, self.d2h_over]:
+            if event is not None:
+                event.synchronize()
+
+    def transfer_inputs_h2d(self, stream: torch.cuda.Stream) -> None:
+        self.host_io._transfer_inputs(self.device_io, stream=stream, non_blocking=True)
+
+    def transfer_outputs_d2h(self, stream: torch.cuda.Stream | None) -> None:
+        maybe_stream = torch.cuda.stream(stream) if stream is not None else nullcontext()
+        with maybe_stream:
+            self.host_io.output_ids.copy_(self.device_io.output_ids, non_blocking=True)
+
+
+class ContinuousBatchingAsyncIOs:
+    """A class to handle the inputs and outputs for the asynchronous API. It uses two IO pairs to avoid race conditions
+    between the two batches, which means twice as more VRAM is used for static input tensors and CUDA graph. If your GPU
+    is large enough or you want to generate long sequences, this is a good trade-off to make.
+
+    Asynchronous batching works by creating two pairs of host - device inputs and ouputs:
+
+                                    inputs
+                      ┌──────────┐ ────────► ┌────────────┐
+    IO pair object:   │ Host IOs │           │ Device IOs │       (for a CUDA sytem, Host = CPU and Device = GPU)
+                      └──────────┘ ◄──────── └────────────┘
+                                    outputs
+
+    Each pair is separate from the other. This means that each pairs has its own CUDA graphs set, because CUDA graphs
+    need to have static adresses for input tensors. To have a unique set of CUDA graph, we would need to copy the input
+    tensors to a third device-side buffer. This could limit the memory cost of CUDA graphs but would slow down the
+    forward pass.
+    But the CUDA streams orchestrating the transfer from host to device (H2D) and device to host (D2H) are the same for
+    both pairs. Same for the compute stream.
+    The order of steps in async batching looks like this (for 3 batches of compute):
+
+         │ ┌────┬────┐                  ┌────┬────┐     ┌────┬────┐       ┌────┐          ┌────┐
+    CPU  │ │PR 0│PR 1│                  │UP 0│PR 2│     │UP 1│PR 3│       │UP 2│          │UP 3│
+         │ └────┼───┬┴──┐               └────┴────┼───┐ └────┴────┼───┐   └────┘          └────┘
+    H2D  │      │0->│1->│               ¦         │2->│ ¦         │3->│   ¦               ¦
+         │      └───┼───┴───────────┬─────────────┴─┬─┼───────────┴───┼───────────────┐   ¦
+    GPU  │          │   COMPUTE 0   │   COMPUTE 1   │█│   COMPUTE 2   │   COMPUTE 3   │   ¦
+         │          └─────────────���─┼───┬───────────┼─┴─┬─────────────┼───┬───────────┼───┤
+    D2H  │                          │0<-│           │1<-│             │2<-│           │3<-│
+         │                          └───┘           └───┘             └───┘           └───┘
+
+    with: - CPU: actions happening on the CPU (host-side)
+          - GPU: actions happening on the GPU (device-side)
+          - H2D: host to device transfer
+          - D2H: device to host transfer
+    and:
+          - PR N: preparation of batch N
+          - ->N: host to device transfer of batch N
+          - COMPUTE N: compute step for batch N
+          - <-N: device to host transfer of batch N
+          - UP N: update of batch N
+
+    You can see that the GPU is almost always busy, except where the █ is.
+    Proper ordering of steps is ensured through the use of CUDA events and streams.
+    """
+
+    def __init__(
+        self,
+        cache: PagedAttentionCache,
+        config: PretrainedConfig,
+        device: torch.device,
+        model_dtype: torch.dtype,
+        max_graphs: int,
+        return_logprobs: bool,
+        logit_processor: ContinuousBatchingLogitsProcessorList,
+        use_cuda_graph_varlen: bool = False,
+    ) -> None:
+        # Async batching needs streams to function, so check is CUDA is available
+        if not torch.cuda.is_available():
+            raise RuntimeError(f"Async batching requires CUDA, but {torch.cuda.is_available() = }")
+        # IO pairs used to avoid race conditions
+        self.current_pair = 0
+        self.io_pairs = [
+            HostDeviceIOPair(
+                cache,
+                config,
+                device,
+                model_dtype,
+                max_graphs,
+                return_logprobs,
+                logit_processor,
+                use_cuda_graph_varlen,
+            )
+            for _ in range(2)
+        ]
+        # CUDA streams
+        self.h2d_stream = torch.cuda.Stream(device=device)
+        self.d2h_stream = torch.cuda.Stream(device=device)
+        self.compute_stream = torch.cuda.Stream(device=device)
+        # Set all unused compute streams to None
+        self.io_pairs[0].host_io.compute_stream = None
+        self.io_pairs[0].device_io.compute_stream = None
+        self.io_pairs[1].host_io.compute_stream = None
+        self.io_pairs[1].device_io.compute_stream = None
+        # Used in carry over ids computation
+        self.max_batch_tokens = cache.max_batch_tokens
+
+    # These methods are simple wrapper dispatching to the current IO pair
+    def get_cumulative_seqlens(self) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        return self.io_pairs[self.current_pair].host_io.get_cumulative_seqlens()
+
+    # The prepare_batch_tensor method also has to prepare the carry over ids
+    def prepare_batch_tensors(
+        self,
+        requests_in_batch: list[FutureRequestState],
+        logits_processors: ContinuousBatchingLogitsProcessorList,
+        use_decode_fast_path: bool,
+        num_q_tokens: int,
+        max_kv_read: int,
+    ) -> None:
+        io_pair = self.io_pairs[self.current_pair]
+        io_pair.host_io.prepare_batch_tensors(
+            requests_in_batch, logits_processors, use_decode_fast_path, num_q_tokens, max_kv_read
+        )
+        io_pair.host_io.carry_over_ids.copy_(self.infer_carry_over_ids())
+
+    def infer_carry_over_ids(self) -> torch.Tensor:
+        """Infers the ids of the tokens to carry over from batch N to batch N+1. In asynchronous batching mode, we can
+        schedule a request for batch N+1 without knowing the token predicted for that request in batch N. For that
+        reason, we might need to carry over tokens just predicted in batch N before launching the forwar pass of batch
+        N+1. This method computes the ids of the tokens to carry over."""
+        next_req_id_to_new_token_position = self.io_pairs[self.current_pair].host_io.req_id_to_new_token_position
+        prev_req_id_to_new_token_position = self.io_pairs[1 - self.current_pair].host_io.req_id_to_new_token_position
+        carry_over_ids = [-1 for _ in range(self.max_batch_tokens)]
+        # Carry over happens after the raw predictions have been indexed with logits_indices. So output_ids contains the
+        # a sequence of contiguous new tokens in the order the request were added to the batch. Eg:
+        # output_ids = [new_tok_req3, new_tok_req1, new_tok_req2]
+        # Since it's also the order of req_id_to_new_token_position, we just iterate over the old positions and look for
+        # a request_id match: if there is one, we carry the predicted token over to its new position.
+        for i, req_id in enumerate(prev_req_id_to_new_token_position.keys()):
+            new_token_position = next_req_id_to_new_token_position.get(req_id)
+            if new_token_position is not None:
+                carry_over_ids[new_token_position] = i
+        return torch.tensor(carry_over_ids, dtype=torch.int32)
+
+    # The get_model_kwargs method is where the H2D transfer happens
+    def get_model_kwargs(self, use_padding: bool = False) -> dict[str, Any]:
+        io_pair = self.io_pairs[self.current_pair]
+        io_pair.transfer_inputs_h2d(self.h2d_stream)
+        self.h2d_stream.record_event(io_pair.h2d_over)
+        self.compute_stream.wait_event(io_pair.h2d_over)
+        return io_pair.device_io.get_model_kwargs(use_padding=use_padding)
+
+    def get_cb_kwargs(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Returns the tensors used inside the generation step that are not inputs to the model forward pass. Those
+        tensors could be retrieved using this object, but it would trigger a recompile if using torch.compile. They are:
+        - output_ids: the output ids of the current batch
+        - prev_output_ids: the output ids of the previous batch, required to carry over outputs tokens of the previous
+            batch to the input tokens of the next batch.
+        - carry_over_ids: a mask representing how to carry over tokens.
+        """
+        current_pair = self.io_pairs[self.current_pair]
+        previous_pair = self.io_pairs[1 - self.current_pair]
+        return (
+            current_pair.device_io.carry_over_ids,
+            previous_pair.device_io.output_ids,
+            current_pair.device_io.output_ids,
+        )
+
+    def carry_over_tokens(
+        self, input_ids: torch.Tensor, carry_over_ids: torch.Tensor, prev_output_ids: torch.Tensor
+    ) -> None:
+        """As explained in the infer_carry_over_ids method, we might need to carry over tokens just predicted in batch N
+        before launching the forwar pass of batch N+1. This method performs the carry over, and is recorded in CUDA
+        graphs if they are enabled."""
+        # Compute tokens to carry over and the corresponding mask
+        carried_over_ids = prev_output_ids[0, carry_over_ids]
+        carried_over_mask = (carry_over_ids != -1).int()
+        # Truncate everything to the right size
+        carried_over_ids = carried_over_ids[: input_ids.size(1)]
+        carried_over_mask = carried_over_mask[: input_ids.size(1)]
+        # Perform the carry over
+        input_ids[0] = carried_over_ids * carried_over_mask + input_ids[0] * (1 - carried_over_mask)
+
+    # This is called during compute, so we always pick the device IO in the IO pair
+    @property
+    def output_ids(self) -> torch.Tensor:
+        # The output ids are used to copy_ the infered tokens: they need to be on the device
+        return self.io_pairs[self.current_pair].device_io.output_ids
+
+    def get_graph(self) -> torch.cuda.CUDAGraph | None:
+        return self.io_pairs[self.current_pair].device_io.get_graph()
+
+    def set_graph(self, graph: torch.cuda.CUDAGraph) -> None:
+        self.io_pairs[self.current_pair].device_io.set_graph(graph)
+
+    @property
+    def use_block_table(self) -> bool:
+        return self.io_pairs[self.current_pair].host_io.use_block_table
+
+    # The retrieve_device_outputs method is where the D2H transfer happens AND where we switch IO pair
+    def retrieve_device_outputs(self) -> None:
+        io_pair = self.io_pairs[self.current_pair]
+        # Wait for compute to finish before starting D2H transfer
+        self.compute_stream.record_event(io_pair.compute_over)
+        self.d2h_stream.wait_event(io_pair.compute_over)
+        # Transfer the outputs to the host
+        io_pair.transfer_outputs_d2h(self.d2h_stream)
+        self.d2h_stream.record_event(io_pair.d2h_over)
+        # Switch IO pair
+        self.current_pair = 1 - self.current_pair
+
+    # This method is called after the switch and not during the first batch
+    def prepare_batch_update(self) -> tuple[list[FutureRequestState], list[int], list[float] | None]:
+        io_pair = self.io_pairs[self.current_pair]
+        io_pair.d2h_over.synchronize()  # ty:ignore[unresolved-attribute]  <- this is always a CUDA event
+        return io_pair.host_io.prepare_batch_update()
+
+    def reset(self) -> None:
+        """Reset all state for a new generation session. Used in persistent mode between sessions."""
+        self.current_pair = 0
+        for io_pair in self.io_pairs:
+            io_pair.reset()
+        self.h2d_stream.synchronize()
+        self.d2h_stream.synchronize()
+        self.compute_stream.synchronize()

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/offloading_manager.py

@@ -0,0 +1,307 @@
+# Copyright 2026 The HuggingFace Inc. team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Centralized offloading logic for continuous batching.
+
+Handles two offloading strategies when the GPU KV cache is full:
+  1. CPU offloading: copy the KV cache to a pre-allocated pinned CPU buffer, preserving exact request state.
+  2. Soft reset: discard the KV cache and re-prefill from scratch when the request is re-scheduled. This incurs no data
+    transfer overhead, but we need to re-run prefill over all intial + generated tokens (so more compute overhead).
+
+The CPU swap pool is a static set of pinned tensors allocated once at init (like vLLM/SGLang). Blocks are tracked
+with a simple free set — no dynamic allocation or deallocation of tensors ever happens at runtime.
+"""
+
+from collections import deque
+from contextlib import nullcontext
+
+import torch
+
+from ...utils import is_psutil_available
+from .cache import PagedAttentionCache
+from .requests import FutureRequestState, RequestState, RequestStatus, logger
+from .scheduler import Scheduler
+
+
+class OffloadingManager:
+    """Manages request offloading and restoration for continuous batching.
+
+    Owns a static CPU swap pool (pre-allocated pinned tensors mirroring the GPU cache layout), performs GPU↔CPU block
+    copies, decides between CPU offloading and soft reset, and ensures cleanup on cancellation/failure/reset.
+    """
+
+    def __init__(
+        self,
+        cache: PagedAttentionCache,
+        scheduler: Scheduler,
+        cpu_offload_space_gib: float | None,
+        safety_threshold: float,
+        compute_stream: torch.cuda.Stream | None,
+    ) -> None:
+        self.cache = cache
+        self.scheduler = scheduler
+        # All offloading transfers run on the compute stream (stream-ordered, like the fork copy path)
+        self._compute_stream = compute_stream
+
+        # Bookkeeping defaults, valid whether or not the pool is allocated
+        self._cpu_key_cache: list[torch.Tensor] = []
+        self._cpu_value_cache: list[torch.Tensor] = []
+        self._gpu_key_views: list[torch.Tensor] = []
+        self._gpu_value_views: list[torch.Tensor] = []
+        self._free_cpu_blocks: deque[int] = deque()
+        self._request_id_to_cpu_blocks: dict[str, list[int]] = {}
+        self._request_id_to_group_block_counts: dict[str, list[int]] = {}
+
+        # Compute the size of the CPU swap pool in blocks
+        self._num_cpu_blocks = self._compute_num_cpu_blocks(cpu_offload_space_gib, safety_threshold)
+        offloading_enabled = cpu_offload_space_gib is not None and cpu_offload_space_gib > 0
+        if self._num_cpu_blocks == 0:
+            if offloading_enabled:
+                logger.warning(
+                    f"cpu_offload_space={cpu_offload_space_gib:.1f} GiB is too small for even one block. "
+                    "No CPU offloading."
+                )
+            return None
+
+        # Allocate the CPU swap pool
+        cpu_cache_shape = (self._num_cpu_blocks, cache.block_size, cache.num_key_value_heads, cache.head_dim)
+        for _ in cache.key_cache:
+            self._cpu_key_cache.append(torch.empty(cpu_cache_shape, dtype=cache.dtype, pin_memory=True))
+            self._cpu_value_cache.append(torch.empty(cpu_cache_shape, dtype=cache.dtype, pin_memory=True))
+
+        # Pre-view the GPU cache tensors as block-shaped so the hot copy paths avoid per-op .view() calls
+        block_shape = (-1, cache.block_size, cache.num_key_value_heads, cache.head_dim)
+        for k_cache, v_cache in zip(cache.key_cache, cache.value_cache):
+            self._gpu_key_views.append(k_cache.view(*block_shape))
+            self._gpu_value_views.append(v_cache.view(*block_shape))
+
+        # FIFO order favors contiguity when blocks are returned in bulk
+        self._free_cpu_blocks = deque(range(self._num_cpu_blocks))
+
+        # Reusable int32 scratch for cpu_ids / gpu_ids (bounded by _num_cpu_blocks on both paths)
+        self._cpu_ids_scratch = torch.empty(self._num_cpu_blocks, dtype=torch.int32, pin_memory=True)
+        self._gpu_ids_scratch = torch.empty(self._num_cpu_blocks, dtype=torch.int32, device=cache.device)
+
+        # Log the size of the CPU swap pool
+        cache_tensor = self._cpu_key_cache[0]
+        size_in_bytes = 2 * cache_tensor.numel() * cache_tensor.element_size() * len(cache.key_cache)
+        logger.info(
+            f"CPU swap pool initialized: {self._num_cpu_blocks} blocks ({size_in_bytes / (1024**3):.2f} GiB pinned)"
+        )
+
+    def _compute_num_cpu_blocks(self, cpu_offload_space_gib: float | None, safety_threshold: float) -> int:
+        """Returns the number of blocks that can fit in the CPU swap pool."""
+        # Compute the CPU pool size in bytes
+        offload_bytes = int(cpu_offload_space_gib * (1024**3)) if cpu_offload_space_gib is not None else None
+
+        # Determine the maximum number of bytes that can be offloaded based on the safety threshold
+        if is_psutil_available():
+            import psutil
+
+            total_ram = psutil.virtual_memory().available
+            max_bytes = int(total_ram * safety_threshold)
+        else:
+            max_bytes = None
+
+        # If both the request number of bytes and its limit are not None, we just clamp one to the other
+        if offload_bytes is not None and max_bytes is not None:
+            if offload_bytes > max_bytes:
+                clamped_gib = max_bytes / (1024**3)
+                logger.warning(
+                    f"cpu_offload_space={cpu_offload_space_gib:.1f} GiB exceeds {safety_threshold:.0%} of total RAM "
+                    f"({total_ram / (1024**3):.1f} GiB). Clamping to {clamped_gib:.1f} GiB."
+                )
+                offload_bytes = max_bytes
+        # Else if the max is None, throw a warning and accept the requested number of bytes as is
+        elif offload_bytes is not None:
+            logger.warning(
+                "psutil is not available — cpu_offload_space_safety_threshold cannot be enforced. "
+                "Install psutil to enable the safety cap."
+            )
+        # Else if the requested number of bytes is None, we use the max number of bytes as the requested number of bytes
+        elif max_bytes is not None:
+            offload_bytes = max_bytes
+            logger.warning(f"Auto-sizing CPU swap pool from safety threshold: {max_bytes / (1024**3):.2f} GiB.")
+        # Otherwise, it means the pool was supposed to be sized using psutil but it is not available
+        else:
+            raise ImportError(
+                "cpu_offload_space=None requires psutil to auto-size the CPU swap pool. Install psutil or pass an "
+                "explicit GiB value."
+            )
+
+        # Compute how many blocks fit in CPU pool
+        bytes_per_block = (
+            2                                 # one for key, one for value
+            * len(self.cache.key_cache)       # number of layers in a layer group
+            * self.cache.block_size           # block size
+            * self.cache.num_key_value_heads  # number of key value heads
+            * self.cache.head_dim             # head dimension
+            * self.cache.dtype.itemsize       # data type size in bytes
+        )  # fmt: skip
+        if bytes_per_block == 0:
+            raise ValueError("The number of bytes per block is 0. This is not possible.")
+        return offload_bytes // bytes_per_block
+
+    def _stream_ctx(self):
+        """Returns a context manager that runs enclosed ops on the compute stream, or a no-op when none is set."""
+        return torch.cuda.stream(self._compute_stream) if self._compute_stream is not None else nullcontext()
+
+    def offload_one_request(self) -> None:
+        """Offload one active request to make room in the GPU cache. Tries CPU offloading first; if the pool is full,
+        falls back to the legacy soft reset."""
+        scheduler = self.scheduler
+        request_id, state = scheduler.pop_request_to_evict()
+        logger.info(
+            f"Offloading request {request_id} with {len(state.initial_tokens)} initial tokens and "
+            f"{len(state.generated_tokens)} generated tokens."
+        )
+
+        # Try CPU offloading first, if it fails, we soft reset the request
+        offloaded_to_cpu = self._offload_to_cpu(request_id, state)
+        if offloaded_to_cpu:
+            # We set the allocated blocks to 0 so the scheduler re-allocates all blocks using position_offset.
+            state.allocated_blocks = 0
+            # DECODING requests have empty remaining_prefill_tokens, so we use tokens_to_process as a placeholder
+            # so the scheduler has at least 1 token to schedule and enters the allocation path.
+            if state._status == RequestStatus.DECODING:
+                state.remaining_prefill_tokens = state.tokens_to_process[:]
+            # Here, the new state is the same as the old one, but with the status set to PENDING. We bypass the setter
+            # to avoid the lifespan bookeeping and the associated warning
+            state._status = RequestStatus.PENDING
+            new_state = state
+            logger.debug(f"Offloaded request {request_id} to CPU: {len(self._free_cpu_blocks)} free blocks remaining.")
+        else:
+            new_state = state.create_equivalent_initial_request()
+            state._status = RequestStatus.FINISHED
+            logger.debug(f"Soft reset request {request_id}.")
+
+        scheduler.finish_request(request_id)
+        scheduler.add_waiting_request(new_state)
+        scheduler.block_new_requests = True
+
+    def restore_scheduled_requests(self, requests_in_batch: list[FutureRequestState]) -> None:
+        """Restore KV caches from CPU for any CPU-offloaded requests in the scheduled batch. Indices are accumulated
+        per group across all requests, then copied in one batched operation per layer."""
+        cache = self.cache
+        all_cpu_indices: list[int] = []
+        all_gpu_indices: list[int] = []
+
+        for future_state in requests_in_batch:
+            # Skip state that are not CPU-offloaded
+            state = future_state.state
+            if not state.is_cpu_offloaded:
+                continue
+            # TODO: if the H2D copy below raises, already-popped entries leak (never returned to _free_cpu_blocks)
+            # Accumulate CPU indices for this request
+            cpu_indices = self._request_id_to_cpu_blocks.pop(state.request_id)
+            group_counts = self._request_id_to_group_block_counts.pop(state.request_id)
+            all_cpu_indices.extend(cpu_indices)
+            # Accumulate GPU indices for this request, but since there may be extra block due to re-allocation, slice to
+            # match the number of blocks offloaded.
+            max_allocated_blocks = 0
+            for group_idx, n in enumerate(group_counts):
+                gpu_blocks = cache.group_cache_managers[group_idx].block_table.get(state.request_id, [])
+                all_gpu_indices.extend(gpu_blocks[:n])
+                max_allocated_blocks = max(max_allocated_blocks, n)
+            # Restore the state to non-offloaded state
+            state.is_cpu_offloaded = False
+            state.allocated_blocks = max_allocated_blocks  # ensures re-allocation is accounted for
+            # Prefix sharing: restored blocks will be re-hashed during the next update
+            if cache.allow_block_sharing:
+                future_state.complete_blocks += state.position_offset // cache.block_size
+            logger.debug(
+                f"Restored CPU-offloaded request {state.request_id} with {len(state.initial_tokens)} prefill tokens "
+                f"and {len(state.generated_tokens)} generated tokens."
+            )
+
+        # Early return if there are no copy to perform
+        if not all_cpu_indices:
+            return None
+
+        # Single batched copy for all requests (still, one copy per layer)
+        cpu_ids = self._cpu_ids_scratch[: len(all_cpu_indices)]
+        gpu_ids = self._gpu_ids_scratch[: len(all_cpu_indices)]
+        cpu_ids.copy_(torch.as_tensor(all_cpu_indices, dtype=torch.int32))  # cpu op, not in the stream
+        with self._stream_ctx():
+            gpu_ids.copy_(torch.as_tensor(all_gpu_indices, dtype=torch.int32))
+            for cpu_k, gpu_k in zip(self._cpu_key_cache, self._gpu_key_views):
+                gpu_k[gpu_ids].copy_(cpu_k[cpu_ids])
+            for cpu_v, gpu_v in zip(self._cpu_value_cache, self._gpu_value_views):
+                gpu_v[gpu_ids].copy_(cpu_v[cpu_ids])
+        self._free_cpu_blocks.extend(all_cpu_indices)
+
+    def free_request_cpu_cache(self, state: RequestState) -> None:
+        """Free CPU blocks for a single request (e.g., on cancellation)."""
+        if state.is_cpu_offloaded:
+            self._return_cpu_blocks(state.request_id)
+            state.is_cpu_offloaded = False
+
+    def free_all_waiting_cpu_caches(self) -> None:
+        """Free all CPU-offloaded caches in the waiting queue (e.g., on fail_all or reset)."""
+        for state in self.scheduler.waiting_requests.values():
+            self.free_request_cpu_cache(state)
+
+    def reset(self) -> None:
+        """Reset CPU offloading state for a new generation session."""
+        self.free_all_waiting_cpu_caches()
+        self._request_id_to_cpu_blocks.clear()
+        self._request_id_to_group_block_counts.clear()
+        self._free_cpu_blocks = deque(range(self._num_cpu_blocks))
+
+    def _offload_to_cpu(self, request_id: str, state: RequestState) -> bool:
+        """Copy a request's KV cache blocks from GPU to the static CPU swap pool. Returns True on success, False if
+        the pool is full."""
+
+        # Get the indices to offload from
+        gpu_indices = []
+        group_block_counts = []
+        for cm in self.cache.group_cache_managers:
+            blocks = cm.block_table.get(request_id, [])
+            gpu_indices.extend(blocks)
+            group_block_counts.append(len(blocks))
+
+        # No CPU offloading if there are no blocks to offload or not enough free blocks in the CPU swap pool
+        total_gpu_blocks = len(gpu_indices)
+        if total_gpu_blocks == 0 or len(self._free_cpu_blocks) < total_gpu_blocks:
+            return False
+
+        # Reserve CPU blocks from the free pool
+        cpu_indices = [self._free_cpu_blocks.popleft() for _ in range(total_gpu_blocks)]
+
+        # Offload using the compute stream so it does not interfere with current generation
+        cpu_ids = self._cpu_ids_scratch[:total_gpu_blocks]
+        gpu_ids = self._gpu_ids_scratch[:total_gpu_blocks]
+        cpu_ids.copy_(torch.as_tensor(cpu_indices, dtype=torch.int32))  # cpu op, not in the stream
+        with self._stream_ctx():
+            gpu_ids.copy_(torch.as_tensor(gpu_indices, dtype=torch.int32))
+            # Keys
+            for cpu_key_cache, gpu_key_view in zip(self._cpu_key_cache, self._gpu_key_views):
+                cpu_key_cache[cpu_ids].copy_(gpu_key_view[gpu_ids])
+            # Values
+            for cpu_value_cache, gpu_value_view in zip(self._cpu_value_cache, self._gpu_value_views):
+                cpu_value_cache[cpu_ids].copy_(gpu_value_view[gpu_ids])
+            # TODO: add asynchronous version of this
+            # TODO: can we get rid of this for loop? eg. by consolidating the cache.
+
+        # No explicit sync needed: finish_request is logical, and the next forward pass serializes on the same stream.
+        self._request_id_to_cpu_blocks[request_id] = cpu_indices
+        self._request_id_to_group_block_counts[request_id] = group_block_counts
+        state.is_cpu_offloaded = True
+        return True
+
+    def _return_cpu_blocks(self, request_id: str) -> tuple[list[int], list[int]]:
+        """Return CPU blocks to the free pool without copying anything."""
+        cpu_ids = self._request_id_to_cpu_blocks.pop(request_id)
+        group_counts = self._request_id_to_group_block_counts.pop(request_id)
+        self._free_cpu_blocks.extend(cpu_ids)
+        return cpu_ids, group_counts

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/requests.py

@@ -0,0 +1,361 @@
+# Copyright 2025 The HuggingFace Inc. team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import time
+from copy import deepcopy
+from dataclasses import dataclass, field
+from enum import IntEnum
+
+import torch
+
+from ...utils import is_psutil_available, is_torch_xpu_available
+from ...utils.logging import logging
+from ...utils.metrics import traced
+
+
+if is_psutil_available():
+    import psutil
+
+# This is a temporary token ID used to represent a token that is not yet generated
+# TODO: update this to 0 and check it breaks nothing + simplify carry over and time new logic
+TMP_TOKEN_ID = -1
+
+
+# We centralize the logger here to coordinate between logging and progress bar
+logger = logging.getLogger("ContinuousBatchingLogger")
+# Add a handler to the logger to print the logs to the console. Only happens once thanks to setting propagate to False.
+if logger.propagate:
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+    logger.propagate = False
+
+
+def get_device_and_memory_breakdown() -> tuple[torch.device, int, int, int]:
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()
+        # Use mem_get_info to get actual free memory: device_properties().total_memory returns the physical device
+        # total which ignores CUDA context and driver overhead (~0.5 GiB), leading to overcommit.
+        free_memory, total_memory = torch.cuda.mem_get_info(device)
+        reserved_memory = torch.cuda.memory_reserved(device)
+        allocated_memory = total_memory - free_memory
+    elif is_torch_xpu_available():
+        device = torch.device("xpu")
+        torch.xpu.empty_cache()
+        torch.xpu.synchronize()
+        total_memory = torch.xpu.get_device_properties(device).total_memory
+        reserved_memory = torch.xpu.memory_reserved(device)
+        allocated_memory = torch.xpu.memory_allocated(device)
+    elif torch.backends.mps.is_available() and torch.backends.mps.is_built():
+        device = torch.device("mps")
+        # MPS memory reporting (PyTorch 2.0+)
+        total_memory = torch.mps.driver_allocated_memory()
+        allocated_memory = total_memory - getattr(torch.mps, "recommended_max_memory")()
+        reserved_memory = 0  # MPS does not track reserved separately
+    else:
+        device = torch.device("cpu")
+        if is_psutil_available():
+            total_memory = psutil.virtual_memory().total
+            allocated_memory = psutil.Process().memory_info().rss
+            reserved_memory = allocated_memory
+        else:
+            logger.error(
+                "Cannot get memory breakdown on CPU without psutil: returning 0 for all memory values. Please install "
+                "psutil to get an actual memory breakdown."
+            )
+            total_memory = 0
+            reserved_memory = 0
+            allocated_memory = 0
+
+    return device, total_memory, reserved_memory, allocated_memory
+
+
+class RequestStatus(IntEnum):
+    """Status of a generation request through its lifecycle."""
+
+    PENDING = 0
+    PREFILLING = 1
+    DECODING = 2
+    FINISHED = 3
+    FAILED = 4
+
+
+@dataclass
+class GenerationOutput:
+    """Tracks the output of a generation request.
+
+    Attributes:
+        request_id (str): The ID of the generation request.
+        prompt_ids (list[int]): The IDs of the prompt tokens.
+        generated_tokens (list[int]): The generated tokens.
+        logprobs (list[float]): The log probabilities of the generated tokens.
+        error (Optional[str]): Any error message associated with the request. When None, the request was successful.
+        status (RequestStatus): The status of the request.
+        created_time (float): The time the request was created.
+        lifespan (tuple[float, float]): The time the request was no longer pending and the time the request finished.
+    """
+
+    request_id: str
+    prompt_ids: list[int] = field(default_factory=list)
+    generated_tokens: list[int] = field(default_factory=list)
+    logprobs: list[float] = field(default_factory=list)
+    error: str | None = None
+    status: RequestStatus = RequestStatus.PENDING
+    created_time: float = field(default_factory=time.perf_counter)
+    lifespan: tuple[float, float] = (-1, -1)  # (time request was no longer pending, time request finished)
+    timestamps: list[float] | None = None  # Timestamps of the generated tokens
+
+    def is_finished(self) -> bool:
+        return self.status == RequestStatus.FINISHED
+
+
+@dataclass
+class RequestState:
+    """Tracks the state of a generation request through its lifecycle.
+
+    Attributes:
+        request_id (str): The ID of the generation request.
+        initial_tokens (list[int]): The initial prompt tokens.
+        num_children (int): The number of children requests
+        full_prompt_ids (list[int] | None): The tokens IDs of the full prompt.
+        prompt_ids (list[int] | None): The tokens IDs currently being processed.
+        remaining_prompt_ids (list[int]): The initial tokens IDs remaining to be processed.
+        static_outputs (list[int]): The generated tokens.
+        allocated_blocks (int): The number of blocks allocated to the request.
+        position_offset (int): The current position in the sequence for position_ids.
+        status (RequestStatus): The status of the request: can be one of PENDING, PREFILLING, PREFILLING_SPLIT,
+                                SPLIT_PENDING_REMAINDER, DECODING, FINISHED, FAILED
+        max_new_tokens (int | None): The maximum number of new tokens to generate.
+        eos_token_id (None | int | list[int]): The ID(s) of the end-of-sequence tokens. Only used in post-init.
+        _eos_token_ids (set[int]): The IDs of the end-of-sequence tokens, formatted as a set.
+        streaming (bool): Whether to stream tokens as they're generated
+        created_time (float): The time the request was created.
+        error (Optional[str]): Any error message associated with the request. When None, has had no error yet.
+    """
+
+    # Required fields
+    request_id: str
+    initial_tokens: list[int]  # Initial prompt tokens # TODO: rename this as prefill tokens
+
+    # Optional fields (CB parameters)
+    streaming: bool = False  # Whether to stream tokens as they're generated
+    record_timestamps: bool = False  # Whether to record timestamps for the generated tokens
+
+    # Optional fields (generation parameters)
+    max_new_tokens: int | None = 20  # Maximum number of new tokens to generate. None means no limit. Default to 20.
+    eos_token_id: int | list[int] | None = None  # ID(s) of the end-of-sequence tokens. Only used in post-init.
+    num_children: int = 0  # Number of children requests
+    logit_processor_kwargs: dict = field(default_factory=dict)  # Keyword arguments for the logits processor.
+
+    # Internal fields (for scheduling)
+    tokens_to_process: list[int] = field(default_factory=list)  # Tokens IDs currently being processed
+    generated_tokens: list[int] = field(default_factory=list)  # Generated tokens
+    logprobs: list[float] = field(default_factory=list)  # Log probabilities of the generated tokens
+    position_offset: int = 0  # Current position in the sequence for position_ids
+    allocated_blocks: int = 0  # Number of blocks allocated to the request
+
+    _status: RequestStatus = RequestStatus.PENDING  # Status of the request, hidden behind a property
+    _eos_token_ids: set[int] = field(default_factory=set)  # IDs of the end-of-sequence tokens, formatted as a set
+
+    # Internal fields (for tracking)
+    created_time: float = field(default_factory=time.perf_counter)  # Time the request was created
+    error: str | None = None  # Error message if the request failed
+    lifespan: tuple[float, float] = (-1, -1)  # (time request was no longer pending, time request finished)
+    _timestamps: list[float] = field(default_factory=list)  # Timestamps of the generated tokens
+    _true_initial_tokens: int = 0  # The true number of initial tokens, useful when soft resetting requests
+    # TODO: remove the attribute above to _num_initial_tokens once initial_tokens is renamed
+
+    # Fields overwritten in __post_init__
+    _new_tokens_limit: int = 2147483647  # An int to check the max number of new tokens w/out always comparing w/ None
+    remaining_prefill_tokens: list[int] = field(default_factory=list)  # Initial tokens left to process
+    is_cpu_offloaded: bool = False  # True when the request's KV cache is in the CPU swap pool
+
+    def __post_init__(self):
+        # If no max length is set, we set an absurdly high value which will never be reached
+        self._new_tokens_limit = 2147483647 if self.max_new_tokens is None else self.max_new_tokens
+        # Keep a copy of the initial tokens to process
+        self.remaining_prefill_tokens = self.initial_tokens[:]
+        # Format the EOS token ID(s) as a set of ints. If there is no EOS token ID, it's an empty set
+        if self.eos_token_id is None:
+            pass
+        # If there is a single EOS token ID, add it to the set only if the ID is valid, ie. non-negative
+        elif isinstance(self.eos_token_id, int):
+            if self.eos_token_id >= 0:
+                self._eos_token_ids.add(self.eos_token_id)
+        # If there are multiple EOS token IDs, add them to the set only if they are valid, ie. non-negative
+        else:
+            for token_id in self.eos_token_id:
+                if token_id >= 0:
+                    self._eos_token_ids.add(token_id)
+
+    @property
+    def status(self) -> RequestStatus:
+        return self._status
+
+    @status.setter
+    def status(self, value: RequestStatus):
+        if self._status == RequestStatus.PENDING:
+            self.lifespan = (time.perf_counter(), -1)
+        elif value == RequestStatus.FINISHED:
+            self.lifespan = (self.lifespan[0], time.perf_counter())
+            self.log_end_of_request()
+        self._status = value
+
+    @property
+    def timestamps(self) -> list[float] | None:
+        return self._timestamps if self.record_timestamps else None
+
+    def log_end_of_request(self):
+        prefill_len = len(self.initial_tokens)
+        decode_len = self.generated_len()
+        start_time = self.lifespan[0] - self.created_time
+        end_time = self.lifespan[1] - self.created_time
+        logger.info(
+            f"Request {self.request_id} finished: {prefill_len = } {decode_len = } {start_time = } {end_time = }"
+        )
+
+    def current_len(self) -> int:
+        """Get the current length of the sequence (prompt + generated tokens)."""
+        return self.position_offset
+
+    def generated_len(self) -> int:
+        """Get the number of tokens generated so far."""
+        return len(self.generated_tokens)
+
+    # TODO: this logic seems one token off, check it out
+    @traced
+    def update_and_check_completion(self, token_id: int, logprob: float | None) -> bool:
+        """Update the request with a newly generated token (and optional log probability of the token) and check for
+        completion. Returns True if the request is now complete, False otherwise."""
+        # Only update if we're in decoding state # TODO: seems useless (always true) -- remove this
+        if self.status != RequestStatus.DECODING:
+            return False
+
+        # If we're recording timestamps, add timestamp to the list
+        if self.record_timestamps:
+            self._timestamps.append(time.perf_counter())
+
+        # Stop if we reached an EOS token
+        is_eos = token_id in self._eos_token_ids
+        current_len = self.generated_len()
+
+        # Replace the temporary token if we're not finishing due to max length
+        # (EOS tokens should still be added to the output)
+        if is_eos or (current_len < self._new_tokens_limit):
+            self.generated_tokens.append(token_id)
+            self.tokens_to_process = [token_id]  # this works for 2 levels of pipelines, but not sure for more
+            current_len += 1
+            if logprob is not None:
+                self.logprobs.append(logprob)
+        else:
+            logger.warning(f"Request {self.request_id} generated a useless token: {token_id}")
+
+        if is_eos or current_len >= self._new_tokens_limit:
+            self.status = RequestStatus.FINISHED
+            return True
+        return False  # We still need to process more tokens
+
+    def __repr__(self):
+        msg = [
+            f"request_id={self.request_id}",
+            f"status={self._status}",
+            f"out_tokens={self.generated_len()}",
+            f"query_length={len(self.tokens_to_process)}",
+            f"remaining_tokens={len(self.remaining_prefill_tokens)}",
+            f"kv_length={self.position_offset}",
+            f"full_prompt_length={len(self.initial_tokens)}",
+            f"allocated_blocks={self.allocated_blocks}",
+            f"generated_tokens={self.generated_tokens}",
+            f"logit_processor_kwargs={self.logit_processor_kwargs}",
+        ]
+        return "RequestState(\n\t" + ",\n\t".join(msg) + "\n)"
+
+    def to_generation_output(self):
+        """Convert the request state to a GenerationOutput object."""
+        if self._true_initial_tokens:
+            self.generated_tokens = self.initial_tokens[self._true_initial_tokens :] + self.generated_tokens
+            self.initial_tokens = self.initial_tokens[: self._true_initial_tokens]
+        return GenerationOutput(
+            request_id=self.request_id,
+            prompt_ids=self.initial_tokens,
+            generated_tokens=self.generated_tokens,
+            logprobs=self.logprobs,
+            error=self.error,
+            status=self.status,
+            created_time=self.created_time,
+            lifespan=self.lifespan,
+            timestamps=self.timestamps,
+        )
+
+    def fork(self, new_request_id: str) -> "RequestState":
+        """Fork the request into a new request with the same state except for request_id, created_time and lifespan."""
+        new_request = deepcopy(self)
+        # Update tracking fields
+        new_request.request_id = new_request_id
+        new_request.created_time = time.perf_counter()
+        new_request.lifespan = (new_request.created_time, -1)
+        new_request._timestamps = []
+        # Update fields overwritten in __post_init__
+        new_request.remaining_prefill_tokens = self.remaining_prefill_tokens[:]
+        return new_request
+
+    def get_request_config(self) -> dict:
+        """Get all the fields necessary to create a request that would have the same configuration."""
+        return {
+            "streaming": self.streaming,
+            "record_timestamps": self.record_timestamps,
+            "max_new_tokens": self.max_new_tokens,
+            "eos_token_id": self.eos_token_id,
+            "num_children": self.num_children,
+            "logit_processor_kwargs": deepcopy(self.logit_processor_kwargs),
+        }
+
+    def create_equivalent_initial_request(self) -> "RequestState":
+        """Creates an equivalent new request by removing the generated tokens and adding them to the initial prompt. The
+        created request has THE SAME request_id. Notably, we can retrieve the original request from the created one with
+        the _true_initial_tokens attribute. The logprobs of the generated tokens are kept in the new request."""
+
+        request_config = self.get_request_config()
+        # If there is a number of max new tokens, we update it to account for the already generated tokens
+        if self.max_new_tokens is not None:
+            request_config["max_new_tokens"] = self.max_new_tokens - len(self.generated_tokens)
+        # Create new request state
+        new_state = RequestState(
+            request_id=self.request_id,
+            initial_tokens=self.initial_tokens + self.generated_tokens,
+            logprobs=self.logprobs[:],
+            _true_initial_tokens=self._true_initial_tokens + len(self.initial_tokens),
+            **request_config,
+        )
+        # If the request has been soft reset once already, this stays the same
+        if self._true_initial_tokens:
+            new_state._true_initial_tokens = self._true_initial_tokens
+        # Otherwise, we set the true initial tokens to the number of initial tokens
+        else:
+            new_state._true_initial_tokens = len(self.initial_tokens)
+        return new_state
+
+
+class FutureRequestState:
+    """Tracks the current state of a request and the relevant information to update it."""
+
+    # This makes instantiating this class faster
+    __slots__ = ("state", "has_new_token", "complete_blocks", "query_length")
+
+    def __init__(self, state: RequestState, has_new_token: bool, complete_blocks: int, query_length: int) -> None:
+        self.state = state
+        self.has_new_token = has_new_token
+        self.complete_blocks = complete_blocks
+        self.query_length = query_length

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/scheduler.py

@@ -0,0 +1,431 @@
+# Copyright 2025 The HuggingFace Inc. team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import threading
+from abc import ABC, abstractmethod
+from collections import deque
+
+from ...utils.metrics import attach_tracer, traced
+from .cache import PagedAttentionCache
+from .requests import FutureRequestState, RequestState, RequestStatus, logger
+
+
+class Scheduler(ABC):
+    """
+    Abstract base class for scheduling requests in the continuous batch processor. Schedulers manage the lifecycle of
+    requests from when they are added to the waiting queue to when they are scheduled for processing. Different
+    schedulers implement different strategies for prioritizing and batching requests.
+    """
+
+    def __init__(self, cache: PagedAttentionCache):
+        self.cache = cache
+        self._cancellation_lock = threading.Lock()
+        # This is to compute the read cache used by a new request being scheduled
+        self.read_cache_limit = None if self.cache.num_full_attention_groups else self.cache.config.sliding_window
+        self.max_decode_fast_path_length = self.cache.max_blocks_per_request * self.cache.block_size
+        # Initialize mutable states via reset()
+        self.reset()
+
+    def reset(self) -> None:
+        """Reset scheduler state for a new generation loop."""
+        self.active_requests: dict[str, RequestState] = {}
+        self.waiting_requests: dict[str, RequestState] = {}
+        self.waiting_requests_order: deque[str] = deque()
+        self._requests_to_cancel: set[str] = set()
+        self._requests_to_fork: list[RequestState] = []
+        self.block_new_requests = False
+
+    @traced
+    def add_waiting_request(self, state: RequestState):
+        """Adds a request to the waiting list."""
+        self.waiting_requests[state.request_id] = state
+        self.waiting_requests_order.append(state.request_id)
+
+    @abstractmethod
+    def schedule_batch(
+        self, token_budget: int, cache_budget: int
+    ) -> tuple[list[FutureRequestState] | None, bool, int, int]:
+        """Schedules requests for the next batch based on available token and cache budgets. This method selects which
+        requests should be processed in the current batch, considering the budgets and the scheduler's prioritization
+        rules. The token_budget is the maximum number of tokens that can be processed in a batch, and the cache_budget
+        is the maximum number of KV cache entries that can be read in a batch.
+        Returns the list of scheduled requests in their "FutureRequestState" form, a boolean indicating if the decode
+        fast path can be used, the total number of query tokens and the maximum number of kv tokens read."""
+
+    @traced
+    def has_pending_requests(self) -> bool:
+        """Checks if there are requests ready to be processed."""
+        return bool(len(self.active_requests) or len(self.waiting_requests))
+
+    @traced
+    def finish_request(self, request_id: str) -> None:
+        """Completes processing of a request and frees its allocated cache blocks. This method is called
+        when a request has finished generation or encountered an error.
+        """
+        self.cache.free_blocks(request_id)
+        self.active_requests.pop(request_id, None)
+
+    def pop_request_to_evict(self) -> tuple[str, RequestState]:
+        """Remove and return an active request chosen as the eviction victim for cache-pressure offload or soft reset.
+        Picks the newest active request when `block_new_requests` is set, else the oldest."""
+        if self.block_new_requests:
+            return self.active_requests.popitem()
+        request_id = next(iter(self.active_requests))
+        return request_id, self.active_requests.pop(request_id)
+
+    @traced
+    def get_active_request_static_outputs(self, request_id: str) -> list[int]:
+        """Gets generated tokens for an active request."""
+        if request_id in self.active_requests:
+            return self.active_requests[request_id].generated_tokens
+        return []
+
+    @traced
+    def set_request_cancellation(self, request_id: str):
+        """Marks a request for cancellation."""
+        with self._cancellation_lock:
+            self._requests_to_cancel.add(request_id)
+
+    @traced
+    def clear_cancelled_requests(self) -> list[RequestState]:
+        """Remove all cancelled requests from active and waiting queues."""
+        cancelled_states = []
+        with self._cancellation_lock:
+            for request_id in self._requests_to_cancel:
+                state_a = self.active_requests.pop(request_id, None)
+                state_w = self.waiting_requests.pop(request_id, None)
+                # Invariant: a request is never in both queues; state_a or state_w picks the one it was in
+                state = state_a or state_w
+                if state is not None:
+                    cancelled_states.append(state)
+                if request_id in self.waiting_requests_order:
+                    self.waiting_requests_order.remove(request_id)
+                self.cache.free_blocks(request_id)
+            self._requests_to_cancel = set()
+        return cancelled_states
+
+    @traced
+    def request_is_cancelled(self, request_id: str) -> bool:
+        """Checks if a request has been cancelled or removed."""
+        return request_id in self._requests_to_cancel or (
+            request_id not in self.active_requests and request_id not in self.waiting_requests
+        )
+
+    @traced
+    def _allocate_blocks_if_needed(self, state: RequestState, len_next_tokens: int) -> bool:
+        """Allocate additional cache blocks for a request if the currently allocated blocks are insufficient to
+        accommodate the next tokens. It calculates how many blocks are needed based on the request's current
+        cache occupancy and the number of tokens to be processed. The allocation itself is done by the CacheAllocator
+        objects. Returns a boolean indicating if the allocation was successful or not.
+        """
+        # First we check that the occupancy is less than the requested length, then we allocate enough blocks to cover
+        # the requested length. This is done using `current_len` so it also works for offloaded requests.
+        current_len = state.current_len()
+        occupancy = state.allocated_blocks * self.cache.block_size - current_len
+        if occupancy < len_next_tokens or state.allocated_blocks == 0:
+            blocks_needed = ((len_next_tokens - occupancy + 1) // self.cache.block_size) + 1
+            allocated = self.cache.allocate_blocks(blocks_needed, state.request_id, state.allocated_blocks)
+            if allocated is None:
+                return False
+            state.allocated_blocks += allocated
+        return True
+
+    def _infer_request_tokens(self, state: RequestState, request_ids_to_remove_from_waiting: set[str]) -> list[int]:
+        """Prepares a request for processing in the current batch. If prefix sharing is enabled, and the request was
+        pending, this is where we look for a prefix match and split the request if found."""
+        # If prefix sharing is enabled, we look for a prefix match and split the request if found
+        if self.cache.use_prefix_sharing and state.status == RequestStatus.PENDING and not state.is_cpu_offloaded:
+            prefill_length = self.cache.search_prefix_match(state.request_id, state.remaining_prefill_tokens)
+            if prefill_length > 0:
+                self.active_requests[state.request_id] = state
+                request_ids_to_remove_from_waiting.add(state.request_id)
+                state.status = RequestStatus.PREFILLING
+                # We keep track of the number of allocated blocks to avoid double allocation
+                state.allocated_blocks += prefill_length // self.cache.block_size
+                # Even if we match the whole request, we keep at least 1 token to start decoding
+                prefill_length = min(prefill_length, len(state.remaining_prefill_tokens) - 1)
+                state.remaining_prefill_tokens = state.remaining_prefill_tokens[prefill_length:]
+                state.position_offset += prefill_length
+
+        # If the request is decoding, the tokens to process are already set
+        if state.status == RequestStatus.DECODING:
+            request_tokens = state.tokens_to_process
+        # Otherwise, the tokens to process are the remaining prefill tokens
+        else:
+            request_tokens = state.remaining_prefill_tokens
+        return request_tokens
+
+    def _schedule_request(
+        self,
+        state: RequestState,
+        request_tokens: list[int],
+        token_budget: int,
+        request_ids_to_remove_from_waiting: set[str],
+    ) -> None:
+        """Schedules a request for the current batch, updating the request's status according to the token budget left.
+        After a request is scheduled, it is part of the next batch unless there is an error.
+        If the request has children (for parallel decoding), it ensures at least one token remains before the request is
+        forked."""
+        # If the request has one or more children we make sure not to prefill it entirely
+        # This does not check the request state, but DECODING request already have children set to 0.
+        if state.num_children > 0 and token_budget >= len(request_tokens) - 1:
+            token_budget = len(request_tokens) - 1
+            self._requests_to_fork.append(state)
+
+        # Case: we can process the entire prompt/remainder
+        if len(request_tokens) <= token_budget:
+            if state.status == RequestStatus.PENDING:
+                self.active_requests[state.request_id] = state
+                request_ids_to_remove_from_waiting.add(state.request_id)
+            if state.status <= RequestStatus.PREFILLING:
+                state.tokens_to_process = state.remaining_prefill_tokens
+                state.remaining_prefill_tokens = []
+                # Although prefill will only be done after the batch being scheduled now, we set the status to DECODING
+                # to stay coherent when using asynchronous batching
+                state.status = RequestStatus.DECODING
+
+        # Otherwise: we need to split the request
+        else:
+            if state.status == RequestStatus.PENDING:
+                self.active_requests[state.request_id] = state
+                state.status = RequestStatus.PREFILLING
+                request_ids_to_remove_from_waiting.add(state.request_id)
+            state.remaining_prefill_tokens = request_tokens[token_budget:]
+            state.tokens_to_process = request_tokens[:token_budget]
+
+    def _process_candidates(
+        self,
+        candidates: list[RequestState],
+        token_budget: int,
+        cache_budget: int,
+        request_ids_to_remove_from_waiting: set[str],
+        safety_margin: float = 0.0,
+    ) -> tuple[list[FutureRequestState], bool, bool, int, int]:
+        """Schedules candidate requests for the current batch.
+
+        This method contains the common logic shared by all schedulers: it checks token and cache budgets, allocates
+        cache blocks if needed, updates request states, and tracks which waiting requests should be removed from the
+        waiting queue.
+        """
+        scheduled_requests = []
+        one_allocation_failed = False
+        decode_fast_path = self.cache.max_blocks_per_request > 0  # best way to check if decode fast path availability
+        safety_margins = safety_margin * self.cache.num_blocks
+        original_token_budget, original_cache_budget = token_budget, cache_budget
+
+        for state in candidates:
+            num_free_blocks = self.cache.get_num_free_blocks()
+            # If we are out the safety margin, we only accept decoding requests or the first prefill request
+            outside_safety_margin = num_free_blocks < safety_margins
+            if outside_safety_margin and scheduled_requests and state.status != RequestStatus.DECODING:
+                logger.info(
+                    f"Outside safety margin, breaking out of scheduling loop. {num_free_blocks = } {safety_margins = }"
+                )
+                break
+
+            # Infer the tokens that will be present in the batch if token budget is enough
+            request_tokens = self._infer_request_tokens(state, request_ids_to_remove_from_waiting)
+            # Account for token budget
+            request_len = min(len(request_tokens), token_budget)
+
+            # This block checks cache budget: decode batches have infinite budget, but varlen batches don't, because KV
+            # cache is read through a fixed-sized index tensor. We keep track of the current budget in case the batch
+            # goes from decode to varlen
+            is_decode_eligible = request_len == 1 and state.position_offset < self.max_decode_fast_path_length
+            read_cache_needed = state.current_len()
+            if self.read_cache_limit is not None:
+                read_cache_needed = min(read_cache_needed, self.read_cache_limit)
+            # A request that would change the batch from decode to varlen is rejected if the cache budget is too low
+            if not (decode_fast_path and is_decode_eligible) and cache_budget < read_cache_needed:
+                continue
+
+            # Check there will be enough cache for the new tokens
+            allocation_successful = self._allocate_blocks_if_needed(state, request_len)
+
+            # If the allocation would not be successful, we move on to the next request
+            if not allocation_successful:
+                one_allocation_failed = True
+                # If we reached a waiting request and the cache is full, all subsequent waiting requests will need
+                # allocation as well, so we can safely break out of the scheduling loop.
+                if num_free_blocks == 0 and state.request_id in self.waiting_requests:
+                    logger.info(f"Breaking mid-loop for request {state.request_id} because the cache is full")
+                    break
+                continue
+
+            # If this point is reached, it means we can safely schedule the request
+            self._schedule_request(state, request_tokens, token_budget, request_ids_to_remove_from_waiting)
+            request_len = len(state.tokens_to_process)  # it may change after scheduling
+
+            # The decode fast path is only used if the request is a single token and its length is less than the max blocks per request
+            decode_fast_path &= request_len == 1 and state.position_offset < self.max_decode_fast_path_length
+
+            # Update the token and cache budgets
+            token_budget -= request_len
+            cache_budget -= read_cache_needed
+
+            # If using prefix sharing, we make note of the blocks that will be computed in the forward pass
+            if self.cache.allow_block_sharing:
+                tokens_in_current_block = state.current_len() % self.cache.block_size
+                tokens_after_forward = tokens_in_current_block + request_len
+                complete_blocks = tokens_after_forward // self.cache.block_size
+            else:
+                complete_blocks = 0
+
+            # Store the future request state
+            has_new_token = not state.remaining_prefill_tokens
+            scheduled_requests.append(FutureRequestState(state, has_new_token, complete_blocks, request_len))
+
+            # Remove the request from the waiting queue and mark it as removed
+            req_id = state.request_id
+            was_waiting = self.waiting_requests.pop(req_id, None) is not None
+            if was_waiting:
+                request_ids_to_remove_from_waiting.add(req_id)
+
+            # Early exit of the loop if we have no budget left
+            if token_budget == 0 or (cache_budget <= 0 and not decode_fast_path):
+                break
+
+        num_q_tokens = original_token_budget - token_budget
+        max_kv_read = original_cache_budget - cache_budget
+        return scheduled_requests, one_allocation_failed, decode_fast_path, num_q_tokens, max_kv_read
+
+    def _get_waiting_candidates(self) -> list[RequestState]:
+        """Returns waiting requests in priority order. Since CPU-offloaded requests are cheaper to restore than fresh
+        requests, they get priority, but we interleave them with fresh request to not saturate new batches with only
+        offloaded requests."""
+        offloaded: deque[RequestState] = deque()
+        fresh: deque[RequestState] = deque()
+        for req_id in self.waiting_requests_order:
+            state = self.waiting_requests[req_id]
+            (offloaded if state.is_cpu_offloaded else fresh).append(state)
+        ordered: list[RequestState] = []
+        while offloaded or fresh:
+            if offloaded:
+                ordered.append(offloaded.popleft())
+            if fresh:
+                ordered.append(fresh.popleft())
+        return ordered
+
+    def _cleanup_waiting_queue(self, request_ids_to_remove_from_waiting: set[str]) -> None:
+        """Removes processed requests from the waiting queue order."""
+        self.waiting_requests_order = deque(
+            [req_id for req_id in self.waiting_requests_order if req_id not in request_ids_to_remove_from_waiting]
+        )
+
+
+# TODO: further common-ize the two classes
+@attach_tracer()
+class FIFOScheduler(Scheduler):
+    """This scheduler processes requests in the order they arrive, meaning decoding requests has priority over
+    prefilling requests. Additionally, it includes a safety margin mechanism to prevent cache exhaustion. By default,
+    when 80% of the cache is full, new requests will not be scheduled to prioritize decoding active requests."""
+
+    def __init__(self, cache: PagedAttentionCache, safety_margin: float = 0.2):
+        """Initializes the FIFO scheduler. The safety margin is the percentage of free blocks under which we stop
+        scheduling new prefill requests, so safety_margin = 0.1 means that when there is less than 10% of free blocks,
+        or equivalently when more than 90% of blocks are already allocated, we stop scheduling new prefill requests.
+        """
+        super().__init__(cache)
+        self.safety_margin = safety_margin
+
+    @traced
+    def schedule_batch(
+        self, token_budget: int, cache_budget: int
+    ) -> tuple[list[FutureRequestState] | None, bool, int, int]:
+        priority_states: list[RequestState] = []
+        second_priority_states: list[RequestState] = []
+
+        for state in self.active_requests.values():
+            if state.status == RequestStatus.DECODING:
+                priority_states.append(state)
+            elif state.status == RequestStatus.PREFILLING:
+                second_priority_states.append(state)
+
+        # Add waiting requests to second priority, with CPU-offloaded requests first
+        if not self.block_new_requests:
+            second_priority_states.extend(self._get_waiting_candidates())
+
+        candidates = priority_states + second_priority_states
+        request_ids_to_remove_from_waiting = set()
+        scheduled_requests, one_allocation_failed, decode_fast_path, num_q_tokens, max_kv_read = (
+            self._process_candidates(
+                candidates,
+                token_budget,
+                cache_budget,
+                request_ids_to_remove_from_waiting,
+                safety_margin=self.safety_margin,
+            )
+        )
+
+        # We remove waiting requests before checking requests were scheduled, because there might have been prefill matches
+        self._cleanup_waiting_queue(request_ids_to_remove_from_waiting)
+
+        # If no requests were scheduled and the cache is full, we signal it by returning None
+        if not scheduled_requests and one_allocation_failed:
+            return None, decode_fast_path, 0, 0
+
+        return scheduled_requests, decode_fast_path, num_q_tokens, max_kv_read
+
+
+# FIXME: prioritize adding from waiting reqs before scheduling `RequestStatus.DECODING` when cache space allows it
+# TODO: further consolidate the code by making more of it common. The reference Scheduler is FIFO, not this one.
+@attach_tracer()
+class PrefillFirstScheduler(Scheduler):
+    """Scheduler that prioritizes split prefill requests over decoding requests. This scheduler ensures that split
+    prefill requests (which are continuations of partially processed prompts) are completed before processing new
+    decoding requests."""
+
+    @traced
+    def schedule_batch(
+        self, token_budget: int, cache_budget: int
+    ) -> tuple[list[FutureRequestState] | None, bool, int, int]:
+        priority_states: list[RequestState] = []
+        second_priority_states: list[RequestState] = []
+
+        for state in self.active_requests.values():
+            # XXX: when cache is full, state can stay on `PREFILLING_SPLIT` so we need to take those into account
+            if state.status == RequestStatus.PREFILLING:
+                priority_states.append(state)
+            elif state.status == RequestStatus.DECODING:
+                second_priority_states.append(state)
+
+        # Add waiting requests to second priority, with CPU-offloaded requests first
+        if not self.block_new_requests:
+            second_priority_states.extend(self._get_waiting_candidates())
+
+        candidates = priority_states + second_priority_states
+        request_ids_to_remove_from_waiting = set()
+        scheduled_requests, one_allocation_failed, decode_fast_path, num_q_tokens, max_kv_read = (
+            self._process_candidates(
+                candidates,
+                token_budget,
+                cache_budget,
+                request_ids_to_remove_from_waiting,
+                safety_margin=0.0,
+            )
+        )
+
+        # We remove waiting requests before checking requests were scheduled, because there might have been prefill matches
+        self._cleanup_waiting_queue(request_ids_to_remove_from_waiting)
+
+        # If no requests were scheduled and the cache is full, we signal it by returning None
+        if not scheduled_requests and one_allocation_failed:
+            return None, decode_fast_path, 0, 0
+
+        return scheduled_requests, decode_fast_path, num_q_tokens, max_kv_read
+
+
+SCHEDULER_MAPPING = {
+    "fifo": FIFOScheduler,
+    "prefill_first": PrefillFirstScheduler,
+}

micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/utils.py

@@ -0,0 +1,217 @@
+# Copyright 2026 The HuggingFace Inc. team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections import OrderedDict
+from dataclasses import dataclass
+from math import ceil, log2
+from typing import Any
+
+import torch
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.generation.configuration_utils import ContinuousBatchingConfig
+
+from .requests import FutureRequestState, RequestState, RequestStatus, logger
+
+
+class CudaGraphBuffer:
+    """A fixed-size dict for CUDA graphs with LRU eviction when full."""
+
+    def __init__(self, max_size: int) -> None:
+        if max_size <= 0:
+            raise ValueError(f"max_size must be positive, but got {max_size}")
+        self.max_size = max_size
+        self._storage: OrderedDict[tuple[int, ...], torch.cuda.CUDAGraph] = OrderedDict()
+
+    def __del__(self) -> None:
+        original_max_size = self.max_size
+        self.max_size = 1  # 0 would cause an infinite loop, 1 is enough to clear all graphs
+        self.plan_for_new_graph(silent=True)
+        self.max_size = original_max_size
+
+    def get_graph(self, key: tuple[int, ...]) -> torch.cuda.CUDAGraph | None:
+        graph = self._storage.get(key)
+        if graph is not None:
+            self._storage.move_to_end(key)
+        return graph
+
+    def plan_for_new_graph(self, silent: bool = False) -> None:
+        while len(self._storage) >= self.max_size:
+            evicted_key, evicted_graph = self._storage.popitem(last=False)
+            if not silent:
+                logger.info(f"Evicting graph for {evicted_key = }")
+            evicted_graph.reset()
+
+    def set_graph(self, key: tuple[int, ...], graph: torch.cuda.CUDAGraph) -> None:
+        # In our use case, this should not have any effect because we plan for a new graph before it is captured
+        self.plan_for_new_graph()
+        self._storage[key] = graph
+
+
+@dataclass
+class WorkloadHints:
+    """A tiny dataclass containing hints to help choose good continuous batching defaults"""
+
+    max_prompt_length: int = 0
+    max_generated_length: int = 0
+
+    # TODO: can this be fused with other resolve methods?
+    def resolve_using_hints(self, cb_config: "ContinuousBatchingConfig") -> None:
+        """Resolves the config using the given hints."""
+        # The max number of block per request is an even number large enough to hold the max request length
+        if self.max_prompt_length and self.max_generated_length:
+            if cb_config.max_blocks_per_request is None:
+                max_sequence_length = self.max_prompt_length + self.max_generated_length
+                blocks_per_request = int(ceil(max_sequence_length / cb_config.block_size)) + 1
+                cb_config.max_blocks_per_request = blocks_per_request + (blocks_per_request % 2)
+
+
+def attn_mask_is_needed(config: PretrainedConfig) -> bool:
+    """Checks if attention mask is needed for the given (config)."""
+    return config._attn_implementation in ["paged|eager", "paged|sdpa"]
+
+
+def pad_to_interval(size: int, interval_size: int, max_value: int) -> int:
+    """Return the smallest multiple of (interval_size) >= (size), capped at (max_value)."""
+    if interval_size <= 0:
+        return max_value
+    padded = ceil(size / interval_size) * interval_size if size > 0 else interval_size
+    return min(padded, max_value)
+
+
+def pad_to_pow2(value: int, max_value: int, min_value: int = 0) -> int:
+    """Return the smallest power of 2 >= (value), capped at (max_value). If a minimum value is provided, the value is at
+    least padded to that value."""
+    value = max(value, max(1, min_value))
+    padded = 2 ** int(ceil(log2(value)))
+    return min(padded, max_value)
+
+
+def aligned_divide(x: int, divide_by: int, align_to: int) -> int:
+    x = int(ceil(x / divide_by))
+    if x % align_to:
+        x += align_to - (x % align_to)
+    return x
+
+
+def build_attention_mask(
+    attention_mask: torch.Tensor,
+    cumulative_seqlens_q: list[int],
+    cumulative_seqlens_k: list[int],
+    sliding_window: int = 1,
+) -> None:
+    """Builds an attention mask inplace using the cumulative seqlens of the query and key. If given a sliding window, it
+    will also apply a sliding window mask on top. The attention mask is not boolean, it uses zeroes and -inf (or its
+    equivalent) so it's more of an attention score bias tensor.
+    The attention mask is a block-diagonal matrix, with each block an attention mask for a single query-key pair.
+    Each of those block is built from a causal mask and, if there is a sliding window, a sliding window mask.
+
+    An example is represented below, with seqlen_k = 8, seqlen_q = 4 and sliding_window = 6:
+
+    CAUSAL MASK:
+
+           █ █ █ █ █ ░ ░ ░
+           █ █ █ █ █ █ ░ ░
+           █ █ █ █ █ █ █ ░
+           █ █ █ █ █ █ █ █
+
+    SLIDING WINDOW MASK:
+         ┌──────────────────────── seqlen_k - seqlen_q - sliding_window = 8 - 4 - 6 = -2 offset to the left
+       <─┴─>
+     ░ █ | █ █ █ █ █ █ █ █
+     ░ ░ | █ █ █ █ █ █ █ █
+     ░ ░ | ░ █ █ █ █ █ █ █
+     ░ ░ | ░ ░ █ █ █ █ █ █
+
+    ATTENTION MASK (sum of causal and sliding window masks):
+
+           █ █ █ █ █ ░ ░ ░
+           █ █ █ █ █ █ ░ ░
+           ░ █ █ █ █ █ █ ░
+           ░ ░ █ █ █ █ █ █
+
+    Another example with seqlen_k = 5, seqlen_q = 3 and sliding_window = 2:
+
+    CAUSAL MASK:
+
+           █ █ █ ░ ░
+           █ █ █ █ ░
+           █ █ █ █ █
+
+    SLIDING WINDOW MASK:
+         ┌──────────────────────── seqlen_k - seqlen_q - sliding_window = 5 - 3 - 2 = 0 offset to the left
+        <┴>
+         | ░ █ █ █ █
+         | ░ ░ █ █ █
+         | ░ ░ ░ █ █
+
+    ATTENTION MASK (sum of causal and sliding window masks):
+
+           ░ █ █ ░ ░
+           ░ ░ █ █ ░
+           ░ ░ ░ █ █
+
+    """
+    min_value = torch.finfo(attention_mask.dtype).min
+    for i in range(len(cumulative_seqlens_q) - 1):
+        seqlen_q = cumulative_seqlens_q[i + 1] - cumulative_seqlens_q[i]
+        seqlen_k = cumulative_seqlens_k[i + 1] - cumulative_seqlens_k[i]
+        if seqlen_q < seqlen_k and seqlen_q >= 1:
+            causal_diagonal = seqlen_k - seqlen_q + 1
+        else:
+            causal_diagonal = 1
+        query_range = slice(cumulative_seqlens_q[i], cumulative_seqlens_q[i + 1])
+        key_range = slice(cumulative_seqlens_k[i], cumulative_seqlens_k[i + 1])
+        # Apply causal mask
+        minus_inf = torch.full(
+            attention_mask[..., query_range, key_range].shape,
+            min_value,
+            dtype=attention_mask.dtype,
+            device=attention_mask.device,
+        )
+        masked = torch.triu(minus_inf, diagonal=causal_diagonal)
+        # Apply sliding window mask if needed
+        if sliding_window > 1:
+            sliding_diagonal = seqlen_k - seqlen_q - sliding_window
+            masked += torch.tril(minus_inf, diagonal=sliding_diagonal)
+        # Replace in attention mask
+        attention_mask[..., query_range, key_range] = masked
+
+
+def create_warmup_future_states(
+    num: int,
+    status: RequestStatus,
+    num_query_tokens: int,
+    num_cache_tokens: int,
+    cache: Any,  # not annotated to avoid circular import
+) -> list[FutureRequestState]:
+    """An utility function to create a list of FutureRequestStates for the warmup of CB."""
+    # Setup
+    request_ids = [f"__warmup_{status.name}_{i}__" for i in range(num)]
+    total_tokens = num_query_tokens + num_cache_tokens
+    blocks_needed = ceil(total_tokens / cache.block_size)
+    # Main loop
+    future_states = []
+    for req_id in request_ids:
+        state = RequestState(request_id=req_id, initial_tokens=[0] * total_tokens, max_new_tokens=1)
+        state._status = status  # bypass the property setter to avoid the lifecycle side effects
+        state.tokens_to_process = [0] * num_query_tokens
+        state.position_offset = num_cache_tokens
+        # Stop if allocation fails for any request
+        allocated = cache.allocate_blocks(blocks_needed, state.request_id, 0)
+        if allocated is None:
+            return future_states
+        future_states.append(
+            FutureRequestState(state, has_new_token=True, complete_blocks=0, query_length=num_query_tokens)
+        )
+    return future_states