ĐÁNH GIÁ HIỆU NĂNG BÀI TOÁN TÍNH NGHỊCH ĐẢO MA TRẬN BẰ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 BTL THUỘC HỌC PHẦN:
TÍNH TỐN HIỆU NĂNG CAO
ĐÁNH GIÁ HIỆU NĂNG BÀI TỐN TÍNH NGHỊCH ĐẢO
MA TRẬN BẰNG OPENMP
Giáo viên hướng dẫn: TS. Hà Mạnh Đào
Nhóm sinh viên thực hiện:
1, Vũ Văn Tuệ

Mã SV: 2021606491

2, Lê Hoàng An

Mã SV: 2021604365

3, Nguyễn Minh Đức

Mã SV: 2021607287

Mã Lớp: 20231IT6069001

Nhóm: 10

Hà nội, Năm 2023


LỜI CẢM ƠN
Lời đầu tiên, chúng em xin bày tỏ lòng biết ơn sâu sắc đến TS. Hà

Mạnh Đào, người đã dành thời gian và tâm huyết để hướng dẫn chúng em
trong q trình nghiên cứu và hồn thiện đề tài. Sự am hiểu chuyên sâu và
lòng tận tâm của thầy đã giúp chúng em có thêm những kiến thức sâu sắc về
bộ mơn tính tốn hiệu năng cao.
Chúng em trân trọng mọi lời góp ý và phản hồi mang tính xây dựng từ
phía thầy. Đây là cơ hội quý báu để chúng em có thể hồn thiện và nâng cao
chất lượng của đề tài. Sự hỗ trợ và chia sẻ kinh nghiệm của thầy là nguồn
động viên lớn, giúp chúng em không chỉ làm việc hiệu quả hơn mà cịn trở
nên chín chắn hơn trong lĩnh vực nghiên cứu.
Chúng em cảm nhận sâu sắc lòng nhân ái và sự hướng dẫn tận tâm của
TS. Hà Mạnh Đào. Những giờ giảng, những lời khuyên hữu ích và sự động
viên của thầy đã tạo nên một hành trình học tập đầy ý nghĩa và khám phá.
2

Chúng em xin chân thành cảm ơn thầy vì những đóng góp to lớn và sẽ ln
mang theo sự tri ân này trong lịng trong hành trình phát triển của chúng tơi.

Cảm ơn thầy rất nhiều!

Tính toán hiệu năng cao


LỜI MỞ ĐẦU
Trong thời đại ngày nay, việc tối ưu hóa và đánh giá hiệu năng của các
thuật tốn tính toán là một thách thức quan trọng, đặc biệt là trong lĩnh vực xử
lý ma trận. Bài tốn tính ma trận nghịch đảo, một trong những vấn đề lớn của
đại số tuyến tính, đặt ra nhu cầu về hiệu suất cao và sự tận dụng tối đa tài
nguyên hệ thống.
Trong nỗ lực tối ưu hóa hiệu năng cho bài tốn này, chúng em chọn sử
dụng OpenMP - một tiêu chuẩn lập trình đa luồng mở, để mơ phỏng và đánh

giá hiệu năng của thuật tốn tính ma trận nghịch đảo. OpenMP cung cấp một
cách tiếp cận linh hoạt để tận dụng sức mạnh của các lõi xử lý đa nhiệm trên
các kiến trúc máy tính hiện đại.
Trong đề tài này, chúng em sẽ trình bày quy trình và kết quả của việc
ứng dụng OpenMP trong bài tốn tính ma trận nghịch đảo, đồng thời đánh giá
hiệu năng của thuật toán sau khi tối ưu hóa. Điều này khơng chỉ giúp chúng
3

em hiểu rõ hơn về khả năng của OpenMP mà cịn mang lại những thơng tin
quan trọng về khả năng mở rộng và tối ưu hóa trong việc xử lý ma trận lớn.
Chúng em hi vọng rằng nghiên cứu này sẽ đóng góp một phần nhỏ vào sự
phát triển và ứng dụng hiệu suất của các thuật toán đại số tuyến tính trong mơi
trường tính tốn đa luồng ngày nay.

