HarmonyOS开发：NNAPI硬件加速适配与多NPU调度

核心要点：NNAPI是HarmonyOS连接AI推理框架与底层NPU硬件的桥梁，掌握NNAPI适配与多NPU调度，是释放端侧AI极致性能的关键。本文从NNAPI架构原理、设备发现、算子适配、多NPU负载均衡到故障容错，全方位解析硬件加速的实战技巧。

一、背景与动机

你有没有想过，为什么同样的模型，在旗舰机上推理只要5ms，在入门机上却要50ms？

答案不是"CPU太弱"这么简单。旗舰机和入门机最大的差距不在CPU，而在NPU——那个专门为AI计算设计的硬件加速器。

华为从麒麟970开始引入NPU，到麒麟9000S的达芬奇架构2.0，NPU的INT8算力已经从1.92 TOPS飙升到了超过20 TOPS。这意味着什么？意味着一个INT8量化的MobileNetV2，NPU推理一帧只需要1-2ms，而CPU可能需要30-50ms。10倍以上的性能差距！

但问题来了：你的APP怎么知道设备有没有NPU？有NPU的话怎么把推理任务"送"给NPU？如果有多个NPU（比如大核NPU+小核NPU），怎么分配任务？NPU突然不可用了怎么办？

这些问题，都需要通过NNAPI来解决。NNAPI（Neural Network API）是HarmonyOS提供的AI硬件加速接口，它就像一个"翻译官"，把上层推理框架的计算请求翻译成底层NPU能理解的指令。今天咱们就深入NNAPI的内部机制，看看怎么榨干NPU的每一滴算力。

二、核心原理

2.1 NNAPI架构总览

NNAPI在HarmonyOS AI技术栈中处于"中间层"的位置，连接上层的推理框架和下层的硬件驱动：

2.2 NNAPI核心概念

Device（设备）：NNAPI中的Device代表一个AI计算设备，可以是NPU、GPU或CPU。每个Device都有自己的能力集（支持的算子、数据类型、性能指标）。

Model（模型）：NNAPI中的Model是由算子和操作数（Operand）组成的计算图。MindSpore Lite的模型在提交给NPU之前，需要先转换为NNAPI的Model格式。

Compilation（编译）：将Model编译为特定Device可执行的格式。编译过程包括算子映射、内存布局优化、指令生成等。

Execution（执行）：一次具体的推理执行，设置输入数据、触发计算、获取输出结果。

2.3 NPU硬件架构

华为达芬奇NPU架构的核心特点：

2.4 多NPU调度策略

在支持多NPU的设备上（如大核NPU+小核NPU），调度策略直接影响性能：

1. 性能优先：所有任务分配给大核NPU，最大化吞吐量
2. 功耗优先：轻量任务分配给小核NPU，降低功耗
3. 负载均衡：根据各NPU的负载情况动态分配任务
4. 流水线并行：将一个推理任务拆分为多个子图，分布到不同NPU上流水线执行

2.5 算子适配与回退机制

并非所有MindSpore Lite算子都能在NPU上执行。NNAPI的回退机制如下：

模型算子列表 → NPU支持检查
├── 支持的算子 → 编译为NPU指令
└── 不支持的算子 → 回退到CPU执行
    └── 如果NPU和CPU之间数据拷贝开销 > CPU直接执行 → 全部回退CPU

关键判断标准：NPU加速收益是否大于数据搬运开销。如果一个模型中只有少量算子在NPU上执行，频繁的CPU↔NPU数据拷贝可能反而拖慢推理速度。

三、代码实战

3.1 NPU设备发现与能力检测

在应用启动时检测设备的NPU能力，为后续的调度决策提供依据：

// NpuDeviceDetector.ets
// 功能：NPU设备发现与能力检测

import { mindsporeLite } from '@kit.MindSporeLiteKit';
import { common } from '@kit.AbilityKit';

/**
 * NPU设备信息
 */
interface NpuDeviceInfo {
  /** 设备是否可用 */
  isAvailable: boolean;
  /** 设备名称 */
  deviceName: string;
  /** 支持的算子列表 */
  supportedOps: string[];
  /** INT8算力估算（TOPS） */
  int8Tops: number;
  /** FP16算力估算（TFLOPS） */
  fp16Tflops: number;
  /** 片上缓存大小（MB） */
  cacheSizeMB: number;
  /** 功耗等级 */
  powerLevel: 'high' | 'medium' | 'low';
  /** 支持的频率等级 */
  frequencyLevels: number;
}

/**
 * 设备能力评估结果
 */
interface DeviceCapabilityResult {
  /** NPU设备信息 */
  npuInfo: NpuDeviceInfo | null;
  /** CPU设备信息 */
  cpuInfo: { threadCount: number; supportsFP16: boolean };
  /** 推荐的执行策略 */
  recommendedStrategy: string;
  /** 预估的加速比 */
  estimatedSpeedup: number;
}

/**
 * NPU设备检测器
 */
export class NpuDeviceDetector {
  private context: common.Context;

  constructor(context: common.Context) {
    this.context = context;
  }

