Sắp xếp trường để tiết kiệm bộ nhớ

struct Kem { char a; double b; char c; };
struct Tot { double b; char a; char c; };

struct Kem { char a; double b; char c; };

byte:  0    1 2 3 4 5 6 7    8 .. 15      16   17 .. 23
     +----+--------------+-------------+----+-----------+
     | a  |   DEM 7      |      b      | c  |  DEM 7    |
     +----+--------------+-------------+----+-----------+
     sizeof = 24, du lieu 10 byte, dem 14 byte


struct Tot { double b; char a; char c; };

byte:  0 .. 7      8    9    10 .. 15
     +-----------+----+----+-----------+
     |     b     | a  | c  |   DEM 6   |
     +-----------+----+----+-----------+
     sizeof = 16, du lieu 10 byte, dem 6 byte


Tiet kiem 8 byte tren 24, tuc 33 phan tram.
Voi mang mot trieu phan tu: tiet kiem 8 MB.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct { char a; double b; char c; } Kem;
typedef struct { double b; char a; char c; } Tot;

enum { N = 5000000 };

static double duyet_kem(const Kem *ds) {
    double t = 0;
    for (size_t i = 0; i < N; ++i) t += ds[i].b;
    return t;
}

static double duyet_tot(const Tot *ds) {
    double t = 0;
    for (size_t i = 0; i < N; ++i) t += ds[i].b;
    return t;
}

int main(void) {
    printf("Kem: %d byte moi phan tu, %.1f MB cho %d phan tu\n",
           (int)sizeof(Kem), (double)sizeof(Kem) * N / 1048576.0, N);
    printf("Tot: %d byte moi phan tu, %.1f MB cho %d phan tu\n",
           (int)sizeof(Tot), (double)sizeof(Tot) * N / 1048576.0, N);

    Kem *a = calloc(N, sizeof *a);
    Tot *b = calloc(N, sizeof *b);
    if (a == NULL || b == NULL) return 1;

    clock_t t0 = clock();
    double s1 = duyet_kem(a);
    clock_t t1 = clock();
    double s2 = duyet_tot(b);
    clock_t t2 = clock();

    printf("duyet Kem: %.0f ms\n", (double)(t1 - t0) * 1000 / CLOCKS_PER_SEC);
    printf("duyet Tot: %.0f ms\n", (double)(t2 - t1) * 1000 / CLOCKS_PER_SEC);
    printf("(%.0f %.0f)\n", s1, s2);

    free(a); free(b);
    return 0;
}

typedef struct { int loai; } CoSo;

typedef struct {
    CoSo co_so;              /* PHAI la truong dau tien */
    int  ban_kinh;
} HinhTron;

typedef struct {
    CoSo co_so;              /* PHAI la truong dau tien */
    int  rong, cao;
} HinhChuNhat;

void ve(CoSo *h) {
    switch (h->loai) {
        case 1: ve_tron((HinhTron *)h); break;
        case 2: ve_chu_nhat((HinhChuNhat *)h); break;
    }
}

HinhTron t = { { 1 }, 5 };
ve((CoSo *)&t);              /* HOP LE: con tro toi struct tro toi
                                thanh vien dau tien */

/* Neu ban sap xep lai va dua co_so xuong duoi thi phep ep kieu
   nay thanh UB, va chuong trinh doc sai truong loai.

   Nen: khi dung mau nay, THEM chu thich va _Static_assert: */

_Static_assert(offsetof(HinhTron, co_so) == 0, "co_so phai o dau");

# 1. pahole -R de xuat thu tu toi uu
$ pahole -R --reorganize duan.o

struct SinhVien {
        double     diem;      /*  0  8 */
        long       ngay_sinh; /*  8  8 */
        char       ten[32];   /* 16 32 */
        ...
        /* size: 64, cachelines: 1 */
        /* saved 8 bytes! */

# 2. pahole --packable liet ke moi struct co the nen lai
$ pahole --packable duan.o
SinhVien           72      64        8
KetNoi            104      96        8
CauHinh            48      40        8
# ten, kich thuoc hien tai, kich thuoc toi uu, tiet kiem duoc

# 3. clang dump bo cuc
$ clang -Xclang -fdump-record-layouts -c bocuc.c
*** Dumping AST Record Layout
         0 | struct Kem
         0 |   char a
         8 |   double b
        16 |   char c
           | [sizeof=24, align=8]

# 4. GDB, da co san moi noi
(gdb) ptype/o struct SinhVien