Module 4 — Tổng kết & cheat sheet

TL;DR: Module 4 đi từ câu hỏi "ai dọn rác" đến kỹ năng chẩn đoán leak và tối ưu cache. Bạn biết cấp phát thủ công đòi hỏi kiểm soát chặt (malloc/free) còn GC tự động nhưng không phải viên đạn bạc; biết ref-counting đơn giản nhưng chết ở cycle trong khi tracing GC mạnh hơn với cái giá stop-the-world pause; biết logical leak là thứ GC không cứu được vì object vẫn reachable; và cuối cùng đo trực tiếp rằng SoA thực sự nhanh hơn AoS khi vòng lặp chỉ dùng ít field. Đây là trang để bookmark.

Đã đi qua những gì

Module bắt đầu từ hai triết lý đối lập: C đặt trách nhiệm dọn dẹp vào tay lập trình viên (malloc/free) — kiểm soát tuyệt đối, nhưng một lỗi nhỏ dẫn tới leak, double free, dangling pointer. Ngôn ngữ bậc cao (Java, Go, Python) giao việc đó cho runtime GC — an toàn hơn, code đơn giản hơn, nhưng không miễn phí hoàn toàn.

Bạn đi sâu vào hai cơ chế GC chính: ref-counting (đếm bao nhiêu thứ đang giữ object, thu khi = 0 — đơn giản, real-time, nhưng chết ở reference cycle) và tracing GC (duyệt đồ thị reachability từ root set, mark-and-sweep — mạnh hơn, thu được cycle, nhưng gây stop-the-world pause). Generational GC kết hợp cả hai tư tưởng: chia heap theo tuổi, GC thường xuyên vùng trẻ, ít thường xuyên vùng già.

Rồi bạn học điều quan trọng nhất về GC: nó không cứu được logical leak — object reachable nhưng không bao giờ dùng nữa. Static collection không clear, listener không unregister, ThreadLocal không remove, cache không có eviction — đây là những "lỗi logic" mà GC nhìn thấy một tham chiếu hợp lệ và không dám thu. Triệu chứng: heap tăng dần, GC chạy nhiều mà không giảm, cuối cùng OOM.

Capstone kết nối lại với Module 2: bạn tự đo rằng refactor AoS sang SoA giảm thời gian vòng lặp 2–5 lần nhờ spatial locality — đây là minh chứng sống rằng bố cục dữ liệu quyết định hiệu năng, không phải chỉ thuật toán.

mindmap
  root(("Quan ly<br/>bo nho"))
    Manual vs GC
      malloc free trong C
      Leak double-free dangling pointer
      GC tự động thu reachable
      Tradeoff an toan vs kiem soat
    Co che GC
      Ref-counting dem tham chieu
      Chet o reference cycle
      Tracing GC mark-and-sweep
      Generational young old gen
      Stop-the-world pause
    Logical leak
      GC chi thu unreachable
      Reachable nhung vo dung
      Static collection listener ThreadLocal
      Heap dump dominator tree
    Cache va layout
      AoS pointer chasing field thua
      SoA field lien tuc 100% huu ich
      Do truoc-sau nanoTime JMH
      SIMD mo duong tu SoA

🗺️ Cheat sheet

📖 Glossary module

⚠️ Pitfall tổng hợp

1. Quên free trên mọi code path trong C:

// SAI: early return truoc khi free
char* process(int n) {
    char* buf = malloc(n);
    if (n > MAX) return NULL;   // LEAK: buf chua duoc free
    // ... xu ly ...
    free(buf);
    return result;
}

// DUNG: free tren moi path
char* process(int n) {
    char* buf = malloc(n);
    if (n > MAX) {
        free(buf);              // cleanup truoc khi return
        return NULL;
    }
    // ... xu ly ...
    free(buf);
    return result;
}

2. Tin "có GC = không leak":

// SAI: static cache tang mai khong clear
static final Map<String, byte[]> cache = new HashMap<>();

public void handle(String key, byte[] data) {
    cache.put(key, data);       // put nhung khong co remove/evict
}
// Sau 1 trieu request: 1 trieu entry trong heap, OOM

// DUNG: bounded cache voi eviction
static final Cache<String, byte[]> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .build();

3. ThreadLocal trong thread pool — quên remove:

// SAI: set khong remove
threadLocal.set(requestContext);
doWork();
// thread pool tai dung thread -> context cu van o day

// DUNG: remove trong finally
threadLocal.set(requestContext);
try {
    doWork();
} finally {
    threadLocal.remove();       // dam bao ca khi exception
}

4. AoS khi vòng lặp chỉ dùng ít field:

// SAI (hieu nang): AoS khi hot loop chi dung x, y
for (Particle p : particles) {
    p.x += p.vx * dt;           // keo ca mass, charge, color vao cache
    p.y += p.vy * dt;
}

// DUNG: SoA khi hot loop it field, du lieu lon hon cache
for (int i = 0; i < n; i++) {
    xs[i] += vxs[i] * dt;       // cache line toan x, toan vx
    ys[i] += vys[i] * dt;
}

