Khái niệm hệ điều hành pptx

HỆ ĐIỀU HÀNH
Mở đầu.
I. Hệ điều hành là gì ?
- Là các chương trình giúp người sử dụng giao tiếp dễ dàng với máy.
- Quản lý các tài nguyên của máy tính để nạp và thực thi chương trình để đạt hiệu
quả cao nhất.
II. Các chức năng:
- Quản lý các tiến trình (process)
+ Điều phối CPU : First in first out , Shortest Job First, quay vòng Round Robin.
+ Critical Section (viết tắt : CS, miền găng): đưa ra giải thuật bảo đảm để ở một
thời điểm chỉ có duy nhất một tiến trình thực thi miền găng.
+ Đồng bộ hóa các tiến trình: buộc tiến trình phải thực hiện theo một trình tự nào
đó. (Semaphore)
+ Dead lock : loại trừ, tránh, phát hiện và giải quyết.
- Quản lý vùng nhớ :
+ Phân chia bộ nhớ cho các tiến trình (phân vùng cố định, phân vùng liên tục, phân
trang, phân đọan, kết hợp phân trang và phân đoạn )
+ Định vị địa chỉ
+ Bộ nhớ ảo – Chiến lược chọn trang thay thế
- Quản lý file và đĩa: tổ chức lưu trữ file trên đĩa.
- Quản lý thiết bị ngoại vi.
+ Driver: hoạt động giao tiếp giữa phần cứng, thiết bị với hệ điều hành.
+ DMA (Direct Memory Access)
+ PNP (Plug and play).
He dieu hanh 2 Page 1
Bài 1. QUẢN LÝ TIẾN TRÌNH.
I. Tiến trình:
- Tiến trình (Process) là chương trình đang thực thi.
- Tiến trình chiếm tài nguyên : CPU, bộ nhớ, các thiết bị xuất nhập.
- Các thông tin về tiến trình lưu trữ trong PCB (Process Control Block): id của tiến
trình, trạng thái của tiến trình, ngữ cảnh của tiến trình : con trỏ lệnh, khối nhớ của

tiến trình, danh sách tiến trình con do tiến trình này tạo ra, độ ưu tiên của tiến
trình, thông tin thống kê.
- Tiểu trình: phát sinh bởi tiến trình (thread) giúp tiến trình hoàn tất nhanh hơn. Sử
dụng bộ nhớ của tiến trình (nhưng có stack riêng).
- Các trạng thái của tiến trình.
II. Điều phối CPU:
3 sv thi
0g A 3g-B-3g30—C 5g
Ai tới trước, thi trước:
FIFO(độc quyền)
3+3.5+5=11.5 11.5/3=4 (thời gian hoàn thành trung bình)
0+3+3.5=6.5  6.5/3=2,1(thời gian chờ trung bình)
Ai giỏi thi trước
:SJF(độc quyền)
0g-B-0g30 C 2g A 5g
0.5+2+5=7.5  7.5/3=2.5(Tftb)
0+0.5+2=2.5  2.5/3=0.8(Twtb)
Luân phiên:
Round robin(không độc quyền)
0g-A-0.30-B-1-C-1.30-A-2g-C-2g30-A-3g-C-3g30-A-4g-A-4g30-A-5g
Tftb =1+3.5+5…=9.5/3=3.2?
Twtb=?
B xong lúc 1g
C xong lúc 3g30
A xong lúc 5g
B chờ 0.5
C chờ 1+0.5+0.5=2g
He dieu hanh 2 Page 2
Khởi
tạo

Ready list
Block list
Kết
thúc
Running
(Hàng đợi các tiến
trình sẵn sàng}
(Hàng đợi các tiến
trình bị chặn)
A chờ 0+1+0.5+0.5=2g
Twtb=0.5+2+2=4.5g/3=1.5g
1.
Trong hệ điều hành đa tiến trình, có nhiều cách điều phối CPU
Process Thời điểm readylist Thời gian CPU
1 0 24
2 1 3
3 2 3
First In First Out (FIFO) : tiến trình được nạp vào Ready List trước sẽ thực hiện
trước. Loại độc quyền.
+ Thời gian lưu lại hệ thống (thời gian hoàn thành)
P
1
24 P
2
27 P
3
30
P
1
P

2
P
3

