Ứng dụng cơ chế multi thread để giải quyết bài toán nhân hai ma trận lớn

TRƯỜNG ĐẠI HỌC BÁCH KHOA
KHOA CÔNG NGHỆ THÔNG TIN
BỘ MÔN MẠNG VÀ TRUYỀN THÔNG


ĐỒ ÁN HỆ ĐIỀU HÀNH
Đề tài:
Ứng dụng cơ chế multi thread để giải quyết bài toán nhân hai ma trận lớn

Sinh viên
: Vũ Đức Nội
Lớp
: 11T3
Cán bộ hướng dẫn : Phạm Minh Tuấn

Đà Nẵng 12/2014


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

LỜI NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................

...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................
...................................................................................................................................

SVTH: Vũ Đức Nội

Page: 2


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

MỤC LỤC

CHƯƠNG 1. LỜI NÓI ĐẦU ................................................................................4
TỔNG QUAN VỀ ĐỀ TÀI .....................................................................................5
CHƯƠNG 2. CƠ SỞ LÝ THUYẾT ......................................................................6
2.1.
GIỚI THIỆU..............................................................................................6

2.2.
CÁC KHÁI NIỆM CƠ BẢN VỀ THREAD .......................................................6
2.2.1. Định nghĩa thread và multi thread ...................................................6
2.2.2. Chia sẽ bộ nhớ trong pthreads .........................................................9
2.2.3. Tính an toàn của Threads.................................................................9
2.2.4. Ưu và khuyết điểm của cơ chế multi thread ..................................10
2.3.
LẬP TRÌNH MULTI THREAD TRONG HỆ ĐIỀU HÀNH UBUNTU .................11
2.3.1. Các thủ tục chính lập trình multi thread trong Ubuntu ..................11
2.3.2. Tạo thread ......................................................................................11
2.3.3. Hủy Thread ....................................................................................12
2.3.4. Truyền tham số cho thread ............................................................12
2.3.5. Nối thread ......................................................................................13
CHƯƠNG 3. THIẾT KẾ VÀ XÂY DỰNG CHƯƠNG TRÌNH ........................15
3.1.
PHÂN TÍCH YÊU CẦU .............................................................................15
3.2.
TỔ CHỨC CSDL ....................................................................................15
3.3.
XÂY DỰNG CÁC CHỨC NĂNG.................................................................16
CHƯƠNG 4. TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ ..................................18
4.1.
MÔI TRƯỜNG TRIỂN KHAI .....................................................................18
4.2.
CODE CHƯƠNG TRÌNH ...........................................................................18
KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN.............................................................21
4.3.
NHỮNG KẾT QUẢ ĐẠT ĐƯỢC .................................................................21
4.4.
NHỮNG VẤN ĐỀ TỒN TẠI .......................................................................21

4.5.
HƯỚNG PHÁT TRIỂN..............................................................................21
TÀI LIỆU THAM KHẢO .....................................................................................22

SVTH: Vũ Đức Nội

Page: 3


Đồ án: Nguyên Lý Hệ Điều Hành

Chương 1.

GVHD: Phạm Minh Tuấn

LỜI NÓI ĐẦU

Những kiến thức cơ bản cũng như nâng cao về hệ điều hành, nắm bắt được
nguyên tắc hoạt động. Nguyên lý hệ điều hành là học phần rất quan trọng và bắt
buộc đối với tất cả sinh viên chuyên ngành công nghệ thông tin. Nguyên lý hệ điều
hành cung cấp cho sinh viên động cơ bản của hệ điều hành trên máy tính.
Hệ điều hành được xem là thành phần trung gian hay là cầu nối cho sự giao tiếp
của người sử dụng và máy tính. Thông qua hệ điều hành người sử dụng dễ dàng làm
việc và khai thác hiệu quả thiết bị phần cứng máy tính, quản lý phần mềm ứng dụng.
Người sử dụng chỉ cần thao tác các lệnh, các sự kiện và chờ các tiến trình của hệ
điều hành thực hiện.
Với một Hệ điều hành có tiềm năng như thế, chúng ta phải có sự nghiên cứu,
hiểu biết về nó, để có thể nắm bắt tốt về các khái niệm chuyên ngành về Hệ điều
hành.
Em xin cảm ơn sự hướng dẫn tận tình của thầy Phạm Minh Tuấn đã giúp em

