ĐÁNH GIÁ HIỆU NĂNG NHÂN MA TRẬN VỚI THUẬT TOÁN CANNON SỬ DỤNG OPENMP

TRƯỜNG ĐẠI HỌC CÔNG NGHIỆP HÀ NỘI
KHOA CÔNG NGHỆ THÔNG TIN

BÁO CÁO BÀI

TẬP LỚN

Học Phần: TÍNH TỐN HIỆU NĂNG CAO (HPC)
ĐỀ TÀI: ĐÁNH GIÁ HIỆU NĂNG NHÂN MA TRẬN VỚI

THUẬT TOÁN CANNON SỬ DỤNG OPENMP
Giảng viên hướng dẫn
Lớp

: TS Hà Mạnh Đào
: 20231IT6069001

Nhóm thực hiện

: Nhóm 16

1. Nguyễn Hưng Thịnh - 2021603670
2. Lữ Sơn Trường - 2021601393
3. Lê Trần Anh Tú - 2021601281

DANH MỤC


DANH MỤC.............................................................................................................3
DANH MỤC HÌNH ẢNH.......................................................................................5

LỜI MỞ ĐẦU..........................................................................................................6
CHƯƠNG 1: TỔNG QUAN VỀ ĐỀ TÀI..............................................................7
1.1 Mô tả mục tiêu bài tập lớn............................................................................7
1.2 Giới thiệu về nhân ma trận và ứng dụng.........................................................8
1.3 Giới thiệu về OpenMP..................................................................................9
1.4 Giới thiệu về thuật toán Cannon.................................................................13
CHƯƠNG 2: Thiết kế thuật tốn Cannon..........................................................14
2.1 Mơ tả chi tiết thuật toán Cannon...................................................................14
2.2 Thiết kế mã nguồn thuật toán Cannon...........................................................15
2.2.1 Thuật tốn Cannon khơng sử dụng OpenMp.........................................15
2.2.2 Thuật tốn Cannon sử dụng OpenMP....................................................17
2.3 Giải thích tác dụng của OpenMP trong mã nguồn......................................19
2.3.1

Các phân chia cơng việc....................................................................19

2.3.2 Tối ưu hố hiệu suất...............................................................................19
CHƯƠNG 3: THỰC NGHIỆM...........................................................................20
3.1 Mơi trường thực nghiệm và bài tốn.............................................................20
3.1.1 Mơi trường thực nghiệm.........................................................................20
3.1.2 Bài tốn...................................................................................................20
3.2 Thực hiện thực nghiệm và kết luận...............................................................21
3.2.1 Thực nghiệm với mã nguồn không sử dụng OpenMP...........................21
3.2.2 Thực nghiệm với mã nguồn có sử dụng OpenMP..................................22
3.3 Kết luận.........................................................................................................23

LỜI MỞ ĐẦU


Khoanh vùng giữa hiện thực và khả năng, tính tốn hiệu năng cao không chỉ

là một khái niệm, mà là cột mốc dẫn đường cho sự tiến bộ và sự phát triển trong
thế giới cơng nghệ ngày nay. Được hình thành từ việc tận dụng tối đa tài ngun
tính tốn, hiệu năng cao khơng chỉ địi hỏi sự tinh tế trong thiết kế mà còn yêu cầu
sự kết hợp tuyệt vời giữa kiến thức lý thuyết và ứng dụng thực tế.
Nhìn rộng hơn, mơn tính tốn hiệu năng cao khơng chỉ là về việc tối ưu hóa thuật
tốn hay tăng cường sức mạnh tính tốn. Đó cịn là việc thấu hiểu sâu sắc về cách
các yếu tố kỹ thuật, từ cấu trúc dữ liệu đến cấu trúc máy tính, hịa quyện vào nhau
để tạo ra những giải pháp đột phá, từ ứng dụng di động đến các hệ thống phức tạp
địi hỏi sự xử lý cực kỳ nhanh chóng.
Tính tốn hiệu năng cao không chỉ tập trung vào việc làm cho mọi thứ chạy nhanh
hơn, mà còn là việc định hình lại cách chúng ta nghĩ về khả năng và giới hạn của
công nghệ. Qua sự tiến bộ không ngừng, chúng ta có thể đạt được những tiến bộ kỳ
diệu mà trước đây dường như không thể. Đây là cuộc hành trình khơng chỉ tạo ra
những sản phẩm và dịch vụ tuyệt vời, mà cịn định hình lại cả nền văn hóa cơng
nghiệp và khoa học kỹ thuật.
Với những cơ hội và thách thức khơng ngừng, mơn tính tốn hiệu năng cao là hành
trình khơng chỉ đầy thú vị mà còn đầy hứa hẹn, mở ra cánh cửa cho sự sáng tạo và
đổi mới vô tận.