Tính toán hiệu năng cao


MỤC LỤC
Chương 1.
1.1

Giới thiệu về OpenMP và thư viện..........................................................................5

1.1.1

OpenMP là gì?..................................................................................................5

1.1.2

Mơ hình song song OpenMP............................................................................5

1.1.3

Tổng quan về API OpenMP.............................................................................7

1.1.4

Cú pháp OpenMP...........................................................................................10

1.1.5

Hiệu suất với OpenMP...................................................................................10

1.1.6

Ưu nhược điểm và tính năng OpenMP..........................................................11

1.2

Giới thiệu về MPI...................................................................................................12

1.2.1

Phương pháp khử Gassian..............................................................................12

1.2.2

Phân tích bài tốn...........................................................................................15

Chương 2.

4

Tổng quan về OpenMP.........................................................................................5

2.1

Kết quả nghiên cứu.............................................................................................17

Thiết kế thuật toán tuần tự phép khử Gassian........................................................17

2.1.1

Bài tốn..........................................................................................................17

2.1.2

Thuật tốn.......................................................................................................17

2.2

Tận dụng tính song song........................................................................................19

Chương 3.
3.1

Kết luận và bài học kinh nghiệm........................................................................22

Kết quả đánh giá trên ma trận khác nhau...............................................................22

3.1.1

Thông số hệ thống..........................................................................................22

3.1.2

Thiết lập bài toán............................................................................................22

3.1.3

Thống kê thời gian.........................................................................................22

3.1.4

Thống kê thời gian.........................................................................................23

3.1.5

Kết luận..........................................................................................................24

TÀI LIỆU THAM KHẢO........................................................................................................25

Tính tốn hiệu năng cao


Chương 1. Tổng quan về OpenMP
1.1 Giới thiệu về OpenMP và thư viện

1

2

OpenMP là gì?
OpenMP (Open Multi-Processing) là một tiêu chuẩn lập trình đa luồng
mở được thiết kế để tận dụng sức mạnh của xử lý đa nhân (multicore) và đa
luồng trong các kiến trúc máy tính hiện đại. Mục tiêu chính của OpenMP là
giúp nhà phát triển tận dụng tài nguyên xử lý đa nhiệm một cách hiệu quả mà
không cần sự chú ý chi tiết đối với các vấn đề phức tạp của lập trình đa luồng.
OpenMP là một giao diện lập trình ứng dụng(API) được định nghĩa bởi
một nhóm các tổ chức phần cứng chuyên dụng và các nhà cung cấp phần
mềm. OpenMP cung cấp một mô hình lập trình linh động, có thể mở rộng cho
các nhà phát triển trên mơ hình tính tốn song song cho bộ nhớ chia sẻ.
OpenMP hỗ trợ các ngôn ngữ là C/C++ và Fortran trên một lượng rộng
các kiến trúc phần cứng khác nhau. Trong đề tài này chúng tôi sẽ sử dụng
5

OpenMP trên môi trường C++ để cài đặt và minh họa hiệu suất của thuật toán
nhân ma trận khi làm việc trên hai mơ hình lập trình là tuần tự và song song.
Các ưu điểm của OpenMP bao gồm tính di động, tính chất đa nền tảng, và
khả năng tích hợp dễ dàng vào mã nguồn hiện tại mà không cần thay đổi quá
nhiều. Bằng cách sử dụng OpenMP, người lập trình có thể tận dụng hiệu quả
sức mạnh của các bộ xử lý đa nhân, giúp cải thiện hiệu suất của ứng dụng của
họ trong môi trường tính tốn đa luồng và đa nhân.
Mơ hình song song OpenMP
Cơ chế đa luồng
 OpenMP thực hiện việc tính tốn song song tuân theo cơ chế đa
