第16章：Neural Networks API (NNAPI)

设备管理器初始化流程：

1. 扫描 HAL 服务（通过 hwservicemanager）
2. 加载 HIDL/AIDL 驱动
3. 查询设备能力
4. 构建设备注册表

Score = α * SupportRatio + β * PerformanceScore + γ * PowerEfficiency
其中 α、β、γ 根据编译偏好动态调整

// 获取特定设备
ANeuralNetworksDevice* device;
ANeuralNetworks_getDevice(deviceIndex, &device);

// 查询设备特性
int64_t featureLevel;
ANeuralNetworksDevice_getFeatureLevel(device, &featureLevel);

// 指定编译设备
ANeuralNetworksCompilation_setDevices(compilation, &device, 1);

// 位于 hardware/interfaces/neuralnetworks/版本/IDevice.hal
interface IDevice {
    // 设备能力查询
    getCapabilities() → (status, capabilities)

        - capabilities.relaxedFloat32toFloat16PerformanceScalar
        - capabilities.relaxedFloat32toFloat16PerformanceTensor
        - capabilities.operandPerformance[] // 每种数据类型的性能
        - capabilities.ifPerformance // IF/WHILE 条件性能
        - capabilities.whilePerformance // 循环性能

    // 支持度查询
    getSupportedOperations(model) → (status, supportedOps[])

        - 返回每个操作的支持状态
        - 考虑操作参数和数据类型
        - 检查设备特定限制

    // 模型准备（编译）
    prepareModel(model, preference, deadlineNs, callbacks) → status

        - model: 序列化的模型结构
        - preference: 执行偏好（延迟/功耗/吞吐量）
        - deadlineNs: 编译截止时间
        - callbacks: 异步回调接口

    // 内存分配（v1.3+）
    allocate(desc, roles, type, deadlineNs) → (status, buffer, token)

        - desc: 内存描述符
        - roles: 内存用途（输入/输出/中间结果）
        - type: 分配类型（设备/主机共享）
        - 返回 IBuffer 对象和 token

    // 缓存支持（v1.2+）
    prepareModelFromCache(deadlineNs, cacheHandles, token, callbacks)

        - 从缓存恢复编译模型
        - 避免重复编译开销
}

interface IPreparedModel {
    // 基本同步执行
    execute(request, measure) → (status, outputShapes, timing)

        - request: 包含输入输出内存位置
        - measure: 是否测量执行时间
        - outputShapes: 动态输出形状
        - timing: 执行时间统计

    // 带超时同步执行（v1.3+）
    executeSynchronously(request, measure, deadlineNs, loopTimeoutNs)

        - deadlineNs: 最晚完成时间
        - loopTimeoutNs: 循环超时设置

    // Fence 异步执行（v1.3+）
    executeFenced(request, waitFor, measure, deadlineNs, loopTimeoutNs, 
                  executionTimeoutNs) → (status, syncFence, callback)

        - waitFor: 输入依赖的 fence
        - syncFence: 输出完成 fence
        - 与 GPU/Camera 管线集成

    // Burst 模式配置（v1.2+）
    configureExecutionBurst(requestChannel, resultChannel, context) → status

        - 使用 FMQ (Fast Message Queue) 通信
        - 减少 IPC 开销
        - 预分配执行资源
}

内存共享流程：

1. 应用分配 hidl_memory/AHardwareBuffer
2. 通过 IPC 传递内存句柄
3. 驱动映射到设备地址空间
4. 直接在设备上访问数据

class MemoryPool {
    // 按大小分类的内存块
    std::map<size_t, std::vector<Memory>> pools;

    // 分配策略
    Memory allocate(size_t size) {
        // 1. 查找匹配的空闲块
        // 2. 如果没有，分配新块
        // 3. 记录使用状态
    }

    // 回收机制
    void recycle(Memory mem) {
        // 1. 标记为空闲
        // 2. 合并相邻块
        // 3. 定期清理未用块
    }
};

