본문으로 건너뛰기
Modern Embedded Recipes · 122/152

임베디드 포스트모템 분석 — Core Dump와 Field Crash

· Hawk · 5분 읽기

#한 줄 요약

“Crash는 현장에서 일어나지만 분석은 사무실에서 합니다.” 그 사이를 잇는 것이 coredump (Linux) 또는 mini-dump (MCU)입니다.

#어떤 상황에서 쓰나

Field에 배포된 device가 가끔 reboot합니다. 사용자는 “그냥 멈췄어요”라고만 합니다. 재현이 안 됩니다. 현장의 상태를 사무실로 가져오는 메커니즘이 필요합니다.

Linux 기반 device는 coredump, MCU 기반 device는 mini-dump 또는 last-gasp log 패턴을 씁니다. 둘 다 본질은 같습니다. Crash 순간의 register·memory·log를 압축해 그대로 가져오는 것.

#Linux Coredump

#활성화

Terminal window
# 기본은 비활성. systemd
sudo systemctl enable systemd-coredump.service
sudo systemctl start systemd-coredump.service
# 또는 직접
ulimit -c unlimited
echo "/var/crash/core.%e.%p.%t" | sudo tee /proc/sys/kernel/core_pattern
# 또는 단일 program
$ ulimit -c unlimited
$ ./my_program
Segmentation fault (core dumped)

coredumpctl list로 최근 coredump를 봅니다.

Terminal window
coredumpctl list
TIME PID UID GID SIG COREFILE EXE
Mon 10:23 5234 1000 1000 SIGSEGV present /usr/bin/my_program
coredumpctl debug 5234
# → gdb로 진입

#gdb로 coredump 분석

Terminal window
gdb /path/to/my_program /var/crash/core.my_program.5234.1700000000
(gdb) bt
#0 0x00007f1234567890 in process_input (data=0x0) at input.c:42
#1 0x00007f1234567abc in main (argc=1, argv=...) at main.c:78
(gdb) frame 0
(gdb) print data
$1 = (char *) 0x0
(gdb) list
40 char *p = data;
41 while (*p) { /* NULL deref */
42 process(*p++);
43 }

NULL pointer dereference가 즉시 보입니다. print / info locals로 변수 값도.

#Symbol과 source 매핑

Terminal window
# release build는 보통 strip됨
gcc -g -O2 -o my_program main.c # debug symbol 포함
# strip된 binary는 별도 symbol file 필요
objcopy --only-keep-debug my_program my_program.debug
strip my_program
gdb -s my_program.debug my_program core

Production에서는 strip된 binary를 배포하고, 사무실에 unstripped + debug-info를 보관.

#MCU Mini-dump 패턴

MCU에는 OS가 없으니 coredump system이 없습니다. 직접 만듭니다.

#Backup SRAM에 저장

#define DUMP_MAGIC 0xC0FFEE00
typedef struct {
uint32_t magic;
uint32_t reset_reason; /* RCC->CSR snapshot */
uint32_t pc, lr, psr;
uint32_t cfsr, hfsr, bfar, mmar;
uint32_t r0_r3[4];
uint32_t r12;
uint32_t stack[64]; /* fault 직전 stack top */
uint32_t log_tail; /* log ring tail */
uint8_t log[2048]; /* 최근 log */
} __attribute__((packed)) mini_dump_t;
void hardfault_save_dump(uint32_t *sp) {
mini_dump_t *d = (mini_dump_t*)BACKUP_SRAM;
d->magic = DUMP_MAGIC;
d->reset_reason = RCC->CSR;
d->r0_r3[0] = sp[0];
d->r0_r3[1] = sp[1];
d->r0_r3[2] = sp[2];
d->r0_r3[3] = sp[3];
d->r12 = sp[4];
d->lr = sp[5];
d->pc = sp[6];
d->psr = sp[7];
d->cfsr = *(volatile uint32_t*)0xE000ED28;
d->hfsr = *(volatile uint32_t*)0xE000ED2C;
d->bfar = *(volatile uint32_t*)0xE000ED38;
d->mmar = *(volatile uint32_t*)0xE000ED34;
memcpy(d->stack, sp, sizeof(d->stack));
memcpy(d->log, g_log_ring, sizeof(d->log));
d->log_tail = g_log_tail;
NVIC_SystemReset();
}

