다중 큐 SSD NVMe 프로토콜의 장점 (Multi-Queue SSD & NVMe)

핵심 인사이트 (3줄 요약)

본질: NVMe (Non-Volatile Memory Express)는 과거 뱅글뱅글 도는 하드디스크(HDD) 시절에 만들어진 좁고 느린 AHCI/SATA 통신 규격을 버리고, 빛처럼 빠른 플래시 메모리(SSD)를 PCIe 버스에 직접 직결하여 초고속으로 대화하기 위해 백지부터 새로 설계한 스토리지 프로토콜이다.

가치: 기존에 딱 1개(단일 큐)밖에 없던 대기줄을 **64,000개의 거대한 다중 큐(Multi-Queue)**로 쪼개고 각 큐마다 64,000개의 명령을 구겨 넣게 함으로써, 수십 개의 CPU 코어가 락(Lock) 경합 없이 동시에 디스크 I/O를 쏟아낼 수 있는 미친 병렬성(Parallelism)을 완성했다.

융합: 하드웨어의 발전(PCIe)과 운영체제 커널의 블록 I/O 스택 개조(Linux Multi-Queue Block Layer, blk-mq), 그리고 락-프리(Lock-free) 폴링 기술이 융합되어 수백만 IOPS라는 기적적인 스루풋을 달성해 클라우드 데이터센터의 표준이 되었다.

Ⅰ. 개요 및 필요성 (Context & Necessity)

개념:
- NVMe는 저장장치를 메인보드의 PCIe(PCI Express) 슬롯에 직결하여 CPU와 최단 거리로 통신하는 논리적 디바이스 인터페이스 규격이다.
- 핵심 구조는 한 번에 하나의 명령만 줄 서던 낡은 병목(AHCI)을 깨고, 수많은 스레드가 각자의 전용 차선(Submission Queue & Completion Queue)을 가지고 비동기적으로 I/O를 던지는 다중 큐(Multi-Queue) 구조다.
필요성(문제의식):
- 2010년대 SSD 내부에 낸드(NAND) 칩이 8개, 16개씩 달리면서 하드웨어 자체는 한 번에 16개의 일을 처리할 수 있는 괴물이 되었다.
- 그런데 이 괴물을 과거 HDD용으로 만든 SATA 케이블(AHCI 프로토콜)에 연결하니 문제가 터졌다. AHCI는 대기줄(Queue)이 1개뿐이고, 명령어도 최대 32개밖에 담지 못했다.
- 16코어 CPU에서 스레드 16개가 동시에 파일을 읽으려 하면, 1개뿐인 큐에 명령을 넣기 위해 서로 스핀락(Lock)을 걸고 치고박고 싸우느라(병목 현상) SSD는 놀고 CPU만 터져나갔다.
- 해결책: "SSD가 엄청 빠르니까, 아예 CPU 코어마다 전용 톨게이트(Queue)를 하나씩 깔아주자! 락(Lock) 걸 필요 없이 각자 자기 톨게이트에 무한정 던지게 만들자!"
💡 비유:
- SATA/AHCI (단일 큐): 차선이 16개(초고속 SSD 칩)나 뚫려있는 거대한 고속도로인데, 진입하는 요금소(Queue)가 딱 1개밖에 없어서 자동차(CPU 스레드)들이 톨게이트 앞에서 1시간씩 줄을 서서 빵빵거리는 상황.
- NVMe (다중 큐): 고속도로 입구에 요금소를 64,000개(다중 큐) 지어버렸다. 차들은 줄 서거나 눈치 볼 필요 없이 뻥 뚫린 자기 전용 톨게이트를 1초 만에 하이패스로 통과해 고속도로를 질주한다.
등장 배경:
- 엔터프라이즈 환경에서 SSD 성능이 10만 IOPS를 넘어가자, 통신 규격(Overhead)이 하드웨어의 발목을 잡는 'Tail chasing' 역전 현상이 일어났다. 이에 인텔, 삼성, 샌디스크 등 90여 개 기업이 모여 2011년 NVMe 1.0 컨소시엄을 출범시켰다.

  ┌─────────────────────────────────────────────────────────────┐
  │                 AHCI (단일 큐) vs NVMe (다중 큐) 병목 구조 비교       │
  ├─────────────────────────────────────────────────────────────┤
  │                                                             │
  │  [ 레거시 SATA / AHCI 구조 ] - 병목 지옥                       │
  │   Core 0 ─▶ (Lock 대기) ─┐                                 │
  │   Core 1 ─▶ (Lock 대기) ─┼─▶ 톨게이트 1개 (Max 32개) ──▶ [SSD]  │
  │   Core 2 ─▶ 큐 점유 중!  ─┘                                 │
  │   ※ 코어가 늘어날수록 톨게이트 앞에 줄을 서야 해서 성능이 수직 하락함.    │
  │                                                             │
  │  [ 모던 PCIe / NVMe 구조 ] - 하이패스 병렬 처리                 │
  │   Core 0 ──▶ 전용 Queue 0 (Max 64K개 명령) ────┐             │
  │   Core 1 ──▶ 전용 Queue 1 (Max 64K개 명령) ────┼──▶ [SSD]  │
  │   Core 2 ──▶ 전용 Queue 2 (Max 64K개 명령) ────┘             │
  │   ※ 코어마다 자기만의 큐를 가지므로 Lock 경합 0%. 스케일 아웃 무한정!    │
  └─────────────────────────────────────────────────────────────┘