t
f
= 24 + 27 + 30 = 81 t
fTB
= 81/3 = 27
+ Thời gian chờ:
tw = 0 + 23 + 25 = 48 t
wTB
= 48 / 3 = 16
Shortest Job First : tiến trình có thời gian xử lý ngắn nhất thực hiện trước. Loại
độc quyền.
+ Thời gian lưu lại hệ thống:
P
2
3 P
3
6 P
1
30
P
2
P
3
P
1

T
a
= 3 + 6 + 30 = 39 T
a TB
= 39 : 3 = 13
+ Thời gian chờ:
T
b
= 0 + 3 + 6 = 9 T
b TB
= 9 : 3 = 3 < 16
Round Robin: quay vòng, mỗi tiến trình được cấp phát CPU trong một khoảng thời
gian giới hạn (time slide, vd = 4)
+ Thời gian lưu lại hệ thống:
P
1
4 P
2
7 P
3
10 P
1
14 18 22 26 30
P
2
P
3
P
1

T
f
= 7 + 10 + 30 = 47 T
f TB
= 47: 3 = 15.7
+ Thời gian chờ:
T
w
= 0 + 6 + 0 + . . . . + 4 + 7 = 17 T
f TB
= 17 : 3 = 5.6
P
1
P
2
He dieu hanh 2 Page 3
- Độ ưu tiên: tiến trình có độ ưu tiên cao sẽ thực hiện trước.
Tiến trình Thứ tự xuất
hiện
Thời gian thực
hiện
Độ ưu
tiên
P
1
0 24 2
P
2
0 3 1
P

3
0 3 3
+ Thời gian lưu lại hệ thống:
P
2
3 P
1
27 P
3
30
P
2
P
1
P
3

T
f
= 3 + 27 + 30 = 60 T
f TB
= 60 : 3 = 20
+ Thời gian chờ:
T
w
= 0 + 3 + 27 = 30 T
w TB
= 30 : 3 = 10
- Không độc quyền: độ ưu tiên sẽ giảm khi trở lại Readylist.
τ = 2 (bài tập)

+ Thời gian lưu lại hệ thống:
P
2
2 P
1
4 P
2
5 P
3
7 P
1
9 P
3
30
P
1
P
2
P
3

T
a
= 5 + 10 + 30 = 45 T
a TB
= 45: 3 = 15
+ Thời gian chờ:
T
b
= 2 + 5 + 6 + 2 + 3 + 1 = 15 T

b TB
= 15 : 3 = 5
P
1
P
3
P
1
III. Vấn đề Critical secsion:
1. Critical section(CS) Là đoạn chương trình mà 2 (từ 2 trở lên) tiến trình
thực hiện đồng thời có thể phát sinh kết qủa ngoài ý muốn.
Ví dụ: if (tiềnrút <= tàikhoản)
tàikhoản = tàikhoản - tiềnrút
P1 Tiềnrút=400, tàikhoản=500
If (tiềnrút<=tàikhoản)
P2 Tiềnrút=300, tàikhoản=500
If (tiềnrút<=tàikhoản)
P1 Tàikhoản -=tiềnrút  tàikhoản= 100
P2 Tàikhoản -=tiềnrút  tàikhoản= -200??? Tức là khách
hàng rút ra số tiền lớn hơn số tiền gửi vào ngân hàng
He dieu hanh 2 Page 4
2. Các giải pháp:
a). Giải pháp cờ hiệu: Sử dụng một biến cờ :
int flag = 0 ;
// flag = 0 : Critical section tự do, flag=1 : Critical section bận
while (TRUE)
{
while (flag= = 1); // vòng lặp đợi cho đến khi flag = 0
flag = 1;
critical section ();// ví dụ đoạn rút tiền

flag = 0;
non_ critical section ()
}
Flag=0
P1 While(flag==1);
Flag=1
Cs(); đang chạy
P2 While(flag==1);//lãng phí CPU
P1 Cs(); xong
Flag=0
Non_cs();
P2 While(flag==1);
Flag=1
Cs();
P1
P2
Tình huống lỗi :
Tiến trình Khởi động flag = 0
P1 while (flag= = 1); // thấy flag= 0
P2 while (flag= = 1); // thấy flag= 0
flag = 1;
critical section (); //P2 đang chạy critical section
P1 flag= 1;
critical section (); //P1 cũng chạy critical section
Hai tiến trình đồng thời thực hiện critical section  giải pháp cờ hiệu không
“bảo vệ” được critical section
b). Giải pháp luân phiên:
Sử dụng biến luân phiên int turn;
turn = 0  cho phép tiến trình P
0

