ĐÁNH GIÁ HIỆU NĂNG GIẢI PHƯƠNG TRÌNH POISSON 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 HỌC PHẦN TÍNH TỐN HIÊU NĂNG CAO
ĐỀ TÀI:
ĐÁNH GIÁ HIỆU NĂNG GIẢI PHƯƠNG TRÌNH POISSON SỬ DỤNG
OPENMP.

Giảng Viên Hướng Dẫn:

TS. Hà Mạnh Đào

Sinh Viên:

Nguyễn Thị Thanh - 2021600419
Đàm Lê Tuấn Vũ - 2021606931
Lê Văn Xuân - 2021605103

Ngành: KHMT

Khóa: 16

1


Danh mục các thuật ngữ
LIS - Language Independent Specifications
MIMD - Multiple Instruction Multiple Data
OpenMP - Open Multi-Processing

2


MỞ ĐẦU
1. Đặt vấn đề
Trong lĩnh vực lý thuyết xác suất và thống kê, phân phối Poisson (phân phối
Poa-Dông), một phân phối xác suất rời rạc, đặc trưng bởi việc mô tả số lần một
sự kiện xảy ra trong một khoảng thời gian nhất định, đã từng được coi là công
cụ quan trọng. Khác biệt quan trọng giữa Phân phối Poisson và các phân phối
xác suất rời rạc khác nằm ở việc nó khơng chỉ xác định xác suất của một sự
kiện trong một lần thử như phân phối Bernoulli hay số lần sự kiện xảy ra trong
n lần thử như phân phối nhị thức, mà cịn là trung bình số lần xảy ra thành công
trong một khoảng thời gian cố định.
Mặc dù Phân phối Poisson đã được ứng dụng trong nhiều lĩnh vực, từ khoảng
cách, diện tích đến sự phân rã hạt nhân, tuy nhiên, với sự tiến triển nhanh chóng
của cơng nghệ thơng tin và lượng lớn thơng tin được tạo ra hàng ngày, những
thuật toán truyền thống dựa trên phương trình Poisson đã khơng thể đáp ứng
hiệu quả yêu cầu của thời đại. Bài toán hiện nay là làm thế nào chúng ta có thể
giải quyết vấn đề này, sử dụng phương trình Poisson với dữ liệu lớn và phân
tán, để đáp ứng mục tiêu tối ưu hóa thời gian tìm kiếm trong mơi trường ngập
tràn thơng tin hiện đại.
2. Mục đích
Đánh giá hiệu năng giải phương trình Poisson sử dụng OpenMP.
3. Nội dung
Có 3 nội dung:
- Nội dung 1: Nghiên cứu về bài tốn phương trình Poisson. Đánh giá ưu
điểm, nhược điểm của từng thuật toán.
- Nội dung 2: Cải tiến thuật toán sử dụng phương trình Poisson bằng cách
song song hóa thuật tốn để tối ưu về thời gian tìm kiếm trên nguồn dữ liệu
lớn.

3


- Nội dung 3: Tiến hành thử nghiệm, đánh giá thuật toán cải tiến.
4. Phương pháp nghiên cứu
Để thực hiện những nội dung đã nêu ở trên, nhóm chúng em đã sử dụng một
số phương pháp cho từng nội dung như sau:
- Nội dung 1: Sử dụng phương pháp phân tích, so sánh và đánh giá các
thuật tốn sử dụng phương trình Poisson.
- Nội dung 2: Sử dụng phương pháp phân tích khả năng song song hóa
các thuật tốn.
- Nội dung 3: Sử dụng phương pháp đối sánh để đánh giá kết quả thử
nghiệm của thuật toán đã cải tiến.

4


MỤC LỤC
Chương 1: Phương trình Poisson..............................................................................6
Một vài nét về phương trình Poisson.....................................................................6
Chương 2: Lập trình song song với OpenMP...........................................................9
2.1 Tổng quan về lập trình song song với OpenMP...............................................9
2.1.1 Giới thiệu....................................................................................................9
2.1.2 Lịch sử phát triển........................................................................................9
2.1.3 Mục đích và ứng dụng của OpenMP........................................................10
2.1.4 Ưu điểm của OpenMP.............................................................................10
2.2 Lập trình song song với OpenMP..................................................................10
2.2.1 Giới thiệu..................................................................................................10
2.2.2 Một số vấn đề về hiệu năng......................................................................13
2.2.2.1 Năng lực tính tốn...........................................................................13

