dice-cuda-generation

name	dice-cuda-generation
title	DICE: Diffusion LLMs Excel at Generating CUDA Kernels
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2602.11715
keywords	["Code Generation","CUDA Kernels","Diffusion Models","Reinforcement Learning","Bi-Phase Training"]
description	Train diffusion language models to generate optimized CUDA kernels using bi-phase reinforcement learning. First phase masks and regenerates core kernel logic with provided scaffolding to prevent PyTorch shortcuts. Second phase enables end-to-end generation. Leverage diffusion's global context awareness for non-sequential code generation.

DICE: Diffusion LLMs Excel at Generating CUDA Kernels

Problem Context

Generating correct, efficient CUDA kernels requires understanding memory access patterns, thread synchronization, and hardware constraints. Autoregressive models struggle with the global coordination needed for optimal kernels. Diffusion models excel because they can revise entire sequences, refining global properties like memory coalescing and instruction-level parallelism. However, they require specialized RL training to avoid deceptive solutions (e.g., using PyTorch functions instead of custom kernels).

Core Concept

DICE (Diffusion for Imperative Code Execution) uses bi-phase RL training:

1. Kernel infilling: Models learn correct CUDA logic with scaffolding (prefix/suffix provided), preventing shortcuts
2. End-to-end generation: Models progress to full kernel implementation with invocation logic

This leverages diffusion's iterative refinement to handle the multi-constraint optimization problem of kernel generation.

Architecture Overview

• CuKe dataset: 6,303 high-performance CUDA kernels with verified 2.0× speedups
• Kernel infilling stage: Learn core logic with fixed prefix/suffix via RL
• End-to-end stage: Full kernel generation including invocation and bounds checks
• Diffusion advantage: Parallel token generation better suited to code's non-sequential structure
• RL rewards: Compilation success + runtime speedup measurements

Implementation

Step 1: Prepare kernel dataset and scaffolding

from typing import List, Tuple, Dict
import re

class CUDaKernelDataset:
    """Curated CUDA kernel dataset with verified speedups."""

    def __init__(self, dataset_path: str = None):
        self.kernels = []
        self.load_dataset(dataset_path)

    def load_dataset():
        
        
        
        

     () -> [, , ]:
        
        lines = kernel_code.split()

        
        kernel_start = 
        kernel_end = 

         i, line  (lines):
               line    line.lower():
                kernel_start = i
             kernel_start     line.strip() == :
                kernel_end = i
                

         kernel_start    kernel_end  :
             , kernel_code, 

        
        prefix_lines = lines[:kernel_start + ]  
        middle_lines = lines[kernel_start + :kernel_end]
        suffix_lines = lines[kernel_end:]  

        prefix = .join(prefix_lines)
        middle = .join(middle_lines)
        suffix = .join(suffix_lines)

         prefix, middle, suffix

     () -> []:
        
        examples = []

         kernel  .kernels[:num_examples]:
            prefix, middle, suffix = .create_kernel_scaffold(kernel[])

             prefix  :
                

            examples.append({
                : prefix,
                : middle,
                : suffix,
                : kernel[],
                : kernel[]
            })

         examples