thực hiện critical section; turn = 1  cho phép
tiến trình P
1
thực hiện critical section
Tiến trình P
1:
He dieu hanh 2 Page 5
while (TRUE)
{
while (turn != 0);
critical section ( );//A chạy cs
turn = 1;//giao chìa cho người B
non_ critical section ();
}
Tiến trình P
2:
while (TRUE)
{
while (turn != 1);
critical section ( );//B chạy cs
turn = 0;// giao chìa cho A
non_ critical section( );
}
Turn = 1
P1 while (turn != 0);
critical section ( );//A chạy cs
P2 while (turn != 1);  lãng phí CPU
P1 Critical section(); xong
Turn= 1;
P2 while (turn != 1);

critical_section();
Tổng quát cho tiến trình P
i

trong trường hợp có n tiến trình P
0
,P
1
, … ,P
n-1
while (TRUE)
{
while (turn != i);
critical section ( );
turn = (i + 1)%n ;
non_ critical section( );
}

Tình huống lỗi :
Tiến trình Turn=0
P1 While(turn!=0);
Cs();
Turn=1
Non_cs()
P2 While(turn!=1);
Cs();
Turn=0;
Non_cs() xong
P1 Non_cs()
P2 While (turn!=1); lặp cho hết thời gian

He dieu hanh 2 Page 6
P1 Non_cs();
P2 While (turn!=1); lặp cho hết thời gian
P1 Non_cs();
P2 While (turn!=1); lặp cho hết thời gian
P
0
ngăn chận P
1
thực hiện critical section ();
He dieu hanh 2 Page 7
c). Giải pháp Peterson :
int turn; // trong gp luân phiên
int like[2]; // flag, like[0]=1;p1 muốn chạy cs
Tiến trình P
1

:
while (TRUE)
{ like[ 1 ] = 1;//p1 muốn chạy cs
turn = 0 ;//p1 nhường quyền chạy cs cho p0
while ( turn = = 0 && like [ 0 ] = = 1 );
critical_section ( );//p1 chạy cs
like [ 1 ] = 0;//p1 xong cs
non_ critical_section ( );
}
Tiến trình P1 : ???
Tiến trình Chương trình chạy
P0 like [ 0 ] =1;
turn = 1;

while ( turn = = 1 && like [ 1 ] = = 1 );
critical section ();//P0 đang chạy cs
P1 like [ 1 ] =1;
turn = 0;
while ( turn = = 0 && like [ 0 ] = = 1 );
//lãng phí thời gian CPU
P0 critical section ();//P0 xong cs
like [ 0 ] =0;
non_critical section ();
P1 while ( turn = = 0 && like [ 0 ] = = 1 );
critical section ();
Bài tập: tìm tình huống lỗi trong gp Peterson
Cả ba giải pháp đều có chung một khuyết điểm là lãng phí CPU. Do đó xếp vào loại
giải pháp Busy_Waitting
e) Giải pháp Sleep and wake_up:
He dieu hanh 2 Page 8
Bắt
đầu
Ready list
Block list
Kết
thúc
Running
Hàng đợi các tiến trình sẵn sàng Hàng đợi các tiến trình bị chặn
Sleep ( ) : hàm tiến trình gọi để tự treo (blocked) vì critical section đang bận
Wake_up ( ) : do một tiến trình vừa thực hiện critical section xong gọi, để đánh
thức tiến trình bị blocked.
int busy = 0 ; // giống biến flag
int blocked = 0 ; // cho biết số tiến trình sleeping
while (TRUE)

{
if ( bussy = = 1 ) // cs bận ?
{ blocked ++;
sleep ( );
}
busy = 1 ;
critical_section ( ) ;
busy = 0;
if ( blocked > 0){ //có ttrình sleeping
blocked ;
wake_up ( ); //đánh thức tiến trình ngủ
}
non_critical_section ( ) ;
}
Tiến trình Busy=0 blocked=0
P1 if (busy = = 1) False
bussy = 1
critical section ( ) ; đang chạy
P2 if (bussy = = 1)
blocked + +  blocked=1
sleep() ;
P1 critical section ( ) ; xong
busy=0
if (blocked>0) true
blocked—
wake up()  p2
P2 Busy=1
Critical section();
Trình bày tình huống lỗi trong gp sleep & wake up
a. 2 tiến trình đồng thời chạy cs (hiệp, tám, vi, dũng, tấn)