[다이어그램 해설] 이 구조적 차이가 수십 배의 성능 격차를 만들어낸다. AHCI 환경에서는 여러 응용 프로그램이 동시에 디스크 I/O를 유발하면, 운영체제 커널의 블록 레이어(Block Layer)에서 글로벌 락(Global Lock)이 걸려버려 CPU 스레드들이 줄줄이 수면(Sleep) 상태로 뻗어버렸다. 반면 NVMe는 메인 메모리(RAM)에 큐(Ring Buffer)를 수만 개 만들어 둔다. 리눅스 커널은 CPU 코어 개수만큼 큐를 매핑시켜(Multi-Queue), 코어 0번은 큐 0번에만, 코어 1번은 큐 1번에만 락-프리(Lock-free)로 I/O 요청을 쑤셔 넣는다. 뒷단의 SSD 컨트롤러가 이 수만 개의 큐를 맹렬히 순회하며 데이터를 쓸어가는 진정한 의미의 '독립 병렬 고속도로'가 개통된 것이다.

📢 섹션 요약 비유: 은행 창구가 1개뿐일 때는 번호표를 뽑고 한참 기다려야 했지만(AHCI), 은행원이 6만 4천 명으로 늘어나서 손님이 문을 열고 들어가자마자 곧바로 자기 전담 은행원에게 서류를 던지고 나올 수 있게 된(NVMe) 혁명적 고객 응대 시스템입니다.

Ⅱ. 아키텍처 및 핵심 원리 (Deep Dive)

NVMe의 SQ (Submission Queue)와 CQ (Completion Queue)

NVMe 프로토콜은 데이터를 주고받는 방식 자체를 극도로 얇고 가볍게 덜어냈다. 핵심은 한 쌍의 큐(Ring Buffer)를 통한 완벽한 비동기 통신이다.

명령 제출 (SQ, Submission Queue): CPU(호스트)는 "A 주소의 데이터를 B로 읽어와"라는 64바이트짜리 명령서를 메모리 상의 SQ에 밀어 넣는다. 그리고 SSD에게 초인종(Doorbell Register)을 한 번 띡 누르고 자기 할 일을 하러 돌아간다.
SSD의 처리 (DMA): SSD 컨트롤러는 초인종 소리를 듣고, 메모리의 SQ에서 명령서를 가져가 해석한 뒤, 실제 데이터를 PCIe 버스를 통해 메모리로 다이렉트로 쏴준다(DMA).
완료 통보 (CQ, Completion Queue): 데이터 전송이 끝나면 SSD는 메모리 상의 CQ에 "명령어 1번 완료됨"이라는 영수증을 쓴다. 그리고 CPU에게 인터럽트(MSI-X)를 쏴서 "다 됐으니 영수증 확인해"라고 알려준다. CPU는 CQ 영수증만 보고 앱을 깨워준다.

리눅스 커널 블록 레이어의 대개조 (blk-mq)

