DPDK

DPDK(Data Plane Development Kit) 고성능 패킷(Packet) 처리 구조를 심층 분석합니다. EAL 초기화와 hugepage/NUMA 메모리 모델, IOVA(VA/PA), PMD poll-mode 루프, rte_mbuf/ring/graph/mempool 데이터 경로, VFIO/UIO 및 bifurcated PMD, AF_XDP와 representor/rte_flow/hairpin, dmadev, OVS-DPDK·VPP·testpmd 운영 시나리오, trace·metrics·power 관리와 하드닝·트러블슈팅까지 실무 중심으로 다룹니다.

DPDK는 Intel이 주도하여 개발한 고성능 패킷 처리 프레임워크로, 커널 네트워크 스택을 완전히 바이패스하여 유저 공간에서 NIC를 직접 제어합니다. 표준 커널 드라이버가 인터럽트(Interrupt) 기반으로 패킷을 처리하는 반면, DPDK는 폴링(polling) 기반 PMD(Poll Mode Driver)를 사용하여 컨텍스트 스위칭(Context Switching)과 인터럽트 오버헤드(Overhead)를 제거합니다. 10~400GbE 환경에서 수십~수백 Mpps(백만 패킷/초)의 처리량을 단일 서버에서 달성할 수 있으며, 통신사(NFV), 클라우드(가상 스위칭), 금융(초저지연 트레이딩), CDN, 보안 장비 등에서 핵심 기술로 사용됩니다.

DPDK 아키텍처 개요

커널 네트워크 스택 vs DPDK 비교

항목별 상세 비교

위 표의 각 항목이 왜 차이를 만드는지 구체적으로 살펴봅니다.

• 패킷 수신 모델 — 커널은 NIC 인터럽트 → softirq → NAPI 폴링의 하이브리드 모델입니다. 인터럽트 진입/탈출에 약 1μs, softirq 스케줄링에 추가 지연이 발생합니다. DPDK는 전용 코어가 rte_eth_rx_burst()를 상시 호출하는 busy-poll 방식이므로 인터럽트 지연이 0입니다.
• 패킷 버퍼 — sk_buff는 범용 구조체로 200바이트 이상의 메타데이터를 포함하며 동적 할당/해제 비용이 큽니다. rte_mbuf는 128바이트(2캐시라인) 고정 구조체로 사전 할당된 Mempool에서 꺼내 쓰므로 할당 비용이 거의 없습니다.
• 프로토콜 스택 — 커널 스택은 L2→L3→L4→Netfilter→conntrack→socket 계층을 모두 통과합니다. DPDK 애플리케이션은 필요한 프로토콜만 직접 파싱하므로 불필요한 계층을 건너뜁니다. 다만 TCP/IP가 필요하면 VPP나 F-Stack 같은 유저 공간 스택을 별도로 통합해야 합니다.
• CPU 사용 패턴 — 커널은 이벤트 기반이므로 유휴 시 CPU를 반납합니다. DPDK는 할당된 코어를 100% 점유하므로, 패킷이 없어도 CPU를 소비합니다. 8코어 서버에서 DPDK에 4코어를 할당하면 나머지 서비스는 4코어만 사용할 수 있습니다.
• 보안/격리 — 커널 스택은 네임스페이스, cgroup, Netfilter, SELinux/AppArmor로 다층 격리를 제공합니다. DPDK는 IOMMU/VFIO 수준의 DMA 격리만 있으므로, 멀티테넌트(Multi-tenant) 환경에서는 애플리케이션 수준의 격리를 별도로 구현해야 합니다.
• 처리량 차이의 원인 — 64바이트 패킷 기준으로 커널 스택은 코어당 1~5 Mpps인 반면, DPDK PMD는 14.88 Mpps(10GbE 와이어레이트)에 도달합니다. 이 3~15배 차이는 인터럽트 제거, 복사 제거, 배치 처리(burst), 캐시라인 정렬 최적화가 누적된 결과입니다.

EAL (Environment Abstraction Layer)

EAL은 DPDK의 초기화 계층으로, 애플리케이션이 하드웨어와 OS 세부 사항에 독립적으로 동작하도록 추상화합니다. rte_eal_init() 호출 시 수행되는 핵심 작업:

/* DPDK 애플리케이션 기본 구조 */
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_mbuf.h>

int main(int argc, char *argv[])
{
    /* EAL 초기화: hugepage 매핑, 코어 설정, PCI 스캔 */
    int ret = rte_eal_init(argc, argv);
    if (ret < 0)
        rte_exit(EXIT_FAILURE, "EAL init failed\\n");

    /* Mempool 생성 (패킷 버퍼 풀) */
    struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create(
        "MBUF_POOL",
        8192,              /* 풀 크기 (mbuf 개수) */
        256,               /* per-core 캐시 크기 */
        0,                 /* priv_size */
        RTE_MBUF_DEFAULT_BUF_SIZE,  /* 데이터룸 크기 */
        rte_socket_id()    /* NUMA 소켓 */
    );

    /* 포트 설정 및 시작 */
    struct rte_eth_conf port_conf = { 0 };
    rte_eth_dev_configure(port_id, nb_rx_q, nb_tx_q, &port_conf);
    rte_eth_rx_queue_setup(port_id, 0, 1024, rte_eth_dev_socket_id(port_id),
                          NULL, mbuf_pool);
    rte_eth_tx_queue_setup(port_id, 0, 1024, rte_eth_dev_socket_id(port_id),
                          NULL);
    rte_eth_dev_start(port_id);

    /* 메인 패킷 처리 루프 (busy-poll) */
    while (!force_quit) {
        struct rte_mbuf *bufs[32];
        uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, bufs, 32);
        if (nb_rx == 0)
            continue;

        /* 패킷 처리 ... */
        process_packets(bufs, nb_rx);

        uint16_t nb_tx = rte_eth_tx_burst(port_id, 0, bufs, nb_rx);
        for (uint16_t i = nb_tx; i < nb_rx; i++)
            rte_pktmbuf_free(bufs[i]);  /* 전송 실패 mbuf 반환 */
    }

    rte_eal_cleanup();
    return 0;
}

rte_eal_init() 내부 구현 분석

rte_eal_init()은 DPDK의 진입점으로, 내부적으로 20개 이상의 서브시스템을 순서대로 초기화합니다. 핵심 단계를 소스 수준에서 분석합니다.

/* lib/eal/linux/eal.c — rte_eal_init() 핵심 흐름 (간략화) */
int
rte_eal_init(int argc, char **argv)
{
    /* ① 커맨드라인 파싱: -l, -n, --socket-mem, -a 등 */
    eal_parse_args(argc, argv);

    /* ② 프로세스 타입 결정: primary vs secondary */
    rte_config.process_type = eal_proc_type_detect();

    /* ③ 플러그인 로딩: lib/ 아래 PMD .so 동적 로드 */
    eal_plugins_init();

    /* ④ Hugepage 메모리 매핑 — 가장 중요한 단계 */
    rte_eal_hugepage_init();
    /*   내부:
     *   - /sys/kernel/mm/hugepages 스캔 → 2MB/1GB 크기별 페이지 수 확인
     *   - /dev/hugepages/에 파일 생성 → mmap(MAP_HUGETLB | MAP_POPULATE)
     *   - /proc/self/pagemap 읽어 물리 주소(PA) 획득 → IOVA PA 모드에 사용
     *   - NUMA 노드별 메모리 분배: --socket-mem 또는 자동 감지
     */

    /* ⑤ 메모리 서브시스템 초기화 */
    rte_eal_memzone_init();   /* 이름 기반 메모리 영역 관리 */
    rte_eal_malloc_heap_init();  /* 힙 관리자: hugepage 위 동적 할당 */

    /* ⑥ IOVA 모드 결정: VA vs PA */
    iova_mode = rte_bus_get_iommu_class();
    /*   IOMMU 있음 → VA 모드 (유저 가상 주소 = IOVA)
     *   IOMMU 없음 → PA 모드 (물리 주소 = IOVA, root 필요) */

    /* ⑦ lcore 스레드 생성 */
    RTE_LCORE_FOREACH_WORKER(i) {
        pthread_create(&lcore_config[i].thread_id,
                       NULL, eal_thread_loop, (void *)(uintptr_t)i);
        /* 각 스레드를 지정된 CPU에 affinity 설정 */
        pthread_setaffinity_np(lcore_config[i].thread_id,
                               sizeof(cpu_set), &lcore_config[i].cpuset);
    }

    /* ⑧ 버스 스캔: PCI, VDEV 등 모든 디바이스 열거 */
    rte_bus_scan();
    /*   PCI 버스: /sys/bus/pci/devices/ 순회
     *   각 디바이스의 vendor:device ID를 등록된 PMD와 매칭
     *   VFIO/UIO 바인딩 상태 확인 */

    /* ⑨ 버스 프로빙: 매칭된 PMD로 디바이스 초기화 */
    rte_bus_probe();
    /*   PMD의 probe() 콜백 호출
     *   PCI BAR mmap, 하드웨어 초기화, 포트 등록 */

    /* ⑩ 서비스 코어, 타이머, 로깅 등 런타임 초기화 */
    rte_service_init();
    rte_timer_subsystem_init();

    return fctret;  /* 파싱된 EAL 인자 수 반환 */
}

Hugepage 매핑 상세 과정

/* lib/eal/linux/eal_hugepage_info.c — hugepage 정보 수집 */
static int
hugepage_info_init(void)
{
    /* /sys/kernel/mm/hugepages/ 아래 디렉토리 순회 */
    /* hugepages-2048kB, hugepages-1048576kB 등 */
    for (dirent = readdir(dir); dirent; dirent = readdir(dir)) {
        /* 크기별 free/total hugepage 수 읽기 */
        get_hugepage_dir(hpi->hugepage_sz, hpi->hugedir,
                          sizeof(hpi->hugedir));

        /* 마운트포인트 확인: /dev/hugepages 또는 /mnt/huge 등 */
        hpi->num_pages[socket] = get_num_hugepages(
            hpi->hugedir, hpi->hugepage_sz, socket);
    }
    return 0;
}

/* lib/eal/linux/eal_memory.c — 실제 hugepage mmap */
static void *
alloc_hugepage(struct hugepage_info *hpi, int socket)
{
    /* hugepage 파일 생성 */
    fd = open(filepath, O_CREAT | O_RDWR, 0600);
    ftruncate(fd, hpi->hugepage_sz);

    /* mmap: MAP_HUGETLB로 hugepage 매핑
     * MAP_POPULATE: 즉시 물리 페이지 할당 (fault 방지)
     * MAP_SHARED: 멀티프로세스 모드에서 secondary와 공유 */
    addr = mmap(NULL, hpi->hugepage_sz,
                 PROT_READ | PROT_WRITE,
                 MAP_SHARED | MAP_POPULATE | MAP_HUGETLB,
                 fd, 0);

    /* mbind()로 NUMA 노드에 바인딩 */
    mbind(addr, hpi->hugepage_sz, MPOL_BIND,
           &nodemask, max_node, MPOL_MF_STRICT);

    /* PA 모드: /proc/self/pagemap에서 물리 주소 획득 */
    if (rte_eal_iova_mode() == RTE_IOVA_PA)
        physaddr = rte_mem_virt2phy(addr);

    return addr;
}

PCI 버스 프로빙과 PMD 매칭

/* drivers/bus/pci/linux/pci.c — PCI 디바이스 스캔 */
static int
pci_scan_one(const char *dirname, const struct rte_pci_addr *addr)
{
    struct rte_pci_device *dev;

    dev = malloc(sizeof(*dev));
    dev->addr = *addr;

    /* sysfs에서 디바이스 정보 읽기 */
    snprintf(filename, sizeof(filename),
             "%s/vendor", dirname);
    pci_parse_sysfs_value(filename, &dev->id.vendor_id);

    snprintf(filename, sizeof(filename),
             "%s/device", dirname);
    pci_parse_sysfs_value(filename, &dev->id.device_id);

    /* NUMA 노드 확인 */
    snprintf(filename, sizeof(filename),
             "%s/numa_node", dirname);
    pci_parse_sysfs_value(filename, &dev->device.numa_node);

    /* VFIO/UIO 바인딩 드라이버 확인 */
    snprintf(filename, sizeof(filename),
             "%s/driver", dirname);
    dev->kdrv = pci_get_kernel_driver_by_path(filename);
    /* RTE_PCI_KDRV_VFIO, RTE_PCI_KDRV_UIO_GENERIC 등 */

    /* PCI BAR 리소스 매핑 정보 */
    pci_parse_sysfs_resource(dirname, dev);

    rte_pci_insert_device(dev);
    return 0;
}

/* drivers/bus/pci/pci_common.c — PMD 매칭과 프로빙 */
static int
pci_probe_all_drivers(struct rte_pci_device *dev)
{
    /* 등록된 모든 PMD 드라이버를 순회 */
    TAILQ_FOREACH(dr, &rte_pci_bus.driver_list, next) {
        /* vendor:device ID 매칭 */
        if (rte_pci_match(dr, dev)) {
            /* PMD의 probe() 콜백 호출 */
            ret = dr->probe(dr, dev);
            /* probe() 내부:
             *   1. PCI BAR mmap (VFIO/UIO 경유)
             *   2. NIC 하드웨어 리셋 + 초기화
             *   3. rte_eth_dev 등록 (포트 할당)
             *   4. dev_ops 함수 포인터 테이블 설정
             */
            return ret;
        }
    }
    return -ENODEV;
}

PMD (Poll Mode Driver)

PMD는 DPDK의 핵심으로, 커널 드라이버 없이 유저 공간에서 NIC를 직접 제어합니다. NIC의 PCIe BAR를 mmap()하여 하드웨어 레지스터(Register)에 직접 접근하고, DMA 디스크립터 링(descriptor ring)을 유저 공간 메모리에 배치합니다.

• Interrupt 오버헤드: 초당 수백만 개의 Interrupt가 발생하여 CPU 부하 증가
• 컨텍스트 스위치: 커널-유저 공간 전환 비용 발생
• 복사 오버헤드: 패킷이 커널 버퍼 → 유저 버퍼로 복사

PMD는 이 문제를 해결하기 위해 폴링(Polling) 방식으로 동작합니다. 애플리케이션이 직접 NIC를 폴링하여 패킷을 수신하므로 오버헤드가 없습니다.

RX (수신) 동작 원리

PMD의 RX 동작은 생산자-소비자(Producer-Consumer) 패턴을 따릅니다:

이 과정이 매번 반복되며, PMD는 Interrupt 없이도 패킷을 지속적으로 수신할 수 있습니다.

/* PMD의 RX burst 내부 (간략화) — ixgbe_recv_pkts() 기반 */
static uint16_t
pmd_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
{
    struct pmd_rx_queue *rxq = rx_queue;
    volatile union rx_desc *rxdp;  /* 하드웨어 descriptor 포인터 */
    uint16_t nb_rx = 0;

    while (nb_rx < nb_pkts) {
        rxdp = &rxq->rx_ring[rxq->rx_tail];

        /* DD 비트 확인: NIC가 DMA를 완료했는가? */
        if (!(rxdp->wb.status & RX_DESC_DD))
            break;  /* 더 이상 수신된 패킷 없음 */

        /* mbuf 회수 및 메타데이터 설정 */
        struct rte_mbuf *mb = rxq->sw_ring[rxq->rx_tail];
        mb->pkt_len = rxdp->wb.pkt_len;
        mb->data_len = rxdp->wb.pkt_len;
        mb->hash.rss = rxdp->wb.rss_hash;
        mb->vlan_tci = rxdp->wb.vlan_tag;

        rx_pkts[nb_rx++] = mb;

        /* 새 mbuf를 할당하여 descriptor에 채움 (NIC에 반환) */
        struct rte_mbuf *nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
        rxdp->read.pkt_addr = rte_mbuf_data_iova(nmb);
        rxq->sw_ring[rxq->rx_tail] = nmb;

        rxq->rx_tail = (rxq->rx_tail + 1) & rxq->rx_tail_mask;
    }

    /* tail 레지스터 갱신 → NIC에 새 descriptor 사용 가능 알림 */
    if (nb_rx)
        rte_write32(rxq->rx_tail, rxq->tail_ptr);

    return nb_rx;
}

/* PMD의 TX burst 내부 (간략화) */
static uint16_t
pmd_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
{
    struct pmd_tx_queue *txq = tx_queue;
    uint16_t nb_tx = 0;

    /* 이전에 전송 완료된 descriptor 정리 (mbuf 반환) */
    tx_free_bufs(txq);

    while (nb_tx < nb_pkts) {
        volatile union tx_desc *txdp = &txq->tx_ring[txq->tx_tail];
        struct rte_mbuf *mb = tx_pkts[nb_tx];

        /* TX descriptor에 mbuf의 DMA 주소와 길이 설정 */
        txdp->read.buffer_addr = rte_mbuf_data_iova(mb);
        txdp->read.cmd_type_len = mb->data_len | TX_DESC_EOP | TX_DESC_RS;

        txq->sw_ring[txq->tx_tail] = mb;
        txq->tx_tail = (txq->tx_tail + 1) & txq->tx_tail_mask;
        nb_tx++;
    }

    /* tail 레지스터 갱신 → NIC가 전송 시작 */
    rte_wmb();  /* 메모리 배리어: descriptor 쓰기 완료 보장 */
    rte_write32(txq->tx_tail, txq->tail_ptr);

    return nb_tx;
}

TX (송신) 동작 원리

TX 동작은 RX의 역순으로 진행됩니다:

Rx/Tx 오프로드 플래그

DPDK PMD는 NIC 하드웨어의 오프로드 기능을 ol_flags와 tx_offload 필드로 노출합니다. 올바른 오프로드 설정은 CPU 부하를 NIC으로 이전하여 처리량을 크게 향상시킵니다.

/* Tx 오프로드 설정 예시: TSO + Checksum */
struct rte_eth_conf port_conf = {
    .txmode = {
        .offloads = RTE_ETH_TX_OFFLOAD_IPV4_CKSUM
                   | RTE_ETH_TX_OFFLOAD_TCP_CKSUM
                   | RTE_ETH_TX_OFFLOAD_TCP_TSO,
    },
};

/* 패킷 송신 시 mbuf 오프로드 필드 설정 */
pkt->ol_flags = RTE_MBUF_F_TX_IPV4 | RTE_MBUF_F_TX_IP_CKSUM
              | RTE_MBUF_F_TX_TCP_CKSUM | RTE_MBUF_F_TX_TCP_SEG;
pkt->l2_len = sizeof(struct rte_ether_hdr);   /* 14 */
pkt->l3_len = sizeof(struct rte_ipv4_hdr);     /* 20 */
pkt->l4_len = sizeof(struct rte_tcp_hdr);      /* 20 (옵션 없음) */
pkt->tso_segsz = 1460;                         /* MSS */

/* Checksum: pseudo-header checksum을 앱이 계산, 나머지는 NIC */
rte_ipv4_phdr_cksum(ip_hdr, pkt->ol_flags);

/* NIC capability 조회 */
struct rte_eth_dev_info dev_info;
rte_eth_dev_info_get(port_id, &dev_info);
printf("RX offloads: 0x%lx\\n", dev_info.rx_offload_capa);
printf("TX offloads: 0x%lx\\n", dev_info.tx_offload_capa);

벡터화 PMD와 스칼라 PMD

DPDK PMD는 동일 NIC에 대해 여러 코드 경로를 제공합니다. 벡터화(vectorized) PMD는 SSE/AVX2/AVX-512/NEON SIMD 명령어를 사용하여 한 번에 여러 descriptor를 처리하므로 스칼라 경로 대비 1.5~3배의 처리량을 달성합니다.

벡터 PMD 구현 분석 (AVX2 RX 경로)

벡터 PMD가 어떻게 SIMD로 다수 descriptor를 동시 처리하는지 i40e AVX2 RX 경로를 기반으로 분석합니다.

