(123doc) Xay Dung Chuong Trinh Mo Phong Cac Giai Thuat Dinh Thoi Cho Cpu

LỜI NÓI ĐẦU
Hệ điều hành là một thành phần quan trọngkhông thể thiếu được trong mỗi một hệ
thống máy tính điện tử. Nó là phần gắn bó trực tiếp với phần cứng và là môi trường để
cho các chương trình ứng dụng khác chạy trên nó. Việc tìm hiểu về hệ điều hành đối
với các sinh viên ngành công nghệ thông tin là rất quan trọng. Thông qua môn học
“Nguyên Lý Hệ Điều Hành” em đã được học về các kiến thức cơ bản. Để hiểu rõ hơn
về các thức làm việc, chức năng quản lý và phân phối tài nguyên cũng như ứng dụng
các kiến thức đã được học về hệ điều hành vào thực tế em chọn đề tài :” Xây Dựng
Chương Trình Mô Phỏng Các Giả Thuật Định Thời Cho CPU”.
Trong quá trình làm không tránh khỏi những thiếu sót, em mong nhận được lời nhận
xét và giúp đỡ của các thầy cô giáo để chúng em hoàn thiện hơn. Đồng thời em xin
được gửi lời cảm ơn chân thành đến cô “ Trần Hồ Thuỷ Tiên” đã nhiệt tình giúp đỡ em
hoàn thành đề tài này.
Mô phỏng các giải thuật lập lịch cho CPU
MỤC LỤC
LỜI NÓI ĐẦU............................................................................................................................2
I. GIỚI THIỆU ĐỀ TÀI.............................................................................................................4
1. Đề Tài.....................................................................................................................................4
2. Mục Tiêu................................................................................................................................4
II. CƠ SỞ LÝ THUYẾT............................................................................................................5
1. Các khái niệm......................................................................................................................5
a. Định thời cho CPU là gì?......................................................................................................5
b. Vì sao phải định thời cho CPU?............................................................................................5
c. Các mục tiêu của định thời....................................................................................................5
2. Các danh sách sử dụng trong quá trình điều phối...............................................................5
III. CÁC GIẢI THUẬT ĐỊNH THỜI CHO CPU......................................................................8
a Chiến lược FIFO( First Comes First Served)........................................................................8
b.Chiến lược điều phối theo độ ưu tiên(Priority-Scheduling PS).............................................9
c.Chiến lược công việc ngắn nhất trước (Shortest-job-first SJF)...........................................11
d.Chiến lược phân phối xoay vòng (Round Robin).................................................................12
IV. THIẾT KẾ HỆ THỐNG....................................................................................................14
1. Cấu trúc dữ liệu....................................................................................................................14
a. Cấu trúc dữ liệu tiến trình...................................................................................................14
b. Đầu vào:...............................................................................................................................14
c. Đầu ra:.................................................................................................................................14
2. Thuật toán.............................................................................................................................14
b. FCFS....................................................................................................................................17
c. SJF........................................................................................................................................18
d. SRT.......................................................................................................................................20
e. RR.........................................................................................................................................21
f. Tính hời gian chờ,lưu lại của các tiến trình và thời gian chờ trung bình............................24
g. Vẽ sơ đồ Grant.....................................................................................................................25
V. CHẠY THỬ CHƯƠNG TRÌNH.........................................................................................27
a. Giao diện ban đầu................................................................................................................27
d. Thuật toán FCFS..................................................................................................................27
e. Thuật toán SJF.....................................................................................................................28
f. Thuật toán SRT(thời gian chờ trung bình thấp nhất)...........................................................28
g. Thuật toán Round Robin (thời gian chờ trung bình cao nhất)............................................29
VI. KẾT LUẬN........................................................................................................................30
VII.TÀ I LIỆ U............................................................................................................................31
VIII. PHỤ LỤC........................................................................................................................32
GVHD: Trần Hồ Thuỷ Tiên Page 2

I. GIỚI THIỆU ĐỀ TÀI

1. Đề Tài
Xây dựng chương trình mô phỏng các giải thuật định thời cho CPU.
2. Mục Tiêu
Hiểu về các khái niệm cơ bản về định thời cho CPU, mục tiêu của định thời và các
thuật toán định thời:
 Tìm hiểu các thuật toán FIFO, SJF, SRT, RR.
- Các ưu điểm của các giải thuật định thờiCPU.
- Các nhược điểm của các giải thuật định thời CPU.
- Các nguyên tắc hoạt động và sự khác nhau của các giải thuật này
 Xây dựng mô phỏng sử dụng các thuật toán trên bằng ngôn ngữ lập trình (ở đây
em chọn ngôn ngữ C++ trên môi trường Dev-C++,có cài đặt thêm gói winBGIm hỗ trợ
đồ họa để xây dựng mô phỏng).
- Viết chương trình mô phỏng các giải thuật đã tìm hiểu trên

II. CƠ SỞ LÝ THUYẾT
1. Các khái niệm.
a. Định thời cho CPU là gì?
Định thời cho CPU là cách chuyển đổi CPU giữa các quá trình, để hệ điều hành có thể
làm cho máy tính hoạt động nhiều hơn. Nó là cơ sở của các hệ điều hành đa chương.
Trong môi trường hệ điều hành đa nhiệm, bộ phận điều phối tiến trình có nhiệm vụ
xem xét và quyết định khi nào thì dừng tiến trình hiện tại để thu hồi processsor và
chuyển processor cho tiến trình khác. Và khi đã có processor thì chọn tiến trình ở trạng
thái ready để cấp processor cho nó.
b. Vì sao phải định thời cho CPU?
Trong hệ thống multitasking(đa nhiệm) thì tại mỗi thời điểm trong bộ nhớ có nhiều
process(tiến trình) nhưng tại mỗi thời điểm chỉ có một process được thực thi do đó cần
phải giải quyết vấn đề phân chia,do đó cần định thời để phân phối thời gian sử dụng
CPU cho các tiến trình của người sử dụng và hệ thống.
c. Các mục tiêu của định thời.
 Sự công bằng( Fairness): Các tiến trình chia sẻ CPU một cách công bằng, không
có tiến trình nào phải chờ đợi vô hạn để được cấp phát CPU.
 Tính hiệu qủa (Efficiency): Khoảng thời gian CPU bận, từ 0% đến 100%.Cần giữ
cho CPU càng bận càng tốt.
 Thời gian đáp ứng hợp lý (Response time): Cực tiểu hoá thời gian hồi đáp cho các
tương tác của người sử dụng.
 Thời gian lưu lại trong hệ thống (Turnaround Time): Cực tiểu hóa thời gian hoàn
tất các tác vụ xử lý theo lô.
 Thông lượng tối đa(Throughput ): Cực đại hóa số công việc được xử lý trong một
đơn vị thời gian.
Tuy nhiên thường không thể thỏa mãn tất cả các mục tiêu kể trên vì bản thân
chúng có sự mâu thuẫn với nhau mà chỉ có thể dung hòa chúng ở mức độ nào đó.
2. Các danh sách sử dụng trong quá trình điều phối.
Hệ điều hành sử dụng hai loại danh sách để thực hiện điều phối các tiến trình là danh
sách sẵn sàng (ready list) và danh sách chờ đợi(waiting list).
Khi một tiến trình bắt đầu đi vào hệ thống, nó được chèn vào danh sách các tác vụ
(job list).Danh sách này bao gồm tất cả các tiến trình của hệ thống. Nhưng chỉ các tiến

trình đang thường trú trong bộ nhớ chính và ở trạng thái sẵn sàng tiếp nhận CPU để
hoạt động mới được đưa vào danh sách sẵn sàng.
Bộ điều phối sẽ chọn một tiến trình trong danh sách sẵn sàng và cấp CPU cho tiến
trình đó. Tiến trình được cấp CPU sẽ thực hiện xử lý, và có thể chuyển sang trạng thái
chờ khi xảy ra các sự kiện như đợi một thao tác nhập/xuất hoàn tất, yêu cầu tài nguyên
chưa được thỏa mãn, được yêu cầu tạm dừng...Khi đó tiến trình sẽ được chuyển sang
một danh sách chờ đợi.
Hình 2.1: Các danh sách sử dụng trong quá trình điều phối.
Các danh sách điều phối