아무리 NVMe 하드웨어가 다중 큐를 지원해도, OS 커널이 예전 방식대로 줄을 한 줄로 세우면 말짱 도루묵이다. 리눅스는 커널 3.13부터 NVMe의 성능을 100% 뽑기 위해 **멀티 큐 블록 I/O 레이어(blk-mq)**라는 거대한 아키텍처 개조를 단행했다.

  ┌───────────────────────────────────────────────────────────────────┐
  │                 Linux blk-mq (Multi-Queue) 아키텍처 맵핑 흐름       │
  ├───────────────────────────────────────────────────────────────────┤
  │                                                                   │
  │   [ 사용자 애플리케이션 스레드 (User Space) ]                        │
  │     Thread 1 (Core 0)      Thread 2 (Core 1)      Thread 3 (Core 2) │
  │        │                      │                      │            │
  │  ======│======================│======================│=========== │
  │        ▼                      ▼                      ▼            │
  │   [ Software Staging Queues (소프트웨어 큐) ] - 코어마다 1개씩 존재      │
  │     ┌─────────┐            ┌─────────┐            ┌─────────┐     │
  │     │ SW 큐 0 │            │ SW 큐 1 │            │ SW 큐 2 │     │
  │     └────┬────┘            └────┬────┘            └────┬────┘     │
  │          │ (I/O 병합 및 스케줄링)│                      │            │
  │          └─────────┬──────────┘                      │            │
  │                    ▼                                ▼            │
  │   [ Hardware Dispatch Queues (하드웨어 큐 = NVMe SQ) ]              │
  │           ┌─────────────────┐             ┌─────────────────┐     │
  │           │  HW Queue 0     │             │  HW Queue 1     │     │
  │           │ (NVMe 컨트롤러 연결)│             │ (NVMe 컨트롤러 연결)│     │
  │           └─────────┬───────┘             └─────────┬───────┘     │
  │                     │                               │             │
  │  ===================│===============================│============ │
  │                     ▼                               ▼             │
  │   [ 물리적 장치 (NVMe SSD 하드웨어 컨트롤러) ]                         │
  └───────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 이 아키텍처의 핵심은 "락 프리(Lock-free)"에 있다. 리눅스는 CPU 코어마다 독립적인 Software Queue를 달아주어, 앱 스레드들이 큐에 데이터를 넣을 때 다른 코어 눈치를 보지 않게(락 경합 배제) 만들었다. 그리고 이 소프트웨어 큐들을 NVMe 컨트롤러가 지원하는 실제 Hardware Queue의 개수에 맞춰 1:1 또는 N:1로 스마트하게 매핑(Mapping)해 준다. 이 2계층 큐 구조 덕분에 백만 IOPS의 미친 데이터 폭우 속에서도 커널의 CPU 소모율은 극단적으로 낮게 유지된다.

📢 섹션 요약 비유: 수만 개의 택배를 보낼 때, 중앙 집중하치장 한 곳(단일 큐)에 모든 택배 기사(코어)가 몰려들어 싸우는 걸 막기 위해, 동네마다 지역 우체국(SW 큐)을 수백 개 만들고 바로 직통 트럭(HW 큐)으로 쏴버려 물류 체증을 원천적으로 삭제한 거대한 고속 물류망입니다.

Ⅲ. 융합 비교 및 다각도 분석

AHCI (SATA) vs NVMe (PCIe) 기술 스펙의 잔혹한 차이

NVMe는 조금 빠른 기술이 아니라, 스토리지 패러다임 자체를 갈아엎은 혁명이다.

비교 항목	AHCI (SATA/SAS SSD)	NVMe (PCIe SSD)	압도적 차이점
큐(Queue) 개수	단 1개	최대 64,000개	다중 스레드 병목 현상 완벽히 해소
큐당 뎁스(Depth)	32개	최대 64,000개	엄청난 깊이로 디스크 병렬 쓰기 스루풋 극대화
인터럽트 방식	고전적 IRQ, 핀 인터럽트	MSI-X 기반 2048개 스티어링	수천 개의 큐 완료 응답을 각 CPU 코어에 분산 타격 가능
통신 오버헤드	레지스터 1번 읽는 데 CPU 4번 개입	CPU 명령 1번에 바로 전송	4KB I/O 시 필요한 커널 명령어(클럭) 절반 이하로 감소
물리적 레이턴시	~100 µs 이상	10~20 µs 미만	플래시 낸드의 한계 속도를 거의 그대로 하드웨어에 노출

과목 융합 관점