hoàn thành đề tài này.

Sinh viên thực hiện
Vũ Đức Nội

SVTH: Vũ Đức Nội

Page: 4


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

TỔNG QUAN VỀ ĐỀ TÀI
1 Tên đề tài.
Ứng dụng cơ chế multi thread trong hệ điều hành đề giải quyết bài toán nhân
hai ma trận lớn trong hệ điều hành Ubuntu.
2 Phương pháp triển khai đề tài
- Tìm hiểu về phương pháp lập trình C trên Ubuntu.
- Tìm hiểu về cách tạo thread.
- Thiết kế xây dựng chương trình nhân 2 ma trận bằng multi thread.
3 Kết cấu của đồ án
Đồ án gồm các phần:
- Cơ sở lý thuyết về lập trình đa luồng trong Ubuntu.
- Thiết kế và xây dựng chương trình nhân hai ma trận bằng multi thread.
- Kết quả thực hiện.

SVTH: Vũ Đức Nội

Page: 5


Đồ án: Nguyên Lý Hệ Điều Hành

Chương 2.

GVHD: Phạm Minh Tuấn

CƠ SỞ LÝ THUYẾT

2.1. Giới thiệu
Trong khoa học máy tính, một chuỗi các tính toán kết quả từ một fork của một
chương trình máy tính chia thành hai hoặc nhiều nhiệm vụ chạy đồng thời. Sự thể
hiện của các thread và tiến trình (process) là khác nhau trong một hệ điều hành,
nhưng trong hầu hết các trường hợp, một thread được nằm bên trong một tiến trình.
Nhiều thread có thể tồn tại cùng trong một tiến trình và chia sẻ tài nguyên như bộ
nhớ, trong khi những tiến trình khác nhau không thế chia sẻ tài nguyên.
Trên một bộ xử lý đơn, multi thread thường xảy ra bởi sự phân chia thời gian
ghép (như trong multitasking): bộ xử lý chuyển giữa những thread khác nhau. Ngữ
cảnh chuyển thường xảy ra một cách thường xuyên đủ để người dùng nhận thấy
được nhiều thread hoặc nhiệm vụ đang chạy tại cùng một thời điểm. Trên một bộ đa
xử lý hoặc hệ thống nhiều nhân, những thread hoặc nhiệm vụ sẽ chạy cùng lúc, với
mỗi một bộ xử lý hoặc nhân chạy một thread hoặc nhiệm vụ riêng.
Nhiều hệ điều hành hiện đại hỗ trợ trực tiếp sự phân chia thời gian hoặc đa
thread với một bộ lập lịch tiến trình. Nhân của hệ điều hành cho phép người lập
trình tính toán thread bằng các giao diện lời gọi hệ thống. Một vài thể hiện được gọi
là thread nhân, trong khi một tiến trình nhẹ (lightweight process) là một kiểu xác
định của thread nhân để chia sẻ trạng thái và thông tin.
Chương trình có thể có thread không gian người dùng khi lập trình thread với

thời gian, tín hiệu hoặc những phương thức khác để làm gián đoạn thực hiện riêng
của họ để thực hiện một sắp xếp ad-hoc hoặc chia thời gian.

2.2. Các khái niệm cơ bản về thread
2.2.1.

Định nghĩa thread và multi thread

- Thread là luồng chạy trong một process. Nó là dòng các điều khiển trong một
process. Nó được sử dụng để thực hiện các công việc cho process.

- Threads cũng tương tự như processes, đều được phân chia thời gian bởi
kernel. Với hệ thống chỉ có một bộ vi xử lý thì kernel sử dụng cách phân
SVTH: Vũ Đức Nội

Page: 6


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