class ExecutionQueue {
    // 优先级队列
    std::priority_queue<Task> highPriorityQueue;
    std::priority_queue<Task> normalQueue;
    std::priority_queue<Task> lowPriorityQueue;

    // 工作线程池
    std::vector<std::thread> workers;

    // 任务调度
    void schedule(Task task) {
        // 1. 根据优先级入队
        // 2. 唤醒空闲工作线程
        // 3. 负载均衡
    }
};

enum ErrorCode {
    // 基本错误
    NONE = 0,
    DEVICE_UNAVAILABLE = 1,
    GENERAL_FAILURE = 2,
    OUTPUT_INSUFFICIENT_SIZE = 3,
    INVALID_ARGUMENT = 4,

    // 资源错误
    INSUFFICIENT_MEMORY = 1000,
    DEVICE_BUSY = 1001,
    RESOURCE_EXHAUSTED = 1002,

    // 执行错误
    MISSED_DEADLINE = 2000,
    ABORTED = 2001,
    INVALID_STATE = 2002,
};

class ErrorRecovery {
    // 重试机制
    template<typename Func>
    auto retryWithBackoff(Func func, int maxRetries) {
        for (int i = 0; i < maxRetries; i++) {
            try {
                return func();
            } catch (RecoverableError& e) {
                std::this_thread::sleep_for(
                    std::chrono::milliseconds(100 * (1 << i)));
            }
        }
    }

    // 降级策略
    void fallbackToCPU(Model model) {
        // 切换到 CPU 参考实现
    }
};

struct PerformanceCounters {
    // 执行统计
    uint64_t totalExecutions;
    uint64_t successfulExecutions;
    uint64_t failedExecutions;

    // 时间统计
    Duration totalHardwareTime;
    Duration totalDriverTime;
    Duration averageLatency;

    // 资源使用
    size_t peakMemoryUsage;
    float averageUtilization;
};

// HVX 向量化示例
void conv2d_hvx(const uint8_t* input, const uint8_t* weights, 
                uint8_t* output) {
    // 使用 HVX 内在函数
    HVX_Vector vin = vmem(input);
    HVX_Vector vweight = vmem(weights);
    HVX_Vector vout = vdmpy(vin, vweight); // 向量点积
    vmem(output) = vout;
}

APU 3.0 架构：

- 6 个 AI 核心 (AI Core)
- 每核 2048 MACs
- 支持 INT8/INT16/FP16
- 4MB 局部内存
- 独立 DMA 引擎

class APUScheduler {
    // 多模型调度
    void scheduleModels(vector<Model> models) {
        // 1. 资源评估
        // 2. 核心分配
        // 3. 并发执行
    }
};

128x128 系统阵列：

- INT8 运算: 16K ops/cycle
- bfloat16: 8K ops/cycle
- 脉动阵列架构

// TPU 特定优化
void optimizeForTPU(Graph& graph) {
    // 1. 矩阵分块
    tileMatrixOps(graph, 128, 128);
    // 2. 内存布局
    optimizeMemoryLayout(graph);
    // 3. 指令调度
    scheduleInstructions(graph);
}

大核：处理复杂模型

- 3D Cube 计算单元
- 高精度计算

微核：处理轻量任务

- 低功耗设计
- 快速响应

class ModelValidator {
    // 拓扑验证
    bool validateTopology(const Model& model) {
        // 1. 检查环路
        if (hasCycle(model.graph)) return false;

        // 2. 验证连接性
        for (auto& op : model.operations) {
            if (!validateConnections(op)) return false;
        }

        // 3. 检查输入输出
        return validateIOTensors(model);
    }

    // 参数验证
    bool validateParameters(const Operation& op) {
        // 检查参数范围
        // 验证维度兼容性
        // 确认数据类型
    }
};

struct ComputeGraph {
    std::vector<Node> nodes;
    std::vector<Edge> edges;
    std::map<int, TensorInfo> tensorInfo;