운영체제 시스템 콜 (io_uring): NVMe의 하드웨어 다중 큐가 워낙 빠르다 보니, 유저 앱이 read/write 시스템 콜을 부르며 커널로 진입하는 문맥 교환 시간조차 병목(Overhead)이 되었다. 이 NVMe의 SQ/CQ 링 버퍼 철학을 OS의 유저 공간으로 그대로 끌고 올라온 것이 리눅스의 io_uring이다. 결국 하드웨어의 초고속 아키텍처 사상이 OS 시스템 콜의 진화를 강제한 가장 아름다운 융합 사례다.
분산 시스템 (NVMe-oF): 로컬 메인보드에 꽂힌 PCIe 버스의 한계를 넘어, 이더넷(RoCE)이나 인피니밴드 네트워크 케이블 너머에 있는 원격 스토리지를 내 로컬 NVMe 큐처럼 직접 통신하게 해주는 NVMe over Fabrics (NVMe-oF) 기술이 클라우드 블록 스토리지(EBS)의 지형을 통합하고 있다.
📢 섹션 요약 비유: 낡은 모뎀 전화선(SATA)을 걷어내고 초고속 광랜(NVMe)을 깐 격입니다. 옛날엔 차 한 대(1개 큐)에 32명만 태우고 시골길을 달렸다면, 지금은 6만 4천 대의 KTX에 각각 6만 4천 명을 태우고 서울-부산 직통 고속철(PCIe)을 미친 듯이 쏘아 보내는 인류의 스토리지 정복기입니다.

Ⅳ. 실무 적용 및 기술사적 판단

실무 시나리오 및 트러블슈팅

시나리오 — AWS 고성능 DB(io2 볼륨)의 CPU 편중 현상: AWS EC2에 최고 비싼 NVMe 볼륨을 달고 초당 20만 IOPS를 때리는 데이터베이스를 돌리는데, CPU 코어 0번만 사용률이 100%가 되고 나머지 코어는 놀면서 DB에 렉이 걸린다.
- 원인 분석: NVMe가 다중 큐를 열어놔도, OS가 그 수만 개의 큐에서 쏟아지는 완료 인터럽트(MSI-X)를 멍청하게 CPU 0번 하나에만 몰아주게(Default Routing) 세팅되어 있으면 0번 코어 혼자 인터럽트 폭풍에 맞아 질식사(Interrupt Storm)한다.
- 아키텍트 판단 (IRQ Affinity 및 Polling 모드 전환): irqbalance 데몬을 활성화하거나 스크립트를 짜서 NVMe 큐의 하드웨어 인터럽트를 코어 수만큼 정확히 1:1로 분산 맵핑(SMP Affinity)해야 한다. 더 극한의 환경이라면 인터럽트 자체를 꺼버리고 커널이 직접 NVMe 하드웨어 큐를 무한 확인하는 **IO Polling 모드(echo 1 > /sys/block/nvme0n1/queue/io_poll)**로 전환하여 컨텍스트 스위칭 지연을 0초로 만들어야 지연 시간(Latency) 스파이크를 잡을 수 있다.
시나리오 — 구형 커널(CentOS 6)에 최신 NVMe 장착 시 성능 반토막: 구형 레거시 서버에 PCIe 어댑터를 달아 NVMe SSD를 달았는데, 벤치마크 속도가 스펙의 30%밖에 안 나온다.
- 원인 분석: 구형 리눅스 2.6 커널은 NVMe라는 짐승을 다룰 blk-mq(멀티 큐 블록 레이어) 아키텍처 자체가 없다. 결국 수많은 코어가 단 하나의 구형 싱글 큐(Single Queue) 모듈 락을 잡기 위해 피 터지게 싸우며 CPU 자원을 갉아먹는다.
- 아키텍트 판단 (OS 업그레이드 및 커널 바이패스): 하드웨어가 아무리 좋아도 OS가 옛날 것이면 병목이다. 커널 3.13 이상(안전하게 4.x 이상) 최신 OS로 즉시 마이그레이션 해야 한다. 만약 레거시 OS를 도저히 바꿀 수 없다면, SPDK (Storage Performance Development Kit) 같은 커널 바이패스 툴을 써서 앱이 커널을 무시하고 NVMe 레지스터에 유저 스페이스에서 직접 다이렉트 통신을 갈겨버리는 우회 아키텍처를 세워야 한다.

  ┌───────────────────────────────────────────────────────────────────┐
  │                 극초저지연(Ultra-low Latency) I/O 아키텍트 선택 트리      │
  ├───────────────────────────────────────────────────────────────────┤
  │                                                                   │
  │   [ 밀리초(ms) 단위가 아닌 마이크로초(µs) 보장 시스템을 구축한다 ]          │
  │                │                                                  │
  │                ▼                                                  │
  │      인터럽트 처리로 인한 CPU 문맥 교환 오버헤드(5~10µs) 조차 아까운가?      │
  │          ├─ 예 ─────▶ [ NVMe I/O Polling 활성화 ]                  │
  │          │             (인터럽트 끄고 CPU가 100% 루프 돌며 장치 확인. 극강 속도)│
  │          └─ 아니오 (일반적인 웹/DB 서버 환경)                          │
  │                │                                                  │
  │                ▼                                                  │
  │      운영체제의 시스템 콜과 파일 시스템(VFS) 오버헤드마저 없애고 싶은가?        │
  │          ├─ 예 ─────▶ [ SPDK (Storage Performance Dev Kit) 도입 ] │
  │          │             (커널 바이패스! DB가 NVMe 하드웨어를 직접 제어함!)    │
  │          │                                                        │
  │          └─ 아니오 ──▶ [ 최신 커널의 `io_uring` + `blk-mq` 조합 채택 ]  │
  │                        (기본 NVMe 환경의 가장 우아하고 강력한 성능 표준)      │
  └───────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 클라우드 엔지니어나 하드코어 DB 아키텍트는 "장비만 꽂으면 다 빠른 줄 아는" 편견과 싸워야 한다. NVMe 자체 지연 시간이 10µs인데, 리눅스 커널 스택을 타고 내려가는 소프트웨어 시간이 15µs다. 배보다 배꼽이 더 커진 시대다. 이 벽을 부수기 위해 인텔과 커널 해커들이 내놓은 답은 "방해되는 중간 관리자(커널, 인터럽트)를 모조리 치워버리고, 앱과 NVMe 칩을 다이렉트로 연결(SPDK, Polling)해 버려라"는 극단적 탈중앙화다.

