메모리 정렬과 패딩 분석 — Natural·Strict Alignment·Trap

1
struct s1 {
2
    char  a;        /* offset 0 */
3
    /* padding 3 byte */
4
    int   b;        /* offset 4 */
5
    char  c;        /* offset 8 */
6
    /* padding 3 byte */
7
};
8
/* sizeof(s1) = 12 */
9

10
struct s2 {
11
    int   b;        /* offset 0 */
12
    char  a;        /* offset 4 */
13
    char  c;        /* offset 5 */
14
    /* padding 2 byte */
15
};
16
/* sizeof(s2) = 8 — 33% 절약 */

1
#include <stddef.h>
2
#include <stdalign.h>
3

4
struct s {
5
    char a;
6
    int  b;
7
    long long c;
8
};
9

10
printf("sizeof  = %zu\n", sizeof(struct s));     /* 16 */
11
printf("offsetof(a) = %zu\n", offsetof(struct s, a));  /* 0 */
12
printf("offsetof(b) = %zu\n", offsetof(struct s, b));  /* 4 */
13
printf("offsetof(c) = %zu\n", offsetof(struct s, c));  /* 8 */
14
printf("alignof = %zu\n", alignof(struct s));    /* 8 */

1
struct frame {
2
    uint8_t  type;
3
    uint8_t  flags;
4
    uint16_t len;
5
    uint32_t payload;
6
};
7

8
_Static_assert(sizeof(struct frame) == 8, "frame layout drift");
9
_Static_assert(offsetof(struct frame, len) == 2, "len position");

1
struct __attribute__((packed)) bad {
2
    char  a;
3
    int   b;       /* offset 1 — misaligned! */
4
};
5

6
struct bad p;
7
int v = p.b;       /* Cortex-M3: 2 cycle, Cortex-M0: fault */

1
/* 안전한 packed 접근 — memcpy로 우회 */
2
int v;
3
memcpy(&v, &p.b, sizeof(v));

1
/* 외부 device와의 wire format — packed 필수 */
2
struct __attribute__((packed)) sensor_packet {
3
    uint8_t  sof;
4
    uint16_t length;     /* little-endian */
5
    uint32_t timestamp;
6
    int16_t  data[8];
7
    uint16_t crc;
8
};
9

10
_Static_assert(sizeof(struct sensor_packet) == 25, "wire format");

1
#include <stdalign.h>
2

3
alignas(8) static uint8_t dma_buf[1024];    /* 8-byte 정렬 */
4

5
struct alignas(64) hot {
6
    int a;
7
};

1
/* GCC, Clang */
2
__attribute__((aligned(8)))  uint8_t b1[1024];
3
__attribute__((aligned(64))) struct x { int a; } y;
4

5
/* MSVC */
6
__declspec(align(8)) uint8_t b1[1024];
7

8
/* C11 표준 */
9
_Alignas(8) uint8_t b1[1024];
10
alignas(8) uint8_t b1[1024];     /* stdalign.h */

1
void func(void) {
2
    alignas(16) char buf[64];    /* stack에 16-byte align */
3
}

1
Cortex-M4 72 MHz
2
aligned 32-bit read          1 cycle
3
unaligned 32-bit read        2 cycle
4
aligned + memcpy 32-bit      2~3 cycle (memcpy 펼침)
5
packed 접근 → memcpy 우회    2~3 cycle (안전)
6

7
Cortex-A72
8
aligned NEON load (vld1q)    1 cycle
9
unaligned NEON load          2 cycle (cross-line)

1
struct 재배열 효과 (RAM 절약)
2
field 순서: char int char int char    32 byte
3
field 순서: int int char char char    16 byte (50% 절약)

1
struct __attribute__((packed)) cfg {
2
    char a;
3
    int  b;
4
};   /* in-memory struct에 packed — Cortex-M0에서 fault */

1
struct frame *p = (struct frame *)buf;   /* buf가 align 0이면 fault */
2
int v = p->len;

1
struct {
2
    unsigned a : 3;
3
    unsigned b : 5;
4
    unsigned c : 8;
5
} bf;

1
char buf[12];
2
struct s msg;
3
memcpy(buf, &msg, sizeof(buf));    /* sizeof(s)와 다를 수 있음 */

1
void f(void) {
2
    alignas(64) char buf[64];    /* stack은 16/32 byte만 보장 */
3
}