Đồ án Cơ Sở Ngành Mạng

Mục lục
Mở Đầu.....................................................................................................................................................1
PHẦN I: NGUYÊN LÝ HỆ ĐIỀU HÀNH ............................................................................................2
CHƯƠNG 1. CƠ SỞ LÝ THUYẾT ..............................................................................................................2
1.1. Sơ lược về hệ điều hành ...........................................................................................................2
1.2. Bộ nhớ ảo ..................................................................................................................................3
1.3. Thuật toán LRU .......................................................................................................................5
CHƯƠNG 2. PHÂN TÍCH THIẾT KẾ HỆ THỐNG .......................................................................................5
2.1. Thiết kế cấu trúc dữ liệu .....................................................................................................5
2.2. Thiết kế chức năng ..............................................................................................................7
PHẦN II: LẬP TRÌNH MẠNG .......................................................................................................... 10
CHƯƠNG 1. CƠ SỞ LÝ THUYẾT ........................................................................................................... 10
1.1. Mô hình client/server ....................................................................................................... 10
1.2. Giao thức TCP .................................................................................................................. 14
CHƯƠNG 2. PHÂN TÍCH THIẾT KẾ HỆ THỐNG .................................................................................... 15
2.1. Thiết kế client ................................................................................................................... 15
2.2. Thiết kế server .................................................................................................................. 17
CHƯƠNG 3. TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ ............................................................................... 18
3.1. Triển khai chương trình ....................................................................................................... 18
3.2. Đánh giá kết quả.................................................................................................................... 23
KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN .......................................................................................... 23
TÀI LIỆU THAM KHẢO ................................................................................................................... 23

1
Đồ án Cơ Sở Ngành Mạng

Mở Đầu

Nhằm mục đích tìm hiểu về các thuật toán thay thế trang LRU trong môn nguyên lý hệ
điều hành và làm quen với việc sử dụng giao thức TCP, em đã chọn đề tài “Mô phỏng
thuật toán thay thế trang LRU thông qua mô hình client/server bằng giao thức TCP” cho
đồ án cơ sở ngành mạng. Hy vọng rằng có thể áp dụng các kiến thức đã học vào thực tế
và tích lũy thêm kinh nghiệm lập trình cho bản thân.
Tuy nhiên, do kiến thức còn hạn hẹp nên chắc chắn không thể tránh được thiếu xót. Vì
thế, em rất mong sự đóng góp ý kiến của các thầy cô để giúp đề tài của em hoàn thiện
hơn.
Em xin chân thành cảm ơn Ts. Phạm Minh Tuấn đã quan tâm, giúp đỡ và hướng
dẫn chúng em rất nhiều trong quá trình tìm hiểu, thiết kế và hoàn thành đồ án này.

Đà Nẵng, ngày 30 tháng 11 năm 2015

1
Đồ án Cơ Sở Ngành Mạng

PHẦN I: NGUYÊN LÝ HỆ ĐIỀU HÀNH

TIÊU ĐỀ: Thuật toán LRU

CHƯƠNG 1. CƠ SỞ LÝ THUYẾT

1.1. Sơ lược về hệ điều hành

1.1.1. Hệ điều hành là gì?
Hệ điều hành là một phần mềm chạy trên máy tính, dùng để điều hành,
quản lý các thiết bị phần cứng và các tài nguyên phần mềm trên máy tính.
Hệ điều hành đóng vai trò trung gian trong việc giao tiếp giữa người sử
dụng và phần cứng máy tính, cung cấp một môi trường cho phép người sử dụng
phát triển và thực hiện các ứng dụng của họ một cách dễ dàng.
1.1.2. Quá trình phát triển
Quá trình phát triển được chia làm 4 giai đoạn cơ bản:
- Giai đoạn 1945-1955: vào khoảng giữa thập niên 1940, Howard Aiken
và John von Neumann đã thành công trong việc xây dựng máy tính dùng ống chân
không. Lúc này thì chưa có ngôn ngữ lập trình và hệ điều hành cũng chưa được
nhắc đên.
-Giai đoạn 1955-1965: sự ra đời của thiết bị bán dẫn đã làm thay đồi bức
tranh tổng thể, máy tính trở nên đáng tin cậy hơn, ngôn ngữ lập trình đầu tiên xuất
hiện là hợp ngữ hay FORTRAN. Hệ thống xử lý theo lô ra đời và nó là tiền thân
của các hệ điều hành sau này.
-Giai đoạn 1965-1980: máy IBM 360 là máy tính đầu tiên sử dụng mạch
tích hợp (IC). Từ đó làm kích thước của hệ thống giảm đi đáng kể, các yêu cầu
xử lý ngày càng phức tạp hơn. Lúc này, hệ điều hành ra đời nhằm điều phối, giải
quyết các tranh chấp thiết bị. Giai đoạn này đánh dấu sự ra đời của hệ điều hành
chia sẻ thời gian như CTSS cảu MIT. Đồng thời các hệ điều hành lớn cũng ra đời
như MULTICS, UNIX và hệ thống các máy mini cũng xuất hiện như DEC PDP-
1.