/* drivers/net/i40e/i40e_rxtx_vec_avx2.c — AVX2 벡터 RX (간략화) */
static inline uint16_t
_recv_raw_pkts_vec_avx2(struct i40e_rx_queue *rxq,
                         struct rte_mbuf **rx_pkts,
                         uint16_t nb_pkts)
{
    volatile union i40e_rx_desc *rxdp = rxq->rx_ring + rxq->rx_tail;
    struct rte_mbuf **sw_ring = rxq->sw_ring + rxq->rx_tail;
    uint16_t nb_rx = 0;

    /* 8개 descriptor를 한 번에 256비트 AVX2 레지스터로 로드 */
    while (nb_rx < nb_pkts) {
        /* ① 8개 descriptor의 status 필드를 AVX2로 일괄 로드 */
        __m256i descs_lo = _mm256_loadu_si256(
            (__m256i *)(rxdp));        /* desc[0]~desc[3] */
        __m256i descs_hi = _mm256_loadu_si256(
            (__m256i *)(rxdp + 4));    /* desc[4]~desc[7] */

        /* ② DD 비트 추출: 8개 descriptor 동시 검사 */
        __m256i staterr = _mm256_and_si256(
            _mm256_unpackhi_epi32(descs_lo, descs_hi),
            dd_mask);
        uint8_t dd_bits = (uint8_t)_mm256_movemask_epi8(
            _mm256_cmpeq_epi32(staterr, dd_mask));

        /* DD=0인 첫 번째 descriptor에서 중단 */
        int num_valid = __builtin_ctz(~dd_bits) / 4;
        if (num_valid == 0) break;

        /* ③ 패킷 길이를 AVX2로 일괄 추출 → mbuf.pkt_len 설정 */
        __m256i pktlen = _mm256_srli_epi32(
            _mm256_and_si256(descs_lo, len_mask), 10);
        /* shuffle로 pkt_len 필드 위치에 정렬 */

        /* ④ mbuf 포인터를 rx_pkts[]에 일괄 저장 */
        _mm256_storeu_si256((__m256i *)&rx_pkts[nb_rx],
            _mm256_loadu_si256((__m256i *)&sw_ring[0]));

        /* ⑤ 새 mbuf 할당 + descriptor 리필 (배치) */
        i40e_rxq_rearm(rxq);

        nb_rx += num_valid;
        rxdp += 8;
        sw_ring += 8;
    }
    return nb_rx;
}

인터럽트 모드 (하이브리드 폴링)

DPDK는 100% busy-poll만 지원하는 것이 아닙니다. Rx 인터럽트 모드를 사용하면 빈 폴링 시 epoll_wait()로 블로킹하여 CPU를 절약하고, 패킷이 도착하면 VFIO eventfd 인터럽트로 깨어나 폴링을 재개합니다.

/* 인터럽트 모드: 빈 폴링 시 epoll 대기 */
while (!force_quit) {
    uint16_t nb_rx = rte_eth_rx_burst(port_id, queue_id, pkts, 32);

    if (nb_rx == 0) {
        /* 패킷 없음 → 인터럽트 활성화 후 대기 */
        rte_eth_dev_rx_intr_enable(port_id, queue_id);
        struct rte_epoll_event ev;
        rte_epoll_wait(epfd, &ev, 1, timeout_ms);
        rte_eth_dev_rx_intr_disable(port_id, queue_id);
        continue;
    }

    /* 패킷 있음 → 일반 폴링 처리 */
    process_packets(pkts, nb_rx);
}

rte_mbuf 구조체(Struct)

rte_mbuf는 DPDK의 패킷 버퍼로, 커널의 sk_buff에 대응하지만 설계 철학이 다릅니다. sk_buff는 동적으로 할당되며 메타데이터가 풍부한 반면, rte_mbuf는 Mempool에서 사전 할당되어 고정 크기의 경량 구조체입니다.

/* rte_mbuf 핵심 필드 (lib/mbuf/rte_mbuf_core.h) */
struct rte_mbuf {
    /* 캐시라인 0 (핫 필드) */
    void         *buf_addr;       /* 가상 주소: headroom + 데이터 시작 */
    rte_iova_t    buf_iova;       /* IO 가상 주소 (DMA용, IOVA) */

    union {
        struct {
            uint32_t pkt_len;       /* 전체 패킷 길이 (체인 포함) */
            uint16_t data_len;      /* 이 세그먼트의 데이터 길이 */
            uint16_t vlan_tci;      /* VLAN Tag */
        };
    };
    uint64_t      ol_flags;       /* Offload 플래그 (checksum, TSO, VLAN...) */

    union {
        uint32_t rss;            /* RSS 해시값 */
        struct {
            uint16_t hash;
            uint16_t id;
        } fdir;                     /* Flow Director 필터 ID */
    } hash;

    uint16_t      data_off;       /* buf_addr부터 데이터 시작까지 오프셋 (headroom) */
    uint16_t      refcnt;         /* 참조 카운트 (공유 mbuf) */
    uint16_t      nb_segs;        /* 체인된 세그먼트 수 */
    uint16_t      port;           /* 입력 포트 ID */

    /* 캐시라인 1 (TX offload) */
    uint64_t      tx_offload;     /* L2/L3/L4 len, TSO segsz 등 (비트필드) */
    struct rte_mempool *pool;    /* 소속 Mempool (반환 시 사용) */
    struct rte_mbuf    *next;    /* 다음 세그먼트 (체인) */

    /* 메모리 배치: rte_mbuf 구조체 + headroom + packet data + tailroom */
    /* 자세한 배치는 아래 SVG 참고 */
};

mbuf 조작 함수 상세 분석

DPDK의 mbuf 조작 함수들은 성능을 위해 대부분 static inline으로 구현됩니다. 핵심 함수의 내부 동작을 분석합니다.

/* lib/mbuf/rte_mbuf.h — mbuf 할당과 해제 핵심 구현 */

/* ━━━ 할당: rte_pktmbuf_alloc() ━━━ */
static inline struct rte_mbuf *
rte_pktmbuf_alloc(struct rte_mempool *mp)
{
    struct rte_mbuf *m;

    /* mempool에서 mbuf 1개를 꺼냄 */
    if (rte_mempool_get(mp, (void **)&m) < 0)
        return NULL;

    /* mbuf 필드 초기화 (패킷 수신 준비) */
    rte_pktmbuf_reset(m);
    /* rte_pktmbuf_reset() 내부:
     *   m->next = NULL;
     *   m->pkt_len = 0;
     *   m->tx_offload = 0;
     *   m->vlan_tci = 0;
     *   m->nb_segs = 1;
     *   m->port = RTE_MBUF_PORT_INVALID;
     *   m->ol_flags = 0;
     *   m->data_off = RTE_PKTMBUF_HEADROOM;  // 128바이트
     *   m->data_len = 0;
     */
    return m;
}

/* ━━━ 해제: rte_pktmbuf_free() ━━━ */
static inline void
rte_pktmbuf_free(struct rte_mbuf *m)
{
    struct rte_mbuf *m_next;

    while (m != NULL) {
        m_next = m->next;
        /* 참조 카운트 감소: 0이면 실제 해제 */
        if (__rte_mbuf_refcnt_update(m, -1) == 0) {
            m->next = NULL;
            rte_mbuf_raw_free(m);
            /* → rte_mempool_put(m->pool, m)
             *   per-core 캐시에 반환 */
        }
        m = m_next;
    }
}

/* ━━━ 데이터 접근: rte_pktmbuf_mtod() ━━━ */
#define rte_pktmbuf_mtod_offset(m, t, o) \
    ((t)((char *)(m)->buf_addr + (m)->data_off + (o)))

#define rte_pktmbuf_mtod(m, t) \
    rte_pktmbuf_mtod_offset(m, t, 0)

/* 사용 예: 이더넷 헤더 접근 */
struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m,
    struct rte_ether_hdr *);

/* ━━━ 헤더 추가: rte_pktmbuf_prepend() ━━━ */
static inline char *
rte_pktmbuf_prepend(struct rte_mbuf *m, uint16_t len)
{
    /* headroom 공간이 충분한지 확인 */
    if (rte_pktmbuf_headroom(m) < len)
        return NULL;

    /* data_off를 앞으로 이동 → 헤더 공간 확보 */
    m->data_off -= len;
    m->data_len += len;
    m->pkt_len  += len;

    return (char *)m->buf_addr + m->data_off;
}

/* ━━━ 데이터 추가: rte_pktmbuf_append() ━━━ */
static inline char *
rte_pktmbuf_append(struct rte_mbuf *m, uint16_t len)
{
    void *tail;
    struct rte_mbuf *m_last = rte_pktmbuf_lastseg(m);

    /* tailroom 공간이 충분한지 확인 */
    if (rte_pktmbuf_tailroom(m_last) < len)
        return NULL;

    /* 현재 데이터 끝 위치 계산 */
    tail = (char *)m_last->buf_addr + m_last->data_off
           + m_last->data_len;
    m_last->data_len += len;
    m->pkt_len       += len;

    return (char *)tail;
}

/* ━━━ 복제: rte_pktmbuf_clone() ━━━ */
static inline struct rte_mbuf *
rte_pktmbuf_clone(struct rte_mbuf *md,
                   struct rte_mempool *mp)
{
    struct rte_mbuf *mc;

    /* 새 mbuf 할당 (간접 mbuf) */
    mc = rte_pktmbuf_alloc(mp);

    /* 원본의 buf_addr과 data_off를 공유 → 데이터 복사 없음 */
    rte_pktmbuf_attach(mc, md);
    /* attach 내부:
     *   mc->buf_addr = md->buf_addr;
     *   mc->buf_iova = md->buf_iova;
     *   mc->data_off = md->data_off;
     *   mc->data_len = md->data_len;
     *   rte_mbuf_refcnt_update(md, 1);  // 원본 참조 카운트 증가
     *   mc->ol_flags |= IND_ATTACHED_MBUF;
     */

    mc->pkt_len = md->pkt_len;
    mc->nb_segs = md->nb_segs;
    return mc;
}

배치 할당/해제 (Bulk Operations)

/* 배치 할당: 한 번에 여러 mbuf를 mempool에서 꺼냄 */
struct rte_mbuf *mbufs[32];
int ret = rte_pktmbuf_alloc_bulk(pool, mbufs, 32);
/* 내부: rte_mempool_get_bulk()로 32개를 한 번에 가져옴
 * → per-core 캐시에서 32개 pop (CAS 불필요)
 * → 캐시 부족 시 공용 Ring에서 bulk 리필 (CAS 1회)
 * → 개별 alloc 32번 호출 대비 ~3배 빠름 */

/* 배치 해제: 한 번에 여러 mbuf를 mempool에 반환 */
unsigned int i;
for (i = 0; i < nb_rx; i++)
    pkts[i] = bufs[i];  /* 미전송 패킷 수집 */
rte_pktmbuf_free_bulk(pkts, nb_rx);
/* 내부: rte_mempool_put_bulk()로 한 번에 반환
 * → per-core 캐시에 한 번에 push
 * → 캐시 오버플로우 시 공용 Ring에 bulk 반환 */

멀티 세그먼트 mbuf (Scatter-Gather)

단일 mbuf의 데이터 영역(기본 2048B)보다 큰 패킷(Jumbo Frame, 최대 9KB)은 여러 mbuf를 next 포인터로 체이닝하여 표현합니다. 이를 Scatter-Gather라고 하며, NIC의 SG DMA 기능과 연동됩니다.

/* 멀티 세그먼트 mbuf 순회 */
struct rte_mbuf *seg = pkt;
uint32_t total_len = 0;

while (seg != NULL) {
    uint8_t *data = rte_pktmbuf_mtod(seg, uint8_t *);
    process_segment(data, seg->data_len);
    total_len += seg->data_len;
    seg = seg->next;
}
/* total_len == pkt->pkt_len 이어야 정상 */

/* 멀티 세그먼트를 단일 세그먼트로 선형화 (필요 시) */
if (rte_pktmbuf_linearize(pkt) != 0)
    rte_pktmbuf_free(pkt);  /* 선형화 실패 (headroom 부족) */

PMD Scatter RX 구현 분석

NIC가 수신한 패킷이 단일 descriptor 버퍼(2048B)보다 크면, PMD는 여러 descriptor에 걸쳐 수신하고 mbuf를 체이닝합니다.