b. Có tiến trình nhưng ko được đánh thức(tâm,nguyên,phụng, huy)
He dieu hanh 2 Page 9
c.
P1 : if (busy==1) false
P2 : if (busy==1) false
Busy = 1
Cs();
P1 : busy = 1
Cs();  2 ttrình đồng thời cs
P1 If (busy==1) false
Busy=1
Cs()
P2 If (busy==1) true
Blocked++  blocked =1
P1 Busy=0
If (blocked>0) true
Blocked  blocked = 0
Wakeup()  đánh thức ???
P2 Sleep()  P2 không bao giờ được đánh thức, vì blocked=0
P1 …
Giải pháp có liên quan đến phần cứng:
1. Giải pháp cấm ngắt: (ngắt là một tín hiệu liên lạc) là tiến trình thực hiện
critical section sẽ chiếm giữ ngắt timer được độc quyền CPU. Nguy hiểm.
2. Giải pháp xây dựng cụm chỉ thị không bi cắt ngang:
 test_and_set(flag);
f. Giải thuật Semaphore:
Semaphore: là một giải thuật loại sleep and wake_up nhưng dùng đoạn chỉ thị
không bị cắt ngang.
Down ( )
{

e = e – 1;
e
: cho biết số tiến trình bị treo.
if ( e < 0 ) Sleep ( );
}
Up ( )
{
e = e + 1;
if ( e <= 0 ) Wake_up ( );
}
Ban đầu e=1
while ( TRUE )
He dieu hanh 2 Page 10
{
Down ( );
Critical section ( ) ;
Up ( );
Non_critical section ( ) ;
}
Bài tập : xây dựng một cụm lệnh không bị ngắt để giải pháp flag không bị lỗi. Viết
lại giải pháp flag sử dụng cum lệnh này.
He dieu hanh 2 Page 11
Minh họa giải pháp Semaphore :
Tiến trình Chương trình chạy : (ban đầu e=1)
P1 Down ( ); [ e = e – 1  e = 0
If (e<0) false ]
Critical section ( ) ;
P2 Down ( ); [ e = e – 1  e = -1
If (e<0) Sleep ( );  p2 sleep ]
P1 Up ( ); [ e = e + 1  e = 0

If (e<=0) Wake_up ( )  đánh thức p2 ]
Non_critical section ( );
P2 Critical section ( )
Ví dụ 2 :
Tiến trình Chương trình chạy
P1 Down ( ); [ e = e – 1  e = 0 ]
P2 Down ( ); [ e = e – 1  e = -1 ]
Sleep ( );
P1 Critical section ( );
P1 Up ( ); e = e + 1
Wake_up ( ) ; [đánh thức P2 ]
Non_critical section ( );
Giải thuật không phát sinh lỗi.
IV. Vấn đề đồng bộ hóa các tiến trình :
Là qui định một trình tự ( nào đó ) thực hiện các tiến trình.
Tuyển sinh :
P1: nhập điểm toán
P2 : nhập điểm lý
P3 : nhập điểm hoá
P4: cộng điểm
P5 : xếp giảm
Ví dụ: Có 2 tiến trình : P
1
thực hiện công việc A xong P
2
mới được phép thực hiện
công việc B.
Có 3 tiến trình :
P
1

xong A thì P
2
mới được phép thực hiện B, P
2
xong B thì P
3
được phép thực
hiện C
P1( )
{
A( );
S1.up()
}
P2( )
{ S1.down();
B();
S2.up();
}
P3( )
{ S2.down();
C( );
}
He dieu hanh 2 Page 12
Hay yêu cầu P
1
xong A, P
2
xong B thì P
3
được phép thực hiện C.

P1( )
{
A( );
S1.up();
}
P2( )
{
B();
S1.up();
}
P3( )
{
S1.down();
S1.down();
C( );
}
Ví dụ: Giải quyết yêu cầu P
1
xong công việc A, cho phép P
2
thực hiện công việc B
S1.e=0
P1( )
{ …
A( );
S1.up ( );
…
}
P2( )
{ ….

S1.down ( );
B( );
…
}
Tiến trình
Chương trình chạy (ban đầu e=0)
P2 Down ( ); [ e = e – 1  e = -1
If (e<0) Sleep ( ); ]
P1 A ( );
Up ( ) ; [ e = e + 1  e = 0
If (e<=0) Wake_up ( );  đánh thức P2 ]
P2 B ( );
 A xong B chạy
