6.7 외부 라이브러리 및 C++ 생태계와의 통합

6.7 외부 라이브러리 및 C++ 생태계와의 통합

C++ 은 그 자체만으로 무언가를 해내기보다는, 수백 개의 써드파티 라이브러리를 하나로 접착시키는 거대한 ’풀(Glue)’의 성격을 띤 언어다. Zenoh는 뼛속까지 네트워크 전송 계층(Transport Layer)이므로, 데이터의 포맷팅(직렬화)이나 그래픽 렌더링(GUI UI)에 대해서는 완벽하게 침묵한다. 결국 모든 것은 C++ 개발자의 아키텍처 역량에 달렸다.

이 장에서는 글로벌 표준 페이로드인 Protobuf / FlatBuffers 로 메시지를 굽는 법, 메이저 비동기 런타임인 Boost.Asio의 이벤트 루프 안에 Zenoh의 통신망을 매끄럽게 끼워 넣는 법, 그리고 Qt나 ImGui 같은 프레임워크 환경에서 콜백 함수가 UI 렌더링 스레드를 갉아먹거나 데드락(Deadlock)에 빠지지 않도록 우회하는 프론트엔드 연동 런북을 서술한다.

1. Protocol Buffers(Protobuf)를 이용한 데이터 포맷팅 및 직렬화

구글이 낳은 C++ 생태계의 표준 직렬화 압축 병기. JSON으로 파싱하면 300바이트가 될 센서 데이터를 20바이트의 압축된 바이너리로 떨어트리며, 버전을 올려도 하위 호환성(Backward Compatibility)을 보장하는 신의 도구다.

1.0.1 [Runbook] Protobuf - Zenoh 종단 간 파이프라인

robot.proto 파일을 통해 컴파일된 RobotState C++ 클래스가 있다고 가정하자.

1. [송신] Protobuf -> Zenoh Payload 직렬화
C++의 std::string은 단지 텍스트뿐만 아니라 널(Null) 바이트를 포함한 이진 배열(Binary)을 훌륭하게 담는 그릇이다. Protobuf는 SerializeToString() API를 통해 배열 복사를 최적화한다.

#include "robot.pb.h"
#include "zenoh.hxx"

void publish_robot_state(zenoh::Publisher& pub, int id, float battery) {
    // 1. Protobuf 객체 조립
    robo::RobotState state;
    state.set_id(id);
    state.set_battery(battery);

    // 2. 바이트(String 덤프) 직렬화
    std::string serialized_data;
    if (!state.SerializeToString(&serialized_data)) {
        std::cerr << "직렬화 인코딩 실패!" << std::endl;
        return;
    }

    // 3. Zenoh 망으로 구겨 넣기!
    pub.put(serialized_data);
}

2. [수신] Zenoh ZBuf -> Protobuf 역직렬화 복원
Zenoh는 조각난 배열체(get_payload())를 주므로, Protobuf의 ParseFromArray()나 일자 문자열(as_string())로 넘겨서 해결한다.

auto sub = session.declare_subscriber("fleet/state", [](const%20zenoh::Sample&%20sample) {
    auto payload_str = sample.get_payload().as_string();

    robo::RobotState state;
    // 1. 1줄 파싱 체인: 바이트 -> Protobuf 멤버 변수들
    if (state.ParseFromString(payload_str)) {
        std::cout << "복원 성공 [로봇 " << state.id() << "] 배터리: " << state.battery() << std::endl;
    } else {
        std::cerr << "손상된 패킷 혹은 구형 스키마의 메시지 유입" << std::endl;
    }
});

이 조합이면 백엔드 gRPC 생태계와 100% 바이너리 호환이 되며, C++, Rust, Python 등 서로 다른 언어들이 완벽한 규격서(proto)를 공유하게 된다.

2. FlatBuffers 및 CDR(Common Data Representation)과의 연동

초당 10만 번씩 날아오는 데이터에서, 데이터를 풀어서 치환(역직렬화)하는 시간조차 아까운 자율주행 센서나 고주파수(HFT) 도메인은 Protobuf 마저도 거부한다. 왜냐하면 Protobuf는 파싱할 때 내부 메모리에 C++ 객체(Struct) 트리를 100% 새로 생성(Allocation)하기 때문이다.