    // 构建图
    void buildFromModel(const Model& model) {
        // 1. 创建节点
        for (auto& op : model.operations) {
            nodes.push_back(createNode(op));
        }

        // 2. 连接边
        for (auto& connection : model.connections) {
            edges.push_back(createEdge(connection));
        }

        // 3. 推断张量信息
        inferTensorShapes();
    }
};

class OperatorFusion {
    // Conv + BatchNorm + ReLU 融合
    void fuseConvBNReLU(Graph& graph) {
        for (auto& pattern : findPatterns(graph, "Conv->BN->ReLU")) {
            // 1. 提取参数
            auto conv = pattern.nodes[0];
            auto bn = pattern.nodes[1];
            auto relu = pattern.nodes[2];

            // 2. 计算融合参数
            auto fusedWeights = fuseWeights(conv.weights, 
                                           bn.scale, bn.bias, 
                                           bn.mean, bn.variance);

            // 3. 创建融合节点
            auto fusedOp = createFusedConvBNReLU(fusedWeights);

            // 4. 替换原节点
            graph.replace(pattern, fusedOp);
        }
    }

    // 其他融合模式
    void fusePatterns(Graph& graph) {
        fuseConvBNReLU(graph);
        fuseMatMulAdd(graph);      // MatMul + Add
        fuseActivations(graph);     // 多种激活函数
        fuseElementwise(graph);     // 元素级操作
    }
};

class ConstantFolding {
    void foldConstants(Graph& graph) {
        bool changed = true;
        while (changed) {
            changed = false;
            for (auto& node : graph.nodes) {
                if (allInputsConstant(node)) {
                    // 1. 计算常量结果
                    auto result = evaluateNode(node);

                    // 2. 替换为常量节点
                    auto constNode = createConstant(result);
                    graph.replace(node, constNode);

                    changed = true;
                }
            }
        }
    }
};

class LayoutOptimizer {
    // NCHW <-> NHWC 转换优化
    void optimizeLayout(Graph& graph) {
        // 1. 分析最佳布局
        auto layout = analyzeOptimalLayout(graph);

        // 2. 插入转换节点
        insertLayoutTransforms(graph, layout);

        // 3. 合并相邻转换
        mergeAdjacentTransforms(graph);
    }
};

class CodeGenerator {
    // 为不同设备生成代码
    std::unique_ptr<ExecutableCode> generate(const Graph& graph, 
                                             Device device) {
        switch (device.type) {
            case DeviceType::CPU:
                return generateCPUCode(graph);
            case DeviceType::GPU:
                return generateGPUCode(graph);
            case DeviceType::DSP:
                return generateDSPCode(graph);
            case DeviceType::NPU:
                return generateNPUCode(graph);
        }
    }

    // CPU 代码生成
    std::unique_ptr<CPUCode> generateCPUCode(const Graph& graph) {
        CPUCodeBuilder builder;

        // 1. 内存分配
        auto memoryPlan = planMemory(graph);

        // 2. 指令选择
        for (auto& node : graph.nodes) {
            auto kernels = selectKernels(node, cpuInfo);
            builder.addKernels(kernels);
        }

        // 3. 向量化优化
        builder.vectorize();

        return builder.build();
    }
};

class MemoryPlanner {
    MemoryPlan planMemory(const Graph& graph) {
        // 1. 生命周期分析
        auto lifetimes = analyzeLifetimes(graph);

        // 2. 内存复用
        auto allocation = allocateWithReuse(lifetimes);

        // 3. 对齐优化
        optimizeAlignment(allocation);

        // 4. 缓存优化
        optimizeCacheUsage(allocation);

        return allocation;
    }

    // 内存复用算法
    Allocation allocateWithReuse(const Lifetimes& lifetimes) {
        // 使用图着色算法
        auto graph = buildInterferenceGraph(lifetimes);
        auto coloring = colorGraph(graph);
        return assignMemory(coloring);
    }
};

class ParallelizationStrategy {
    // 数据并行
    void applyDataParallelism(ComputeKernel& kernel) {
        auto batchSize = kernel.inputShape[0];
        auto numThreads = getOptimalThreadCount();

        kernel.parallel_for(0, batchSize, numThreads);
    }