  /**
   * 检测NPU设备可用性
   */
  async detectNpu(): Promise<NpuDeviceInfo | null> {
    try {
      // 尝试创建NPU设备
      const npuDevice = new mindsporeLite.NpuDevice();
      
      // 如果创建成功，说明NPU可用
      const npuInfo: NpuDeviceInfo = {
        isAvailable: true,
        deviceName: 'DaVinci NPU',
        supportedOps: this.getSupportedOps(),
        int8Tops: this.estimateInt8Tops(),
        fp16Tflops: this.estimateFp16Tflops(),
        cacheSizeMB: this.estimateCacheSize(),
        powerLevel: 'high',
        frequencyLevels: 4
      };

      console.info(`[NpuDetector] NPU可用: ${npuInfo.deviceName}`);
      console.info(`[NpuDetector] INT8算力: ${npuInfo.int8Tops} TOPS`);
      console.info(`[NpuDetector] 片上缓存: ${npuInfo.cacheSizeMB} MB`);
      
      return npuInfo;
    } catch (error) {
      console.warn(`[NpuDetector] NPU不可用: ${JSON.stringify(error)}`);
      return null;
    }
  }

  /**
   * 获取NPU支持的算子列表
   * 注意：实际支持列表取决于具体的NPU硬件版本
   */
  private getSupportedOps(): string[] {
    // 达芬奇NPU常见支持的算子
    return [
      // 卷积类
      'CONV_2D', 'DEPTHWISE_CONV_2D', 'CONV_2D_TRANSPOSE',
      // 激活类
      'RELU', 'RELU6', 'SIGMOID', 'TANH', 'PRELU',
      // 池化类
      'MAX_POOL_2D', 'AVG_POOL_2D',
      // 归一化类
      'BATCH_NORM', 'L2_NORM', 'SOFTMAX',
      // 全连接类
      'FULLY_CONNECTED',
      // 元素级操作
      'ADD', 'MUL', 'SUB', 'DIV',
      // 变形类
      'RESHAPE', 'TRANSPOSE', 'CONCAT',
      // 量化相关
      'QUANTIZE', 'DEQUANTIZE'
    ];
  }

  /**
   * 估算INT8算力（TOPS）
   * 根据设备型号估算，实际值应以官方规格为准
   */
  private estimateInt8Tops(): number {
    // 简化估算：基于设备内存和CPU核心数推断设备等级
    // 实际应通过系统API获取设备型号
    const totalMemoryMB = 8192; // 简化
    
    if (totalMemoryMB >= 16384) {
      return 28; // 旗舰级
    } else if (totalMemoryMB >= 12288) {
      return 20; // 高端
    } else if (totalMemoryMB >= 8192) {
      return 14; // 中高端
    } else {
      return 8; // 中端
    }
  }

  /**
   * 估算FP16算力（TFLOPS）
   */
  private estimateFp16Tflops(): number {
    // FP16算力通常为INT8的1/4到1/2
    return this.estimateInt8Tops() / 4;
  }

  /**
   * 估算片上缓存大小（MB）
   */
  private estimateCacheSize(): number {
    const tops = this.estimateInt8Tops();
    if (tops >= 20) return 4;
    if (tops >= 14) return 2;
    return 1;
  }

  /**
   * 综合评估设备能力
   */
  async evaluateDeviceCapability(): Promise<DeviceCapabilityResult> {
    const npuInfo = await this.detectNpu();
    
    // CPU信息
    const cpuInfo = {
      threadCount: 4, // 简化，实际应通过系统API获取
      supportsFP16: true
    };

    // 推荐策略
    let recommendedStrategy: string;
    let estimatedSpeedup: number;

    if (npuInfo && npuInfo.isAvailable) {
      if (npuInfo.int8Tops >= 20) {
        recommendedStrategy = 'NPU优先（高性能模式）';
        estimatedSpeedup = 5.0;
      } else if (npuInfo.int8Tops >= 10) {
        recommendedStrategy = 'NPU优先（均衡模式）';
        estimatedSpeedup = 3.0;
      } else {
        recommendedStrategy = 'NPU+CPU混合';
        estimatedSpeedup = 2.0;
      }
    } else {
      recommendedStrategy = 'CPU FP16推理';
      estimatedSpeedup = 1.0;
    }

    const result: DeviceCapabilityResult = {
      npuInfo,
      cpuInfo,
      recommendedStrategy,
      estimatedSpeedup
    };

    console.info(`[NpuDetector] 推荐策略: ${recommendedStrategy}`);
    console.info(`[NpuDetector] 预估加速比: ${estimatedSpeedup}x`);

    return result;
  }

  /**
   * 测试NPU实际推理性能
   * @param modelPath 测试模型路径
   * @param iterations 测试轮次
   */
  async benchmarkNpuPerformance(
    modelPath: string,
    iterations: number = 30
  ): Promise<{ npuTime: number; cpuTime: number; speedup: number } | null> {
    try {
      // NPU推理测试
      const npuContext = new mindsporeLite.Context();
      try {
        const npu = new mindsporeLite.NpuDevice();
        npu.frequency = mindsporeLite.Frequency.FREQ_LEVEL_3;
        npuContext.addDevice(npu);
      } catch (e) {
        console.warn('[NpuDetector] NPU不可用，无法测试');
        return null;
      }

      const npuTime = await this.runBenchmark(modelPath, npuContext, iterations);

      // CPU推理测试
      const cpuContext = new mindsporeLite.Context();
      const cpu = new mindsporeLite.CpuDevice();
      cpu.isEnableFloat16 = true;
      cpu.threadNum = 4;
      cpuContext.addDevice(cpu);

      const cpuTime = await this.runBenchmark(modelPath, cpuContext, iterations);

      const speedup = cpuTime / npuTime;

      console.info(`[NpuDetector] NPU: ${npuTime}ms, CPU: ${cpuTime}ms, 加速比: ${speedup.toFixed(2)}x`);

      return { npuTime, cpuTime, speedup };
    } catch (error) {
      console.error(`[NpuDetector] 性能测试失败: ${JSON.stringify(error)}`);
      return null;
    }
  }

