ĐÁNH GIÁ HIỆU NĂNG TÍNH TÍCH 2 MA TRẬN SỬ DỤNG THƯ VIỆN OPENMP
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (842.57 KB, 32 trang )
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
ĐÁNH GIÁ HIỆU NĂNG TÍNH TÍCH 2 MA TRẬN SỬ
DỤNG THƯ VIỆN OPENMP
GVHD:
Nhóm :
Thành viên:
T.S Hà Mạnh Đào
3
Đinh Đại Việt - 2020607115
NguyễnTrung Kiên - 2020602618
Nguyễn Tuấn Vũ_2020605541
Hà Nội, 2023
1
LỜI MỞ ĐẦU
Sự phát triển và mở rộng phạm vi ứng dụng của công nghệ thông tin luôn
gặp phải hai thách thức lớn đó là khơng gian nhớ và tốc độ xử lí của máy tính.
Một số bài tốn do thực tiễn và nghiên cứu lý thuyết đặt ra đòi hỏi phải xử lý
nhanh trên một cơ sở dữ liệu đồ sộ, đặc biệt là trong các lĩnh vực trí tuệ nhân tạo,
nhận dạng, xử lí ảnh, điều khiển tự động, mơ phỏng, các bài tốn dự báo,... mà
các phương pháp và cơng cụ tính tốn truyền thống khơng thể đáp ứng được.
Trong những trường hợp ấy, ta có thể tìm cách phân rã bài tốn thành những bài
tốn có kích thước và quy mơ dữ liệu nhỏ hơn. Tuy nhiên điều đó khơng phải bao
giờ cũng có thể thực hiện. Xử lí song song (parallel processing) là một trong
những giải pháp giúp ta có thể xử lý tình huống nêu trên. Hiện nay có rất nhiều
chuẩn hỗ trợ lập trình song song như OpenMP hỗ trợ lập trình song song trên bộ
nhớ phân tán, OpenMP hỗ trợ lập trình trên bộ nhớ chia sẽ chung, Pthread hỗ trợ
lập trình luồng,...
Bài báo này giới thiệu những kiến thức cơ bản về tính tốn song song và
lập trình song song. Ngồi ra cịn trình bày khái niệm về OpenMP, những ngun
tắc lập trình song song với openMP. Sử dụng thư viện hàm openMP lập trình
minh họa bài tốn nhân hai ma trận bằng thuật toán Cannon. Rút ra những kết
luận về thời gian chạy chương trình bằng giải thuật tuần tự và bằng giải thuật
song song.
Do kiến thức, kinh nghiệm còn hạn chế nên bài báo cáo có thể cịn có một
số lỗi sai, chương trình có thể khơng đúng trong một vài trường hợp, mong thầy
và các bạn góp ý, giúp đỡ để chúng em hoàn thiện hơn.
Chúng em xin cảm ơn!
2
Mục Lục
Chương 1. Tổng quan về mơ hình lập trình song song với MPI..........................5
1.1
Tính tốn song song...................................................................................5
1.1.1
Tính tốn song song là gì?...................................................................5
1.1.2
Tại sao phải tính tốn song song?........................................................5
1.1.3
Các thành phần liên quan đến tính tốn song song..............................6
1.1.4
Ngun lý thiết kế thuật toán song song..............................................6
1.2
Giới thiệu về OpenMP...............................................................................8
1.2.1
Khái niệm về OpenMP........................................................................8
1.2.2
Lịch sử của OpenMP...........................................................................8
1.2.3
Mục đích và ứng dụng của OpenMP...................................................9
1.2.4
Mơ hình lập trình song song OpenMP.................................................9
Chương 2. Phương pháp giải quyết bài toán......................................................14
2.1
Bài toán nhân 2 ma trận dày đặc (dense) và thuật tốn Cannon..............14
2.1.1
Ma trận dày đặc (dense) là gì?...........................................................14
2.1.2
Phép nhân 2 ma trận..........................................................................14
2.1.3
Thiết kế thuật toán song song nhân 2 ma trận dày đặc (dense).........15
2.2
Tính tích 2 ma trận bằng thuật toán tuần tự và thuật toán song song......18
2.2.1
Thuật toán tuần tự..............................................................................18
2.2.2
Thuật toán song song.........................................................................20
2.3
Một số vấn đề về hiệu năng.....................................................................22
Chương 3. Thực nghiệm và kết quả...................................................................24
3
3.1
Cấu hình thiết bị.......................................................................................24
3.2
Kết quả thực hiện.....................................................................................25
3.3
Kết luận....................................................................................................30
Tài liệu tham khảo...............................................................................................31
Hình 1: Mơ Hình Fork-Join..................................................................................11
Hình 2 ví dụ ma trận dày đặc................................................................................17
Hình 3 Tách ma trận thành các khối 1..................................................................17
Hình 4 Căn chỉnh ma trận.....................................................................................17
Hình 5 Nhân các ma trận con...............................................................................18
Hình 6 Đổi vị trí....................................................................................................18
Hình 7 Lặp lại bước 3&4......................................................................................19
Hình 8 So sánh thời gian chạy..............................................................................24
Hình 9 So sánh thời gian chạy 2...........................................................................24
Hình 10 Cấu hình thiết bị.....................................................................................26
Hình 11Biểu đồ so sánh thời gian tính tốn trung bình........................................28
Hình 12 Biểu đồ so sánh thời gian tính tốn lâu nhất...........................................29
Hình 13 Biểu đồ Speed Up...................................................................................30
Hình 14 Biểu đồ Efficiency..................................................................................30
4
Chương 1. Tổng quan về mơ
hình lập trình song song
với MPI
1.1 Tính tốn song song
1.1.1
Tính tốn song song là gì?
Như chúng ta đã thấy các phần mềm phổ biến ngày nay hầu hết đều được viết
trên cơ sở của tính toán tuần tự. Các phần mềm này thường được thực hiện trên
một máy tính đơn với duy nhất một bộ xử lý. Vấn đề ở đây được giải quyết thông
qua một chuỗi các lệnh tuần tự được thực hiện bởi một bộ xử lý. Tại một thời
điểm chỉ có một lệnh được thực hiện.
Tính tốn song song ra đời là một sự cải tiến của tính tốn tuần tự. Nó là sự giải
quyết vấn đề dựa trên sự thực thi đồng thời của nhiều tài nguyên máy tính.
Tài nguyên máy tính đây bao gồm:
-
Một máy tính đơn với nhiều bộ xử lý
-
Nhiều máy tính nối lại với nhau thành một mạng máy tính
-
Kết hợp cả hai loại trên
Tính tốn song song thường được dùng để giải quyết các vấn đề hết sức phức tạp
u cầu thời gian tính tốn lớn hoặc làm việc với khối dữ liệu lớn như các bài
tốn dự báo thời tiết, mơ phỏng tai nạn xe hơi, xây dựng các mơ hình thương mại
và các vấn đề khoa học như khai phá dữ liệu , trí tuệ nhân tạo, an tồn dữ liệu…
1.1.2
Tại sao phải tính tốn song song?
Việc tính tốn song song là rất cần thiết. Ngồi hai ngun nhân chính là nó
được dùng để tính tốn các bài tốn u cầu thời gian tính tốn lớn và khối lượng
dữ liệu lớn cịn có các nguyên nhân khác như để sử dụng tài nguyên của các máy
khác trong một mạng LAN hoặc thông qua mạng internet, có thể sử dụng nhiều
5
tài ngun tính tốn nhỏ kết hợp lại tạo nên một siêu máy tính. Do giới hạn về
khơng gian lưu trữ của bộ nhớ trên một máy đơn để giải quyết một vấn đề lớn
việc sử dụng nhiều bộ nhớ trên nhiều máy tính là rất hữu hiệu trong trường hợp
này.
Giới hạn của tính tốn tuần tự bao gồm cả hai nguyên nhân thực tế và nguyên
nhân vật lý. Để xây dựng nên một máy tính tuần tự tốc độ cao gặp rất nhiều hạn
chế:
- Về tốc độ truyền dữ liệu: Tốc độ truyền của máy tính tuần tự phụ thuộc
trực tiếp vào sự di chuyển dữ liệu trong phần cứng. Cho nên việc tăng tốc độ thực
hiện phải chủ yếu căn cứ vào các yếu tố tính tốn.
- Về kích cỡ: Cơng nghệ chế tạo bộ xử lý cho phép gắn nhiều bóng bán dẫn
trên một con chip. Tuy nhiên việc làm này sẽ làm tăng kích thước của bộ xử lý
- Về thương mại: Việc tạo ra một bộ xử lý tốc độ xử lý cao là rất tốn kém.
Sử dụng nhiều bộ xử lý nhỏ đạt hiệu quả tương tự mà lại ít tốn kém hơn.
1.1.3
Các thành phần liên quan đến
tính tốn song song
-
Kiến trúc máy tính song song.
-
Phần mềm hệ thống.
-
Giải thuật song song.
-
Ngôn ngữ lập trình song song.
1.1.4
Ngun lý thiết kế thuật tốn song
song
Khi muốn thực hiện việc xử lí song song ta phải xét cả kiến trúc máy
tính và các thuật tốn song song. Để thiết kế được các thuật toán song song cần
phải thực hiện:
- Phân chia dữ liệu cho các tác vụ.
6
- Chỉ ra cách truy cập và chia sẻ dữ liệu.
- Phân các tác vụ cho các tiến trình (bộ xử lí).
- Các tiến trình được đồng bộ ra sao
Khi thiết kế một thuật tốn song song có thể sử dụng năm ngun lí
chính trong thiết kế thuật tốn song song:
- Nguyên lý lập lịch: mục đích là giảm tối thiểu các bộ xử lí sử dụng
trong thuật tốn sao cho thời gian tính tốn là khơng tăng (xét theo khía
cạnh độ phức tạp).
- Ngun lý hình ống: Ngun lý này được áp dụng khi bài toán xuất
hiện một dãy các thao tác {T1, T2, . . ., Tn}, trong đó Ti+1 thực hiện sau khi
Ti kết thúc.
- Nguyên lý chia để trị: Chia bài toán thành những phần nhỏ hơn tương
đối độc lập với nhau và giải quyết chúng một cách song song.
- Nguyên lý đồ thị phụ thuộc dữ liệu: Phân tích mối quan hệ dữ liệu
trong tính toán để xây dựng đồ thị phụ thuộc dữ liệu và dựa vào đó để xây
dựng thuật tốn song song.
- Nguyên lý điều kiện tương tranh: Nếu hai tiến trình cùng muốn
truy cập vào cùng một mục dữ liệu chia sẻ thì chúng phải tương tranh với
nhau, nghĩa là chúng có thể cản trở lẫn nhau.
Ngồi những ngun lý nêu trên, khi thiết kế thuật tốn song song ta
cịn phải chú ý đến kiến trúc của hệ thống tính tốn. Khi chuyển một thuật
toán tuần tự sang thuật toán song song hoặc chuyển một thuật tốn song
song thích hợp với kiến trúc đang có. Cần xác định được yêu cầu sau:
- Kiến trúc tính tốn nào sẽ phù hợp với bài toán?
- Những bài toán loại nào sẽ xử lý hiệu quả trong kiến trúc
song song cho trước ?
7
1.2 Giới thiệu về OpenMP
1.2.1
Khái niệm về OpenMP
OpenMP là một giao diện lập trình ứng dụng (API) được sử dụng để điều
khiển các luồng trên cấu trúc chia sẻ bộ nhớ chung. Thành phần của OpenMP
bao gồm :
1. Các chỉ thị biên dịch (Compiler Directives)
2. Các thư viện runtime (Runtime Library Routines)
3. Các biến môi trường (Emviroment Variables) .
Các chỉ thị biên dịch, các thư viện runtime và các biến mơi trường này được
sử dụng để lập trình song song với hai ngôn ngữ Fortran và C/C++. OpenMP là
một chuẩn bộ nhớ chia sẻ hỗ trợ bởi nhiều nền phần cứng và phần mềm như là
DEC, Intel, IBM, SGI, Numerical Algorithms Group. Hơn thế nữa OpenMP cịn
có thể thực thi trên cả môi trường UNIX và Windows NT 2.1.2.
1.2.2
Lịch sử của OpenMP
Ngay từ trước thập kỷ 90. Các nhà cung cấp các máy tính chia sẻ bộ nhớ đã
đưa ra các sản phẩm hỗ trợ sự đồng bộ và các chỉ thị cơ bản. Để lập trình các
chương trình song song trên kiến trúc dạng này thì ngơn ngữ Fortran được sử
dụng với rất nhiều tiện dụng. Người sử dụng có thể làm giảm thời gian thực hiện
các chương trình Fortran bằng cách thực hiện các vòng lặp theo cách song song.
Trong trường hợp này trình biên dịch phải chịu trách nhiệm song song hóa một
cách tự động các vịng lặp thông qua các BXL SMP. Tuy nhiên mỗi một nhà
8
cung cấp lại sử dụng những phương thức và sự thực thi khác nhau phụ thuộc vào
các nền tảng phần cứng và kiến trúc riêng của họ.
Để đưa ra một chuẩn hỗ trợ việc lập trình song song trên kiến trúc chia sẻ bộnhớ
thì năm 1994 chuẩn ANSI X3H5 ra đời. Nhưng nó khơng tồn tại được lâu vì
trong thời gian này các máy tính bộ nhớ phân tán trở nên rất phổ biến. Chuẩn
OpenMP được bắt đưa ra vào mùa xuân năm 1997 để thay thế chuẩn ANSI
X3H5. Trong thời gian này thì các máy tính chia sẻ bộ nhớ rất thịnh hành. Bên
cạnh đó Pthread cũng được đưa ra nhưng Pthread khơng có tính mở rộng, khơng
có các chỉ thị biên dịch. Pthread không hỗ trợ song song tốt, người lập trình rất
khó thực thiện việc song song hóa nhờ vào Pthread. Với Pthread người lập trình
phải quan tâm nhiều đến các chi tiết ở mức thấp. Và OpenMP được thiết kế để
giảm bới những nhược điểm của Pthread.
1.2.3
Mục đích và ứng dụng của
OpenMP
OpenMP ra đời với mục tiêu cung cấp một chuẩn chung cho rất nhiều kiến
trúc và nền tảng phần cứng. Nó thiết lập một tập các chỉ thị biên dịch hỗ trợ việc
lập trình song song trên máy tính chia sẻ bộ nhớ chung. Một mức song song
chính thường được thực thi với ba đến bốn chỉ thị. OpenMP ra đời giúp cho việc
lập trình song song một cách dễ dàng nó cung cấp khả năng song song hóa
chương trình tuần tự mà khơng dùng đến thư viện thơng điệp v.v...
Có thể sử dụng OpenMP để giải quết các vấn đề giới hạn về thời gian như
bài tốn dự báo thời tiết, và để mơ phỏng các vấn đề thực tế như bài tốn mơ
phỏng tai nạn xe hơi, giải quyết các bài toán khoa học u cầu khối lượng tính
tốn lớn như bài tốn mô phỏng N-Body, dự báo thời tiết …
9
1.2.4
Mơ hình lập trình song song
OpenMP
1.2.4.1
Song song hóa dựa trên cơ chế luồng (Thread based a trên cơ chế luồng (Thread based chế luồng (Thread based luồng (Thread based ng (Thread based
parallelism)
Trong mơ hình trên chương trình xử lý trên bộ nhớ toàn cục bao gồm nhiều luồng
thực thi đồng thời. OpenMP dựa vào sự tồn tại của nhiều luồng trên một mơ hình
lập trình chia sẻ bộ nhớ chung.
1.2.4.1.1 Mơ hình song song hiện (Explicit Parallelism) n (Explicit Parallelism)
Mơ hình trên là một mơ hình lập trình khơng tự động. Người lập trình có quyền
điều khiển việc song song hóa một cách độc lập
1.2.4.1.2 Mơ hình Fork-Join
Trong các mơ hình trên thì OpenMP sử dụng mơ hình Fork-Join để thực thi cơng
việc song song. Trong mơ hình này tất cả các chương trình song song đều bắt đầu
với việc xử lý đơn bởi một luồng chủ (master thread). Luồng chủ này sẽ thực thi
một cách tuần tự cho tới khi bắt gặp vùng song song (parallel region) đầu tiên .
FORK: Có nghĩa là luồng chủ sau đó sẽ tạo ra một tập các luồng song song. Và
sau đó đoạn mã trong vùng song song được thực thi song song bởi tập luồng song
song vừa tạo ra.
10
JOIN: Khi mà tập luồng song song đã hoàn thành đoạn mã trong vùng song song
chúng sẽ được đồng bộ và kết thúc rồi sau đó cơng việc lại được thực hiện bởi
luồng chủ
Hình 1: Mơ Hình Fork-Join
1.2.4.2
Các chỉ thị trong OpenMP thị trong OpenMP trong OpenMP
1.2.4.2.1 Khuôn dạng chỉ thị trong OpenMPng chỉ thị trong OpenMP thị trong OpenMP trong OpenMP
Chỉ thị trong OpenMP được cho dưới dạng sau
# pragma omp directive-name [clause...] newline
# pragma omp: Yêu cầu bắt buộc đối với mọi chỉ thị OpenMP C/C++
directive-name: Là tên của chỉ thị phải xuất hiện sau #pragma omp và đứng
trước bất kì mệnh đề nào
[clause...]: Các mệnh đề này không bắt buộc trong chỉ thị
newlin : Yêu cầu bắt buộc với mỗi chỉ thị nó là tập mã lệnh nằm trong khối cấu
trúc được bao bọc bởi chỉ thị
a. Phạm vi tĩnh ( Static Extent )
11
Đó là những đoạn mã nguyên bản trong phạm vi từ đầu đến cuối khối cấu
trúc cho sau mỗi chỉ thị. Phạm vi tĩnh của chỉ thị không mở rộng đến các
thủ tục và các tệp chứa mã.
b. Chỉ thị đơn độc (Orphaned Directive)
Chỉ thị đơn độc là chỉ thị xuất hiện độc lập với chỉ thị khác. Nó tồn tại ở
ngoài phạm vi tĩnh của chỉ thị khác. Chỉ thị đơn độc mở rộng với các thử
tục và các tệp mã nguồn
c. Phạm vi động (Dynamic Extent)
Phạm vi động của chỉ thị bao gồm phạm vi tĩnh của của chỉ thị và phạm vi
của các chỉthị mồ côi 2.2.2.2 Cấu trúc vùng song song
Một vùng song song là một khối mã nguồn được thực thi bởi nhiều luồng.
Trong C/C++ một vùng song song có định dạng như sau:
#pragma omp parallel [clause...] newline
if (scalar_expression)
private (list)
shared (list)
default (shared | none)
firstprivate (list)
reduction (operator : list)
copyin (list)
structured_block
Khi mà một luồng gặp chỉ thị PARALLEL thì nó sẽ tạo ra một tập các
luồng và luồng ban đầu sẽ là luồng chủ của tập các luồng đó. Luồng chủ ở đây
cũng là một thành viên trong tập các luồng đó và là luồng số 0 .Để bắt đầu thực
hiện một vùng song song thì đoạn mã nguồn trong vùng song song được sao ra
những bản giống nhau đưa cho mỗi luồng thực hiện một cách song song. Đợi cho
đến khi tất cả các luồng đều thực hiện song cơng việc của mình thì luồng chủ sẽ
thực hiện cơng việc tuần tự cịn lại ngồi vùng song song đó. Vậy câu hỏi đặt ra ở
12
đây là có bao nhiêu luồng để thực hiện đoạn mã song song trong vùng song song.
Để biết được điều này người ta dùng hàm thư viện OMP_NUM_THREAD(), và
để
biết
được
số
thứ
tự
của
mỗi
luồng
ta
dùng
hàm
OMP_GET_THREAD_NUM() ...Lưu ý số thứ tự của các luồng nằm trong
khoảng từ 0 đến số thứ tự của luồng chủ trừ đi 1. Cũng từ khái niệm vùng song
song xuất hiện khái niệm vùng song song lồng và khái niệm luồng động.
Vùng song song lồng (Nested Parallel Region): Có nghĩa là trong một
vùng song song con xuất hiên các vùng song song nhỏ khác Luồng động
(Dynamic Thread). Theo mặc định thì khi một chương trình được chia ra thành
nhiều vùng song song thì các vùng song song đó sẽ được thực hiện bởi các luồng
với số lượng bằng nhau. Điều này có thể thay đổi bằng cách cho phép hệthống
gán động số lượng các luồng thực hiện cho mỗi vùng song song . Chúng ta có hai
cách thức để gán động các luồng thứ nhất là dùng hàm thư viện
omp_set_dynamic() và thứ hai là dùng biến môi trường OMP_DYNAMIC.
1.2.4.2.2Các hàm OpenMP thường dùngng dùng
Tên hàm
Ý nghĩa
omp_get_max_threads trả về giới hạn trên về số luồng có thể được sử
dụng để thành lập một nhóm mới nếu một cấu trúc
song song
omp_get_num_procs
trả về số lượng bộ xử lý có sẵn cho thiết bị.
13
omp_get_num_thread
s
trả về số luồng
omp_get_wtime
trả về thời gian đồng hồ treo tường đã trơi qua tính
bằng giây.
omp_in_parallel
trả về true nếu ICV mức hoạt động var lớn hơn
khơng; nếu khơng, nó trả về false.
omp_init_lock &
omp_init_nest_lock
Khởi tạo khóa
omp_set_dynamic
bật hoặc tắt điều chỉnh động số lượng các luồng có
sẵn để thực hiện các vùng song song tiếp theo bằng
cách đặt giá trị của ICV dyn-var.
omp_set_nested
khơng dùng nữa cho phép hoặc vơ hiệu hóa song
song lồng nhau bằng cách đặt ICV tối đa mức hoạt
động-var.
omp_test_lock &
omp_test_nest_lock
Các thói quen này cố gắng đặt khóa OpenMP
nhưng khơng đình chỉ thực hiện tác vụ thực hiện
các thói quen.
omp_unset_lock &
omp_unset_nest_lock
cung cấp phương tiện để gỡ cài đặt khóa OpenMP.
14
Chương 2. Phương pháp giải
quyết bài toán
2.1 Bài toán nhân 2 ma trận dày đặc (dense) và thuật toán Cannon
2.1.1
Ma trận dày đặc (dense) là gì?
Trong phân tích số và tính tốn khoa học, ma trận dày đặc hoặc mảng dày đặc là
ma trận mà trong đó hầu hết các phần tử đều khác 0 (có rất ít số 0, số phần tử
bằng 0 thường gần bằng số hàng hoặc số cột). Ngược lại, nếu hầu hết các phần tử
bằng 0, ma trận đó được coi là ma trận thưa (Sparse).
2.1.2
Phép nhân 2 ma trận
Trong toán học, phép nhân ma trận là phép toán nhị phân tạo ra ma trận từ
hai ma trận. Để nhân ma trận, số lượng cột trong ma trận thứ nhất phải bằng số
lượng hàng trong ma trận thứ hai. Ma trận kết quả, được gọi là tích ma trận, có số
lượng hàng của ma trận đầu tiên và số cột của ma trận thứ hai.
Nếu A là ma trận m×n và B là ma trận n×p, thì tích ma trận C = B (ký hiệu
khơng có dấu nhân hoặc dấu chấm) được xác định là ma trận m×p.
15
Với cơng thức:
2.1.3 Thiết kế thuật tốn song song nhân 2 ma trận dày đặc (dense)
Để đơn giản, chúng ta sẽ làm việc với ma trận vng kích thước n×n. Coi số
lượng bộ xử lý có sẵn trong các máy song song là p. Ma trận cần nhân sẽ là 2 ma
trận dày đặc (có ít số 0) A và B có cùng kích thước n×n. Kết quả sẽ được lưu trữ
trong ma trận C.
Ta thực hiện phép nhân theo các bước sau:
B1: Chia ma trận thành các khối vuông Pi, trong đó Pi là các threads có sẵn (vd 4
threads thì có P0, P1, P2, P3).
B2: Tạo ma trận các quy trình có kích thước P*1/2 × P*1/2 sao cho mỗi q trình
có thể duy trì một khối ma trận A con và một khối ma trận B con.
B3: Mỗi khối được gửi đến từng quy trình và phần phụ được sao chép từ các khối
được nhân với nhau và kết quả được thêm vào trong các tiểu khối C.
16
B4: Các khối con A được đẩy sang trái một bước và các khối con B được cuộn
lên một bước.
B5: Lặp lại bước 3 & 4 √ p lần.
Ví dụ:
Cho 2 ma trận dày đặc A và B có kích thước 4x4
Hình 2 ví dụ ma trận dày đặc
Cho p=4, chia ma trận A và ma trận B thành 4 khối:
Hình 3 Tách ma trận thành các khối 1
Căn chỉnh ma trận:
17
Hình 4 Căn chỉnh ma trận
Mỗi khối được gửi đến từng quy trình và phần phụ được sao chép từ các khối
được nhân với nhau và kết quả được thêm vào trong các tiểu khối C.
Hình 5 Nhân các ma trận con
Các khối con A được đẩy sang trái một bước và các khối con B được cuộn lên
một bước.
18
Hình 6 Đổi vị trí
Lặp lại bước 3 & 4 √p lần:
Hình 7 Lặp lại bước 3&4
19
2.2
Tính tích 2 ma trận bằng thuật tốn tuần tự và thuật toán song song.
2.2.1 Thuật toán tuần tự
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <float.h>
#define N 4000 // Kich thuoc ma tran NxN
int main() {
int** a = (int**)malloc(N * sizeof(int*));
for (int i = 0; i < N; i++)
{
a[i] = (int*)malloc(N * sizeof(int));
}
int** b = (int**)malloc(N * sizeof(int*));
for (int i = 0; i < N; i++)
{
b[i] = (int*)malloc(N * sizeof(int));
}
int** c = (int**)malloc(N * sizeof(int*));
for (int i = 0; i < N; i++)
{
c[i] = (int*)malloc(N * sizeof(int));
}
clock_t start, end;
double dif;
printf("Khoi tao ma
start = clock();
for (int i = 0; i <
{
for (int j = 0;
{
a[i][j] = i
}
}
tran...\n");
N; i++)
j < N; j++)
+ j;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
b[i][j] = i * j;
}
}
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
c[i][j] = 0;
}
}
printf("Nhan hai ma tran
\n");
20
