NPU (Neural Processing Unit)

Linux NPU 드라이버를 AI 추론 워크로드의 지연시간·전력·메모리 효율 관점에서 심층 정리합니다. DRM accel 계층과 커맨드 제출 모델, 사용자 공간 런타임과 커널 ioctl 경계, 텐서 버퍼 할당과 DMA-BUF 공유, IOMMU/PASID 기반 주소 공간 격리, 펌웨어 로딩과 에러 복구 시나리오, DVFS/thermal/runtime PM 연계 전력 최적화, CPU/GPU/NPU 협업 파이프라인 구성과 프로파일링까지 실전 NPU 스택 구축에 필요한 핵심 내용을 다룹니다.

NPU (Neural Processing Unit) 개요

NPU(Neural Processing Unit)는 딥러닝 추론/학습 워크로드에 최적화된 전용 하드웨어 가속기입니다. 메인라인의 DRM Accel(drivers/accel/) 서브시스템은 GPU와 분리된 전용 디바이스 노드(/dev/accel/accel0)를 통해 NPU 및 AI 가속기를 관리하며, 커널 버전별 구체 기능은 릴리스/배포판 정책을 확인해야 합니다.

NPU vs GPU vs CPU 연산 특성

NPU 하드웨어 아키텍처 개념

NPU의 핵심은 Systolic Array(맥동 배열)를 기반으로 한 행렬 연산 유닛과 전용 데이터 흐름 제어기입니다. 대부분의 NPU는 다음과 같은 공통 구조를 가집니다.

NPU 데이터 흐름

NPU에서 추론을 수행하는 전체 데이터 흐름은 다음과 같습니다.

1. 모델 컴파일: ONNX/TFLite 모델을 NPU 전용 바이너리(blob)로 오프라인 컴파일. 레이어별 타일링, 양자화, 메모리 할당 계획이 포함됨
2. 버퍼 할당: GEM BO(Buffer Object)를 통해 입력/출력/가중치 버퍼를 커널 드라이버에 할당 요청
3. 커맨드 버퍼 생성: UMD가 DMA 전송, 연산 커맨드 등을 커맨드 버퍼에 기록
4. 잡 제출: ioctl을 통해 커맨드 버퍼를 커널에 제출 → drm_sched가 스케줄링
5. HW 실행: 펌웨어가 레이어 단위로 Compute Cluster에 디스패치, SRAM ↔ DDR DMA 전송 관리
6. 완료 통보: IRQ → dma_fence 시그널 → 유저 공간에 결과 전달

양자화(Quantization)와 데이터 타입

NPU는 전력 효율을 위해 낮은 정밀도의 데이터 타입을 사용합니다. MAC 어레이의 데이터 타입에 따라 연산 처리량(TOPS)이 크게 달라집니다.

DRM Accel 서브시스템

DRM Accel은 Linux 6.2에서 도입된 NPU/AI 가속기 전용 프레임워크입니다. DRM의 인프라를 재사용하면서도 GPU와 별개의 디바이스 노드 네임스페이스를 제공합니다.

디바이스 노드 구조

# GPU 디바이스 노드 (DRM)
/dev/dri/card0          # DRM master (KMS + 렌더)
/dev/dri/renderD128     # render-only (non-root GPU 접근)

# NPU/Accel 디바이스 노드 (DRM Accel)
/dev/accel/accel0       # AI 가속기 전용 노드
/dev/accel/accel1       # 두 번째 가속기 (있는 경우)

# sysfs 계층
/sys/class/accel/accel0/
    ├── device           # → PCI/platform 디바이스 심링크
    ├── dev              # major:minor 번호
    └── power/           # 전원 관리 속성

Accel 드라이버 등록

Accel 드라이버는 drm_dev_alloc() 대신 accel_minor_alloc()을 내부적으로 사용합니다. 드라이버는 drm_driver에 DRIVER_COMPUTE_ACCEL 플래그를 설정하여 Accel 모드를 활성화합니다.