  /**
   * 运行基准测试
   */
  private async runBenchmark(
    modelPath: string,
    context: mindsporeLite.Context,
    iterations: number
  ): Promise<number> {
    const model = new mindsporeLite.Model();
    const buffer = this.context.resourceMgr.getRawFileContentSync(modelPath);
    model.build(buffer.buffer, context);

    const inputs = model.getInputs();
    const inputSize = inputs[0].shape.reduce((a: number, b: number) => a * b, 1);
    const dummyInput = new Float32Array(inputSize);
    inputs[0].setData(dummyInput.buffer);

    // 预热
    for (let i = 0; i < 5; i++) {
      model.predict(inputs);
    }

    // 正式测试
    const startTime = Date.now();
    for (let i = 0; i < iterations; i++) {
      model.predict(inputs);
    }
    const totalTime = Date.now() - startTime;

    model.free();

    return totalTime / iterations;
  }
}

3.2 多NPU调度器：智能分配推理任务

在支持多NPU的设备上，实现负载感知的任务调度：

// MultiNpuScheduler.ets
// 功能：多NPU调度器 - 智能分配推理任务到不同NPU

import { mindsporeLite } from '@kit.MindSporeLiteKit';
import { common } from '@kit.AbilityKit';

/**
 * NPU实例信息
 */
interface NpuInstance {
  /** 实例ID */
  id: string;
  /** NPU类型 */
  type: 'big_core' | 'little_core';
  /** MindSpore Lite NpuDevice实例 */
  device: mindsporeLite.NpuDevice;
  /** 当前负载（0-1） */
  currentLoad: number;
  /** 累计推理次数 */
  totalInferences: number;
  /** 平均推理时间（ms） */
  avgInferTime: number;
  /** 是否可用 */
  isAvailable: boolean;
}

/**
 * 调度策略
 */
type SchedulingStrategy = 'performance' | 'power_saving' | 'load_balanced' | 'pipeline';

/**
 * 调度决策结果
 */
interface SchedulingDecision {
  /** 选中的NPU实例ID */
  selectedNpuId: string;
  /** 选择原因 */
  reason: string;
  /** 预估推理时间（ms） */
  estimatedTime: number;
}

/**
 * 多NPU调度器
 */
export class MultiNpuScheduler {
  private npuInstances: Map<string, NpuInstance> = new Map();
  private strategy: SchedulingStrategy = 'load_balanced';
  private context: common.Context;
  private fallbackToCpu: boolean = false;

  constructor(context: common.Context) {
    this.context = context;
  }

  /**
   * 初始化NPU实例
   * 尝试发现并注册所有可用的NPU
   */
  async initialize(): Promise<boolean> {
    try {
      // 尝试创建大核NPU
      try {
        const bigCoreDevice = new mindsporeLite.NpuDevice();
        bigCoreDevice.frequency = mindsporeLite.Frequency.FREQ_LEVEL_3;
        
        this.npuInstances.set('npu_big_0', {
          id: 'npu_big_0',
          type: 'big_core',
          device: bigCoreDevice,
          currentLoad: 0,
          totalInferences: 0,
          avgInferTime: 0,
          isAvailable: true
        });
        console.info('[Scheduler] 大核NPU注册成功');
      } catch (e) {
        console.warn('[Scheduler] 大核NPU不可用');
      }

      // 尝试创建小核NPU（部分设备支持）
      try {
        const littleCoreDevice = new mindsporeLite.NpuDevice();
        littleCoreDevice.frequency = mindsporeLite.Frequency.FREQ_LEVEL_1;
        
        // 如果大核已注册，小核使用不同ID
        if (this.npuInstances.size > 0) {
          this.npuInstances.set('npu_little_0', {
            id: 'npu_little_0',
            type: 'little_core',
            device: littleCoreDevice,
            currentLoad: 0,
            totalInferences: 0,
            avgInferTime: 0,
            isAvailable: true
          });
          console.info('[Scheduler] 小核NPU注册成功');
        }
      } catch (e) {
        // 小核NPU不可用是正常的
      }

      if (this.npuInstances.size === 0) {
        console.warn('[Scheduler] 无可用NPU，将回退到CPU');
        this.fallbackToCpu = true;
        return false;
      }

      console.info(`[Scheduler] 初始化完成，共${this.npuInstances.size}个NPU实例`);
      return true;
    } catch (error) {
      console.error(`[Scheduler] 初始化失败: ${JSON.stringify(error)}`);
      this.fallbackToCpu = true;
      return false;
    }
  }

  /**
   * 设置调度策略
   */
  setStrategy(strategy: SchedulingStrategy): void {
    this.strategy = strategy;
    console.info(`[Scheduler] 调度策略切换为: ${strategy}`);
  }