2
Đồ án Cơ Sở Ngành Mạng

Giai đoạn sau 1980 : giai đoạn này đánh dấu sự ra đời của máy tính cá
nhân, đặc biệt là IBM PC với hệ điều hành MS_DÓ và Window sau này. Bên
cạnh đó cũng có cách hệ điều hành dựa trên UNIX như Linux. Ngoài ra, trong
giai đoạn này cũng đánh dấu sự phát triển của hệ điều hành mạng và hệ điều hành
phan tán.
1.2. Bộ nhớ ảo
1.2.1. Định nghĩa
Bộ nhớ ảo là một kỹ thuật cho phép xử lý một tiến trình không được nạp
toàn bộ vào bộ nhớ vật lý. Bộ nhớ ảo mô hình hoá bộ nhớ như một bảng lưu trữ
rất lớn và đồng nhất, tách biệt hẳn khái niệm không gian địa chỉ và không gian
vật lý. Người sử dụng chỉ nhìn thấy và làm việc trong không gian địa chỉ ảo, việc
chuyển đổi sang không gian vật lý do hệ điều hành thực hiện với sự trợ giúp của
các cơ chế phần cứng cụ thể.
Bộ nhớ áo có thể được cài đặt thông qua:
- Yêu cầu phân trang (demand paging)
- Yêu cầu phân đoạn (demand segmentation)
1.2.2. Yêu cầu phân trang
- Chỉ đưa một trang vào bộ nhớ khi cần thiết
- Ưu điểm:
 Giảm thao tác vào ra
 Tiết kiệm bộ nhớ
 Xử lý nhanh
 Tăng số lượng người sử dụng tiến trình

Với mô hình này, cần cung cấp một cơ chế phần cứng giúp phân biệt các
trang đang ở trong bộ nhớ chính và các trang trên đĩa. Có thể sử dụng lại bit valid-
invalid nhưng với ngữ nghĩa mới:
valid : trang tương ứng là hợp lệ và đang ở trong bộ nhớ chính .
invalid : hoặc trang bất hợp lệ (không thuộc về không gian địa chỉ của tiến
trình) hoặc trang hợp lệ nhưng đang được lưu trên bộ nhớ phụ.
Một phần tử trong bảng trang mộ tả cho một trang không nằm trong bộ
nhớ chính, sẽ được đánh dấu invalid và chứa địa chỉ của trang trên bộ nhớ phụ.

1.2.3. Lỗi trang

Truy xuất đến một trang được đánh dấu bất hợp lệ sẽ làm phát sinh một lỗi
trang (page fault). Khi dò tìm trong bảng trang để lấy các thông tin cần thiết cho việc
chuyển đổi địa chỉ, nếu nhận thấy trang đang được yêu cầu truy xuất là bất hợp lệ, cơ

3
Đồ án Cơ Sở Ngành Mạng

chế phần cứng sẽ phát sinh một ngắt để báo cho hệ điều hành. Hệ điều hành sẽ xử lý lỗi
trang như sau :
Kiểm tra truy xuất đến bộ nhớ là hợp lệ hay bất hợp lệ
Nếu truy xuất bất hợp lệ : kết thúc tiến trình
Ngược lại : đến bước 3
Tìm vị trí chứa trang muốn truy xuất trên đĩa.
Tìm một khung trang trống trong bộ nhớ chính :
Nếu tìm thấy : đến bước 5
Nếu không còn khung trang trống, chọn một khung trang (nạn nhân) và
chuyển trang (nạn nhân) ra bộ nhớ phụ (lưu nội dung của trang đang chiếm giữ
khung trang này lên đĩa), cập nhật bảng trang tương ứng rồi đến bước 5
Chuyển trang muốn truy xuất từ bộ nhớ phụ vào bộ nhớ chính : nạp trang
cần truy xuất vào khung trang trống đã chọn (hay vừa mới làm trống ) ; cập nhật
nội dung bảng trang, bảng khung trang tương ứng.
Tái kích hoạt tiến trình người sử dụng.