#include <drm/drm_accel.h>
#include <drm/drm_drv.h>
#include <drm/drm_gem.h>
#include <drm/drm_ioctl.h>

/* Accel 드라이버 플래그: DRIVER_COMPUTE_ACCEL을 설정하면
 * /dev/accel/accelN 노드가 생성됨 (GPU용 /dev/dri/* 대신)
 * 참고: DRIVER_RENDER와 동시에 사용 불가 */
static const struct drm_driver my_npu_driver = {
    .driver_features    = DRIVER_GEM | DRIVER_COMPUTE_ACCEL,
    .name               = "my_npu",
    .desc               = "My NPU Accelerator",
    .date               = "20250101",
    .major              = 1,
    .minor              = 0,

    /* GEM 오퍼레이션 */
    .gem_create_object  = my_npu_gem_create_object,

    /* ioctl 테이블 */
    .ioctls             = my_npu_ioctls,
    .num_ioctls         = ARRAY_SIZE(my_npu_ioctls),

    /* 파일 오퍼레이션 */
    .fops               = &my_npu_fops,
};

/* probe에서 등록 */
static int my_npu_probe(struct pci_dev *pdev,
                        const struct pci_device_id *ent)
{
    struct drm_device *drm;
    struct my_npu_device *ndev;
    int ret;

    ndev = devm_drm_dev_alloc(&pdev->dev, &my_npu_driver,
                              struct my_npu_device, drm);
    if (IS_ERR(ndev))
        return PTR_ERR(ndev);

    drm = &ndev->drm;
    pci_set_drvdata(pdev, ndev);

    /* HW 초기화: MMIO 매핑, IRQ 등록, 펌웨어 로딩 */
    ret = my_npu_hw_init(ndev);
    if (ret)
        return ret;

    /* drm_dev_register()가 내부적으로 accel_minor를 할당
     * → /dev/accel/accelN 생성 */
    ret = drm_dev_register(drm, 0);
    if (ret)
        goto err_hw;

    dev_info(&pdev->dev, "NPU registered as /dev/accel/accel%d\\n",
             drm->accel->index);
    return 0;

err_hw:
    my_npu_hw_fini(ndev);
    return ret;
}

GEM Buffer Object 관리

NPU 드라이버는 GEM을 사용해 가중치, 텐서, 커맨드 버퍼 등의 메모리를 관리합니다. 일반적으로 drm_gem_shmem_object 헬퍼를 확장하거나, 독자적인 GEM 오브젝트를 구현합니다.

/* NPU 전용 GEM 버퍼 오브젝트 */
struct my_npu_bo {
    struct drm_gem_shmem_object base;
    u64  npu_addr;             /* NPU 가상 주소 (디바이스 MMU 매핑) */

    enum {
        NPU_BO_INPUT     = 0,   /* 입력 텐서 */
        NPU_BO_OUTPUT    = 1,   /* 출력 텐서 */
        NPU_BO_WEIGHTS   = 2,   /* 모델 가중치 (읽기 전용) */
        NPU_BO_CMDQ      = 3,   /* 커맨드 큐 */
    } usage;

    bool shared;               /* DMA-BUF로 다른 디바이스와 공유 가능 */
};

/* GEM 생성 ioctl 핸들러 */
static int my_npu_gem_create_ioctl(struct drm_device *dev,
                                    void *data,
                                    struct drm_file *file)
{
    struct my_npu_create_bo *args = data;
    struct my_npu_bo *bo;
    int ret;

    args->size = ALIGN(args->size, SZ_4K);

    bo = my_npu_bo_alloc(dev, args->size, args->flags);
    if (IS_ERR(bo))
        return PTR_ERR(bo);

    /* NPU MMU에 매핑 → npu_addr 할당 */
    ret = my_npu_mmu_map(bo);
    if (ret)
        goto err_free;