  /**
   * 根据调度策略选择NPU
   */
  schedule(): SchedulingDecision {
    if (this.fallbackToCpu || this.npuInstances.size === 0) {
      return {
        selectedNpuId: 'cpu',
        reason: 'NPU不可用，回退CPU',
        estimatedTime: 50 // CPU预估
      };
    }

    switch (this.strategy) {
      case 'performance':
        return this.scheduleForPerformance();
      case 'power_saving':
        return this.scheduleForPowerSaving();
      case 'load_balanced':
        return this.scheduleForLoadBalanced();
      case 'pipeline':
        return this.scheduleForPipeline();
      default:
        return this.scheduleForLoadBalanced();
    }
  }

  /**
   * 性能优先调度
   * 始终选择推理速度最快的NPU
   */
  private scheduleForPerformance(): SchedulingDecision {
    let bestNpu: NpuInstance | null = null;
    let bestTime = Infinity;

    for (const npu of this.npuInstances.values()) {
      if (!npu.isAvailable) continue;
      
      // 大核NPU优先
      const estimatedTime = npu.type === 'big_core' ? 5 : 10;
      if (estimatedTime < bestTime) {
        bestTime = estimatedTime;
        bestNpu = npu;
      }
    }

    if (!bestNpu) {
      return { selectedNpuId: 'cpu', reason: '无可用NPU', estimatedTime: 50 };
    }

    return {
      selectedNpuId: bestNpu.id,
      reason: `性能优先，选择${bestNpu.type === 'big_core' ? '大核' : '小核'}NPU`,
      estimatedTime: bestTime
    };
  }

  /**
   * 功耗优先调度
   * 优先使用小核NPU，大核仅在必要时使用
   */
  private scheduleForPowerSaving(): SchedulingDecision {
    // 优先选择小核
    for (const npu of this.npuInstances.values()) {
      if (npu.isAvailable && npu.type === 'little_core') {
        return {
          selectedNpuId: npu.id,
          reason: '功耗优先，选择小核NPU',
          estimatedTime: 10
        };
      }
    }

    // 没有小核，使用大核低频模式
    for (const npu of this.npuInstances.values()) {
      if (npu.isAvailable && npu.type === 'big_core') {
        return {
          selectedNpuId: npu.id,
          reason: '功耗优先，大核低频模式',
          estimatedTime: 8
        };
      }
    }

    return { selectedNpuId: 'cpu', reason: '无可用NPU', estimatedTime: 50 };
  }

  /**
   * 负载均衡调度
   * 根据各NPU的当前负载分配任务
   */
  private scheduleForLoadBalanced(): SchedulingDecision {
    let leastLoadedNpu: NpuInstance | null = null;
    let minLoad = Infinity;

    for (const npu of this.npuInstances.values()) {
      if (!npu.isAvailable) continue;
      
      if (npu.currentLoad < minLoad) {
        minLoad = npu.currentLoad;
        leastLoadedNpu = npu;
      }
    }

    if (!leastLoadedNpu) {
      return { selectedNpuId: 'cpu', reason: '无可用NPU', estimatedTime: 50 };
    }

    return {
      selectedNpuId: leastLoadedNpu.id,
      reason: `负载均衡，选择负载最低的${leastLoadedNpu.type === 'big_core' ? '大核' : '小核'}NPU (负载${(minLoad * 100).toFixed(0)}%)`,
      estimatedTime: leastLoadedNpu.type === 'big_core' ? 5 : 10
    };
  }

  /**
   * 流水线调度
   * 将推理任务拆分为子图，分布到不同NPU
   */
  private scheduleForPipeline(): SchedulingDecision {
    // 流水线模式：大核处理前半部分，小核处理后半部分
    // 简化实现：交替分配
    const npus = Array.from(this.npuInstances.values()).filter(n => n.isAvailable);
    
    if (npus.length === 0) {
      return { selectedNpuId: 'cpu', reason: '无可用NPU', estimatedTime: 50 };
    }

    // 简单轮询
    const totalInferences = npus.reduce((sum, n) => sum + n.totalInferences, 0);
    const selectedNpu = npus[totalInferences % npus.length];

    return {
      selectedNpuId: selectedNpu.id,
      reason: `流水线调度，轮询分配到${selectedNpu.id}`,
      estimatedTime: selectedNpu.type === 'big_core' ? 5 : 10
    };
  }

  /**
   * 创建包含选中NPU的推理上下文
   */
  createContext(npuId: string): mindsporeLite.Context {
    const context = new mindsporeLite.Context();

    if (npuId !== 'cpu') {
      const npu = this.npuInstances.get(npuId);
      if (npu && npu.isAvailable) {
        context.addDevice(npu.device);
      }
    }

    // 始终添加CPU作为回退
    const cpu = new mindsporeLite.CpuDevice();
    cpu.isEnableFloat16 = true;
    cpu.threadNum = 4;
    context.addDevice(cpu);

    return context;
  }

  /**
   * 更新NPU负载信息
   * @param npuId NPU实例ID
   * @param inferTime 本次推理耗时
   */
  updateLoad(npuId: string, inferTime: number): void {
    const npu = this.npuInstances.get(npuId);
    if (!npu) return;

    npu.totalInferences++;
    
    // 使用EMA更新平均推理时间
    const alpha = 0.1;
    npu.avgInferTime = alpha * inferTime + (1 - alpha) * npu.avgInferTime;
    
    // 更新负载（简化：基于推理频率估算）
    // 假设目标帧率为30fps，每帧33ms
    npu.currentLoad = Math.min(1.0, npu.avgInferTime / 33);
  }

