flowchart TB
    subgraph CompilationModule["Compilation 模块"]
        CompilerManager["CompilerManager<br/>编译管理器"]
        VllmBackend["VllmBackend<br/>vLLM编译后端"]
        
        subgraph CompilerInterface["编译器接口"]
            EagerAdaptor["EagerAdaptor<br/>即时执行适配器"]
            InductorAdaptor["InductorAdaptor<br/>Inductor适配器"]
            StandaloneAdaptor["InductorStandaloneAdaptor<br/>独立编译适配器"]
        end
        
        subgraph CacheSystem["缓存系统"]
            CacheLoader["Cache Loader<br/>缓存加载器"]
            CacheStorage["Cache Storage<br/>缓存存储"]
            HashComputer["Hash Computer<br/>哈希计算器"]
        end
        
        subgraph PassManager["Pass管理"]
            PostGradPass["PostGradPassManager<br/>后梯度Pass管理器"]
            InductorPass["InductorPass<br/>Inductor优化Pass"]
            CustomPass["Custom Pass<br/>自定义优化Pass"]
        end
        
        subgraph Monitoring["性能监控"]
            CompilationCounter["Compilation Counter<br/>编译计数器"]
            PerformanceMonitor["Performance Monitor<br/>性能监控器"]
            MetricsCollector["Metrics Collector<br/>指标收集器"]
        end
    end
    
    subgraph External["外部组件"]
        TorchCompile["torch.compile"]
        PyTorchInductor["PyTorch Inductor"]
        CUDAKernels["CUDA Kernels"]
        ModelExecutor["Model Executor"]
    end
    
    ModelExecutor --> CompilerManager
    CompilerManager --> VllmBackend
    VllmBackend --> CompilerInterface
    CompilerInterface --> TorchCompile
    TorchCompile --> PyTorchInductor
    PyTorchInductor --> CUDAKernels
    
    CompilerManager --> CacheSystem
    VllmBackend --> PassManager
    CompilerManager --> Monitoring
    
    classDef compilation fill:#e1f5fe
    classDef interface fill:#f3e5f5
    classDef cache fill:#e8f5e8
    classDef pass fill:#fff3e0
    classDef monitor fill:#ffebee
    classDef external fill:#f0f0f0
    
    class CompilerManager,VllmBackend compilation
    class EagerAdaptor,InductorAdaptor,StandaloneAdaptor interface
    class CacheLoader,CacheStorage,HashComputer cache
    class PostGradPass,InductorPass,CustomPass pass
    class CompilationCounter,PerformanceMonitor,MetricsCollector monitor
    class TorchCompile,PyTorchInductor,CUDAKernels,ModelExecutor external

def compile(
    self,
    graph: fx.GraphModule,
    example_inputs: List[Any],
    additional_inductor_config: Dict[str, Any],
    compilation_config: CompilationConfig,
    graph_index: int = 0,
    num_graphs: int = 1,
    runtime_shape: Optional[int] = None
) -> Any:
    """
    编译模型图的核心算法
    支持缓存复用、分片编译和性能监控
    """
    # 1) 编译统计和监控
    if graph_index == 0:
        global compilation_start_time
        compilation_start_time = time.time()
    
    compilation_counter.num_backend_compilations += 1
    
    # 2) 尝试从缓存加载
    compiled_graph = self.load(graph, example_inputs, graph_index, runtime_shape)
    if compiled_graph is not None:
        if graph_index == num_graphs - 1:
            # 记录缓存命中的加载时间
            elapsed = time.time() - compilation_start_time
            logger.info(f"Load compiled graph from cache, took {elapsed:.3f}s")
        return compiled_graph
    
    # 3) 缓存未命中，执行编译
    if isinstance(self.compiler, InductorAdaptor):
        maybe_key = None  # Inductor自动生成key
    else:
        maybe_key = f"artifact_shape_{runtime_shape}_subgraph_{graph_index}"
    
    # 4) 调用具体编译器进行编译
    compiled_graph, handle = self.compiler.compile(
        graph, example_inputs, additional_inductor_config,
        runtime_shape, maybe_key
    )
    
    # 5) 保存编译结果到缓存
    if compiled_graph is not None and handle is not None:
        self.save(handle, graph, example_inputs, graph_index, runtime_shape, compiled_graph)
    
    return compiled_graph

def compute_hash_keys(
    self,
    graph: fx.GraphModule,
    example_inputs: List[Any],
    graph_index: int,
    runtime_shape: Optional[int] = None
) -> Tuple[str, str]:
    """
    计算编译缓存的哈希键
    确保缓存的正确性和一致性
    """
    # 1) 收集影响编译的因素
    hash_factors = []
    
    # 模型图结构哈希
    graph_code = str(graph.code)
    hash_factors.append(("graph_code", graph_code))
    
    # 输入形状和数据类型
    input_shapes = [tuple(inp.shape) for inp in example_inputs if hasattr(inp, 'shape')]
    input_dtypes = [str(inp.dtype) for inp in example_inputs if hasattr(inp, 'dtype')]
    hash_factors.append(("input_shapes", input_shapes))
    hash_factors.append(("input_dtypes", input_dtypes))
    
    # 运行时形状信息
    if runtime_shape is not None:
        hash_factors.append(("runtime_shape", runtime_shape))
    
    # 编译器配置
    compiler_config = self.compilation_config.to_dict()
    hash_factors.append(("compiler_config", compiler_config))
    
    # 编译器版本信息
    compiler_version = self.compiler.compute_hash(self.vllm_config)
    hash_factors.append(("compiler_version", compiler_version))
    
    # 2) 生成哈希
    hash_content = json.dumps(hash_factors, sort_keys=True)
    cache_key = hashlib.md5(hash_content.encode(), usedforsecurity=False).hexdigest()[:16]
    
    # 3) 构建文件路径
    cache_filename = f"graph_{graph_index}_shape_{runtime_shape}_{cache_key}"
    
    return cache_key, cache_filename

def piecewise_compile(
    self,
    graph: fx.GraphModule,
    example_inputs: List[Any]
) -> Callable:
    """
    分片编译算法
    将大型模型图分解为多个小图分别编译
    """
    # 1) 图分析和分片策略
    split_items = self._analyze_and_split_graph(graph)
    
    # 2) 创建拼接图模块
    split_gm = self._create_stitching_graph(split_items)
    
    # 3) 逐片编译
    compiled_pieces = []
    for i, split_item in enumerate(split_items):
        logger.info(f"Compiling piece {i+1}/{len(split_items)}")
        
        # 编译单个分片
        compiled_piece = self.compile(
            split_item.graph,
            split_item.example_inputs,
            self.compilation_config.to_dict(),
            self.compilation_config,
            graph_index=i,
            num_graphs=len(split_items)
        )
        
        compiled_pieces.append(compiled_piece)
    
    # 4) 构建完整的可调用对象
    def compiled_function(*args, **kwargs):
        # 按顺序执行各个编译片段
        intermediate_results = []
        current_inputs = args
        
        for piece in compiled_pieces:
            piece_output = piece(*current_inputs)
            intermediate_results.append(piece_output)
            current_inputs = piece_output if not isinstance(piece_output, tuple) else piece_output
        
        return intermediate_results[-1]
    
    return compiled_function