이를 부수기 위한 무기가 역직렬화를 아예 하지 않고 날아온 바이트 그 자체에 포인터만 던져서 데이터를 읽어내는 FlatBuffers 와 로보틱스 전통의 Fast-CDR이다.

2.0.1 [Runbook] FlatBuffers 제로 역직렬화(Zero-Deserialization) 전술

FlatBuffers의 목적은 바이트 스트림을 받는 즉시 “추출 오버헤드 0“으로 값을 찍어 누르는 것이다. 송수신 양쪽 시스템의 바이트 패딩이 통일되어야 한다.

[수신부 극한 튜닝: Pointer Casting 체제]
네트워크에서 온 바이트 파편들을 std::vector 로 이어 붙인 다음, 파싱 함수 호출 없이 곧바로 읽어버린다.

#include "monster_generated.h" // FlatBuffers 컴파일 타임 생성 헤더
#include "zenoh.hxx"

auto sub = session.declare_subscriber("game/monster", [](const%20zenoh::Sample&%20sample) {
    // 1. Zenoh 덩어리를 1열 횡대 바이트로 통일
    auto chunk = sample.get_payload().as_vector();

    // 2. 단 1의 CPU 복사나 객체 생성도 없음!
    // 도착한 메모리(chunk.data())의 특정 주소 번지를 'Monster' 구조체처럼 취급하겠다고 선언!
    auto monster = GetMonster(chunk.data());

    // 3. 필드 접근. 구조체를 푼 게 아니라, 이순간 바이너리의 N번째 바이트 공간을 찍어서 바로 읽는다!
    std::cout << "도착한 몬스터 체력: " << monster->hp() << std::endl;
});

특히 ROS2 미들웨어 브릿지를 개발하거나, Jetson NANO 같은 모바일 GPU 보드에서 배터리를 수호해야 할 때 FlatBuffers 나 CDR (C++ eProsima Fast CDR) 과 Zenoh의 결합은 현존하는 로컬/원격 통신 체계 중에서 정점에 오를 수밖에 없는 필연적인 메커니즘이다.

3. Boost.Asio 등 비동기 I/O 이벤트 루프와의 통합 아키텍처

당신이 들어간 회사에 이미 Boost.Asio 로 도배된 수십만 줄의 비동기 네트워크/타이머 코드가 돌고 있다고 가정하자.
여기에 Zenoh를 추가할 때 아무 생각 없이 Zenoh의 declare_subscriber 콜백 안에서 무거운 로직을 돌리거나 wait() 를 걸어버리면, Boost 스레드 풀(Thread Pool)과 Zenoh의 백그라운드 스레드가 서로를 공격하며 최악의 스레드 기아 상태(Thread Starvation)를 초래한다.

3.0.1 [Runbook] Asio IO_Context로 Zenoh 작업 위임격리 설계

Zenoh 콜백 워커에서 오래 머물게 하지 마라. Zenoh 백그라운드에서 패킷을 낚아챈 즉시, Boost.Asio 의 메인 이벤트 루프 큐(io_context::post) 로 작업을 밀어 넘겨버리는 아키텍처 분리 전술이다.

#include <boost/asio.hpp>
#include <iostream>
#include "zenoh.hxx"

// 전역 또는 싱글톤 앱 컨텍스트에 Asio 심장을 묶어둠
boost::asio::io_context g_io_context;

void run_zenoh_to_asio_bridge(zenoh::Session& session) {
    auto sub = session.declare_subscriber(
        "heavy/computation/task", 
        // [위험구역] 이 람다는 무작위의 Zenoh 내부 스레드에서 호명된다!
        [](const%20zenoh::Sample&%20sample) {
            std::string payload = sample.get_payload().as_string();
            
            // 여기서 AI 연산이나 DB 쓰기를 돌리면 Zenoh 라우터망 전체가 블록된다!!
            // 따라서 0.01ms 만에 Asio의 스케줄러 망으로 작업을 '기명 투척(Post)' 한다.
            
            boost::asio::post(g_io_context, [data = std::move(payload)]() {
                // [안전구역] 이 람다는 돌고 돌아서 오직 Asio를 구동하는 전담 스레드풀에서만 실행됨
                std::cout << "[Asio Worker] 수신된 태스크 처리 시작: " << data << std::endl;
                // 무거운 파일 I/O 나 DB 쿼리를 자유자재로 실행.
            });
        }
    );
}