Backup SRAM, RP2040 watchdog scratch, NRF52 GPREGRET 등 reset에서 살아남는 영역에 저장.

#부팅 시 dump 확인 + 전송

void boot_check_dump(void) {
mini_dump_t *d = (mini_dump_t*)BACKUP_SRAM;
if (d->magic == DUMP_MAGIC) {
printf("Previous crash detected:\n");
printf("PC=0x%08lx CFSR=0x%08lx BFAR=0x%08lx\n",
d->pc, d->cfsr, d->bfar);
if (network_available()) {
send_dump_to_cloud(d, sizeof(*d));
} else {
store_dump_to_flash(d); /* 다음 connect 시 전송 */
}
d->magic = 0;
}
}

WiFi 있는 device는 즉시 cloud로, 없으면 flash에 두고 다음 boot에 전송.

#Memfault 패턴

Memfault SDK는 production에서 사용하는 상용 솔루션입니다. 오픈소스 대안의 base 패턴.

  1. Crash 시 register + stack + thread info를 coredump format으로 저장
  2. Reboot 후 chunk 단위로 cloud upload
  3. 서버에서 elf와 결합해 symbolicate
  4. 동일 root cause의 crash를 grouping
  5. 대시보드에서 firmware 버전별 crash rate 추적

핵심은 대량의 device에서 동일 crash를 자동 grouping하는 것입니다. Field 100대 중 5대가 같은 PC에서 reboot하면 한 그룹으로 묶입니다.

#Last-Gasp Logging

Crash 직전 1초의 로그가 가장 중요합니다. 평소에 RAM ring buffer에 적어두고 crash 시 NVRAM에 dump.

#define LAST_GASP_N 128
typedef struct {
uint32_t ts;
uint16_t code;
uint16_t arg;
} __attribute__((packed)) gasp_t;
static volatile gasp_t g_gasp[LAST_GASP_N];
static volatile uint16_t g_gasp_idx;
static inline void gasp_log(uint16_t code, uint16_t arg) {
uint16_t i = g_gasp_idx++ & (LAST_GASP_N - 1);
g_gasp[i].ts = DWT->CYCCNT;
g_gasp[i].code = code;
g_gasp[i].arg = arg;
}

Hot path에서 µs 단위로 부르고, crash dump에 ring 전체를 포함시킵니다. Host에서 ring을 풀어 마지막 128개 event를 시간 순으로 봅니다.

#RAM watchpoint 패턴 — Stack overflow 잡기

extern uint32_t _stack_bottom;
*(uint32_t*)&_stack_bottom = 0xCAFEDEAD;
void watch_stack(void) {
if (*(uint32_t*)&_stack_bottom != 0xCAFEDEAD) {
gasp_log(GASP_STACK_OVERFLOW, 0);
hardfault_save_dump(NULL);
}
}

타이머나 idle에서 주기적으로 호출. Overflow가 발생하는 순간은 아니지만 그 직후를 잡습니다.

#Reset Reason 분석