luồng. Luồng là một đơn vị thực thi nhỏ nhất của một tiến trình
và có thể được sắp lịch bởi hệ điều hành. Trong một tiến trình có
thể có nhiều luồng thực thi.
Song song tường minh

Tính tốn hiệu năng cao


 Khơng giống như một số mơ hình lập trình song song được trừu
tượng hóa tự động khác, OpenMP yêu cầu người lập trình điều
khiển tồn bộ hoạt động tính tốn song song. Một chương trình
song song có thể được xây dựng trong OpenMP bằng việc chèn
thêm các chỉ thị tiền xử lý vào một chương trình tuần tự bình
thường.
Cơ chế bộ nhớ chia sẻ

6

Hình 1. 1 Mơ hình lập trình bộ nhớ chia sẻ
 OpenMP được thiết kế cho hệ thống đa nhân chia sẻ bộ nhớ trên
các kiến trúc có thể kể tên như UMA, hay NUMA. Trong
OpenMP mọi luồng đều có thể truy cập đến vùng nhớ tồn cục.
Dữ liệu có thể là tồn cục hoặc riêng tư giữa các luồng. Việc
đồng bộ hóa có thể được thực hiện bởi người lập trình nhưng
phần lớn được tự động.
Mơ hình fork – join
 OpenMP sử dụng mơ hình fork-join cho việc thực thi song song.
Một chương trình OpenMP ban đầu là một tiến trình đơn thực
hiện tuần tự cho đến khi gặp một đoạn chỉ thị song song sẽ được
rẽ nhánh ra thành các chương trình con, sau khi thực hiện xong
thì sẽ lại về một luồng chính. Fork chỉ q trình rẽ nhánh, Join
Tính tốn hiệu năng cao


chỉ q trình hợp lại.

Hình 1. 2 Minh họa mơ hình Fork join của OpenMP
Các đoạn song song lồng nhau
 OpenMP các luồng song song tiếp tục tách thành các luồng song
song nhỏ hơn nhằm đẩy mạnh tốc độ tính tốn.

3

Tổng quan về API OpenMP
OpenMP gồm các thành phần chính sau:
 Các chỉ thị biên dịch
7

 Thư viện lập lịch thời gian chạy
 Các biến môi trường
Cấu trúc chỉ thị biên dịch trong OpenMP
 Chỉ thị biên dịch được sử dụng với các mục đích:
 Sinh ra một luồng các chương trình song song
 Phân chia các khối lệnh giữa các luồng
 Thực hiện tuần tự các đoạn mã được chỉ định
 Đồng bộ hóa cơng việc giữa các luồng
 Cú pháp của một chỉ thị tiền xử lý OpenMP trong C++
#pragma omp [Tên chỉ thị] [Các đối số bổ sung]
Thư viện lập lịch thời gian chạy
 OpenMP bao gồm nhiều thư viện lập lịch thời gian chạy với
được sử dụng cho các mục đích sau:
 Thiết đặt truy vấn số luồng
 Truy vấn id của luồng, số luồng hiện có
Tính tốn hiệu năng cao

 Truy vấn chu kỳ đồng hồ và phân giải
Các biến môi trường
 OpenMP cung cấp các biến môi trường giúp người lập trình
cấu hình thời gian chạy cho đoạn thực thi song song.
 Biến môi trường thường được sử dụng cho các mục đích sau
 Thiết đặt số luồng
 Chỉ định cách các lần lặp trong vòng lặp được chia ra cho
các luồng
 Gán các luồng với các tiến trình
 Thiết lập cấu trúc ngăn xếp

8