Bài tập :
P0(){
A();
}
P1(){
B();
}
P3(){
C();
}
a. A và B xong C chạy
b. A hay B xong C chạy
c. A xong B chạy, B xong C chạy
Bài tập :
A và B xong  C và D chạy
P0(){
A();

}
P1(){
B();
}
P2(){
C();
}
P3(){
D();
}
Bài làm câu a :
P0(){ P1(){ P3(){
He dieu hanh 2 Page 13
A();
s.Up();
}
B();
s.Up();
}
s.Down();
C();

}
P0 A()
s.Up()
[ e++  e=1
If (e<0) false]
P3 s.Down();
[ e  e= 0
If (e<0) false]

C();  C chạy khi B chưa chạy
Lời giải câu a :
P0(){
A();
s.Up();
}
P1(){
B();
s.Up();
}
P3(){
s.Down();
s.Down();
C();

}
Bài làm câu b :
P0(){
A();
s.Up();
}
P1(){
B();
s.Up();
}
P3(){
s.Down();
C();

}

Bài làm câu c:
P0(){
A();
s.Up();
}
P1(){
s.down();
B();
s.up();
}
P3(){
s.down();
C();

}
P0 A()
s.Up()
[ e++  e=1
If (e<=0) false
]
P3 s.Down()
[ e  e=0
If(e<0) false
]
C();  C chạy khi B chưa chạy
P0(){
A();
s.Up();
P1(){
s.down();

B();
P2(){
s.down();
s.down();
C();
He dieu hanh 2 Page 14
} s.up();
}

}
P0 A()
s.Up()
[ e++  e=1
If (e<=0) false
]
P2 s.Down()
[ e  e=0
If (e<0) false
]
s.Down()
[ e  e=-1
If (e<0) sleep(); // good night P2
P1 s.Down()
[ e  e=-2
If (e<0) sleep(); // good night P1
 không có tiến trình đánh thức P2, P1
Lời giải c:
P0(){
A();

S1.Up();
}
P1(){
S1.down();
B();
S2.up();
}
P2(){
S2.down();
C();

}
S1.e =0 S2.e=0
P0 A()
S1.up()
[ s1.e++  s1.e=1
If (s1.e<0) false]
P2 S2.down()
[ s2.e  s2.e = -1
If (e<0) true
Sleep();
P1 S1.down()
[ s1.e ;  s1.e = 0
If (e<0) false]
B()
S2.up()
[ s2.e++  s2.e=0
If (e<=0) true
Wakeup()  đánh thức P2
]

P2 C();
2 biến Semaphore vì có 2 yêu cầu ĐBH
Lời giải : sai
He dieu hanh 2 Page 15
P0(){
A();
S1.up()
}
P1(){
B();
S1.up();
}
P2(){
S1.down()
C();
}
P3(){
S1. down()
D();
}
Vì :
P0 A();
S1.up();
P3 S1.down();
D();  D chạy khi B chưa chạy
A và B xong  C chạy (s1)
A và B xong  D chạy (s2)
P0(){
A();
S1.up();

S2.up();
}
P1(){
B();
S1.up();
S2.up()
}
P2(){
S1.down()
S1.down()
C();
}
P3(){
S2.down();
S2.down();
D();
}
Sách tham khảo thực hành :
Lập trình trên môi trường Windows NT
Tác giả : Trần Hạnh Nhi
Tập 1: tiến trình, tiểu trình, memory, file … 
Tập 2 : lập trình mạng
Hướng dẫn :
1. Visual C : menu File  new  file  c++ source file
2. gõ :
# include <stdio.h>
#include <windows.h>
int dem = 0;
void cs()//tăng đếm lên 1
{

int x=dem;
x++;
for ( int j=0 ; j < 20000 ; j++) ;
dem=x;
}
void ham0(int n){
for(int i=0; i < n ;i++){
cs();
printf( “ hàm 0 : %d \n “, dem);
}
}
void ham1(int n){
for(int i=0; i < n ;i++){
cs();
printf( “ hàm 1 : %d \n “, dem);
}
}
He dieu hanh 2 Page 16
/*
void main(){
ham0(25000);
ham1(25000);
printf(“ ket thuc : %d \n”, dem);
}
*/
HANDLE h[2];
DWORD id[2];
void main(){
h[0]=CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ham0, (void
*)25000, 0, &id[0]);

h[1]=CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ham1, (void
*)25000, 0, &id[1]);
WaitForMultipleObjects(2, h, INFINITE, TRUE);
printf(“ ket thuc : %d \n”, dem);
}
Chạy : menu Build  Execute

P1( ){
A ( );
Up ( );
}
P2 ( ){
B ( );
Up ( );
}
Sai
P3 ( ){
down ( );
C( );
}
Đúng:
P3 ( ){
down ( );
down ( );
C ( );
}
Tình huống sai :
Tiến trình Chương trình chạy e = - 1
P3 Down ( ); [ e = e – 1 ] (e = - 2)
Sleep ( )

He dieu hanh 2 Page 17
P1 Job1 ( );
Up ( ) ; [ e = e + 1 ] ( e = -1 )
Wake_up ( ); đánh thức P3
P3 Down ( ); [ e = e + 1 ] ( e = - 2 )
Sleep ( );
P2 Job2 ( );
Up ( ) ; [ e = e + 1 ] ( e = -1 )
Wake_up ( ); đánh thức P3
P3 Job3 ( );
P1 Job1 ( );
Up ( );
Nên sử dụng 2 e là e1 và e2.
4 tiểu trình P1,P2,P3,P4 chứa 4 công việc lần lượt A,B,C,D. Đồng bộ hoá :
a. A,B xong thì C,D chạy
P1(){
A();
}
P2(){
B();
}
P3(){
C();
}
P4(){
D();
}
b. A xong thì B,C chạy. B,C xong thì D chạy
V. Vấn đề Deadlock:
Deadlock là một tình trạng của hệ thống trong đó có các tiến trình chờ đợi nhau vô

hạn.
1. Các yếu tố dẫn đến Deadlock:
a). Các tài nguyên không thể chia xẻ ( như bộ nhớ).
b). Các tiến trình chiếm giữ tài nguyên và yêu cầu thêm tài nguyên.
c). Chỉ đến khi kết thúc, tiến trình mới hoàn trả tài nguyên.
d). Yêu cầu tài nguyên của các tiến trình tạo thành một chu trình.
He dieu hanh 2 Page 18
Chưa
hoàn
toàn
đúng.
P
3
P
2
P
1
R
2
R
1
R
3
2. Các giải pháp cho vấn đề Dead Lock :
a). Giải pháp loại bỏ triệt để một yếu tố dẫn đến Deadlock ( Deadlock
preventation ):
- Tài nguyên không chia sẻ : không được.
- Sự chiếm giữ và yêu cầu thêm tài nguyên: không biết được chính xác tài nguyên
đủ tiến trình, quá lãng phí.
- Có thể dẫn đến những tiến trình không bao giờ hoàn thành.