chia thời gian để “làm cho” các threads như là chạy đồng thời theo cùng
cách thức kernel thực hiện với processes. Và với các hệ thống đa nhân thì
các threads thực sự có thể chay đồng thời giống như là nhiều processes.
- Thế thì tại sao multithread lại được ưa chuộng hơn là nhiều process độc lập
đối với các task có mối quan hệ với nhau? Đó là bởi vì các threads sử dụng
chung cùng một không gian bộ nhớ. Mỗi thread độc lập đều có thể truy
nhập vào cùng một biến toàn cục trong bộ nhớ. Trong khi fork() cho phép
tạo ra nhiều process nhưng rất khó khăn trong việc trao đổi thông tin giữa

process với nhau vì mỗi process có một không gian vùng nhớ riêng. Không
có một câu trả lời đơn giản cho việc trao đổi giữa các process (IPC). Do
vậy mà multiprocess programming sẽ phải chịu 2 trở ngại lớn:
- Perforamance thấp vì khi tạo một process mới đòi hỏi kernel thực thi nhiều
phép tính toán để cấp phát bộ nhớ.
- Trong hầu hết các trường hợp thì IPC làm chương trình trở nên phức tạp hơn
rất nhiều.
- Hơn thế nữa, quá tải và sự phức tạp không phải là những thứ tốt. Nếu bạn đã
từng phải làm những thay đổi lớn cho một chương trình của bạn mà support
IPC, sẽ rất tốt nếu sử dụng cách tiếp cận chia sẻ vùng nhớ đơn giản của
threads. Pthreads không cần phải những lời gọi expensive và phực tạp bởi
vì threads “sống cùng một ngôi nhà”. Bạn không phải đẩy dữ liệu thông
qua một file hoặc một vùng nhớ nào đó. Chính vì lý do này mà bạn nên cân
nhặc mô hình một process/nhiều threads hơn là nhiều process/một thread.
- Như đã nói ở trên, tạo một thread nhanh hơn rất nhiều (từ 10 cho đến 100
lần) so với tạo một process. Kernel không cần phải tạo một bản copy độc
lập của không gian bộ nhớ hiện thời, bảng các mô tả file (file descriptors).
Điều đó tiết kiệm rất nhiều thời gian của CPU.

SVTH: Vũ Đức Nội

Page: 7


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

- Multi thread là một process tách ra thành một hoặc nhiều luồng khác nhau để
cùng thực hiện các nhiệm vụ khác nhau cùng một lúc.

VD: Khi ta nghe nhạc trên youtube thì trình ứng dụng sẽ phân ra thành nhiều
luồng. Một luồng thực thi công việc load nhạc trên internet, một luồng thực thi
công việc phát nhạc.

- Giống như process một thread cũng có nhiều trạng thái như: running,
blocked, ready và terminated.
- Mỗi thread đều có một stack riêng nó. Mỗi stack đó đều chứa một frame cho
mỗi thủ tục được gọi tới. Các frame này chứa các biến cục bộ của thủ tục
và trả về địa chỉ để sử dụng khi thủ tục gọi đã hoàn tất.

SVTH: Vũ Đức Nội

Page: 8


Đồ án: Nguyên Lý Hệ Điều Hành

2.2.2.

GVHD: Phạm Minh Tuấn

Chia sẽ bộ nhớ trong pthreads

Tất cả thread đều có thể truy cập vào vùng nhớ chung đã được chia sẽ.
Mỗi thread sẽ có dữ liệu riêng của nó.
Công việc của các lập trình viên là đồng bộ hóa quyền truy cập vào các vùng nhớ
dùng chung đã chia sẽ.

Shared memory model

2.2.3.

Tính an toàn của Threads
 Đề cập khả năng của một ứng dụng để thực hiện nhiều Thread cùng một lúc
mà không cần chia sẻ dữ liệu hoặc tạo ra các điều kiện để thực thi.
 Ví dụ:
o ứng dụng của chúng ta tạo ra một vài Thread, mỗi trong số đó thường xuyên
gọi đến cùng một thư viện:
o Thư viện này thường xuyên truy cập / sửa đổi một cấu trúc chung hoặc vị trí
trong bộ nhớ.
o Mỗi thread này gọi thường xuyên có thể sẽ cố gắng sửa đổi vị trí cấu trúc /
bộ nhớ chung này cùng một lúc.

