Rust 임베디드: LWIP 소켓 버퍼 최적화를 통한 초고속 센서 데이터 스트리밍

2026년, 임베디드 시스템은 과거와 달리 고성능 센서와 복잡한 AI 추론 엔진을 탑재하며 ‘엣지’의 역할이 더욱 중요해졌다. 특히 자율주행, 산업 자동화 등 실시간성이 요구되는 애플리케이션에서는 수많은 센서 데이터가 초고속으로 스트리밍되어야 한다. 이 과정에서 임베디드 보드의 제한적인 리소스 위에 동작하는 네트워크 스택의 성능은 병목 지점이 되기 쉽다.

본 포스트에서는 Rust 기반의 고성능 임베디드 시스템에서 LWIP(Lightweight IP) 네트워크 스택을 사용하여 초고속 센서 데이터를 스트리밍할 때 발생할 수 있는 성능 문제를 진단하고, 핵심적인 LWIP 소켓 버퍼 파라미터 튜닝을 통해 최적의 성능을 확보하는 엔지니어링 접근법을 다룬다.

문제 정의: 왜 기본 LWIP 설정은 부족한가?

최근 개발 중인 자율주행 센싱 모듈은 Rust로 구현된 STM32H7 기반 펌웨어 위에서 LiDAR 및 초음파 센서 데이터를 통합 처리하고, 이를 실시간으로 로컬 엣지 서버에 UDP/TCP를 통해 전송해야 했다. 500Hz 이상의 주기로, 매 주기당 수십 KB에서 수백 KB에 달하는 데이터를 전송하는 요건이었다.

초기 LWIP 기본 설정으로 동작시켰을 때, 다음과 같은 문제가 발생했다.

데이터 손실: UDP 전송 시 간헐적인 패킷 손실이 발생했다.
높은 지연 시간: TCP 전송 시에도 평균 지연 시간이 예상보다 높게 측정되었으며, 특정 구간에서는 지연 시간 스파이크가 관찰되었다.
CPU 사용률: 네트워크 관련 CPU 사용률이 비정상적으로 높게 나타났다.

이는 LWIP의 기본 버퍼 설정이 범용적인 저사양 임베디드 환경에 맞춰져 있어, 고대역폭 및 실시간성이 요구되는 현대 임베디드 시스템에는 부적합하다는 것을 시사한다.

원리 분석: LWIP 버퍼 관리의 이해

LWIP는 자체적인 메모리 관리 시스템과 PBUF(Packet Buffer)를 통해 네트워크 패킷을 처리한다. 데이터 스트리밍 성능에 직접적인 영향을 미치는 주요 파라미터는 다음과 같다.

PBUF: LWIP의 기본 패킷 단위. PBUF_POOL_SIZE는 PBUF 풀의 개수, PBUF_POOL_BUFSIZE는 각 PBUF의 크기를 결정한다. 너무 작으면 패킷 분할(fragmentation)이 잦아지고, 너무 크면 메모리 낭비가 심하다.
MEM_SIZE: LWIP가 사용할 수 있는 전체 힙 메모리 크기. 소켓 구조체, TCP 제어 블록 등 다양한 내부 객체에 사용된다.
TCP Send/Receive Buffer (TCP_SND_BUF, TCP_WND):
- TCP_SND_BUF: TCP 소켓이 보낼 데이터를 저장하는 송신 버퍼의 크기. 이 버퍼가 가득 차면 애플리케이션은 블로킹되거나 ERR_MEM 오류를 받는다.
- TCP_WND: TCP 수신 윈도우 크기. 수신 측이 한 번에 받을 수 있는 최대 데이터 양을 나타낸다. 전송 효율과 흐름 제어에 중요하며, TCP_SND_BUF보다 크거나 같아야 이상적이다.
UDP Send/Receive MBOX (UDP_SNDBOX, UDP_RECVMBOX):
- UDP_SNDBOX: UDP 소켓의 송신 메시지 큐 크기 (메시지 수).
- UDP_RECVMBOX: UDP 소켓의 수신 메시지 큐 크기 (메시지 수). 너무 작으면 수신 버퍼 오버플로우로 인한 패킷 손실이 발생한다.
ARP Table Size (LWIP_ARP_TABLE_SIZE): ARP 캐시 크기. 자주 통신하는 호스트가 많을 경우 중요한 파라미터.