int main() {
    auto session = zenoh::Session::open(zenoh::Config::create_default());
    run_zenoh_to_asio_bridge(session);

    // [시스템 심장] 메인 스레드는 Boost의 asio run() 루프에 평생 자신을 헌납한다.
    // Asio는 백그라운드에서 넘어온 Zenoh 일감을 큐에서 빼내 열심히 처리한다.
    g_io_context.run();

    return 0;
}

이 패턴은 Qt, 언리얼 엔진(Unreal Engine), 로시(ROS) 등 C++ 생태계에 존재하는 수많은 “자체 메인 루프(Main Event Loop)” 시스템들과 Zenoh를 충돌 없이 결합하는 이른바 만능 열쇠(Golden Key)가 된다.

4. Qt, ImGui 등 GUI 프레임워크 기반 C++ 애플리케이션에서의 Zenoh 활용

화면에 예쁜 게이지와 카메라 연동 모니터를 붙이기 위해 C++ 프론트엔드(Qt, ImGui)를 띄웠다 치자.
가장 많이 하는 초보적인 실수는 Zenoh Subscriber 콜백 람다 안에서 곧바로 UI 함수(예: label->setText(data))를 때리는 짓이다.
대차게 코어 덤프(Core Dump) 혹은 화면 멈춤(Freeze) 이 일어난다. GUI 시스템은 반드시 ’메인 UI 쓰레드’에서만 화면 그래픽 포인터를 수정하도록 강제하는 스레드 배타성 구조를 갖고 있기 때문이다.

4.0.1 [Runbook] 백그라운드 Zenoh 데이터를 메인 UI 캔버스로 안전하게 배달하기

메인 렌더링 스레드를 해치지 않으면서(Lock-free Buffer) 초당 60프레임의 데이터를 넘기는 런북.

[ImGui 적용 시나리오]
게임 엔진이나 로보틱스 관제에서 많이 쓰이는 매 프레임 업데이트 방식의 ImGui 렌더링 파이프파인.

#include <mutex>
#include <string>
#include "zenoh.hxx"
#include "imgui.h" // 가상의 ImGui 엔진

// 스레드 간 교환용 배달함 (스마트 포인터 락 추천)
std::mutex g_ui_mutex;
std::string g_latest_robot_status = "Waiting...";

void init_zenoh_backend(zenoh::Session& session) {
    auto sub = session.declare_subscriber("robot/status", [](const%20zenoh::Sample&%20s) {
        // [동기화 배관 시작] Zenoh의 무작위 스레드가 자물쇠를 연다
        std::lock_guard<std::mutex> lock(g_ui_mutex);
        g_latest_robot_status = s.get_payload().as_string();
    });
}

// 메인 함수 - 즉 UI를 그리는 그래픽 렌더 큐 (보통 초당 60번 실행됨)
void main_loop() {
    auto session = zenoh::Session::open(zenoh::Config::create_default());
    init_zenoh_backend(session);

    while(true) { // 60 프레임 루프
        // 1. UI 렌더링 전, 배달함에서 제일 최신 데이터만 번개같이 복사(Copy) 해온다
        std::string current_status;
        {
            std::lock_guard<std::mutex> lock(g_ui_mutex);
            current_status = g_latest_robot_status; // 여기서 화면 렌더링을 하면 데드락 걸린다!
        }
        
        // 2. 락(Lock)을 푼 안전 지대에서 ImGui 화면 그리기 호출
        ImGui::Begin("로봇 대시보드");
        ImGui::Text("현재 상태: %s", current_status.c_str());
        ImGui::End();

        // 렌더 컨텍스트 강제 (기타 백엔드 연산 및 sleep)
    }
}

[아키텍처 인스펙션: Qt 시그널 / 슬롯 시스템 활용]
만약 당신의 팀이 헤비급 프레임워크인 Qt5/6 를 쓰고 있다면, 굳이 Mutex 락을 팔 필요도 없다.
Zenoh의 백그라운드 람다 블록 안에서 QMetaObject::invokeMethod() 를 호출하여, 커스텀 Qt 시그널(Signal)에 페이로드를 담아 던지면 파이프라인(Event Queue)이 알아서 메인 렌더 스레드의 슬롯(Slot)까지 데이터를 택배 배달해 준다. 이것이 C++ 생태계의 거인 위에 올라타는 법이다.