Pipeline là một kỹ thuật chia một nhiệm vụ phức tạp thành nhiều giai đoạn nhỏ liên tiếp và tương đối độc lập, cho phép các giai đoạn này hoạt động song song. Kỹ thuật này được ứng dụng rộng rãi trong kiến trúc máy tính, xử lý tín hiệu số và nhiều lĩnh vực khác.

Khái niệm cơ bản

• Định nghĩa Pipeline: Pipeline hoạt động giống như dây chuyền sản xuất trong nhà máy, mỗi công nhân đảm nhận một công đoạn cụ thể, sản phẩm lần lượt đi qua từng bước để hoàn thiện. Trong kiến trúc phần mềm, một tác vụ lớn được chia nhỏ thành các bước thực thi tuần tự, mỗi tác vụ có thể được xử lý ở các giai đoạn khác nhau cùng lúc.
• Tác vụ và Giai đoạn: Tác vụ là toàn bộ công việc cần thực hiện, còn giai đoạn là các phần nhỏ của tác vụ. Ví dụ trong pipeline thực thi lệnh, tác vụ là thực hiện một lệnh hoàn chỉnh, gồm các giai đoạn như: 1. Lấy lệnh (Fetch), 2. Giải mã (Decode), 3. Thực thi (Execute), 4. Truy cập bộ nhớ (Memory), 5. Ghi kết quả (Write-back).

Nguyên lý hoạt động

• Cơ chế xử lý song song: Điểm cốt lõi của pipeline là xử lý đồng thời các giai đoạn khác nhau của nhiều tác vụ khác nhau. Ví dụ, khi tác vụ đầu tiên đang ở giai đoạn thực thi, tác vụ thứ hai có thể đang ở giai đoạn giải mã, và tác vụ thứ ba đang ở giai đoạn lấy lệnh. Điều này giúp tận dụng tối đa tài nguyên hệ thống và tăng tốc độ xử lý.
• Chu kỳ đồng hồ: Pipeline thường hoạt động theo chu kỳ đồng hồ. Mỗi giai đoạn hoàn thành nhiệm vụ trong một chu kỳ và truyền kết quả sang giai đoạn tiếp theo. Lý tưởng là mỗi chu kỳ đều hoàn thành một giai đoạn của một tác vụ, từ đó nâng cao hiệu suất tổng thể.

Tác vụ 1: [L] [G] [T] [B] [G]
Tác vụ 2:    [L] [G] [T] [B] [G]
Tác vụ 3:       [L] [G] [T] [B] [G]

Ưu điểm của Pipeline

• Tăng năng suất: Nhờ xử lý song song nhiều tác vụ, hệ thống có thể xử lý nhiều hơn trong cùng một khoảng thời gian, cải thiện đáng kể năng suất.
• Tối ưu hóa sử dụng tài nguyên: Các tài nguyên phần cứng trong từng giai đoạn có thể được tái sử dụng giữa các tác vụ, giảm thời gian rảnh. Ví dụ, đơn vị ALU có thể được sử dụng lại trong các giai đoạn thực thi khác nhau.
• Giảm chi phí: Với khả năng sử dụng tài nguyên cao hơn, hệ thống có thể đạt được hiệu suất tương đương mà không cần đầu tư quá nhiều phần cứng như trong cấu trúc không dùng pipeline.

Vấn đề gặp phải trong Pipeline

• Rủi ro trong Pipeline
• Rủi ro dữ liệu: Khi lệnh sau cần kết quả của lệnh trước chưa được tạo ra, xảy ra rủi ro dữ liệu. Ví dụ, lệnh B cần kết quả từ lệnh A, nhưng lệnh A chưa hoàn tất, lệnh B phải chờ. Có thể phân loại rủi ro dữ liệu thành RAW, WAR và WAW.
• Rủi ro điều khiển: Lệnh nhánh và các lệnh điều khiển làm thay đổi thứ tự thực thi, khiến những lệnh đã vào pipeline có thể không hợp lệ, cần được xóa để duy trì hiệu suất. Ví dụ, khi gặp lệnh nhánh điều kiện, bộ xử lý dự đoán hướng nhánh, nếu sai thì phải xóa các lệnh đã vào pipeline và bắt đầu lại từ nhánh đúng.
• Rủi ro cấu trúc: Xảy ra khi nhiều lệnh cùng muốn sử dụng một tài nguyên phần cứng. Ví dụ, hai lệnh cùng truy cập bộ nhớ, nhưng chỉ có một cổng truy cập, dẫn đến xung đột.
• Vấn đề độ sâu của Pipeline: Độ sâu pipeline là số lượng giai đoạn trong pipeline. Tăng độ sâu giúp tăng mức độ song song, nhưng cũng làm tăng độ phức tạp phần cứng và độ trễ chu kỳ đồng hồ, đồng thời làm khó khăn hơn trong việc xử lý rủi ro. Ví dụ, khi độ sâu tăng, chi phí lưu trữ giữa các giai đoạn tăng, và hậu quả của dự đoán sai nhánh cũng lớn hơn.