    ret = drm_gem_handle_create(file, &bo->base.base, &args->handle);
    drm_gem_object_put(&bo->base.base);
    args->npu_addr = bo->npu_addr;
    return ret;

err_free:
    drm_gem_object_put(&bo->base.base);
    return ret;
}

컴퓨트 잡 제출 (Job Submission)

NPU 드라이버는 drm_sched(GPU 스케줄러)를 재사용하여 컴퓨트 잡을 관리합니다.

/* NPU 잡 구조체 — drm_sched_job을 임베드 */
struct my_npu_job {
    struct drm_sched_job  base;
    struct my_npu_bo     *cmd_bo;      /* 커맨드 버퍼 */
    struct my_npu_bo    **bos;         /* 입출력 버퍼 참조 */
    u32                  bo_count;
    struct dma_fence     *done_fence;  /* 완료 fence */
};

/* drm_sched 백엔드 콜백 */
static struct dma_fence *
my_npu_run_job(struct drm_sched_job *sched_job)
{
    struct my_npu_job *job =
        container_of(sched_job, struct my_npu_job, base);
    struct my_npu_device *ndev = job_to_ndev(job);

    /* 1. 커맨드 버퍼의 NPU 가상 주소를 HW 레지스터에 기록 */
    writel(lower_32_bits(job->cmd_bo->npu_addr),
           ndev->mmio + NPU_REG_CMD_ADDR_LO);
    writel(upper_32_bits(job->cmd_bo->npu_addr),
           ndev->mmio + NPU_REG_CMD_ADDR_HI);

    /* 2. 실행 트리거 — 펌웨어가 처리 시작 */
    writel(NPU_CMD_EXECUTE, ndev->mmio + NPU_REG_DOORBELL);

    /* 3. HW fence 반환 — IRQ 핸들러에서 시그널됨 */
    return dma_fence_get(job->done_fence);
}

static enum drm_gpu_sched_stat
my_npu_timedout_job(struct drm_sched_job *sched_job)
{
    struct my_npu_job *job =
        container_of(sched_job, struct my_npu_job, base);

    dev_err(job->dev, "NPU job timeout — resetting engine\\n");
    my_npu_engine_reset(job_to_ndev(job));

    return DRM_GPU_SCHED_STAT_NOMINAL;
}

static const struct drm_sched_backend_ops my_npu_sched_ops = {
    .run_job      = my_npu_run_job,
    .timedout_job = my_npu_timedout_job,
};

펌웨어 로딩

대부분의 NPU는 부팅 시 펌웨어를 로딩해야 합니다. 커널의 request_firmware() API를 사용하여 /lib/firmware/에서 NPU 펌웨어 바이너리를 로드합니다.

static int my_npu_load_firmware(struct my_npu_device *ndev)
{
    const struct firmware *fw;
    int ret;

    ret = request_firmware(&fw, "my_npu/fw.bin", ndev->dev);
    if (ret) {
        dev_err(ndev->dev, "firmware load failed: %d\\n", ret);
        return ret;
    }

    /* 펌웨어를 NPU의 내부 SRAM 또는 전용 메모리 영역에 복사 */
    memcpy_toio(ndev->fw_region, fw->data, fw->size);

    /* 부트 레지스터 — 펌웨어 실행 시작 */
    writel(NPU_FW_BOOT, ndev->mmio + NPU_REG_FW_CTRL);

    /* 부팅 완료 대기 (mailbox 통신) */
    ret = my_npu_wait_fw_ready(ndev, 5000);
    release_firmware(fw);
    return ret;
}

NPU MMU (디바이스 가상 메모리)

NPU는 자체 MMU(또는 IOMMU 연동)를 통해 디바이스 가상 주소 공간을 관리합니다. 이를 통해 연속적이지 않은 물리 페이지를 NPU에서 연속 주소로 접근할 수 있습니다.