SVTH: Vũ Đức Nội

Page: 9


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

o Nếu thường không sử dụng đồng bộ xây dựng để ngăn chặn tham nhũng dữ
liệu, thì đó không phải là thread an toàn.

Thread unsafe

2.2.4.

Ưu và khuyết điểm của cơ chế multi thread

- Ưu điểm:
+ Thời gian xử lý nhanh hơn khi giải quyết các bài toán lớn.
+ Rất cần thiết trong một số trình ứng dụng.
- Khuyết điểm:
+ Khó viết và khó kiểm soát lỗi.
+ Các luồng trong một quá trình có thể bị chồng chéo dữ liệu.
+ Việc tránh xung đột dữ liệu khá khó khăn.
+ Khả năng đổ vỡ cao. Vì các threads ở trong cùng một không gian bộ nhớ
nên nếu một thread đổ vỡ (crash) sẽ kéo theo toàn bộ process và các thread
khác bị terminate.

SVTH: Vũ Đức Nội

Page: 10


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

2.3. Lập trình multi thread trong hệ điều hành Ubuntu
2.3.1.

Các thủ tục chính lập trình multi thread trong Ubuntu

Để sử dụng các thủ tục này ta cần phải khai báo thư viện #include .
Các thủ tục bao gồm:
int pthread_create(pthread_t *thread,

const
*(*start_routine)(void*), void *arg);

pthread_attr_t

*attr,

void

int pthread_join(pthread_t th,void **thread_return);
Ngoài ra ta còn có 1 số các thủ tục khác như:
void pthread_exit(void *retval);
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
2.3.2.

Tạo thread

Ban đầu, chương trình main() bao gồm một thread đơn mặc định. Tất cả những
thread khác phải được tạo ra từ lập trình viên. Hàm pthread_create tạo ra 1 thread
mới và làm chúng được thực thi. Thủ tục này được gọi số lần tùy ý và từ bất kỳ đâu
trong code của bạn. Các tham số trong thủ tục pthread_create:
Thread: một định danh duy nhất cho một thread mới và được trả về bởi thủ tục
con.
Attr: một đối tượng thuộc tính có thể được sử dụng để thiết lập các thuộc tính
cho thread. Bạn có thể xác định một đối tượng thuộc tính thread, hoặc để NULL với
giá trị mặc định.
Start_routine: thủ tục C để thread sẽ thực thi một lần khi nó được tạo ra.
Arg: một tham số đơn để có thể được truyền cho start_routine. Nó phải được
truyền bởi tham chiếu như là con trỏ kiểu void.

Mỗi một lần được tao ra, thread có thể tạo ra các thread khác. Không có hệ
thống cập bậc hoặc phụ thuộc giữa các thread.
Nếu tạo 1 thread thành công thì hàm pthread_create sẽ trả về giá trị 0. Nếu
không 1 giá trị lỗi sẽ được trả về để thông báo thread không được tạo thành công.
Sau khi tạo ra, các thread là cùng loại với nhau, và có thể tạo ra các thread khác.
Không có sự phân cấp hay phụ thuộc giữa các thread.

SVTH: Vũ Đức Nội

Page: 11


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

2.3.3. Hủy Thread
Có một vài cách mà trong đó Pthread bị hủy:
-Những thread mà trả về từ thủ tục bắt đầu của nó ( thủ tục chính với thread ban
đầu).
-Những thread thực hiện lời gọi tới hàm pthread_exit.
-Những thread bị hủy từ những thủ tục khác bằng hàm pthread_cancel.
-Tiến trình cuối bị ngắt trong khi thực hiện lời gọi tới hàm khác hoặc thoát khỏi
thủ tục con.
Hàm pthread_exit được sử dụng để thoát khỏi một thread. Thông thường, thủ tục
pthread_exit() được gọi sau khi 1 thread đã hoàn thành công việc của nó và
không còn yêu cầu nào. Nếu hàm main() kết thúc trước khi những thread được
tạo ra và thoát với hàm pthread_exit(), những thread khác vẫn tiếp tục được thực
hiện. Ngoài ra, chúng cũng sẽ tự động bị ngắt khi hàm main() kết thúc. Người
lập trình có thể tùy chọn chỉ định một trạng thái (status) ngắt, được lưu như một