2.2.2.2 Cân bằng tải.....................................................................................15
2.2.2.3 Tình trạng bế tắc và cách khắc phục................................................16
Chương 3: OpenMP trong bài toán sử dụng phương trình Poisson........................18
3.1 Yêu cầu đặt ra cho bài tốn sử dụng phương trình Poisson...........................18
3.2 Xây dựng hàm tính xác suất với phương trình Poisson.................................18
3.2.1 Xây dựng chương trình tuần tự cho bài tốn............................................19
3.2.2 Xây dựng chương trình song song với vòng lặp Jacobi...........................23
3.2.3 Lựa chọn hàm OpenMP cho thuật tốn song song...................................28
3.3 Chi phí thời gian.............................................................................................32
Chương 4: Kết quả thử nghiệm...............................................................................33
Tài liệu tham khảo...................................................................................................37

5


Chương 1: Phương trình Poisson
Một vài nét về phương trình Poisson
Phương trình Poisson tìm ra bởi nhà tốn học Siméon-Denis Poisson (1781–
1840) và đã được xuất bản cùng với lý thuyết xác suất của ông, vào năm 1838 với
tựa đề Recherches sur la probabilité des jugements en matières criminelles et
matière civile ("Research on the Probability of Judgments in Criminal and Civil
Matters"). Theo đó, nếu xem xét một biến ngẫu nhiên N nào đó, và đếm số lần xuất
hiện (rời rạc) của nó trong một khoảng thời gian cho trước. Nếu giá trị kì vọng
(hay số lần trung bình mà biến ngẫu nhiên đó xảy ra trong khoảng thời gian đó là λ,
thì xác suất để cũng chính sự kiện đó xảy ra k lần (k là số nguyên không âm, k = 0,
1, 2,...) sẽ được tính theo cơng thức

với


e là cơ số của logarit tự nhiên (e = 2.71828...)



k là số lần xuất hiện của một sự kiện - mà xác suất của nó là cho bởi cơng
thức trên



k! là giai thừa của k



λ là số thực dương, bằng với giá trị kì vọng xuất hiện của sự kiện trong một
khoảng cho sẵn. Ví dụ, nếu một sự kiện trung bình xảy ra 1 lần trong 4 phút,
giờ ta quan tâm số lần sự kiện xảy ra trong khoảng thời gian 10 phút, ta
dùng mơ hình phân phối Poisson với λ = 10/4 = 2.5.
Vì đây là biến ngẫu nhiên rời rạc, công thức trên cho ta công thức của hàm

khối xác suất.
6


Phương trình Poisson ra đời gắn liền với quá trình Poisson. Nó được áp dụng
cho nhiều hiện tượng (có tính rời rạc) (nghĩa là số lần xuất hiện trong một
khoảng (thời gian, khơng gian) cho trước đó phải là số nguyên 0, 1, 2, 3,...) với
xác suất để sự kiện (hiện tượng) đó xảy ra là khơng đổi trong suốt khoảng (thời
gian, khơng gian) đó. Các ví dụ sau được mơ hình theo phân phối Poisson:

 Số lượng xe hơi đi ngang qua 1 điểm trên con đường trong một khoảng thời

gian cho trước.
 Số lần gõ bị sai của khi đánh máy một trang giấy.
 Số cuộc điện thoại tại một trạm điện thoại trong mỗi phút.
 Số lần truy cập vào một máy chủ web trong mỗi phút.
 Số lượng người lính bị chết do ngựa đá mỗi năm trơng mỗi đội của kị binh
Phổ. Ví dụ này rất nổi tiếng trong cuốn sách của Ladislaus Josephovich
Bortkiewicz (1868–1931).
 Số lượng bóng đèn bị cháy trong một khoảng thời gian xác định.
 Số lượng virut có thể lây nhiễm lên một tế bào trong cấu trúc tế bào.
 Số lần động vật bị chết do xe cộ cán phải trên mỗi đơn vị độ dài của một con
đường.
 Số lần đột biến xảy ra trên một đoạn DNA sau khi chịu một lượng bức xạ..
 Số lượng cây thông trên mỗi đơn vị diện tích rừng hỗn hợp.
 Số lượng ngơi sao trong một thể tích khơng gian vũ trụ.

7


8


Chương 2: Lập trình song song với OpenMP
2.1 Tổng quan về lập trình song song với OpenMP
2.1.1 Giới thiệu
OpenMP (Open Multi – Processing) là một giao diện lập trình ứng dụng
Application Program Interface (API) được sử dụng để điều khiển các luồng
(Thread) dựa trên cấu trúc chia sẻ bộ nhớ chung. OpenMP khơng phải một ngơn
ngữ lập trình mới mà nó hoạt động trên sự liên kết chặt chẽ với ngơn ngữ lập trình
làm cơ sở, vd: Fortran, C/C++ .OpenMP cung cấp cơ chế để chỉ định việc thực
hiện song song. Các thành phần của OpenMP gồm:

 Các chỉ thị biên dịch (Compiler Directive).
 Thư viện runtime (Runtime Library Rountines).
 Các biến môi trường (Enviroment Variables).
Được định nghĩa dựa trên một nhóm phạm trù phần cứng và phần mềm, OpenMP
là một thư viện, giúp cho người lập trình đơn giản và mềm dẻo để phát triển
chương trình song song chạy trên máy PC hỗ trợ nhiều bộ xử lý.
2.1.2 Lịch sử phát triển
- OpenMP do ARB (Architecture Review Board) một nhóm các nhà phát triển máy
tính phát hành với tên API.
- Phiên bản đầu tiên 1.0 dành cho Fortran được công bố vào tháng 10 năm 1997.
- Vào tháng 10 năm 1998 C/C ++ tích hợp thành chuẩn của mình.
- Phiên bản 2.0 được Fortran công bố vào năm 2000 và đến năm 2002 C/C++ cũng
tung ra phiên bản 2.0 của mình.
- Phiên bản 2. 5 được cả Fortran và C/C ++ công bố vào năm 2005.

9


- Phiên bản 3. 0 được công bố vào năm 2008 và nó là phiên bản hiện tại được tích
hợp thêm nhiều tính năng mới.
2.1.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 toá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 yê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 …
2.1.4 Ưu điểm của OpenMP
• Một chuẩn hồn chỉnh và được cơng nhận trên thực tế.
• Hiệu suất và khả năng mở rộng tốt.
–Nếu chương trình được thiết kế đúng!
• Tính khả chuyển cao.
–Chương trình viết ra có thể dịch bởi nhiều chương trình dịch khác nhau.
• Dễ sử dụng nhờ sự đơn giản và số lượng ít các chỉ thị.
• Cho phép song song hóa tăng dần chương trình tuần tự.
2.2 Lập trình song song với OpenMP
2.2.1 Giới thiệu
OpenMP cung cấp mơ hình lập trình đa luồng cấp cao, xây dựng trên thư
viện lập trình đa luồng của hệ thống, vd: POSIX Threads, và nhiều thứ nữa.
10


Thực thi song song(Explicit Parallelism): 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
Thực hiện theo mơ hình Fork-Join
–Chương trình OpenMP bắt đầu việc thực hiện như một luồng chủ duy nhất,
master thread
–Luồng chủ thực hiện tuần tự cho đến vùng song song đầu tiên
–Luồng chủ tạo nhóm các luồng để chia sẻ thực hiện các cơng việc song
song

* 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
* 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ủ
Mơ hình bộ nhớ OpenMP
•Mọi luồng có quyền truy cập đến vùng nhớ chung tồn cục
•Dữ liệu hoặc là chia sẻ hoặc là riêng tư
•Việc truyền dữ liệu là trong suốt với người lập trình
11


•Cần thiết phải đồng bộ hóa nhưng hầu như được thực hiện ngầm

Tính năng chính của OpenMP
• Tạo nhóm các luồng cho thực hiện song song
• Chỉ rõ cách các chia sẻ cơng việc giữa các luồng thành viên của
nhóm
• Khai báo dữ liệu chia sẻ và riêng tư
• Đồng bộ các luồng và cho phép các luồng thực hiện thực hiện cơng
việc một các độc quyền
• Cung cấp hàm thời gian chạy
• Quản lý số lượng luồng
Viết chương trình song song với OpenMP
- Chia tách bài toán thành các công việc
+ Lý tưởng nhất khi các công việc là hồn tồn độc lập
- Gán cơng việc cho các luồng thực thi
- Viết mã trên mơi trường lập trình song song
12


- Thiết kế chương trình phụ thuộc vào
+ Nền tảng phần cứng

+ Cấp độ song song
+ Bản chất của bài tốn
- Song song theo dữ liệu
+ Khuyến khích lập trình song song có cấu trúc dựa trên phân
chia cơng việc trong vòng lặp.
+ #pragma omp parallel for
- Song song theo công việc
+ Hỗ trợ việc gán các công việc cụ thể cho các luồng thông qua
chỉ số của luồng
+ # pragma omp parallel sections
2.2.2 Một số vấn đề về hiệu năng
2.2.2.1 Năng lực tính tốn
Việc song song hóa một chương trình nhằm làm cho chương trình đó chạy
nhanh hơn, tuy nhiên chương trình đó sẽ chạy nhanh hơn bao nhiêu lần? Định luật
Amdahl’s cho phép ta xác định điều này. Giả sử xét về khía cạnh thời gian 22 chạy
chương trình, một phần p của chương trình có thể song song hóa và phần 1- p cịn
lại buộc phải chạy tuần tự. Trong trường hợp lý tưởng, nếu thực thi chương trình
sử dụng n bộ xử lý, thời gian chạy chương trình sẽ là 1-p + p/n của thời gian chạy
chương trình một cách tuần tự. Đây là hệ quả trực tiếp của định luật Amdahl áp
dụng cho trường hợp thực thi lý tưởng.
Ví dụ: nếu 80% chương trình có thể được song song hóa, và ta có 4 bộ xử lý,
thời gian chạy song song sẽ là: 1 - 0.8 + 0.8/4 = 0.4 tức là bằng 40% thời gian chạy
tuần tự.

13


Hình 2.1: Khả năng tăng tốc độ tính tốn, trường hợp lý tưởng.
Đối với chương trình trên, thời gian chạy song song sẽ không thể nào nhỏ
hơn 20% thời gian chạy tuần tự cho dù ta sử dụng số lượng vô cùng lớn các bộ xử

lý. Trên thực tế, khi chạy một chương trình song song, thường xuất hiện các chi
phí truyền thơng và việc phân cơng cơng việc khơng cân bằng giữa các bộ xử lý.
Do đó thời gian chạy chương trình sẽ là:

Hình 2.2: Khả năng tăng tốc độ tính tốn, trường hợp thực tế.
Do vậy để tăng tốc độ của chương trình ta cần:
- Tăng tỉ lệ (thành phần) được song song hóa của chương trình.
- Phân công công việc một cách công bằng cho các bộ xử lý.
14


- Giảm tới mức tối thiểu thời gian truyền thông.
2.2.2.2 Cân bằng tải
Giả sử rằng nếu dữ liệu được phân tán trên các bộ nhớ địa phương của các
bộ xử lý trong hệ thống nhiều máy tính, khi đó khối lượng công việc của các bộ xử
lý cần phải được phân phối hợp lý trong suốt q trình tính tốn. Trong nhiều
trường hợp, giả sử này là đúng, tuy nhiên trong thực tế điều này không phải lúc
nào cũng thực hiện được. Giải pháp được đưa ra ở đây là cân bằng tải động nhằm
mục đích làm thay đổi sự phân phối khối lượng công viêc giữa các bộ xử lý trong
q trình thực hiện tính tốn.
Thơng thường sau khi phân phối khối lượng công việc cho các bộ xử lý, quá
trình cân bằng tải động thực hiện bốn bước cơ bản sau:
- Giám sát hiệu năng của các bộ xử lý.
- Trao đổi thông tin trạng thái giữa các bộ xử lý.
- Tính tốn và ra quyết định phân phối lại khối lượng công việc.
- Thực hiện việc chuyển đổi dữ liệu thực sự.
Để thực hiện được điều này, rất nhiều thuật toán đã được đề xuất. Người ta
phân lớp các thuật toán này theo các chiến lược: tập trung, phân tán hoàn toàn
(fully distributed) và phân tán một nửa (semi distributed).
a. Các thuật toán cân bằng tải tập trung

Các thuật tốn này thường đưa ra quyết định có tính chất tổng thể trong việc
phân phối lại khối lượng công việc cho các bộ xử lý. Một vài thuật tốn trong lớp
này sử dụng thơng tin hệ thống có tính tồn cục để lưu trạng thái các máy tính
riêng lẻ. Thơng tin này sẽ giúp thuật tốn phân phối công việc một cách dễ dàng.
Tuy nhiên, khối lượng thông tin tăng theo tỉ lệ thuận với số lượng các bộ xử lý, do

15


đó nó địi hỏi khối lượng lớn bộ nhớ trên một bộ xử lý để lưu thơng tin trạng thái.
Vì vậy thuật tốn thuộc lớp này khơng được tiếp cận một cách rộng rãi.
b. Các thuật toán cân bằng tải phân tốn hồn tồn
Trong các thuật tốn dạng này, mỗi bộ xử lý có một bản sao về thơng tin
trạng thái của hệ thống. Các bộ xử lý trao đổi thông tin trạng thái với nhau và sử
dụng các thông tin này để làm thay đổi một cách cục bộ việc phân chia công việc.
Tuy 25 nhiên các bộ xử lý chỉ có thơng tin trạng thái cục bộ nên việc cân bằng tải
khơng tốt bằng các thuật tốn cân bằng tải tập trung.
c. Các thuật toán cân bằng tải phân tán một nửa
Các thuật toán thuộc lớp này chia các bộ xử lý thành từng miền. Trong mỗi
miền sử dụng thuật toán cân bằng tải tập trung để phân phối cơng việc cho các bộ
xử lý thuộc miền đó.

2.2.2.3 Tình trạng bế tắc và cách khắc phục
Các tiến trình xử lý bị rơi vào tình trạng bế tắc nếu mỗi tiến trình đó nắm giữ
tài ngun mà một vài tiến trình khác đang yêu cầu để xử lý. Lý do tiềm ẩn của sự
bế tắc là do nhiều tiến trình cùng sử dụng nguồn tài ngun chung mà khơng có sự
kiểm sốt tốt.
Đối với các hệ thống đa máy tính, một trong những sự bế tắc phổ biến nhất
là bế tắc vùng đệm (buffer deadlock) xảy ra khi một tiến trình đợi một thơng điệp
mà thơng điệp này có thể không bao giờ nhận được do vùng đệm đã đầy.

Bốn điều kiện sau là nguyên nhân gây ra bế tắc:
o Sự loại trừ lẫn nhau: mỗi tiến trình có sự độc quyền trong việc sử
dụng tài nguyên của nó.
16


o Khơng có sự ưu tiên: Mỗi tiến trình khơng bao giờ giải phóng tài
nguyên mà nó đang chiếm giữ cho tới tận khi khơng cịn sử dụng
chúng nữa.
o Sự chờ đợi tài nguyên: mỗi tiến trình đang chiếm giữ tài nguyên trong
khi lại chờ đợi các tiến trình khác giải phóng chúng.
o Sự chờ đợi giữa các tiến trình: tiến trình chờ đợi tài nguyên mà tiến
trình kế tiếp đang chiếm giữ mà tài ngun đó khơng được giải phóng.
 Một số giải pháp khắc phục sự bế tắc
o Dị tìm sự bế tắc khi chúng xảy ra và cố gắng khôi phục lại.
o Sử dụng các thông tin yêu cầu tài nguyên của các tiến trình để điều
khiển sự phân phối để khi tiếp tục phân phối các tài ngun khơng là
ngun nhân để các tiến trình rơi vào bế tắc.
o Ngăn cấm không để xảy ra điều kiện thứ 4 trong các điều kiện trên.

17


Chương 3: OpenMP trong bài tốn sử dụng phương trình Poisson
3.1 Yêu cầu đặt ra cho bài toán sử dụng phương trình Poisson
Phân phối Poisson là một phân phối xác suất rời rạc với thơng tin mà nó
cung cấp là trung bình số lần xảy ra thành cơng của một sự kiện trong một khoảng
thời gian nhất định. Độ phức tạp của thuật tốn sử dụng phương trình Poisson này
là O (n2).
Yêu cầu đặt ra ở đây là với số liệu cho trước lớn và rời rạc dẫn đến độ phức

tạp cao với số lượng phép tính rất lớn. Vì vậy chi phí để tính xác suất với dữ liệu
tương ứng với thuật tốn này là khơng nhỏ.
Để đáp ứng yêu cầu trên với chi phí thấp nhất, cần cải tiến thuật tốn sử
dụng phương trình Poisson cổ điển để đáp ứng yêu cầu về thời gian.
3.2 Xây dựng hàm tính xác suất với phương trình Poisson
Trong chương trình C tính tốn song song này ta sử dụng OpenMP để thực
hiện phép lặp Jacobi và sử dụng phép lặp Jacobi để giải hệ tuyến tính tính nghiệm
gần đúng của phương trình Poisson trong hình chữ nhật.
Phiên bản của phương trình Poisson đang được giải ở đây là:
…

- ∆ 2 U(X,Y) = F(X,Y)

trên hình chữ nhật có hai cạnh X, Y (0 <= X <= 1, 0 <= Y <= 1), với nghiệm chính
xác:
U(x,y) = sin ( pi * x * y )
Suy ra:
F(x,y) = pi^2 * ( x^2 + y^2 ) * sin ( pi * x * y )
và với các điều kiện biên Dirichlet dọc theo các đường x = 0, x = 1, y = 0 và y = 1.
(Các điều kiện biên trong trường hợp này thực tế sẽ bằng 0, nhưng chúng ta viết

18


bài tốn như thể chúng ta khơng biết điều đó , giúp chúng ta dễ dàng thay đổi vấn
đề sau này).
Lặp lại Jacobi được áp dụng nhiều lần cho đến khi phát hiện sự hội tụ. Để thuận
tiện khi viết các phương trình rời rạc, chúng ta giả sử rằng DX = DY và ước lượng
tốn tử Poisson bằng cơng thức:
( U(i-1, j) + U(i+1, j) + U(i, j-1) + U(i, j+1) - 4*U(i, j) ) / dx /dy

Cùng với điều kiện biên tại các nút biên, ta có hệ tuyến tính cho U. Có thể
áp dụng phép lặp Jacobi để ước lượng nghiệm cho hệ tuyến tính.
OpenMP được sử dụng trong ví dụ này để thực hiện song song phép lặp
Jacobi. Tuy nhiên phép lặp Jacobi có thể hội tụ rất chậm và độ chậm tăng lên khi
ma trận lớn hơn. Vì vậy, nếu phải sử dụng phép lặp Jacobi, tính song song có thể
giúp chương trình tính tốn nhanh hơn. Nhưng tại một thời điểm nào đó, chúng ta
cũng có thể thấy rằng việc có được một bộ giải tuyến tính tốt hơn (thậm chí là một
bộ giải khơng song song) có thể giải phương trình poisson nhanh hơn phép lặp
Jacobi.

3.2.1 Xây dựng chương trình tuần tự cho bài tốn


Hàm main() chương trình chính:

int main ( int argc, char *argv[] )
{
dx = 1.0 / ( double ) ( nx - 1 );
dy = 1.0 / ( double ) ( ny - 1 );
timestamp ( );
rhs ( nx, ny, f );
for ( j = 0; j < ny; j++ )
{
for ( i = 0; i < nx; i++ )
{
if ( i == 0 || i == nx - 1 || j == 0 || j == ny - 1 )
{
unew[i][j] = f[i][j];
}
else

{
unew[i][j] = 0.0;

19


}
}
}
unew_norm = r8mat_rms ( nx, ny, unew );
for ( j = 0; j < ny; j++ )
{
y = ( double ) ( j ) / ( double ) ( ny - 1 );
for ( i = 0; i < nx; i++ )
{
x = ( double ) ( i ) / ( double ) ( nx - 1 );
uexact[i][j] = u_exact ( x, y );
}
}
u_norm = r8mat_rms ( nx, ny, uexact );
cout << " RMS of exact solution = " << u_norm << "\n";
converged = false;
for ( j = 0; j < ny; j++ )
{
for ( i = 0; i < nx; i++ )
{
udiff[i][j] = unew[i][j] - uexact[i][j];
}
}
error = r8mat_rms ( nx, ny, udiff );

for ( it = 1; it <= it_max; it++ )
{
for ( j = 0; j < ny; j++ )
{
for ( i = 0; i < nx; i++ )
{
u[i][j] = unew[i][j];
}
}
sweep ( nx, ny, dx, dy, f, u, unew );
u_norm = unew_norm;
unew_norm = r8mat_rms ( nx, ny, unew );
for ( j = 0; j < ny; j++ )
{
for ( i = 0; i < nx; i++ )
{
udiff[i][j] = unew[i][j] - u[i][j];
}
}
diff = r8mat_rms ( nx, ny, udiff );
for ( j = 0; j < ny; j++ )
{
for ( i = 0; i < nx; i++ )
{
udiff[i][j] = unew[i][j] - uexact[i][j];
}
}
error = r8mat_rms ( nx, ny, udiff );
if ( diff <= tolerance )
{

converged = true;
break;

20