안티패턴

구형 I/O 스케줄러(CFQ, Deadline) 설정 방치: 하드디스크 시절에는 헤드가 이리저리 튀는 걸 막으려고 커널이 엘리베이터 알고리즘(CFQ, Completely Fair Queuing)을 돌려 I/O 순서를 예쁘게 정렬해 줬다. NVMe에 대고 이 짓거리를 하면 대참사가 난다. NVMe 낸드 칩은 순서고 뭐고 들어오는 대로 번개처럼 병렬로 써버리는 게 제일 빠르기 때문이다. 최신 커널은 다중 큐 블록에선 none이나 mq-deadline 같은 초경량 스케줄러로 자동으로 바꾸지만, 구형 시스템 튜닝을 한답시고 강제로 CFQ를 세팅해 놓으면 컨트롤러의 병렬성을 스스로 봉인해 버리는 바보가 된다.
📢 섹션 요약 비유: 미슐랭 3스타 셰프(NVMe) 6만 명을 주방에 고용해 놓고, 매니저(CFQ 스케줄러) 1명이 문 앞에서 "너네 요리하기 전에 주문서 가나다순으로 다 정리하고 요리해!"라고 꼰대 짓을 하며 막아서서 식당 회전율을 개판으로 만드는 답답한 튜닝의 전형입니다.

Ⅴ. 기대효과 및 결론

정량/정성 기대효과

구분	AHCI/SATA 프로토콜 SSD	NVMe 다중 큐 프로토콜 SSD	개선 효과
정량 (I/O 스루풋/IOPS)	최대 10만 IOPS 병목 한계	100만 ~ 수백만 IOPS 돌파	초대형 DB 및 빅데이터 분석 처리의 물리적 한계 해방
정량 (컨텍스트 오버헤드)	싱글 락(Lock) 경합으로 CPU 점유율 폭증	Lock-Free 다중 큐로 CPU 오버헤드 0 수렴	남는 CPU 연산력을 애플리케이션 비즈니스 로직에 100% 집중
정성 (확장성)	코어 수가 늘수록 큐 병목으로 성능 저하	코어 수만큼 큐가 늘어나 선형적(Linear) 성능 확장	128코어, 256코어 매니코어 서버 하드웨어 투자 효율 극대화

미래 전망

NVMe over Fabrics (NVMe-oF)의 세계 제패: 내 메인보드에 꽂힌 64,000개의 대기줄(Queue)이, 이제는 100Gbps 이더넷(RDMA) 케이블을 타고 네트워크 너머의 수천 대 스토리지 랙으로 확장된다. 서버를 열어 SSD를 꽂을 필요 없이, 클라우드 스토리지 어레이를 마치 로컬 PCIe 슬롯에 꽂은 것과 동일한 마이크로초 지연 시간으로 끌어다 쓰는 초거대 스토리지 분산화(Disaggregation)의 시대가 열렸다.
ZNS (Zoned Namespace) NVMe: 차세대 NVMe 규격이다. 그동안 SSD 수명을 깎아먹고 성능을 널뛰기하게 만들었던 FTL 컨트롤러의 웨어 레벨링 짐을 호스트(OS) 커널에게 아예 넘겨버린다. OS가 영역(Zone)을 관리하여 데이터가 연속적으로만 예쁘게 쓰이게 강제함으로써 쓰기 증폭(WA) 오버헤드를 아예 없애버리고 지연 시간을 얼음처럼 평온하게 고정시키는 엔터프라이즈 궁극의 폼팩터다.