typedef enum {
RESET_POWER = 1 << 0,
RESET_PIN = 1 << 1,
RESET_SW = 1 << 2,
RESET_IWDG = 1 << 3,
RESET_WWDG = 1 << 4,
RESET_LOWPWR = 1 << 5,
RESET_BOR = 1 << 6,
} reset_reason_t;
reset_reason_t get_reset_reason(void) {
uint32_t csr = RCC->CSR;
reset_reason_t r = 0;
if (csr & RCC_CSR_PORRSTF) r |= RESET_POWER;
if (csr & RCC_CSR_PINRSTF) r |= RESET_PIN;
if (csr & RCC_CSR_SFTRSTF) r |= RESET_SW;
if (csr & RCC_CSR_IWDGRSTF) r |= RESET_IWDG;
if (csr & RCC_CSR_WWDGRSTF) r |= RESET_WWDG;
if (csr & RCC_CSR_LPWRRSTF) r |= RESET_LOWPWR;
if (csr & RCC_CSR_BORRSTF) r |= RESET_BOR;
RCC->CSR |= RCC_CSR_RMVF; /* clear */
return r;
}
Reason의미
RESET_POWER정상 부팅 (전원 인가)
RESET_PIN사용자가 reset 버튼
RESET_SW우리가 NVIC_SystemReset
RESET_IWDGIndependent watchdog → 코드 hang
RESET_WWDGWindow watchdog → timing 위반
RESET_BORBrown-out → 전압 dip
RESET_LOWPWRLow-power mode escape failure

Cloud에서 reset reason 분포를 보면 어떤 종류 crash가 흔한지 한눈에 보입니다. IWDG 50%, BOR 30%, hardfault 20%면 전원 또는 hang 문제가 우선.

#Field Debug — 원격 진단

USB 없이 ssh도 없는 device 어떻게 debug할까. 다음 옵션이 있다.

  1. NB-IoT / LTE-M / WiFi — 가벼운 telemetry
  2. BLE — 1m 거리에서 mobile app으로 dump 받기
  3. UART/SD card — 회수 후 분석
  4. 디바이스 자체에 dump-view UI

크리티컬한 device는 모든 reset마다 cloud에 reset reason과 mini-dump를 보냅니다. 한 사용자의 device에서만 발생하는 crash도 잡힙니다.

#Crash Grouping

다음 두 crash는 같은 bug입니다.

device-A: PC=0x08001234 CFSR=0x00008200 BFAR=0x00000004
device-B: PC=0x08001234 CFSR=0x00008200 BFAR=0x00000004
device-C: PC=0x08001236 CFSR=0x00008200 BFAR=0x00000004 ← PC가 약간 다름

PC가 정확히 일치 안 해도 같은 source line이면 같은 bug. addr2line으로 normalize한 다음 grouping.

Terminal window
addr2line -e firmware.elf 0x08001234 0x08001236
process_packet at packet.c:78
process_packet at packet.c:78

같은 line이면 같은 그룹.

#자주 보는 함정

Dump 영역을 normal RAM에 둠

mini_dump_t dump; /* .bss에 위치 → 부팅 시 0으로 clear */

.bss는 부팅 직후 0으로 초기화됩니다. no-init RAM 또는 backup SRAM에 둡니다.

__attribute__((section(".noinit"))) mini_dump_t dump;

Stack overflow로 dump 자체가 망가짐

Fault 진입 시 NVIC가 stack에 push 못 하면 더블 fault. Dump 코드는 fault entry 전에 작은 stack frame으로 동작해야 합니다.

__attribute__((naked))
void HardFault_Handler(void) {
__asm volatile (
"ldr sp, =_temp_dump_stack \n" /* fault용 별도 stack */
"b hardfault_save_dump \n"
);
}

Cloud 전송 실패 시 dump 잃음

전송 실패 가능성. Flash에 재전송 큐로 두고, 다음 connect 시 다시 시도.

Production에서 PII 포함

Coredump에는 RAM 전체가 들어갈 수 있어 사용자 데이터·암호가 노출됩니다. Field에서 어느 영역만 dump할지 명시. PII 영역은 dump 전에 zero로 wipe.

Symbol file 분실

Release 빌드의 .elf를 잃으면 0x08001234영원히 의미 없는 숫자. 모든 release elf를 영구 보관.