  /**
   * 标记NPU不可用（故障容错）
   */
  markNpuUnavailable(npuId: string, reason: string): void {
    const npu = this.npuInstances.get(npuId);
    if (npu) {
      npu.isAvailable = false;
      console.warn(`[Scheduler] NPU ${npuId} 标记为不可用: ${reason}`);
    }

    // 检查是否还有可用NPU
    const availableCount = Array.from(this.npuInstances.values())
      .filter(n => n.isAvailable).length;
    
    if (availableCount === 0) {
      this.fallbackToCpu = true;
      console.warn('[Scheduler] 所有NPU不可用，回退到CPU');
    }
  }

  /**
   * 尝试恢复NPU
   */
  async tryRecoverNpu(npuId: string): Promise<boolean> {
    try {
      const testDevice = new mindsporeLite.NpuDevice();
      // 如果能创建成功，说明NPU已恢复
      const npu = this.npuInstances.get(npuId);
      if (npu) {
        npu.device = testDevice;
        npu.isAvailable = true;
        npu.currentLoad = 0;
        this.fallbackToCpu = false;
        console.info(`[Scheduler] NPU ${npuId} 已恢复`);
        return true;
      }
    } catch (e) {
      console.warn(`[Scheduler] NPU ${npuId} 恢复失败`);
    }
    return false;
  }

  /**
   * 获取调度状态报告
   */
  getStatusReport(): string {
    let report = '===== NPU调度状态 =====\n';
    report += `调度策略: ${this.strategy}\n`;
    report += `CPU回退: ${this.fallbackToCpu ? '是' : '否'}\n`;

    for (const [id, npu] of this.npuInstances) {
      report += `\n[${id}]\n`;
      report += `  类型: ${npu.type}\n`;
      report += `  可用: ${npu.isAvailable ? '是' : '否'}\n`;
      report += `  负载: ${(npu.currentLoad * 100).toFixed(0)}%\n`;
      report += `  平均推理时间: ${npu.avgInferTime.toFixed(2)}ms\n`;
      report += `  累计推理次数: ${npu.totalInferences}\n`;
    }

    return report;
  }

  /**
   * 释放所有资源
   */
  release(): void {
    this.npuInstances.clear();
  }
}

3.3 完整NPU加速推理应用：带故障容错与自动恢复

将NPU检测、调度、容错集成到完整的应用中：

// NpuAcceleratedApp.ets
// 功能：NPU加速推理应用 - 带故障容错与自动恢复

import { mindsporeLite } from '@kit.MindSporeLiteKit';
import { fileIo } from '@kit.CoreFileKit';
import { common } from '@kit.AbilityKit';
import { NpuDeviceDetector } from './NpuDeviceDetector';
import { MultiNpuScheduler, SchedulingStrategy } from './MultiNpuScheduler';

@Entry
@Component
struct NpuAcceleratedApp {
  @State npuStatus: string = '检测中...';
  @State currentDevice: string = '未知';
  @State schedulingStrategy: string = 'load_balanced';
  @State inferTime: number = 0;
  @State totalInferences: number = 0;
  @State npuInferences: number = 0;
  @State cpuInferences: number = 0;
  @State isRunning: boolean = false;
  @Status schedulerReport: string = '';

  private model: mindsporeLite.Model | null = null;
  private npuDetector: NpuDeviceDetector | null = null;
  private scheduler: MultiNpuScheduler | null = null;
  private recoverTimer: number = -1;

  async aboutToAppear(): Promise<void> {
    this.npuDetector = new NpuDeviceDetector(this.getContext());
    this.scheduler = new MultiNpuScheduler(this.getContext());

    // 检测NPU
    const capability = await this.npuDetector.evaluateDeviceCapability();
    
    if (capability.npuInfo?.isAvailable) {
      this.npuStatus = `NPU可用 (${capability.npuInfo.deviceName})`;
      this.currentDevice = 'NPU';
      
      // 初始化调度器
      await this.scheduler.initialize();
      this.scheduler.setStrategy('load_balanced');
    } else {
      this.npuStatus = 'NPU不可用，使用CPU';
      this.currentDevice = 'CPU';
    }

    // 加载模型
    await this.loadModel();
  }

  aboutToDisappear(): void {
    if (this.recoverTimer >= 0) {
      clearInterval(this.recoverTimer);
    }
    if (this.model) {
      this.model.free();
    }
    this.scheduler?.release();
  }

  /**
   * 加载模型
   */
  async loadModel(): Promise<void> {
    try {
      // 根据调度决策创建上下文
      const decision = this.scheduler?.schedule() || { selectedNpuId: 'cpu' };
      const context = this.scheduler?.createContext(decision.selectedNpuId) || new mindsporeLite.Context();

      if (!this.scheduler) {
        const cpu = new mindsporeLite.CpuDevice();
        cpu.isEnableFloat16 = true;
        cpu.threadNum = 4;
        context.addDevice(cpu);
      }

      this.model = new mindsporeLite.Model();
      const modelPath = this.getContext().resourceDir + '/mobilenetv2.ms';
      const buffer = fileIo.readFileSync(modelPath);
      
      const result = this.model.build(buffer.buffer, context);
      
      if (result === mindsporeLite.CompileRetCode.COMPILE_SUCCESS) {
        console.info('[App] 模型加载成功');
      } else {
        console.error('[App] 模型加载失败');
      }
    } catch (error) {
      console.error(`[App] 加载异常: ${JSON.stringify(error)}`);
    }
  }

