자율주행/로보틱스 기술 스택 완전 정복: C++, ROS2, CUDA, TensorRT부터 VLM/VLA, 시뮬레이션까지

┌────────────────────────────────────────────────────────────────┐
│                    자율주행 기술 스택 전체 구조                    │
│                                                                │
│  ┌──────────┐  ┌───────────┐  ┌───────────┐  ┌──────────────┐ │
│  │ 센서 계층 │  │ 인식 계층  │  │ 판단 계층  │  │  제어 계층    │ │
│  │ GPS/IMU  │→│ CV/DL     │→│ Planning  │→│ Control      │ │
│  │ Camera   │  │ 센서 퓨전  │  │ Prediction│  │ CAN/Ethernet │ │
│  │ LiDAR    │  │ VLM/VLA   │  │           │  │              │ │
│  └──────────┘  └───────────┘  └───────────┘  └──────────────┘ │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │ 인프라 계층: C++ | ROS2 | CUDA | TensorRT | Cloud/MLOps │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │ 검증 계층: SIL/HIL | Simulation(CARLA/Isaac) | VR/AR    │  │
│  └──────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────┘

// Concepts: 타입 안전한 센서 인터페이스
template<typename T>
concept Sensor = requires(T s) {
    { s.read() } -> std::convertible_to<SensorData>;
    { s.calibrate() } -> std::same_as<bool>;
};

// Ranges: 센서 데이터 파이프라인
auto obstacles = pointCloud
    | views::filter(isAboveGround)
    | views::transform(toWorldFrame)
    | views::take(maxObstacles);

// Coroutines: RTOS 오버헤드 없는 협력적 멀티태스킹
// co_await, co_yield로 비동기 I/O 처리

✗ Hot path에서 동적 메모리 할당 → ✓ std::pmr 할당자 또는 사전 할당 풀
✗ 실시간 제어 루프에서 예외 → ✓ std::expected 또는 에러 코드
✗ 뮤텍스 기반 통신 → ✓ std::atomic, lock-free 자료구조
✗ 기본 스케줄링 → ✓ SCHED_FIFO / SCHED_RR (POSIX)

Front Camera ──┐
Left Camera  ──┤
Right Camera ──┼──→ [BEV Feature Space] ──→ 3D Detection
Rear Camera  ──┤                            Lane Detection
Side Cameras ──┘                            Occupancy Prediction

인식 진화 경로:
CNN (2011-2016) → RNN+GAN (2016-2018) → BEV (2018-2020)
→ Transformer+BEV (2020-현재) → Occupancy (2022-현재) → End-to-End VLA (2024-현재)

행동 출력 방식 비교:

RT-2 방식 (Action Tokenization):
  "move arm" → LLM → [토큰256] [토큰128] [토큰064] → 이산 행동

pi0 방식 (Flow Matching):
  "move arm" → VLM → Flow Expert → 연속적 벡터 필드 → 부드러운 행동

┌─────────────────────────────────────────────┐
│              CUDA 메모리 계층                  │
│                                              │
│  레지스터 (스레드당)                            │
│    ↓                                         │
│  공유 메모리 (블록당, ~48-164KB)               │
│    ↓                                         │
│  L2 캐시                                     │
│    ↓                                         │
│  글로벌 메모리 (VRAM)                          │
│                                              │
│  스레드 → 워프(32개) → 블록(최대1024) → 그리드   │
└─────────────────────────────────────────────┘

최적화 전: Conv → BatchNorm → ReLU (3개 커널 실행)
최적화 후: Conv+BN+ReLU (1개 커널 실행)

효과: 커널 실행 오버헤드 최대 80% 감소
      메모리 대역폭 최대 50% 감소
      처리량 ~30% 향상

PyTorch Model
  → ONNX Export (torch.onnx.export)
  → TensorRT Builder (trtexec 또는 Python API)
    → 그래프 최적화 + 레이어 퓨전
    → 정밀도 캘리브레이션 (INT8/FP8)
    → 커널 자동 튜닝
  → 직렬화된 엔진 (.engine 파일)
  → TensorRT Runtime (추론)

Large Teacher (FP32)
  → Knowledge Distillation → Smaller Student
  → Structured Pruning → 채널/헤드 제거
  → QAT Fine-tuning → INT8/FP8
  → TensorRT Export → 퓨전·최적화 엔진

Predict (예측):  x̂ₖ|ₖ₋₁ = F·x̂ₖ₋₁ + B·uₖ
                 Pₖ|ₖ₋₁ = F·Pₖ₋₁·Fᵀ + Q

Update (보정):   Kₖ = Pₖ|ₖ₋₁·Hᵀ·(H·Pₖ|ₖ₋₁·Hᵀ + R)⁻¹
                 x̂ₖ = x̂ₖ|ₖ₋₁ + Kₖ·(zₖ - H·x̂ₖ|ₖ₋₁)