Các phương pháp khắc phục rủi ro trong Pipeline

• Khắc phục rủi ro dữ liệu
• Chuyển dữ liệu trực tiếp (Data Bypass): Truyền kết quả của lệnh trước trực tiếp tới lệnh tiếp theo mà không cần chờ ghi vào thanh ghi, giảm thời gian chờ. Ví dụ, kết quả từ giai đoạn thực thi được chuyển trực tiếp sang giai đoạn giải mã của lệnh kế tiếp.
• Đổi tên thanh ghi (Register Renaming): Đổi tên các thanh ghi để tránh phụ thuộc giữa các lệnh, loại bỏ rủi ro dữ liệu. Ví dụ, ánh xạ các lần sử dụng cùng một thanh ghi vật lý sang các thanh ghi logic khác nhau.
• Tạm dừng pipeline: Dừng các lệnh sau khi phát hiện rủi ro dữ liệu, đợi cho đến khi dữ liệu sẵn sàng. Phương pháp này làm giảm hiệu suất nhưng dễ triển khai.
• Khắc phục rủi ro điều khiển
• Dự đoán nhánh (Branch Prediction): Dự đoán hướng nhánh của lệnh điều khiển, nạp lệnh dự đoán vào pipeline để thực thi sớm. Nếu dự đoán đúng thì tiếp tục; nếu sai thì phải xóa pipeline và tải lại lệnh đúng. Các phương pháp phổ biến bao gồm dự đoán tĩnh và động.
• Trì hoãn nhánh (Delayed Branch): Di chuyển một số lệnh phía sau lệnh nhánh lên trước để thực thi, không quan tâm đến kết quả nhánh, giúp giảm ảnh hưởng của lệnh nhánh. Những lệnh này gọi là lệnh trì hoãn.
• Khắc phục rủi ro cấu trúc
• Sao chép tài nguyên: Tăng số lượng tài nguyên phần cứng để nhiều lệnh có thể sử dụng tài nguyên khác nhau, tránh xung đột. Ví dụ, thêm cổng bộ nhớ để tránh xung đột khi nhiều lệnh truy cập.
• Lên lịch tài nguyên: Sử dụng thuật toán lên lịch để sắp xếp việc sử dụng tài nguyên, tránh đồng thời sử dụng cùng một tài nguyên. Ví dụ, sử dụng thuật toán ưu tiên để ưu tiên lệnh quan trọng.

Chỉ số hiệu suất của Pipeline

• Năng suất (Throughput): Số lượng tác vụ hoàn thành trong một đơn vị thời gian. Trong lý tưởng, mỗi chu kỳ đồng hồ hoàn thành một giai đoạn, nhưng thực tế sẽ thấp hơn do các rủi ro.
• Tỷ lệ tăng tốc (Speedup): Tỷ lệ thời gian thực thi của tác vụ khi không dùng pipeline so với khi dùng pipeline. Thể hiện mức độ cải thiện tốc độ.
• Hiệu suất: Tỷ lệ thời gian thực tế của các giai đoạn so với tổng thời gian. Hiệu suất cao hơn nghĩa là tài nguyên được sử dụng tối ưu.

Phân loại kiến trúc Pipeline

• Pipeline lệnh: Dùng trong CPU để thực thi lệnh, chia quy trình thực thi thành nhiều giai đoạn để tăng hiệu suất.
• Pipeline toán học: Dùng để xử lý các phép tính số học, chia phép toán thành các giai đoạn như cộng, nhân, v.v., tăng tốc độ xử lý.
• Pipeline xử lý: Kết nối nhiều đơn vị xử lý, mỗi đơn vị thực hiện một phần công việc, tạo thành một pipeline xử lý song song.

Ứng dụng thực tế

• CPU máy tính: Hiện đại sử dụng pipeline để tăng tốc độ thực thi lệnh, ví dụ CPU x86.
• Xử lý tín hiệu số: Dùng trong xử lý âm thanh, video để tăng tốc độ lọc, mã hóa, giải mã.
• Trích xuất học sâu: Trong quá trình suy luận mô hình, chia các tầng tính toán thành các giai đoạn để xử lý song song, tăng tốc độ.

Lưu ý khi thiết kế Pipeline

• Phân chia giai đoạn hợp lý: Mỗi giai đoạn nên có thời gian xử lý gần bằng nhau, tránh tạo nghẽn.
• Thiết kế giao diện rõ ràng: Xác định đầu vào và đầu ra của mỗi giai đoạn để đảm bảo truyền dữ liệu chính xác.
• Xử lý lỗi: Cần có cơ chế phát hiện và xử lý lỗi tại từng giai đoạn để duy trì ổn định hệ thống.

Các cách triển khai Pipeline

Triển khai phần mềm

1. Đa luồng (Multithreading)