Hệ điều hành chỉ sử dụng một danh sách sẵn sàng cho toàn hệ thống, nhưng mỗi một
tài nguyên ( thiết bị ngoại vi ) có một danh sách chờ đợi riêng bao gồm các tiến trình
đang chờ được cấp phát tài nguyên đó.
Quá trình xử lý của một tiến trình trải qua những chu kỳ chuyển đổi qua lại giữa danh
sách sẵn sàng và danh sách chờ đợi. Sơ đồ dưới đây mô tả sự điều phối các tiến trình
dựa trên các danh sách của hệ thống.
Thoạt đầu tiến trình mới được đặt trong danh sách các tiến trình sẵn sàng (ready list),
nó sẽ đợi trong danh sách này cho đến khi được chọn để cấp phát CPU và bắt đầu xử lý.
Sau đó có thể xảy ra một trong các tình huống sau :
Tiến trình phát sinh một yêu cầu một tài nguyên mà hệ thống chưa thể đáp ứng, khi
đó tiến trình sẽ được chuyển sang danh sách các tiến trình đang chờ tài nguyên tương
ứng.
Tiến trình có thể bị bắt buộc tạm dừng xử lý do một ngắt xảy ra, khi đó tiến trình
được đưa trở lại vào danh sách sẵn sàng để chờ được cấp CPU cho lượt tiếp theo.

Hình 2.2: Tiến trình có thể bị bắt buộc tạm ngừng xử lý do một ngắt xảy ra.
Sơ đồ chuyển đổi giữa các danh sách điều phối

Trong trường hợp đầu tiên, tiến trình cuối cùng sẽ chuyển từ trạng thái blocked sang
trạng thái ready và lại được đưa trở vào danh sách sẵn sàng. Tiến trình lặp lại chu kỳ
này cho đến khi hoàn tất tác vụ thì được hệ thống hủy bỏ khỏi mọi danh sách điều phối.

III. CÁC GIẢI THUẬT ĐỊNH THỜI CHO CPU

a. Chiến lược FIFO( First Comes First Served)
Hình 3.1: Chiến lược FIFO.
 Nguyên tắc.
 Đây là thuật toán điều phối theo nguyên tắc độc quyền.
 Processor được cấp phát cho tiến trình đầu tiên trong danh sách sẵn sàng có yêu
cầu, là tiến trình được đưa vào hệ thống sớm nhất.
 FIFO được sử dụng trong điều phối độc quyền nên khi tiến trình được cấp
processor nó sẽ sở hữu processor cho đến khi kết thúc xử lý hay phải đợi một thao tác
vào/ra hoàn thành, khi đó tiến trình chủ động trả lại processor cho hệ thống.
 Ví dụ:
Nếu hệ điều hành cần cấp processor cho 3 tiến trình P1, P2, P3, với thời điểm vào
ready list và khoảng thời gian mỗi tiến trình cần processor được mô tả trong bảng sau:
Tiến trình Thời điểm vào Thời gian xử lý

P1 0 24
P2 1 3
P3 2 3
Thì thứ tự cấp processor cho các tiến trình diễn ra như sau:
Tiến trình: P1 P2 P3
Thời điểm: 0 24 27
Giản đồ Gantt cho việc định thời là:
Hình 3.2: Giản đồ Gantt cho việc định thời.
Vậy thời gian chờ của tiến trình P1 là 0, của P2 là 23 (24 -1), của P3 là:

25= 24+3- 2
Và thời gian chờ đợi trung bình của các tiến trình là:
(0 + 23 + 25)/3 = 16.
 Các ưu điểm của giả thuật FIFO:
 Ưu điểm của thuật toán này là giờ CPU không bị phân phối lại(không bị ngắt) và
chi phí thực hiện thấp nhất(vì không phải thay đổi thứ tự ưu tiên phục vụ, thứ tự ưu tiên
làthứ tự của tiến trình trong hàng đợi).
 Cáchạn chế của giải thuật FIFO:
 Thứ nhất, có thời gian chờ đợi trung bình lớn nên không phù hợp với các hệ thống
chia sẻ thời gian.
 Thứ hai, khả năng tương tác kém khi nó được áp dụng trên các hệ thống
uniprocessor.
 Thứ ba, nếu các tiến trình ở đầu ready list cần nhiều thời gian của processor thì các
tiến trình ở cuối ready list sẽ phải chờ lâu mới được cấp processor.
 ứng dụng của giải thuật FIFO:
 FCFS thường được sử dụng trong các hệ thống bó (batch system).
 Giải thuật này đặc biệt không phù hợp với các hệ phân chia thời gian, trong các hệ
này, cần cho phép mỗi tiến trình được cấp phát CPU đều đặn trong từng khoảng thời
gian.
b. Chiến lược điều phối theo độ ưu tiên(Priority-Scheduling PS)
 Nguyên tắc
 Giải thuật điều phối với độ ưu tiên có thể theo nguyên tắc độc quyền hay không
độc quyền.
 Mỗi tiến trình được gán cho một độ ưu tiên tương ứng, tiến trình có độ ưu tiên cao
nhất sẽ được chọn để cấp phát processor đầu tiên.
 Độ ưu tiên có thể được định nghĩa nội tại hay nhờ vào các yếu tố bên ngoài.
 Khi một tiến trình được đưa vào danh sách các tiến trình sẵn sàng, độ ưu tiên của
nó được so sánh với độ ưu tiên của tiến trình hiện hành đang xử lý. Giải thuật điều phối
với độ ưu tiên và không độc quyền sẽ thu hồi CPU từ tiến trình hiện hành để cấp phát
cho tiến trình mới nếu độ ưu tiên của tiến trình này cao hơn tiến trình hiện hành. Một
giải thuật độc quyền sẽ chỉ đơn giản chèn tiến trình mới vào danh sách sẵn sàng, và tiến
trình hiện hành vẫn tiếp tục xử lý hết thời gian dành cho nó.

 Ví dụ: Nếu hệ điều hành cần cấp processor cho 3 tiến trình P1, P2, P3 với độ ưu
tiên và khoảng thời gian mỗi tiến trình cần processor được mô tả trong bảng sau:
Tiến trình Độ ưu tiên Thời gian xử lý
P1 3 24
P2 1 3
P3 2 3
Thì thứ tự cấp processor (theo nguyên tắc độc quyền) cho các tiến trình lần lượt là:
Tiến trình P2 P3 P1
Thời điểm 0 4 7
Trong phần xây dựng ứng dụng mô phỏng chúng ta sẽ thực hiện chiến lược điều phối
với độ ưu tiên là thời gian lưu lại ngắn nhất SRT(Shortest Remaining Time).
Shortest Remaining Time (SRT)
Nguyên tắc
Nếu một tiến trình mới đến mà có thời gian dùng nhỏ hơn thời gian cần CPU còn lại
của tiến trình đang thực thi, thì thực hiện tiến trình mới đến này
Cách làm này còn được gọi là Shortest-Remaining-Time (SRTF)
Nó là phiên bản điều phối không độc quyền của SJF
Ví dụ:
Process Thời điểm đến Burst time (ms)
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
- Giản đồ Gantt khi định thời theo SRTF
- Thời gian đợi trung bình = (9 + 1 + 0 + 2)/4 = 3
+Tốt hơn giải thuật SJF
Ưu điểm
-Tránh trường hợp các process có thời gian thực thi dài độc chiếm CPU
- Có thời gian quay vòng tốt hơn SJF
- Process có thời gian thực thi ngắn có độ ưu tiên cao
Nhược điểm
-Cần phải quản lý thời gian thực thi còn lại của các process

