Skip to content

vllm.compilation.monitor

Functions:

monitor_profiling_run(tag='')

Context manager that times the initial profiling run.

Asserts that no backend compilation occurs during the profiling run (all compilation should have completed before this point).

Source code in vllm/compilation/monitor.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
@contextlib.contextmanager
def monitor_profiling_run(tag: str = "") -> Generator[None, None, None]:
    """Context manager that times the initial profiling run.

    Asserts that no backend compilation occurs during the profiling run
    (all compilation should have completed before this point).
    """
    from vllm.compilation.counter import compilation_counter

    backend_compilations_before = compilation_counter.num_backend_compilations
    start = time.perf_counter()
    yield
    elapsed = time.perf_counter() - start
    assert (
        compilation_counter.num_backend_compilations == backend_compilations_before
    ), (
        "backend compilation occurred during the initial profiling run; "
        "all compilation should be complete before the profiling run starts."
    )
    log_prefix = f"[{tag}] " if tag else ""
    logger.info(
        "%sInitial profiling/warmup run took %.2f s",
        log_prefix,
        elapsed,
    )

monitor_torch_compile(vllm_config, message='%storch.compile took %.2f s in total', is_encoder=False, tag='', announce_start=True)

Context manager that times torch.compile and manages depyf debugging.

On normal exit: logs the compile time and exits depyf. On exception: cleans up depyf without logging (compilation failed).

announce_start=False suppresses the "Starting torch.compile" line; used by the AOT-load probe so a failed load attempt doesn't announce a compile it didn't perform.

Source code in vllm/compilation/monitor.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
@contextlib.contextmanager
def monitor_torch_compile(
    vllm_config: VllmConfig,
    message: str = "%storch.compile took %.2f s in total",
    is_encoder: bool = False,
    tag: str = "",
    announce_start: bool = True,
) -> Generator[None, None, None]:
    """Context manager that times torch.compile and manages depyf debugging.

    On normal exit: logs the compile time and exits depyf.
    On exception: cleans up depyf without logging (compilation failed).

    ``announce_start=False`` suppresses the "Starting torch.compile" line;
    used by the AOT-load probe so a failed load attempt doesn't announce a
    compile it didn't perform.
    """
    global torch_compile_start_time
    torch_compile_start_time = time.perf_counter()

    compilation_config = vllm_config.compilation_config
    log_prefix = f"[{tag}] " if tag else ""
    if announce_start and compilation_config.mode == CompilationMode.VLLM_COMPILE:
        logger.info("%sStarting torch.compile", log_prefix)
    depyf_cm = None
    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)
        depyf_cm = depyf.prepare_debug(path.as_posix())
        depyf_cm.__enter__()

    try:
        yield
    except Exception:
        raise
    else:
        total_compile_time = time.perf_counter() - torch_compile_start_time
        if compilation_config.mode == CompilationMode.VLLM_COMPILE:
            if is_encoder:
                compilation_config.encoder_compilation_time += total_compile_time
            else:
                compilation_config.compilation_time += total_compile_time
            logger.info(message, log_prefix, total_compile_time)
    finally:
        if depyf_cm is not None:
            try:
                depyf_cm.__exit__(None, None, None)
            except Exception:
                logger.warning("Exception during depyf cleanup.", exc_info=True)