OS & Concurrency: Scheduling và Execution Flow

OS Thread là "công việc cần chạy"
Physical Thread là "máy móc thực thi"
Kernel Scheduler gán OS Thread lên Physical Thread

                    HARDWARE LAYER
┌──────────────────────────────────────────┐
│  CPU Package                             │
│  ┌─────────┐  ┌─────────┐               │
│  │ Core 0  │  │ Core 1  │  ...          │
│  │ [HT0]   │  │ [HT0]   │               │
│  │ [HT1]   │  │ [HT1]   │               │
│  └────┬────┘  └────┬────┘               │
└───────┼────────────┼────────────────────┘
        │
        ▼           OS / KERNEL LAYER
┌───────────────────────────────────────────┐
│  Kernel Scheduler                         │
│  Run Queue:  [T3][T7][T1][T9]...          │
│  Wait Queue: [T2][T5][T8]...              │
└───────────────────────────────────────────┘

// Linux: gắn thread chỉ chạy trên Core 2 và Core 3
cpu_set_t cpuset;
CPU_SET(2, &cpuset);
CPU_SET(3, &cpuset);
pthread_setaffinity_np(thread, sizeof(cpuset), &cpuset);

Ví dụ:
  Thread A: vruntime = 10ms  (đã chạy nhiều)
  Thread B: vruntime = 3ms   ← được chọn ✓
  Thread C: vruntime = 7ms

  Sau khi B chạy 4ms → vruntime B = 7ms → B và C bằng nhau

         [7ms - Thread C]
        /                \
  [3ms - B]           [10ms - A]

→ Thread vruntime nhỏ nhất = nút tận cùng trái
→ Pick O(log n) — cực nhanh dù hàng nghìn threads

Trigger 1 — Timer Interrupt (quan trọng nhất)
  Hardware timer ngắt CPU mỗi ~1-10ms
  → Kiểm tra thread hiện tại đã chạy đủ chưa?
  → Nếu rồi → preempt → schedule thread khác

Trigger 2 — Thread tự block
  Thread gọi: sleep(), read(), recv(), mutex.lock()...
  → Tự rời CPU → Scheduler chạy thread khác ngay lập tức

Trigger 3 — Thread mới được tạo
  → Xem xét có nên preempt thread hiện tại không

Trigger 4 — I/O hoàn thành / Signal
  Thread BLOCKED → chuyển sang READY
  → Có thể preempt thread hiện tại nếu mới hơn và important hơn

result = a + b

Assembly: ADD rax, rbx

CPU Pipeline:
  Fetch   → Decode   → Execute   → Writeback
  (lấy      (hiểu      (ALU         (ghi
  lệnh)      lệnh)      tính)        kết quả)

Kết quả đi: Register → L1 Cache → L2 Cache → L3 Cache → RAM

┌─────────────────────────────────────────────┐
│           Application (User Mode)           │  ← code bạn viết
└──────────────────┬──────────────────────────┘
                   │ syscall (open, read, write, send...)
                   │ ~200-400ns overhead mỗi lần
┌──────────────────▼──────────────────────────┐
│            Linux Kernel (Kernel Mode)        │
│   Scheduler | Memory Manager | Network | FS  │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│     Physical Hardware: CPU, RAM, NIC, Disk   │
└─────────────────────────────────────────────┘

1. Browser gửi request
   → OS tạo OS Thread
   → Thread gọi send() syscall → vào Kernel Mode
   → Kernel xử lý network stack → gửi packet
   → Thread bị BLOCKED (chờ response) — CPU được giải phóng!

2. Server response về
   → Hardware interrupt từ NIC
   → Kernel đánh thức thread → READY
   → Scheduler gán Core khi có Core rảnh

3. Thread nhận data → xử lý
   → CPU chạy thật sự (RUNNING state)
   → Render kết quả ra màn hình

while (true) {
    HLT;  // instruction: nghỉ đến interrupt tiếp theo
}

C1: ~1µs để thức dậy   (giảm clock)
C3: ~50µs để thức dậy  (giảm voltage)
C6: ~200µs để thức dậy (gần như tắt core)