/* drivers/net/ixgbe/ixgbe_rxtx.c — Scatter RX 경로 (간략화) */
static uint16_t
ixgbe_recv_pkts_lro_bulk_alloc(void *rx_queue,
    struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
{
    struct ixgbe_rx_queue *rxq = rx_queue;
    struct rte_mbuf *first_seg = NULL;
    struct rte_mbuf *last_seg = NULL;
    uint16_t nb_rx = 0;

    while (nb_rx < nb_pkts) {
        volatile union ixgbe_adv_rx_desc *rxdp;
        rxdp = &rxq->rx_ring[rxq->rx_tail];

        if (!(rxdp->wb.upper.status_error & IXGBE_RXDADV_STAT_DD))
            break;

        struct rte_mbuf *rxm = rxq->sw_ring[rxq->rx_tail];
        rxm->data_len = rxdp->wb.upper.length;

        /* ① 첫 번째 세그먼트인가? */
        if (first_seg == NULL) {
            first_seg = rxm;
            first_seg->pkt_len = 0;
            first_seg->nb_segs = 0;
        }

        /* ② 체인에 현재 세그먼트 연결 */
        first_seg->pkt_len += rxm->data_len;
        first_seg->nb_segs++;
        if (last_seg != NULL)
            last_seg->next = rxm;
        last_seg = rxm;
        rxm->next = NULL;

        /* ③ EOP(End Of Packet) 비트: 패킷 완료? */
        if (rxdp->wb.upper.status_error & IXGBE_RXDADV_STAT_EOP) {
            /* 패킷 완전 수신 — 메타데이터 설정 */
            first_seg->hash.rss = rxdp->wb.lower.hi_dword.rss;
            first_seg->ol_flags = rx_desc_status_to_pkt_flags(
                rxdp->wb.upper.status_error);
            first_seg->port = rxq->port_id;

            rx_pkts[nb_rx++] = first_seg;
            first_seg = NULL;
            last_seg = NULL;
        }

        /* 새 mbuf 할당하여 descriptor 리필 */
        struct rte_mbuf *nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
        rxdp->read.pkt_addr = rte_mbuf_data_iova_default(nmb);
        rxq->sw_ring[rxq->rx_tail] = nmb;
        rxq->rx_tail = (rxq->rx_tail + 1) & rxq->rx_tail_mask;
    }
    return nb_rx;
}

rte_pktmbuf_chain()과 rte_pktmbuf_linearize() 구현

/* lib/mbuf/rte_mbuf.h — 두 mbuf를 체이닝 */
static inline int
rte_pktmbuf_chain(struct rte_mbuf *head,
                   struct rte_mbuf *tail)
{
    struct rte_mbuf *cur_tail;

    /* head의 마지막 세그먼트 찾기 */
    cur_tail = rte_pktmbuf_lastseg(head);

    /* tail이 이미 간접 mbuf이거나 refcnt > 1이면 실패 */
    if (tail->ol_flags & IND_ATTACHED_MBUF ||
        rte_mbuf_refcnt_read(tail) != 1)
        return -EOVERFLOW;

    /* 체인 연결 */
    cur_tail->next = tail;
    head->nb_segs += tail->nb_segs;
    head->pkt_len += tail->pkt_len;

    /* tail은 더 이상 독립 패킷이 아님 */
    tail->pkt_len = tail->data_len;
    return 0;
}

/* lib/mbuf/rte_mbuf.c — 멀티 세그먼트를 단일 버퍼로 선형화 */
int
rte_pktmbuf_linearize(struct rte_mbuf *mbuf)
{
    size_t seg_len, copy_len;
    struct rte_mbuf *m, *m_next;
    char *buffer;

    /* 이미 단일 세그먼트면 아무것도 안 함 */
    if (mbuf->nb_segs == 1)
        return 0;

    /* 첫 번째 mbuf의 tailroom에 나머지 데이터가 들어가는지 확인 */
    copy_len = mbuf->pkt_len - mbuf->data_len;
    if (rte_pktmbuf_tailroom(mbuf) < copy_len)
        return -1;  /* 공간 부족 */

    /* 후속 세그먼트 데이터를 첫 번째 mbuf 뒤에 복사 */
    buffer = rte_pktmbuf_mtod_offset(mbuf, char *,
                                       mbuf->data_len);
    m = mbuf->next;
    while (m != NULL) {
        m_next = m->next;
        seg_len = m->data_len;
        rte_memcpy(buffer,
                    rte_pktmbuf_mtod(m, char *),
                    seg_len);
        buffer += seg_len;

        /* 후속 세그먼트를 mempool에 반환 */
        rte_pktmbuf_free_seg(m);
        m = m_next;
    }

    /* 단일 세그먼트로 갱신 */
    mbuf->data_len = mbuf->pkt_len;
    mbuf->nb_segs = 1;
    mbuf->next = NULL;
    return 0;
}

Ring 라이브러리

DPDK rte_ring은 고정 크기, FIFO, lock-free 큐로, 코어 간 패킷 전달, 멀티프로세스 IPC, 태스크(Task) 분배 등에 사용됩니다. CAS(Compare-And-Swap) 연산 기반으로 락 없이 다수 생산자/소비자를 지원합니다.

/* Ring 기본 사용 */
struct rte_ring *ring = rte_ring_create(
    "MY_RING",
    1024,                /* 크기 (2의 거듭제곱이어야 함) */
    rte_socket_id(),     /* NUMA 소켓 */
    RING_F_SP_ENQ | RING_F_SC_DEQ  /* 단일 생산자/소비자 (더 빠름) */
);

/* 생산자: 패킷을 Ring에 삽입 */
struct rte_mbuf *pkts[32];
unsigned nb = rte_eth_rx_burst(port, 0, pkts, 32);
unsigned sent = rte_ring_enqueue_burst(ring, (void **)pkts, nb, NULL);

/* 소비자: Ring에서 패킷 추출 (다른 코어) */
struct rte_mbuf *dequeued[32];
unsigned got = rte_ring_dequeue_burst(ring, (void **)dequeued, 32, NULL);

MP enqueue CAS 알고리즘 구현 분석

Multi-Producer(MP) enqueue는 여러 코어가 동시에 Ring에 삽입할 수 있도록 lock-free CAS 알고리즘을 사용합니다. 이 구현은 DPDK 성능의 핵심 기반입니다.

/* lib/ring/rte_ring_c11_pvt.h — MP enqueue 핵심 (간략화) */
static inline unsigned int
__rte_ring_move_prod_head(struct rte_ring *r,
    unsigned int is_sp, unsigned int n,
    enum rte_ring_queue_behavior behavior,
    uint32_t *old_head, uint32_t *new_head,
    uint32_t *free_entries)
{
    uint32_t cons_tail;
    int success;

    *old_head = __atomic_load_n(&r->prod.head,
                                 __ATOMIC_RELAXED);
    do {
        /* ① 현재 소비자 tail 읽기 (데이터 의존성으로 acquire) */
        cons_tail = __atomic_load_n(&r->cons.tail,
                                     __ATOMIC_ACQUIRE);

        /* ② 빈 슬롯 수 계산 */
        *free_entries = r->capacity -
            (*old_head - cons_tail);

        /* ③ 삽입할 수 있는 개수 결정 */
        if (n > *free_entries)
            n = (behavior == RTE_RING_QUEUE_FIXED) ?
                0 : *free_entries;
        if (n == 0) return 0;

        *new_head = *old_head + n;

        if (is_sp) {
            /* SP 모드: CAS 불필요, 직접 갱신 */
            r->prod.head = *new_head;
            success = 1;
        } else {
            /* ④ MP 모드: CAS로 head를 원자적으로 이동 */
            success = __atomic_compare_exchange_n(
                &r->prod.head,
                old_head, *new_head,
                0,  /* weak CAS: 실패 시 재시도 */
                __ATOMIC_RELAXED,
                __ATOMIC_RELAXED);
        }
    } while (!success);
    /* CAS 성공: [old_head, new_head) 구간이 이 코어에 예약됨 */

    return n;
}

/* 예약 후 데이터 복사 + tail 갱신 */
static inline unsigned int
__rte_ring_do_enqueue_elem(struct rte_ring *r,
    const void *obj_table, unsigned int esize,
    unsigned int n, ...)
{
    uint32_t old_head, new_head;

    /* ① head 이동 (슬롯 예약) */
    n = __rte_ring_move_prod_head(r, is_sp, n,
            behavior, &old_head, &new_head, &free);

    /* ② 예약된 슬롯에 데이터 복사 */
    __rte_ring_enqueue_elems(r, old_head, obj_table,
                             esize, n);

    /* ③ tail을 순차적으로 갱신
     * 다른 코어가 먼저 CAS에 성공했지만 아직 데이터 복사 중이면,
     * 이 코어는 spin-wait하며 기다림 → 순서 보장 */
    __rte_ring_update_tail(&r->prod, old_head,
                            new_head, is_sp, 1);
    /* update_tail 내부:
     * while (rte_atomic_load(&prod.tail) != old_head)
     *     rte_pause();  // 이전 코어의 복사 완료 대기
     * rte_atomic_store(&prod.tail, new_head, release);
     */

    return n;
}

Mempool과 메모리 관리

rte_mempool은 고정 크기 객체의 풀로, DPDK에서 mbuf 할당/해제의 핵심입니다. Hugepage 위에 구축되며, per-core 캐시로 코어 간 경합(Contention)을 최소화합니다.

/* Mempool 생성과 NUMA 인식 */
struct rte_mempool *pool;

/* 기본: 패킷 mbuf 풀 */
pool = rte_pktmbuf_pool_create(
    "PKT_POOL",
    65535,                   /* 총 mbuf 개수 (2^n - 1 권장) */
    512,                     /* per-core 캐시 크기 (0이면 캐시 비활성) */
    0,                       /* priv_size: mbuf당 추가 메타데이터 크기 */
    RTE_MBUF_DEFAULT_BUF_SIZE,  /* 2048 + 128(headroom) = 2176 */
    rte_socket_id()          /* NUMA 노드 */
);

/* 고급: 외부 메모리로 Mempool 생성 (huge 1GB) */
struct rte_pktmbuf_extmem ext_mem = {
    .buf_ptr  = mmap_addr,      /* 사전 매핑된 hugepage 주소 */
    .buf_iova = iova_addr,      /* IOMMU 매핑된 DMA 주소 */
    .buf_len  = 1ULL << 30,    /* 1GB */
    .elt_size = 2176,           /* mbuf + data 크기 */
};
pool = rte_pktmbuf_pool_create_extbuf("EXT_POOL", 65535, 512,
                                        0, 2176, rte_socket_id(),
                                        &ext_mem, 1);

Mempool 내부 구현: per-core 캐시와 할당 경로

/* lib/mempool/rte_mempool.h — per-core 캐시 구조 */
struct rte_mempool_cache {
    uint32_t size;       /* 캐시 최대 크기 (생성 시 지정) */
    uint32_t flushthresh; /* = size × 1.5, 초과 시 Ring으로 반환 */
    uint32_t len;        /* 현재 캐시에 있는 객체 수 */
    void *objs[0];       /* 객체 포인터 배열 (LIFO 스택) */
};

/* lib/mempool/rte_mempool.h — 할당 핵심: rte_mempool_get() */
static inline int
rte_mempool_get_bulk(struct rte_mempool *mp,
                      void **obj_table, unsigned int n)
{
    struct rte_mempool_cache *cache;

    /* ① 현재 코어의 로컬 캐시 가져오기 */
    cache = rte_mempool_default_cache(mp,
                rte_lcore_id());

    if (cache != NULL && cache->len >= n) {
        /* ② 캐시에 충분한 객체 → 캐시에서 직접 pop
         * 락 없음, CAS 없음, O(1) */
        cache->len -= n;
        rte_memcpy(obj_table,
                    &cache->objs[cache->len],
                    sizeof(void *) * n);
        return 0;
    }

    /* ③ 캐시 부족 → 공용 Ring에서 배치 리필 */
    unsigned int req = n + (cache ? cache->size : 0);
    int ret = rte_mempool_ops_dequeue_bulk(mp,
                  cache ? cache->objs : obj_table, req);
    if (ret < 0)
        return ret;  /* Ring도 비어있음 */

    if (cache) {
        cache->len = cache->size;  /* 캐시 리필 완료 */
        /* 나머지 n개를 obj_table에 복사 */
        rte_memcpy(obj_table,
                    &cache->objs[cache->len],
                    sizeof(void *) * n);
        cache->len -= n;
    }
    return 0;
}

/* lib/mempool/rte_mempool.h — 반환 핵심: rte_mempool_put() */
static inline void
rte_mempool_put_bulk(struct rte_mempool *mp,
                      void * const *obj_table,
                      unsigned int n)
{
    struct rte_mempool_cache *cache;

    cache = rte_mempool_default_cache(mp,
                rte_lcore_id());

    if (cache != NULL) {
        /* 캐시에 push (LIFO 스택) */
        rte_memcpy(&cache->objs[cache->len],
                    obj_table,
                    sizeof(void *) * n);
        cache->len += n;

        /* flushthresh 초과 시 넘치는 분량을 Ring에 반환 */
        if (cache->len >= cache->flushthresh) {
            rte_mempool_ops_enqueue_bulk(mp,
                &cache->objs[cache->size],
                cache->len - cache->size);
            cache->len = cache->size;
        }
        return;
    }

    /* 캐시 없음: 공용 Ring에 직접 반환 */
    rte_mempool_ops_enqueue_bulk(mp, obj_table, n);
}

rte_pktmbuf_pool_create() 내부 동작

/* lib/mbuf/rte_mbuf.c — Mempool 생성 핵심 (간략화) */
struct rte_mempool *
rte_pktmbuf_pool_create(const char *name,
    unsigned int n, unsigned int cache_size,
    uint16_t priv_size, uint16_t data_room_size,
    int socket_id)
{
    struct rte_mempool *mp;
    unsigned int elt_size;

    /* ① 요소 크기 계산 */
    elt_size = sizeof(struct rte_mbuf)  /* 128B */
             + priv_size               /* 사용자 메타데이터 */
             + data_room_size;         /* headroom + 데이터 */
    /* 기본: 128 + 0 + 2176 = 2304B per mbuf */

    /* ② Mempool 구조체 생성 */
    mp = rte_mempool_create(name, n, elt_size,
                              cache_size, 0,
                              NULL, NULL,
                              rte_pktmbuf_init, NULL,
                              socket_id, 0);
    /*   rte_mempool_create() 내부:
     *   a) memzone 할당: hugepage에서 n × elt_size 연속 메모리 확보
     *   b) Ring 생성: 공용 풀로 사용할 rte_ring 할당
     *   c) per-core 캐시 배열 할당: lcore 수 × sizeof(cache)
     *   d) 각 요소에 대해 rte_pktmbuf_init() 콜백 호출
     */

    return mp;
}

/* lib/mbuf/rte_mbuf.c — mbuf 초기화 콜백 */
void
rte_pktmbuf_init(struct rte_mempool *mp,
                  void *opaque_arg,
                  void *_m, unsigned int i)
{
    struct rte_mbuf *m = _m;
    uint32_t mbuf_size = rte_pktmbuf_priv_size(mp)
                        + mp->elt_size;

    memset(m, 0, mbuf_size);

    /* buf_addr: mbuf 구조체 바로 뒤 */
    m->buf_addr = (char *)m + sizeof(struct rte_mbuf)
                + rte_pktmbuf_priv_size(mp);

    /* buf_iova: DMA용 IO 가상 주소 */
    m->buf_iova = rte_mempool_virt2iova(m)
                + sizeof(struct rte_mbuf)
                + rte_pktmbuf_priv_size(mp);

    m->buf_len = mp->elt_size
               - sizeof(struct rte_mbuf)
               - rte_pktmbuf_priv_size(mp);

    m->data_off = RTE_PKTMBUF_HEADROOM;  /* 128B */
    m->refcnt = 1;
    m->nb_segs = 1;
    m->pool = mp;
}

rte_hash — Cuckoo 해시 테이블

rte_hash는 DPDK의 고성능 해시 테이블로, 플로우 테이블, 세션 캐시, ARP 테이블 등 데이터 경로의 키-값 조회에 사용됩니다. 내부적으로 Cuckoo 해싱(Cuckoo Hashing)을 사용하여 최악의 경우에도 O(1) 조회를 보장합니다.

rte_hash 생성과 조회 구현

/* rte_hash 생성 */
struct rte_hash_parameters params = {
    .name = "flow_table",
    .entries = 65536,        /* 최대 엔트리 수 */
    .key_len = sizeof(struct flow_key),  /* 키 크기 (바이트) */
    .hash_func = rte_hash_crc,  /* CRC32 해시 함수 */
    .hash_func_init_val = 0,
    .socket_id = rte_socket_id(),
    .extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF
                | RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD,
};
struct rte_hash *h = rte_hash_create(&params);

/* 키-값 삽입 */
struct flow_key key = { .src_ip = ..., .dst_ip = ..., ... };
int32_t pos = rte_hash_add_key(h, &key);
/* pos >= 0이면 성공, pos가 key_store 인덱스 */
flow_data[pos] = my_flow_data;  /* 사용자 데이터 매핑 */

/* 키-값 삽입 (데이터 포인터 포함) */
rte_hash_add_key_data(h, &key, (void *)flow_data_ptr);

/* 조회 */
int32_t ret = rte_hash_lookup(h, &key);
if (ret >= 0)
    result = flow_data[ret];  /* 인덱스로 데이터 접근 */

/* 데이터 포인터로 직접 조회 */
void *data;
ret = rte_hash_lookup_data(h, &key, &data);

/* 배치 조회: 여러 키를 한 번에 조회 (prefetch 최적화) */
const void *keys[32];
int32_t positions[32];
int hits = rte_hash_lookup_bulk(h, keys, 32, positions);

/* 삭제 */
rte_hash_del_key(h, &key);

rte_hash 내부 구현: Cuckoo 해싱 알고리즘

/* lib/hash/rte_cuckoo_hash.c — rte_hash_add_key() 내부 (간략화) */
int32_t
__rte_hash_add_key_with_hash(const struct rte_hash *h,
    const void *key, hash_sig_t sig)
{
    uint32_t prim_bucket_idx, sec_bucket_idx;
    uint16_t short_sig;  /* signature: 해시의 상위 16비트 */

    /* ① 해시값에서 primary/secondary 버킷 인덱스 계산 */
    prim_bucket_idx = sig & h->bucket_bitmask;
    short_sig = get_short_sig(sig);
    sec_bucket_idx = rte_hash_secondary_hash(sig)
                   & h->bucket_bitmask;

    /* ② primary 버킷에서 빈 슬롯 탐색 */
    struct rte_hash_bucket *prim_bkt =
        &h->buckets[prim_bucket_idx];
    for (int i = 0; i < RTE_HASH_BUCKET_ENTRIES; i++) {
        if (prim_bkt->sig_current[i] == NULL_SIGNATURE) {
            /* 빈 슬롯 발견 → 키 저장 */
            prim_bkt->sig_current[i] = short_sig;
            prim_bkt->key_idx[i] = alloc_key_slot(h);
            rte_memcpy(get_key_slot(h, prim_bkt->key_idx[i]),
                        key, h->key_len);
            return prim_bkt->key_idx[i];
        }
    }

    /* ③ primary 가득 참 → secondary 버킷 시도 */
    struct rte_hash_bucket *sec_bkt =
        &h->buckets[sec_bucket_idx];
    for (int i = 0; i < RTE_HASH_BUCKET_ENTRIES; i++) {
        if (sec_bkt->sig_current[i] == NULL_SIGNATURE) {
            sec_bkt->sig_current[i] = short_sig;
            sec_bkt->key_idx[i] = alloc_key_slot(h);
            rte_memcpy(get_key_slot(h, sec_bkt->key_idx[i]),
                        key, h->key_len);
            return sec_bkt->key_idx[i];
        }
    }

    /* ④ 양쪽 모두 가득 → Cuckoo eviction (BFS 탐색) */
    return rte_hash_cuckoo_insert_mw(h, prim_bkt, sec_bkt,
                                      key, sig, short_sig);
}

/* lib/hash/rte_cuckoo_hash.c — rte_hash_lookup() 내부 (간략화) */
int32_t
__rte_hash_lookup_with_hash(const struct rte_hash *h,
    const void *key, hash_sig_t sig)
{
    uint32_t prim_idx = sig & h->bucket_bitmask;
    uint16_t short_sig = get_short_sig(sig);
    struct rte_hash_bucket *bkt;

    /* ① primary 버킷에서 signature 비교 (캐시라인 1개) */
    bkt = &h->buckets[prim_idx];
    for (int i = 0; i < RTE_HASH_BUCKET_ENTRIES; i++) {
        if (bkt->sig_current[i] == short_sig) {
            /* signature 일치 → 키 전체 비교 */
            void *key_slot = get_key_slot(h, bkt->key_idx[i]);
            if (rte_hash_cmp_eq(key, key_slot, h) == 0)
                return bkt->key_idx[i];  /* 찾음 */
        }
    }

    /* ② secondary 버킷에서 재시도 */
    uint32_t sec_idx = rte_hash_secondary_hash(sig)
                     & h->bucket_bitmask;
    bkt = &h->buckets[sec_idx];
    for (int i = 0; i < RTE_HASH_BUCKET_ENTRIES; i++) {
        if (bkt->sig_current[i] == short_sig) {
            void *key_slot = get_key_slot(h, bkt->key_idx[i]);
            if (rte_hash_cmp_eq(key, key_slot, h) == 0)
                return bkt->key_idx[i];
        }
    }

    return -ENOENT;  /* 키 없음 */
}

배치 조회 파이프라이닝 기법

/* rte_hash_lookup_bulk() 내부의 소프트웨어 파이프라이닝 (간략화) */

/* 1단계: 모든 키의 해시 계산 + primary 버킷 prefetch */
for (uint32_t i = 0; i < num_keys; i++) {
    hash_vals[i] = rte_hash_hash(h, keys[i]);
    prim_idx[i] = hash_vals[i] & h->bucket_bitmask;
    rte_prefetch0(&h->buckets[prim_idx[i]]);
}

/* 2단계: primary 버킷 signature 비교 + secondary prefetch */
for (uint32_t i = 0; i < num_keys; i++) {
    struct rte_hash_bucket *bkt = &h->buckets[prim_idx[i]];
    int found = search_bucket(bkt, short_sigs[i]);
    if (!found) {
        sec_idx[i] = rte_hash_secondary_hash(hash_vals[i])
                   & h->bucket_bitmask;
        rte_prefetch0(&h->buckets[sec_idx[i]]);
    }
}

/* 3단계: secondary 비교 + 키 전체 비교 */
for (uint32_t i = 0; i < num_keys; i++) {
    if (positions[i] < 0) {
        /* primary 미스 → secondary에서 재시도 */
        search_bucket(&h->buckets[sec_idx[i]], ...);
    }
    /* signature 일치 엔트리가 있으면 키 전체 비교 */
    rte_prefetch0(get_key_slot(h, key_idx));
}

/* 4단계: 키 데이터 비교 (이미 prefetch 완료) */
for (uint32_t i = 0; i < num_keys; i++) {
    if (rte_hash_cmp_eq(keys[i], key_slot, h) == 0)
        positions[i] = key_idx;
}

RCU QSBR — 안전한 메모리 회수

QSBR(Quiescent State Based Reclamation)은 DPDK의 RCU(Read-Copy-Update) 구현입니다. lock-free 해시 테이블에서 삭제된 엔트리의 메모리를 안전하게 회수하는 데 사용됩니다. 삭제 시점에 다른 코어가 해당 메모리를 읽고 있을 수 있으므로, 모든 읽기 코어가 quiescent state를 보고한 뒤에 메모리를 해제합니다.

/* QSBR + rte_hash 통합 사용 패턴 */
#include <rte_hash.h>
#include <rte_rcu_qsbr.h>

/* ━━━ 초기화 ━━━ */
size_t sz = rte_rcu_qsbr_get_memsize(num_threads);
struct rte_rcu_qsbr *qsv = rte_zmalloc("qsbr", sz,
                                        RTE_CACHE_LINE_SIZE);
rte_rcu_qsbr_init(qsv, num_threads);

/* rte_hash에 QSBR 연결 (삭제 시 자동 defer) */
struct rte_hash_rcu_config rcu_cfg = {
    .v = qsv,
    .mode = RTE_HASH_QSBR_MODE_DQ,  /* Deferred Queuing */
    .dq_size = 1024,
    .trigger_reclaim_limit = 0,
    .max_reclaim_size = 128,
};
rte_hash_rcu_qsbr_add(hash_table, &rcu_cfg);

/* ━━━ Reader 스레드 (데이터 경로) ━━━ */
rte_rcu_qsbr_thread_register(qsv, lcore_id);
rte_rcu_qsbr_thread_online(qsv, lcore_id);

while (!force_quit) {
    /* 패킷 수신 + 해시 조회 (lock-free) */
    uint16_t nb_rx = rte_eth_rx_burst(port, queue, pkts, 32);
    for (int i = 0; i < nb_rx; i++) {
        int32_t pos = rte_hash_lookup(hash_table, &key);
        if (pos >= 0)
            process_flow(flow_data[pos], pkts[i]);
    }

    /* 폴링 루프 끝에서 quiescent state 보고 */
    rte_rcu_qsbr_quiescent(qsv, lcore_id);
}

/* ━━━ Writer 스레드 (제어 경로) ━━━ */
/* 삭제: rte_hash가 내부적으로 QSBR defer를 사용 */
rte_hash_del_key(hash_table, &key);
/* → 즉시 키 슬롯 제거, 메모리는 grace period 후 자동 회수
 * rte_hash_rcu_qsbr_add()로 연결했으므로 별도 코드 불필요 */

Memzone — 이름 기반 메모리 영역 관리

rte_memzone은 hugepage 위에 이름으로 참조 가능한 연속 메모리 영역을 예약하는 저수준 API입니다. Mempool, Ring, 해시 테이블 등 DPDK의 모든 데이터 구조가 내부적으로 memzone을 통해 메모리를 할당합니다. 멀티프로세스 모드에서 primary와 secondary가 동일한 이름으로 memzone을 조회하여 메모리를 공유합니다.

rte_memzone_reserve() 구현 분석

/* lib/eal/common/eal_common_memzone.c — memzone 예약 (간략화) */
const struct rte_memzone *
rte_memzone_reserve_aligned(const char *name,
    size_t len, int socket_id,
    unsigned int flags, unsigned int align)
{
    struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
    struct rte_memzone *mz;
    void *addr;

    /* ① 이름 중복 검사 */
    rte_rwlock_write_lock(&mcfg->mlock);
    if (memzone_lookup_thread_unsafe(name) != NULL) {
        rte_rwlock_write_unlock(&mcfg->mlock);
        return NULL;  /* 이미 존재 */
    }

    /* ② 빈 memzone 슬롯 할당 */
    mz = get_free_memzone_slot(mcfg);
    if (mz == NULL) {
        rte_rwlock_write_unlock(&mcfg->mlock);
        return NULL;  /* RTE_MAX_MEMZONE 초과 */
    }

    /* ③ malloc_heap에서 hugepage 메모리 할당 */
    addr = malloc_heap_alloc(name, len, socket_id, flags, align);
    if (addr == NULL) {
        rte_rwlock_write_unlock(&mcfg->mlock);
        return NULL;  /* 메모리 부족 */
    }

    /* ④ memzone 메타데이터 기록 */
    strlcpy(mz->name, name, sizeof(mz->name));
    mz->addr = addr;
    mz->iova = rte_malloc_virt2iova(addr);
    mz->len = len;
    mz->hugepage_sz = mcfg->memseg[0].hugepage_sz;
    mz->socket_id = socket_id;
    mz->flags = flags;

    rte_rwlock_write_unlock(&mcfg->mlock);
    return mz;
}

/* memzone 조회 (멀티프로세스에서 secondary가 사용) */
const struct rte_memzone *
rte_memzone_lookup(const char *name)
{
    struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
    const struct rte_memzone *mz;

    rte_rwlock_read_lock(&mcfg->mlock);
    mz = memzone_lookup_thread_unsafe(name);
    rte_rwlock_read_unlock(&mcfg->mlock);
    return mz;
}

/* memzone 실전 사용 예시: 공유 통계 메모리 */

/* Primary 프로세스: memzone 예약 */
const struct rte_memzone *mz = rte_memzone_reserve_aligned(
    "APP_STATS",
    sizeof(struct app_stats) * MAX_PORTS,
    rte_socket_id(),
    RTE_MEMZONE_SIZE_HINT_ONLY,  /* 크기 부족 시 다른 NUMA도 허용 */
    RTE_CACHE_LINE_SIZE);        /* 64B 정렬 */
struct app_stats *stats = mz->addr;
memset(stats, 0, mz->len);

/* Secondary 프로세스: 동일 이름으로 조회 */
const struct rte_memzone *mz = rte_memzone_lookup("APP_STATS");
struct app_stats *stats = mz->addr;
/* stats는 primary와 동일한 물리 메모리를 가리킴 */

/* 모든 memzone 목록 출력 (디버깅) */
rte_memzone_dump(stdout);

DPDK 커널 인터페이스: VFIO vs UIO

DPDK가 유저 공간에서 NIC를 제어하려면 커널의 도움이 필요합니다. PCIe BAR 메모리를 유저 공간에 매핑하고, DMA를 위한 물리/IO 주소 변환(Address Translation)을 제공하는 두 가지 메커니즘:

# ━━━ VFIO 기반 DPDK 디바이스 바인딩 ━━━

# 1. IOMMU 활성화 확인
dmesg | grep -i iommu
# "DMAR: IOMMU enabled" 또는 "AMD-Vi: IOMMU performance counters supported"

# 2. vfio-pci 모듈 로드
modprobe vfio-pci

# 3. NIC 상태 확인
dpdk-devbind --status

# Network devices using kernel driver
# 0000:03:00.0 'Ethernet Controller X710' if=ens3f0 drv=i40e
# 0000:03:00.1 'Ethernet Controller X710' if=ens3f1 drv=i40e

# 4. 커널 드라이버에서 언바인딩 → VFIO에 바인딩
ip link set ens3f0 down
dpdk-devbind --bind=vfio-pci 0000:03:00.0

# 5. 바인딩 확인
dpdk-devbind --status
# Network devices using DPDK-compatible driver
# 0000:03:00.0 'Ethernet Controller X710' drv=vfio-pci

# ━━━ Hugepage 설정 ━━━

# 2MB hugepage 1024개 = 2GB
echo 1024 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

# NUMA 노드별 설정 (듀얼 소켓)
echo 512 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages
echo 512 > /sys/devices/system/node/node1/hugepages/hugepages-2048kB/nr_hugepages

# 1GB hugepage (부팅 커맨드라인에서만 예약 가능)
# GRUB: default_hugepagesz=1G hugepagesz=1G hugepages=4

# hugetlbfs 마운트
mount -t hugetlbfs nodev /dev/hugepages

# ━━━ UIO 기반 (레거시, IOMMU 없는 환경) ━━━
modprobe uio_pci_generic
dpdk-devbind --bind=uio_pci_generic 0000:03:00.0
# ⚠ DMA 격리 없음 — 프로덕션에서 비권장

/* 커널 VFIO-PCI 드라이버가 DPDK에 제공하는 인터페이스 */

/* 1. Container FD — IOMMU 도메인 (DMA 매핑 관리) */
container_fd = open("/dev/vfio/vfio", O_RDWR);
ioctl(container_fd, VFIO_SET_IOMMU, VFIO_TYPE1v2_IOMMU);

/* 2. Group FD — IOMMU 그룹 */
group_fd = open("/dev/vfio/15", O_RDWR);
ioctl(group_fd, VFIO_GROUP_SET_CONTAINER, &container_fd);

/* 3. Device FD — 특정 PCI 디바이스 */
device_fd = ioctl(group_fd, VFIO_GROUP_GET_DEVICE_FD, "0000:03:00.0");

/* 4. BAR 매핑 — NIC 레지스터에 직접 접근 */
struct vfio_region_info reg = { .argsz = sizeof(reg), .index = 0 };
ioctl(device_fd, VFIO_DEVICE_GET_REGION_INFO, &reg);
bar0 = mmap(NULL, reg.size, PROT_READ | PROT_WRITE, MAP_SHARED,
            device_fd, reg.offset);
/* 이제 bar0[offset]으로 NIC 레지스터 직접 read/write 가능 */

/* 5. DMA 매핑 — hugepage를 IOMMU에 등록 */
struct vfio_iommu_type1_dma_map dma = {
    .argsz = sizeof(dma),
    .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
    .vaddr = (uint64_t)hugepage_vaddr,
    .iova  = (uint64_t)hugepage_vaddr,  /* VA=IOVA 모드 */
    .size  = hugepage_size,
};
ioctl(container_fd, VFIO_IOMMU_MAP_DMA, &dma);
/* NIC DMA가 이 hugepage 영역에 접근 가능 */

IOVA 모드: VA vs PA

현재 DPDK EAL은 Linux에서 버스(Bus)가 요구하는 모드, 물리 주소(Physical Address) 접근 가능 여부, IOMMU 그룹 존재 여부를 함께 보고 IOVA 모드를 고릅니다. 공식 Programmer's Guide는 대부분의 경우 RTE_IOVA_VA를 기본 선호 모드로 설명합니다. VFIO + IOMMU가 있으면 VA와 IOVA를 같게 둘 수 있어 초기화와 DMA 매핑이 단순해지기 때문입니다.

비특권 실행과 EAL 메모리 옵션

최신 Linux GSG는 비특권 DPDK 실행을 공식적으로 다룹니다. 핵심은 hugepage 예약은 root가 먼저 수행하고, 그 뒤에는 hugetlbfs 디렉터리와 /dev/vfio/* 권한을 사용자나 전용 그룹에 넘겨주는 방식입니다. 멀티프로세스가 필요 없다면 --in-memory를 사용해 hugetlbfs 파일 접근 자체를 생략할 수도 있습니다.

# 1. root가 hugepage 예약
sudo dpdk-hugepages.py -p 1G --setup 2G

# 2. 사용자 전용 hugepage 마운트 생성
export HUGEDIR=$HOME/huge-1G
mkdir -p "$HUGEDIR"
sudo dpdk-hugepages.py --mount --directory "$HUGEDIR" \
  --user "$(id -u)" --group "$(id -g)"

# 3. VFIO 디바이스를 일반 사용자에게 넘김
sudo dpdk-devbind --bind=vfio-pci --uid "$(id -u)" --gid "$(id -g)" \
  0000:03:00.0

# 4. 필요 리소스 한도 조정 (/etc/security/limits.d/dpdk.conf)
* soft memlock unlimited
* hard memlock unlimited
* soft nofile 1048576
* hard nofile 1048576

# 5. 비특권 testpmd 실행
dpdk-testpmd -l 2-5 -n 4 \
  --huge-dir "$HUGEDIR" \
  --iova-mode=va \
  -a 0000:03:00.0 \
  -- -i --rxq=2 --txq=2 --forward-mode=io

bifurcated PMD와 Linux control plane

모든 DPDK 포트가 VFIO/UIO로 디바이스 전체를 탈취하는 것은 아닙니다. 최신 DPDK 문서는 일부 NIC가 bifurcated driver 모델을 제공한다고 설명합니다. 이 모델에서는 커널 드라이버가 netdev와 control plane을 유지하고, DPDK PMD는 데이터 경로를 분담합니다. 대표적인 예가 mlx5 계열입니다.

패킷 처리 파이프라인 모델

DPDK 애플리케이션은 두 가지 기본 패킷 처리 모델을 사용합니다:

단계 간 전달은 rte_ring으로 수행합니다. 장점은 단계별 독립 확장, 단점은 Ring 통과 지연과 NUMA 크로싱 비용입니다.

/* Run-to-Completion 모델 구현 예시 (RSS 기반 L2 포워딩) */

/* 포트 설정: 코어 수만큼 RX/TX 큐 생성 */
struct rte_eth_conf port_conf = {
    .rxmode = {
        .mq_mode = RTE_ETH_MQ_RX_RSS,    /* RSS 활성화 */
    },
    .rx_adv_conf = {
        .rss_conf = {
            .rss_hf = RTE_ETH_RSS_IP | RTE_ETH_RSS_TCP | RTE_ETH_RSS_UDP,
        },
    },
};
rte_eth_dev_configure(port_id, nb_cores, nb_cores, &port_conf);

/* 각 코어에 RX/TX 큐 1개씩 할당 */
for (int q = 0; q < nb_cores; q++) {
    rte_eth_rx_queue_setup(port_id, q, 1024, socket_id, NULL, mbuf_pool);
    rte_eth_tx_queue_setup(port_id, q, 1024, socket_id, NULL);
}

/* 워커 함수: 각 코어가 독립적으로 실행 */
static int
worker_main(void *arg)
{
    unsigned core_id = rte_lcore_id();
    unsigned queue_id = core_to_queue[core_id];

    while (!force_quit) {
        struct rte_mbuf *pkts[32];
        uint16_t nb_rx = rte_eth_rx_burst(port_id, queue_id, pkts, 32);

        for (uint16_t i = 0; i < nb_rx; i++) {
            struct rte_ether_hdr *eth = rte_pktmbuf_mtod(pkts[i],
                                        struct rte_ether_hdr *);
            /* MAC 주소 스왑 (L2 포워딩) */
            struct rte_ether_addr tmp = eth->dst_addr;
            eth->dst_addr = eth->src_addr;
            eth->src_addr = tmp;
        }

        uint16_t nb_tx = rte_eth_tx_burst(port_id, queue_id, pkts, nb_rx);
        for (uint16_t i = nb_tx; i < nb_rx; i++)
            rte_pktmbuf_free(pkts[i]);
    }
    return 0;
}

/* 모든 워커 코어에서 실행 시작 */
rte_eal_mp_remote_launch(worker_main, NULL, CALL_MAIN);

Pipeline 모델: 코어 간 Ring 전달 구현

/* Pipeline 모델 — 단계별 전용 코어 할당 */

/* 코어 간 전달용 Ring 생성 */
struct rte_ring *rx_to_worker = rte_ring_create(
    "RX_WORKER", 1024,
    rte_socket_id(),
    RING_F_SP_ENQ | RING_F_SC_DEQ);  /* 1:1이므로 SP/SC */

struct rte_ring *worker_to_tx = rte_ring_create(
    "WORKER_TX", 1024,
    rte_socket_id(),
    RING_F_SP_ENQ | RING_F_SC_DEQ);

/* RX 코어: NIC → Ring */
static int rx_core(void *arg) {
    while (!force_quit) {
        struct rte_mbuf *pkts[32];
        uint16_t nb = rte_eth_rx_burst(port, 0, pkts, 32);
        if (nb)
            rte_ring_enqueue_burst(rx_to_worker,
                (void **)pkts, nb, NULL);
    }
    return 0;
}

/* Worker 코어: Ring → 처리 → Ring */
static int worker_core(void *arg) {
    while (!force_quit) {
        struct rte_mbuf *pkts[32];
        unsigned nb = rte_ring_dequeue_burst(rx_to_worker,
            (void **)pkts, 32, NULL);
        for (unsigned i = 0; i < nb; i++)
            process_packet(pkts[i]);  /* DPI, NAT, ACL 등 */
        if (nb)
            rte_ring_enqueue_burst(worker_to_tx,
                (void **)pkts, nb, NULL);
    }
    return 0;
}

/* TX 코어: Ring → NIC */
static int tx_core(void *arg) {
    while (!force_quit) {
        struct rte_mbuf *pkts[32];
        unsigned nb = rte_ring_dequeue_burst(worker_to_tx,
            (void **)pkts, 32, NULL);
        if (nb) {
            uint16_t sent = rte_eth_tx_burst(port, 0,
                pkts, nb);
            for (uint16_t i = sent; i < nb; i++)
                rte_pktmbuf_free(pkts[i]);
        }
    }
    return 0;
}

Graph 라이브러리 — 노드 기반 패킷 실행기

rte_graph는 DPDK의 패킷 처리 로직을 "노드 그래프"로 표현하는 런타임입니다. 예전의 수동 while (rx_burst → process → tx_burst) 루프를 대체한다기보다, 그 루프를 재사용 가능한 노드 단위로 정규화해 주는 계층이라고 보는 편이 정확합니다. 최신 Programmer's Guide는 Graph가 run-to-completion(RTC)와 dispatch 두 실행 모델을 제공하고, 통계/멀티프로세스/그래프 export까지 지원한다고 설명합니다.

/* Graph 생성 흐름의 핵심만 남긴 예시 */
struct rte_graph_param graph_conf = {
    .socket_id = rte_socket_id(),
    .nb_node_patterns = 1,
    .node_patterns = (const char *[]){ "*" },
};

rte_graph_t graph_id = rte_graph_create("graph0", &graph_conf);
struct rte_graph *graph = rte_graph_lookup("graph0");

/* 메인 루프는 rte_graph_walk() 한 줄로 단순화 */
while (!force_quit)
    rte_graph_walk(graph);

rte_graph_walk() 내부 구현 분석

/* lib/graph/rte_graph_worker.h — rte_graph_walk() 핵심 (간략화) */
static inline void
rte_graph_walk(struct rte_graph *graph)
{
    struct rte_node *node;
    rte_graph_off_t head;

    /* ① 보류 큐(pending list)에서 실행할 노드를 순회 */
    head = graph->head;
    while (head != RTE_GRAPH_OFF_INVALID) {
        node = RTE_PTR_ADD(graph, head);
        head = node->next;  /* 다음 보류 노드로 이동 */

        /* ② 노드의 입력 objs 배열에 패킷이 있으면 process() 호출 */
        if (node->idx > 0) {
            node->process(graph, node,
                          node->objs,   /* rte_mbuf** 배열 */
                          node->idx);   /* 패킷 수 */
            node->idx = 0;  /* 처리 완료, 카운터 리셋 */
        }
    }

    /* ③ 보류 큐 초기화 — 다음 walk()를 위해 비움 */
    graph->head = RTE_GRAPH_OFF_INVALID;
    graph->tail = RTE_GRAPH_OFF_INVALID;
}

/* 노드 process() 콜백 예시: ethdev_rx 소스 노드 */
static uint16_t
ethdev_rx_node_process(struct rte_graph *graph,
                        struct rte_node *node,
                        void **objs, uint16_t cnt)
{
    struct ethdev_rx_node_ctx *ctx = node->ctx;
    uint16_t next_index = 0;  /* 기본 다음 노드 */

    /* NIC에서 패킷 수신 */
    uint16_t nb_rx = rte_eth_rx_burst(
        ctx->port_id, ctx->queue_id,
        (struct rte_mbuf **)objs,
        RTE_GRAPH_BURST_SIZE);

    if (nb_rx == 0)
        return 0;

    /* 수신된 패킷을 다음 노드(예: ip4_lookup)로 전달 */
    rte_node_next_stream_move(graph, node,
                               next_index);
    return nb_rx;
}

/* 노드 process() 예시: ip4_lookup 처리 노드 */
static uint16_t
ip4_lookup_node_process(struct rte_graph *graph,
                         struct rte_node *node,
                         void **objs, uint16_t cnt)
{
    struct rte_mbuf *mbuf;
    uint16_t next;

    for (uint16_t i = 0; i < cnt; i++) {
        mbuf = (struct rte_mbuf *)objs[i];

        /* FIB 조회 → 다음 홉 결정 → 다음 노드 선택 */
        next = lpm_lookup(mbuf);

        /* 패킷을 해당 다음 노드의 스트림에 추가 */
        rte_node_enqueue_x1(graph, node, next, objs[i]);
    }
    return cnt;
}

AF_XDP PMD — 커널 통합 고성능 경로

AF_XDP는 DPDK의 완전한 커널 바이패스와 커널 네트워크 스택 사이의 중간 지점입니다. 커널의 XDP 훅에서 패킷을 유저 공간으로 제로카피 전달하므로, VFIO 바인딩 없이 커널 드라이버를 유지하면서 고성능 패킷 처리가 가능합니다.

# ━━━ AF_XDP PMD로 DPDK 실행 ━━━

# NIC은 커널 드라이버에 그대로 유지 (VFIO 바인딩 불필요!)
ip link show ens3f0
# ens3f0: ... state UP ... driver: i40e

# AF_XDP PMD로 DPDK 앱 실행
dpdk-l2fwd -l 0-3 -n 4 \
  --vdev net_af_xdp0,iface=ens3f0,start_queue=0,queue_count=4 \
  -- -p 0x1

# 제로카피 모드 (NIC 드라이버가 지원하는 경우)
# i40e, ice, mlx5 등이 AF_XDP 제로카피 지원
dpdk-l2fwd -l 0-3 -n 4 \
  --vdev net_af_xdp0,iface=ens3f0,start_queue=0,queue_count=4 \
  -- -p 0x1
# 제로카피는 NIC 드라이버가 자동 감지하여 활성화

rte_flow, representor, embedded switch

현대 NIC와 DPU는 단순한 RX/TX 큐 이상의 기능을 제공합니다. PF/VF/SF 앞단의 embedded switch(eSwitch)를 하드웨어가 직접 처리하고, DPDK는 representor 포트와 rte_flow transfer 규칙으로 이 내부 스위치를 제어합니다. 이 개념을 이해해야 OVS hardware offload, SR-IOV, SmartNIC, switchdev 구성이 한 그림으로 연결됩니다.

# representor 포트를 함께 열어 eSwitch를 제어하는 예시
dpdk-testpmd -l 2-7 -n 4 \
  -a 0000:03:00.0,representor=vf[0-3] \
  -- -i

# rte_flow 관점에서는 attr.transfer = 1 이면
# 큐가 아니라 eSwitch 도메인에 규칙을 넣겠다는 뜻입니다.

/* eSwitch transfer 규칙의 핵심만 남긴 예시 */
struct rte_flow_attr attr = {
    .ingress = 1,
    .transfer = 1,   /* 큐가 아닌 eSwitch 도메인 */
};

/* 패턴/액션은 NIC별 지원 범위가 다르므로
 * 반드시 rte_flow_validate()와 rte_eth_dev_info_get()로 먼저 확인 */
rte_flow_validate(port_id, &attr, pattern, actions, &error);

rte_flow 패턴·액션 카탈로그

rte_flow는 NIC 하드웨어에 패킷 분류/액션 규칙을 설치하는 통합 API입니다. 패턴(pattern)으로 매칭 조건을 정의하고, 액션(action)으로 매칭된 패킷의 처리를 지정합니다. NIC별 지원 범위가 다르므로 반드시 rte_flow_validate()로 검증해야 합니다.

/* rte_flow 규칙 생성 — IPv4 TCP 포트 80을 Queue 2로 전달 */
struct rte_flow_attr attr = { .ingress = 1 };

/* 패턴: ETH / IPv4 / TCP dst_port=80 */
struct rte_flow_item_eth eth_spec = { 0 };
struct rte_flow_item_ipv4 ipv4_spec = { 0 };
struct rte_flow_item_tcp tcp_spec = {
    .hdr.dst_port = rte_cpu_to_be_16(80),
};
struct rte_flow_item_tcp tcp_mask = {
    .hdr.dst_port = 0xFFFF,
};

struct rte_flow_item pattern[] = {
    { .type = RTE_FLOW_ITEM_TYPE_ETH,  .spec = &eth_spec },
    { .type = RTE_FLOW_ITEM_TYPE_IPV4, .spec = &ipv4_spec },
    { .type = RTE_FLOW_ITEM_TYPE_TCP,  .spec = &tcp_spec, .mask = &tcp_mask },
    { .type = RTE_FLOW_ITEM_TYPE_END },
};

/* 액션: Queue 2 + 카운터 */
struct rte_flow_action_queue queue = { .index = 2 };
struct rte_flow_action_count count = { 0 };

struct rte_flow_action actions[] = {
    { .type = RTE_FLOW_ACTION_TYPE_COUNT, .conf = &count },
    { .type = RTE_FLOW_ACTION_TYPE_QUEUE, .conf = &queue },
    { .type = RTE_FLOW_ACTION_TYPE_END },
};

/* 검증 후 생성 */
struct rte_flow_error error;
if (rte_flow_validate(port_id, &attr, pattern, actions, &error) == 0) {
    struct rte_flow *flow = rte_flow_create(port_id, &attr,
                                              pattern, actions, &error);
} else {
    printf("Flow validate failed: %s\\n", error.message);
}

Connection Tracking (CT) 오프로드

DPDK 22.x 이후 rte_flow는 하드웨어 기반 Connection Tracking을 지원합니다. 커널의 conntrack처럼 TCP/UDP 연결 상태(NEW, ESTABLISHED, RELATED, INVALID)를 NIC eSwitch 하드웨어가 추적하고, rte_flow 규칙에서 상태를 기반으로 패킷을 분류/드롭합니다. OVS hardware offload의 stateful firewall 지원에 핵심입니다.

/* CT 오프로드: ESTABLISHED 연결은 하드웨어에서 직접 전달 */
struct rte_flow_item_conntrack ct_item = {
    .flags = RTE_FLOW_CONNTRACK_FLAG_ESTABLISHED,
};

struct rte_flow_item ct_pattern[] = {
    { .type = RTE_FLOW_ITEM_TYPE_ETH },
    { .type = RTE_FLOW_ITEM_TYPE_IPV4 },
    { .type = RTE_FLOW_ITEM_TYPE_TCP },
    { .type = RTE_FLOW_ITEM_TYPE_CONNTRACK, .spec = &ct_item },
    { .type = RTE_FLOW_ITEM_TYPE_END },
};

/* ESTABLISHED → representor로 직접 전달 (CPU 바이패스) */
struct rte_flow_action ct_actions[] = {
    { .type = RTE_FLOW_ACTION_TYPE_PORT_ID, .conf = &repr_port },
    { .type = RTE_FLOW_ACTION_TYPE_END },
};

Flow isolated mode

isolated mode는 "명시적으로 설치한 rte_flow 규칙만 포트에 들어오게 하겠습니다"는 선언입니다. 이 모드를 켜면 PMD의 기본 RSS/기본 큐 처리 경로를 차단하고, 포트 전체를 flow rule 기반 제어면으로 바꾸게 됩니다. 하드웨어 오프로드 어플라이언스나 엄격한 서비스 체인에서 특히 유용합니다.

testpmd> flow isolate 0 true
testpmd> flow create 0 ingress pattern eth / ipv4 / tcp / end \
          actions queue index 0 / end
testpmd> flow list 0

Hairpin queue와 intra-device 포워딩

hairpin queue는 패킷을 호스트 메모리까지 올리지 않고 NIC 내부에서 다른 RX/TX 큐나 포트로 되돌리는 기능입니다. OVS hardware offload, representor 기반 서비스 체인, 고속 TAP 없는 VM 브리징, 장치 내부 loopback 테스트에서 중요합니다. 최신 testpmd 문서도 hairpin 관련 명령과 포트 프록시 조회 기능을 별도로 다룹니다.

/* Hairpin capability 조회 후 큐 구성하는 패턴 */
struct rte_eth_hairpin_cap cap;
rte_eth_dev_hairpin_capability_get(port_id, &cap);

struct rte_eth_hairpin_conf hp = {
    .peer_count = 1,
    .manual_bind = 1,
    .tx_explicit = 1,
};

rte_eth_rx_hairpin_queue_setup(port_id, rxq_id, 1024, &hp);
rte_eth_tx_hairpin_queue_setup(port_id, txq_id, 1024, &hp);

Virtio/Vhost-user 아키텍처

DPDK 환경에서 VM과의 패킷 교환은 vhost-user 프로토콜을 통해 이루어집니다. QEMU 게스트의 virtio-net 프론트엔드와 호스트의 DPDK vhost 백엔드가 공유 메모리(hugepage) 위의 virtqueue를 통해 제로카피로 패킷을 전달합니다. 이 구조를 이해해야 OVS-DPDK, Snabbswitch, VPP 등 가상 스위칭의 성능 특성을 설명할 수 있습니다.

# ━━━ QEMU vhost-user 설정 ━━━

# 1. vhost-user 소켓 경로 (OVS-DPDK가 생성)
# /tmp/vhost-user0

# 2. QEMU 실행 (vhost-user 백엔드 연결)
qemu-system-x86_64 \
  -m 4G -smp 4 \
  -object memory-backend-file,id=mem,size=4G,mem-path=/dev/hugepages,share=on \
  -numa node,memdev=mem \
  -chardev socket,id=char0,path=/tmp/vhost-user0,server=off \
  -netdev vhost-user,id=net0,chardev=char0,vhostforce=on,queues=4 \
  -device virtio-net-pci,netdev=net0,mq=on,vectors=10 \
  ...

# 핵심 옵션 설명:
# share=on        — hugepage를 호스트와 게스트가 공유 (필수)
# vhostforce=on   — vhost-user 강제 사용
# queues=4        — 멀티큐 virtio (vCPU 수에 맞춤)
# vectors=10      — MSI-X 벡터 수 (2*queues + 2)

rte_vhost_enqueue/dequeue 구현 분석

/* lib/vhost/virtio_net.c — 호스트→게스트 패킷 전달 (간략화) */
uint16_t
rte_vhost_enqueue_burst(int vid, uint16_t queue_id,
    struct rte_mbuf **pkts, uint16_t count)
{
    struct virtio_net *dev = get_device(vid);
    struct vhost_virtqueue *vq = dev->virtqueue[queue_id];
    uint16_t avail_idx, free_entries;

    /* ① 게스트의 avail ring에서 빈 descriptor 확인 */
    avail_idx = __atomic_load_n(&vq->avail->idx,
                                 __ATOMIC_ACQUIRE);
    free_entries = avail_idx - vq->last_avail_idx;
    count = RTE_MIN(count, free_entries);

    for (uint16_t i = 0; i < count; i++) {
        /* ② avail ring에서 descriptor index 가져오기 */
        uint16_t desc_idx = vq->avail->ring[
            (vq->last_avail_idx + i) & (vq->size - 1)];

        struct vring_desc *desc = &vq->desc[desc_idx];

        /* ③ 게스트 메모리에 패킷 데이터 복사
         * (공유 hugepage이므로 호스트에서 직접 접근 가능) */
        void *dst = (void *)(uintptr_t)
            gpa_to_hva(dev, desc->addr);
        rte_memcpy(dst + virtio_hdr_size,
                    rte_pktmbuf_mtod(pkts[i], void *),
                    pkts[i]->pkt_len);

        /* ④ virtio 헤더 설정 (checksum 오프로드 힌트 등) */
        struct virtio_net_hdr *hdr = dst;
        hdr->num_buffers = 1;
        hdr->flags = 0;

        /* ⑤ used ring에 완료 보고 */
        vq->used->ring[used_idx & (vq->size - 1)] =
            (struct vring_used_elem){
                .id = desc_idx,
                .len = pkts[i]->pkt_len + virtio_hdr_size,
            };
    }

    /* ⑥ used ring index 갱신 → 게스트에게 새 패킷 도착 알림 */
    __atomic_store_n(&vq->used->idx,
        vq->last_used_idx + count, __ATOMIC_RELEASE);

    /* ⑦ 게스트에 인터럽트(eventfd kick) 전송 (필요 시) */
    if (!(vq->avail->flags & VRING_AVAIL_F_NO_INTERRUPT))
        eventfd_write(vq->callfd, (eventfd_t)1);

    return count;
}

OVS-DPDK (Open vSwitch + DPDK)

OVS-DPDK는 Open vSwitch의 데이터플레인을 DPDK로 교체하여 가상 스위칭 성능을 극대화한 구성입니다. 클라우드/NFV 환경에서 VM/컨테이너 간 네트워크 트래픽을 유저 공간에서 처리하여, 기존 커널 OVS 대비 5~10배의 처리량을 달성합니다.

# ━━━ OVS-DPDK 설정 예시 ━━━

# 1. OVS에 DPDK 초기화 파라미터 설정
ovs-vsctl --no-wait set Open_vSwitch . \
  other_config:dpdk-init=true \
  other_config:dpdk-socket-mem="1024,1024" \
  other_config:dpdk-lcore-mask=0x3 \
  other_config:dpdk-hugepage-dir="/dev/hugepages"

# 2. OVS 데몬 재시작
systemctl restart openvswitch-switch

# 3. DPDK 브릿지 생성
ovs-vsctl add-br br0 -- set bridge br0 datapath_type=netdev

# 4. DPDK 물리 포트 추가 (VFIO 바인딩된 NIC)
ovs-vsctl add-port br0 dpdk-p0 -- set Interface dpdk-p0 \
  type=dpdk options:dpdk-devargs=0000:03:00.0

# 5. vhost-user 포트 추가 (VM 연결용)
ovs-vsctl add-port br0 vhost-user0 -- set Interface vhost-user0 \
  type=dpdkvhostuserclient \
  options:vhost-server-path="/tmp/vhost-user0"

# 6. PMD 스레드 CPU 할당 (NUMA 인식)
ovs-vsctl set Open_vSwitch . other_config:pmd-cpu-mask=0x3C

# 7. 플로우 설정 (OpenFlow)
ovs-ofctl add-flow br0 "in_port=dpdk-p0,actions=output:vhost-user0"
ovs-ofctl add-flow br0 "in_port=vhost-user0,actions=output:dpdk-p0"

# ━━━ 성능 확인 ━━━
ovs-appctl dpif-netdev/pmd-stats-show   # PMD 스레드 통계
ovs-appctl dpif-netdev/pmd-rxq-show     # RX 큐 매핑
ovs-appctl dpctl/dump-flows             # 데이터패스 플로우
ovs-appctl coverage/show                # 내부 이벤트 카운터

OVS-DPDK 데이터패스 내부 구현 분석

OVS-DPDK의 패킷 처리 핵심은 PMD 스레드가 실행하는 dp_netdev_process_rxq_port() 함수입니다. 이 함수가 NIC/vhost-user 큐에서 패킷을 수신하고, 플로우 캐시를 조회하여 액션을 실행합니다.

/* lib/dpif-netdev.c — OVS-DPDK PMD 스레드 메인 루프 (간략화) */
static void
dp_netdev_process_rxq_port(struct dp_netdev_pmd_thread *pmd,
                            struct dp_netdev_rxq *rxq)
{
    struct dp_packet_batch batch;
    int error;

    /* ① NIC/vhost-user에서 패킷 배치 수신 */
    error = netdev_rxq_recv(rxq->rx, &batch, NULL);
    /* netdev_rxq_recv()는 내부적으로
     * rte_eth_rx_burst() 또는 rte_vhost_dequeue_burst()를 호출 */

    if (error || dp_packet_batch_is_empty(&batch))
        return;

    /* ② 패킷을 플로우 캐시에서 조회하여 분류 */
    dp_netdev_input(pmd, &batch, rxq->port->port_no);
}

/* lib/dpif-netdev.c — 플로우 조회 3단계 캐시 */
static void
dp_netdev_input(struct dp_netdev_pmd_thread *pmd,
                struct dp_packet_batch *packets,
                odp_port_t port_no)
{
    /* ① EMC (Exact Match Cache) — O(1) 해시 조회
     * 최빈 플로우를 해시 테이블에 캐시
     * 히트 시 즉시 액션 실행 → 최고 성능 경로 */
    emc_processing(pmd, packets, keys, &missed_batch);

    if (dp_packet_batch_is_empty(&missed_batch))
        return;  /* 모든 패킷 EMC 히트 → 완료 */

    /* ② dpcls (Datapath Classifier) — 튜플 기반 분류
     * EMC 미스 패킷을 5-tuple 마스크 기반으로 조회
     * EMC보다 느리지만 와일드카드 매칭 지원 */
    dpcls_lookup(pmd->cls, keys, &missed_batch,
                  &upcall_batch);

    if (!dp_packet_batch_is_empty(&upcall_batch)) {
        /* ③ upcall — ofproto로 미스 보고
         * dpcls에도 없는 새 플로우 → OpenFlow 테이블 조회
         * 매칭된 액션을 데이터패스에 캐시 설치 */
        dp_netdev_upcall(pmd, &upcall_batch);
    }

    /* 분류된 모든 패킷에 대해 액션 실행 */
    dp_netdev_execute_actions(pmd, packets, actions);
    /* 액션 예: output(포트 전송), mod_vlan, set_field,
     * ct(conntrack), drop, controller 등 */
}

DPDK 성능 튜닝

DPDK 성능 튜닝은 시스템 레벨(커널 부트 파라미터, BIOS)에서 시작하여 DPDK 레벨(burst 크기, descriptor ring, mempool), 마지막으로 애플리케이션 레벨(파이프라인 구조, 캐시 정렬)까지 3단계로 진행합니다. 각 항목이 성능에 미치는 영향과 설정 근거를 상세히 설명합니다.

# ━━━ 시스템 레벨 DPDK 성능 튜닝 ━━━

# CPU 격리 (GRUB 커맨드라인)
# GRUB_CMDLINE_LINUX="isolcpus=4-15 nohz_full=4-15 rcu_nocbs=4-15 \
#   intel_pstate=disable processor.max_cstate=1 intel_idle.max_cstate=0 \
#   default_hugepagesz=1G hugepagesz=1G hugepages=8 \
#   iommu=pt intel_iommu=on"

# NUMA 토폴로지 확인 — NIC이 어느 NUMA 노드에 있는지
cat /sys/bus/pci/devices/0000:03:00.0/numa_node
# 0  → NUMA 노드 0의 코어와 메모리를 사용해야 함

# 해당 NUMA 노드의 코어 확인
lscpu | grep "NUMA node0"
# NUMA node0 CPU(s): 0-7,16-23

# irqbalance 비활성화 + DPDK 코어에서 IRQ 배제
systemctl stop irqbalance
# /proc/irq/default_smp_affinity에서 DPDK 코어 제외
echo 000F > /proc/irq/default_smp_affinity  # 코어 0-3만 IRQ 허용

# CPU 주파수 고정 (Turbo Boost는 유지, P-state 전환 최소화)
cpupower -c 4-15 frequency-set -g performance

# 코어별 C-state 확인
turbostat --quiet --show Core,CPU,Busy%,Bzy_MHz,IRQ,C1%,C6% sleep 1

burst 크기와 벡터 PMD의 관계

DPDK PMD는 burst 크기에 따라 서로 다른 코드 경로를 선택합니다. burst 크기가 충분히 크고 2의 거듭제곱이면 벡터화(Vectorized) PMD가 활성화되어 SIMD 명령어(SSE4/AVX2/AVX-512)로 여러 descriptor를 한 번에 처리합니다.

성능 측정과 병목 분석

# ━━━ testpmd로 기본 PPS 측정 ━━━
dpdk-testpmd -l 4-7 -n 4 -- -i --nb-cores=2 --rxq=2 --txq=2

# testpmd 내부 명령
testpmd> set fwd io             # 단순 포워딩 (최대 PPS 측정용)
testpmd> start
testpmd> show port stats all    # RX/TX PPS, 바이트, 에러 확인

# ━━━ perf로 코어별 병목 분석 ━━━
# LLC(Last Level Cache) 미스 확인 — 캐시 효율 측정
perf stat -e LLC-load-misses,LLC-store-misses \
         -e instructions,cycles \
         -C 4-7 sleep 5

# 함수별 CPU 사용 프로파일링
perf top -C 4 -g --no-children

# ━━━ dpdk-proc-info로 큐별 통계 ━━━
dpdk-proc-info -- --stats
dpdk-proc-info -- --xstats      # 확장 통계 (드롭, 에러 상세)

QoS/Traffic Management (rte_sched)

rte_sched는 DPDK의 계층적 QoS 스케줄러로, 통신사 NFV와 엔터프라이즈 네트워크에서 가입자/서비스별 대역폭(Bandwidth) 보장과 트래픽 셰이핑을 유저 공간에서 구현합니다. 커널의 tc/HTB/TBF에 대응하지만, DPDK 데이터 경로 내에서 패킷 단위로 동작하므로 수십 Mpps 수준의 처리량에서도 정밀한 QoS를 유지할 수 있습니다.

/* rte_sched QoS 스케줄러 설정 (간략화) */
struct rte_sched_subport_params subport_params = {
    .tb_rate = 1250000000,       /* 10 Gbps in bytes/s */
    .tb_size = 1000000,           /* 토큰 버킷 크기 */
    .tc_rate = {
        [0] = 500000000,          /* TC0: 4 Gbps (Best Effort) */
        [1] = 375000000,          /* TC1: 3 Gbps (Assured Forwarding) */
        [2] = 250000000,          /* TC2: 2 Gbps (Expedited Forwarding) */
        [3] = 125000000,          /* TC3: 1 Gbps */
    },
    .tc_period = 10,              /* TC 갱신 주기 (ms) */
};

struct rte_sched_pipe_params pipe_profiles[] = {
    {   /* 프로필 0: 일반 가입자 100 Mbps */
        .tb_rate = 12500000,       /* 100 Mbps */
        .tb_size = 100000,
        .tc_rate = { 6250000, 3125000, 3125000, 0 },
        .tc_period = 40,
        .wrr_weights = { 1, 1, 1, 1 },
    },
};

/* 스케줄러 생성 및 패킷 큐잉/디큐잉 */
struct rte_sched_port *sched = rte_sched_port_config(&port_params);
rte_sched_subport_config(sched, 0, &subport_params, 0);
rte_sched_pipe_config(sched, 0, pipe_id, 0);

/* 데이터 경로에서: classify → enqueue → dequeue */
rte_sched_port_pkt_write(sched, pkts, nb_pkts, subport, pipe, tc, queue);
uint16_t nb_enq = rte_sched_port_enqueue(sched, pkts, nb_pkts);
uint16_t nb_deq = rte_sched_port_dequeue(sched, out_pkts, 32);
rte_eth_tx_burst(port_id, 0, out_pkts, nb_deq);

WRED 드롭 정책 구현

/* lib/sched/rte_sched.c — WRED 드롭 판단 (간략화) */
static inline int
rte_sched_port_enqueue_qwa(struct rte_sched_port *port,
    uint32_t qindex, struct rte_mbuf *pkt)
{
    struct rte_sched_queue *q = port->queue + qindex;
    uint32_t qlen = q->qw - q->qr;  /* 현재 큐 길이 */

    /* WRED: 색상별 드롭 확률 계산 */
    enum rte_color color = pkt->color;  /* GREEN/YELLOW/RED */
    struct rte_red *red = &q->red_params[color];

    /* EWMA(지수 가중 이동 평균)로 평균 큐 길이 갱신 */
    red->avg = ((1 - red->wq_log2) * red->avg)
             + (red->wq_log2 * qlen);

    if (red->avg < red->min_th) {
        /* 안전 영역: 무조건 수용 */
        return 0;  /* enqueue 허용 */
    } else if (red->avg >= red->max_th) {
        /* 위험 영역: 무조건 드롭 */
        rte_pktmbuf_free(pkt);
        return -1;
    } else {
        /* 중간 영역: 확률적 드롭
         * 드롭 확률 = (avg - min_th) / (max_th - min_th) × maxp */
        uint32_t drop_prob = rte_red_calc_drop_prob(red);
        if (rte_rand() % 100 < drop_prob) {
            rte_pktmbuf_free(pkt);
            return -1;
        }
        return 0;
    }
}

Eventdev — 이벤트 기반 패킷 스케줄링

rte_eventdev는 DPDK의 이벤트 기반 프로그래밍 모델로, 하드웨어 이벤트 스케줄러(Intel DLB2 등)나 소프트웨어 구현을 통해 패킷을 워커 코어에 동적으로 분배합니다. Run-to-Completion과 Pipeline 모델의 장점을 결합합니다.

큐 타입별 시맨틱 상세

Eventdev 워커 루프 예시

/* eventdev 워커 코어 — 이벤트 수신 → 처리 → 전달 */
static int
event_worker_loop(void *arg)
{
    uint8_t dev_id = *(uint8_t *)arg;
    struct rte_event events[BURST_SIZE];

    while (!force_quit) {
        /* 이벤트 스케줄러에서 이벤트 수신 */
        uint16_t nb_rx = rte_event_dequeue_burst(
            dev_id, /* eventdev ID */
            port_id, /* 워커 포트 ID */
            events, BURST_SIZE,
            0       /* timeout: 0이면 non-blocking */
        );

        for (uint16_t i = 0; i < nb_rx; i++) {
            struct rte_mbuf *m = events[i].mbuf;

            /* 패킷 처리 로직 (L3 포워딩, DPI 등) */
            process_packet(m);

            /* 처리 결과를 TX Adapter 큐로 전달 */
            events[i].queue_id = TX_QUEUE_ID;
            events[i].op = RTE_EVENT_OP_FORWARD;
        }

        if (nb_rx > 0)
            rte_event_enqueue_burst(dev_id, port_id,
                                     events, nb_rx);
    }
    return 0;
}

Eventdev 초기화 코드

/* eventdev + RX/TX Adapter 초기화 골격 */
struct rte_event_dev_config dev_conf = {
    .nb_event_queues = 4,
    .nb_event_ports = 6,        /* 워커 포트 수 */
    .nb_events_limit = 4096,
    .nb_event_queue_flows = 1024,
    .nb_event_port_dequeue_depth = 128,
    .nb_event_port_enqueue_depth = 128,
};
rte_event_dev_configure(dev_id, &dev_conf);

/* Atomic 큐 설정 — 플로우별 직렬화 보장 */
struct rte_event_queue_conf q_conf = {
    .schedule_type = RTE_SCHED_TYPE_ATOMIC,
    .nb_atomic_flows = 1024,
    .nb_atomic_order_sequences = 1024,
};
rte_event_queue_setup(dev_id, queue_id, &q_conf);

/* RX Adapter: ethdev 포트 → eventdev 큐 연결 */
rte_event_eth_rx_adapter_create(adapter_id, dev_id, &port_conf);
rte_event_eth_rx_adapter_queue_add(adapter_id,
    eth_port_id, -1, /* -1 = 모든 RX 큐 */
    &queue_conf);
rte_event_eth_rx_adapter_start(adapter_id);

/* TX Adapter: eventdev → ethdev 포트 연결 */
rte_event_eth_tx_adapter_create(tx_adapter_id, dev_id, &port_conf);
rte_event_eth_tx_adapter_queue_add(tx_adapter_id,
    eth_port_id, -1);
rte_event_eth_tx_adapter_start(tx_adapter_id);

Eventdev vs 수동 Pipeline vs Run-to-Completion

Cryptodev — 암호화 가속 프레임워크

rte_cryptodev는 DPDK의 암호화 추상화 계층으로, 하드웨어 가속기(Intel QAT, Marvell OCTEON, ARM CE)와 소프트웨어 구현(AESNI, OpenSSL, ARMv8 CE)을 동일한 API로 접근합니다. IPSec VPN, TLS 프록시, MACsec, 디스크 암호화 가속 등에서 DPDK 데이터 경로와 통합되어 패킷 단위 암호 연산을 인라인 또는 lookaside 방식으로 처리합니다.

/* Cryptodev 세션 생성 및 암호화 요청 (간략화) */

/* 1. Crypto 디바이스 설정 */
struct rte_cryptodev_config conf = {
    .nb_queue_pairs = 1,
    .socket_id = rte_socket_id(),
};
rte_cryptodev_configure(cdev_id, &conf);

/* 2. 세션 풀 생성 */
struct rte_mempool *sess_pool = rte_cryptodev_sym_session_pool_create(
    "SESS_POOL", 256, 0, 0, 0, rte_socket_id());

/* 3. 대칭 암호화 세션: AES-128-CBC + HMAC-SHA256 */
struct rte_crypto_sym_xform cipher_xform = {
    .type = RTE_CRYPTO_SYM_XFORM_CIPHER,
    .cipher = {
        .op = RTE_CRYPTO_CIPHER_OP_ENCRYPT,
        .algo = RTE_CRYPTO_CIPHER_AES_CBC,
        .key = { .data = key, .length = 16 },
        .iv = { .offset = IV_OFFSET, .length = 16 },
    },
    .next = &auth_xform,  /* 인증 체이닝 */
};

void *session = rte_cryptodev_sym_session_create(cdev_id,
    &cipher_xform, sess_pool);

/* 4. 암호화 요청 (enqueue/dequeue) */
struct rte_crypto_op *ops[32];
rte_crypto_op_bulk_alloc(op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC,
                        ops, 32);

for (int i = 0; i < 32; i++) {
    ops[i]->sym->m_src = pkts[i];  /* mbuf 연결 */
    rte_crypto_op_attach_sym_session(ops[i], session);
}

uint16_t enq = rte_cryptodev_enqueue_burst(cdev_id, 0, ops, 32);
/* ... 다른 작업 수행 ... */
uint16_t deq = rte_cryptodev_dequeue_burst(cdev_id, 0, ops, 32);

DPDK 멀티프로세스 모드

DPDK는 primary-secondary 프로세스 모델을 지원합니다. Primary 프로세스가 EAL 초기화, 포트 설정, Mempool 생성을 수행하고, Secondary 프로세스가 공유 메모리(hugepage)를 통해 동일한 자원에 접근합니다.

# 멀티프로세스 실행 예시

# Primary 프로세스 시작
dpdk-l2fwd -l 0-3 -n 4 --proc-type primary -- -p 0x3

# Secondary 프로세스 (패킷 덤프)
dpdk-pdump -l 4 --proc-type secondary -- \
  --pdump 'port=0,queue=*,rx-dev=/tmp/rx.pcap'

# Secondary 프로세스 (통계 모니터링)
dpdk-proc-info --proc-type secondary -- --stats

컨테이너·Kubernetes 통합

DPDK를 컨테이너화하면 배포·확장·롤백(Rollback)이 용이하지만, hugepage 마운트(Mount), VFIO 디바이스 노출, CPU 격리, NUMA 인식 스케줄링 등 추가 설정이 필요합니다. Kubernetes 환경에서는 SR-IOV Device Plugin과 Multus CNI가 DPDK 워크로드에 VF를 동적 할당하는 표준 패턴입니다.

# Kubernetes DPDK Pod 스펙 예시
apiVersion: v1
kind: Pod
metadata:
  name: dpdk-testpmd
  annotations:
    k8s.v1.cni.cncf.io/networks: sriov-dpdk-net
spec:
  containers:
  - name: testpmd
    image: dpdk-app:24.11
    command: ["dpdk-testpmd"]
    args:
      - "-l"
      - "2-5"
      - "-n"
      - "4"
      - "--iova-mode=va"
      - "--in-memory"
      - "--"
      - "-i"
      - "--rxq=2"
      - "--txq=2"
    resources:
      requests:
        cpu: "4"
        memory: "4Gi"
        hugepages-1Gi: "2Gi"
        intel.com/sriov_dpdk: "1"
      limits:
        cpu: "4"
        memory: "4Gi"
        hugepages-1Gi: "2Gi"
        intel.com/sriov_dpdk: "1"
    securityContext:
      capabilities:
        add: ["IPC_LOCK", "SYS_RAWIO"]
    volumeMounts:
    - name: hugepages
      mountPath: /dev/hugepages
  volumes:
  - name: hugepages
    emptyDir:
      medium: HugePages-1Gi

# ━━━ Docker 직접 실행 예시 ━━━

# SR-IOV VF 생성
echo 4 > /sys/class/net/ens3f0/device/sriov_numvfs

# VF를 vfio-pci에 바인딩
dpdk-devbind --bind=vfio-pci 0000:03:02.0

# VFIO 그룹 번호 확인
ls -la /sys/bus/pci/devices/0000:03:02.0/iommu_group
# → /sys/kernel/iommu_groups/42

# Docker 실행 (privileged 없이!)
docker run --rm -it \
  --device /dev/vfio/42 \
  --device /dev/vfio/vfio \
  -v /dev/hugepages:/dev/hugepages \
  --ulimit memlock=-1:-1 \
  --cpuset-cpus=4-7 \
  dpdk-app:24.11 \
  dpdk-testpmd -l 4-7 -n 4 -a 0000:03:02.0 -- -i

DPDK 디버깅과 모니터링

# ━━━ DPDK 디버깅/모니터링 명령 모음 ━━━

# 포트 통계 (기본 + 확장)
dpdk-proc-info -- --stats
dpdk-proc-info -- --xstats  # NIC별 상세 카운터 (rx_good_bytes, tx_errors, ...)

# 실시간 패킷 캡처 (secondary 프로세스)
dpdk-pdump -l 8 --proc-type secondary -- \
  --pdump 'port=0,queue=*,rx-dev=/tmp/capture.pcap'
# 캡처 파일을 tcpdump/Wireshark로 분석
tcpdump -r /tmp/capture.pcap

# dumpcap 스타일 캡처 (pcapng)
dpdk-dumpcap --list-interfaces
dpdk-dumpcap -i "0000:03:00.0" -c 1000 -w /tmp/trace.pcapng

# 텔레메트리 API (DPDK 20.05+)
# UNIX 소켓 경로: /var/run/dpdk/rte/dpdk_telemetry.vX
dpdk-telemetry.py
# 대화형 쿼리:
# --> /ethdev/stats,0
# --> /ethdev/xstats,0
# --> /eal/params
# --> /mempool/list

# testpmd로 성능 측정
dpdk-testpmd -l 0-3 -n 4 -a 0000:03:00.0 -- \
  -i \
  --forward-mode=io \
  --rxq=4 --txq=4 \
  --nb-cores=3 \
  --burst=32

# testpmd 내부 명령:
# testpmd> start
# testpmd> show port stats all
# testpmd> show fwd stats all
# testpmd> show port xstats 0
# testpmd> stop

# Mempool 상태 확인
dpdk-proc-info -- --mempool=MBUF_POOL

# EAL 로그 레벨 (런타임 조정)
# --log-level=lib.eal:8   (DEBUG)
# --log-level=pmd.net.mlx5:7  (INFO)

/* 프로그래밍 방식 통계 수집 */
struct rte_eth_stats stats;
rte_eth_stats_get(port_id, &stats);

printf("Port %u: RX %lu pkts (%lu bytes) TX %lu pkts (%lu bytes)\\n",
       port_id,
       stats.ipackets, stats.ibytes,
       stats.opackets, stats.obytes);
printf("  RX errors: %lu  TX errors: %lu  RX no-mbuf: %lu\\n",
       stats.ierrors, stats.oerrors, stats.rx_nombuf);

/* 확장 통계 (xstats): NIC별 상세 카운터 */
int len = rte_eth_xstats_get(port_id, NULL, 0);
struct rte_eth_xstat *xstats = malloc(len * sizeof(*xstats));
struct rte_eth_xstat_name *names = malloc(len * sizeof(*names));
rte_eth_xstats_get(port_id, xstats, len);
rte_eth_xstats_get_names(port_id, names, len);

for (int i = 0; i < len; i++)
    printf("  %s: %lu\\n", names[i].name, xstats[i].value);

추가 런타임 서비스: DMA, 전력, 메트릭, 추적

DPDK는 ethdev와 mempool만으로 끝나지 않습니다. 최신 Programmer's Guide는 DMA 엔진 추상화(dmadev), 유휴 폴링 완화용 전력 관리, 메트릭 레지스트리, 저오버헤드 trace 라이브러리를 별도 서브시스템으로 제공합니다. 패킷 처리 코드가 어느 정도 안정되면, 실제 운영 품질은 이 주변 서비스에서 갈리는 경우가 많습니다.

dmadev — 복사/메모리 이동 오프로딩

rte_dmadev는 패킷 그 자체를 처리하는 장치가 아니라 메모리 이동 작업을 오프로딩하는 계층입니다. 공식 문서는 submission/completion ring 기반 API와 ring-less API를 함께 설명합니다. 패킷 payload 복사, 배치 memcpy, 압축/암호화 전 사전 정렬, 소프트웨어 파이프라인의 copy stage 분리에 유용합니다.

/* dmadev 장치 탐색 및 설정 */
int16_t dev_id = rte_dma_next_dev(0);
if (dev_id < 0)
    rte_exit(EXIT_FAILURE, "No DMA device found\n");

struct rte_dma_conf dev_conf = { .nb_vchans = 1 };
rte_dma_configure(dev_id, &dev_conf);

/* vchan(가상 채널) 설정 — 방향, 큐 깊이 */
struct rte_dma_vchan_conf vchan_conf = {
    .direction = RTE_DMA_DIR_MEM_TO_MEM,
    .nb_desc = 2048,   /* submission ring 크기 */
};
rte_dma_vchan_setup(dev_id, 0, &vchan_conf);
rte_dma_start(dev_id);

/* ━━━ 데이터 경로: 비동기 복사 + 완료 수거 ━━━ */
uint16_t vchan = 0;
uint16_t job = rte_dma_copy(dev_id, vchan,
                            src_iova, dst_iova, copy_len,
                            RTE_DMA_OP_FLAG_SUBMIT);
/* RTE_DMA_OP_FLAG_SUBMIT: copy + submit 한 번에 수행 */

/* 다른 패킷 처리 작업을 수행... */

/* 완료 수거 — 배치로 여러 작업의 완료 확인 */
uint16_t last_idx;
bool has_error;
uint16_t done = rte_dma_completed(dev_id, vchan,
                                  32, &last_idx, &has_error);
if (has_error) {
    /* 실패한 작업의 인덱스 확인 */
    rte_dma_completed_status(dev_id, vchan,
                              32, &last_idx, status);
}

유휴 폴링과 전력 관리

DPDK는 본질적으로 busy-poll 프레임워크이지만, 최신 power management 문서는 empty poll 기반 절전, monitor/pause instruction, CPU frequency scaling 연계를 별도로 제공합니다. 즉 "DPDK는 항상 100% CPU를 태운다"는 단순화는 반만 맞습니다. 낮은 부하 구간에서 지연 허용치가 있다면, empty poll 횟수를 기준으로 절전과 지연을 절충할 수 있습니다.

/* empty poll 기반 전력 관리 적용 예시 */
#include <rte_power_empty_poll.h>

/* 초기화: 임계치와 주파수 단계 설정 */
rte_power_empty_poll_stat_init(&ep_params,
    freq_info, RTE_MAX_LCORE);

/* 폴링 루프 내부 */
uint16_t nb_rx = rte_eth_rx_burst(port, queue, bufs, BURST);
if (nb_rx == 0) {
    /* 빈 폴링 횟수 누적 → 임계치 초과 시 자동으로 주파수 낮춤 */
    rte_power_empty_poll_stat_update(lcore_id);
} else {
    /* 패킷 수신 → 즉시 최대 주파수 복귀 */
    rte_power_poll_stat_update(lcore_id, nb_rx);
}

Metrics와 Trace

Metrics 라이브러리는 이름이 등록된 메트릭 집합에 값을 채워 넣는 모델이고, Trace 라이브러리는 저오버헤드 순환 버퍼에 이벤트를 남긴 뒤 파일로 내보내는 모델입니다. 관측 대상을 "지속적 수치"와 "순간 사건"으로 분리하면 설계가 단순해집니다.

/* ━━━ Metrics 라이브러리: 커스텀 메트릭 등록과 갱신 ━━━ */
const char * const names[] = {
    "rx_missed_errors",
    "flow_table_hits",
    "flow_table_misses",
};
int key = rte_metrics_reg_names(names, 3);

/* 주기적 갱신 (예: 1초 간격) */
uint64_t values[3] = {
    rx_missed,
    flow_hits,
    flow_misses,
};
rte_metrics_update_values(RTE_METRICS_GLOBAL,
                           key, values, 3);

/* ━━━ Trace 라이브러리: 커스텀 트레이스 포인트 정의 ━━━ */

/* 헤더 파일에서 트레이스 포인트 선언 */
RTE_TRACE_POINT(
    app_trace_pkt_drop,
    RTE_TRACE_POINT_ARGS(uint16_t port_id,
                          uint32_t reason),
    rte_trace_point_emit_u16(port_id);
    rte_trace_point_emit_u32(reason);
)

/* 데이터 경로에서 호출 */
app_trace_pkt_drop(port_id, DROP_REASON_TTL_EXPIRED);

# ━━━ Telemetry 소켓으로 런타임 모니터링 ━━━

# Telemetry 소켓 경로 확인
ls /var/run/dpdk/rte/dpdk_telemetry.*

# dpdk-telemetry.py로 대화형 조회
dpdk-telemetry.py
--> /ethdev/xstats,0
--> /ethdev/info,0
--> /mempool/list
--> /mempool/info,pktmbuf_pool_0

# Trace 수집 및 분석
# EAL 옵션으로 트레이스 활성화
./dpdk-app --trace="app_trace_*" --trace-dir=/tmp/dpdk-trace

# babeltrace2로 CTF 트레이스 분석
babeltrace2 /tmp/dpdk-trace/rte-*

실전 예제: 고성능 L2 포워딩 애플리케이션

DPDK의 가장 기본적인 데이터 경로인 L2(MAC 기반) 포워딩을 실전 수준으로 구현합니다. 단순 예제와 달리 NUMA 배치, 멀티큐 활용, graceful shutdown, xstats 모니터링까지 포함한 프로덕션 패턴을 다룹니다.

/* l2fwd 프로덕션 패턴 — 핵심 루프 */
#define MAX_PKT_BURST 32
#define BURST_TX_DRAIN_US 100

static volatile bool force_quit = false;

static void
l2fwd_main_loop(void)
{
    struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
    struct rte_eth_dev_tx_buffer *buffer;
    uint16_t port_id, dst_port;
    unsigned lcore_id = rte_lcore_id();
    uint64_t prev_tsc = 0, cur_tsc, diff_tsc;
    const uint64_t drain_tsc =
        ((uint64_t)BURST_TX_DRAIN_US * rte_get_tsc_hz()) / 1000000;

    /* 이 lcore가 담당하는 포트/큐 정보 조회 */
    struct lcore_queue_conf *qconf = &lcore_queue_conf[lcore_id];
    if (qconf->n_rx_port == 0) return;

    while (!force_quit) {
        cur_tsc = rte_rdtsc();
        diff_tsc = cur_tsc - prev_tsc;

        /* TX drain: 미완성 burst를 주기적으로 flush */
        if (unlikely(diff_tsc > drain_tsc)) {
            for (unsigned i = 0; i < qconf->n_rx_port; i++) {
                port_id = qconf->rx_port_list[i];
                dst_port = l2fwd_dst_ports[port_id];
                buffer = tx_buffer[dst_port];
                rte_eth_tx_buffer_flush(dst_port, 0, buffer);
            }
            prev_tsc = cur_tsc;
        }

        /* RX burst → MAC 교환 → TX buffer */
        for (unsigned i = 0; i < qconf->n_rx_port; i++) {
            port_id = qconf->rx_port_list[i];
            dst_port = l2fwd_dst_ports[port_id];
            buffer = tx_buffer[dst_port];

            uint16_t nb_rx = rte_eth_rx_burst(port_id, 0,
                                              pkts_burst, MAX_PKT_BURST);
            if (nb_rx == 0) continue;

            for (uint16_t j = 0; j < nb_rx; j++) {
                struct rte_mbuf *m = pkts_burst[j];
                rte_prefetch0(rte_pktmbuf_mtod(m, void *));
                l2fwd_simple_forward(m, dst_port, buffer);
            }
        }
    }
}

static void
l2fwd_simple_forward(struct rte_mbuf *m,
                     uint16_t dst_port,
                     struct rte_eth_dev_tx_buffer *buffer)
{
    struct rte_ether_hdr *eth =
        rte_pktmbuf_mtod(m, struct rte_ether_hdr *);

    /* src와 dst MAC 교환 */
    struct rte_ether_addr tmp;
    rte_ether_addr_copy(&eth->src_addr, &tmp);
    rte_ether_addr_copy(&eth->dst_addr, &eth->src_addr);
    rte_ether_addr_copy(&tmp, &eth->dst_addr);

    rte_eth_tx_buffer(dst_port, 0, buffer, m);
}

포트 초기화와 mempool 설정

/* mempool 생성 — NUMA 노드별 */
struct rte_mempool *pktmbuf_pool[RTE_MAX_NUMA_NODES];

for (int i = 0; i < rte_socket_count(); i++) {
    int sid = rte_socket_id_by_idx(i);
    char name[32];
    snprintf(name, sizeof(name), "mbuf_pool_%d", sid);
    pktmbuf_pool[sid] = rte_pktmbuf_pool_create(
        name,
        8192,       /* n: 포트당 4096 + 여유 */
        256,        /* cache_size: lcore 로컬 캐시 */
        0,          /* priv_size */
        RTE_MBUF_DEFAULT_BUF_SIZE,
        sid);
    if (!pktmbuf_pool[sid])
        rte_exit(EXIT_FAILURE, "NUMA %d mempool 생성 실패\n", sid);
}

/* 포트 구성 */
struct rte_eth_conf port_conf = {
    .rxmode = { .mq_mode = RTE_ETH_MQ_RX_RSS },
    .rx_adv_conf.rss_conf = {
        .rss_key = NULL,   /* 기본 Toeplitz 키 사용 */
        .rss_hf = RTE_ETH_RSS_IP | RTE_ETH_RSS_TCP | RTE_ETH_RSS_UDP,
    },
    .txmode = { .mq_mode = RTE_ETH_MQ_TX_NONE },
};

RTE_ETH_FOREACH_DEV(port_id) {
    int socket_id = rte_eth_dev_socket_id(port_id);
    rte_eth_dev_configure(port_id, nb_rxq, nb_txq, &port_conf);

    for (uint16_t q = 0; q < nb_rxq; q++)
        rte_eth_rx_queue_setup(port_id, q, 1024,
                              socket_id, NULL, pktmbuf_pool[socket_id]);
    for (uint16_t q = 0; q < nb_txq; q++)
        rte_eth_tx_queue_setup(port_id, q, 1024,
                              socket_id, NULL);
    rte_eth_dev_start(port_id);
    rte_eth_promiscuous_mode_enable(port_id);
}

실전 예제: rte_flow 하드웨어 오프로드

rte_flow API를 사용하면 NIC 하드웨어에 직접 플로우 규칙을 설치하여 소프트웨어 처리 없이 패킷을 분류·드롭·리디렉트할 수 있습니다. 여기서는 실전에서 자주 사용되는 패턴 세 가지 — 특정 플로우를 지정 큐로 분배, 불필요한 트래픽 하드웨어 드롭, hairpin을 이용한 NIC 내부 루프백 — 을 다룹니다.

패턴 1: 특정 TCP 포트 트래픽을 지정 큐로 분배

/* TCP dst port 80 → RX Queue 1로 분배 */
struct rte_flow_attr attr = {
    .ingress = 1,
    .priority = 0,
};

/* 패턴: ETH / IPv4 / TCP dst_port=80 */
struct rte_flow_item_eth  eth_spec  = { 0 };
struct rte_flow_item_ipv4 ipv4_spec = { 0 };
struct rte_flow_item_tcp  tcp_spec  = {
    .hdr.dst_port = rte_cpu_to_be_16(80),
};
struct rte_flow_item_tcp  tcp_mask  = {
    .hdr.dst_port = 0xFFFF,
};

struct rte_flow_item pattern[] = {
    { .type = RTE_FLOW_ITEM_TYPE_ETH,  .spec = &eth_spec },
    { .type = RTE_FLOW_ITEM_TYPE_IPV4, .spec = &ipv4_spec },
    { .type = RTE_FLOW_ITEM_TYPE_TCP,  .spec = &tcp_spec,
                                       .mask = &tcp_mask },
    { .type = RTE_FLOW_ITEM_TYPE_END },
};

/* 액션: Queue 1로 분배 + 카운터 */
struct rte_flow_action_queue  queue_action  = { .index = 1 };
struct rte_flow_action_count count_action = { 0 };

struct rte_flow_action actions[] = {
    { .type = RTE_FLOW_ACTION_TYPE_COUNT, .conf = &count_action },
    { .type = RTE_FLOW_ACTION_TYPE_QUEUE, .conf = &queue_action },
    { .type = RTE_FLOW_ACTION_TYPE_END },
};

struct rte_flow_error error;
struct rte_flow *flow = rte_flow_create(port_id, &attr,
                                           pattern, actions, &error);
if (!flow)
    rte_exit(EXIT_FAILURE, "Flow 생성 실패: %s\n", error.message);

패턴 2: 하드웨어 수준 트래픽 드롭

/* 특정 src IP로부터의 모든 트래픽을 하드웨어에서 드롭 */
struct rte_flow_item_ipv4 ipv4_spec = {
    .hdr.src_addr = rte_cpu_to_be_32(RTE_IPV4(10,0,0,100)),
};
struct rte_flow_item_ipv4 ipv4_mask = {
    .hdr.src_addr = 0xFFFFFFFF,
};

struct rte_flow_item pattern[] = {
    { .type = RTE_FLOW_ITEM_TYPE_ETH },
    { .type = RTE_FLOW_ITEM_TYPE_IPV4,
      .spec = &ipv4_spec, .mask = &ipv4_mask },
    { .type = RTE_FLOW_ITEM_TYPE_END },
};

struct rte_flow_action actions[] = {
    { .type = RTE_FLOW_ACTION_TYPE_DROP },
    { .type = RTE_FLOW_ACTION_TYPE_END },
};

/* validate → create 2단계 패턴 사용 */
if (rte_flow_validate(port_id, &attr, pattern, actions, &error))
    fprintf(stderr, "Flow 유효성 검사 실패: %s\n", error.message);
else
    flow = rte_flow_create(port_id, &attr, pattern, actions, &error);

패턴 3: Hairpin — NIC 내부 RX→TX 루프백

/* Hairpin 큐 설정: RX Queue 2 → TX Queue 2 (NIC 내부) */
struct rte_eth_hairpin_conf hairpin_conf = {
    .peer_count = 1,
    .peers[0] = { .port = port_id, .queue = 2 },
    .manual_bind = 0,
    .force_memory = 1,
};

rte_eth_rx_hairpin_queue_setup(port_id, 2, 0, &hairpin_conf);
rte_eth_tx_hairpin_queue_setup(port_id, 2, 0, &hairpin_conf);

/* rte_flow로 매칭 트래픽을 hairpin 큐로 보냄 */
struct rte_flow_action_queue hairpin_queue = { .index = 2 };
struct rte_flow_action actions[] = {
    { .type = RTE_FLOW_ACTION_TYPE_QUEUE, .conf = &hairpin_queue },
    { .type = RTE_FLOW_ACTION_TYPE_END },
};

실전 예제: pktgen-dpdk 패킷 생성기 활용

pktgen-dpdk는 DPDK 기반 고성능 패킷 생성·수신 도구로, line rate 트래픽 생성과 정밀한 성능 측정을 동시에 수행합니다. 10/25/100 GbE 환경에서 실제 PPS, 지연, 드롭률을 측정하는 실전 절차를 다룹니다.

# pktgen-dpdk 빌드 (meson 기반)
git clone https://github.com/pktgen/Pktgen-DPDK.git
cd Pktgen-DPDK
meson build -Denable_lua=false
ninja -C build

# 실행: 4 lcore, 2 포트
sudo ./build/app/pktgen -l 0-3 -n 4 --socket-mem 1024,0 -- \
    -P -m "[1:2].0" -m "[3].1"
# -P: 프로미스큐어스 모드
# -m "[lcore_list].port": lcore와 포트 매핑

성능 측정 시나리오

# pktgen 콘솔에서 실행하는 명령

# 시나리오 1: 64바이트 최소 프레임 — 최대 PPS 측정
set 0 size 64
set 0 rate 100
set 0 count 0        # 무한 전송
start 0

# 시나리오 2: IMIX (Internet Mix) — 실제 트래픽 패턴 시뮬레이션
# 64B:40%, 594B:33%, 1518B:27% (일반적인 인터넷 트래픽 비율)
set 0 size 64
set 0 rate 40
start 0
# 별도 포트/스트림에서 594B, 1518B 생성

# 시나리오 3: 지연 측정 (latency)
enable 0 latency
set 0 rate 50        # 50% rate로 지연 측정
start 0
page latency         # 지연 통계 페이지 전환

# 결과 확인
page main            # 메인 통계 (PPS, Mbps, 오류)
page stats           # 상세 포트 통계

# 결과 CSV 저장
save results.csv

흔한 실수와 안티패턴

DPDK는 커널 네트워크 스택 대비 하드웨어에 훨씬 가까운 수준에서 동작하므로, 한 가지 설정 오류가 성능을 10배 이상 저하시키는 경우가 빈번합니다. 아래는 실무에서 반복적으로 발생하는 실수와 그 진단·해결 방법입니다.

1. Hugepage 부족 / NUMA 불일치

# NUMA 노드별 hugepage 상태 확인
cat /sys/devices/system/node/node0/hugepages/hugepages-1048576kB/nr_hugepages
cat /sys/devices/system/node/node1/hugepages/hugepages-1048576kB/nr_hugepages

# NIC이 어느 NUMA 노드에 있는지 확인
cat /sys/bus/pci/devices/0000:3b:00.0/numa_node

# 노드별 hugepage 할당 (커널 부팅 파라미터)
# GRUB: hugepagesz=1G hugepages=4 default_hugepagesz=1G
# 또는 런타임:
echo 2 > /sys/devices/system/node/node0/hugepages/hugepages-1048576kB/nr_hugepages
echo 2 > /sys/devices/system/node/node1/hugepages/hugepages-1048576kB/nr_hugepages

2. IOMMU/VFIO 설정 누락

3. lcore 수와 RX/TX 큐 매핑 불일치

/* 흔한 실수: lcore 4개인데 RX 큐가 2개뿐 */
lcore 0 → RXQ 0  (정상)
lcore 1 → RXQ 1  (정상)
lcore 2 → ???     (유휴 — CPU 100% 점유하며 아무 일 안 함)
lcore 3 → ???     (유휴 — CPU 100% 점유하며 아무 일 안 함)

/* 올바른 매핑: lcore 수 = RX 큐 수 */
rte_eth_dev_configure(port_id, 4, 4, &port_conf);  /* 4 RXQ, 4 TXQ */
/* 또는 lcore 수를 NIC 큐 수에 맞춤 */
dpdk-app -l 0-1 ...  /* 2 lcore for 2 queues */

/* NIC 최대 큐 수 확인 */
struct rte_eth_dev_info dev_info;
rte_eth_dev_info_get(port_id, &dev_info);
printf("max_rx_queues=%u max_tx_queues=%u\n",
       dev_info.max_rx_queues, dev_info.max_tx_queues);

4. rte_mbuf 메모리 풀 크기 과소/과대 설정

/* mempool 크기 산정 공식 */
#define NB_RXD 1024
#define NB_TXD 1024
#define MEMPOOL_CACHE_SIZE 256

unsigned nb_mbufs = RTE_MAX(
    nb_ports * (nb_rxq * NB_RXD + nb_txq * NB_TXD +
                MAX_PKT_BURST + nb_lcores * MEMPOOL_CACHE_SIZE),
    8192U);

/* 실전 권장: 포트 2개, 큐 4개씩이면 */
/* 2 * (4*1024 + 4*1024 + 32 + 4*256) = 18,496 → 2^15 = 32768로 올림 */

5. RSS 해시 키 설정 오류

/* 흔한 실수: rss_hf에 NIC이 지원하지 않는 플래그 포함 */
struct rte_eth_dev_info dev_info;
rte_eth_dev_info_get(port_id, &dev_info);

/* 반드시 NIC 지원 범위와 AND 연산 */
port_conf.rx_adv_conf.rss_conf.rss_hf &=
    dev_info.flow_type_rss_offloads;

/* 흔한 실수 2: 커스텀 해시 키 길이가 NIC과 불일치 */
/* Intel NIC: 40바이트, Mellanox: 40바이트, 일부: 52바이트 */
printf("RSS key len = %u\n", dev_info.hash_key_size);

/* 대칭(Symmetric) RSS가 필요한 경우 — 양방향 동일 큐 */
/* Toeplitz 대칭 키 사용 또는 XOR 기반 해시 함수 선택 */
static uint8_t symmetric_key[40] = {
    0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
    0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
    0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
    0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
    0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
};
port_conf.rx_adv_conf.rss_conf.rss_key = symmetric_key;
port_conf.rx_adv_conf.rss_conf.rss_key_len = 40;

6. 애플리케이션 종료 시 리소스 미해제

/* 시그널 핸들러 */
static void signal_handler(int signum)
{
    if (signum == SIGINT || signum == SIGTERM)
        force_quit = true;
}

/* 올바른 종료 시퀀스 */
static void cleanup(void)
{
    uint16_t port_id;

    /* 1. 모든 lcore의 메인 루프 종료 대기 */
    rte_eal_mp_wait_lcore();

    /* 2. 포트 정지 및 해제 */
    RTE_ETH_FOREACH_DEV(port_id) {
        rte_eth_dev_stop(port_id);
        rte_flow_flush(port_id, NULL);  /* flow rule 정리 */
        rte_eth_dev_close(port_id);
    }

    /* 3. mempool은 rte_eal_cleanup()이 처리 */
    rte_eal_cleanup();
}

/* main()에서: */
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
/* ... 메인 루프 ... */
cleanup();

이벤트 드리븐 vs Poll 모드 비교

DPDK의 기본 모델인 Poll 모드(PMD)는 lcore가 무한 루프로 NIC을 폴링하여 최소 지연을 달성하지만, CPU를 항상 100% 점유합니다. 이벤트 드리븐 모드(rte_event)는 하드웨어 또는 소프트웨어 이벤트 스케줄러를 통해 "일이 있을 때만" 워커를 깨워 전력 효율과 확장성을 높입니다.

/* 이벤트 드리븐 모드 기본 루프 */
static void
event_worker_loop(void *arg)
{
    uint8_t event_dev_id = *(uint8_t *)arg;
    struct rte_event events[MAX_PKT_BURST];

    while (!force_quit) {
        uint16_t nb_events = rte_event_dequeue_burst(
            event_dev_id,
            0,        /* port_id */
            events,
            MAX_PKT_BURST,
            0);       /* timeout_ticks: 0 = non-blocking */

        for (uint16_t i = 0; i < nb_events; i++) {
            struct rte_mbuf *m = events[i].mbuf;
            /* 패킷 처리 로직 */
            process_packet(m);

            /* TX Adapter로 전달 */
            events[i].op = RTE_EVENT_OP_FORWARD;
            events[i].queue_id = TX_STAGE_QUEUE;
        }

        if (nb_events > 0)
            rte_event_enqueue_burst(event_dev_id, 0,
                                    events, nb_events);
    }
}

Graph Library: 패킷 처리 파이프라인

rte_graph는 기존 수동 RTC 루프를 재사용 가능한 노드 그래프로 구조화하는 프레임워크입니다. 여기서는 기본 개념을 넘어 커스텀 노드 작성, 노드 간 데이터 전달, 성능 통계 수집, 그리고 dispatch 모드 활용까지 실전 패턴을 다룹니다.

/* 커스텀 분류 노드 예시 */
static uint16_t
classifier_node_process(struct rte_graph *graph,
                        struct rte_node *node,
                        void **objs, uint16_t nb_objs)
{
    uint16_t n_ip4 = 0, n_drop = 0;
    void **to_ip4, **to_drop;

    /* next edge 0 = ip4_lookup, edge 1 = drop */
    to_ip4 = rte_node_next_stream_get(graph, node, 0, nb_objs);
    to_drop = rte_node_next_stream_get(graph, node, 1, nb_objs);

    for (uint16_t i = 0; i < nb_objs; i++) {
        struct rte_mbuf *m = (struct rte_mbuf *)objs[i];
        struct rte_ether_hdr *eth =
            rte_pktmbuf_mtod(m, struct rte_ether_hdr *);

        if (eth->ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4))
            to_ip4[n_ip4++] = m;
        else
            to_drop[n_drop++] = m;
    }

    rte_node_next_stream_put(graph, node, 0, n_ip4);
    rte_node_next_stream_put(graph, node, 1, n_drop);
    return nb_objs;
}