이 파라미터들은 lwipopts.h 파일에서 컴파일 시점에 정의되며, Rust 임베디드 환경에서는 보통 build.rs 스크립트나 외부 빌드 시스템을 통해 이 파일을 커스터마이징하여 사용한다.

최적화 전략 및 구현

우리의 목표는 최소한의 메모리 사용으로 최대의 처리량을 달성하고, 지연 시간을 최소화하는 것이다. 다음 단계를 통해 튜닝을 진행했다.

기본 데이터 스트림 분석: 평균 패킷 크기, 최대 패킷 크기, 초당 전송량 등을 먼저 파악한다. 우리 시스템에서는 최대 200KB의 데이터를 하나의 논리적 블록으로 전송해야 했고, 이를 여러 PBUF으로 분할 전송하는 방식을 사용했다.
PBUF 및 MEM_SIZE 증대: PBUF 풀의 크기와 PBUF 개당 크기를 늘려 패킷 분할 오버헤드를 줄였다. 또한, MEM_SIZE를 충분히 확보하여 LWIP 내부 구조체 할당에 문제가 없도록 했다.
- PBUF_POOL_SIZE: 기본 16에서 64로 증대
- PBUF_POOL_BUFSIZE: 기본 1518(MTU)에서 2048 또는 4096으로 증대 (최대 패킷 크기와 MTU를 고려)
- MEM_SIZE: 16KB에서 64KB 또는 128KB로 증대
TCP 버퍼 튜닝: TCP_SND_BUF와 TCP_WND를 전송해야 할 데이터 블록 크기 이상으로 설정했다.
- 예를 들어, 200KB 데이터를 한 번에 전송해야 한다면, TCP_SND_BUF를 최소 256KB(262144) 이상으로 설정한다.
- TCP_WND도 TCP_SND_BUF와 같거나 그 이상으로 설정하여 수신 측의 윈도우 흐름 제어로 인한 전송 중단을 최소화했다.
UDP 메시지 큐 튜닝: UDP의 경우 신뢰성 보장은 없지만, 송신 큐와 수신 큐의 크기를 충분히 확보하여 애플리케이션 레벨에서의 데이터 처리 속도와 네트워크 전송 속도 간의 불균형으로 인한 손실을 줄였다.
- UDP_RECVMBOX: 수신 버퍼 오버플로우 방지를 위해 8에서 32 또는 64로 증대.

`lwipopts.h` 예시 (일부 발췌)

#ifndef LWIP_HDR_LWIPOPTS_H
#define LWIP_HDR_LWIPOPTS_H

/* Memory options */
#define MEM_ALIGNMENT           4
#define MEM_SIZE                (128 * 1024) // 128KB
#define MEMP_NUM_PBUF           256          // PBUF 풀 개수 증대
#define MEMP_NUM_TCP_PCB        16
#define MEMP_NUM_RAW_PCB        4
#define MEMP_NUM_UDP_PCB        16
#define MEMP_NUM_NETBUF         32
#define MEMP_NUM_NETCONN        32

/* PBUF options */
#define PBUF_POOL_SIZE          64           // PBUF 풀 개수 증대
#define PBUF_POOL_BUFSIZE       4096         // 각 PBUF 버퍼 크기 4KB

/* TCP options */
#define LWIP_TCP                1
#define TCP_MSS                 1460         // 표준 이더넷 MTU에 맞춰 1460
#define TCP_WND                 (256 * 1024) // 256KB 수신 윈도우
#define TCP_SND_BUF             (256 * 1024) // 256KB 송신 버퍼
#define TCP_SND_QUEUELEN        (4 * TCP_SND_BUF / TCP_MSS)