struct my_npu_mmu {
    struct my_npu_device  *ndev;
    dma_addr_t            pgd_dma;    /* L1 페이지 디렉토리 */
    u64                  *pgd_cpu;    /* CPU 매핑 */
    struct drm_mm         va_space;   /* VA 할당 관리 */
    struct mutex          lock;
};

static int my_npu_mmu_map(struct my_npu_bo *bo)
{
    struct my_npu_mmu *mmu = &bo_to_ndev(bo)->mmu;
    struct drm_mm_node *node = &bo->mm_node;
    struct sg_table *sgt;
    int ret;

    mutex_lock(&mmu->lock);

    /* VA 공간에서 영역 할당 */
    ret = drm_mm_insert_node_generic(&mmu->va_space, node,
                                      bo->base.base.size,
                                      SZ_4K, 0, DRM_MM_INSERT_BEST);
    if (ret)
        goto out;

    bo->npu_addr = node->start;

    sgt = drm_gem_shmem_get_pages_sgt(&bo->base);
    if (IS_ERR(sgt)) {
        drm_mm_remove_node(node);
        ret = PTR_ERR(sgt);
        goto out;
    }

    my_npu_mmu_write_ptes(mmu, bo->npu_addr, sgt);
    my_npu_mmu_flush_tlb(mmu);

out:
    mutex_unlock(&mmu->lock);
    return ret;
}

주요 Linux NPU 드라이버

Intel NPU (IVPU) 드라이버 상세

Intel NPU(이전 명칭 VPU)는 Meteor Lake부터 Intel 클라이언트 프로세서에 통합된 AI 추론 가속기입니다. drivers/accel/ivpu/에 위치하며, DRM Accel 프레임워크를 사용하는 대표적인 드라이버입니다.

Intel NPU ioctl 인터페이스

AMD XDNA (Ryzen AI) 드라이버

AMD Ryzen AI 프로세서(Phoenix, Hawk Point, Strix Point)에 통합된 XDNA NPU입니다. FPGA 기반 AI Engine 타일로 구성되며, 각 타일은 VLIW 프로세서 + 벡터 유닛을 포함합니다.

Intel Gaudi (habanalabs) 드라이버

데이터센터급 AI 학습/추론 가속기인 Intel Gaudi 시리즈를 지원합니다. DRM Accel 프레임워크 도입 이전부터 존재하며, 6.2에서 drivers/accel/로 이동했습니다.

/* habanalabs 드라이버 핵심 구조 (간략화) */
struct hl_device {
    struct drm_device      drm;
    const struct hl_asic_funcs *asic_funcs;  /* ASIC별 함수 포인터 */
    struct hl_cs_counters_atomic  cs_cnt;    /* 커맨드 서브미션 */
    struct hl_vm            vm;              /* 메모리 관리 */
    struct hl_nic          *nic;             /* 멀티 디바이스 통신 */
    struct hwmon_ops       *hwmon;           /* 전원/열 관리 */
};

/* hl_asic_funcs: ASIC 추상화 인터페이스 */
struct hl_asic_funcs {
    int  (*hw_init)(struct hl_device *hdev);
    void (*hw_fini)(struct hl_device *hdev, bool hard);
    int  (*suspend)(struct hl_device *hdev);
    int  (*resume)(struct hl_device *hdev);
    int  (*cb_mmap)(struct hl_device *hdev,
                    struct vm_area_struct *vma);
    void (*ring_doorbell)(struct hl_device *hdev,
                          u32 hw_queue_id, u32 pi);
    /* ... 50+ 함수 포인터 ... */
};

Qualcomm QNN / HTP (Hexagon Tensor Processor)

Qualcomm은 Snapdragon SoC에 DSP 기반 AI 가속기를 통합해 왔습니다. 초기 Hexagon DSP에서 시작해, 현재는 HTP(Hexagon Tensor Processor)라는 독립적인 AI 코어로 진화했습니다. Snapdragon 8 Gen 3, Snapdragon X Elite 등 최신 칩에는 전용 NPU 클러스터가 탑재됩니다.