- có thể làm phát sinh các trường hợp “đói CPU” có thời gian sử dụng CPU tương đối
lâu
- ví dụ trường hợp các tiến trình có thời gian ngắn liên tục được đưa vào -> các tiến
trình dài không được phép sử dụng CPU
c. Chiến lược công việc ngắn nhất trước (Shortest-job-first)
Nguyên tắc :Giải thuật này gán tớimỗi quá trình chiều dài của chu kỳ CPU tiếp theo
cho quá trình sau đó. Khi CPU sẵn dùng, nó được gán tới quá trình có chu kỳ CPU kế
tiếp ngắn nhất. Nếu hai quá trình có cùng chiều dài chu kỳ CPU kế tiếp, định thời FIFO
được dùng. Chú ý rằng thuật ngữ phù hợp hơn là chu kỳ CPU kế tiếp ngắn nhất
(shortest next CPU burst) vì định thời được thực hiện bằng cách xem xét chiều dài của
chu kỳ CPU kế tiếp của quá trình hơn là toàn bộ chiều dài của nó.Chúng ta dùng thuật
ngữ SJF vì hầu hết mọi người và mọi sách tham khảo tới nguyên lý của loại định thời
biểu này như SJF.
Ví dụ :
Tiến Thời điểm vào RL Thời gian xử
trình lý
P1 0 6
P2 1 8
P3 2 4
P4 3 2
Sử dụng thuật giải SJF độc quyền, thứ tự cấp phát CPU như sau:
P1 P4 P3 P2
0 6 8 12 20
Sử dụng thuật giải SJF không độc quyền, thứ tự cấp phát CPU như sau:
P1 P4 P1 P3 P2
0 3 5 8 12 20
 Ưu điểm :
- Giải thuật được xem là tối ưu, thời gian chờ đợi trung bình giảm
- Tận dụng hết năng lực của CPU
 Nhược điểm :
- Cài đặt thuật toán phức tạp,tốn nhiều xữ lý cho quá trình quản lý.

- Mặcdù SJF là tối ưu nhưng nó không thể được cài đặt tại cấp định thời CPU ngắn
vì không có cách nào để biết chiều dài chu kỳ CPU tiếp theo.
- Giảithuật SJF có thể trưng dụng hoặc không trưng dụng CPU, dẫn tới giải thuật
này có nhiều dị bản khác nhau và sẽ tối ưu hay không tối ưu phụ thuộc vào trưng dụng
CPU.
d. Chiến lược phân phối xoay vòng (Round Robin)
Nguyên tắc : Danh sách sẵn sàng được xử lý như một danh sách vòng, bộ điều phối
lần lượt cấp phát cho từng tiến trình trong danh sách một khoảng thời gian tối đa sử
dụng CPU cho trước gọi là quantum. Tiến trình đến trước thì được cấp phát CPU trước.
Đây là một giải thuật điều phối không độc quyền : khi một tiến trình sử dụng CPU đến
hết thời gian quantum dành cho nó, hệ điều hành thu hồi CPU và cấp cho tiến trình kế
tiếp trong danh sách. Nếu tiến trình bị khóa hay kết thúc trước khi sử dụng hết thời gian
quantum, hệ điều hành cũng lập tức cấp phát CPU cho tiến trình khác. Khi tiến trình
tiêu thụ hết thời gian CPU dành cho nó mà chưa hoàn tất, tiến trình được đưa trở lại vào
cuối danh sách sẵn sàng để đợi được cấp CPU trong lượt kế tiếp.
Ví dụ :
Hình 3.3: Chiến lược RR.
Hình 2.10 Điều phối Round Robin

Tiến Thời điểm vào Thời gian xử
trình RL lý
P1 0 24
P2 1 3
P3 2 3
Nếu sử dụng quantum là 4 milisecondes, thứ tự cấp phát CPU sẽ là
P1 P2 P3 P1 P1 P1 P1 P1
0 ‘4 7 10 14 18 22 26
30
Thời gian chờ đợi trung bình sẽ là (0+6+3+5)/3 = 4.66 milisecondes.
 Ưu điểm :

- Các quá trình sẽ được luân phiên cho CPU xữ lý nên thời gian chờ đợi sẽ ít.
- Đối với các quá trình liên quan đến nhập xuất,IO,người dùng thì rất hiệu quả.
- Việc cài đặt không quá phức tạp
 Nhược điểm :
- Thời gian chờ đợi trung bình dưới chính sách RR thường là quá dài.
- Nếu thời gian định mức cho việc xữ lý quá lớn thì RR thành FIFO
- Nếu thời gian quá ngắn so với thời gian xữ lý của một tiến trình trong danh sách
hàng đợi thì việc chờ đợi và xữ lý luân phiên sẽ nhiều.
- Qui tắc là định mức thời gian nên dài hơn 80% chu kỳ CPU.

IV. THIẾT KẾ HỆ THỐNG
1. Cấu trúc dữ liệu

Cấu trúc dữ liệu đề xuất cho tiến trình được xây dựng thành các struct nhằm tạo điều kiện
thuân lợi cho việc quản lý các tiến trình.
a. Cấu trúc dữ liệu tiến trình
Để lưu trữ thông tin về tiến trình dùng một struct “process” gồm có 3 trường:
struct process
{ int id;
int timexh;
int timeth;
};
- Id : tên tiến trình
- Txh : thời gian đến
- Tth: thời gian xử lý của tiến trình
b. Đầu vào:
Một danh sách gồm các tiến trình.
c. Đầu ra:
Một danh sách bao gồm các struct “sodo” dùng để vẽ sơ đồ giant.mỗi struct sodo là một ô
được vẽ trong sơ đồ Giant
Struct “sodo” gồm các trường như sau:
struct sodo
{ int *ten;
int *moc;
int sl;
};
- Ten[] : tên các tiến trình

- Moc[] : các mốc thời gian
- Sl : số lượng các ô được vẽ
Ví dụ để có được sơ đồ Giant như sau
Thì đầu ra cần có G.ten[1]=1,G.ten[2]=2,G.ten[3]=3

G.moc[1]=0,G.moc[2]=1,G.moc[3]=10. G.sl=3.
2. Thuật toán
Trước khi thực hiện các thuật toán thì các tiến trình được sắp xếp theo thời gian đến tăng
dần.
a. Hàm main()