  /**
   * 执行推理（带NPU故障容错）
   */
  async runInference(inputData: Float32Array): Promise<Float32Array | null> {
    if (!this.model) return null;

    this.isRunning = true;

    try {
      const inputs = this.model.getInputs();
      inputs[0].setData(inputData.buffer);

      const startTime = Date.now();
      this.model.predict(inputs);
      this.inferTime = Date.now() - startTime;

      const outputs = this.model.getOutputs();
      const outputData = new Float32Array(outputs[0].getData().slice(0));

      // 更新统计
      this.totalInferences++;
      if (this.currentDevice === 'NPU') {
        this.npuInferences++;
        this.scheduler?.updateLoad('npu_big_0', this.inferTime);
      } else {
        this.cpuInferences++;
      }

      return outputData;
    } catch (error) {
      // NPU推理失败 - 故障容错
      console.error(`[App] 推理失败: ${JSON.stringify(error)}`);
      
      if (this.currentDevice === 'NPU') {
        console.warn('[App] NPU推理失败，尝试回退到CPU...');
        this.handleNpuFailure();
      }
      
      return null;
    } finally {
      this.isRunning = false;
    }
  }

  /**
   * 处理NPU故障
   */
  private handleNpuFailure(): void {
    // 标记NPU不可用
    this.scheduler?.markNpuUnavailable('npu_big_0', '推理异常');
    this.currentDevice = 'CPU';
    this.npuStatus = 'NPU故障，已回退CPU';

    // 重新加载模型（使用CPU）
    if (this.model) {
      this.model.free();
      this.model = null;
    }

    // 使用CPU上下文重新加载
    const context = new mindsporeLite.Context();
    const cpu = new mindsporeLite.CpuDevice();
    cpu.isEnableFloat16 = true;
    cpu.threadNum = 4;
    context.addDevice(cpu);

    try {
      this.model = new mindsporeLite.Model();
      const modelPath = this.getContext().resourceDir + '/mobilenetv2.ms';
      const buffer = fileIo.readFileSync(modelPath);
      this.model.build(buffer.buffer, context);
      console.info('[App] CPU回退模型加载成功');
    } catch (e) {
      console.error('[App] CPU回退模型加载失败');
    }

    // 启动NPU恢复检测定时器
    this.startNpuRecoveryCheck();
  }

  /**
   * 启动NPU恢复检测
   * 每30秒尝试恢复NPU
   */
  private startNpuRecoveryCheck(): void {
    if (this.recoverTimer >= 0) return; // 避免重复启动

    this.recoverTimer = setInterval(async () => {
      console.info('[App] 尝试恢复NPU...');
      const recovered = await this.scheduler?.tryRecoverNpu('npu_big_0');
      
      if (recovered) {
        console.info('[App] NPU已恢复，重新加载模型...');
        clearInterval(this.recoverTimer);
        this.recoverTimer = -1;
        
        this.currentDevice = 'NPU';
        this.npuStatus = 'NPU已恢复 ✓';
        
        // 重新加载模型（使用NPU）
        if (this.model) {
          this.model.free();
        }
        await this.loadModel();
      }
    }, 30000); // 30秒检测一次
  }

  /**
   * 切换调度策略
   */
  switchStrategy(strategy: SchedulingStrategy): void {
    this.scheduler?.setStrategy(strategy);
    this.schedulingStrategy = strategy;
  }