HTP 아키텍처와 진화

FastRPC 커널 드라이버

Qualcomm DSP/HTP는 FastRPC 메커니즘으로 유저 공간과 통신합니다. FastRPC는 CPU↔DSP 간 함수 호출을 원격 프로시저 콜(RPC) 형태로 처리하며, 커널 드라이버 drivers/misc/fastrpc.c가 이를 중재합니다.

# FastRPC 관련 디바이스 노드
ls /dev/fastrpc-*
# /dev/fastrpc-cdsp   → Compute DSP (AI 추론)
# /dev/fastrpc-adsp   → Audio DSP
# /dev/fastrpc-mdsp   → Modem DSP

# remoteproc를 통한 DSP 펌웨어 상태 확인
cat /sys/bus/platform/drivers/qcom-q6v5-pas/*/state

/* FastRPC 커널 핵심 구조 (drivers/misc/fastrpc.c) */
struct fastrpc_channel_ctx {
    char                  *name;       /* "cdsp", "adsp" 등 */
    struct rpmsg_device   *rpdev;      /* rpmsg 채널 */
    struct fastrpc_apps   *apps;
    spinlock_t             lock;
    struct idr             ctx_idr;    /* 컨텍스트 ID 관리 */
    u32                    dsp_cap_idx;
};

struct fastrpc_invoke_ctx {
    int                    nscalars;   /* 인자 수 */
    struct fastrpc_map   **maps;       /* DMA buf 매핑 */
    dma_addr_t             buf;        /* 인자 버퍼 */
    struct completion      work;       /* 완료 대기 */
    int                    retval;     /* DSP 반환값 */
};

/* RPC 흐름:
 * 1. 유저 공간 → ioctl(FASTRPC_IOCTL_INVOKE)
 * 2. 커널: DMA 버퍼 고정(pin) + IOMMU 매핑
 * 3. rpmsg로 DSP에 invoke 메시지 전송
 * 4. DSP가 HTP에서 연산 실행
 * 5. 완료 인터럽트 → completion 시그널
 * 6. 유저 공간 복귀
 */

QNN SDK와 양자화

QNN(Qualcomm Neural Network) SDK는 ONNX/TFLite 모델을 HTP에서 실행 가능한 형태로 변환하고, INT4/INT8 양자화를 통해 추론 속도를 극대화합니다.

# ONNX 모델 → QNN 변환 (오프라인 컴파일)
qnn-onnx-converter \
  --input_network mobilenet_v3.onnx \
  --output_path   mobilenet_v3.cpp \
  --input_dim     input "1,3,224,224"

# QNN 모델 → HTP 바이너리 (.serialized)
qnn-model-lib-generator \
  -m mobilenet_v3.cpp \
  -b libQnnHtp.so \
  --output_dir ./output/

# 추론 성능 측정 (TOPS, 지연 시간)
qnn-net-run \
  --model        output/mobilenet_v3.serialized \
  --backend      libQnnHtp.so \
  --input_list   input_list.txt \
  --duration     10

Huawei Ascend / CANN AI 플랫폼

Huawei Ascend는 대규모 AI 훈련(910 시리즈)과 에지 추론(310 시리즈)을 위해 설계된 자체 AI 칩 시리즈입니다. 핵심 연산 유닛인 DaVinci Core는 행렬 곱셈을 3D 큐브 방식으로 처리하여 고효율 AI 연산을 구현합니다.

Ascend 아키텍처: DaVinci Core

CANN 런타임 구조

CANN(Compute Architecture for Neural Networks)은 Ascend 칩을 위한 소프트웨어 스택입니다. PyTorch/TensorFlow와 Ascend 하드웨어 사이를 중재하며, 커널 드라이버와 런타임 라이브러리로 구성됩니다.