    // 模型并行
    void applyModelParallelism(Graph& graph) {
        // 1. 分区
        auto partitions = partitionGraph(graph);

        // 2. 调度
        schedulePartitions(partitions);
    }

    // 流水线并行
    void applyPipelineParallelism(ExecutionPlan& plan) {
        // 创建流水线阶段
        auto stages = createPipelineStages(plan);

        // 设置缓冲区
        setupInterstageBuffers(stages);
    }
};

class INT8Quantizer {
    // 量化参数计算
    struct QuantParams {
        float scale;
        int32_t zero_point;

        // 计算量化参数
        static QuantParams compute(float min_val, float max_val) {
            QuantParams params;

            // 对称量化
            float max_abs = std::max(std::abs(min_val), 
                                    std::abs(max_val));
            params.scale = max_abs / 127.0f;
            params.zero_point = 0;

            // 非对称量化
            // params.scale = (max_val - min_val) / 255.0f;
            // params.zero_point = -min_val / params.scale;

            return params;
        }
    };

    // 量化核心函数
    void quantizeTensor(const float* input, int8_t* output, 
                       size_t size, const QuantParams& params) {
        for (size_t i = 0; i < size; i++) {
            int32_t q = std::round(input[i] / params.scale + 
                                  params.zero_point);
            output[i] = std::max(-128, std::min(127, q));
        }
    }

    // 反量化
    void dequantizeTensor(const int8_t* input, float* output,
                         size_t size, const QuantParams& params) {
        for (size_t i = 0; i < size; i++) {
            output[i] = (input[i] - params.zero_point) * params.scale;
        }
    }
};

class DynamicQuantization {
    // 运行时校准
    void calibrate(const Model& model, const Dataset& calibData) {
        std::map<int, QuantStats> stats;

        // 1. 收集统计信息
        for (auto& sample : calibData) {
            auto activations = runModel(model, sample);
            updateStats(stats, activations);
        }

        // 2. 计算量化参数
        for (auto& [tensorId, stat] : stats) {
            quantParams[tensorId] = computeOptimalParams(stat);
        }
    }

    // 最优参数计算
    QuantParams computeOptimalParams(const QuantStats& stats) {
        // KL 散度最小化
        return minimizeKLDivergence(stats.histogram);
    }
};

class MixedPrecisionOptimizer {
    // 精度分配策略
    void assignPrecisions(Graph& graph) {
        // 1. 敏感度分析
        auto sensitivities = analyzeSensitivity(graph);

        // 2. 分配精度
        for (auto& node : graph.nodes) {
            if (sensitivities[node.id] > threshold) {
                node.precision = Precision::FP32;
            } else if (node.type == OpType::MatMul) {
                node.precision = Precision::FP16;
            } else {
                node.precision = Precision::INT8;
            }
        }

        // 3. 插入类型转换
        insertCastOperations(graph);
    }
};

class TensorLifetimeAnalyzer {
    struct Lifetime {
        int firstUse;
        int lastUse;
        size_t size;
        int alignment;
    };

    std::map<int, Lifetime> analyze(const Graph& graph) {
        std::map<int, Lifetime> lifetimes;

        // 1. 遍历执行顺序
        auto order = topologicalSort(graph);

        // 2. 记录使用点
        for (int step = 0; step < order.size(); step++) {
            auto& node = graph.nodes[order[step]];

            // 输入张量
            for (int input : node.inputs) {
                lifetimes[input].lastUse = step;
                if (lifetimes[input].firstUse == -1) {
                    lifetimes[input].firstUse = step;
                }
            }

            // 输出张量
            for (int output : node.outputs) {
                lifetimes[output].firstUse = step;
                lifetimes[output].size = getTensorSize(output);
            }
        }

        return lifetimes;
    }
};

class MemoryPool {
    struct Block {
        size_t offset;
        size_t size;
        bool free;
    };

    std::vector<Block> blocks;
    size_t totalSize;