Hình 1.1 các bước xử lý lỗi trang

1.2.4. Các thuật toán
Một số thuật toán được sử dụng để xử lý lỗi trang:

4
Đồ án Cơ Sở Ngành Mạng

- FIFO: Các trang vào đầu tiên trong bộ nhớ là một trang được chọn để đổi
vị trí.
- Trang quang học: Thuật toán đổi vị trí trang quang học có tỉ lệ trang lỗi
ít nhất trong tất cả các thuật toán. Một thuật toán đổi vị trí quang học tồn
tại và đã được gọi là OPT hoặc MIN.
- Thuật toán tối ưu: Thay thế trang sẽ lâu được sử dụng nhất trong tương
lai.
- LRU (Least Recently Used): Trang mà không được sử dụng cho thời gian
dài nhất trong bộ nhớ chính là một trang được chọn để đổi vị trí.

1.3. Thuật toán LRU

- Mô tả : thay trang lâu nhất chưa được truy suất
- Lỗi trang : sảy ra khi truy xuất đến 1 trang ko có trong bộ nhớ/địa chỉ ko hợp lệ.
Chỉ xét trong
trường hợp trang ko có trong bộ nhớ (bộ nhớ chính )
- Quá trình truy xuất trang (trường hợp có lỗi trang):
 Truy xuất đến trang ko có trong bộ nhớ (i)
 Gởi tín hiệu đến HĐH
 HĐH + MMU tìm trang trong bộ nhớ phụ
 Nạp trang/thay trang vào bộ nhớ
 Cập nhật PMT
 Truy xuất lại

CHƯƠNG 2. PHÂN TÍCH THIẾT KẾ HỆ THỐNG

2.1. Thiết kế cấu trúc dữ liệu

- Tạo biến đảm nhiệm chức năng là hàng đợi, mô tả các tiến trình được gọi
và đưa vào hàng đợi, chờ để được thực thi.
Queue = new ArrayList<String>();
- Tạo ra dữ liệu giúp ghi lại trạng thái bộ nhớ hiện thời qua mỗi lần thực thi
tiến trình. Mỗi ô bộ nhớ phải ghi lại tên tiến trình được đưa vào và lần cuối
cùng được sử dụng.
public class Memory {

5
Đồ án Cơ Sở Ngành Mạng

String page;
int state;
Memory(){
page=new String();
state=0;
}
public String getPage(){
return page;
}
public int getState(){
return state;
}
public void setPage(String page){
this.page=page;
}
public void setState(int state){
this.state=state;
}
}
- Tạo ra một biến thuộc một kiểu dữ liệu có khả năng lưu trữ thông tin bộ
nhớ trong suốt quá trình để cho phép nhìn thấy toàn bộ tiến trình đã được
thực thi và trạng thái bộ nhớ lúc đó.
public class Store implements Serializable{
Vector title;
Vector row1,row2,row3,row4;
Vector data;
public Store(){
title=new Vector();
data=new Vector();
row1=new Vector();
row2=new Vector();
row3=new Vector();
row4=new Vector();
add("tien trinh","o nho 1","o nho 2","o nho 3","o nho 4");
}
public void add(String vTitle,String vRow1,String vRow2,String
vRow3,String vRow4){

6
Đồ án Cơ Sở Ngành Mạng

title.add(vTitle);
row1.add(vRow1);
row2.add(vRow2);
row3.add(vRow3);
row4.add(vRow4);
}
public Vector getTitle(){
return title;
}
public Vector getData(){
data.clear();
data=new Vector(row1.size());
data.add(row1);
data.add(row2);
data.add(row3);
data.add(row4);
return data;
}
}
2.2. Thiết kế chức năng

Hệ thống chỉ mô tả một chức năng duy nhất là mô phỏng lại thuật toán LRU.
Tuy nhiên, việc này yêu cầu nhiều hành động tham gia vào. Do đó, các phương
thức được tạo ra nhằm đáp ứng yêu cầu của các hành động đó.
 Đưa các tiến trình được gọi vào hàng đợi: các tiến trình được gọi sẽ được