Cấu trúc tổng quát của một đoạn chương trình OpenMP
#include <omp.h>
main () {

Tính tốn hiệu năng cao


4

5

Cú pháp OpenMP
Một số chỉ thị tiền xử lý:
 parallel: Chỉ thị bắt đầu đoạn code song song
 for: Thực hiện vòng lặp for bên trong vùng song song được chia cho
các luồng

 sections: Xác định các phần mã được chia sẻ cho các luồng
 single: Chỉ định phần mã được thực thi trên một luồng duy nhất
 master: Chỉ ra luồng chính được thực thi của một chương trình
 critical: Chỉ định phần mã là đoạn giới hạn (Đoạn chương trình sử dụng
tài nguyên gang)
 barrier: Tạo thanh chặn ngăn các luồng tiếp tục thực thi cho đến khi tất
cả các luồng khác đã xong
 atomic: Chỉ phần bộ nhớ chỉ được cập nhật duy nhất bởi một luồng tại
một thời điểm
9

 flush: Chỉ định các luồng có cùng một khung nhìn chung cho bộ nhớ
chia sẻ
 ordered: Chỉ định thứ tự được thực hiện trong vòng lặp for song song
 threadprivate: Chỉ định một biến riêng của luồng
Các hàm quan trọng:
 omp_get_thread_num(): Lấy ra số lượng luồng hiện thời
 omp_get_num_thread(): Lấy ra id của luồng hiện tại
 num_threads(): Chỉ định số luồng thực hiện

Hiệu suất với OpenMP





Hệ số tăng tốc là hệ số mà thời gian giải quyết vấn đề có thể được cải
thiện so với việc sử dụng chỉ một bộ xử lý.
Việc song song hóa phần lớn chương trình là rất quan trọng.
Mỗi lần chương trình gọi một vùng song song hoặc vịng lặp, nó sẽ

gây ra một khoản chi phí nhất định để chuyển sang chế độ song song.
Ngồi chi phí gọi vịng lặp song song và thực thi rào cản, hiệu ứng bộ
nhớ đệm và đồng bộ hóa cũng có thể làm tăng chi phí đáng kể.
Tính tốn hiệu năng cao


Cân bằng tải (Load balancing): trong OpenMP có thể được hiểu là phân
phối công việc giữa các thread để tăng hiệu suất xử lý. Các công việc được
chia nhỏ và phân phối đều cho các thread để tận dụng tối đa tài nguyên của hệ
thống. Nếu một số thread phải thực hiện nhiều công việc hơn so với các
thread khác, hiệu suất sẽ bị giảm.Trong trường hợp ma trận thưa thớt, nếu một
số hàng có nhiều phần từ khác khơng hơn so với các hàng khác, cân bằng tải
có thể là một vấn đề với lập lịch tĩnh.Vấn đề cân bằng tải có thể được giải
quyết bằng cách sử dụng lập lịch động.Tuy nhiên, việc sử dụng lịch trình
động cũng có chi phí riêng của nó.Lập lịch tĩnh thường có thể đạt được hiệu
quả tải tốt trong các tình huống mà lượng công việc cho mỗi lần lặp là đồng
đều hoặc nó biến đổi theo một cách dự đốn được. 

6

Ưu nhược điểm và tính năng OpenMP
Có một số ưu điểm của OpenMP như các ứng dụng tương đối dễ để thực
10

hiện với độ trễ thấp và bằng thông cao. OpenMP cho phép lập lịch thời gian
chạy và dynamic load balancing do đó ưu điểm lớn nhất của OpenMP là khẳ
năng giao tiếp ngầm. Mặc dù vậy vẫn có một số nhưng hạn chế nhất định như
việc truy cập song song vào bộ nhớ có thể dẫn đến việc giảm hiệu suất và khi
kích thước của vong lập song song nhỏ nên chi phí trở thành vấn đề và việc
đồng bộ hịa trở nên cần thiết. Các tính năng chính của OpenMP



Hỗ trợ cho bộ tăng tốc: Một cơ chế sẽ được cung cấp để xác định
các vùng mã trong đó việc tính tốn dữ liệu (và/hoặc) sẽ được
chuyển sang bất kỳ thiết bị máy tính nào.



Xử lí lỗi: các khả năng của OpenMP được xác định rõ ràng để cải
thiện khả năng phục hồi và tính ổn định của các ứng dụng
OpenMP khi có lỗi ở cấp độ hệ thống, cấp độ thời gian chạy và lỗi
do người dùng giải thích.



Mối quan hệ của luồng: Người dùng mơ tả nơi thực thi các luồng
OpenMP. Dữ liệu nền tảng và các thuộc tính thuật tốn cụ thể
được tách biệt, đóng góp một hành vi xác định và đơn giản trong
Tính tốn hiệu năng cao


sử dụng. Lợi ích cho người dùng là địa phương tốt hơn, ít chia sẻ
sai hơn và băng thơng bộ nhớ nhiều hơn
Tiện ích mở rộng tác vụ: Các tiện ích mở rộng tác vụ mới đang được xem
xét là đồng bộ hóa sâu tác vụ, tác vụ phụ thuộc, hỗ trợ giảm bớt cho tác vụ và
các luồng chỉ dành cho tác vụ. Các luồng chỉ dành cho tác vụ là các luồng
không tham gia vào chia sẻ cấu trúc công việc mà chỉ chờ các tác vụ được
thực thi.
1.2 Giới thiệu về MPI

1

Phương pháp khử Gassian
Phép khử Gass là một thuật toán liên quan đến việc biến đổi sơ cấp các
hàng của ma trận, được ứng dụng phổ biến trong đại số tuyến tính. Một số
ứng dụng của phương pháp này là: tính hạng của mà trận, giải hệ phương
trình, tính nghịch đảo của một ma trận khả nghịch. Trong bài luận này, việc
tính tốn sẽ sử dụng bằng OpenMP. Để tính tốn thời gian thực hiện cho từ độ
lớn của ma trận. Và đánh giá khả năng gia tốc và hiệu năng trong từ trường

11

hợp.
Thuật toán được chia làm 2 phần
1.

Forward elimination: biến đổi ma trận thành ma trận hàng bậc thang

2.

Backward Substitution: Biển đổi ma trận hàng bậc thang và tìm kết
quả
Tính nghịch đảo của ma trận khả nghịch [A] dựa trên cơ sở là ma trận
khơng có nhiều hơn một nghịch đảo của ma trận đó.
Xét một ma trận khơng suy biến A ϵ Rnxn .

a11 a12
[ A ]= a 21 ⋱
⋮ ⋮
ai1 ⋯

[

⋯ a1 j
⋯ ⋮
⋱ ⋮
⋯ aij

]
Tính tốn hiệu năng cao


Sau đó để tính nghịch đảo ma trận ta đưa thêm một ma trận đơn vị với
kích thước bằng với ma trận ban đầu vào bên phải ma trận cần tính

a11 a12
[ A|I ]= a21 ⋱
⋮ ⋮
ai 1 ⋯

[

⋯ a1 j | 1 0 ⋯
⋯ ⋮| 0 ⋱ ⋯
⋱ ⋮| ⋮ ⋯ ⋱
⋯ a ij | 0 ⋯ ⋯

0
⋮
⋮

1

]

Đặt

mi1 =

ai1
a11

i=1,2,3. . .n

Các phần tử bên dưới a11 của ma trận gốc sẽ được loại bỏ bằng cách nhân
mỗi phần từ của hàng 1 với mi1 rồi trừ đi phần tử tương ứng từ hàng 2 đến
hàng cuối cùng. Phép toán như sau:
12

aij =aij −mi1 ×a 1 j i, j=1,2,3. . .n
bij =bij −mi1 ×b1 j i, j=1,2,3. ..n
Với bij là các phần tử vế phải ma trận trận bổ xung [A|I].
Kết quả của ma trận sau thao tác hàng phần tử ở hàng thứ 2 sẽ có kết quả
như sau.

a11
a12
[ A|I ]= 0 a 22−m21×a12
⋮
⋮
0 a i2 −mi1×a12

[

⋯ a1 j |
1
0 ⋯
⋯ ⋮ | 0−m21 1 ⋯
⋮
⋯ ⋱
⋱ ⋮|
⋯ a ij | 0−mi 1 ⋯ ⋯
Tính tốn hiệu năng cao

0
⋮
⋮
1

]


Theo cách tương tự, tất cả các hàng tiếp theo có thể được biến đổi bằng
thao tác biến đổi sơ cấp và các phần tử bên dưới các phần tử đường chéo có
thể bị loại bỏ. Sau khi hồn thành thao tác hàng cho tất cả các hàng, vế phải
của ma trận bổ xung có dạng bậc hàng rút gọn như hình dưới đây

a11 a 12
[ A|I ]= 0 a 22
⋮ ⋮
0

0

[

⋯ a1 j| 1
0
⋯ ⋮ | b21 b22
⋱ ⋮| ⋮ ⋯
⋯ aij | b i1 b i2

⋯ 0
⋯ ⋮
⋱ ⋮
⋯ bij

]

Có thể thấy vế phải của ma trận bổ xung[A|I] khơng cịn là ma trận đơn
vị. Điều này hồn thành q trình đầu của thuật tốn. Bước tiếp theo của thuật
toán BackWard Substitution bắt đầu từ hàng cuối cùng của ma trận đi lên đến
13

hàng hai.
Đặt

a ik
mik=
a kk

k=1,2, . .. n−1

i=k +1,. .. n

Sau đó, thao tác phép biến đổi sơ cấp được thực hiện trước để loại bỏ tất
cả các phần tử phía trên các phần tử đường chéo của vế phải của ma trận bổ
xung [A|I]

aij =aij −mik ×a kj k=1,2,3 . .. n−1
bij =bij −mi1 ×b1 j i, j=k+1 , k+2, ... n
Sau đó, mỗi hàng được chia cho phần tử đường chéo tương ứng của ma
trận vế trái akk để biến ma trận vế trái thành ma trận đơn vị:

Tính tốn hiệu năng cao


2

aij =
bij =

aij
aii
bij
bii

Ma trận sẽ có dạng

1 0
0 1
[ A|I ]=
⋮ ⋮

0 ⋯

[

⋯
⋯
⋱
⋯

0 | b11
⋮ | b21
⋮| ⋮
0| b
i1

b12
b22
⋯
b i2

⋯ b1 j
⋯ b2 j
⋱ ⋮
⋯ b ij

]

14
Có thể nhận thấy ma trận bên trái đã được chuyển hóa hồn tồn thành ma
trận đơn vị. Vậy ma trận vế phải tương ứng là ma trận nghịch đảo của ma trận

gốc.

b11
¿
[ Aalignl¿ −1 ¿ ]= b 21
⋮
bi1

[

b 12
b 22
⋯
bi 2

⋯
⋯
⋱
⋯

b1 j
b2 j ¿
⋮
bij

]

Phân tích bài tốn
Trong phần trên chúng ta đã thảo luận cách bắt đầu tạo chương trình song
song. Chúng ta sẽ sử dụng phương pháp phân tích nhân tử LU đơn giản để

phân tích ma trận thành ma trận tam giác dưới và ma trận tam giác trên. Các
ma trận tam giác dưới và trên này sau đó được sử dụng để tính nghịch đảo của
Tính tốn hiệu năng cao


ma trận. Việc phân tách LU được thực hiện bằng phương pháp khử Gaussian
và ít tính tốn hơn so với kỹ thuật tính nghịch đảo ma trận thơng thường.
Giả sử chúng ta cần đảo ngược ma trận A. Nếu B là nghịch đảo của A thì:
A.B = I
I là ma trận đơn vị.
Nếu chúng ta có thể chia A thành hai ma trận sao cho một ma trận là
ma trận tam giác dưới và ma trận kia là ma trận tam giác trên thì:
A = L.U
L là ma trận tam giác dưới và U là ma trận tam giác trên. Do đó
L.U.B = I
L.(X) = I
X = U.B
Ta giải được hai phương trình dưới đây
L.X = I
15

U.B = X
Giải hai phương trình trên sẽ được B, nghịch đảo của A
Việc tính tốn L và U có thể được thực hiện song song vì việc tính tốn
khơng phụ thuộc vào các bước trước đó. Tương tự, việc tính tốn nghịch đảo
có thể được thực hiện song song, vì việc tính tốn từng cột của kết quả là độc
lập với nhau. Logic tương tự được sử dụng để song song hóa mã nối tiếp bằng
lệnh OpenMP.

Tính tốn hiệu năng cao

1.

Chương 2. Kết quả nghiên cứu
2.1 Thiết kế thuật toán tuần tự phép khử Gassian

1

2

Bài tốn
Cho ma trận A n×n , xác định nghịch đảo của ma trận ký hiệu là A-1
A×B=B× A=I n ⇒ B= A

−1

Phép biến đổi sơ cấp:
1. Hốn đổi vị trí các hàng khác nhau của ma trận
2. Nhân một hàng của ma trận với một số khác 0
3. Cộng hàng i với hàng j với i khác j
Chúng ta biết rằng nếu một chuỗi các phép biến đổi sơ cấp được áp
dụng cho ma trận A biến nó thành ma trận đơn vị I n, thì cùng một chuỗi
16

các phép biến đổi sơ cấp được áp dụng cho ma trận đơn vị I n sẽ biến nó
thành A-1.
Vì vậy, chúng ta có thể tìm ma trận nghịch đảo A -1 bằng cách tìm chuỗi
các phép biến đổi sơ cấp ma trận bổ xung [ A | In ] thành [ I | A-1 ]

Thuật toán
Thuật toán được chia thành 2 phần như đã nêu ở phần I. Sau đây là các
bước thực hiện Cho i = 1 đến n thực hiện
Nếu A[i,i] = 0 và A[m,i] = 0 với m > i, kết luật A -1 khơng tồn tại
và dừng thuật tốn
Nếu A[i,i] = 0 và A[m,i] != 0 với giá trị nhỏ nhất m > i, đổi chỗ
hàng i với hàng m trong mảng
Chia từng giá trị của hàng i với giá trị A[i, i]. với j = 1 đến n, A[i,
j] = A[i, j]/A[i,i].

Tính tốn hiệu năng cao


Ta có A[i, i] = 1. Nếu i < n, sau đó với r > i, trừ A[r, i] lần hàng i
từ hàng r .
for (int i = 0; i < n; ++i) {
// Check if diagonal element is zero
if (A[i][i] == 0) {
// Swap with the nearest subsequent row where A[i,i] ≠ 0
int swapRow = i + 1;
while (swapRow < n && A[swapRow][i] == 0) {
swapRow++;
}
if (swapRow == n) {
cout << "INVERSE DOES NOT EXIST" << endl;
return;
}
// Swap rows
swap(A[i], A[swapRow]);
swap(I[i], I[swapRow]);

}
// Scale the current row
double scale = A[i][i];
for (int col = 0; col < n; ++col) {
A[i][col] /= scale;
I[i][col] /= scale;
}
// Elimination
if (i < n - 1) {

17

for (int row = i + 1; row < n; ++row) {
double factor = A[row][i];
for (int col = 0; col < n; ++col) {
A[row][col] -= factor * A[i][col];
I[row][col] -= factor * I[i][col];
}
}
}

}

1. Lặp qua từng dòng (i = 0 đến n-1):
Mã lặp qua từng dòng của ma trận, bắt đầu từ dòng đầu tiên đến
dòng cuối cùng.
2. Kiểm tra phần tử chéo có bằng khơng hay khơng:
Nếu phần tử chéo A[i][i] bằng 0, đoạn mã thực hiện việc đổi chỗ
dòng hiện tại với dịng liền kề gần nhất mà có phần tử chéo khác 0.
Nếu khơng tìm thấy dịng thích hợp, tức là khơng có dịng nào có

phần tử chéo khác 0, thì chương trình xuất thơng báo "INVERSE
DOES NOT EXIST" (Nghịch đảo không tồn tại) và kết thúc.
3. Đổi chỗ các dòng:
Nếu phần tử chéo A[i][i] bằng 0, đoạn mã thực hiện việc đổi chỗ
dòng hiện tại với dòng liền kề gần nhất mà có phần tử chéo khác 0.
Nếu khơng tìm thấy dịng thích hợp, tức là khơng có dịng nào có
phần tử chéo khác 0, thì chương trình xuất thơng báo "INVERSE
Tính tốn hiệu năng cao


DOES NOT EXIST" (Nghịch đảo không tồn tại) và kết thúc.
4. Chuẩn hóa dịng hiện tại:
Nếu phần tử chéo A[i][i] bằng 0, đoạn mã thực hiện việc đổi chỗ
dòng hiện tại với dịng liền kề gần nhất mà có phần tử chéo khác 0.
Nếu khơng tìm thấy dịng thích hợp, tức là khơng có dịng nào có
phần tử chéo khác 0, thì chương trình xuất thơng báo "INVERSE
DOES NOT EXIST" (Nghịch đảo khơng tồn tại) và kết thúc.
5. Q trình Loại bỏ (Elimination):
Nếu phần tử chéo A[i][i] bằng 0, đoạn mã thực hiện việc đổi chỗ
dòng hiện tại với dòng liền kề gần nhất mà có phần tử chéo khác 0.
Nếu khơng tìm thấy dịng thích hợp, tức là khơng có dịng nào có
phần tử chéo khác 0, thì chương trình xuất thơng báo "INVERSE
DOES NOT EXIST" (Nghịch đảo khơng tồn tại) và kết thúc.
2.2 Tận dụng tính song song
Trong đoạn mã trên, ta sẽ sử dụng OpenMP để tận dụng đa luồng trong
q trình thực hiện thuật tốn Gaussian elimination. Dưới đây là mơ tả chi
tiết:
18



#pragma omp parallel for:
˗

Dịng này tạo một khu vực song song, trong đó mỗi luồng sẽ thực hiện
một phần của vòng lặp for sau đó.

˗

num_threads(12) xác định số lượng luồng sử dụng, trong trường hợp
này là 12 luồng.



schedule(dynamic):
Tính tốn hiệu năng cao


˗

Dòng này áp dụng lập lịch dynamic cho tất cả các vịng lặp for trong
khối parallel for.

˗

Điều này có nghĩa là các đơn vị công việc (chunk) sẽ được gửi cho các
luồng theo cách động, giúp cân bằng tải công việc khi các phần của
cơng việc có thể mất thời gian khác nhau để hoàn thành.

˗

Chunk size trong OpenMP là kích thước của các phần cơng việc được
chia nhỏ và gửi đến các luồng để thực hiện. Kích thước này ảnh hưởng
đến cách cơng việc được phân chia và có thể ảnh hưởng đến hiệu suất
chung của chương trình. Cụ thể, chunk size là số lượng các vòng lặp
trong một lần phân phối cơng việc.

19



#pragma omp parallel for:
˗

Dịng này tạo một khu vực song song mới cho việc swap các hàng của
ma trận A và I khi phát hiện phần tử đường chéo là 0.

Tính tốn hiệu năng cao




#pragma omp parallel for:
˗

Dòng này tạo một khu vực song song cho quá trình loại bỏ các phần tử
dưới đường chéo trong quá trình loại bỏ Gaussian.

˗

Mỗi luồng thực hiện một phần của vòng lặp `for` để giảm bớt các
phần tử dưới đường chéo.



#pragma omp parallel for:
˗

Được sử dụng để tạo một khu vực song song cho vòng lặp for, nơi 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,

20

vịng lặp là việc chia mỗi phần tử trong hàng i của ma trận A và I cho
scale.



#pragma omp parallel for:

˗

Dòng này tạo một khu vực song song cho quá trình back substitution.

Mỗi luồng thực hiện một phần của vịng lặp `for` để thực hiện back
substitution.

Tính toán hiệu năng cao