static struct rte_node_register classifier_node = {
    .name = "classifier",
    .process = classifier_node_process,
    .nb_edges = 2,
    .next_nodes = { [0] = "ip4_lookup",
                    [1] = "pkt_drop" },
};
RTE_NODE_REGISTER(classifier_node);

Graph 성능 통계와 디버깅

/* 그래프 통계 수집 활성화 */
struct rte_graph_cluster_stats_param stats_param = {
    .socket_id = SOCKET_ID_ANY,
    .fn = NULL,         /* 기본 콘솔 출력 */
    .nb_graph_patterns = 1,
    .graph_patterns = (const char *[]){ "*" },
};

struct rte_graph_cluster_stats *stats =
    rte_graph_cluster_stats_create(&stats_param);

/* 주기적으로 호출하여 노드별 통계 출력 */
rte_graph_cluster_stats_get(stats, 0);

/* 출력 예시:
 * +------+---+------+----------+----------+---------+
 * | Node |St | Calls|   Objs   |  Realloc |  Cycles |
 * +------+---+------+----------+----------+---------+
 * | rx   | 0 | 1.2M | 38.5M   |    0     |   120   |
 * | cls  | 0 | 1.2M | 38.5M   |   12     |   180   |
 * | tx   | 0 | 1.1M | 37.0M   |    0     |    95   |
 * | drop | 0 | 0.1M |  1.5M   |    0     |    40   |
 * +------+---+------+----------+----------+---------+
 */