lấy tên tiến trình đưa vào trong hàng đợi để chờ xử lý. Phương thức này
không có giá trị trả về.

public void layTienTrinh(String s) {

int i;
i = queue.lastIndexOf(" ");
if (i != -1) {
queue = queue.substring(0, i) + " " + s;
} else
queue = s;

7
Đồ án Cơ Sở Ngành Mạng

String s1 = s.trim();
while (true) {
i = s1.indexOf(" ");
if (i == -1)
break;
Queue.add(s1.substring(0, i).trim());
s1 = s1.substring(i).trim();
}
}
 Kiểm tra xem tiến trình đó đã có trong bộ nhớ hay chưa: thực hiện việc
truy cập vào trong bộ nhớ và so sánh với tên tiến trình hiện thời để kiểm
tra. Phương thức này trả về giá trị true hoặc false.

public boolean checkMemory(String process) {

int i;
for (i = 0; i < 4; i++)
if (process.compareTo(memory[i].page) == 0)
break;
if (i < 4)
return true;// da ton tai trong memory
return false;// chua ton tai
}
 Tìm vị trí vần thiết để đưa tiến trình vào: tiến hành kiểm tra xem có ô
nhớ nào còn trống hay không. Nếu có trả về vị trí của ô nhớ đó. Ngược
lại, tìm một tiến trình trong bộ nhớ lâu nhất chưa được gọi và trả về vị
trí của tiến trình đó.

public int check() {

int imax = 0, max = memory[0].state;

8
Đồ án Cơ Sở Ngành Mạng

for (int i = 0; i < 4; i++) {

if (memory[i].page.equals(""))
return i;
if (memory[i].state > max) {
max = memory[i].state;
imax = i;
}
}
return imax;}
 Phương thức mô phỏng LRU:lấy một tiến trình ra khỏi hàng đợi. Sau đó,
kiếm tra tiến trình đó có trong bộ nhớ hay không. Nếu có thì cài đặt lại thời
gian gọi gần đây nhất. Ngược lại, tìm vị trí thích hợp theo thuật toán rồi
đưa tiến trình vào bộ nhớ. Cuối cùng lưu lại trang thái bộ nhớ trong lượt
đó. Phương thức này không có giá trị trả về.