    // 分配算法
    size_t allocate(size_t size, int alignment) {
        // 1. 首次适配
        for (auto& block : blocks) {
            if (block.free && block.size >= size) {
                size_t alignedOffset = align(block.offset, alignment);
                if (alignedOffset + size <= block.offset + block.size) {
                    // 分割块
                    splitBlock(block, alignedOffset, size);
                    return alignedOffset;
                }
            }
        }

        // 2. 扩展池
        expandPool(size, alignment);
        return allocate(size, alignment);
    }

    // 碎片整理
    void defragment() {
        // 合并相邻空闲块
        mergeAdjacentFreeBlocks();

        // 移动占用块
        compactAllocatedBlocks();
    }
};

class WorkspaceOptimizer {
    // 计算最小工作空间
    size_t computeMinWorkspace(const Graph& graph) {
        // 1. 分析每个操作的工作空间需求
        std::map<int, size_t> workspaceNeeds;
        for (auto& node : graph.nodes) {
            workspaceNeeds[node.id] = 
                estimateWorkspace(node.type, node.params);
        }

        // 2. 并发分析
        auto concurrentOps = analyzeConcurrency(graph);

        // 3. 计算峰值需求
        size_t maxWorkspace = 0;
        for (auto& group : concurrentOps) {
            size_t groupWorkspace = 0;
            for (int opId : group) {
                groupWorkspace += workspaceNeeds[opId];
            }
            maxWorkspace = std::max(maxWorkspace, groupWorkspace);
        }

        return maxWorkspace;
    }
};

class BatchOptimizer {
    // 动态批处理
    void optimizeBatching(ExecutionPlan& plan) {
        // 1. 分析批处理机会
        auto batchableOps = findBatchableOperations(plan);

        // 2. 合并批次
        for (auto& group : batchableOps) {
            auto optimalBatchSize = computeOptimalBatchSize(group);
            mergeBatches(group, optimalBatchSize);
        }

        // 3. 重新调度
        rescheduleExecution(plan);
    }

    // 最佳批大小计算
    int computeOptimalBatchSize(const OpGroup& group) {
        // 考虑内存带宽和计算能力
        int memoryLimit = getAvailableMemory() / group.memoryPerItem;
        int computeLimit = getComputeCapacity() / group.computePerItem;

        return std::min(memoryLimit, computeLimit);
    }
};

class PipelineExecutor {
    struct Stage {
        std::vector<Operation> ops;
        std::queue<Task> taskQueue;
        std::thread worker;
    };

    std::vector<Stage> stages;

    // 创建流水线
    void createPipeline(const Graph& graph) {
        // 1. 划分阶段
        auto stageOps = partitionIntoStages(graph);

        // 2. 创建工作线程
        for (auto& ops : stageOps) {
            Stage stage;
            stage.ops = ops;
            stage.worker = std::thread([this, &stage]() {
                processStage(stage);
            });
            stages.push_back(std::move(stage));
        }

        // 3. 设置缓冲区
        setupInterstageBuffers();
    }
};

class AsyncMemoryTransfer {
    // DMA 传输管理
    class DMAManager {
        std::queue<TransferRequest> pendingTransfers;
        std::vector<DMAChannel> channels;

        // 发起异步传输
        Future<void> asyncTransfer(void* src, void* dst, 
                                  size_t size) {
            auto channel = getAvailableChannel();

            TransferRequest req{src, dst, size};
            auto future = channel.startTransfer(req);

            // 后台线程管理传输
            transferThread.addTask([channel, future]() {
                future.wait();
                channel.release();
            });

            return future;
        }
    };

    // 预取策略
    void prefetchData(const ExecutionPlan& plan) {
        for (int i = 0; i < plan.operations.size() - 1; i++) {
            auto& currentOp = plan.operations[i];
            auto& nextOp = plan.operations[i + 1];

            // 当前操作执行时，预取下一个操作的数据
            parallel_invoke(
                [&]() { executeOperation(currentOp); },
                [&]() { prefetchOperationData(nextOp); }
            );
        }
    }
};