CHƯƠNG 1: TỔNG QUAN VỀ ĐỀ TÀI
1.1 Mô tả mục tiêu bài tập lớn
Bài tập lớn này nhằm tập trung vào việc nghiên cứu, thử nghiệm và đánh giá hiệu
năng của thuật tốn nhân ma trận Cannon sử dụng cơng nghệ song song hóa
OpenMP. Mục tiêu chính là hiểu rõ về cách thuật toán Cannon hoạt động, áp dụng
hiệu quả của OpenMP để tối ưu hóa việc nhân ma trận và đánh giá hiệu suất của
thuật toán trên nền tảng đa lõi.

- Hiểu Rõ Thuật Toán Cannon:
Trước hết, chúng ta sẽ thâm nhập vào cách thuật toán Cannon thực hiện nhân ma

trận. Bao gồm quá trình chia ma trận thành các khối, phân phối công việc cho các
lõi xử lý, và cách thức di chuyển khối ma trận để tận dụng song song hóa việc tính
tốn.

- Áp Dụng OpenMP vào Thuật Toán Cannon:
Sau khi nắm vững thuật toán, chúng ta sẽ đi sâu vào việc áp dụng công nghệ song
song hóa OpenMP vào thuật tốn Cannon. Chia nhỏ cơng việc và quản lý luồng để
tận dụng hiệu suất tính tốn trên các hệ thống đa lõi.

- Đo Đạc và Phân Tích Hiệu Suất:
Bước tiếp theo sẽ là thực hiện thử nghiệm trên các bộ dữ liệu kiểm tra và ma trận
thử nghiệm để đo đạc thời gian thực hiện và tài ngun sử dụng của thuật tốn.
Phân tích hiệu suất trên các kích thước ma trận và loại dữ liệu khác nhau để đánh
giá tính linh hoạt và hiệu quả của thuật toán.

- So Sánh và Đánh Giá Kết Quả:
Kết quả thu được từ thực nghiệm sẽ được so sánh và phân tích để đưa ra nhận xét
về hiệu suất của thuật tốn Cannon sử dụng OpenMP. Từ đó, chúng ta có thể tìm ra
điểm mạnh, điểm yếu và cải thiện tiềm năng của thuật toán trong các trường hợp
dữ liệu khác nhau.

- Tối Ưu Hóa và Đề Xuất Cải Tiến:
Cuối cùng, bằng việc tổng hợp kết quả và thông tin thu được, chúng ta sẽ đề xuất
các cải tiến hoặc tối ưu hóa trong thuật tốn để nâng cao hiệu suất và tận dụng tối
đa tiềm năng của hệ thống đa lõi.


- Mục Tiêu Tổng Quát:
Bằng cách hoàn thành bài tập này, mục tiêu cuối cùng là hiểu rõ hơn về cách thức
hoạt động và hiệu suất của thuật toán Cannon khi áp dụng cơng nghệ song song