- Không giải quyết được.
b). Giải pháp tránh Deadlock ( Deadlock avoidance )
- Kiểm tra tình trạng của hệ thống.
Max Allocation Need
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 3 2 2 1 0 0 2 2 2
P2 6 1 3 2 1 1 4 0 2
P3 3 1 4 2 1 1 1 0 3
P4 4 2 2 0 0 2 4 2 0
Available
4 1 2
Available Need Process
4 1 2 >= 4 0 2 P2
6 2 3 >= 1 0 3 P3
8 3 4 >= 4 2 0 P4
8 3 6 >= 2 2 2 P1
9 3 6
Mọi tiến trình hoàn thành (finished
i
=true)
 hệ thống SAFE với trình tự cấp phát tài nguyên là P2, P3, P4, P1
Int Max[nP][nR];
Int Allocation[nP][nR];
Int Need[nP][nR];
Int Available[nR]={4,1,2};
+ Tính Need
For i
He dieu hanh 2 Page 19
For j
Need[i][j]=Max[i][j]- Allocation[i][j]

For i: Finished[i]=False
+ Lặp:
Tìm tiến trình i sao cho (Need[i]<=Available && Finished[i]= = False)
Nếu tìm thấy
{ Finished[i]=True;
Available += Allocation[i]; // Available = (4 1 2 ) + ( 2 1 1 ) = ( 6 2
3 )
}
Ngược lại : break;
Bài tập :
Max Allocation Need
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 5 5 6 0 0 0 5 5 6
P2 8 8 8 3 5 4 5 3 4
P3 12 10 10 2 2 3 10 8 7
P4 10 10 10 2 4 2 8 6 8
Available
5 3 5
1. Hệ thống Safe ?
5 3 5 >= 5 3 4 P2
8 8 9 >= 8 6 8 P4
10 12 11 >= 5 5 6 P1
10 12 11 >= 10 8 7 P3
12 14 14
Mọi tt hoàn thành  safe với trình tự cấp phát tài nguyên là P2, P4, P1,
P3
2. Nếu P1 yêu cầu tài nguyên Request
1
= { 1, 1, 0 } thì OS sẽ làm gì ?
Giả sử đáp ứng Request