/* DOT 그래프 export (Graphviz 시각화용) */
rte_graph_export("graph0", fopen("pipeline.dot", "w"));

DPDK + GPU 연동 (gpudev)

DPDK 21.11에서 도입된 rte_gpudev 라이브러리는 GPU 메모리와 DPDK mbuf 간 zero-copy 데이터 교환을 가능하게 합니다. DPI(Deep Packet Inspection), AI/ML 기반 트래픽 분석, 암호화/압축 가속 등 GPU의 대규모 병렬 연산 능력을 네트워크 데이터 경로에 직접 통합할 수 있습니다.

/* DPDK gpudev 기본 사용 패턴 */
#include <rte_gpudev.h>

/* 1. GPU 디바이스 탐색 */
int16_t gpu_id = rte_gpu_find_next(RTE_GPU_ID_NONE);
struct rte_gpu_info gpu_info;
rte_gpu_info_get(gpu_id, &gpu_info);
printf("GPU: %s, NUMA: %d\n", gpu_info.name, gpu_info.numa_node);

/* 2. GPU 메모리 할당 */
size_t gpu_buf_size = 1024 * 1024;  /* 1 MB */
void *gpu_buf = rte_gpu_mem_alloc(gpu_id, gpu_buf_size, 0);

/* 3. CPU에서 GPU 메모리 접근 가능하게 매핑 */
void *cpu_ptr;
rte_gpu_mem_cpu_map(gpu_id, gpu_buf_size, gpu_buf, &cpu_ptr);

