Skip to content

vllm.compilation.monitor

context_manager module-attribute 

context_manager = None

cudagraph_capturing_enabled module-attribute 

cudagraph_capturing_enabled: bool = True

logger module-attribute 

logger = init_logger(__name__)

torch_compile_start_time module-attribute 

torch_compile_start_time: float = 0.0

end_monitoring_torch_compile 

end_monitoring_torch_compile(
    vllm_config: VllmConfig,
) -> None
Source code in vllm/compilation/monitor.py 
31
32
33
34
35
36
37
38
39
40
41
42
def end_monitoring_torch_compile(vllm_config: VllmConfig) -> None:
    compilation_config: CompilationConfig = vllm_config.compilation_config
    if compilation_config.mode == CompilationMode.VLLM_COMPILE:
        logger.info_once(
            "torch.compile takes %.2f s in total",
            compilation_config.compilation_time,
            scope="local",
        )
        global context_manager
        if context_manager is not None:
            context_manager.__exit__(None, None, None)
            context_manager = None

set_cudagraph_capturing_enabled 

set_cudagraph_capturing_enabled(enabled: bool) -> None
Source code in vllm/compilation/monitor.py 
60
61
62
def set_cudagraph_capturing_enabled(enabled: bool) -> None:
    global cudagraph_capturing_enabled
    cudagraph_capturing_enabled = enabled

start_monitoring_torch_compile 

start_monitoring_torch_compile(
    vllm_config: VllmConfig,
) -> None
Source code in vllm/compilation/monitor.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def start_monitoring_torch_compile(vllm_config: VllmConfig) -> None:
    global torch_compile_start_time
    torch_compile_start_time = time.time()

    compilation_config: CompilationConfig = vllm_config.compilation_config
    path = vllm_config.compile_debug_dump_path()
    if compilation_config.mode == CompilationMode.VLLM_COMPILE and path:
        import depyf

        path.mkdir(parents=True, exist_ok=True)
        logger.debug("Dumping depyf output to %s", path)
        global context_manager
        context_manager = depyf.prepare_debug(path.as_posix())
        context_manager.__enter__()

validate_cudagraph_capturing_enabled 

validate_cudagraph_capturing_enabled() -> None
Source code in vllm/compilation/monitor.py 
48
49
50
51
52
53
54
55
56
57
def validate_cudagraph_capturing_enabled() -> None:
    # used to monitor whether a cudagraph capturing is legal at runtime.
    # should be called before any cudagraph capturing.
    # if an illegal cudagraph capturing happens, raise an error.
    global cudagraph_capturing_enabled
    if not cudagraph_capturing_enabled:
        raise RuntimeError(
            "CUDA graph capturing detected at an inappropriate "
            "time. This operation is currently disabled."
        )