┌──────────────────────────────────────────────────┐
│                    SIL 환경                        │
│                                                   │
│  [인식 알고리즘] ←→ [센서 시뮬레이션]               │
│  [계획 알고리즘] ←→ [시나리오 엔진]                 │
│  [제어 알고리즘] ←→ [차량 역학 모델]                │
│                                                   │
│  실행 환경: Host PC (x86)                          │
│  물리 하드웨어: 없음                                │
│  반복 속도: 초~분                                   │
│  CI/CD 통합: 가능 (클라우드 병렬화)                  │
└──────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────┐
│                    HIL 환경                        │
│                                                   │
│  [실제 ECU (DUT)] ←→ [HIL 시뮬레이터]              │
│                       ├ 차량 역학 모델              │
│                       ├ 센서 신호 주입 (HDMI/ETH)  │
│                       ├ 버스 시뮬레이션 (CAN/ETH)   │
│                       └ 고장 주입                   │
│                                                   │
│  실행 환경: 실제 타겟 하드웨어 (Orin, EyeQ 등)      │
│  실시간: 하드웨어 클록 레이트                        │
│  ISO 26262: 기능 안전 인증에 필수                    │
└──────────────────────────────────────────────────┘

MIL (Model-in-the-Loop)     — MATLAB/Simulink 프로토타이핑
  → SIL                      — Host PC + 시뮬레이션 환경
    → PIL (Processor-in-the-Loop) — 타겟 프로세서 컴파일, Host 실행
      → HIL                  — 타겟 ECU + 시뮬레이션 환경
        → VIL (Vehicle-in-the-Loop) — 실차 + 시나리오 주입
          → Road Testing     — 실차 + 실환경

# CARLA Docker 실행
docker pull carlasim/carla:0.9.15
docker run --privileged --gpus all --net=host \
    carlasim/carla:0.9.15 /bin/bash ./CarlaUE4.sh

# Python API로 시나리오 제어
pip install carla

import carla

client = carla.Client('localhost', 2000)
world = client.get_world()

# 차량 스폰
blueprint = world.get_blueprint_library().find('vehicle.tesla.model3')
spawn_point = world.get_map().get_spawn_points()[0]
vehicle = world.spawn_actor(blueprint, spawn_point)

# 카메라 센서 부착
camera_bp = world.get_blueprint_library().find('sensor.camera.rgb')
camera = world.spawn_actor(camera_bp, carla.Transform(), attach_to=vehicle)

┌─────────────────────────────────────────────────────────────────┐
│                     자율주행 풀 스택                               │
│                                                                  │
│  1. Sensing         센서 드라이버, 시간 동기화, 로깅               │
│       ↓                                                          │
│  2. Localization    HD Map 매칭, V-SLAM, LiDAR SLAM, GNSS/IMU   │
│       ↓              → 6-DOF 차량 자세 (100+ Hz)                  │
│  3. Perception      3D 검출, 추적, 시맨틱 세그멘테이션, Occupancy  │
│       ↓              → 3D 바운딩 박스, 트랙 ID, 시맨틱 맵          │
│  4. Prediction      에이전트 미래 궤적 예측 (3-8초)                │
│       ↓              → 에이전트별 다중 모드 궤적                    │
│  5. Planning        경로 계획, 행동 계획, 모션 계획                │
│       ↓              → 궤적 (자세 + 속도 시퀀스)                   │
│  6. Control         횡방향(조향) + 종방향(가감속) 제어              │
│       ↓              → CAN 명령 (steer-by-wire, brake-by-wire)   │
└─────────────────────────────────────────────────────────────────┘

차량 (Edge)
  → 셀룰러/WiFi로 원시 로그 업로드
  → Object Storage (S3/GCS/Azure Blob)
  → 데이터 카탈로그 & 인덱싱 (시나리오 마이닝)
  → 자동 어노테이션 (기존 모델로 사전 라벨링)
  → 인간 어노테이션 (검증, 코너 케이스)
  → 데이터셋 버전 관리 (DVC, LakeFS)
  → 학습 클러스터
  → 모델 레지스트리
  → 검증 파이프라인 (오프라인 메트릭, SIL)
  → OTA 배포

A/B 파티션: 비활성 파티션 업데이트 → 재부팅 시 전환
Delta 업데이트: 변경 바이트만 전송 (100-500MB vs 10+GB)
Staged 롤아웃: 1% → 모니터링 → 점진적 확대
Rollback: 이상 감지 시 이전 버전 복원

모델 배포 → 실주행 데이터 수집 → 실패 사례 자동 마이닝
→ 어노테이션 추가 → 재학습 → SIL 검증 → A/B 테스트 → 전체 배포
→ [반복]