/* 4. Communication List 생성 (비동기 배치 통신) */
struct rte_gpu_comm_list *comm_list =
    rte_gpu_comm_create_list(gpu_id, 64);  /* 64 슬롯 */

/* 5. 패킷 데이터를 comm_list에 등록 */
rte_gpu_comm_populate_list_pkts(comm_list, 0, pkts, nb_rx);

/* 6. GPU 커널 실행 (CUDA 예시) */
/* GPU 측에서 comm_list를 읽어 패킷 처리 */

/* 7. 정리 */
rte_gpu_comm_destroy_list(comm_list, 64);
rte_gpu_mem_cpu_unmap(gpu_id, cpu_ptr);
rte_gpu_mem_free(gpu_id, gpu_buf);

DPDK 23.x / 24.x 주요 변경사항

DPDK는 연 3회(3월, 7월, 11월) 메이저 릴리스를 발행하며, 각 LTS(Long Term Support)는 2년간 유지됩니다. 최근 릴리스에서 데이터 경로 성능, API 안정성, 하드웨어 지원 범위에 중요한 변경이 있었습니다.

DPDK 23.x 시리즈 (23.03, 23.07, 23.11)

DPDK 24.x 시리즈 (24.03, 24.07, 24.11)

마이그레이션 주요 주의사항

