| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| """ |
| Base classes for cache management strategies. |
| """ |
|
|
| from abc import ABC, abstractmethod |
| from typing import Dict, Optional, Tuple |
| import torch |
|
|
|
|
| class CacheStrategy(ABC): |
| """ |
| Abstract base class for cache management strategies. |
| |
| All cache implementations should inherit from this class and implement |
| the required methods. |
| """ |
|
|
| def __init__(self, enabled: bool = True): |
| """ |
| Initialize the cache strategy. |
| |
| Args: |
| enabled: Whether this cache strategy is enabled |
| """ |
| self.enabled = enabled |
|
|
| @abstractmethod |
| def reset(self): |
| """ |
| Reset the cache state. |
| |
| This method should clear all internal state and prepare the cache |
| for a new inference run. |
| """ |
| pass |
|
|
| def reset_if_enabled(self): |
| """Reset the cache if it is enabled.""" |
| if self.enabled: |
| self.reset() |
|
|
|
|
| class OutputCache(CacheStrategy): |
| """ |
| Abstract base class for output reuse strategies. |
| |
| Output caching strategies determine when model outputs can be reused |
| based on input similarity metrics. |
| """ |
|
|
| @abstractmethod |
| def should_reuse( |
| self, |
| chunk_id: int, |
| step: int, |
| current_features: torch.Tensor, |
| **kwargs |
| ) -> bool: |
| """ |
| Determine whether the output for a chunk should be reused. |
| |
| Args: |
| chunk_id: The ID of the current chunk |
| step: The current denoising step |
| current_features: Feature tensor for the current input |
| **kwargs: Additional arguments specific to the implementation |
| |
| Returns: |
| True if the output should be reused, False otherwise |
| """ |
| pass |
|
|
| @abstractmethod |
| def update_residual( |
| self, |
| chunk_id: int, |
| residual: torch.Tensor |
| ): |
| """ |
| Update the residual for a chunk. |
| |
| When outputs are reused, the residual from the previous step is |
| applied to the current input. |
| |
| Args: |
| chunk_id: The ID of the chunk |
| residual: The residual tensor to store |
| """ |
| pass |
|
|
| @abstractmethod |
| def get_residual(self, chunk_id: int) -> Optional[torch.Tensor]: |
| """ |
| Get the stored residual for a chunk. |
| |
| Args: |
| chunk_id: The ID of the chunk |
| |
| Returns: |
| The residual tensor if available, None otherwise |
| """ |
| pass |
|
|
|
|
| class KVCompressor(CacheStrategy): |
| """ |
| Abstract base class for KV cache compression strategies. |
| |
| KV cache compression manages memory usage by selectively compressing |
| KV caches from completed chunks. |
| """ |
|
|
| @abstractmethod |
| def should_compress( |
| self, |
| current_chunk_id: int, |
| cache_used: int, |
| cache_capacity: int, |
| **kwargs |
| ) -> bool: |
| """ |
| Determine whether KV cache compression should be triggered. |
| |
| Args: |
| current_chunk_id: The ID of the most recently completed chunk |
| cache_used: Current KV cache usage in tokens |
| cache_capacity: Total KV cache capacity in tokens |
| **kwargs: Additional arguments specific to the implementation |
| |
| Returns: |
| True if compression should be performed, False otherwise |
| """ |
| pass |
|
|
| @abstractmethod |
| def compress( |
| self, |
| inference_params, |
| chunk_tracker, |
| clean_chunk_ids: list, |
| active_chunk_ids: list, |
| **kwargs |
| ) -> Dict[int, Tuple[int, int]]: |
| """ |
| Compress KV caches for specified chunks. |
| |
| Args: |
| inference_params: Inference parameters containing KV cache |
| chunk_tracker: Tracker managing chunk ranges |
| clean_chunk_ids: List of chunk IDs to compress |
| active_chunk_ids: List of chunk IDs to keep uncompressed |
| **kwargs: Additional arguments |
| |
| Returns: |
| Dictionary mapping chunk_id to (start, end) ranges after compression |
| """ |
| pass |
|
|
