Skip to content

vllm.models.deepseek_v41.nvidia.ops.candidate_paged_logits

FP8 indexer scores over DSV4.1's candidate blocks.

Classes:

CandidatePagePlanKernel

Bases: VllmCuTeDSLJitKernel[tuple[int, int]]

Cache int32 page IDs; consumers derive offsets from sparse indices.

Source code in vllm/models/deepseek_v41/nvidia/ops/candidate_paged_logits.py
class CandidatePagePlanKernel(VllmCuTeDSLJitKernel[tuple[int, int]]):
    """Cache int32 page IDs; consumers derive offsets from sparse indices."""

    @staticmethod
    def kernel(key: tuple[int, int]) -> Any:
        page_size, sparse_block_size = key

        @cute.kernel
        def device_kernel(
            block_table: cute.Tensor,
            sparse_indices: cute.Tensor,
            valid_end: cute.Tensor,
            row_indices: cute.Tensor,
            physical_blocks: cute.Tensor,
        ):
            tile, row, _ = cute.arch.block_idx()
            tid, _, _ = cute.arch.thread_idx()
            block = tile * 256 + tid
            if block < sparse_indices.shape[1]:
                page = Int32(0)
                if block * sparse_block_size < valid_end[row]:
                    pos = sparse_indices[row, block] * sparse_block_size
                    page = block_table[row_indices[row], pos // page_size]
                physical_blocks[row, block] = page

        @cute.jit
        def entry(
            block_table: cute.Tensor,
            sparse_indices: cute.Tensor,
            valid_end: cute.Tensor,
            row_indices: cute.Tensor,
            physical_blocks: cute.Tensor,
            stream: CUstream,
        ):
            device_kernel(
                block_table, sparse_indices, valid_end, row_indices, physical_blocks
            ).launch(
                grid=(
                    cute.ceil_div(sparse_indices.shape[1], 256),
                    sparse_indices.shape[0],
                    1,
                ),
                block=(256, 1, 1),
                stream=stream,
            )

        return entry

    def get_warmup_keys(
        self, *, page_size: int, sparse_block_size: int
    ) -> list[tuple[int, int]]:
        return [(page_size, sparse_block_size)]

    def warmup_inputs(self, key: tuple[int, int]) -> tuple[Any, ...]:
        def matrix(dtype):
            return make_fake_tensor(
                dtype,
                (cute.sym_int(), cute.sym_int()),
                (cute.sym_int(), 1),
                assumed_align=dtype.width // 8,
            )

        def vector():
            return make_fake_tensor(Int32, (cute.sym_int(),), (1,), assumed_align=4)

        return matrix(Int32), matrix(Int32), vector(), vector(), matrix(Int32)

    @kernel_launcher
    def __call__(
        self,
        block_table: torch.Tensor,
        sparse_indices: torch.Tensor,
        valid_end: torch.Tensor,
        row_indices: torch.Tensor,
        physical_blocks: torch.Tensor,
        *,
        page_size: int,
        sparse_block_size: int,
    ) -> CuTeDSLLaunchSpec[tuple[int, int]]:
        assert physical_blocks.dtype == torch.int32
        return (page_size, sparse_block_size), (
            block_table,
            sparse_indices,
            valid_end,
            row_indices,
            physical_blocks,
        )