• Nguyên lý: Mỗi giai đoạn được triển khai trong một luồng riêng, các luồng chạy song song như công nhân trên dây chuyền sản xuất. Một luồng chịu trách nhiệm một giai đoạn, sau đó chuyển kết quả cho luồng tiếp theo.
• Ví dụ: Trong pipeline xử lý ảnh gồm 3 giai đoạn: đọc ảnh, lọc, phát hiện cạnh. Có thể tạo 3 luồng tương ứng, mỗi luồng thực hiện một giai đoạn. Luồng đầu đọc xong một ảnh, chuyển cho luồng sau xử lý, đồng thời tiếp tục đọc ảnh mới.
• Ưu điểm: Tận dụng khả năng xử lý đa lõi, tăng năng suất. Thời gian chuyển đổi giữa luồng nhỏ.
• Nhược điểm: Cần quản lý đồng bộ hóa, có thể gây ra vấn đề như đua dữ liệu hoặc deadlock, làm phức tạp mã nguồn.

2. Máy trạng thái (State Machine)

• Nguyên lý: Sử dụng máy trạng thái hữu hạn (FSM) để điều khiển luồng công việc trong pipeline. Mỗi trạng thái tương ứng với một giai đoạn. Việc chuyển trạng thái được thực hiện dựa trên điều kiện.
• Ví dụ: Trong pipeline xử lý đơn hàng:

1. Trạng thái S1 (Nhận đơn): Đọc thông tin đơn hàng.
2. Trạng thái S2 (Kiểm tra kho): Kiểm tra tồn kho.
3. Trạng thái S3 (Thanh toán): Gọi API thanh toán.
4. Trạng thái S4 (Giao hàng): Tạo thông tin vận chuyển.

• Ưu điểm: Logic điều khiển rõ ràng, dễ kiểm tra và bảo trì. Linh hoạt trong điều chỉnh điều kiện.
• Nhược điểm: Năng suất bị giới hạn bởi logic phần mềm. Khó tận dụng đa lõi. Khó mở rộng khi có nhiều trạng thái.

3. Triển khai phần cứng

• Nguyên lý: Sử dụng mạch logic và thanh ghi để chia tác vụ thành các giai đoạn, mỗi giai đoạn xử lý trên đơn vị phần cứng riêng. Dữ liệu được truyền đồng bộ theo chu kỳ đồng hồ.
• Ví dụ: Pipeline xử lý 3 giai đoạn:

1. Giai đoạn 1 (Đọc dữ liệu): Đọc từ bộ nhớ vào thanh ghi.
2. Giai đoạn 2 (Tính toán): Dùng bộ cộng để xử lý.
3. Giai đoạn 3 (Ghi kết quả): Ghi kết quả về bộ nhớ.

• Ưu điểm: Hiệu suất cao, độ trễ thấp, tối ưu hóa cho các tác vụ lặp lại.
• Nhược điểm: Phức tạp trong thiết kế, khó thay đổi cấu trúc, tiêu tốn nhiều tài nguyên phần cứng.

So sánh các phương thức

Mã nguồn mẫu C++ triển khai pipeline đa luồng

#include
#include
#include
#include
#include <condition_variable>
#include
#include

// Hàng đợi an toàn cho luồng
template
class SafeQueue {
private:
std::queue queue;
std::mutex mtx;
std::condition_variable cv;
std::atomic stop_flag{false};

public:
void push(T value) {
std::lock_guard lock(mtx);
queue.push(std::move(value));
cv.notify_one();
}

bool pop(T& value) {
std::unique_lock lock(mtx);
cv.wait(lock, [this] { return !queue.empty() || stop_flag; });

if (queue.empty() && stop_flag) return false;

value = std::move(queue.front());
queue.pop();
return true;
}

void stop() {
stop_flag = true;
cv.notify_all();
}
};

// Giai đoạn xử lý 1
void stage1(SafeQueue& input, SafeQueue& output) {
while (true) {
int value;
if (!input.pop(value)) break;

int result = value * value;
output.push(result);

std::cout << "Giai đoạn 1 xử lý: " << value
<< " -> " << result << std::endl;
}
}

// Giai đoạn xử lý 2
void stage2(SafeQueue& input, SafeQueue& output) {
while (true) {
int value;
if (!input.pop(value)) break;

int result = value + 100;
output.push(result);

std::cout << "Giai đoạn 2 xử lý: " << value
<< " -> " << result << std::endl;
}
}

// Giai đoạn xử lý 3
void stage3(SafeQueue& input) {
while (true) {
int value;
if (!input.pop(value)) break;

std::string result = "Kết quả: " + std::to_string(value);

std::cout << "Giai đoạn 3 xử lý: " << value
<< " -> " << result << std::endl;
}
}

int main() {
SafeQueue queue1, queue2, queue3;

std::vector threads;
threads.emplace_back(stage1, std::ref(queue1), std::ref(queue2));
threads.emplace_back(stage2, std::ref(queue2), std::ref(queue3));
threads.emplace_back(stage3, std::ref(queue3));

for (int i = 1; i <= 5; ++i) {
queue1.push(i);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

queue1.stop();
queue2.stop();
queue3.stop();

for (auto& t : threads) {
if (t.joinable()) t.join();
}

return 0;
}