5. Ref-counting với reference cycle:

# Python ref-counting bi bat bai boi cycle
class Node:
    def __init__(self):
        self.sibling = None

a = Node()
b = Node()
a.sibling = b   # a giu b
b.sibling = a   # b giu a -- CYCLE
del a
del b
# ref count cua ca hai van = 1 (giu lan nhau)
# Python cycle detector xu ly duoc, nhung chi chay dinh ky
# -- khong phai immediate reclaim nhu thong thuong

✅ Self-assessment

Bạn đã đạt module này nếu trả lời được:

• Compare được cấp phát thủ công (malloc/free) với garbage collection tự động về an toàn và chi phí — nêu được ít nhất 2 bug chỉ có ở manual, và 1 chi phí GC không miễn phí.
  • Nếu chưa: đọc lại bài 01 — Cấp phát thủ công vs GC mục 2–4.
• Explain được ref-counting và tracing GC hoạt động thế nào, ưu nhược điểm mỗi cách — giải thích được vì sao ref-counting chết ở cycle và tracing GC cần stop-the-world.
  • Nếu chưa: đọc lại bài 02 — Ref-counting vs tracing GC mục 2–4.
• Diagnose được memory leak trong ngôn ngữ có GC và giải thích vì sao GC không cứu được — nêu được 3 pattern phổ biến và cách dùng heap dump + dominator tree để tìm thủ phạm.
  • Nếu chưa: đọc lại bài 03 — Memory leak có GC mục 3–4.
• Refactor được chương trình dùng AoS sang SoA và đo cải thiện trước-sau — chạy được cả hai phiên bản, giải thích được vì sao SoA nhanh hơn dựa trên cache line và spatial locality.
  • Nếu chưa: làm lại bài 04 — Mini-challenge tối ưu cache miss phần Starter code và Lời giải.

🚀 What's next

Bạn vừa hoàn thành khoá Bộ nhớ (cs-memory) — course tier 2 của track Máy tính cho Lập trình viên.

Nhìn lại hành trình 4 module:

• Module 1 — Mô hình bộ nhớ chương trình: stack, heap, static, con trỏ — bố cục của mọi chương trình đang chạy.
• Module 2 — Cache & memory hierarchy: tại sao truy cập dữ liệu nhanh hay chậm quyết định hiệu năng; cache line, locality, AoS/SoA, false sharing.
• Module 3 — Bộ nhớ ảo: mỗi tiến trình thấy không gian địa chỉ ảo riêng; paging, page table, MMU, TLB, page fault, swap.
• Module 4 — Quản lý bộ nhớ ngôn ngữ: ai dọn rác, dọn thế nào, và khi nào GC không đủ.

Bốn module này cho bạn mechanical sympathy — khả năng nhìn qua lớp trừu tượng ngôn ngữ và thấy máy tính đang làm gì thật sự với bộ nhớ. Đây là nền tảng để đọc code và đoán được "chỗ này có thể chậm vì cache miss", "chỗ này có thể OOM vì logical leak", "chỗ này GC pause có thể gây latency spike".

Tiếp theo: khoá tier 3 của track chưa sẵn sàng. Trong thời gian chờ, hãy củng cố bằng cách:

• Chạy lại capstone bài 04 với N = 10_000_000 và đo bằng perf stat nếu bạn dùng Linux.
• Áp dụng heap dump (jmap + Eclipse MAT) vào một ứng dụng Java bạn đang develop — thử tìm dominator lớn nhất.
• Đọc "What Every Programmer Should Know About Memory" (Drepper) chương 3–5 — cùng topic nhưng sâu hơn và từ góc nhìn C/Linux.

Khám phá thêm: Tất cả khoá học

📚 Tài liệu mở rộng

• "The Garbage Collection Handbook" (Richard Jones, Antony Hosking, Eliot Moss, 2011) — cuốn sách toàn diện nhất về GC algorithms: ref-counting, tracing, generational, incremental, concurrent, real-time. Đọc chương 1–3 cho nền tảng; chương 6–7 cho generational và concurrent GC của JVM.
• OSTEP — "Operating Systems: Three Easy Pieces" (Arpaci-Dusseau) — miễn phí tại https://pages.cs.wisc.edu/~remzi/OSTEP/ — chương "Address Spaces" và "Free Space Management" liên hệ trực tiếp với manual allocation và virtual memory ở Module 3.
• "What Every Programmer Should Know About Memory" (Ulrich Drepper) — chương 5–7 đào sâu AoS/SoA, NUMA, prefetching — đọc sau khi xong Module 2 và capstone này để thấy bức tranh đầy đủ hơn.
• HotSpot GC documentation (Oracle) — tài liệu chính thức về G1GC và ZGC (hai GC của HotSpot): tuning, pause time goals, heap sizing. Tìm tại https://docs.oracle.com/en/java/javase/21/gctuning/ (Java 21).