hóa OpenMP. Đồng thời, từ những hiểu biết và kết quả thu được, chúng ta có cơ sở
để cải thiện và tối ưu hóa thuật toán để phục vụ cho các ứng dụng và nhu cầu tính
tốn trong thực tế.
1.2 Giới thiệu về nhân ma trận và ứng dụng
Nhân ma trận là một trong những phép toán cơ bản và quan trọng trong đại số
tuyến tính. Q trình nhân ma trận thực hiện việc kết hợp các giá trị từ các hàng
của ma trận đầu tiên với các giá trị từ các cột của ma trận thứ hai để tạo ra ma trận
mới.
Công Thức Nhân Ma Trận:
Giả sử có hai ma trận A và B với kích thước lần lượt là m x n và n x p, kết quả của
việc nhân hai ma trận này sẽ tạo ra một ma trận C có kích thước m x p. Q trình
nhân ma trận được thực hiện bằng cách nhân từng phần tử trong hàng của ma trận
A với từng phần tử trong cột của ma trận B tương ứng và tổng hợp kết quả.
Ví dụ:
Ma trận A kích thước 2x3:
|123|
|456|
Ma trận B kích thước 3x2:
|78|
| 9 10 |
| 11 12 |
Kết quả của việc nhân hai ma trận A và B sẽ tạo ra ma trận C kích thước 2x2:
| 58 64 |
| 139 154 |
Ứng Dụng của Nhân Ma Trận:


- Xử Lý Ảnh và Đồ Họa:
Trong xử lý ảnh và đồ họa máy tính, việc nhân ma trận rất quan trọng để thực hiện
các biến đổi hình học, chuyển đổi màu sắc và hiệu chỉnh ảnh.

- Mạng Nơ-ron và Học Máy:
Trong lĩnh vực học máy và mạng nơ-ron, việc nhân ma trận thường xuyên được sử
dụng để thực hiện các phép tính cơ bản trong q trình huấn luyện mơ hình và dự
đốn.

- Tính Tốn Khoa Học và Kỹ Thuật:
Trong các ứng dụng tính tốn khoa học và kỹ thuật, việc nhân ma trận thường được
sử dụng để giải quyết các phương trình đạo hàm riêng, giải các hệ phương trình
tuyến tính, và nhiều ứng dụng tính tốn khác.

- Xử Lý Dữ Liệu và Tính Tốn Song Song:
Trong các ứng dụng xử lý dữ liệu lớn và tính tốn song song, việc nhân ma trận
được tối ưu hóa để thực hiện trên nhiều lõi CPU hoặc GPU.
Việc nhân ma trận khơng chỉ là một phép tốn cơ bản mà còn là một yếu tố quan
trọng trong nhiều lĩnh vực khác nhau, đặc biệt là trong lĩnh vực tính tốn và xử lý
dữ liệu lớn.

1.3Giới thiệu về OpenMP
OpenMP (Open Multiprocessing) là một giao diện lập trình ứng dụng song song
(API) dành cho việc lập trình các ứng dụng song song trên các hệ thống đa lõi và
phân tán. Nó cung cấp một cách tiếp cận linh hoạt và tiện lợi để tận dụng tài
nguyên xử lý đa lõi, giúp các nhà phát triển viết mã song song dễ dàng hơn.
Đặc Điểm Chính của OpenMP:

- Dễ Sử Dụng: OpenMP được thiết kế để đơn giản và dễ sử dụng, cho phép
nhà phát triển song song hóa ứng dụng một cách tương đối nhanh chóng và
hiệu quả.
- Hỗ Trợ Đa Nền Tảng: Nó là một tiêu chuẩn được hỗ trợ trên nhiều nền tảng
phần cứng và hệ điều hành, từ máy tính cá nhân cho đến các siêu máy tính

và cụm máy tính phân tán.


- Tính Chất Mở và Quen Thuộc: OpenMP là một chuẩn mở được duy trì và
phát triển bởi một nhóm các công ty và tổ chức. Điều này đảm bảo tính liên
tục và quen thuộc khi di chuyển giữa các nền tảng khác nhau.
- Hỗ Trợ Đa Dạng Các Cấu Trúc: OpenMP hỗ trợ song song hóa trên nhiều
loại cấu trúc, bao gồm vịng lặp, phân chia cơng việc, các khối mã, và nhiều
loại phép tính khác.
- Tăng Cường Hiệu Năng: Bằng cách tận dụng tài nguyên đa lõi và việc phân
chia công việc, OpenMP giúp tăng cường hiệu suất tính tốn của ứng dụng.
- Thích Hợp cho Mọi Kích Thước Dự Án: Từ những dự án nhỏ đến các dự án
lớn quy mơ cao, OpenMP có thể được áp dụng một cách linh hoạt và phù
hợp.
Cấu Trúc Cơ Bản của OpenMP:

- Chỉ Thị #pragma: Sử dụng các chỉ thị #pragma để thêm chỉ dẫn song song
hóa vào mã nguồn C/C++.
- API Functions: Bên cạnh việc sử dụng chỉ thị #pragma, OpenMP cũng cung
cấp một số hàm API để kiểm soát các hoạt động song song, như quản lý các
luồng và tài ngun.
Ứng Dụng của OpenMP:

- Tính Tốn Khoa Học và Tính Tốn Đa Phương Tiện: OpenMP thường được
sử dụng rộng rãi trong các lĩnh vực như tính tốn khoa học, mơ phỏng, xử lý
hình ảnh, video và âm thanh.
- Cơ Sở Dữ Liệu và Xử Lý Dữ Liệu Lớn:Trong các ứng dụng liên quan đến
cơ sở dữ liệu và xử lý dữ liệu lớn, OpenMP cũng đóng vai trị quan trọng để
tối ưu hóa việc xử lý song song.
Các chỉ thị phổ biến trong OpenMP:

1. #pragma omp parallel
Chức Năng: Tạo một nhóm các luồng song song.
Sử Dụng: Sử dụng để tạo các luồng song song, mỗi luồng thực hiện một phần của
mã trong khối được chỉ định.
Ví Dụ:
#pragma omp parallel


{
// Mã được thực thi song song
printf("Hello, world!\n");
}
2. #pragma omp for
Chức Năng: Phân chia vòng lặp cho các luồng.
Sử Dụng: Sử dụng để song song hóa vịng lặp, phân chia cơng việc của vịng lặp
cho các luồng trong một nhóm song song.
Ví Dụ:
#pragma omp parallel
{
#pragma omp for
for (int i = 0; i < n; ++i) {
// Mã trong vòng lặp được thực thi song song
printf("Iteration %d\n", i);
}
}
3. Hàm API omp_get_thread_num()
Chức Năng: Trả về ID của luồng hiện tại.
Sử Dụng: Sử dụng để xác định ID của luồng đang thực thi trong một nhóm song
song.
Ví Dụ:

#pragma omp parallel
{
int thread_id = omp_get_thread_num();
printf("Hello from thread %d\n", thread_id);


}
4. Hàm omp_get_num_threads()
Chức Năng: Trả về số lượng luồng trong nhóm song song.
Sử Dụng: Sử dụng để biết số lượng luồng đang thực thi trong một nhóm song song.
Ví Dụ:
int num_threads = omp_get_num_threads();
printf("Number of threads: %d\n", num_threads);
5. #pragma omp atomic
Chức Năng: Thực hiện các phép toán nguyên tử.
Sử Dụng: Sử dụng để đảm bảo các phép toán thực hiện nguyên tử mà khơng bị
xung đột giữa các luồng.
Ví Dụ:
#pragma omp parallel
{
#pragma omp atomic
sum += 1;
}
6. #pragma omp barrier
Chức Năng: Đồng bộ hóa các luồng.
Sử Dụng: Sử dụng để đảm bảo rằng tất cả các luồng đã đạt đến một điểm cụ thể
trong mã trước khi tiếp tục thực hiện.
Ví Dụ:
#pragma omp parallel
{

// Mã song song
#pragma omp barrier


// Mã tiếp theo
}

1.4 Giới thiệu về thuật toán Cannon
Thuật toán Cannon là một trong những thuật toán phổ biến được sử dụng để nhân
hai ma trận trong môi trường tính tốn song song. Đặc điểm chính của thuật tốn
này là việc phân chia ma trận đầu vào thành các ô con (submatrix) và thực hiện các
phép di chuyển xoay vịng (cyclic shift) giữa các ơ con này trên một lưới hai chiều
của các tiến trình (processors grid). Thuật tốn này thường được áp dụng trong mơi
trường tính tốn song song như hệ thống đa lõi hoặc cụm máy tính.
Các Bước Cơ Bản của Thuật Toán Cannon:

- Phân Chia Ma Trận: Ma trận được phân chia thành các ô con, mỗi ơ con
được gửi đến mỗi tiến trình.
- Di Chuyển Dữ Liệu: Các ô con của ma trận được di chuyển giữa các tiến
trình theo hướng xoay vịng trên lưới hai chiều.
- Nhân Ma Trận: Sau khi dữ liệu được di chuyển, mỗi tiến trình thực hiện
phép nhân ma trận trên các ơ con mà nó giữ.
- Tổ Hợp Kết Quả: Kết quả từ các phép nhân ma trận trên các ô con được tổ
hợp để tạo ra ma trận kết quả cuối cùng.
Ứng Dụng của Thuật Tốn Cannon:

- Tính Toán Song Song và Đa Lõi: Cannon là một trong những thuật tốn phổ
biến được sử dụng trong tính tốn song song, đặc biệt là trên các hệ thống đa
lõi, cụm máy tính và trong các mơi trường tính tốn phân tán.
- Xử Lý Dữ Liệu Lớn và Tính Tốn Khoa Học: Trên các nền tảng tính tốn

khoa học và xử lý dữ liệu lớn, Cannon cung cấp cách tiếp cận hiệu quả để
thực hiện các phép nhân ma trận với hiệu suất cao.
- Mơ Hình Học Máy và Xử Lý Hình Ảnh: Trong lĩnh vực mơ hình học máy,
xử lý hình ảnh và đồ họa máy tính, việc sử dụng thuật tốn nhân ma trận như
Cannon có thể giúp tối ưu hóa q trình tính tốn.
Thuật tốn Cannon là một phương pháp hiệu quả để thực hiện nhân ma trận trong
môi trường song song, đặc biệt là trên các hệ thống tính tốn có cấu trúc lưới. Việc
phân chia ma trận và di chuyển dữ liệu giữa các tiến trình giúp tận dụng tài nguyên


tính tốn một cách hiệu quả để tăng cường hiệu suất tính tốn của phép nhân ma
trận.

CHƯƠNG 2: Thiết kế thuật tốn Cannon
2.1 Mơ tả chi tiết thuật tốn Cannon
Để mơ tả chi tiết thuật tốn Cannon sử dụng OpenMP trong việc nhân ma trận,
trước hết, chúng ta cần hiểu rõ thuật tốn Cannon và cách OpenMP có thể được áp
dụng để tối ưu hóa việc thực hiện thuật tốn này trên nhiều luồng.
Thuật toán Cannon được sử dụng để nhân hai ma trận vng có kích thước N×N
bằng cách chia mỗi ma trận thành các ô con và di chuyển chúng theo một cách nhất
định trên lưới ma trận 2D ảo. Mỗi bước của thuật toán này liên quan đến việc nhân
ma trận con và cập nhật kết quả trong ma trận kết quả.
Khi sử dụng OpenMP để tối ưu hóa thuật tốn Cannon, chúng ta có thể tận dụng
tính song song của nhiều luồng để thực hiện các phép tính ma trận đồng thời.
Đầu tiên, việc triển khai thuật toán Cannon bằng OpenMP yêu cầu phân chia ma
trận đầu vào thành các ô con. Mỗi luồng sẽ thực hiện việc nhân ma trận con tương
ứng và cập nhật ma trận kết quả tương ứng của chúng.
Một cách tiếp cận phổ biến là sử dụng các hàm và chỉ thị OpenMP như #pragma
omp parallel để tạo các luồng song song. Điều này cho phép chúng ta chia nhỏ
công việc nhân ma trận vào các phần nhỏ hơn và gán từng phần cho các luồng

riêng biệt. Đồng thời, việc sử dụng chỉ thị như #pragma omp for có thể áp dụng để
phân phối cơng việc tính tốn của từng ơ con ma trận cho các luồng.
Cần chú ý rằng việc phân phối công việc phải được thực hiện một cách cẩn thận để
tránh xung đột và đảm bảo tính đồng nhất của kết quả. Điều này có thể địi hỏi sử
dụng các cấu trúc dữ liệu phù hợp và việc đồng bộ hóa phù hợp giữa các luồng.
Ngồi ra, tối ưu hóa hiệu suất của thuật tốn Cannon thơng qua OpenMP cũng đòi
hỏi việc sử dụng các phương pháp như tối ưu hóa bộ nhớ đệm (cache) và tránh các
truy cập khơng đồng bộ đến bộ nhớ chung.
Trong q trình triển khai, việc đánh giá và tinh chỉnh thông qua thử nghiệm với
các kích thước ma trận khác nhau cũng là một phần quan trọng để đảm bảo thuật
toán hoạt động hiệu quả trên nền tảng có nhiều lõi xử lý.