con trỏ kiểu void cho bất kỳ thread nào để có thể tham gia vào lời gọi thread.
Tóm lại: thủ tục pthead_exit() không phải để đóng file, bất kỳ file nào được mở
bên trong thread, các fil
2.3.4.

Truyền tham số cho thread

Thủ tục pthread_create() cho phép người lập trình có thể truyền một đối số cho
thủ tục khởi tạo thread. Tất cả các tham số đều phải được truyền bằng tham
chiếu và kiểu (void *).
Ví dụ 1: truyền 1 tham số:
SVTH: Vũ Đức Nội

Page: 12


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

int t = 5;
pthread_create(&thread, NULL, PrintHello,(void *) t);
Vấn đề đặt ra là nếu như ta muốn truyền 2 tham số cho thread thì phải làm như
thế nào? Trong trường hợp có nhiều tham số cần truyền ta cần tạo ra 1 cấu trúc
struct bao gồm tất cả các tham số, sau đó truyền 1 tham số con trỏ của struct
này vào thủ tục pthread_create().
Ví dụ 2: Truyền nhiều tham số sử dụng struct.
struct thread_data
{
int data1;

int data2;
…
int data;
}data;
pthread_create(&thread, NULL, PrintHello,(void *) &data);
2.3.5.

Nối thread

Nối (joining) là 1 cách để thực hiện việc đồng bộ hóa giữa các thread.
Ví dụ:

Hàm này được sử dụng khi 1 thread đang chạy và chờ 1 thread nào đó để lấy kết
quả.
Vd: Trong hàm main, thread main đang chạy. Khi sử dụng pthread_join(tên thread
cần chờ,giá trị trả về của thread đang chờ) thì hàm main sẽ dừng lại cho đến khi
thread cần chờ đã kết thúc.
Các tham số của hàm pthread_join():
- Tham số đầu tiên của pthread_join() là thread_id, mythread.
- Tham số thứ hai là một con trỏ trỏ vào một con trỏ void. Nếu con trỏ void
SVTH: Vũ Đức Nội

Page: 13


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

không phải là NULL, thì pthread_join sẽ đặt giá trị trả về của

thread_function (là một con trỏ void*) vào tham số thứ 2
Có 2 phương pháp đồng bộ khác là mutexes and condition variables.

SVTH: Vũ Đức Nội

Page: 14


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

Chương 3.
THIẾT KẾ VÀ XÂY DỰNG
CHƯƠNG TRÌNH
3.1. Phân tích yêu cầu
Bài toán đặt ra là nhân hai ma trận lớn bằng multi thread.
Thuật toán nhân hai ma trận:
Phép nhân hai ma trận chỉ thực hiện được khi số cột của ma trận bên trái
bằng số dòng của ma trận bên phải. Nếu ma trân A có kích thước m x n và ma trận
B có kích thước n x p, thì ma trận tích AB có kích thước m x p có phần tử đứng ở
hàng i, cột thứ j xác định bởi:
C[i][j] = A[i][1] * B[1][j] + A[i][2] * B[2][j] + … + A[i][n] * B[n][j]
VD:

Để thực hiện phép nhân hai ma trận bằng multi thread ta tiến hành tạo n thread mỗi
thread có nhiệm vụ nhân các giá trị thuộc hàng thứ i đến hàng thứ j.
3.2. Tổ chức CSDL
- Mỗi ma trận đều có dạng struct:
struct matrix

{
char link[50]; // đường link chứa file
int n; // số hàng
int m; // số cột
int **A;
};
- Ngoài ra còn có biến kiểu pthread_t dùng để tạo các thread.

SVTH: Vũ Đức Nội

Page: 15


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

3.3. Xây dựng các chức năng

-

