Xây dựng chương trình mô phỏng các giải thuật định thời cho CPU
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (757.63 KB, 46 trang )
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
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
GVHD: Trần Hồ Thuỷ Tiên
Page 2
Mô phỏng các giải thuật lập lịch cho CPU
GVHD: Trần Hồ Thuỷ Tiên
Page 3
Mô phỏng các giải thuật lập lịch cho CPU
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.
GVHD: Trần Hồ Thuỷ Tiên
Page 4
Mô phỏng các giải thuật lập lịch cho CPU
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.
GVHD: Trần Hồ Thuỷ Tiên
Page 5
Mô phỏng các giải thuật lập lịch cho CPU
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.
GVHD: Trần Hồ Thuỷ Tiên
Page 6
Mô phỏng các giải thuật lập lịch cho CPU
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
P1
P2
P3
Thời điểm vào
0
1
2
Thời gian xử lý
24
3
3
Thì thứ tự cấp processor cho các tiến trình diễn ra như sau:
Tiến trình:
Thời điểm:
P1
0
P2
24
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
GVHD: Trần Hồ Thuỷ Tiên
Page 7
P3
27
Mô phỏng các giải thuật lập lịch cho CPU
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
P1
P2
P3
Độ ưu tiên
3
1
2
Thời gian xử lý
24
3
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
GVHD: Trần Hồ Thuỷ Tiên
Page 8
Mô phỏng các giải thuật lập lịch cho CPU
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
P1
0.0
7
P2
2.0
4
P3
4.0
1
P4
5.0
4
(ms)
- 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ế
GVHD: Trần Hồ Thuỷ Tiên
Page 9
Mô phỏng các giải thuật lập lịch cho CPU
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
trình
P1
P2
P3
P4
Thời gian xử
lý
6
8
4
2
0
1
2
3
Sử dụng thuật giải SJF độc quyền, thứ tự cấp phát CPU như sau:
P1
0
P4
6
P3
8
P2
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
0
P4
3
P1
5
P3
8
P2
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
GVHD: Trần Hồ Thuỷ Tiên
Page 10
Mô phỏng các giải thuật lập lịch cho CPU
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
trình
P1
P2
P3
Thời điểm vào
RL
0
1
2
Thời gian xử
lý
24
3
3
Nếu sử dụng quantum là 4 milisecondes, thứ tự cấp phát CPU sẽ là
P1
0
P2
‘4
P3
7
P1
10
P1
14
P1
18
P1
22
P1
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.
GVHD: Trần Hồ Thuỷ Tiên
Page 11
Mô phỏng các giải thuật lập lịch cho 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()
GVHD: Trần Hồ Thuỷ Tiên
Page 12
Mô phỏng các giải thuật lập lịch cho CPU
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";
GVHD: Trần Hồ Thuỷ Tiên
Page 13
Mô phỏng các giải thuật lập lịch cho CPU
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= "<
cleardevice();
goto label;
}
while( !kbhit() );
closegraph( );
return( 0 );
}
GVHD: Trần Hồ Thuỷ Tiên
Page 14
Mô phỏng các giải thuật lập lịch cho CPU
GVHD: Trần Hồ Thuỷ Tiên
Page 15
Mô phỏng các giải thuật lập lịch cho CPU
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
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
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]
G.ten[i]=0;
GVHD: Trần Hồ Thuỷ Tiên
Page 16
Mô phỏng các giải thuật lập lịch cho CPU
}
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)
{ sodo G; process *x,tg; int i,j,k,h;
x=new process[n];
for(i=0;i
G.sl=0;
G.ten=new int;
G.moc=new int;
G.moc[0]=0;
j=0,i=0;
GVHD: Trần Hồ Thuỷ Tiên
Page 17
// thuat toan SJF
Mô phỏng các giải thuật lập lịch cho CPU
cout<<"Ket qua theo thuat toan FJS\n\n";
while(j
duoc xu ly
{
for(h=0;h
x[k]=x[k+1];
x[k+1]=tg; }
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]
{ 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;
}
GVHD: Trần Hồ Thuỷ Tiên
Page 18
Mô phỏng các giải thuật lập lịch cho CPU
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
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
while(sopt>0 || slxh
GVHD: Trần Hồ Thuỷ Tiên
Page 19
Mô phỏng các giải thuật lập lịch cho CPU
{
G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
G.moc=(int*)realloc(G.moc,(G.sl+2)*sizeof(int));
for(i=0;i
{ 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
{ 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
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.
GVHD: Trần Hồ Thuỷ Tiên
Page 20
Mô phỏng các giải thuật lập lịch cho CPU
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
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
cout<<"Ket qua theo thuat toan RR\n\n";
for(i=0;i
{ vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
cl[sopt]=a[i].timeth;
xh[i]=1; sopt++; slxh++;
}
GVHD: Trần Hồ Thuỷ Tiên
Page 21
Mô phỏng các giải thuật lập lịch cho CPU
while(sopt>0 || slxh
G.moc=(int*)realloc(G.moc,(G.sl+2)*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
{ 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
{ j=i; break; }
a[j].timeth-=q;
cl[0]=a[j].timeth;
xh[j]=1;
}
G.sl++;
}
else
{ for(i=0;i
{ j=i; break; }
vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(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
{ vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
cl[sopt]=a[i].timeth;
sopt++; slxh++; xh[i]=1;
}
}
return G;
}
GVHD: Trần Hồ Thuỷ Tiên
Page 22
Mô phỏng các giải thuật lập lịch cho CPU
GVHD: Trần Hồ Thuỷ Tiên
Page 23
Mô phỏng các giải thuật lập lịch cho CPU
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
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
totalwaittime+=waittime[i];
timestay[i]=timefinish[i]-x[i].timexh;
}
waittimeavg=(float)totalwaittime/n;
// ve chi tiet
{
char as[30];
setcolor(YELLOW);
setbkcolor(0);
settextstyle(0,0,2);
settextjustify(0,2);
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
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);
GVHD: Trần Hồ Thuỷ Tiên
Page 24
Mô phỏng các giải thuật lập lịch cho CPU
}
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];
settextjustify(1,1);
setbkcolor(BLUE);
settextstyle(0,0,1);
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++)
{
settextjustify(1,2);
settextstyle(0,0,2);
setbkcolor(13);
outtextxy(48,400,"CPU ");
setbkcolor(5);
settextjustify(1,2);
settextstyle(0,0,2);
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);
settextstyle(0,0,2);
setbkcolor(13);
outtextxy(107+60*h,400+60*k,"CPU ");
}
settextjustify(1,1);
setbkcolor(BLUE);
settextstyle(0,0,1);
outtextxy(82+60*h,420+60*k,bs);
if(j%7==1&&j!=1&&i
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");
GVHD: Trần Hồ Thuỷ Tiên
Page 25