Trên tất cả, việc triển khai thuật toán Cannon sử dụng OpenMP đòi hỏi sự hiểu biết
sâu sắc về thuật tốn cơ bản, kiến thức vững về lập trình song song và khả năng tối
ưu hóa hiệu suất của mã nguồn để có được kết quả tốt nhất.
Việc sử dụng OpenMP trong thuật toán Cannon nhằm tận dụng sức mạnh của việc
thực hiện song song trên nhiều lõi xử lý, giúp tăng hiệu suất và giảm thời gian tính
tốn cho việc nhân ma trận lớn.
Dưới đây là các bước thiết kế:
1. Phân Chia Ma Trận:
- Sử dụng chỉ thị #pragma omp parallel để tạo ra các luồng song song.
- Chia ma trận đầu vào thành các ô con (submatrix) và phân phối chúng cho
các luồng.
2. Di Chuyển Dữ Liệu:
- Sử dụng chỉ thị #pragma omp for để thực hiện việc di chuyển dữ liệu giữa
các luồng theo hướng xoay vòng.
- Sử dụng các chỉ thị #pragma omp barrier để đồng bộ hóa các luồng trước khi
bắt đầu phép nhân.
3. Phép Nhân Ma Trận Trên Các Ô Con:

- Mỗi luồng thực hiện phép nhân ma trận trên các ô con mà nó giữ.
- Sử dụng các chỉ thị và hàm của OpenMP để tận dụng tính song song của các
tiến trình.
4. Tổ Hợp Kết Quả:
- Tổ hợp kết quả từ các phép nhân ma trận trên các ô con để tạo ra ma trận kết
quả cuối cùng.
2.2 Thiết kế mã nguồn thuật tốn Cannon
2.2.1 Thuật tốn Cannon khơng sử dụng OpenMp
Dưới đây mà mã nguồn của thuật tốn Cannon khi khơng sử dụng OpenMP
#include <iostream>
#include <vector>
#include <chrono>
using namespace std;
using namespace std::chrono;


const int matrixSize = 10;
// Function to print a matrix
void printMatrix(const vectorfor (const auto& row : matrix) {
for (double element : row) {
cout << element << " ";
}
cout << endl;
}
}
int main() {
vectorvectorvector

// Đo thời gian bắt đầu
auto start = high_resolution_clock::now();
// Cannon's algorithm for matrix multiplication
for (int i = 0; i < matrixSize; ++i) {
for (int j = 0; j < matrixSize; ++j) {
for (int k = 0; k < matrixSize; ++k) {
C[i][j] += A[i][(i + k) % matrixSize] * B[(i + k) % matrixSize][(i + j + k)
% matrixSize];
}
}
}


// Đo thời gian kết thúc
auto stop = high_resolution_clock::now();
// Tính thời gian chạy
auto duration = duration_cast<microseconds>(stop - start);
// In ra thời gian chạy
cout << "Time taken by function: " << duration.count() << " microseconds" <<
endl;
// Print the resulting matrix C
cout << "Resultant Matrix C:" << endl;
printMatrix(C);
return 0;
}

2.2.2 Thuật toán Cannon sử dụng OpenMP
Dưới đây là mã nguồn của thuật toán Cannon sử dụng OpenMP:
#include <iostream>
#include <vector>

#include <chrono>
#include <omp.h>
using namespace std;
using namespace std::chrono;
const int matrixSize = 10;
// Function to print a matrix
void printMatrix(const vectorfor (const auto& row : matrix) {
for (double element : row) {


cout << element << " ";
}
cout << endl;
}
}
int main() {
vectorvectorvector// Đo thời gian bắt đầu
auto start = high_resolution_clock::now();
#pragma omp parallel for collapse(2) // Song song hóa vịng lặp
for (int i = 0; i < matrixSize; ++i) {
for (int j = 0; j < matrixSize; ++j) {
for (int k = 0; k < matrixSize; ++k) {
C[i][j] += A[i][(i + k) % matrixSize] * B[(i + k) % matrixSize][(i + j + k)
% matrixSize];
}
}

}
// Đo thời gian kết thúc
auto stop = high_resolution_clock::now();
// Tính thời gian chạy
auto duration = duration_cast<microseconds>(stop - start);
// In ra thời gian chạy


cout << "Time taken by function: " << duration.count() << " microseconds" <<
endl;
// Print the resulting matrix C
cout << "Resultant Matrix C:" << endl;
printMatrix(C);
return 0;
}