public void xuly() {

if (Queue.isEmpty()) {
queue = "PNH";
return; }
process = Queue.get(0).trim();
Queue.remove(0);
queue = queue.substring(queue.indexOf(" ")).trim();
if (checkMemory(process)) {
for (int i = 0; i < 4; i++)
if (process.compareTo(memory[i].page) == 0)
memory[i].state = 0;
} else {
int position = check();
memory[position].page = process;

9
Đồ án Cơ Sở Ngành Mạng

memory[position].state = 0;
}
for (int i = 0; i < 4; i++)
if (!memory[i].page.equals(""))
memory[i].state++;
store.add(process, memory[0].page, memory[1].page,
memory[2].page, memory[3].page);

PHẦN II: LẬP TRÌNH MẠNG

TIÊU ĐỀ: Mô phỏng LRU

theo mô hình client/server bằng giao thức TCP

CHƯƠNG 1. CƠ SỞ LÝ THUYẾT

1.1. Mô hình client/server

1.1.1. Giới thiệu

Trong mô hình này, chương trình ứng dụng được chia thành 2 thành phần:
Quá trình chuyên cung cấp một số phục vụ nào đó, chẳng hạn: phục vụ tập tin,
phục vụ máy in, phục vụ thư điện tử, phục vụ Web... Các quá trình này được gọi là
các trình phục vụ hay Server.
Một số quá trình khác có yêu cầu sử dụng các dịch vụ do các server cung cấp
được gọi là các quá trình khách hàng hay Client.
Việc giao tiếp giữa client và server được thực hiện dưới hình thức trao đổi các
thông điệp (Message). Để được phục vụ, client sẽ gởi một thông điệp yêu cầu
(Request Message) mô tả về công việc muốn server thực hiện. Khi nhận được thông
điệp yêu cầu, server tiến hành phân tích để xác định công việc cần phải thực thi. Nếu
việc thực hiện yêu cầu này có sinh ra kết quả trả về, server sẽ gởi nó cho client trong
một thông điệp trả lời (Reply Message). Dạng thức (format) và ý nghĩa của các thông
điệp trao đổi giữa client và server được qui định rõ bởi giao thức (protocol) của ứng
dụng.

10
Đồ án Cơ Sở Ngành Mạng

Hình 2.1 Mô hình client/server

1.1.2. Các chế độ giao tiếp
Quá trình giao tiếp giữa client và server có thể diễn ra theo hai chế độ là
nghẽn (blocked) hay không nghẽn (Non blocked).
Chế độ nghẽn: Trong chế độ này, khi quá trình client hay server phát ra
lệnh gửi dữ liệu, (thông thường bằng lệnh send) , sự thực thi của nó sẽ bị tạm
dừng cho đến khi quá trình nhận phát ra lệnh nhận số dữ liệu đó (thường là lệnh
receive). Tương tự cho trường hợp nhận dữ liệu, nếu quá trình nào đó, client hay
server, phát ra lệnh nhận dữ liệu, mà ở thời điểm đó chưa có dữ liệu gửi đến, sự
thực thi của nó cũng tạm dừng cho đến khi có dữ liệu gửi đến.

11
Đồ án Cơ Sở Ngành Mạng

Hình 2.2 Giao tiếp nghẽn

Chế độ không nghẽn: Trong chế độ này, khi quá trình client hay server
phát ra lệnh gửi dữ liệu, sự thực thi của nó vẫn được tiếp tục mà không quan tâm
đến việc có quá trình nào phát ra lệnh nhận số dữ liệu đó hay không. Tượng tự
cho trường hợp nhận dữ liệu, khi quá trình phát ra lệnh nhận dữ liệu, nó sẽ nhận
được số lượng dữ liệu hiện có (bằng 0 nếu chưa có quá trình nào gửi dữ liệu đến).
Sự thực thi của quá trình vẫn được tiếp tục.

12
Đồ án Cơ Sở Ngành Mạng

Hình 2.3 Giao tiếp không nghẽn

1.1.3.Cấu trúc client/server
Client/server hai tầng: là cấu trúc đơn giản nhất. Trong thực tế hầu hết
các kiến trúc client/server là kiến trúc hai tầng. Một ứng dụng hai tầng cung cấp
nhiều trạm làm việc với một tầng trình diễn thống nhất, tầng này truyền tin với
tầng lưu trữ dữ liệu tập trung. Tầng trình diễn thông thường là client, và tầng lưu
trữ dữ liệu là server. Hầu hết các ứng dụng Internet như là email, telnet, ftp thậm
chí là cả Web là các ứng dụng hai tầng.
Client/server ba tầng: Ta có thể tránh được các vấn đề của kiến trúc
client/server hai tầng bằng cách mở rộng kiến trúc thành ba tầng. Một kiến trúc
ba tầng có thêm một tầng mới tách biệt việc xử lý dữ liệu ở vị trí trung tâm.

Kiến trúc n tầng: được chia thành các tầng như sau:
 Tầng giao diện người dùng: quản lý tương tác của người dùng với ứng
dụng
 Tầng logic trình diễn: Xác định cách thức hiển thị giao diện người dùng
và các yêu cầu của người dùng được quản lý như thế nào.
 Tầng logic tác nghiệp: Mô hình hóa các quy tắc tác nghiệp.
 Tầng các dịch vụ hạ tầng: Cung cấp một chức năng bổ trợ cần thiết cho
ứng dụng như các thành phần (truyền thông điệp, hỗ trợ giao tác).

13
Đồ án Cơ Sở Ngành Mạng

1.2. Giao thức TCP

Giao thức TCP (Transmission Control Protocol - "Giao thức điều khiển
truyền vận") là một trong các giao thức cốt lõi của bộ giao thức TCP/IP. Sử dụng
TCP, các ứng dụng trên các máy chủ được nối mạng có thể tạo các "kết nối" với
nhau, mà qua đó chúng có thể trao đổi dữ liệu hoặc các gói tin. Giao thức này
đảm bảo chuyển giao dữ liệu tới nơi nhận một cách đáng tin cậy và đúng thứ tự.
1.2.1. Một số khái niệm
Socket là một cổng logic mà một chương trình sử dụng để kết nối với một
chương trình khác chạy trên một máy tính khác trên Internet. Chương trình mạng
có thể sử dụng nhiều Socket cùng một lúc, nhờ đó nhiều chương trình có thể sử
dụng Internet cùng một lúc.
Một TCP/IP Socket gồm một địa chỉ IP kết hợp với một port ? Xác định
duy nhất một tiến trình (process ) trên mạng.Hay nói cách khác Luồng thông tin
trên mạng dựa vảo IP là để xác định máy một máy trên mạng còn port xác định 1
tiến trình trên 1 máy.
1.2.2. Cách gọi hàm

Hình 2.4 socket trong TCP

14
Đồ án Cơ Sở Ngành Mạng

CHƯƠNG 2. PHÂN TÍCH THIẾT KẾ HỆ THỐNG

2.1. Thiết kế client

Client đảm nhận nhiệm vụ gửi các thông điệp đén server và nhận các dữ
liệu trả về (nếu có).
- Thiết kế phương thức có thể gửi một thông điệp bất kỳ ở dạng chuỗi và
nhận ở dạng chuỗi kết quả trả về từ server. Phương thức này trả về kiểu
String.

public String sent(String message) throws Exception {

connection = new Socket("localhost", 6000);
dis = new DataInputStream(connection.getInputStream());
dos = new
DataOutputStream(connection.getOutputStream());
dos.writeUTF(message);
return dis.readUTF();
}
- Thiết kế phương thức yêu cầu server trả về trạng thái bộ nhớ và tiến trình
đang xử lý ở lượt đó. Tuy nhiên, việc này không được cho client biết được
cấu trúc lưu trữ của biến lưu trữ trạng thái bộ nhớ đó. Phương thức không
có giá trị trả về

public void sentMemory() throws Exception {

for (int i = 0; i < 4; i++)
buff[i] = sent("ACK" + i);
process = sent("ACK4");
}
- Phương thức yêu cầu server trả về thống kê các tiến trình đã được xử lý
cũng như tình trạng bộ nhớ qua mỗi quá trình. Phương thức yêu cầu trả về
đối tượng lưu trữ.

15
Đồ án Cơ Sở Ngành Mạng

public Store sentObject()throws Exception{

connection=new Socket("localhost",6000);
dos=new
DataOutputStream(connection.getOutputStream());
dos.writeUTF("THONGKE");
ObjectInputStream ois;
ois=new ObjectInputStream(connection.getInputStream());
return (Store)ois.readObject();
}
- Thiết kế phương thức yêu cầu trả về trạng thái bộ nhớ trong server. Phương
thức này được gọi ngay lúc client vừa được khởi động lên.

public void setMemoryStart() throws Exception {

for (int i = 0; i < 4; i++) {
memory[i] = sent("ACK" + i);
txtm[i].setText(memory[i]);
}
}
- Phương thức yêu cầu trả về trạng thái của hàng đợi

public void setQueue(String s) {

s = s.trim();
if (s.equals("PNH"))
txt2.setText("Queue is emply");
else {
int i = s.lastIndexOf(" ");
s = s.substring(0, i).trim();
txt2.setText(s);
}

16
Đồ án Cơ Sở Ngành Mạng

2.2. Thiết kế server

Server có nhiệm vụ nhận tất cả các thông điệp từ client và gửi lại kết quả xử
lý các thông điệp đó cho client thể hiện lên. Công việc đó được thực hiện trong
phương thức main
public static void main(String[] args) {
try {
Server dt = new Server();

while (true) {
Socket connection = dt.server.accept();
DataInputStream dis;
Dis =new DataInputStream(connection.getInputStream());
DataOutputStream dos;
dos = new
DataOutputStream(connection.getOutputStream());
dt.nhan = dis.readUTF();
switch (dt.nhan) {
case "CTN":
dt.xuly();
dos.writeUTF(dt.queue);
break;
case "ACK0":
dos.writeUTF(dt.memory[0].page);
break;
case "ACK1":
dos.writeUTF(dt.memory[1].page);
break;
case "ACK2":
dos.writeUTF(dt.memory[2].page);
break;
case "ACK3":
dos.writeUTF(dt.memory[3].page);
break;

17
Đồ án Cơ Sở Ngành Mạng

case "ACK4":
dos.writeUTF(dt.process);
break;
case "START":
dos.writeUTF(dt.queue);
break;
case "THONGKE":
ObjectOutputStream oos;
oos=new ObjectOutputStream
(connection.getOutputStream());
oos.writeObject(dt.store);
break;
default:
dt.layTienTrinh(dt.nhan);
dos.writeUTF(dt.queue);
}
}
} catch (Exception e) {
}

CHƯƠNG 3. TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ

3.1. Triển khai chương trình

- Chạy chương trình server sau đó là chương trình client. Quan sát bên màn
hình client. Vì mới khởi động lên nên ô nhớ và hàng đợi đều trống.

18
Đồ án Cơ Sở Ngành Mạng

- Nhập tên các tiến trình vào ô text, có thể nhập tay hoặc đọc từ file, sau đó
ấn nút “xong”

- Bấm “continue” lần 1, hiện ra thông báo tên tiến trình đang xử lý, hàng
đợi được lấy ra một tiến trình.

19
Đồ án Cơ Sở Ngành Mạng

- Bấm “continue” lần 2, tiến trình đang xử lý không có trong ô nhớ, tiến
hành load từ bộ nhớ vật lý

- Bấm “continue” lần 3, hệ thống tìm thấy ô nhớ số 1 còn trống

20
Đồ án Cơ Sở Ngành Mạng

- Bấm “continue” lần 4, hệ thống tiến hành load trang vào ô nhớ 1

- Bấm “continue” lần 5, quay lại giống lần 1

21
Đồ án Cơ Sở Ngành Mạng

- Sau nhiều lần ấn “continue”, sau đó đó ấn “detail” xuất hiện một cửa số
thống kê các tiến trình đã xử lý và trang thái ô nhớ lúc đó

22
Đồ án Cơ Sở Ngành Mạng

3.2. Đánh giá kết quả

Theo khuôn khổ của đề tài, em làm rõ một số vấn đề liên quan đến môn Nguyên
lý hệ điều hành và Lập trình mạng. Xây dựng thành công chương trình mô phỏng thuật
toán LRU thông qua mô hình client/server.
Đồ án đạt được những kết quả như sau:
- Tìm hiểu cách xây dựng chương trình theo giao thức TCP/IP bằng mô hình
client/server.
- Tìm hiểu các khái niệm về lập trình mạng.
- Tìm hiểu về các thuật toán FIFO, thuật toán ưu tiên và đặc biệt là thuật
toán LRU trên bộ nhớ ảo trong hệ điều hành.

Tuy nhiên, đồ án này vẫn còn nhiều điểm hạn chế nên chương trình không thể trở
thành sản phẩm thương mại. Việc quản lý mã nguồn vẫn còn thủ công và không theo
quy trình.

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

Đồ án đã mô phỏng thành công thuật toán LRU trong hệ điều hành.
Đồng thời kết hợp với môn Lập trình mạng để giao tiếp giữa 2 chương trình
với nhau theo mô hình client/server.
Đồ án tìm hiểu và làm rõ một số vẫn đề liên quan về thuật toán LRU,
hệ điều hành, lập trình mạng qua giao thức TCP/IP
Cũng cố lại kiến thức về hướng đối tượng và lập trình trên java
Bên cạnh đó, đồ án vẫn có thể nâng cấp để phát triển hơn. Về hệ điều
hành, có thể làm nhiều thuật toán như FIFO, thuật toán ưu tiên, thuật toán
quang học,… Về lập trình mạng, có thể thêm các chức năng tính toán thời
gian chờ,…
Em xin cảm ơn thầy Phạm Minh Tuấn đã hướng dẫn em suốt quá
trình làm đồ án này.

TÀI LIỆU THAM KHẢO

1. Giáo trình lập trình mạng

2. Hệ điều hành
https://vi.wikipedia.org/wiki/H%E1%BB%87_%C4%91i%E1%BB%81u_h%C3%A0nh

23
Đồ án Cơ Sở Ngành Mạng

3. Lịch sử phát triển của hệ điều hành

https://voer.edu.vn/c/lich-su-phat-trien-he-dieu-hanh/a039fa79/4b6ec0d4

4. Bộ nhớ ảo
http://vietjack.com/operating_system/os_virtual_memory.jsp

5. Lập trình socket với TCP

https://loiuit.wordpress.com/2011/05/29/l%E1%BA%ADp-trinh-socket-v%E1%BB%9Bi-tcp/

24