Tạo hai chương trình con:
+ void *readFile(void *arg); // Để thực hiện việc đọc file
Tiến hành mở file bằng hàm fopen() và đọc file bằng hàm fscanf() để
đọc dữ liệu vào ma trận.
Code:
void *readFile(void *arg)
{
struct matrix *temp = (struct matrix*) arg;
FILE *file;

file = fopen(temp->link,"r");
if (file == NULL)
{
printf("Khong the doc file! Vui long
kiem tra lai duong dan\n");
}
else
{
int i,j;
fscanf(file,"%d",&temp->n);
fscanf(file,"%d",&temp->m);
temp->A = (int**)malloc(temp->n *
sizeof(int*));
for (i = 0;i < temp->n;i++)
temp->A[i] = (int*)malloc(temp->m *
sizeof(int));
for (i = 0;i < temp->n;i++)
for (j = 0;j < temp->m;j++)
fscanf(file,"%d",&temp>A[i][j]);
}
SVTH: Vũ Đức Nội

Page: 16


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

}

+ void *multi(void *arg);// Để nhân 2 ma trận.
Tiến hành nhân 2 ma trận từ hàng from đến to của ma trận A.
Với:
from = (i *fileA.n) / num_thrd
to = ((i + 1) * fileA.n) / num_thrd
i là chỉ số thread.
num_thrd là số thread dùng trong phép nhân này.
Code:
void *multi(void *arg)
{
int s = (int)arg;
int from = (s * fileA.n)/num_thrd;
int to = ((s+1) * fileA.n)/num_thrd;
int i,j,k;
int temp = 0;
for (i = from; i < to; i++)
{
for (j = 0; j < fileB.m; j++)
{
fileC.A[i][j] = 0;
for ( k = 0; k < fileA.m; k++)
fileC.A[i][j] += fileA.A[i][k]
* fileB.A[k][j];
}
}
pthread_exit(NULL);

}

SVTH: Vũ Đức Nội

Page: 17


Đồ án: Nguyên Lý Hệ Điều Hành

Chương 4.
QUẢ

GVHD: Phạm Minh Tuấn

TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT

4.1. Môi trường triển khai
Chương trình được triển khai trên hệ điều hành Ubuntu. Chương trình được
viết trên IDE Code Block và được viết bằng ngôn ngữ C.
4.2. Code chương trình
#include <stdio.h>
#include
#include <stdlib.h>
#include <string.h>
struct matrix
{
char link[50];
int n; // so hang
int m; // so cot
int **A;
};
int num_thrd = 20;

struct matrix fileA;
struct matrix fileB;
struct matrix fileC;
void *readFile(void *arg);
void *multi(void *arg);
int main()
{
int i,j;
pthread_t readFileA,readFileB;
strcpy(fileA.link,"/home/DucNoi/Desktop/Doan/matranA
.txt");
strcpy(fileB.link,"/home/DucNoi/Desktop/Doan/matranB
.txt ");
// thread thu 1 doc ma tran A
pthread_create(&readFileA, NULL,readFile,(void
*)&fileA);
// thread thu 2 doc ma tran B
pthread_create(&readFileB, NULL,readFile,(void
*)&fileB);
// Doi den khi 2 thread doc xong file
pthread_join(readFileA,NULL);
pthread_join(readFileB,NULL);
SVTH: Vũ Đức Nội

Page: 18


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

// Kiem tra xem ma tran A co the nhan voi ma
tran B khong
if (fileA.m != fileB.n)
{
// Ma tran A khong the nhan voi ma tran B
printf("Hai ma tran nay khong the nhan voi
nhau!\n");
return(0);
}
// Ma tran A co the nhan voi ma tran B;
fileC.n = fileA.n;
fileC.m = fileB.m;
fileC.A = (int**)malloc((fileC.n + 100)*
sizeof(int*));
for (i = 0;i < fileC.n;i++)
fileC.A[i] = (int*)malloc(fileC.m *
sizeof(int));
pthread_t *thread;
thread = (pthread_t*) malloc(num_thrd *
sizeof(pthread_t));
for(i = 0;i < num_thrd;i++)
{
if (pthread_create (&thread[i], NULL, multi,
(void*)i) != 0)
{
perror("Can't create thread");
free(thread);
exit(-1);
}

}
for (i = 0; i < num_thrd; i++)
pthread_join (thread[i], NULL);
// Ghi ket qua vao file ketqua.txt
FILE *file;
file =
fopen("/home/Ducnoi/Desktop/Doan/ketqua.txt","w");
fprintf(file,"%d %d\n",fileC.n,fileC.m);
for (i = 0;i {
for (j = 0;j < fileC.m;j++)
fprintf(file,"%d ",fileC.A[i][j]);
fprintf(file,"\n");
}
fclose(file);
printf("Ket qua da duoc luu vao file
ketqua.txt\n+");
printf("All Done!\n");
}
void *readFile(void *arg)
{
SVTH: Vũ Đức Nội

Page: 19


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

struct matrix *temp = (struct matrix*) arg;
FILE *file;
file = fopen(temp->link,"r");
if (file == NULL)
{
printf("Khong the doc file! Vui long kiem
tra lai duong dan\n");
}
else
{
int i,j;
fscanf(file,"%d",&temp->n);
fscanf(file,"%d",&temp->m);
temp->A = (int**)malloc(temp->n *
sizeof(int*));
for (i = 0;i < temp->n;i++)
temp->A[i] = (int*)malloc(temp->m *
sizeof(int));
for (i = 0;i < temp->n;i++)
for (j = 0;j < temp->m;j++)
fscanf(file,"%d",&temp->A[i][j]);
}
}
void *multi(void *arg)
{
int s = (int)arg;
int from = (s * fileA.n)/num_thrd;
int to = ((s+1) * fileA.n)/num_thrd;
int i,j,k;
int temp = 0;

for (i = from; i < to; i++)
{
for (j = 0; j < fileB.m; j++)
{
fileC.A[i][j] = 0;
for ( k = 0; k < fileA.m; k++)
fileC.A[i][j] += fileA.A[i][k] *
fileB.A[k][j];
}
}
pthread_exit(NULL);
}

SVTH: Vũ Đức Nội

Page: 20


Đồ án: Nguyên Lý Hệ Điều Hành

Chương 5.
TRIỂN

GVHD: Phạm Minh Tuấn

KẾT LUẬN VÀ HƯỚNG PHÁT

5.1. Những kết quả đạt được
Sau một thời gian nghiên cứu và tìm hiểu tài liệu, đề tài đã thành công trong
việc nhân hai ma trận với kích thước lớn.

5.2. Những vấn đề tồn tại
-

Chưa có giao diện.

-

Chưa xây dựng chức năng để người sử dụng dẫn nguồn đến file ma trận cần
thực hiện phép nhân.

5.3. Hướng phát triển
Từ những thiếu sót trên, nếu có điều kiện phát triển sẽ nghiên cứu thêm để
chương trình được hoàn chỉnh và đẹp mắt.
Trên đây là phần trình bày của em về đề tài: “Ứng dụng multi thread trong hệ
điều hành Ubuntu để nhân hai ma trận lớn”. Trong quá trình thực hiện đề tài, dù đã
rất cố gắng, nhưng do trình độ kiến thức còn nhiều hạn chế, nên không tránh khỏi
những thiếu sót trong bài làm. Em mong nhận được những đóng góp ý kiến của
thầy, cô để đề tài được hoàn thiện hơn.

SVTH: Vũ Đức Nội

Page: 21


Đồ án: Nguyên Lý Hệ Điều Hành

GVHD: Phạm Minh Tuấn

TÀI LIỆU THAM KHẢO

[1] Jacque Arsac. Nhập môn lập trình. Nguyên bản : Premières lecons de
programmation. Trung tâm hệ thống Thông tin ISC, Hà nội 1991, 241 t.
[2] Doug Cooper. Standard Pascal User Reference Manual. W.W.Norton &
Company, 1983, 476 t.
[3] Neil Matthew and Richard Stones. Beginning Linux Programming

---END---

SVTH: Vũ Đức Nội

Page: 22