Bài 10: Tăng Tốc Phần Cứng: GPU, NPU & AMX

Mở đầu: khi băng thông đã đủ, bức tường tiếp theo là tính toán

Bài 9 giải quyết việc đưa dữ liệu tới đúng chỗ nhanh nhất (UMA loại bỏ bước sao chép PCIe). Nhưng có dữ liệu nhanh chưa đủ — CPU vô hướng vẫn phải TÍNH TOÁN từng phần tử MỘT theo thứ tự. Đồ hoạ 3D và deep learning đều xoay quanh MỘT phép toán lõi: nhân ma trận. Bài này so sánh 3 kiến trúc phần cứng xử lý CÙNG phép toán đó với thông lượng khác biệt tới hàng nghìn lần.

1. Kiến trúc SIMD vs SIMT

SIMD (Single Instruction, Multiple Data) — CPU hiện đại có các thanh ghi vector rộng (vd AVX-256 xử lý 8 số 32-bit CÙNG lúc trong MỘT lệnh) — vẫn là kiến trúc scalar cơ bản, chỉ "nới rộng" từng lệnh để xử lý nhiều dữ liệu hơn. SIMT (Single Instruction, Multiple Threads) — cách GPU tổ chức: hàng nghìn Shader Core nhỏ, đơn giản, chạy CÙNG một lệnh nhưng trên hàng nghìn luồng dữ liệu độc lập song song — khác về BẢN CHẤT so với việc "nới rộng lệnh" của SIMD.

2. Kiến trúc NPU & Apple AMX

NPU (Neural Processing Unit) và Tensor Core là phần cứng CHUYÊN DỤNG chỉ để tăng tốc MỘT phép toán: nhân ma trận (và các biến thể tích chập convolution) — nhanh hơn hàng chục lần so với chạy phép toán tương đương trên CPU thông thường, nhờ thiết kế phần cứng CHỈ để làm một việc thay vì linh hoạt như CPU. Apple AMX (Apple Matrix Coprocessor) là khối đồng xử lý ma trận ẨN ngay trong lõi CPU Apple Silicon — không cần chuyển dữ liệu sang GPU (tiếp nối tinh thần UMA của Bài 9), CPU tự "gọi thẳng" tập lệnh AMX riêng khi chạy qua Accelerate framework hoặc CoreML.

SIMD (CPU vector, vd AVX-256):
  1 lenh --> xu ly CUNG LUC 8 so 32-bit trong 1 thanh ghi rong
  Van la 1 loi thuc thi (control flow), chi "no rong" DU LIEU

SIMT (GPU, vd CUDA/Metal):
  1 lenh --> hang nghin Shader Core doc lap chay CUNG lenh do
  MOI Shader Core co du lieu RIENG - that su nhieu LUONG thuc thi song song
  (neu cac luong trong 1 nhom RE NHANH khac huong -> phai chay TUAN TU ca 2 nhanh)

Kien truc      | Muc dich chinh              | Vi du
---------------|------------------------------|---------------------------
CPU + SIMD     | Da nang, phep toan da dang   | AVX/AVX-512 (x86), NEON (ARM)
GPU (SIMT)     | Song song HANG NGHIN luong   | Do hoa, huan luyen mo hinh lon
NPU/TensorCore | Chuyen dung nhan ma tran     | Suy luan AI tren thiet bi di dong
Apple AMX      | Nhan ma tran AN trong CPU    | Accelerate framework, CoreML
                 (khong can chuyen du lieu sang GPU - tiep noi tinh than UMA Bai 9)

3. Bài toán tính toán thông lượng FLOPs

Nhân 2 ma trận $N \times N$ theo thuật toán tuần tự kinh điển: mỗi trong $N^2$ phần tử kết quả cần $N$ phép nhân + $(N-1)$ phép cộng — tổng số phép tính dấu phẩy động (FLOPs):

$$\text{Total FLOPs} = N^2 \times (2N - 1) = 2N^3 - N^2$$

Verified thật: nhân ma trận 1024×1024 cần đúng 2.146.435.072 FLOPs (~2,15 tỷ). So sánh thời gian tính CÙNG phép toán này trên 3 kiến trúc — CPU vô hướng (4 GFLOPS), CPU SIMD (32 GFLOPS, tương đương AVX 8-wide = 8× scalar), và GPU (10 TFLOPS):

function matrixMultiplyFlops(n) {
  return 2 * Math.pow(n, 3) - Math.pow(n, 2);
}
function computeTimeSeconds(flops, flopsPerSecond) {
  return flops / flopsPerSecond;
}
// Verified: matrixMultiplyFlops(1024) = 2.146.435.072 FLOPs
// Verified: scalar (4 GFLOPS)  -> 0,5366 giay
// Verified: SIMD (32 GFLOPS)   -> 0,0671 giay (nhanh hon scalar DUNG 8 lan = 32/4)
// Verified: GPU (10 TFLOPS)    -> 0,000215 giay = 0,215 ms (nhanh hon scalar 2500 lan)

SIMD nhanh hơn scalar đúng 8 lần — CHÍNH XÁC bằng độ rộng vector (không phải một con số ước lượng). GPU nhanh hơn scalar tới 2500 lần — chênh lệch khổng lồ này đến từ việc GPU có hàng nghìn Shader Core làm việc song song thật sự, khác hẳn việc chỉ "nới rộng" một lệnh như SIMD.

// Ma tran 4x4: chi 112 FLOPs - qua nho de GPU "dang" cong suc
const cmpSmall = compareComputeMethods(4, 4, 32, 10, 0.0001); // 0,1ms overhead GPU
// cmpSmall.scalarTimeSeconds ~ 0.000000028 s (khong overhead)
// cmpSmall.gpuTimeSeconds    ~ 0.0001 s (GAN NHU TOAN BO la overhead, tinh toan that ~0)
// Verified: cmpSmall.gpuTimeSeconds > cmpSmall.scalarTimeSeconds -> GPU CHAM HON!

4. Thực hành: So sánh nhân ma trận Scalar vs SIMD vs GPU/AMX

Đổi kích thước ma trận và thông số 3 kiến trúc để xem thời gian tính thay đổi trực tiếp — thử giảm N xuống rất nhỏ (vd 4) để tự tay thấy pitfall overhead GPU verified ở trên:

Tóm lược

• ✅ SIMD "nới rộng" một lệnh CPU để xử lý nhiều dữ liệu cùng lúc; SIMT (GPU) chạy hàng nghìn luồng thật sự độc lập — khác nhau về bản chất tổ chức song song.
• ✅ NPU/Tensor Core và Apple AMX là phần cứng CHUYÊN DỤNG chỉ để tăng tốc nhân ma trận.
• ✅ Verified: nhân ma trận 1024×1024 = 2.146.435.072 FLOPs. SIMD nhanh hơn scalar đúng 8 lần (= độ rộng vector); GPU nhanh hơn scalar 2500 lần.
• ✅ Pitfall: với ma trận quá nhỏ (4×4), overhead nạp dữ liệu vào GPU khiến nó CHẬM HƠN CPU vô hướng — verified thật bằng engine.
• ✅ Pitfall: GPU rất yếu với code rẽ nhánh tuần tự phức tạp — không thể thay thế CPU cho mọi việc.

Trắc nghiệm ôn tập