#정리

  • Linux는 systemd-coredump → gdb로 분석.
  • MCU는 mini-dump를 backup SRAM에 저장 → reboot 후 cloud 전송.
  • Mini-dump = register + stack + 최근 log + reset reason.
  • Last-gasp ring buffer로 crash 직전 event를 살립니다.
  • Reset reason flag (RCC->CSR)로 IWDG/BOR/SW reset을 구분.
  • PC를 source line으로 normalize해서 같은 bug를 grouping.
  • Strip된 binary와 unstripped + debug symbol을 같이 보관.
  • Dump 영역은 .noinit 또는 backup SRAM. .bss 금지.

다음 편은 FPGA 기초입니다.

#관련 항목

Modern Embedded Recipes · 123 of 152

  1. 1 Modern Embedded Recipes — 모던 임베디드 실전 레시피 시리즈 소개
  2. 2 디지털 신호 기초 — Voltage Level·Edge·Setup/Hold 분석
  3. 3 임베디드 클럭과 타이밍 — Skew·Jitter·PLL·MMCM 분석
  4. 4 GPIO 내부 구조 분해 — Push-Pull·Open-Drain·Schmitt Trigger
  5. 5 UART 하드웨어 동작 분석 — Baud Rate·Framing·FIFO
  6. 6 SPI 하드웨어 분석 — Clock Mode·MOSI/MISO·Chip Select
  7. 7 I2C 하드웨어 분석 — Open-Drain·Clock Stretching·Arbitration
  8. 8 ADC 동작 원리 — SAR·Sigma-Delta·Pipelined 비교
  9. 9 DAC 동작 원리 — R-2R Ladder·Sigma-Delta·Settling Time
  10. 10 PWM 신호 생성 분석 — Duty·Frequency·Dead Time·Center-Aligned
  11. 11 CAN 버스 전기적 특성 — Differential·Termination·Dominant/Recessive
  12. 12 RS-485·RS-422 차동 신호 분석 — Termination·Biasing·Topology
  13. 13 LVDS 차동 신호 분석 — Common-Mode·Impedance·Eye Pattern
  14. 14 ARM Cortex-M 시리즈 비교 — M0·M3·M4·M7·M33·M55 분석
  15. 15 ARM Cortex-A 시리즈 비교 — A53·A55·A72·A78·X1 분석
  16. 16 ARM 레지스터 구조 분석 — R0~R15·CPSR·SPSR·Banked Registers
  17. 17 Cortex-M 예외 처리 — Vector Table·NVIC·Tail-Chaining 추적
  18. 18 ARM 메모리 맵 분석 — Normal·Device·Strongly-Ordered Region
  19. 19 ARM L1·L2 캐시 분석 — Set Associative·Inclusive·Maintenance
  20. 20 ARM MPU 활용 — Region·Attribute·Privilege Separation
  21. 21 ARM MMU 기초 분석 — Translation Table·TLB·ASID
  22. 22 ARM TrustZone-M 기초 — Secure/Non-Secure·NSC·MPC
  23. 23 ARM Memory Barrier 실전 — DMB·DSB·ISB·DMA·MMIO
  24. 24 임베디드 크로스 컴파일러 분석 — GCC·Clang·Sysroot 구성
  25. 25 C 컴파일 4단계 — Preprocess·Compile·Assemble·Link 추적
  26. 26 ELF 파일 구조 분석 — Section·Segment·Symbol Table·DWARF
  27. 27 링커 스크립트 기초 — SECTIONS·MEMORY·entry point
  28. 28 링커 스크립트 고급 — Overlay·BSS·init_array·LMA/VMA
  29. 29 임베디드 스타트업 코드 분석 — Reset_Handler·Vector Table·SystemInit
  30. 30 C 런타임 crt0 분석 — Stack·BSS Zero·Data Copy·atexit
  31. 31 임베디드 메모리 레이아웃 — .text·.rodata·.data·.bss·.heap·.stack
  32. 32 임베디드 컴파일러 최적화 분석 — -O0~-O3·-Os·-LTO 비교
  33. 33 Map 파일 분석 — Symbol·Section·Size 추적으로 코드 크기 진단
  34. 34 Make·CMake 크로스 컴파일 — Toolchain File·Sysroot 통합
  35. 35 임베디드 Bootloader 체인 — BootROM·SPL·U-Boot·Kernel·Secure Boot
  36. 36 첫 bare-metal 프로그램 작성 — Linker·Startup·main의 최소 구성
  37. 37 MMIO 레지스터 직접 접근 — volatile·Memory Map·Aliasing 분석
  38. 38 GPIO 드라이버 직접 구현 — STM32 HAL 없이 레지스터로
  39. 39 임베디드 클럭 설정 분석 — HSE·PLL·SYSCLK·AHB/APB 분주
  40. 40 Cortex-M 인터럽트 핸들링 — NVIC·Priority·Vector·EXTI
  41. 41 SysTick 타이머 활용 — 24-bit Counter·1ms Tick·delay 구현
  42. 42 UART 드라이버 구현 — polling·interrupt·DMA 3가지 방식 비교
  43. 43 SPI 드라이버 구현 — Master·Slave·CRC·DMA
  44. 44 I2C 드라이버 구현 — Master·7-bit/10-bit·Clock Stretching 처리
  45. 45 임베디드 DMA 기초 — Memory-to-Memory·Peripheral·Circular Mode
  46. 46 저전력 모드 분석 — Sleep·Stop·Standby·Wake-up Source
  47. 47 IWDG·WWDG 워치독 구현 — Independent vs Window 비교
  48. 48 임베디드 Flash 프로그래밍 — Erase·Program·Read While Write
  49. 49 DDR 초기화 실패 진단 — Timing·Calibration·Walking Bit Test
  50. 50 PWM 출력 실전 — LED 밝기·모터 속도 제어
  51. 51 DC 모터 제어 — H-Bridge·PWM Duty·Encoder Feedback
  52. 52 스테퍼 모터 제어 — Full Step·Half Step·Microstepping
  53. 53 서보 모터 제어 — PWM 1ms~2ms·Closed Loop·PID
  54. 54 Character LCD 제어 — HD44780·4-bit Mode·Custom Char
  55. 55 SPI OLED 제어 — SSD1306·Frame Buffer·Page 단위 갱신
  56. 56 TFT 디스플레이 구동 — RGB565·FSMC·LTDC·DMA2D
  57. 57 환경 센서 활용 — BME280 온습압·SHT3x·BMP180 비교
  58. 58 IMU 센서 활용 — MPU6050·LSM6DSO·Sensor Fusion
  59. 59 CAN 통신 구현 — bxCAN·Filter·Mailbox·CAN-FD
  60. 60 USB Device 기초 — Descriptor·Enumeration·Endpoint·HID/CDC
  61. 61 Ethernet MAC+PHY 통합 — RMII·lwIP·DMA Descriptor
  62. 62 SD Card + FatFs 구현 — SPI/SDIO 모드·CSD/CID·Wear
  63. 63 RTC 활용 — Calendar·Alarm·Wake-up Timer·Backup Domain
  64. 64 RTOS 도입 결정 분석 — Super Loop vs RTOS 트레이드오프
  65. 65 RTOS Task 설계 패턴 — 우선순위·스택·State Machine
  66. 66 RTOS Scheduler 동작 분석 — Tick·Context Switch·Yield
  67. 67 RTOS Semaphore 활용 — Binary·Counting·ISR Give
  68. 68 RTOS Mutex 활용 — Recursive·Priority Inheritance 적용
  69. 69 RTOS Queue 활용 — By-Value·By-Reference·Timeout 패턴
  70. 70 RTOS Event Group 활용 — Bit Wait·Sync·Notify
  71. 71 RTOS Software Timer 활용 — One-shot·Auto-reload·Daemon Task
  72. 72 ISR-Safe API 설계 — Reentrant·Atomic·Defer 패턴
  73. 73 Priority Inversion 진단·예방 — Mars Pathfinder Lesson 추적
  74. 74 Timer Wheel 분석 — Hashed·Hierarchical·O(1) Tick
  75. 75 RTOS 디버깅 기법 — Tracealyzer·SystemView·Stack 추적
  76. 76 임베디드 Linux 부팅 흐름 분석 — BootROM·U-Boot·Kernel·init
  77. 77 U-Boot 활용 — bootcmd·env·tftp·boot.scr 분석
  78. 78 Device Tree 실전 — DTS·DTB·Overlay·Phandle 추적
  79. 79 Device Tree Overlay 적용 — Runtime fragment·dtoverlay
  80. 80 임베디드 커널 빌드 — defconfig·menuconfig·Image·zImage
  81. 81 커널 모듈 기초 — init/exit·Parameter·KBuild·DKMS
  82. 82 캐릭터 드라이버 작성 — file_operations·cdev·register_chrdev
  83. 83 Platform 드라이버 작성 — probe·remove·of_match·DT 바인딩
  84. 84 mmap 4가지 모드 — Anonymous·File·Shared·Huge Page
  85. 85 epoll 실전 — LT·ET·ONESHOT·EXCLUSIVE 비교
  86. 86 UIO·VFIO 분석 — User-Space Driver와 IOMMU 격리
  87. 87 sysfs·configfs 활용 — kobject 기반 User 인터페이스
  88. 88 IRQ Affinity 튜닝 — smp_affinity·isolcpus·irqbalance
  89. 89 루트 파일시스템 구축 — Buildroot 기초·Package·Toolchain
  90. 90 임베디드 동적 메모리 — malloc 위험·결정성·대안 분석
  91. 91 메모리 정렬과 패딩 분석 — Natural·Strict Alignment·Trap
  92. 92 Cache Line Alignment — alignas·Padding·SoA 적용
  93. 93 DMA-Friendly Allocator — dma_alloc_coherent·IOMMU·Pool
  94. 94 Zero-Copy Pipeline — DMA-BUF·sendfile·io_uring·splice
  95. 95 NUMA Memory Topology — numactl·numa_alloc·HBM 적용
  96. 96 SIMD 활용 분석 — Intrinsics·Auto-Vectorization·OpenMP SIMD
  97. 97 ARM NEON 심화 — Matrix Multiply·FFT·Image Filter 적용
  98. 98 임베디드 스택 분석 — high-water·overflow 탐지
  99. 99 임베디드 코드 크기 최적화 — -Os·LTO·Section Garbage Collection
  100. 100 임베디드 전력 최적화 — Sleep Mode·Clock Gating·DVFS
  101. 101 WCET 분석 기법 — Static·Measurement·Hybrid 방법론
  102. 102 Lock-Free Ring Buffer 구현 — SPSC·Power-of-2·Memory Order
  103. 103 Wait-Free Signaling — Atomic Flag·Sequence·Latest-Value
  104. 104 RCU (Read-Copy-Update) 기초 — Quiescent State·Grace Period
  105. 105 Hazard Pointer 분석 — Lock-Free Memory Reclamation
  106. 106 Compare-And-Swap 패턴 — Stack·Counter·Linked List 적용
  107. 107 Atomic Operation 비용 분석 — Fence·Cache Line·Contention
  108. 108 Spinlock vs Mutex 결정 가이드 — Context Switch·Hold Time
  109. 109 ABA 문제 회피 — Tagged Pointer·Hazard·Generation Counter
  110. 110 False Sharing 해결 — Cache Line Padding·SoA 적용
  111. 111 MPMC Queue 구현 — Multi-producer Multi-consumer Lock-Free
  112. 112 임베디드 디버깅 마인드셋 — 가설·격리·재현·이분탐색
  113. 113 JTAG·SWD 안 붙을 때 — 핀·전압·속도·세션 진단
  114. 114 GDB 원격 디버깅 — OpenOCD·J-Link·target remote 구성
  115. 115 Cortex-M 하드폴트 분석 — Stacked Frame·CFSR 읽기
  116. 116 UART 안 찍힐 때 — Bare-metal 체크리스트
  117. 117 임베디드 부팅 실패 진단 — 단계별 Isolation
  118. 118 인터럽트 누락·중복 진단 — Priority·Pending·Re-entry 추적
  119. 119 메모리 오버플로우·오염 진단 — Canary·MPU·Pattern 분석
  120. 120 타이밍·Race 진단 — Heisenbug 잡는 법
  121. 121 통신 프로토콜 분석 — Logic Analyzer와 Protocol Decoder
  122. 122 임베디드 로깅 시스템 설계 — 레벨·버퍼·SWO·Deferred
  123. 123 임베디드 포스트모템 분석 — Core Dump와 Field Crash
  124. 124 FPGA 기초 분석 — LUT·FF·BRAM·DSP 자원 구조
  125. 125 Vivado 사용법 — Project·Constraint·Synth·Impl·Bitstream
  126. 126 PCIe BAR 매핑 분석 — Config Space·Enumeration·MMIO 접근
  127. 127 AXI 인터페이스 — AXI4·AXI4-Lite·AXI-Stream 비교
  128. 128 Zynq PS-PL 통신 — GP·HP·ACP 인터페이스 선택
  129. 129 Mailbox Protocol 분석 — Host와 Accelerator를 잇는 Doorbell
  130. 130 Command Queue·Submission Queue — NVMe·XDMA 공통 패턴
  131. 131 DMA Completion 메커니즘 — Interrupt·Polling·Completion Ring
  132. 132 PCIe Streaming 분석 — BAR Type·MSI-X·Kernel Bypass
  133. 133 Vitis HLS 분석 — Pragma·Pipeline II·Dataflow 실전 감각
  134. 134 HLS 최적화 기법 — Pipeline·Unroll·Partition·Dataflow
  135. 135 Vitis AI 분석 — DPU·xmodel·VART
  136. 136 OpenCL on FPGA — Kernel·Channel·Burst Memory 분석
  137. 137 Intel Quartus 사용법 — Platform Designer·Nios II·HLS
  138. 138 Edge Inference 분석 — Cloud vs Edge·Latency·Privacy
  139. 139 NPU 아키텍처 분석 — Ethos·Hexagon·Systolic Array 비교
  140. 140 딥러닝 Quantization 분석 — PTQ·QAT·INT8·INT4·Calibration
  141. 141 TensorRT 분석 — ONNX→Engine·FP16·INT8·DLA·Multi-Stream
  142. 142 TFLite Micro 분석 — Op Resolver·Tensor Arena·Cortex-M
  143. 143 ONNX Runtime 분석 — Execution Provider와 Cross-Platform 배포
  144. 144 Edge Thermal Management — Throttling·DVFS·Fan Curve·Sustained
  145. 145 NVIDIA Jetson 분석 — Nano·Xavier·Orin·Thor·JetPack·DLA·VPI
  146. 146 Zero-Copy Camera Pipeline — V4L2·DMA-BUF·GPU Import·NPU 직결
  147. 147 온디바이스 LLM 추론 — llama.cpp·GGUF·MLX·KV Cache·NPU Backend
  148. 148 Cortex-M33 TF-M·TrustZone — Secure Firmware·PSA·MCUboot
  149. 149 Matter·Thread 분석 — IoT 통합 표준·Commissioning·Multi-Fabric
  150. 150 PCIe → CXL 진화 — 같은 PHY 위 cache-coherent 프로토콜 추가
  151. 151 QEMU CXL Type 3 디바이스 에뮬레이션 — 노트북에서 CXL 개발 환경 구축
  152. 152 Linux CXL 드라이버 분석 — cxl_pci·cxl_core·region·DAX