[None][fix] Pass max_num_tokens to MLA KV manager and keep warmup-feasibility floors - #16269
[None][fix] Pass max_num_tokens to MLA KV manager and keep warmup-feasibility floors#16269qiaoxj07 wants to merge 1 commit into
Conversation
|
/bot run |
📝 WalkthroughWalkthroughThe MLA KV cache initialization path now forwards ChangesMLA KV Cache Forwarding
Estimated code review effort: 2 (Simple) | ~10 minutes 🚥 Pre-merge checks | ✅ 5✅ Passed checks (5 passed)
✨ Finishing Touches🧪 Generate unit tests (beta)
Comment |
There was a problem hiding this comment.
🧹 Nitpick comments (1)
tests/unittest/_torch/executor/test_kv_cache_estimation.py (1)
487-506: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick winAdd return annotations to the new test functions.
The regression coverage is sufficient for this forwarding bug, but both
test_mla_branch_forwards_max_num_tokens_to_managerand_RecordingManager.__init__should declare-> None.Proposed fix
-def test_mla_branch_forwards_max_num_tokens_to_manager(): +def test_mla_branch_forwards_max_num_tokens_to_manager() -> None: ... - def __init__(self, *args, **kwargs): + def __init__(self, *args: object, **kwargs: object) -> None:As per coding guidelines, Python functions must be annotated with return types. As per path instructions, coverage is sufficient for this targeted regression and requires no follow-up test file.
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate. In `@tests/unittest/_torch/executor/test_kv_cache_estimation.py` around lines 487 - 506, Add -> None return annotations to the new test function test_mla_branch_forwards_max_num_tokens_to_manager and the nested _RecordingManager.__init__ method, without changing the existing regression coverage.Sources: Coding guidelines, Path instructions
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
Nitpick comments:
In `@tests/unittest/_torch/executor/test_kv_cache_estimation.py`:
- Around line 487-506: Add -> None return annotations to the new test function
test_mla_branch_forwards_max_num_tokens_to_manager and the nested
_RecordingManager.__init__ method, without changing the existing regression
coverage.
ℹ️ Review info
⚙️ Run configuration
Configuration used: Path: .coderabbit.yaml
Review profile: CHILL
Plan: Enterprise
Run ID: afa6da09-a36e-4b12-bbac-68f76630a539
📒 Files selected for processing (2)
tensorrt_llm/_torch/pyexecutor/_util.pytests/unittest/_torch/executor/test_kv_cache_estimation.py
👎 Promotion blocked, new vulnerability foundVulnerability report
|
|
/bot run --disable-fail-fast |
d4f8edf to
d61da26
Compare
|
/bot run |
|
PR_Github #58748 [ run ] triggered by Bot. Commit: |
|
PR_Github #58749 [ run ] triggered by Bot. Commit: |
|
PR_Github #58748 [ run ] completed with state |
|
PR_Github #58749 [ run ] completed with state
|
|
/bot run --disable-fail-fast |
|
PR_Github #58759 [ run ] triggered by Bot. Commit: |
aa27e6f to
6d1bb26
Compare
|
/bot run |
|
PR_Github #58766 [ run ] triggered by Bot. Commit: |
|
PR_Github #58759 [ run ] completed with state |
68b3d10 to
7ea1409
Compare
|
PR_Github #58773 [ run ] triggered by Bot. Commit: |
|
PR_Github #58766 [ run ] completed with state |
|
PR_Github #58773 [ run ] completed with state
|
|
/bot run --disable-fail-fast |
|
PR_Github #58776 [ run ] triggered by Bot. Commit: |
|
PR_Github #58776 [ run ] completed with state
|
|
/bot run --disable-fail-fast |
|
PR_Github #58806 [ run ] triggered by Bot. Commit: |
|
PR_Github #58806 [ run ] completed with state |
|
/bot run --disable-fail-fast |
|
PR_Github #58833 [ run ] triggered by Bot. Commit: |
|
PR_Github #58833 [ run ] completed with state
|
…sibility floors _create_kv_cache_manager's is_mla branch omitted max_num_tokens, so DeepseekV4CacheManager sized the KV-estimation temporary quota by the full max_tokens estimate (23.69 GiB per rank on DeepSeek-V4-Pro ISL~990K MTP3) instead of the runtime chunk size (8.14 GiB), inflating the profiling peak and its OOM risk. Forward max_num_tokens like the generic branch does. Passing it alone, however, exposes two latent sizing bugs that made every DSV4-Pro agentx disagg GEN config OOM after estimation: 1. With an explicit kv_cache_config.pool_ratio, _build_cache_config skipped building its constraints and StorageManager dropped constraints from min_slots, so the now-tight estimation quota was split purely by ratio. The ageless COMPRESS pool group got 3084 blocks < the 3872 blocks one full-length request needs, the estimation manager clamped max_seq_len 991048->789502, and CUDA-graph warmup silently skipped every batch size >= 2. The profiling peak missed ~5 GiB of capture working set, the KV estimate rose from 36.09 to 40.70 GiB, and the final executor OOM'd during the advanced-sampling bs=32 graph capture with only 5.75 GiB free after KV pool creation. 2. Even with correct floors, _KVCache.resume rejects any pool group above max_util_for_resume, so a warmup batch that exactly fills its floor fails its last resume (observed: a 32-request warmup batch failing at request 32 with a 32-slot pool group at 31/32 = 97% utilization). Fix by treating constraints as feasibility floors everywhere: - DeepseekV4CacheManager._build_cache_config always builds its constraints (pool_ratio only replaces the typical_step-derived ratio), and Constraint 1 now describes the CUDA-graph warmup batch the engine will actually run: one max_seq_len decode plus minimal decodes up to the engine's largest configured graph batch (passed through _create_kv_cache_manager). With graphs disabled the constraint is dropped entirely — no other warmup creates a max_seq_len-long request, so even the single long request would floor (and possibly bump) the quota for a warmup that will not happen. - StorageManager derives min_slots from constraints even when initial_pool_ratio is provided, and scales the floors by 1/max_util_for_resume so the last request of a constraint batch still passes resume's utilization gate. The scaling only applies in the (0, 1) binding range: the llmapi field permits 0 (where only the first resume of an empty pool passes, so no finite floor helps), and values >= 1 never trigger the gate. - model_engine warns instead of silently skipping CUDA-graph warmup batch sizes and general warmup shapes, since a skip during estimation makes the profiling peak unrepresentative. Verified on the failing DSV4-Pro agentx disagg gen-only config (dep4 c32 mtp3 batch32 maxnt128, GB300): the estimation temp pool stays at the reduced 8.14 GiB quota (8.22 GiB allocated with floors), estimation-phase warmup regains full coverage (bs=32 greedy + advanced sampling and the 32+32 eager step), the profiling peak becomes representative (244.74 GiB), the KV estimate returns to the calibrated 36.09 GiB, and the previously always-OOM config runs the benchmark to completion (reproduced end-to-end with the final code, including the graphs-disabled path on the CTX worker). Same arithmetic verified for the tep8 shape (bs=128 warmup fits at the reduced 19.46 GiB quota). Signed-off-by: Xianjie <5410381+qiaoxj07@users.noreply.github.com>
cbe98e4 to
7b7f089
Compare
5a5e110 to
7b7f089
Compare
|
Superseded by #16311, which replaces this PR with the scoped KV cache estimation fix. |
…resume on both backends Ports the DSv4 warmup-starvation fix (PR NVIDIA#16269) to KVCacheManagerV2's constraint-based min-slot computation, on both the C++ and pure-Python backends so they stay in parity. Two behavior changes in computeMinSlotsFromConstraints / _compute_min_slots_from_constraints: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (previously they were dropped for min-slots), so a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. - The per-constraint slot floors are scaled by 1/max_util_for_resume (clamped to the binding (0, 1) range) because KvCache::resume rejects any pool group above that utilization, so the floor must leave headroom. max_util_for_resume is threaded from KVCacheManagerConfig through the StorageManager constructor on both backends. The C++ side is a rewrite of Lance Liao's commit 15a90e1 (the constraint-floor half): this branch's computeMinSlotsFromConstraints was reworked with structural SWA/SSM floors after his fork point, and neither his branch's nor this branch's Python _storage_manager.py had the fix, so a mechanical cherry-pick did not apply and the Python backend needed the same change. Update the init-ratio test accordingly: with the fix an infeasible initial_pool_ratio is overridden by the constraint's feasibility floor, so test_constraint_floor_overrides_infeasible_initial_pool_ratio asserts the clamped-up share (both backends produce an identical ratio). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
…resume on both backends Ports the DSv4 warmup-starvation fix (PR NVIDIA#16269) to KVCacheManagerV2's constraint-based min-slot computation, on both the C++ and pure-Python backends so they stay in parity. Two behavior changes in computeMinSlotsFromConstraints / _compute_min_slots_from_constraints: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (previously they were dropped for min-slots), so a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. - The per-constraint slot floors are scaled by 1/max_util_for_resume (clamped to the binding (0, 1) range) because KvCache::resume rejects any pool group above that utilization, so the floor must leave headroom. max_util_for_resume is threaded from KVCacheManagerConfig through the StorageManager constructor on both backends. The C++ side is a rewrite of Lance Liao's commit 15a90e1 (the constraint-floor half): this branch's computeMinSlotsFromConstraints was reworked with structural SWA/SSM floors after his fork point, and neither his branch's nor this branch's Python _storage_manager.py had the fix, so a mechanical cherry-pick did not apply and the Python backend needed the same change. Update the init-ratio test accordingly: with the fix an infeasible initial_pool_ratio is overridden by the constraint's feasibility floor, so test_constraint_floor_overrides_infeasible_initial_pool_ratio asserts the clamped-up share (both backends produce an identical ratio). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
…resume on both backends Ports the DSv4 warmup-starvation fix (PR NVIDIA#16269) to KVCacheManagerV2's constraint-based min-slot computation, on both the C++ and pure-Python backends so they stay in parity. Two behavior changes in computeMinSlotsFromConstraints / _compute_min_slots_from_constraints: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (previously they were dropped for min-slots), so a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. - The per-constraint slot floors are scaled by 1/max_util_for_resume (clamped to the binding (0, 1) range) because KvCache::resume rejects any pool group above that utilization, so the floor must leave headroom. max_util_for_resume is threaded from KVCacheManagerConfig through the StorageManager constructor on both backends. The C++ side is a rewrite of Lance Liao's commit 15a90e1 (the constraint-floor half): this branch's computeMinSlotsFromConstraints was reworked with structural SWA/SSM floors after his fork point, and neither his branch's nor this branch's Python _storage_manager.py had the fix, so a mechanical cherry-pick did not apply and the Python backend needed the same change. Update the init-ratio test accordingly: with the fix an infeasible initial_pool_ratio is overridden by the constraint's feasibility floor, so test_constraint_floor_overrides_infeasible_initial_pool_ratio asserts the clamped-up share (both backends produce an identical ratio). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
REVIEW NOTE: this is the cpp-branch behavior delta on top of the previous commit (which mirrors main's PR NVIDIA#16484). It is isolated so it can be reviewed or dropped independently. If we decide to match main exactly, revert just this commit. Diverges from main's resume-utilization fix in two ways, on both the Python and C++ backends: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (main drops them): a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. Follows Lanyu's C++ commit 15a90e1 (which cited PR NVIDIA#16269). - Clamp max_util_for_resume to the binding (0, 1) range before scaling, so a degenerate 0 can't divide-by-zero and a value >= 1 can't shrink floors. Renames test_initial_pool_ratio_overrides_typical_step_and_constraints to test_constraint_floor_overrides_infeasible_initial_pool_ratio to assert the new behavior (main's test_constraint_reserves_resume_headroom is kept as-is). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
REVIEW NOTE: this is the cpp-branch behavior delta on top of the previous commit (which mirrors main's PR NVIDIA#16484). It is isolated so it can be reviewed or dropped independently. If we decide to match main exactly, revert just this commit. Diverges from main's resume-utilization fix in two ways, on both the Python and C++ backends: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (main drops them): a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. Follows Lanyu's C++ commit 15a90e1 (which cited PR NVIDIA#16269). - Clamp max_util_for_resume to the binding (0, 1) range before scaling, so a degenerate 0 can't divide-by-zero and a value >= 1 can't shrink floors. Renames test_initial_pool_ratio_overrides_typical_step_and_constraints to test_constraint_floor_overrides_infeasible_initial_pool_ratio to assert the new behavior (main's test_constraint_reserves_resume_headroom is kept as-is). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
REVIEW NOTE: this is the cpp-branch behavior delta on top of the previous commit (which mirrors main's PR NVIDIA#16484). It is isolated so it can be reviewed or dropped independently. If we decide to match main exactly, revert just this commit. Diverges from main's resume-utilization fix in two ways, on both the Python and C++ backends: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (main drops them): a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. Follows Lanyu's C++ commit 15a90e1 (which cited PR NVIDIA#16269). - Clamp max_util_for_resume to the binding (0, 1) range before scaling, so a degenerate 0 can't divide-by-zero and a value >= 1 can't shrink floors. Renames test_initial_pool_ratio_overrides_typical_step_and_constraints to test_constraint_floor_overrides_infeasible_initial_pool_ratio to assert the new behavior (main's test_constraint_reserves_resume_headroom is kept as-is). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
REVIEW NOTE: this is the cpp-branch behavior delta on top of the previous commit (which mirrors main's PR NVIDIA#16484). It is isolated so it can be reviewed or dropped independently. If we decide to match main exactly, revert just this commit. Diverges from main's resume-utilization fix in two ways, on both the Python and C++ backends: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (main drops them): a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. Follows Lanyu's C++ commit 15a90e1 (which cited PR NVIDIA#16269). - Clamp max_util_for_resume to the binding (0, 1) range before scaling, so a degenerate 0 can't divide-by-zero and a value >= 1 can't shrink floors. Renames test_initial_pool_ratio_overrides_typical_step_and_constraints to test_constraint_floor_overrides_infeasible_initial_pool_ratio to assert the new behavior (main's test_constraint_reserves_resume_headroom is kept as-is). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
REVIEW NOTE: this is the cpp-branch behavior delta on top of the previous commit (which mirrors main's PR NVIDIA#16484). It is isolated so it can be reviewed or dropped independently. If we decide to match main exactly, revert just this commit. Diverges from main's resume-utilization fix in two ways, on both the Python and C++ backends: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (main drops them): a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. Follows Lanyu's C++ commit 15a90e1 (which cited PR NVIDIA#16269). - Clamp max_util_for_resume to the binding (0, 1) range before scaling, so a degenerate 0 can't divide-by-zero and a value >= 1 can't shrink floors. Renames test_initial_pool_ratio_overrides_typical_step_and_constraints to test_constraint_floor_overrides_infeasible_initial_pool_ratio to assert the new behavior (main's test_constraint_reserves_resume_headroom is kept as-is). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
REVIEW NOTE: this is the cpp-branch behavior delta on top of the previous commit (which mirrors main's PR NVIDIA#16484). It is isolated so it can be reviewed or dropped independently. If we decide to match main exactly, revert just this commit. Diverges from main's resume-utilization fix in two ways, on both the Python and C++ backends: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (main drops them): a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. Follows Lanyu's C++ commit 15a90e1 (which cited PR NVIDIA#16269). - Clamp max_util_for_resume to the binding (0, 1) range before scaling, so a degenerate 0 can't divide-by-zero and a value >= 1 can't shrink floors. Renames test_initial_pool_ratio_overrides_typical_step_and_constraints to test_constraint_floor_overrides_infeasible_initial_pool_ratio to assert the new behavior (main's test_constraint_reserves_resume_headroom is kept as-is). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
REVIEW NOTE: this is the cpp-branch behavior delta on top of the previous commit (which mirrors main's PR NVIDIA#16484). It is isolated so it can be reviewed or dropped independently. If we decide to match main exactly, revert just this commit. Diverges from main's resume-utilization fix in two ways, on both the Python and C++ backends: - Constraints stay feasibility floors even under an explicit initial_pool_ratio (main drops them): a declared batch that needs more than its target pool-group share clamps that share up instead of starving during warmup. Follows Lanyu's C++ commit 15a90e1 (which cited PR NVIDIA#16269). - Clamp max_util_for_resume to the binding (0, 1) range before scaling, so a degenerate 0 can't divide-by-zero and a value >= 1 can't shrink floors. Renames test_initial_pool_ratio_overrides_typical_step_and_constraints to test_constraint_floor_overrides_infeasible_initial_pool_ratio to assert the new behavior (main's test_constraint_reserves_resume_headroom is kept as-is). Signed-off-by: Yao Yao <lowsfer@users.noreply.github.com>
Description
_create_kv_cache_manager'sis_mlabranch omitsmax_num_tokensfrom the manager constructor call, while the generic (non-MLA) branch passes it. As a resultDeepseekV4CacheManagerfalls back to_max_num_tokens=Noneand_build_cache_configsizes the context extra quota by the fullmax_tokensestimate instead of the runtime chunk size, inflating the KV-estimation temporary quota (23.69 GiB instead of 8.14 GiB per rank on DeepSeek-V4-Pro, ISL≈990K, MTP3, dep4/ADP) — and with it the profiling peak and its OOM risk.Forwarding
max_num_tokens(one line in_util.py) fixes that, but on its own it trades the profiling-peak risk for a deterministic post-estimation OOM: every DSV4-Pro agentx disagg GEN config failed with it applied. The tight quota exposed two latent sizing bugs:pool_ratiodisabled the sizing constraints entirely (two independent sites:_build_cache_configonly built constraints whenpool_ratio is None, andStorageManagerdropped constraints frommin_slotswheninitial_pool_ratiowas provided). The estimation quota was then split purely by ratio: the ageless COMPRESS pool group got 3,084 blocks < the 3,872 blocks one full-length request needs, the estimation manager clampedmax_seq_len991048→789502, and CUDA-graph warmup silently skipped every batch size ≥ 2. The profiling peak missed ~5 GiB of capture working set, the KV estimate rose from the calibrated 36.09 GiB to 40.70 GiB, and the final executor OOM'd during the advanced-sampling bs=32 graph capture with only 5.75 GiB free after KV-pool creation._KVCache.resume's utilization gate rejects any pool group abovemax_util_for_resume, so a warmup batch that exactly fills its floor fails its last resume (observed: a 32-request warmup batch failing at request 32 with a 32-slot pool group at 31/32 = 97% utilization).Fix
Treat constraints as feasibility floors everywhere:
DeepseekV4CacheManager._build_cache_configalways builds its constraints (pool_ratioonly replaces thetypical_step-derived ratio), and Constraint 1 now describes the CUDA-graph warmup batch the engine will actually run: onemax_seq_lendecode plus minimal decodes up to the engine's largest configured graph batch (model_engine._max_cuda_graph_batch_size, plumbed through_create_kv_cache_manager). Withmax(cuda_graph_batch_sizes) ≪ max_batch_sizethe floor sizes to the real graph batch, and with CUDA graphs disabled (0) the constraint is dropped entirely — no other warmup creates amax_seq_len-long request, so even the single long request would floor (and, on tight quotas, bump) the allocation for a warmup that will not happen. The floor never forces pool allocation for a warmup that won't run.StorageManagerderivesmin_slotsfrom constraints even wheninitial_pool_ratiois provided, and scales the floors by1/max_util_for_resumeso the last request of a constraint batch still passes resume's utilization gate. The scaling only applies in the binding range(0, 1): the llmapi field permitsmax_util_for_resume=0, where only the first resume of an empty pool (utilization 0) passes and every later one is rejected — no finite floor helps and construction must not divide by zero; values>= 1never trigger the gate (utilization cannot exceed 1). Neither degenerate value scales the floors.model_enginewarns instead of silently skipping CUDA-graph warmup batch sizes and general warmup shapes, since a skip during estimation makes the profiling peak unrepresentative.Behavior change note (V2 cache manager owners)
initial_pool_rationo longer overrides constraints completely: the explicit ratio still decides how quota beyond the floors is split, but pool groups are clamped up to the (utilization-scaled) constraint minimums. A ratio split that cannot hold the declared warmup batches produced a manager that could not run them — that behavior was the bug. The existing testtest_initial_pool_ratio_overrides_typical_step_and_constraintsencoded the old semantics and is split intotest_initial_pool_ratio_overrides_typical_step+test_initial_pool_ratio_respects_constraint_floorsaccordingly. When a tier quota is below the floor bytes, construction rounds the quota up (pre-existing_compute_slot_count_for_levelbehavior); the estimation accounting stays correct because it adds back the actually-allocated pool bytes.Verification
A/B on the previously always-failing config (DeepSeek-V4-Pro agentx disagg gen-only, GB300, dep4/ADP, MTP3, c32,
max_batch_size=32,max_num_tokens=128,pool_ratio=[0.3,0.4,0.3]), GEN rank 0:max_num_tokensonlyThe same arithmetic was verified for the tep8 shape (
max_batch_size=128, mtp0): estimation warmup previously capped at bs=64, now fits bs=128 at the reduced 19.46 GiB quota.A second end-to-end run with the final code reproduced the result (estimate 35.94 GiB, run-to-run peak jitter ~0.2 GiB) and exercised the graphs-disabled path on the CTX worker (
cuda_graph_config: null): its generation-graph constraint is dropped, and the (pre-existing) capacity-limited skip of the CTX 128-request general-warmup shape is now visible via the new warning instead of silent.Unit red/green inside the container:
test_initial_pool_ratio_respects_constraint_floorsfails on the old storage manager (pool group pinned at 20 slots vs the required scaled floor of 132) and passes with the fix; the fullkv_cache_manager_v2suite (75 tests) passes unchanged.test_deepseek_v4_pool_ratio_overrides_typical_step_but_keeps_constraintsandtest_deepseek_v4_constraints_cover_cuda_graph_warmup_batchfail on stock code and pass with the fix.Note on non-DSV4 MLA models (e.g. DeepSeek-V3/R1 with the V1 manager): they now receive the real
max_num_tokensinstead of the constructor default8192, which only affects the C++ manager'schunk_size = min(max_num_tokens, max_seq_len)— the same value every non-MLA model already gets.Related: #16236 (sibling stale-
_indexer_compress_ratiofix from the same DSV4 port; independent of this change).Test Coverage
tests/unittest/_torch/executor/test_kv_cache_estimation.py::test_mla_branch_forwards_max_num_tokens_to_managertests/unittest/_torch/attention/sparse/deepseek_v4/test_deepseek_v4_cache_manager.py::test_deepseek_v4_pool_ratio_overrides_typical_step_but_keeps_constraintstests/unittest/_torch/attention/sparse/deepseek_v4/test_deepseek_v4_cache_manager.py::test_deepseek_v4_constraints_cover_cuda_graph_warmup_batchtests/unittest/_torch/attention/sparse/deepseek_v4/test_deepseek_v4_cache_manager.py::test_deepseek_v4_warmup_floor_shrinks_to_actual_graph_batchtests/unittest/_torch/attention/sparse/deepseek_v4/test_deepseek_v4_cache_manager.py::test_deepseek_v4_no_warmup_floor_when_graphs_disabledtests/unittest/kv_cache_manager_v2_tests/test_kv_cache_manager_v2.py::TestInitRatioConfig::test_small_constraint_floors_do_not_inflate_quotatests/unittest/kv_cache_manager_v2_tests/test_kv_cache_manager_v2.py::TestInitRatioConfig::test_initial_pool_ratio_respects_constraint_floors(red/green against the old storage manager)tests/unittest/kv_cache_manager_v2_tests/test_kv_cache_manager_v2.py::TestInitRatioConfig::test_initial_pool_ratio_overrides_typical_steptests/unittest/kv_cache_manager_v2_tests/test_kv_cache_manager_v2.py::TestInitRatioConfig::test_constraint_floors_tolerate_degenerate_max_util_for_resumePR Checklist
[None][fix]format