2.3 Giải thích tác dụng của OpenMP trong mã nguồn
2.3.1 Các phân chia công việc
- Chỉ Thị #pragma omp parallel for collapse(2): Đây là một cách tiếp cận mạnh mẽ
của OpenMP để song song hóa vịng lặp. Trong trường hợp này, collapse(2) được
sử dụng để kết hợp hai vòng lặp i và j vào một lệnh song song duy nhất.
- Parallelism Cấp Tổng Quát (parallel): Chỉ thị parallel được sử dụng để tạo ra một
nhóm các luồng song song để thực hiện các vòng lặp. Khi sử dụng parallel,
OpenMP tự động tạo ra và quản lý một pool các luồng, mỗi luồng sẽ chịu trách
nhiệm thực hiện một phần của công việc song song.
- Collapse(2): Chức năng của collapse là kết hợp nhiều vòng lặp thành một vòng
lặp duy nhất. Trong trường hợp này, collapse(2) kết hợp cả hai vòng lặp i và j vào
một lệnh song song duy nhất. Điều này cho phép mỗi luồng xử lý một phần của ma
trận kết quả thông qua việc nhân ma trận.
- Work Sharing (for): Chỉ thị for cung cấp cách tiếp cận song song hóa các vịng

lặp. Bằng cách sử dụng for, các luồng có thể chia sẻ cơng việc của vịng lặp và mỗi
luồng sẽ thực hiện một phần của vòng lặp. Trong trường hợp này, vịng lặp i và j
của thuật tốn Cannon được phân chia giữa các luồng để tối ưu hiệu suất tính toán..
2.3.2 Tối ưu hoá hiệu suất

- Tận Dụng Song Song Hóa Cơng Việc: OpenMP giúp tận dụng tính song
song của các tiến trình, cho phép các vịng lặp i và j thực hiện đồng thời trên
nhiều luồng, giúp cải thiện hiệu suất tính tốn.


- Optimization Directives (Chỉ thị tối ưu hóa): Trong trường hợp này, khơng
có chỉ thị tối ưu hóa cụ thể được sử dụng, nhưng OpenMP cung cấp nhiều
chỉ thị tối ưu hóa khác nhau như collapse, parallel, for, simd,... để tối ưu hiệu
suất của mã nguồn.
- Tính Paralellism (Tính song song): Bằng cách phân chia vòng lặp i và j để
chạy song song trên nhiều luồng, chương trình có khả năng tận dụng tối đa


CHƯƠNG 3: THỰC NGHIỆM
3.1 Môi trường thực nghiệm và bài tốn
3.1.1 Mơi trường thực nghiệm
Thơng tin máy tính:

-

Laptop HP victus 16
CPU: AMD Ryzen 5 5600H with Radeon Graphics 3.30HZ
Ram: 8 GB
System type: 64-bit operating system

Môi trường: Sử dụng Visual C++ và OpenMP
Phương pháp thực hiện: Đo lường và so sánh thời gian thực thi việc nhân ma trận
giữa hai mã nguồn, một mã nguồn sử dụng OpenMP và một mã nguồn khơng sử
dụng OpenMP
3.1.2 Bài tốn
Thực hiện thực hiện ba trường hợp để so sánh rõ ràng thời gian thực thi:

- TH1: Nhân hai ma trận 10 x 10
- TH2: Nhân hai ma trận 100 x 100
- TH3: Nhân hai ma trận 1000 x 1000 (Trường hợp này không tiến hành in
phần tử )


3.2 Thực hiện thực nghiệm và kết luận
3.2.1 Thực nghiệm với mã nguồn không sử dụng OpenMP
TH1: Ma trận 10 x 10

TH2: Ma trận 100 x 100

TH3: Ma trận 1000 x 1000