/* 22.11 LTS → 24.11 LTS 마이그레이션 체크리스트 */

1. 빌드 환경
   - GCC 10+ 또는 Clang 12+ (C11 필수)
   - meson 0.53+ → 0.56+ 업그레이드 권장
   - pkg-config 파일명 변경 확인: libdpdk.pc

2. API 변경 (컴파일 오류 유발)
   - rte_eth_dev_count() → rte_eth_dev_count_avail()
   - rte_eth_dev_attach() → rte_dev_probe() + rte_eth_dev_get_port_by_name()
   - rte_memcpy() inline 제거 → 표준 memcpy() 사용 권장
   - DEV_RX_OFFLOAD_* → RTE_ETH_RX_OFFLOAD_* 접두사 변경

3. ABI 변경 (재컴파일 필요)
   - rte_eth_dev_info 구조체 크기 변경
   - rte_flow_item 내부 필드 재배치
   - rte_mbuf dynamic field 오프셋 변경 가능

4. 드라이버 지원
   - net/bnxt: 펌웨어 226.x+ 필수
   - net/mlx5: MLNX_OFED 5.9+ 또는 rdma-core 44+ 필요
   - net/ice: DDP 패키지 버전 확인

testpmd 기반 재현 실습

testpmd는 DPDK를 배울 때 가장 중요한 도구입니다. 포트 초기화, 큐 배치, 오프로드 플래그, xstats, flow rule, representor, hairpin을 하나씩 검증할 수 있기 때문입니다. 실무에서는 "내 애플리케이션이 이상하다"라고 보기 전에 먼저 testpmd로 하드웨어와 EAL 조합이 정상인지 확인해야 합니다.