class CompilationCache {
    // 缓存项定义
    struct CacheEntry {
        std::string modelHash;      // 模型哈希
        std::string deviceId;       // 设备标识
        CompilationParams params;   // 编译参数

        std::vector<uint8_t> compiledBinary;  // 编译结果
        std::chrono::time_point<> timestamp;  // 时间戳
        size_t hitCount;                      // 命中次数
    };

    // 缓存存储
    class CacheStorage {
        // 内存缓存
        std::unordered_map<std::string, CacheEntry> memCache;

        // 磁盘缓存
        std::string cacheDir;

        // 保存到磁盘
        void persistToDisk(const std::string& key, 
                          const CacheEntry& entry) {
            std::string filePath = cacheDir + "/" + key + ".nnc";

            // 序列化元数据
            std::ofstream meta(filePath + ".meta");
            serializeMetadata(meta, entry);

            // 保存二进制
            std::ofstream binary(filePath, std::ios::binary);
            binary.write(reinterpret_cast<const char*>(
                entry.compiledBinary.data()), 
                entry.compiledBinary.size());
        }

        // 从磁盘加载
        std::optional<CacheEntry> loadFromDisk(const std::string& key) {
            std::string filePath = cacheDir + "/" + key + ".nnc";

            if (!fileExists(filePath)) return std::nullopt;

            // 加载并验证
            auto entry = deserializeEntry(filePath);
            if (validateEntry(entry)) {
                return entry;
            }

            return std::nullopt;
        }
    };
};

class CacheKeyGenerator {
    std::string generateKey(const Model& model, 
                           const Device& device,
                           const CompilationParams& params) {
        // 1. 计算模型哈希
        std::string modelHash = computeModelHash(model);

        // 2. 设备特征
        std::string deviceFeatures = getDeviceFeatures(device);

        // 3. 编译参数
        std::string paramsHash = hashParams(params);

        // 4. 组合键
        return modelHash + "_" + deviceFeatures + "_" + paramsHash;
    }

    // 模型哈希计算
    std::string computeModelHash(const Model& model) {
        SHA256 hasher;

        // 哈希拓扑结构
        for (auto& op : model.operations) {
            hasher.update(op.type);
            hasher.update(op.inputs);
            hasher.update(op.outputs);
            hasher.update(op.params);
        }

        // 哈希权重数据
        for (auto& tensor : model.tensors) {
            if (tensor.isConstant) {
                hasher.update(tensor.data);
            }
        }

        return hasher.finalize();
    }
};

class CacheEvictionPolicy {
    // LRU 淘汰
    void evictLRU(CacheStorage& cache, size_t targetSize) {
        std::vector<std::pair<std::string, time_t>> entries;

        // 收集所有项的访问时间
        for (auto& [key, entry] : cache.memCache) {
            entries.push_back({key, entry.timestamp});
        }

        // 按时间排序
        std::sort(entries.begin(), entries.end(), 
                 [](auto& a, auto& b) { return a.second < b.second; });

        // 淘汰旧项
        size_t currentSize = cache.getCurrentSize();
        for (auto& [key, _] : entries) {
            if (currentSize <= targetSize) break;

            currentSize -= cache.remove(key);
        }
    }

    // 使用频率淘汰
    void evictLFU(CacheStorage& cache, size_t targetSize) {
        // 按 hitCount 排序并淘汰
    }
};

class ExecutionResourceCache {
    struct ResourcePool {
        std::vector<ExecutionContext> contexts;
        std::queue<int> availableIndices;
        std::mutex mutex;

        // 获取可用上下文
        ExecutionContext* acquire() {
            std::lock_guard<std::mutex> lock(mutex);

            if (availableIndices.empty()) {
                // 创建新上下文
                contexts.emplace_back();
                return &contexts.back();
            }

            int idx = availableIndices.front();
            availableIndices.pop();
            return &contexts[idx];
        }