1
Max Allocation Need
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 5 5 6 1 1 0 4 4 6
P2 8 8 8 3 5 4 5 3 4
P3 12 10 10 2 2 3 10 8 7
P4 10 10 10 2 4 2 8 6 8
Available
4 2 5
4 2 5 >=
He dieu hanh 2 Page 20
Có tt không hoàn thành  Unsafe  OS không đáp ứng yêu cầu P1  OS khóa
(block) P1
3. P1 yêu cầu Request
1
={0,0,1}.OS làm gì?
Max Allocation Need
R1 R2 R3 R1 R2 R3 R1 R2 R3
P1 5 5 6 0 0 1 5 5 5
P2 8 8 8 3 5 4 5 3 4
P3 12 10 10 2 2 3 10 8 7
P4 10 10 10 2 4 2 8 6 8
Available
5 3 4
5 3 4 >= 5 3 4 P2
8 8 8 >= 8 6 8 P4
10 12 10 >= 5 5 5 P1
10 12 11 >= 10 8 7 P3
12 14 14
Safe  đáp ứng Request

1
4. P2 yêu cầu Request
2
={1,1,1} OS làm gì ?
OS đáp ứng yêu cầu của P2 vì đúng trình tự cấp phát tài nguyên để hệ thống
safe (câu 1)
5. P3 yêu cầu Request3={6,2,3}.OS làm gì?
Request3> Available  OS bock P3
+ Kết luận :
Khi mọi Finished[i] đều bằng True : hệ thống SAFE với trình tự cấp phát
P2,P3,P4,P1
Ngược lại : UNSAFE ( Không an toàn -> chắc chắn hệ thống sẽ Deadlock ).
- Giải thuật cấp phát tài nguyên.
+ Khi tiến trình i yêu cầu tài nguyên request[i]:
Nếu (request[i]<= Available && request[i]<=Need[i])
{ - Lưu Allocation[i], Available
- Cấp phát Allocation[i] +=
Available -= request[i];
- Kiểm tra trạng thái của hệ thống.
* Safe: cấp phát thực.
* Unsafe: không cấp phát. Khôi phục lại trạng thái.
}
c). Giải pháp phát hiện và khôi phục Deadlock (Deadlock Detection &
Recorvery):
- Giải thuật phát hiện Deadlock: ( So sánh ba cách giải quyết Deadlock ) giống giải
thuật kiểm tra tình trạng an toàn (Safe / Unsafe)
- Khi Deadlock xảy ra:
+ Buộc một số tiến trình hoàn trả tài nguyên.
He dieu hanh 2 Page 21
+ Buộc tất cả các tiến trình thực hiện lại từ đầu.

Câu hỏi: So sánh 3 cách giải quyết Deadlock.
VI. Liên lạc giữa các tiến trình :
Các tiến trình cùng truy xuất đến các thông tin chung của hệ thống, hoặc cần hợp
tác nhau để giải quyết một yêu cầu. Do đó các tiến trình cần liên lạc với nhau
1. Loại liên lạc/ đặc tính của liên lạc :
a. Tường minh (explicit naming)/tiềm ẩn (implicit naming)
b. Đồng bộ/ không đồng bộ
c. Môi trường xảy ra liên lạc : hệ thống tập trung/ hệ thống phân tán
2. Các cơ chế liên lạc :
1. Tín hiệu (signal)
2. Pipe
3. Sử dụng vùng nhớ chia sẻ
4. Trao đổi thông điệp
5. Sockets
He dieu hanh 2 Page 22
Bài 2 Bộ nhớ
I. Bộ nhớ:
- Là một dãy liên tiếp các từ nhớ, mỗi từ có địa chỉ.
- Các nhiệm vụ của hệ điều hành :
1.Phân phối bộ nhớ cho các tiến trình.
2.Định vị địa chỉ: ( xác định địa chỉ vật lý từ địa chỉ luận lý)
3.Cần giải pháp giải quyết các yêu cầu bộ nhớ rất lớn của các tiến trình.
- Trường hợp hệ điều hành đơn chương MS-DOS 640KB (Conventional memory)
Chương trình
OS
Nếu chương trình lớn hơn vùng nhớ tự do, hệ điều hành sẽ loại bỏ phần hệ điều
hành không thiết yếu ra khởi bộ nhớ. Sau khi chương trình hoàn thành, sẽ nạp
command.com trở lại.
32Mb
64MB