  build() {
    Scroll() {
      Column() {
        // 标题
        Text('NPU加速推理')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .margin({ top: 20, bottom: 16 })

        // NPU状态卡片
        Column() {
          Text('设备状态')
            .fontSize(16)
            .fontWeight(FontWeight.Medium)
            .margin({ bottom: 12 })

          Row() {
            Text('NPU: ')
              .fontSize(14)
            Text(this.npuStatus)
              .fontSize(14)
              .fontWeight(FontWeight.Medium)
              .fontColor(this.npuStatus.includes('可用') || this.npuStatus.includes('恢复') ? '#4CAF50' : '#FF5722')
          }
          .width('100%')
          .margin({ bottom: 4 })

          Row() {
            Text('当前设备: ')
              .fontSize(14)
            Text(this.currentDevice)
              .fontSize(14)
              .fontWeight(FontWeight.Medium)
              .fontColor(this.currentDevice === 'NPU' ? '#4A90D9' : '#E8A838')
          }
          .width('100%')
        }
        .width('90%')
        .padding(16)
        .backgroundColor('#F0F4F8')
        .borderRadius(12)
        .margin({ bottom: 16 })

        // 调度策略选择
        Text('调度策略')
          .fontSize(16)
          .fontWeight(FontWeight.Medium)
          .margin({ bottom: 8 })

        Row() {
          ForEach([
            { key: 'performance', label: '性能优先' },
            { key: 'power_saving', label: '功耗优先' },
            { key: 'load_balanced', label: '负载均衡' },
            { key: 'pipeline', label: '流水线' }
          ], (item: { key: SchedulingStrategy; label: string }) => {
            Button(item.label)
              .height(32)
              .fontSize(12)
              .backgroundColor(this.schedulingStrategy === item.key ? '#4A90D9' : '#E0E0E0')
              .fontColor(this.schedulingStrategy === item.key ? '#FFFFFF' : '#333333')
              .borderRadius(16)
              .margin({ left: 4, right: 4 })
              .onClick(() => this.switchStrategy(item.key))
          })
        }
        .margin({ bottom: 16 })

        // 推理统计
        Column() {
          Text('推理统计')
            .fontSize(16)
            .fontWeight(FontWeight.Medium)
            .margin({ bottom: 12 })

          Row() {
            Text(`总推理次数: ${this.totalInferences}`)
              .fontSize(14)
              .layoutWeight(1)
            Text(`最近耗时: ${this.inferTime}ms`)
              .fontSize(14)
              .fontColor('#50B5A9')
          }
          .width('100%')
          .margin({ bottom: 4 })

          Row() {
            Text(`NPU推理: ${this.npuInferences}次`)
              .fontSize(14)
              .fontColor('#4A90D9')
              .layoutWeight(1)
            Text(`CPU推理: ${this.cpuInferences}次`)
              .fontSize(14)
              .fontColor('#E8A838')
          }
          .width('100%')

          // NPU使用率进度条
          if (this.totalInferences > 0) {
            Row() {
              Text('NPU使用率:')
                .fontSize(12)
                .fontColor('#999999')
              Progress({
                value: this.npuInferences,
                total: this.totalInferences,
                type: ProgressType.Linear
              })
                .width(120)
                .color('#4A90D9')
              Text(`${(this.npuInferences / this.totalInferences * 100).toFixed(0)}%`)
                .fontSize(12)
                .fontColor('#666666')
            }
            .margin({ top: 8 })
          }
        }
        .width('90%')
        .padding(16)
        .backgroundColor('#F0F4F8')
        .borderRadius(12)
        .margin({ bottom: 16 })

        // 操作按钮
        Button('执行推理测试')
          .width('80%')
          .height(48)
          .fontSize(16)
          .backgroundColor('#4A90D9')
          .borderRadius(24)
          .enabled(!this.isRunning)
          .margin({ bottom: 12 })
          .onClick(async () => {
            const testInput = new Float32Array(3 * 224 * 224);
            for (let i = 0; i < testInput.length; i++) {
              testInput[i] = Math.random();
            }
            await this.runInference(testInput);
          })

        // 连续推理按钮（模拟实时场景）
        Button('连续推理测试（30帧）')
          .width('80%')
          .height(48)
          .fontSize(16)
          .backgroundColor('#50B5A9')
          .borderRadius(24)
          .enabled(!this.isRunning)
          .margin({ bottom: 16 })
          .onClick(async () => {
            this.isRunning = true;
            for (let i = 0; i < 30; i++) {
              const testInput = new Float32Array(3 * 224 * 224);
              for (let j = 0; j < testInput.length; j++) {
                testInput[j] = Math.random();
              }
              await this.runInference(testInput);
            }
            this.isRunning = false;
          })

        // 加载指示器
        if (this.isRunning) {
          LoadingProgress()
            .width(40)
            .height(40)
            .color('#4A90D9')
            .margin({ bottom: 16 })
        }
      }
      .width('100%')
      .alignItems(HorizontalAlign.Center)
      .padding({ bottom: 40 })
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#FFFFFF')
  }
}

四、踩坑与注意事项

4.1 NPU编译失败

坑位：模型在CPU上编译成功，添加NPU后编译失败，报错"unsupported operator"。

原因：NPU支持的算子集合是CPU的子集。模型中包含NPU不支持的算子时，编译会失败。

解决方案：

// 方案1：使用CPU+NPU混合模式（推荐）
// MindSpore Lite会自动将不支持的算子回退到CPU
const context = new mindsporeLite.Context();

// 先添加NPU
try {
  const npu = new mindsporeLite.NpuDevice();
  context.addDevice(npu);
} catch (e) { /* NPU不可用 */ }

// 再添加CPU作为回退
const cpu = new mindsporeLite.CpuDevice();
context.addDevice(cpu);

// 方案2：修改模型，替换不支持的算子
// 常见不支持：自定义激活函数、动态Shape、某些归一化
// 替换策略：Swish → ReLU, LayerNorm → BatchNorm

4.2 NPU推理结果与CPU不一致

坑位：同一模型在NPU和CPU上的推理结果差异超过预期。

原因：

1. NPU使用FP16精度，CPU使用FP32精度
2. NPU的算子实现可能与CPU有微小差异
3. 量化参数在NPU和CPU上的处理方式不同

解决方案：

// 方案1：设置可接受的精度容差
function isResultAcceptable(
  cpuOutput: Float32Array,
  npuOutput: Float32Array,
  tolerance: number = 0.01
): boolean {
  const similarity = cosineSimilarity(cpuOutput, npuOutput);
  return similarity > (1 - tolerance);
}

// 方案2：对精度敏感的层强制使用CPU
// 在模型转换时标记不使用NPU的层

// 方案3：使用FP32精度的NPU模式（如果硬件支持）
// HarmonyOS 6支持设置NPU精度偏好

4.3 NPU内存不足

坑位：大模型在NPU上推理时报错"out of memory"。

原因：NPU的片上缓存有限（通常2-4MB），大模型的中间特征图可能超出缓存容量。

解决方案：

// 方案1：使用更小的输入分辨率
// 224x224 → 160x160，中间特征图减少约50%

// 方案2：使用更小的batch size
// batch=4 → batch=1

// 方案3：模型分片执行
// 将模型拆分为多个子图，逐段在NPU上执行
// 每个子图的中间结果暂存到DRAM

// 方案4：使用INT8量化减少内存占用
// INT8的中间特征图只有FP32的1/4

4.4 NPU频率设置不当

坑位：设置NPU最高频率后，设备发热严重，反而触发降频导致性能下降。

原因：持续高频运行会导致NPU温度过高，系统触发温控降频。

解决方案：

// 方案1：使用中等频率（推荐）
const npu = new mindsporeLite.NpuDevice();
npu.frequency = mindsporeLite.Frequency.FREQ_LEVEL_3; // 中等频率

// 方案2：根据场景动态调整频率
// 短时推理：高频
// 长时推理：中频
// 后台推理：低频

// 方案3：监控设备温度，自动降频
function getRecommendedFrequency(thermalState: string): mindsporeLite.Frequency {
  switch (thermalState) {
    case 'normal': return mindsporeLite.Frequency.FREQ_LEVEL_3;
    case 'warm': return mindsporeLite.Frequency.FREQ_LEVEL_2;
    case 'hot': return mindsporeLite.Frequency.FREQ_LEVEL_1;
    default: return mindsporeLite.Frequency.FREQ_LEVEL_2;
  }
}

4.5 NPU突然不可用

坑位：推理过程中NPU突然不可用，应用崩溃。

原因：系统可能因内存压力、温控策略等原因回收NPU资源。

解决方案：

// 必须实现NPU故障容错机制
async safeInfer(inputData: Float32Array): Promise<Float32Array | null> {
  try {
    // 尝试NPU推理
    return await this.npuInfer(inputData);
  } catch (npuError) {
    console.warn(`[SafeInfer] NPU推理失败: ${JSON.stringify(npuError)}`);
    
    try {
      // 回退到CPU推理
      return await this.cpuInfer(inputData);
    } catch (cpuError) {
      console.error(`[SafeInfer] CPU推理也失败: ${JSON.stringify(cpuError)}`);
      return null;
    }
  }
}

五、HarmonyOS 6适配

5.1 新增NNAPI能力

HarmonyOS 6在NNAPI方面带来了以下重要更新：

5.2 迁移指南

1. 异步推理迁移：

// HarmonyOS 5：同步推理
model.predict(inputs); // 阻塞直到推理完成

// HarmonyOS 6：异步推理
const execution = model.createAsyncExecution();
execution.setInput(0, inputData.buffer);
execution.start(); // 非阻塞，立即返回

// 在回调中获取结果
execution.onComplete((outputs) => {
  const result = new Float32Array(outputs[0].getData().slice(0));
  console.info('异步推理完成');
});

2. 共享内存迁移：

// HarmonyOS 6新增：NPU与CPU共享内存，避免数据拷贝
// const sharedMemory = new mindsporeLite.SharedMemory(tensorSize);
// CPU写入输入数据
// sharedMemory.write(inputData);
// NPU直接从共享内存读取，无需拷贝
// execution.setInputFromSharedMemory(0, sharedMemory);

3. 精度控制迁移：

// HarmonyOS 6新增：指定NPU精度模式
const npu = new mindsporeLite.NpuDevice();
// npu.precisionMode = mindsporeLite.NpuPrecisionMode.PREFER_FP16;
// npu.precisionMode = mindsporeLite.NpuPrecisionMode.PREFER_INT8;
// npu.precisionMode = mindsporeLite.NpuPrecisionMode.STRICT_FP32;

六、总结

本文深入讲解了NNAPI硬件加速适配与多NPU调度的核心原理与实战技巧，关键知识点回顾：

NNAPI硬件加速与多NPU调度知识图谱
├── NNAPI架构
│   ├── 应用层 → 推理框架层 → NNAPI Runtime → 硬件驱动
│   ├── 核心概念：Device/Model/Compilation/Execution
│   └── 职责：算子映射、内存管理、执行调度、错误处理
├── NPU硬件
│   ├── 达芬奇架构：3D Cube + 向量单元 + 标量单元
│   ├── 片上缓存：2-4MB SRAM
│   ├── 多核架构：大核（高性能）+ 小核（低功耗）
│   └── INT8算力：8-28 TOPS（视型号而定）
├── 多NPU调度
│   ├── 性能优先：始终选择最快的NPU
│   ├── 功耗优先：优先小核NPU
│   ├── 负载均衡：根据负载动态分配
│   └── 流水线：子图分布到不同NPU
├── 算子适配
│   ├── NPU支持算子：卷积、池化、激活、全连接等
│   ├── 不支持算子：回退CPU执行
│   └── 关键判断：NPU加速收益 > 数据搬运开销
├── 故障容错
│   ├── NPU不可用时回退CPU
│   ├── 定时检测NPU恢复
│   └── 重新加载模型切换设备
└── 踩坑要点
    ├── NPU编译失败：添加CPU作为回退
    ├── 精度不一致：FP16 vs FP32差异
    ├── 内存不足：减小分辨率或使用INT8
    ├── 频率设置：避免持续高频触发降频
    └── NPU突然不可用：必须实现故障容错

一句话总结：NNAPI是端侧AI硬件加速的"任督二脉"——打通了它，NPU的算力才能被充分释放。记住核心原则：NPU优先、CPU回退、负载均衡、故障容错。一个健壮的NPU加速方案，不仅要追求极致性能，更要确保在各种异常情况下都能优雅降级、持续服务。毕竟，用户不会关心你用的是NPU还是CPU，他们只关心——结果对不对、速度快不快、应用稳不稳。