Hình 4.1: Sơ đồ khối hàm main().
Code:
int main( )
{
initwindow( 800 , 600 , "LAP LICH CPU" );
settextstyle(1,0,1);
settextjustify(1,1);
outtextxy( 380 ,30 , "CHUONG TRINH LAP LICH CHO CPU!" );
outtextxy( 380 ,595 , "svth: Nguyen Huu Thien" );
outstreamxy( 0 , 15 );
char k; int n;
process *X; sodo G;
do
{ do{ clrscr();
cout<<"\tSo luong tien trinh: "; cin>>n;
}while(n<=0||n>15);
X=new process[n];
clrscr();
X=input(n); // Tien hanh nhap du lieu cho mang tien
trinh
label:
clrscr();
debai(X,n);
ve_debai(X,n);
gotoxy(1,1);
cout<<"\n\tChon thuat toan";
cout<<"\n\t1. Thuat toan FCFS";
cout<<"\n\t2. Thuat toan SJF";

cout<<"\n\t3. Thuat toan SRT";

cout<<"\n\t4. Thuat toan RR";
cout<<"\n\t5. Nhap lai ";
cout<<"\n\t6. Thoat chuong trinh";
cout<<"\n\t Ban chon: ";
cin>>k;
}while(k=='5');
if(k=='6') exit(0);
if(k!=5)
{
float timeavg;
if(k=='1') {G=FCFS(X,n) ; outtextxy( 310 ,60 , "ALGORITHM
FIRST COME FIRST SERVICE" );
outtextxy( 350 ,75 , "( den
truoc phuc vu truoc)" );}
else if(k=='2') {G=SJF(X,n);outtextxy( 310 ,60 ,
"ALGORITHM SHORTEST JOB FIRST" );
outtextxy( 350 ,75 , "( cong
viec ngan nhat )" );}
else if(k=='3') {G=SRT(X,n);outtextxy( 310 ,60 ,
"ALGORITHM SHORTEST REMAINING TIME" );
outtextxy( 350 ,75 , "(theo
do uu tien)" );}
else if(k=='4') {G=RR(X,n);outtextxy( 310 ,60 ,
"ALGORITHM ROUND ROBIN " );
outtextxy( 350 ,75 , "( xoay
vong)" );}
else {
goto label; }
output(G);
giant_output(G);
timeavg=waittimeavg(G,X,n); //Tinh thoi gian cho doi
trung binh cua thuat toan
cout<<"\n\nThoi gian cho doi trung binh= "<<timeavg;
getch();
cleardevice();
goto label;
}
while( !kbhit() );
closegraph( );
return( 0 );
}

b. FCFS
Đối với thuật toán này thứ tự thực hiện ưu tiên theo thời gian xuất hiện.Tiến trình nào
đến trước sẽ thực hiện trước.
Hình 4.2: Sơ đồ khối FCFS.
Code
sodo FCFS(process *a,int &n)
{ sodo G; process *x; int i,j;
x=new process[n];
for(i=0;i<n;i++)
x[i]=a[i];
G.sl=0;
G.ten=new int;
G.moc=new int;
G.moc[0]=0;
j=0,i=0;
cout<<"Ket qua theo thuat toan FCFS\n\n";
while(j<n)
{
G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
G.moc=(int*)realloc(G.moc,(G.sl+2)*sizeof(int));
if(G.moc[i]<x[j].timexh)
{ G.moc[i+1]=x[j].timexh;
G.ten[i]=0;
}

else
{ G.ten[i]=x[j].id;
G.moc[i+1]=G.moc[i]+x[j].timeth;
j++;
}
G.sl++;
i++;
}
return G;
}
c. SJF
Đối với thuật toán này thứ tự thực hiện ưu tiên theo thời gian thực hiện công việc. Tiến
trình nào có thời gian làm việc với CPU nhỏ nhất sẽ ưu tiên thực hiện trước. Trong trường
hợp thời gian làm việc của các tiến trình bằng nhau thì sẽ xử lý theo thuật toán FCFS.
Hình 4.3: Sơ đồ khối SJF
Code
sodo SJF(process *a,int &n) // thuat toan SJF
{ sodo G; process *x,tg; int i,j,k,h;
x=new process[n];
for(i=0;i<n;i++)
x[i]=a[i];
G.sl=0;
G.ten=new int;
G.moc=new int;
G.moc[0]=0;
j=0,i=0;
cout<<"Ket qua theo thuat toan FJS\n\n";
while(j<n) // con tien trinh chua den hoac chua

duoc xu ly
{
for(h=0;h<n;h++)
for(k=h+1;k<n-1;k++)
if(( x[k].timeth>x[k+1].timeth)&&( x[k+1].timexh<G.moc[i]))

{ tg=x[k];
x[k]=x[k+1];
x[k+1]=tg; }
if(G.moc[i]<x[j].timexh) // tien trinh chua den
{ G.moc[i+1]=x[j].timexh; // moc tiep = tg den
G.ten[i]=0; // o trong
}
else
{
G.ten[i]=x[j].id; // ten o la ten cua process
G.moc[i+1]=G.moc[i]+x[j].timeth;
// cap cpu va xac dinh moc cap cpu tiep theo
j++; // danh dau them 1 process da
duoc xu ly
}
G.sl++; // tang so o trong so do Gantt
i++;
}
return G;
}

d. SRT
Trong thuật toán này thứ tự thực hiện sẽ ưu tiên theo theo thời gian thực hiện công việc
còn lại. Tiến trình nào có thời gian thực hiện còn lại nhỏ nhất sẽ thực hiện trước.
Hình 4.4: Sơ đồ khối STR.
Code
sodo SRT(process *x,int &n)
{ sodo G; int i,j,tg; process *a;
a=new process[n];
for(i=0;i<n;i++)
a[i]=x[i];
int *vt;
int *th;
int *cl;
int sopt=0;
int slxh=0;
int *xh;
xh=new int[n];
vt=new int;
th=new int;
cl=new int;
G.ten=new int;
G.moc=new int;
G.sl=0;
G.moc[0]=0;
for(i=0;i<n;i++) xh[i]=0;
cout<<"Ket qua theo thuat toan SRT\n\n";
while(sopt>0 || slxh<n)

{
for(i=0;i<n;i++)
if (a[i].timexh<=G.moc[G.sl] && xh[i]==0)
{ vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
th=(int*)realloc(th,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
th[sopt]=a[i].timeth;
cl[sopt]=a[i].timeth;
sopt++;
slxh++;
xh[i]=1;
}
for(i=0;i<sopt;i++)
for(j=0;j<sopt-1;j++)
if(th[j+1] >= th[j])
{ tg=vt[j]; vt[j]=vt[j+1]; vt[j+1]=tg;
tg=th[j]; th[j]=th[j+1]; th[j+1]=tg;
tg=cl[j]; cl[j]=cl[j+1]; cl[j+1]=tg;
}
if(sopt==0)
{ G.ten[G.sl]=0;
G.moc[G.sl+1]=a[slxh].timexh;
G.sl++ ;
}
else
{ G.ten[G.sl]=vt[sopt-1];
G.moc[G.sl+1]=G.moc[G.sl]+cl[sopt-1];
G.sl++;
for(i=0;i<n;i++)
if (a[i].timexh < G.moc[G.sl] && xh[i]==0 &&
a[i].timeth< th[sopt-1])
{ G.moc[G.sl]=a[i].timexh;
cl[sopt-1]-=G.moc[G.sl]-G.moc[G.sl-1];
break;
}
if(i==n)
sopt--;
}
}
return G;
}
e. RR
Đối với thuật toán này quá trình thực hiện sẽ phân theo lượng tử (quantumn) thời gian
q .Các tiến trình được đưa vào một hàng đợi và chờ được thực hiện. Theo thời gian xuất
hiện, thực hiện của tiến trình với một khoảng thời gian q, nếu tiến trình đó không thực hiện
xong với khoản thời gian q đó sẽ bị đưa xuống cuối hàng đợi.
Trong khi nó đang thực hiện, nếu có tiến trình nào xuất hiện nó sẽ được đưa vào đầu
hàng đợi sau khi thực hiện xong quantumn.

Hình 4.5: Sơ đồ khối RR.
Code
sodo RR(process *x,int &n)
{ sodo G; process *a; int i,j,q;
a=new process[n];
for(i=0;i<n;i++)
a[i]=x[i];
int *xh,sopt=0,slxh=0,*vt,*cl;
xh=new int[n];
vt=new int;
cl=new int;
G.ten=new int;
G.moc=new int;
G.sl=0; G.moc[0]=0;
for(i=0;i<n;i++) xh[i]=0;
cout<<"Luong tu thoi gian q= "; cin>>q;
cout<<"Ket qua theo thuat toan RR\n\n";
for(i=0;i<n;i++)
if(a[i].timexh==G.moc[0] && xh[i]==0)
vt[sopt]=a[i].id;
xh[i]=1; sopt++; slxh++;
}
while(sopt>0 || slxh<n )

{ G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
if(sopt>0)
{ if(cl[sopt-1]<=q)
{ G.moc[G.sl+1]=G.moc[G.sl]+cl[sopt-1];
G.ten[G.sl]=vt[sopt-1];
sopt--;
for(i=0;i<n;i++)
if(a[i].id==G.ten[G.sl])
{ j=i;
break;
}
xh[j]=1;
}
else
{ G.moc[G.sl+1]=G.moc[G.sl]+q;
G.ten[G.sl]=vt[sopt-1];
for(i=sopt-1;i>0;i--)
{ vt[i]=vt[i-1]; cl[i]=cl[i-1];
xh[i]=xh[i-1];
}
vt[0]=G.ten[G.sl];
for(i=0;i<n;i++)
{ j=i; break; }
a[j].timeth-=q;
cl[0]=a[j].timeth;
xh[j]=1;
}
G.sl++;
}
else
{ for(i=0;i<n;i++)
if(xh[i]==0)
{ j=i; break; }
vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
vt[sopt]=a[j].id;
cl[sopt]=a[j].timeth;
G.moc[G.sl+1]=a[j].timexh;
G.ten[G.sl]=0;
slxh++; sopt++;
G.sl++;
continue;
}
for(i=0;i<n;i++)
if(a[i].timexh<=G.moc[G.sl] && xh[i]==0)
vt[sopt]=a[i].id;
sopt++; slxh++; xh[i]=1;
}
}
return G;
}

f. Tính hời gian chờ,lưu lại của các tiến trình và thời gian chờ trung bình
Code
float waittimeavg(sodo &g,process *x,int &n)
{ int *list,*waittime,*timefinish,*timestay;
float waittimeavg;
int i=g.sl-1,j=0,kt,tg;
int totalwaittime=0;
list=new int[n+1];
waittime=new int[n];
timefinish=new int[n];
timestay=new int[n];
while(j<=g.sl+1 && i>=0)

{ int k=0;
while(k<=j && g.ten[i]!=list[k]) k++;
if(k<=j) kt=1;
else kt=0;
if(kt==0)
{ timefinish[j]=g.moc[i+1];
j++;
list[j]=g.ten[i];
}
i--;
}
for(i=0;i<n;i++)
for(j=1;j<=n;j++)
if(list[j]==x[i].id)
{tg=timefinish[i]; timefinish[i]=timefinish[j-1];
timefinish[j-1]=tg;
tg=list[i+1]; list[i+1]=list[j]; list[j]=tg;
}
for(i=0;i<n;i++)
{ waittime[i]=timefinish[i]-(x[i].timexh+x[i].timeth);
totalwaittime+=waittime[i];
timestay[i]=timefinish[i]-x[i].timexh;
}
waittimeavg=(float)totalwaittime/n;
// ve chi tiet
{
char as[30];
setcolor(YELLOW);
setbkcolor(0);
rectangle(10+300,100,300+480,125);
outtextxy(120+400,105,"CHI TIET");
rectangle(10+300,125,300+480,150+20*n);
outtextxy(20+300,130,"TenTT");
outtextxy(100+310,130,"TimeHT");
outtextxy(200+330,130,"TimeCho");
outtextxy(350+300,130,"TimeLuu");
for(int i=0;i<n;i++)
{
sprintf(as,"P%d",x[i].id);
outtextxy(250+100,150+20*i,as);
sprintf(as,"%d",timefinish[i]);
outtextxy(350+100,150+20*i,as);
sprintf(as,"%d",waittime[i]);
outtextxy(480+100,150+20*i,as);

sprintf(as,"%d",timestay[i]);
outtextxy(500+200,150+20*i,as);
}
}
g. Vẽ sơ đồ Grant
code
void giant_output(sodo &G)
{
int ax,ay,bx,by,rong=40; //Toa do cac o

vuong can ve
int d=0,i=0,j=0,k=0,h=0; //d:So o
can ve; i:Ve o theo hang; j:Xuong dong moi khi het hang
char as[30];
char bs[30];
setbkcolor(BLUE);
line(10,430,700,430);
line(700-5,430-3,700,430);
line(700-5,430+3,700,430);
outtextxy(700-4,440,"t");
for(i=0;i<=G.sl;i++)
{
setbkcolor(13);
outtextxy(48,400,"CPU ");
setbkcolor(5);
if(i!=G.sl)
{
sprintf(bs,"%d",G.moc[i]);
sprintf(as,"P%d ",G.ten[i]);
setbkcolor(G.ten[i]);
if(G.ten[i]!=0) outtextxy(107+60*h,400+60*k,as);
else { settextjustify(1,2);
setbkcolor(13);
outtextxy(107+60*h,400+60*k,"CPU ");
}
setbkcolor(BLUE);
outtextxy(82+60*h,420+60*k,bs);
if(j%7==1&&j!=1&&i<G.sl-1){
k++;h=-1;j=0;
line(10,440+60*k,700,440+60*k);// ve
mui ten cho so do giant
line(700-5,440+60*k-3,700,440+60*k);
line(700-5,440+60*k+3,700,440+60*k);
outtextxy(700-4,450+60*k,"t");

}
h++;
delay(1000);
}
j++;
if(i==G.sl) { settextjustify(1,2);
setbkcolor(13);
outtextxy(108+60*h,461+60*(k-1),"CPU
");
setbkcolor(BLUE);
}
}

V. CHẠY THỬ CHƯƠNG TRÌNH

a. Giao diện ban đầu
Hình 5.1: Giao diện ban đầu.
d. Thuật toán FCFS
Hình 5.2: Chạy thuật toán FCFS.

e. Thuật toán SJF
Hình 5.3: Chạy thuật toán SJF.
f. Thuật toán SRT(thời gian chờ trung bình thấp nhất)
Hình 5.4: Chạy thuật toán SRT.

g. Thuật toán Round Robin (thời gian chờ trung bình cao nhất)
Hình 5.5: Chạy thuật toán RR.

VI. KẾT LUẬN

Trong thời gian thực hiện đề tài em đã hiểu hơn về cơ chế và cách thức làm việc của hệ
điều hành đồng thời có thêm về kinh nghiệm lập trình cấu trúc và đồ họa trong C++ .
Trong quá trình thực hiện em xin chân thành cảm ơn sự chỉ dạy của cô Trần Hồ Thuỷ
Tiên. Dù đã cố gắng hết mình nhưng bài làm không thể tránh khỏi thiếu sót, em mong
nhận được sự cảm thông và góp ý của quý thầy cô và các bạn.

VII.TÀI LIỆU
[1] Vũ Lê Hùng, Giáo Trình Nguyên Lý Hệ Điều Hành, Đại học Bách Khoa Hồ Chí
Minh
[2] Lê Trung Dũng, Giáo Trình Hệ Điều Hành, Nhà xuất bản Giáo Dục
[3] Trần Hồ Thủy Tiên.Giáo Tìình Nguyên Lý Hệ Điều Hành.Đại học Đà Nẵng,
Trường đại học Bách Khoa, Khoa Công Nghệ Thông Tin 01/04/2010.
[4] http://cnx.org/content/m29955/latest/

VIII. PHỤ LỤC
Code của file LAPLICH.cpp trong project LapLichCPU.dev (loại Project là

WinBGIm )
#include <graphics.h>
#include<stdio.h>
#include<conio.h>
#include <iostream.h>
#include<stdlib.h>
#include<alloc.h>
#include<string.h>
#include<windows.h>
using namespace std;
void clrscr(void) // ham xoa man hinh

{
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
HANDLE hConsoleOut;
COORD Home = {0,0};
DWORD dummy;
hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(hConsoleOut,&csbiInfo);
FillConsoleOutputCharacter(hConsoleOut,' ',csbiInfo.dwSize.X *
csbiInfo.dwSize.Y,Home,&dummy);
csbiInfo.dwCursorPosition.X = 0;
csbiInfo.dwCursorPosition.Y = 0;
SetConsoleCursorPosition(hConsoleOut,csbiInfo.dwCursorPosition);
}
void gotoxy(short x,short y) // ham goto xy
{
HANDLE hConsoleOutput;
COORD Cursor_an_Pos = { x,y};
hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(hConsoleOutput , Cursor_an_Pos);
}
struct sodo // cau truc du lieu bieu dien o cua so do Gantt
{ int *ten; // ten cua so do trung voi ten cua tien trinh
int *moc; // moc thoi gian cap cpu cho tien trinh
int sl; // tong so luong cac o trong so do Gantt
};
struct process // cau truc du lieu cua tien trinh
{ int id; // ma cua trinh. ta ko dung ten tien t
int timexh; // thoi gian den cua tien trinh
int timeth; // thoi gian xu ly cua tien trinh
};
process* input(int &n)
{ int i,j;
process *a,tg;

a=new process[n]; // cap phat bo nho cho 1 danh sach don gom n tien
trinh
gotoxy(8,1);cout<<"Ten TT";
gotoxy(18,1);cout<<"Time XH";
gotoxy(28,1); cout<<"Time XL";
for(i=0;i<n;i++)
{
gotoxy(10,i+2);
cout<<"P"<<i;
a[i].id=i+1;
label:
gotoxy(20,i+2);
cin>>a[i].timexh; // nhap thoi gian den cho tien tinh
if(a[i].timexh<0)
{gotoxy(0,10);
printf("thoi gian den phai > hoac =0 , moi ban nhap lai ");
goto label; }
label1:
gotoxy(30,i+2);
cin>>a[i].timeth; // nhap thoi gian xu ly cho tien trinh
if(a[i].timeth<=0)
{gotoxy(0,11);
printf("thoi gian xu ly phai > 0 , moi ban nhap lai ");
goto label1; }
}
for(i=0;i<n;i++)
for(j=0;j<n-1;j++)
if( a[j].timexh>a[j+1].timexh) // sap xep cac tien trinh theo thoi
{ tg=a[j]; a[j]=a[j+1];a[j+1]=tg; }; // gian den tang dan
return a; // tra ve danh sach a gom n tien trinh
} // da duoc sap xep theo tg den
void output(sodo &G) // xuat so do Gantt tren che do van ban cua Dev c++
{ int i=0,j=0;
{ cout<<G.moc[i]<<" "; // xuat moc thoi gian
if(i!=G.sl)
if(G.ten[i]!=0)
cout<<"P"<<G.ten[i]<<" "; // xuat ten tien trinh
j++;
if(j==9) { cout<<"\n"; j=0;} // xuong hang khi xuat duoc 9 o
}
}
void debai(process *A,int &n) // xuat de bai tren che do do hoa
{ gotoxy(57,1);cout<<"TenTT";
gotoxy(65,1);cout<<"TimeXH";
gotoxy(73,1); cout<<"TimeXL";
{ gotoxy(57,i+2);
cout<<" ";
gotoxy(60,i+2);

cout<<"P"<<A[i].id;
gotoxy(68,i+2);
cout<<A[i].timexh;
gotoxy(76,i+2);
cout<<A[i].timeth;
}
}
sodo FCFS(process *a,int &n) // thuat toan fcfs
{ sodo G; process *x; int i,j;
x=new process[n]; // cap phat danh sach x gom n process
for(i=0;i<n;i++)
x[i]=a[i]; // gan danh sach x bang danh sach a
G.sl=0; // so luong o trong so do Grantt ban dau la 0
G.ten=new int;
G.moc=new int;
G.moc[0]=0; // khoi tao moc thoi gian ban dau la 0
j=0,i=0; // j dung dem so tien trinh i dung xac dinh moc dang xet
cout<<"Ket qua theo thuat toan FCFS\n\n";
while(j<n) // khi con tien trinh chua den hoac chua duoc xu ly
{
G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int)); // cap phat lai bo nho
if(G.moc[i]<x[j].timexh) // neu process chua den tra cpu ve cho hdh
{ G.moc[i+1]=x[j].timexh; // moc cap cpu tiep theo la khi process tiep
theo den
G.ten[i]=0; // ten cua so do = 0 o trong sd Grantt la o trong
}
else // process da den
{
G.ten[i]=x[j].id; // ten trong so do Gantt la ten cua process
G.moc[i+1]=G.moc[i]+x[j].timeth; // cap phat cpu va xac dinh moc
cap cpu tiep theo
// = moc hien tai + thoi gian xu ly cua tt
j++; // danh dau tt da xu ly
}
G.sl++; // tang so luong o trong so do Grantt
i++;
}
return G;
}
sodo SJF(process *a,int &n) // thuat toan SJF
{ sodo G; process *x,tg; int i,j,k,h;
x=new process[n];
for(i=0;i<n;i++)
x[i]=a[i];
G.sl=0;
G.ten=new int;
G.moc=new int;
G.moc[0]=0;
j=0,i=0;

cout<<"Ket qua theo thuat toan FJS\n\n";

while(j<n) // con tien trinh chua den hoac chua duoc xu ly
{
for(h=0;h<n;h++)
for(k=h+1;k<n-1;k++)
if(( x[k].timeth>x[k+1].timeth)&&( x[k+1].timexh<G.moc[i]))
{ tg=x[k]; // neu tien trinh da den va co thoi gian xu ly nho hon
x[k]=x[k+1]; // dua len dau danh sach san sang
x[k+1]=tg; }
if(G.moc[i]<x[j].timexh) // tien trinh chua den
{ G.moc[i+1]=x[j].timexh; // moc tiep = tg den cua process
G.ten[i]=0; // o trong so do Gantt la o trong
}
else
{
G.ten[i]=x[j].id; // ten trong so do Gantt la ten cua process
G.moc[i+1]=G.moc[i]+x[j].timeth; // cap cpu va xac dinh moc hien tai
+ tg thuc hien cua tt
j++; // danh dau them 1 process da duoc xu ly
}
i++;
}
return G;
}
sodo SRT(process *x,int &n) // thuat toan SRT

{ sodo G; int i,j,tg; process *a;
a=new process[n];
for(i=0;i<n;i++)
a[i]=x[i];
int *vt; // vi process co the bi ngat tra cpu cho tien trinh khac
// nen ta dung them vt de danh dau cac vi tri
cua tien trinh
int *th; // thoi gian xu ly cua tien trinh
int *cl; // thoi gian xu ly con lai cua tien trinh
int sopt=0; // so process trong danh sach san sang
int slxh=0; // so luong tien trinh da den
int *xh; // danh dau process da xu ly chua
xh=new int[n];
vt=new int;
th=new int;
cl=new int;
G.ten=new int;
G.moc=new int;
G.sl=0; // so luong o trong so do Gantt ban dau =0
G.moc[0]=0; // moc cap cpu dau tien bang 0
for(i=0;i<n;i++) xh[i]=0; // cac tien trinh deu o trang thai chua duoc xu ly
cout<<"Ket qua theo thuat toan SRT\n\n";

while(sopt>0 || slxh<n) // danh sach san sang con process hoac con process
chua den
{
G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int)); // cap phat bo nho lai
for(i=0;i<n;i++)
if (a[i].timexh<=G.moc[G.sl] && xh[i]==0) // process da den va chua
duoc xu ly
th=(int*)realloc(th,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
th[sopt]=a[i].timeth;
sopt++; // tang so tien trinh trong danh sach san sang
slxh++; // tang so tien trinh da den
xh[i]=1; // danh dau tien trinh duoc xu ly
}
for(i=0;i<sopt;i++)
for(j=0;j<sopt-1;j++)
if(th[j+1] >= th[j]) // sap xep lai cac tien trinh trong ds san
sang
{ // theo thoi gian thuc hien ngan hon
tg=vt[j]; vt[j]=vt[j+1]; vt[j+1]=tg;
tg=th[j]; th[j]=th[j+1]; th[j+1]=tg;
tg=cl[j]; cl[j]=cl[j+1]; cl[j+1]=tg;
}
if(sopt==0) // danh sach san sang trong
{ G.ten[G.sl]=0; // tao o trong trong so do Gantt
G.moc[G.sl+1]=a[slxh].timexh; // moc tiep theo = thoi gian den cua
tien trinh tiep theo
G.sl++ ; // tang so o cua so do Gantt len
}
else // danh sach san sang co tien trinh
{ G.ten[G.sl]=vt[sopt-1]; // ten trong so do Gantt la ten cua tien trinh
dau ds san sang
G.moc[G.sl+1]=G.moc[G.sl]+cl[sopt-1]; // moc tiep theo = moc hien tai
+ thoi gian con lai cua process
G.sl++; // tang so luong o trong so do Grantt
for(i=0;i<n;i++) // neu co tien trinh den ma thoi gian thuc
hien nho hon thoi gian
if (a[i].timexh < G.moc[G.sl] && xh[i]==0 && a[i].timeth< th[sopt-1])
// thuc hien con lai cua process
{ G.moc[G.sl]=a[i].timexh; //dinh lai moc thoi gian cap
cpu = thoi gian den cua process do
cl[sopt-1]-=G.moc[G.sl]-G.moc[G.sl-1]; // dinh thoi gian con lai
cho tien trinh vua bi xen ngang
break; //-= moc hien tai - moc truoc do
}
if(i==n) // neu tat ca cac process dc xu li

sopt--; // thi giam so tien trinh trong ready-list

}
}
return G; // tra ve so do Gantt
}
sodo RR(process *x,int &n)

{ sodo G; process *a; int i,j,q;
a=new process[n];
for(i=0;i<n;i++)
a[i]=x[i];
int *xh,sopt=0,slxh=0,*vt,*cl;
xh=new int[n]; // danh dau process da xu ly chua
vt=new int; // dung vt[i] de thay cho ten cua tien trinh thu i
cl=new int; // dinh thoi gian xu ly con lai cua process
G.ten=new int;
G.moc=new int;
G.sl=0; G.moc[0]=0; // khoi tao so luong o=0 trong so do Gantt va moc
dau tien =0
for(i=0;i<n;i++) xh[i]=0; // cac tien trinh deu o trang thai chua duoc xu ly
cout<<"Luong tu thoi gian q= "; cin>>q; // nhap quantumn
cout<<"Ket qua theo thuat toan RR\n\n";
for(i=0;i<n;i++)
if(a[i].timexh==G.moc[0] && xh[i]==0) // neu co process co thoi gian den
=0
vt[sopt]=a[i].id;
cl[sopt]=a[i].timeth; // dinh thoi gian con lai = thoi gian thuc hien
xh[i]=1; sopt++; slxh++; // danh dau process o trang thai da qua xu ly
}
while(sopt>0 || slxh<n ) // danh sach san sang con process hoac con process
chua den
{ G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
if(sopt>0) // danh sach san sang co tien trinh

{ if(cl[sopt-1]<=q) // neu thoi gian con lai cua tien trinh <= quantumn
{ G.moc[G.sl+1]=G.moc[G.sl]+cl[sopt-1]; // moc cap cpu tiep theo= moc
hien tai
// +
thoi gian con lai cua process
G.ten[G.sl]=vt[sopt-1]; // ten trong o cua so do Gantt la ten cua
process
sopt--; // loai tien trinh ra khoi danh sach san sang
for(i=0;i<n;i++)
{ j=i; // tim tien trinh j de danh dau
break;
}

xh[j]=1; // danh dau tien trinh thu j da xuat hien

}
else // thoi gian con lai cua tien trinh lon hon quantumn
{ G.moc[G.sl+1]=G.moc[G.sl]+q; // moc cap cpu tiep theo = moc hien
tai + quantumn
G.ten[G.sl]=vt[sopt-1]; // ten trong o cua so do Gantt la ten cua
process
for(i=sopt-1;i>0;i--) // dua process ve cuoi ready_list
{ vt[i]=vt[i-1];
cl[i]=cl[i-1];
xh[i]=xh[i-1];
}
vt[0]=G.ten[G.sl]; // hoan thanh dua tien trinh ve cuoi ready_list
for(i=0;i<n;i++)
{ j=i; break; } // xac dinh tien trinh j
a[j].timeth-=q; // dinh lai thoi gian xy ly cho process j
cl[0]=a[j].timeth; // dinh thoi gian con lai cho process j
xh[j]=1; // danh dau da qua xu ly
}
G.sl++; // tang so luong o so do Gantt len
}
else // danh sach san sang rong
{ for(i=0;i<n;i++)
if(xh[i]==0) // neu cac process chua qua xu ly
{ j=i; break; }
vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
vt[sopt]=a[j].id;
cl[sopt]=a[j].timeth; // dinh thoi gian con lai = thoi gian thuc hien
G.moc[G.sl+1]=a[j].timexh; // moc cap cpu tiep theo= thoi gian den
cua Process dau readylist
G.ten[G.sl]=0; // o trong so do Gantt la o trong
slxh++; sopt++; // tang so process da den ,tang so process
trong readylist
continue;
}
for(i=0;i<n;i++)
if(a[i].timexh<=G.moc[G.sl] && xh[i]==0) // neu co process co thoi gian
den < moc hien tai
vt[sopt]=a[i].id;
cl[sopt]=a[i].timeth; // dinh thoi gian con lai = thoi gian thuc hien
sopt++; slxh++; xh[i]=1; // tang so process da den ,tang so process
trong readylist
} // danh dau process o trang thai da qua xu ly
}
return G; // tra ve so do Gantt
}

float waittimeavg(sodo &g,process *x,int &n) // tinh thoi gian cho trung
binh
{ int *list,*waittime,*timefinish,*timestay;
float waittimeavg; // thoi gian cho trung binh
int i=g.sl-1,j=0,kt,tg; // i= so luong o -1 ,j dem so luong o cua g
int totalwaittime=0; // tong thoi gian cho
list=new int[n+1]; //danh sach chua cac tien trinh da tim duoc thoi gian
ket thuc
waittime=new int[n]; //danh sach thoi gian cho cua cac tien trinh
timefinish=new int[n]; //danh sach thoi gian hoan thanh cua cac tien trinh
timestay=new int[n]; //danh sach thoi gian luu lai cua cac tien trinh
while(j<=g.sl+1 && i>=0) // chua het o trong so do Grantt va so luong o

chua thong tin ve tien trinh >=0
{ int k=0;
while(k<=j && g.ten[i]!=list[k]) k++; //kiem tra tien trinh da co trong
danh sach tim duoc thoi gian hoan thanh chua
if(k<=j) kt=1;
else kt=0;
if(kt==0) // neu chua co trong danh sach thi dua vao danh sach
{ timefinish[j]=g.moc[i+1]; // dinh thoi gian hoan thanh = moc sau no
j++;
list[j]=g.ten[i]; // danh dau phan tu thu j trong danh sach = ten cua o
trong so do Grant
}
i--;
}
for(i=0;i<n;i++)
for(j=1;j<=n;j++)
if(list[j]==x[i].id) // danh dau phan tu thu j trong danh sach = ten cua
process
{tg=timefinish[i]; timefinish[i]=timefinish[j-1]; timefinish[j-1]=tg;
tg=list[i+1]; list[i+1]=list[j]; list[j]=tg;
} // sap xep thoi gian hoan thanh theo thu tu process vi du het p1->p2
for(i=0;i<n;i++)
{ waittime[i]=timefinish[i]-(x[i].timexh+x[i].timeth);
totalwaittime+=waittime[i];
timestay[i]=timefinish[i]-x[i].timexh;
}
waittimeavg=(float)totalwaittime/n;
char ab[30];
// ve chi tiet
{
char as[30];
setcolor(YELLOW);
setbkcolor(0);
rectangle(10+300,100,300+480,125);
outtextxy(120+400,105,"CHI TIET");

rectangle(10+300,125,300+480,150+20*n);
sprintf(ab,"Thoi gian cho trung binh la: %f s",waittimeavg);

outtextxy(100,170+20*n,ab);
outtextxy(20+300,130,"TenTT");
outtextxy(100+310,130,"TimeHT");
outtextxy(200+330,130,"TimeCho");
outtextxy(350+300,130,"TimeLuu");
{
sprintf(as,"P%d",x[i].id);
outtextxy(250+100,150+20*i,as);
sprintf(as,"%d",timefinish[i]);
outtextxy(350+100,150+20*i,as);
sprintf(as,"%d",waittime[i]);
outtextxy(480+100,150+20*i,as);
sprintf(as,"%d",timestay[i]);
outtextxy(500+200,150+20*i,as);
}
}
//ve chi tiet xong
return waittimeavg;
}
void ve_debai(process *A,int &n)
{
char as[30];
setcolor(YELLOW);
rectangle(10,100,300,125);
outtextxy(120,105,"DE BAI");
rectangle(10,125,300,150+20*n);
outtextxy(20,130,"TenTT");
outtextxy(100,130,"TimeXH");
outtextxy(200,130,"TimeXL");
{
sprintf(as,"P%d",A[i].id);
outtextxy(70,150+20*i,as);
sprintf(as,"%d",A[i].timexh);
sprintf(as,"%d",A[i].timeth);
}
}
void giant_output(sodo &G)

{
int ax,ay,bx,by,rong=40; //Toa do cac o vuong can ve

int d=0,i=0,j=0,k=0,h=0; //d:So o can ve; i:Ve o theo hang;

j:Xuong dong moi khi het hang

char as[30];
char bs[30];
setbkcolor(BLUE);
line(10,430,700,430);
line(700-5,430-3,700,430);
line(700-5,430+3,700,430);
outtextxy(700-4,440,"t");
{
setbkcolor(13);
outtextxy(48,400,"CPU ");
setbkcolor(5);
if(i!=G.sl)
{
sprintf(as,"P%d ",G.ten[i]);
setbkcolor(G.ten[i]);
if(G.ten[i]!=0) outtextxy(107+60*h,400+60*k,as);
else { settextjustify(1,2);
setbkcolor(13);
outtextxy(107+60*h,400+60*k,"CPU ");
}
setbkcolor(BLUE);
if(j%7==1&&j!=1&&i<G.sl-1){
k++;h=-1;j=0;
line(10,440+60*k,700,440+60*k);// ve mui ten cho so do giant
line(700-5,440+60*k-3,700,440+60*k);
line(700-5,440+60*k+3,700,440+60*k);
outtextxy(700-4,450+60*k,"t");
}
h++;
delay(1000);
}
j++;
if(i==G.sl) { settextjustify(1,2);

setbkcolor(13);
outtextxy(108+60*h,461+60*(k-1),"CPU ");
setbkcolor(BLUE);
}
}
int main( )
{
initwindow( 800 , 600 , "LAP LICH CPU" );
outtextxy( 380 ,30 , "CHUONG TRINH LAP LICH CHO CPU!" );
outtextxy( 380 ,595 , "Svth: Nguyen Huu Thien" );
outstreamxy( 0 , 15 );
char k; int n;
process *X; sodo G;
do
{ do{ clrscr();
cout<<"\tSo luong tien trinh: "; cin>>n;
}while(n<=0||n>15);
X=new process[n];
clrscr();
X=input(n); // Tien hanh nhap du lieu cho mang tien trinh
label:
clrscr();
debai(X,n);
ve_debai(X,n);
gotoxy(1,1);
cout<<"\n\tChon thuat toan";
cout<<"\n\t1. Thuat toan FCFS";
cout<<"\n\t2. Thuat toan SJF";
cout<<"\n\t3. Thuat toan SRT";
cout<<"\n\t4. Thuat toan RR";
cout<<"\n\t5. Nhap lai ";
cout<<"\n\t6. Thoat chuong trinh";
cout<<"\n\t Ban chon: ";
cin>>k;
}while(k=='5');
if(k=='6') exit(0);
if(k!=5)
{
float timeavg;
if(k=='1') {G=FCFS(X,n) ; outtextxy( 310 ,60 , "ALGORITHM FIRST
COME FIRST SERVICE" );
outtextxy( 350 ,75 , "( den truoc phuc vu truoc)" );}

else if(k=='2') {G=SJF(X,n);outtextxy( 310 ,60 , "ALGORITHM

SHORTEST JOB FIRST" );
outtextxy( 350 ,75 , "( cong viec ngan nhat )" );}
else if(k=='3') {G=SRT(X,n);outtextxy( 310 ,60 , "ALGORITHM
SHORTEST REMAINING TIME" );
outtextxy( 350 ,75 , "(theo do uu tien)" );}
else if(k=='4') {G=RR(X,n);outtextxy( 310 ,60 , "ALGORITHM
ROUND ROBIN " );
outtextxy( 350 ,75 , "( xoay vong)" );}
else {
goto label; }
output(G);
giant_output(G);
timeavg=waittimeavg(G,X,n); //Tinh thoi gian cho doi trung binh cua
thuat toan
cout<<"\n\nThoi gian cho doi trung binh= "<<timeavg;
getch();
cleardevice();
goto label;
}
while( !kbhit() );
closegraph( );
return( 0 );
}

(123doc) Xay Dung Chuong Trinh Mo Phong Cac Giai Thuat Dinh Thoi Cho Cpu

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

(123doc) Xay Dung Chuong Trinh Mo Phong Cac Giai Thuat Dinh Thoi Cho Cpu

Uploaded by

Copyright:

Available Formats

LỜI NÓI ĐẦU

GVHD: Trần Hồ Thuỷ Tiên Page 2

I. GIỚI THIỆU ĐỀ TÀI

GVHD: Trần Hồ Thuỷ Tiên Page 3

GVHD: Trần Hồ Thuỷ Tiên Page 4

Các danh sách điều phối

GVHD: Trần Hồ Thuỷ Tiên Page 5

Sơ đồ chuyển đổi giữa các danh sách điều phối

GVHD: Trần Hồ Thuỷ Tiên Page 6

III. CÁC GIẢI THUẬT ĐỊNH THỜI CHO CPU

Hình 3.1: Chiến lược FIFO.

Tiến trình Thời điểm vào Thời gian xử lý

Giản đồ Gantt cho việc định thời là:

Hình 3.2: Giản đồ Gantt cho việc định thời.

GVHD: Trần Hồ Thuỷ Tiên Page 7

GVHD: Trần Hồ Thuỷ Tiên Page 8

GVHD: Trần Hồ Thuỷ Tiên Page 9

c. Chiến lược công việc ngắn nhất trước (Shortest-job-first)

GVHD: Trần Hồ Thuỷ Tiên Page 10

Hình 3.3: Chiến lược RR.

Hình 2.10 Điều phối Round Robin

GVHD: Trần Hồ Thuỷ Tiên Page 11

GVHD: Trần Hồ Thuỷ Tiên Page 12

IV. THIẾT KẾ HỆ THỐNG

1. Cấu trúc dữ liệu

- Ten[] : tên các tiến trình

Thì đầu ra cần có G.ten[1]=1,G.ten[2]=2,G.ten[3]=3

GVHD: Trần Hồ Thuỷ Tiên Page 13

Hình 4.1: Sơ đồ khối hàm main().

GVHD: Trần Hồ Thuỷ Tiên Page 14

cout<<"\n\t3. Thuat toan SRT";

GVHD: Trần Hồ Thuỷ Tiên Page 15

Hình 4.2: Sơ đồ khối FCFS.

GVHD: Trần Hồ Thuỷ Tiên Page 16

Hình 4.3: Sơ đồ khối SJF

GVHD: Trần Hồ Thuỷ Tiên Page 17

if(( x[k].timeth>x[k+1].timeth)&&( x[k+1].timexh<G.moc[i]))

GVHD: Trần Hồ Thuỷ Tiên Page 18

Hình 4.4: Sơ đồ khối STR.

GVHD: Trần Hồ Thuỷ Tiên Page 19

GVHD: Trần Hồ Thuỷ Tiên Page 20

Hình 4.5: Sơ đồ khối RR.

GVHD: Trần Hồ Thuỷ Tiên Page 21

GVHD: Trần Hồ Thuỷ Tiên Page 22

while(j<=g.sl+1 && i>=0)

GVHD: Trần Hồ Thuỷ Tiên Page 23

int ax,ay,bx,by,rong=40; //Toa do cac o

GVHD: Trần Hồ Thuỷ Tiên Page 24

GVHD: Trần Hồ Thuỷ Tiên Page 25

V. CHẠY THỬ CHƯƠNG TRÌNH

Hình 5.1: Giao diện ban đầu.

d. Thuật toán FCFS

Hình 5.2: Chạy thuật toán FCFS.

GVHD: Trần Hồ Thuỷ Tiên Page 26

e. Thuật toán SJF

Hình 5.3: Chạy thuật toán SJF.

f. Thuật toán SRT(thời gian chờ trung bình thấp nhất)

Hình 5.4: Chạy thuật toán SRT.

GVHD: Trần Hồ Thuỷ Tiên Page 27

Hình 5.5: Chạy thuật toán RR.

GVHD: Trần Hồ Thuỷ Tiên Page 28

VI. KẾT LUẬN

GVHD: Trần Hồ Thuỷ Tiên Page 29