참고 표준

NVM Express Base Specification: NVM Express.org 컨소시엄에서 큐 구조, 명령어 세트, 관리 인터페이스를 엄격하게 정의한 개방형 산업 스펙.
PCI Express (PCIe): SATA 병목을 버리고 SSD가 메인보드 CPU 직결 고속도로를 달릴 수 있도록 기판을 제공하는 PCI-SIG의 시리얼 버스 통신 표준.

다중 큐 SSD NVMe 프로토콜은 "빠른 짐꾼(NAND)이 백 명인데, 문(Interface)이 하나뿐이라 짐꾼 99명이 놀고 있는 코미디"를 끝내기 위해 문을 6만 개나 뚫어버린 하드웨어 공학의 호탕한 물량 공세다. 이 무식하지만 위대한 하드웨어 다차선 인터페이스는 결국 운영체제 커널의 심장인 블록 레이어(blk-mq)를 완벽히 뜯어고치게 만들었고, 더 나아가 시스템 콜의 모양(io_uring)까지 갈아엎게 만들었다. 꼬리가 개를 흔들듯, 하드웨어 저장 장치의 속도 혁명이 소프트웨어 운영체제의 진화 방향을 거꾸로 멱살 잡고 캐리한 컴퓨터 역사상 가장 짜릿한 패러다임 시프트다.

📢 섹션 요약 비유: 수백만 톤의 폭포수(NAND 데이터)가 떨어지는데, 가느다란 정수기 호스(SATA)를 연결해 놓고 왜 물이 찔끔 나오냐고 불평하던 시대는 끝났습니다. 폭포수 사이즈에 맞춰 거대한 후버 댐 수문 6만 개(NVMe 다중 큐)를 활짝 열어젖힌 것이 바로 빅데이터 시대 인프라의 완성입니다.

📌 관련 개념 맵 (Knowledge Graph)

개념 명칭	관계 및 시너지 설명
락-프리 (Lock-free)	코어마다 전용 큐가 있으므로 뮤텍스(Mutex) 락을 걸고 남을 기다릴 필요 없이 독자적으로 쑤셔 넣는 NVMe 스피드의 핵심 원리다.
인터럽트 (MSI-X)	구형 핀 인터럽트의 1차선 한계를 벗어나, 메시지 기반으로 수천 개의 인터럽트를 코어별로 분산(Steering)시켜 꽂아주는 하드웨어 알람 체계다.
io_uring	NVMe의 비동기 SQ/CQ 큐 철학이 너무 예뻐서, 리눅스 커널이 유저-커널 통신 시스템 콜마저 그 구조를 모방해 만든 초고속 링 버퍼 I/O다.
SPDK (Storage Performance Dev Kit)	극강의 속도를 위해 리눅스 커널조차 못 믿고 유저 앱이 NVMe 큐에 다이렉트로 메모리를 밀어 넣는 커널 우회(Bypass) 툴킷이다.
직접 메모리 접근 (DMA)	NVMe 컨트롤러가 CPU를 귀찮게 하지 않고 메모리상의 Submission Queue에서 명령을 스스로 퍼가는 무혈입성 데이터 배달술이다.

👶 어린이를 위한 3줄 비유 설명

옛날 하드디스크(SATA) 마을은 놀이공원 입구가 딱 1개뿐이라, 엄청 빠른 롤러코스터(SSD)를 지어놔도 입구에서 표를 끊느라(병목 현상) 하루 종일 줄을 서야 했어요.
하지만 최신 NVMe 마을은 놀이공원 입구(큐)를 6만 개나 만들어 버렸어요! 그것도 사람마다 자기 전용 하이패스 입구를 만들어 준 거죠.
덕분에 6만 명의 사람들이 줄을 설 필요 없이 1초 만에 슉! 하고 각자 롤러코스터에 타버릴 수 있게 되어서 컴퓨터가 빛의 속도로 빨라진 거랍니다!