/* UDP options */
#define LWIP_UDP                1
#define UDP_RECVMBOX            64           // UDP 수신 메시지 큐 64개
#define UDP_SNDBOX              32           // UDP 송신 메시지 큐 32개

/* Other options */
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_ARP                1
#define LWIP_ARP_TABLE_SIZE     32           // ARP 테이블 크기 증대

#endif /* LWIP_HDR_LWIPOPTS_H */

Rust 애플리케이션에서의 데이터 전송 로직 (개념적)

Rust 애플리케이션은 lwip-sys나 rust-lwip 같은 크레이트를 통해 LWIP와 상호작용한다. 중요한 점은, LWIP의 송신 버퍼가 가득 찼을 때 lwip_send()와 같은 함수 호출이 EAGAIN 또는 ERR_MEM을 반환할 수 있으므로, 재시도 로직이나 백프레셔(backpressure) 메커니즘을 구현하는 것이 중요하다.

// 개념적인 Rust 코드 스니펫 (실제 구현은 LWIP 바인딩에 따라 달라질 수 있음)
fn send_sensor_data(socket: &mut UdpSocket, data: &[u8], remote_addr: IpAddr) -> Result<(), LwipError> {
    const MAX_RETRIES: usize = 10;
    for i in 0..MAX_RETRIES {
        match socket.send_to(data, remote_addr) {
            Ok(_) => return Ok(()),
            Err(LwipError::Mem) | Err(LwipError::Buf) => {
                // LWIP 내부 버퍼 부족. 잠시 대기 후 재시도
                cortex_m::asm::delay(1_000); // 1ms 대기 (예시)
                if i == MAX_RETRIES - 1 {
                    return Err(LwipError::Mem); // 최종적으로 실패
                }
            },
            Err(e) => return Err(e), // 다른 에러는 즉시 반환
        }
    }
    unreachable!(); // Should not be reached
}

결과 및 학습

상기 버퍼 튜닝을 적용한 결과, 센서 데이터 스트리밍 성능은 획기적으로 개선되었다.

UDP 데이터 손실: 거의 0%에 수렴했다. 간헐적으로 발생하는 손실은 네트워크 물리 계층의 노이즈나 수신 서버의 문제로 판단되었다.
TCP 지연 시간: 평균 지연 시간이 50% 이상 감소했으며, 지연 시간 스파이크 현상도 크게 완화되었다.
CPU 사용률: 네트워크 관련 CPU 사용률이 안정화되어 다른 태스크에 할당 가능한 CPU 리소스가 증가했다.

이러한 결과는 LWIP와 같은 경량 네트워크 스택을 사용할 때, 단순히 코드를 작성하는 것을 넘어 내부 아키텍처와 버퍼 관리 메커니즘을 깊이 이해하고 애플리케이션의 특성에 맞춰 최적화하는 것이 얼마나 중요한지를 보여준다. 특히 Rust 임베디드 환경에서는 unsafe 블록을 통한 직접적인 메모리 접근을 최소화하고, 안전한 추상화를 통해 LWIP를 제어하면서도 성능을 놓치지 않기 위한 세심한 설계가 요구된다.

결론

임베디드 시스템에서 고성능 네트워크 통신을 요구하는 현대적인 애플리케이션은 단순히 LWIP와 같은 스택을 ‘사용’하는 것을 넘어, ‘튜닝’하고 ‘최적화’하는 엔지니어의 역량이 필수적이다. lwipopts.h의 파라미터들을 애플리케이션 요구사항과 시스템 리소스에 맞춰 신중하게 조절함으로써, 우리는 제한된 임베디드 환경에서도 초고속 데이터 스트리밍과 같은 고성능 요구사항을 만족시킬 수 있었다. 앞으로도 이와 같은 저수준 네트워크 스택 최적화는 엣지 컴퓨팅의 성능 한계를 극복하는 핵심 열쇠가 될 것이다.

DevBJ | No Bio, Just Log 기술 삽질로그

Rust 임베디드: LWIP 소켓 버퍼 최적화를 통한 초고속 센서 데이터 스트리밍