랩 환경 준비

# 1. hugepage 준비
sudo dpdk-hugepages.py -p 1G --setup 2G
dpdk-hugepages.py --show

# 2. 장치 바인딩 상태 확인
dpdk-devbind --status

# 3. VFIO 바인딩
sudo modprobe vfio-pci
sudo ip link set ens3f0 down
sudo dpdk-devbind --bind=vfio-pci 0000:03:00.0

# 4. interactive testpmd 시작
dpdk-testpmd -l 2-5 -n 4 \
  --iova-mode=va \
  -a 0000:03:00.0 \
  -- -i \
  --nb-cores=2 \
  --rxq=2 --txq=2 \
  --burst=32 \
  --port-topology=chained

세션 중 확인 명령

testpmd> show port info all
testpmd> show port stats all
testpmd> show rxq info 0 0
testpmd> show txq info 0 0
testpmd> set fwd macswap
testpmd> set burst 64
testpmd> start
testpmd> stop
testpmd> show fwd stats all
testpmd> show port xstats 0
testpmd> clear port stats all
testpmd> dump mempool
testpmd> quit

패킷 캡처와 관찰 포인트

VPP (FD.io) — 유저 공간 네트워크 스택

VPP(Vector Packet Processing)는 Cisco가 개발하고 Linux Foundation의 FD.io 프로젝트로 운영되는 고성능 유저 공간 네트워크 스택입니다. DPDK PMD 위에서 동작하며 L2~L4 스위칭/라우팅, NAT, IPSec, ACL 등 커널 네트워크 스택의 기능을 유저 공간에서 구현합니다. "벡터 처리(Vector Processing)"라는 고유한 패킷 처리 모델이 VPP의 핵심 성능 비결입니다.

벡터 처리 모델

전통적인 패킷 처리(OVS, 커널 등)는 한 패킷을 모든 처리 단계(L2→L3→ACL→NAT→TX)를 거치게 한 뒤 다음 패킷으로 넘어갑니다. 이 방식은 단계마다 다른 코드를 실행하므로 I-cache(명령어 캐시)가 매번 교체됩니다. VPP는 반대로 같은 처리 노드를 256개 패킷에 연속 적용한 뒤 다음 노드로 넘어가는 벡터 모델을 사용합니다.

VPP 노드 그래프 구조

VPP의 패킷 처리 파이프라인은 노드 그래프(Node Graph)로 구성됩니다. 각 노드는 특정 처리 단계(L2 입력, IPv4 조회, ACL 적용 등)를 담당하며, 패킷의 다음 노드(next-node)를 결정하여 전달합니다.

# ━━━ VPP CLI 기본 조작 ━━━

# VPP 상태 확인
vppctl show version
vppctl show interface

# DPDK 인터페이스 할당 후 활성화
vppctl create interface dpdk GigabitEthernet3/0/0
vppctl set interface state GigabitEthernet3/0/0 up
vppctl set interface ip address GigabitEthernet3/0/0 10.0.0.1/24

# NAT44 설정 예시
vppctl nat44 add interface address GigabitEthernet3/0/1
vppctl set interface nat44 in GigabitEthernet3/0/0 out GigabitEthernet3/0/1

# 노드 그래프 성능 분석
vppctl show runtime                 # 노드별 벡터 크기, 클럭, 호출 횟수
vppctl show node counters           # 노드별 처리 패킷/드롭 카운터
vppctl clear runtime                # 카운터 초기화

# 패킷 트레이싱 (디버깅)
vppctl trace add dpdk-input 100     # dpdk-input 노드에서 100개 패킷 캡처
vppctl show trace                   # 캡처된 패킷의 노드별 처리 경로 출력

OVS-DPDK vs VPP 상세 비교

DPDK 관련 커널 소스 구조

DPDK 자체는 유저 공간 라이브러리이지만, 커널 측에서 DPDK 동작을 지원하는 핵심 구성 요소가 있습니다. DPDK가 NIC를 직접 제어하려면 커널이 디바이스를 유저 공간에 노출하고, DMA를 격리하고, 대용량 페이지를 제공해야 합니다. 여기서는 각 커널 서브시스템이 DPDK 동작에 어떻게 기여하는지 소스 수준에서 분석합니다.

VFIO 커널 서브시스템 상세

VFIO(Virtual Function I/O)는 DPDK가 NIC를 유저 공간에서 안전하게 제어하는 핵심 메커니즘입니다. IOMMU를 이용하여 DMA 격리를 보장하면서 디바이스의 PCI BAR, 인터럽트, DMA 매핑을 유저 공간에 노출합니다.

/* drivers/vfio/pci/vfio_pci_core.c — PCI BAR 영역을 유저 공간에 노출 */

static int
vfio_pci_core_mmap(struct vfio_device *core_vdev,
                    struct vm_area_struct *vma)
{
    struct vfio_pci_core_device *vdev =
        container_of(core_vdev, struct vfio_pci_core_device, vdev);
    unsigned int index;

    index = vma->vm_pgoff >> (VFIO_PCI_OFFSET_SHIFT - PAGE_SHIFT);

    /* BAR 인덱스 유효성 검증 */
    if (index >= VFIO_PCI_NUM_REGIONS ||
        !(vdev->bar_mmap_supported & (1 << index)))
        return -EINVAL;

    /* Write-Combining 또는 Uncacheable 매핑 설정 */
    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

    /* PCI BAR 물리 주소를 유저 공간 VMA에 매핑 */
    return remap_pfn_range(vma, vma->vm_start,
                            vdev->bar_mmap[index].pfn,
                            vma->vm_end - vma->vm_start,
                            vma->vm_page_prot);
}

/* drivers/vfio/vfio_iommu_type1.c — DMA 매핑 (IOVA → 물리 주소) */

static int
vfio_dma_do_map(struct vfio_iommu *iommu,
                struct vfio_iommu_type1_dma_map *map)
{
    dma_addr_t iova = map->iova;
    unsigned long vaddr = map->vaddr;
    size_t size = map->size;
    int prot = 0;

    if (map->flags & VFIO_DMA_MAP_FLAG_READ)
        prot |= IOMMU_READ;
    if (map->flags & VFIO_DMA_MAP_FLAG_WRITE)
        prot |= IOMMU_WRITE;

    /* 유저 공간 hugepage의 물리 주소를 pin하고
     * IOMMU 페이지 테이블에 IOVA → PA 매핑 설치 */
    return vfio_pin_map_dma(iommu, iova, vaddr, size, prot);
}

UIO 커널 서브시스템

UIO(Userspace I/O)는 VFIO 이전의 레거시 디바이스 접근 방식입니다. IOMMU 보호 없이 디바이스를 유저 공간에 노출하므로 보안상 VFIO를 우선 사용해야 합니다.

/* drivers/uio/uio_pci_generic.c — UIO PCI 디바이스 등록 */

static struct pci_driver uio_pci_driver = {
    .name     = "uio_pci_generic",
    .id_table = NULL,  /* 모든 PCI 디바이스에 바인딩 가능 */
    .probe    = uio_pci_generic_probe,
    .remove   = uio_pci_generic_remove,
};

static int
uio_pci_generic_probe(struct pci_dev *pdev,
                       const struct pci_device_id *id)
{
    struct uio_pci_generic_dev *gdev;

    /* 디바이스가 INTx 인터럽트를 지원하는지 확인 */
    if (!pdev->irq)
        return -ENODEV;

    gdev = devm_kzalloc(&pdev->dev, sizeof(*gdev), GFP_KERNEL);
    gdev->info.name = "uio_pci_generic";
    gdev->info.version = DRIVER_VERSION;
    gdev->info.irqcontrol = uio_pci_generic_irqcontrol;
    gdev->info.irq = pdev->irq;

    /* PCI BAR 영역을 UIO 리소스로 등록 →
     * 유저 공간에서 /dev/uioX를 mmap()하면 BAR에 접근 가능 */
    return devm_uio_register_device(&pdev->dev, &gdev->info);
}

AF_XDP 커널 소켓 구현

AF_XDP는 커널 드라이버를 유지하면서 XDP 경로로 패킷을 유저 공간에 제로카피 전달하는 메커니즘입니다. DPDK AF_XDP PMD는 이 커널 소켓을 활용합니다.

/* net/xdp/xsk.c — AF_XDP 소켓의 패킷 수신 핵심 경로 */

int xsk_rcv(struct xdp_sock *xs,
            struct xdp_buff *xdp)
{
    u32 len = xdp->data_end - xdp->data;
    u64 addr;
    int err;

    /* UMEM fill ring에서 빈 프레임 주소를 꺼냄 */
    err = xsk_rcv_peek(xs, &addr);
    if (err)
        return err;

    if (xs->umem->flags & XDP_UMEM_FLAG_UNALIGNED_CHUNKS) {
        /* 제로카피 모드: NIC DMA가 UMEM에 직접 기록 */
        xsk_rcv_zc(xs, xdp, addr, len);
    } else {
        /* 복사 모드: 커널 XDP 버퍼 → UMEM 프레임으로 memcpy */
        memcpy(xsk_buff_raw_get_data(xs->umem, addr),
               xdp->data, len);
    }

    /* RX ring에 완료된 프레임 정보를 넣어 유저 공간에 알림 */
    xsk_rcv_commit(xs, addr, len);
    return 0;
}

Hugepage와 DPDK 메모리 모델

/* mm/hugetlb.c — Hugepage 예약과 할당 핵심 */

long hugetlb_reserve_pages(struct inode *inode,
                            long from, long to,
                            struct vm_area_struct *vma,
                            vm_flags_t vm_flags)
{
    long chg, add = -1;
    struct hstate *h = hstate_inode(inode);

    /* 요청된 범위만큼 hugepage 예약 수 증가 */
    chg = region_chg(&inode->i_mapping->private_list,
                      from, to, NULL);

    /* NUMA 정책에 따라 특정 노드에서 hugepage 확보 */
    if (hugetlb_acct_memory(h, chg))
        return -ENOMEM;

    /* 예약 성공: 이후 fault 시 실제 물리 페이지 할당 */
    region_add(&inode->i_mapping->private_list, from, to,
               NULL, NULL);
    return 0;
}

커널 설정 항목별 해설

# DPDK 관련 커널 설정 (CONFIG_*)

# ━━━ VFIO (권장: IOMMU 기반 안전한 디바이스 패스스루) ━━━
CONFIG_VFIO=m                   # VFIO 코어 프레임워크
CONFIG_VFIO_PCI=m               # PCI 디바이스용 VFIO 드라이버
CONFIG_VFIO_IOMMU_TYPE1=m       # Type1 IOMMU 백엔드 (DMA 격리)
CONFIG_VFIO_NOIOMMU=y           # no-IOMMU 모드 (테스트용, 보안 위험)

# ━━━ UIO (레거시: IOMMU 없는 환경에서만 사용) ━━━
CONFIG_UIO=m                    # UIO 코어 프레임워크
CONFIG_UIO_PCI_GENERIC=m        # 범용 PCI UIO 드라이버

# ━━━ IOMMU (VFIO의 DMA 격리를 제공하는 핵심) ━━━
CONFIG_IOMMU_SUPPORT=y          # IOMMU 프레임워크 활성화
CONFIG_INTEL_IOMMU=y            # Intel VT-d (Xeon/Core 서버)
CONFIG_AMD_IOMMU=y              # AMD-Vi (EPYC/Ryzen 서버)
CONFIG_IOMMU_DEFAULT_DMA_LAZY=y # IOVA 지연 해제 (TLB 무효화 배치 처리로 성능 향상)

# ━━━ Hugepage (DPDK 메모리 관리의 기반) ━━━
CONFIG_HUGETLBFS=y              # /dev/hugepages 파일시스템 지원
CONFIG_HUGETLB_PAGE=y           # 2MB/1GB hugepage 지원
CONFIG_TRANSPARENT_HUGEPAGE=y   # THP — DPDK는 명시적 hugetlbfs 선호
                                # (THP는 compaction 오버헤드 + 예측 불가)

# ━━━ AF_XDP (커널 드라이버 유지 + XDP 경로 고속 처리) ━━━
CONFIG_XDP_SOCKETS=y            # AF_XDP 소켓 지원
CONFIG_BPF_SYSCALL=y            # BPF 시스템 콜 (XDP 프로그램 로딩)
CONFIG_NET_CLS_BPF=m            # tc BPF classifier (선택)

# ━━━ NUMA (멀티소켓 서버 필수) ━━━
CONFIG_NUMA=y                   # NUMA 토폴로지 인식
CONFIG_NUMA_BALANCING=y         # 자동 NUMA 밸런싱 (커널 용도)
                                # DPDK는 자체 NUMA 바인딩 사용

# ━━━ 부트 커맨드라인 (GRUB) ━━━
# intel_iommu=on iommu=pt     ← VFIO 사용 시 필수
#   iommu=pt: pass-through 모드 (커널 DMA는 IOMMU 미적용,
#             VFIO가 관리하는 디바이스만 IOMMU 적용 → 성능 향상)
# hugepagesz=1G hugepages=8   ← 부팅 시 1GB hugepage 8개 예약
# default_hugepagesz=1G       ← 기본 hugepage 크기를 1GB로 설정

DPDK 빌드 시스템(Build System)과 버전 변천

DPDK는 22.11 LTS 이후 Meson + Ninja를 유일한 공식 빌드 시스템으로 사용합니다. 이전의 make 기반 빌드는 21.11에서 완전히 제거되었습니다. ABI 안정성 정책은 LTS 릴리스 간에 유지되며, 연 1회 LTS와 분기별 안정 릴리스로 운영됩니다.

# ━━━ DPDK Meson 빌드 (권장) ━━━

# 의존성 설치 (Debian/Ubuntu)
apt install build-essential meson ninja-build python3-pyelftools \
    libnuma-dev libpcap-dev pkg-config

# 소스 다운로드 및 빌드
tar xf dpdk-24.11.tar.xz && cd dpdk-24.11
meson setup build
# 또는 옵션 지정:
meson setup build \
  -Dplatform=native \
  -Dexamples=l2fwd,l3fwd,testpmd \
  -Dmax_ethports=32 \
  -Ddisable_drivers=net/bnxt,net/enic \
  -Ddefault_library=shared
ninja -C build
ninja -C build install
ldconfig

# pkg-config로 DPDK 연동 확인
pkg-config --cflags --libs libdpdk

# ━━━ 애플리케이션 빌드 (Meson 연동) ━━━
# meson.build 예시:
# project('my_app', 'c')
# dpdk_dep = dependency('libdpdk')
# executable('my_app', 'main.c', dependencies: dpdk_dep)

코어 빌드 옵션 상세

Meson 빌드 시스템에서 -D옵션=값 형태로 지정하는 핵심 빌드 옵션의 전체 목록입니다. meson configure build 명령으로 현재 설정을 확인할 수 있습니다.

드라이버·라이브러리 선택 옵션

DPDK는 200개 이상의 PMD(Poll Mode Driver)를 포함하며, 불필요한 드라이버를 제외하면 빌드 시간과 바이너리 크기를 크게 줄일 수 있습니다.

# ━━━ 최소 드라이버 빌드 (mlx5 + virtio만) ━━━
meson setup build \
  -Denable_drivers=net/mlx5,net/virtio,common/mlx5 \
  -Ddisable_libs=pipeline,table,port,fib,rib,reorder \
  -Ddisable_apps=test \
  -Dplatform=generic \
  -Ddefault_library=static \
  -Db_lto=true

크기 제한 및 리소스 상수

DPDK의 내부 자료 구조 크기를 컴파일 타임에 결정하는 상수입니다. 기본값은 범용 서버를 기준으로 설정되어 있으며, 임베디드 환경이나 대규모 NIC 환경에서는 조정이 필요합니다.

기능 토글 옵션

빌드에 포함할 기능을 세밀하게 제어하는 옵션입니다.

크로스 컴파일 설정

DPDK는 Meson의 크로스 컴파일 파일(cross-file)을 사용하여 ARM, RISC-V 등 다양한 아키텍처용 빌드를 지원합니다.

# ━━━ ARM64 크로스 컴파일 파일 (aarch64_cross.txt) ━━━

[binaries]
c = 'aarch64-linux-gnu-gcc'
cpp = 'aarch64-linux-gnu-g++'
ar = 'aarch64-linux-gnu-ar'
strip = 'aarch64-linux-gnu-strip'
pkgconfig = 'aarch64-linux-gnu-pkg-config'

[host_machine]
system = 'linux'
cpu_family = 'aarch64'
cpu = 'armv8-a'
endian = 'little'

[properties]
platform = 'generic'
cpu_instruction_set = 'generic'

# ━━━ 크로스 컴파일 빌드 명령 ━━━

# ARM64 크로스 컴파일 (BlueField DPU 등)
meson setup build-arm64 \
  --cross-file config/arm/arm64_bluefield_platform \
  -Dplatform=generic \
  -Denable_drivers=net/mlx5,common/mlx5,regex/mlx5,vdpa/mlx5 \
  -Ddefault_library=static

ninja -C build-arm64
DESTDIR=/opt/dpdk-arm64 ninja -C build-arm64 install

# RISC-V 크로스 컴파일 (실험적, DPDK 23.11+)
meson setup build-riscv \
  --cross-file config/riscv/riscv64_linux_gcc \
  -Dplatform=generic

ninja -C build-riscv

make → Meson 전환 매핑

DPDK 21.11에서 make 빌드가 제거되었습니다. 기존 CONFIG_RTE_* 환경 변수와 대응하는 Meson 옵션 매핑입니다.