        // 释放上下文
        void release(ExecutionContext* ctx) {
            std::lock_guard<std::mutex> lock(mutex);

            // 清理和重置
            ctx->reset();

            // 放回池中
            int idx = ctx - contexts.data();
            availableIndices.push(idx);
        }
    };

    // 每个模型的资源池
    std::unordered_map<std::string, ResourcePool> modelPools;
};

class BurstExecutor {
    // Burst 会话
    class BurstSession {
        IPreparedModel* model;
        FMQRequestChannel requestChannel;
        FMQResultChannel resultChannel;
        std::thread executorThread;

        // 初始化 Burst 会话
        void initialize() {
            // 1. 创建 FMQ 通道
            requestChannel.create(1024 * 1024);  // 1MB
            resultChannel.create(1024 * 1024);

            // 2. 配置模型
            model->configureExecutionBurst(
                requestChannel.getDescriptor(),
                resultChannel.getDescriptor());

            // 3. 启动执行线程
            executorThread = std::thread([this]() {
                processBurstRequests();
            });
        }

        // 处理 Burst 请求
        void processBurstRequests() {
            while (running) {
                Request req;
                if (requestChannel.read(&req)) {
                    // 直接执行，无 IPC 开销
                    auto result = executeDirectly(req);

                    // 写回结果
                    resultChannel.write(result);
                }
            }
        }
    };

    // Burst 会话管理
    std::unordered_map<std::string, BurstSession> sessions;
};

class HotPathOptimizer {
    // 执行统计
    struct PathStats {
        std::vector<int> executionPath;
        int executionCount;
        double averageTime;
    };

    std::map<std::string, PathStats> pathStatistics;

    // 分析热点路径
    void analyzeHotPaths(const Model& model) {
        // 1. 收集执行路径
        auto paths = collectExecutionPaths(model);

        // 2. 统计频率
        for (auto& path : paths) {
            pathStatistics[hashPath(path)].executionCount++;
        }

        // 3. 识别热点
        std::vector<std::string> hotPaths;
        for (auto& [pathHash, stats] : pathStatistics) {
            if (stats.executionCount > threshold) {
                hotPaths.push_back(pathHash);
            }
        }

        // 4. 优化热点路径
        for (auto& pathHash : hotPaths) {
            optimizePath(pathHash);
        }
    }

    // 路径优化
    void optimizePath(const std::string& pathHash) {
        // 1. 专门编译
        compilePathSpecialized(pathHash);

        // 2. 预分配资源
        preallocatePathResources(pathHash);

        // 3. 缓存中间结果
        cacheIntermediateResults(pathHash);
    }
};

class CacheVersionManager {
    struct VersionInfo {
        int nnApiVersion;
        int halVersion;
        std::string driverVersion;
        std::string buildHash;
    };

    // 验证缓存有效性
    bool validateCache(const CacheEntry& entry) {
        VersionInfo current = getCurrentVersion();
        VersionInfo cached = entry.versionInfo;

        // 版本匹配
        if (current.nnApiVersion != cached.nnApiVersion ||
            current.halVersion != cached.halVersion) {
            return false;
        }

        // 驱动版本检查
        if (current.driverVersion != cached.driverVersion) {
            return requiresRecompilation(current, cached);
        }

        return true;
    }
};

class ConcurrentCacheAccess {
    // 读写锁
    std::shared_mutex cacheMutex;

    // 细粒度锁
    std::unordered_map<std::string, std::unique_ptr<std::mutex>> 
        entryLocks;

    // 安全读取
    std::optional<CacheEntry> read(const std::string& key) {
        std::shared_lock<std::shared_mutex> lock(cacheMutex);

        auto it = cache.find(key);
        if (it != cache.end()) {
            return it->second;
        }

        return std::nullopt;
    }

    // 安全写入
    void write(const std::string& key, const CacheEntry& entry) {
        std::unique_lock<std::shared_mutex> lock(cacheMutex);

        cache[key] = entry;

        // 异步持久化
        persistAsync(key, entry);
    }
};