# Atlas 800T A2 서버에서의 디바이스 확인
npu-smi info                          # NPU 상태 (nvidia-smi 유사)
npu-smi info -t usages -i 0          # 칩 0번 사용률
ls /dev/davinci*                      # DaVinci 디바이스 노드
# /dev/davinci0 ~ /dev/davinci7
# /dev/davinci_manager

# PyTorch + torch_npu 사용 예제
import torch
import torch_npu                        # Ascend 백엔드 플러그인

# NPU 디바이스 지정
device = torch.device("npu:0")          # Ascend 910B 0번 칩
model  = MyModel().to(device)
x      = torch.randn(1, 3, 224, 224).to(device)

# AscendCL 내부 처리:
# 1. PyTorch Op → GE 그래프로 변환
# 2. 그래프 컴파일 → DaVinci ISA
# 3. /dev/davinci0 ioctl로 커널 드라이버 전달
# 4. DaVinci Core에서 3D Cube 연산 실행
output = model(x)

커널 드라이버 현황

# Atlas 200I DK (개발 키트)에서의 추론 예제
# .om 파일 = Ascend 오프라인 모델 (atc 컴파일러 출력)

# 1. ONNX → Ascend .om 변환
atc --model=resnet50.onnx \
    --framework=5 \
    --output=resnet50 \
    --input_shape="input:1,3,224,224" \
    --soc_version=Ascend310P3

# 2. .om 모델 추론 실행
python3 acl_run.py --model resnet50.om

# 커널 DMA 흐름:
# CPU 메모리 → DMA → HBM2e (가중치/입력)
# DaVinci Core 연산 → HBM2e (출력)
# DMA → CPU 메모리 (결과 수집)

NPU 전원 관리

NPU는 항상 활성 상태일 필요가 없으므로, Runtime PM을 통한 공격적인 전원 관리가 중요합니다. 특히 노트북/모바일 SoC에서는 추론이 없을 때 NPU를 완전히 꺼서 전력을 절약합니다.

static int my_npu_runtime_suspend(struct device *dev)
{
    struct my_npu_device *ndev = dev_get_drvdata(dev);

    my_npu_wait_idle(ndev);               /* 잡 완료 대기 */
    my_npu_mmu_save_state(ndev);           /* MMU 컨텍스트 저장 */
    clk_disable_unprepare(ndev->clk);     /* 클럭 게이팅 */
    my_npu_power_off(ndev);                /* 전원 도메인 OFF */
    return 0;
}

static int my_npu_runtime_resume(struct device *dev)
{
    struct my_npu_device *ndev = dev_get_drvdata(dev);
    int ret;

    my_npu_power_on(ndev);                 /* 전원 ON */
    clk_prepare_enable(ndev->clk);         /* 클럭 활성화 */

    ret = my_npu_load_firmware(ndev);       /* FW 재로딩 */
    if (ret)
        return ret;

    my_npu_mmu_restore_state(ndev);        /* MMU 복원 */
    return 0;
}

static const struct dev_pm_ops my_npu_pm_ops = {
    SET_RUNTIME_PM_OPS(my_npu_runtime_suspend,
                       my_npu_runtime_resume, NULL)
    SET_SYSTEM_SLEEP_PM_OPS(my_npu_system_suspend,
                            my_npu_system_resume)
};

NPU와 DMA-BUF: 디바이스 간 버퍼 공유

DMA-BUF를 통해 NPU, GPU, 카메라(ISP), 비디오 디코더 간에 제로카피 버퍼 공유가 가능합니다. 이는 카메라 → NPU → GPU → 디스플레이 같은 ML 파이프라인에서 중요한 역할을 합니다.

/* NPU에서 DMA-BUF 익스포트 (exporter 역할) */
static struct dma_buf *
my_npu_gem_prime_export(struct drm_gem_object *obj, int flags)
{
    struct dma_buf_export_info exp_info = {
        .exp_name  = "my_npu",
        .owner     = obj->dev->driver->fops->owner,
        .ops       = &my_npu_dmabuf_ops,
        .size      = obj->size,
        .flags     = flags,
        .priv      = obj,
    };
    return drm_gem_dmabuf_export(obj->dev, &exp_info);
}