128Mb
256Mb
512Mb
`
Phân vùng cố định, liên tục, nhiều hàng đợi
Phân vùng động,
Liên tục  gây ra hiện tượng phân mảnh
Phân vùng cố định, liên tục, một hàng đợi
He dieu hanh 2 Page 23
32Mb
64MB
128Mb
256Mb
512Mb
640 KB
Operating System
Limit Register
CPU
Base Register
<
+
Physical Memory
Báo lỗi
II. Phân phối bộ nhớ:
1. Phân vùng cố định – cấp phát liên tục :
Chia nhớ chia thành các vùng nhớ cố định. Kích thước các vùng nhớ đều
nhau hoặc khác nhau để đáp ứng các tiến trình có yêu cầu vùng nhớ kích thước
khác nhau . Mỗi tiến trình được cấp phát một vùng nhớ liên tục.
2. Phân vùng động - cấp phát liên tục :

HĐH cấp cho tiến trình các khối nhớ liên tục. Khi tiến trình kết thúc, tạo
thành các khối nhớ tự do không liên tục : hiện tượng phân mảnh ngoại vi. Một tiến
trình mới có thể bị rơi vào tình trạng không được cấp khối nhớ liên tục theo yêu cầu
mặc dù tổng các khối nhớ tự do (và rời rạc) lớn hơn yêu cầu của tiến trình mới.
P4
P3
P2
P1
P0
-Cách quản lý vùng nhớ đã cấp phát cho các tiến trình và vùng nhớ chưa sử dụng
Cách 1 : sử dụng mảng các bit : bit 1 ghi nhận khối nhớ tương ứng đang được sử
dụng và ngược lại, bit 0 ghi nhận khối nhớ tương ứng là tự do. Hình vẽ (sách)
Cách 2 : sử dụng danh sách liên kết đơn, trong đó mỗi phần tử cho biết vùng nhớ
đang được sử dụng bởi tiến trình (P) hay tự do (H), bắt đầu từ khối nhớ nào, gồm
bao nhiêu khối nhớ. Hình vẽ (sách)
-Chiến lược chọn vùng nhớ tự do để cấp phát cho tiến trình mới : 2 blocks:
Best Fit
First Fit
Worst Fit
He dieu hanh 2 Page 24
P7
P6
P5
P4
P2
P2
P1
1 1 1 1 1 1 1 1 1 1 1 1 1 1
3. Phân vùng rời rạc : Phân trang/ phân đoạn/ phân đoạn kết hợp phân trang
Phân trang : Bộ nhớ vật lý chia thành các khung trang (frame). Bộ nhớ của tiến

trình chia thành các trang (page). Kích thước frame bằng với kích thước của page.
Swap-out
Swap-in
Cơ chế định vị :
III. Bộ nhớ ảo (Virtual Memory)
1. Đặt vấn đề : Các tiến trình đòi hỏi kích thước bộ nhớ lớn hơn kích thước
bộ nhớ vật lý.
Có thể giải quyết vấn đề này bằng 2 cách :
-Người lập trình sử dụng kỹ thuật viết chương trình Overlay :
người lập trình xác định tiến trình nào cần giữ lại trong bộ nhớ (vì còn
được sử dụng tiếp tục và thường xuyên), tiến trình nào cần phải trả lại
vùng nhớ ngay khi có thể. Đây là giải pháp đòi hỏi người lập trình phải
hiểu biết kỹ thuật viết chương trình Overlay và vận dụng đúng kỹ
thuật này. MS DOS sử dụng kỹ thuật này.
-Hệ điều hành sử dụng kỹ thuật bộ nhớ ảo. Kỹ thuật bộ nhớ ảo
là kỹ thuật áp dụng một chiến lược nào đó để tự động đưa một vùng
bộ nhớ vật lý ra đĩa (swapping) để có thể nạp một tiến trình khác vào
bộ nhớ vật lý
Có 2 cách cài đặt bộ nhớ ảo :
a.Phân trang theo yêu cầu (Demand Paging) và
b.Phân đoạn theo yêu cầu (Demand Segmentation) : phức tạp hơn
nhiều vì kích thước các đoạn khác nhau.
2. Phân trang theo yêu cầu :
He dieu hanh 2 Page 25
P1
P0
P3
P2
P5
P4

P7
P6
P8