/* GPU에서 NPU의 DMA-BUF를 임포트 (importer 역할) */
struct drm_gem_object *
gpu_gem_prime_import(struct drm_device *dev,
                     struct dma_buf *dma_buf)
{
    struct dma_buf_attachment *attach;
    struct sg_table *sgt;

    attach = dma_buf_attach(dma_buf, dev->dev);
    if (IS_ERR(attach))
        return ERR_CAST(attach);

    sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
    if (IS_ERR(sgt)) {
        dma_buf_detach(dma_buf, attach);
        return ERR_CAST(sgt);
    }

    /* sg_table을 GPU 페이지 테이블에 매핑
     * → NPU가 쓴 결과를 GPU가 직접 읽기 가능 */
    return gpu_create_gem_from_sgt(dev, sgt, dma_buf->size);
}

NPU 커널 설정 (Kconfig)

# DRM Accel 기본 지원
CONFIG_DRM=m                       # DRM 코어 (필수)
CONFIG_DRM_ACCEL=y                 # Accel 서브시스템 활성화

# Intel NPU (IVPU)
CONFIG_DRM_ACCEL_IVPU=m            # Intel VPU/NPU 드라이버

# Intel Gaudi (habanalabs)
CONFIG_DRM_ACCEL_HABANALABS=m      # Gaudi/Gaudi2/Gaudi3

# AMD XDNA (Ryzen AI)
CONFIG_DRM_ACCEL_AMDXDNA=m         # AMD XDNA NPU

# Qualcomm Cloud AI
CONFIG_DRM_ACCEL_QAIC=m            # Qualcomm AIC100

# 공통 의존성
CONFIG_DRM_GEM_SHMEM_HELPER=m      # GEM shmem 헬퍼
CONFIG_DRM_SCHED=m                 # GPU/NPU 스케줄러
CONFIG_DMA_SHARED_BUFFER=y         # DMA-BUF (디바이스 간 공유)
CONFIG_FW_LOADER=y                 # 펌웨어 로더 (필수)
CONFIG_IOMMU_API=y                 # IOMMU 지원

NPU 디버깅

sysfs / debugfs 인터페이스

# Accel 디바이스 확인
ls -la /dev/accel/
ls -la /sys/class/accel/

# Intel NPU debugfs
cat /sys/kernel/debug/accel/0/info
cat /sys/kernel/debug/accel/0/fw_version
cat /sys/kernel/debug/accel/0/busy_time_us
cat /sys/kernel/debug/accel/0/freq

# Runtime PM 상태 확인
cat /sys/class/accel/accel0/device/power/runtime_status

# HW 센서 (hwmon)
cat /sys/class/accel/accel0/device/hwmon/*/temp1_input
cat /sys/class/accel/accel0/device/hwmon/*/power1_input

# AMD XDNA sysfs
cat /sys/class/accel/accel0/device/npu_clk_freq
cat /sys/class/accel/accel0/device/npu_power_state

NPU 디버깅 도구

NPU 유저 공간 소프트웨어 스택

NPU 드라이버는 커널에서 HW 접근과 메모리 관리만 담당하고, 실제 ML 모델 컴파일/실행은 유저 공간 스택이 처리합니다.

# 1. 모델 벤치마크
benchmark_app -m model.onnx -d NPU -hint latency

# 2. Python API로 추론
import openvino as ov

core = ov.Core()
model = core.compile_model("model.onnx", "NPU")
result = model.infer_new_request({"input": input_data})

참고 사항

관련 문서

이 주제와 관련된 다른 문서를 더 깊이 이해하고 싶다면 다음을 참고하세요.

• GPU & DRM — 그래픽 드라이버 서브시스템
• DMA Engine — DMA 전송 프레임워크
• 전원 관리 — 디바이스 전력 제어