Tải bản đầy đủ

hdh10 1

KHOA CÔNG NGHỆ THÔNG TIN
TRƯỜNG ĐẠI HỌC BÁCH KHOA TP HỒ CHÍ MINH

HỆ ĐIỀU HÀNH
Giao tiếp giữa các tiến trình


Một số khái niệm cơ bản*
Tiến trình độc lập không ảnh hưởng và không bị ảnh
hưởng bởi việc thực thi của các tiến trình khác.
Tiến trình hợp tác (không độc lập) có thể ảnh hưởng
và bị ảnh hưởng bởi việc thực thi của các tiến trình
khác.
Ưu điểm của việc hợp tác tiến trình:
Chia sẻ thông tin
Tăng tốc tính toán (xử lý song song)
Tính module hóa
Tiện lợi

2



Một số khái niệm cơ bản*
Các tiến trình sử dụng và cập nhập dữ liệu chia sẻ
như các biến, file và cơ sở dữ liệu dùng chung.
Thao tác ghi phải độc lập từng đôi một để ngăn ngừa
tình trạng đụng độ, có thể dẫn đến tính không toàn
vẹn dữ liệu.
Các miền găng dùng để cung cấp sự toàn vẹn dữ liệu.
Một tiến trình đòi hỏi miền găng phải không bị chờ
mãi mãi: deadlock

3


Đụng độ (race condition)
Race condition: tình huống mà nhiều tiến trình cùng
truy cập và thao tác dữ liệu chia sẻ một cách đồng
thời. Dữ liệu cuối cùng phụ thuộc vào tiến trình cuối
cùng.
Để ngăn ngừa đụng độ, các tiến trình đồng hành phải
được đồng bộ hóa.

4


Đụng độ (race condition)

5


Miền găng (critical section)
n tiến trình đấu tranh với nhau để sử dụng một số dữ
liệu nào đó.
Mỗi tiến trình có một đoạn mã, gọi là miền găng
(critical section (CS)), tại đó dữ liệu chia sẻ được
truy cập.
Vấn đề: bảo đảm rằng khi một tiến trình đang thực
thi trong miền găng của nó, không có tiến trình nào
khác được quyền thực thi trong miền găng của nó.


6


Ngữ cảnh miền găng
Khi một tiến trình thi hành đoạn mã thao tác trên dữ
liệu chia sẻ (hay tài nguyên), chúng ta nói rằng tiến
trình đó đang trong miền găng của nó.
Việc thực thi các miền găng phải có tính duy nhất: tại
bất kỳ thời điểm nào, chỉ có duy nhất một tiến trình
được quyền thực thi trong miền găng của nó (ngay cả
với nhiều bộ xử lý).
Vì vậy mỗi tiến trình phải yêu cầu quyền trước khi
vào miền găng.

7


Ngữ cảnh miền găng
Đoạn mã thể hiện yêu cầu này được gọi làEntry
Section (ES).
Miền găng (CS) có thể theo sau là Leave/Exit
Section (LS).
Phần đoạn mã còn lại là Remainder Section (RS).
Vấn đề của miền găng là thiết kế một giao thức mà
các tiến trình có thể sử dụng để hành động của chúng
sẽ không phụ thuộc vào thứ tự mà sự thi hành của
chúng được chen vào.

8


Giải pháp cho vấn đề miền găng
Có 3 yêu cầu mà một giải pháp đúng cần phải thỏa
mãn:
1. Mutual Exclusion: không có 2 tiến trình cùng ở
trong miền găng một lúc
2. Progress: Một tiến trình bên ngoài miền găng
không được ngăn cản các tiến trình khác vào
miền găng
3. Bounded Waiting: không có tiến trình nào phải
chờ vô hạn để vào miền găng
Chỉ cần một trong ba điều kiện trên sai thì giải
pháp đưa ra là sai.
9


Cấu trúc của các tiến trình
Cấu trúc tổng quát của tiến trình Pi (Pj)
do {
entry section
critical section
leave section
remainder section
} while (1);
Lưu ý: Các tiến trình có thể chia sẻ các biến dùng
chung để đồng bộ hóa hoạt động của chúng.

10


Phân loại các giải pháp cho CS
Giaûi phaùp busy-waiting
Alg. 1 & 2, Peterson, Dekker, Bakery,
TSL, Interrupt

Giaûi phaùp sleep and wake-up
Semaphore
Monitor

11


Giải thuật 1
Biến chia sẻ

int turn;
/* khởi đầu turn = 0 */
nếu turn = i ⇒ Pi được phép vào critical section

Process Pi
do {

while (turn != i) ;
critical section();
turn = j;
remainder section();
} while (1);

Thoả mãn mutual exclusion (1)
Progress (2) & bounded-waiting (3) ?
12


Giải thuật 1
Process P0:
do
while(turn !=0 );
Critical_Section();
turn=1;
Remainder_Section();

Process P1:
do
while(turn!=1);
Critical_Section();
turn=0;
Remainder_Section();

while (1);

while (1);

Ví dụ: P0 có RS rất lớn và P1 có RS nhỏ.
Nếu turn=0, P0 được vào CS và sau đó thực thi vùng RS (turn=1).
Đến P1 vào CS và sau đó thực thi RS (turn=0) và tìm cách vào CS một lần
nữa nhưng yêu cầu bò từ chối !!! P1 phải chờ P0 !!!.
13


Giải thuật 2
Biến chia sẻ
boolean flag[2]; /* khởi đầu flag [0] = flag [1] = false. */
Nếu flag [i] = true ⇒ Pi sẵn sàng vào critical section

Process Pi
do {
flag[i] = true;
while (flag[j]) ;
Critical_Section();
flag [i] = false;
Remainder_Section();
} while (1);
14


Giải thuật 3 (Peterson)
Biến chia sẻ: kết hợp cả giải thuật 1 và 2.
Process Pi
do {
flag [i]= true;
turn = j;
while (flag [j] and turn == j) ;
Critical_Section();
flag [i] = false;
Remainder_Section();
} while (1);

15


Giải thuật Bakery: N process
Trước khi vào CS, process Pi nhận một con số. Process nào giữ
con số nhỏ nhất thì được vào CS
Trường hợp Pi và Pj cùng nhận được một chỉ số:

Nếu i < j thì Pi được vào trước, ngược lại Pj được vào
trước.
Khi ra khỏi CS, Pi đặt lại số của mình bằng 0
Cơ chế cấp số cho các process thường tạo các số theo cơ chế
tăng dần, ví dụ 1,2,3,3,3,3,4,5...

16


Lệnh TSL (Test-and-Set Lock)
Kiểm tra và cập nhật một biến trong một thao tác đơn
(atomic)
nShared data:
bool TestandSet(bool &target)
{
bool rv = target;
target = true;
return rv;
}

bool lock = false;
nProcess Pi

while (1)

{
while (TestandSet(lock)) ;
Critical_Section;
lock = false;
Remainder_Section;
}
17


Semaphores
Là một công cụ đồng bộ hóa được cung cấp bởi
HĐH không đòi hỏi “busy waiting”.
Một semaphore S là một biến nguyên mà ngoài lệnh
khởi tạo ra, chỉ có thể được truy xuất thông qua hai
thao tác độc quyền truy xuất và nguyên tố:
wait(S)
signal(S)

18


Semaphores
Truy cập với 2 thao tác
wait (S):
while S≤ 0 do no-op;
S--;
signal (S):
S++;
Để tránh “busy waiting”: khi một tiến trình phải đợi, nó sẽ
được đặt vào hàng đợi block.
Khi một tiến trình phải đợi một semaphore S, nó sẽ bị block
và đặt vào hàng đợi của semaphore tương ứng.
Thao tác signal lấy một tiến trình từ trong hàng đợi và đặt nó
vào trong danh sách các tiến trình ở trạng thái sẵn sàng.
19


Semaphores
Định nghĩa cấu trúc:
typedef struct {
int value;
struct process *L;
} semaphore;
Giả sử có 2 thao tác cơ bản:
Block tạm cho tiến trình chờ.
wakeup(P) khôi phục lại sự thi hành của tiến trình bị
block P.

20


Semaphores
wait(S):
S.value--;
if (S.value < 0) {
add this process to S.L;
block;
}
signal(S):
S.value++;
if (S.value <= 0) {
remove a process P from S.L;
wakeup(P);
}
21


Vấn đề deadlock trong hệ thống
Tình huống: một tập các process bò blocked, mỗi process giữ tài nguyên
và đang chờ tài nguyên mà process khác trong tập đang giữ.
Ví dụ 1
– Giả sử hệ thống có 2 file trên đóa.
– P1 và P2 mỗi process đang mở một file và yêu cầu mở file kia.

Ví dụ 2
– Semaphore A và B, khởi tạo bằng 1
P0
P1
wait (A);
wait(B);
wait (B);
wait(A);

-8.22-


Mô hình hóa hệ thống
Hệ thống gồm các loại tài nguyên, kí hiệu R1, R2,…, Rm , bao gồm:
– CPU cycle, không gian bộ nhớ, thiết bò I/O, file, semaphore,…



Mỗi loại tài nguyên Ri có Wi thực thể (instance).
Process thường sử dụng tài nguyên theo thứ tự sau
– Yêu cầu (request): process phải chờ nếu yêu cầu không được đáp ứng ngay
– Sử dụng (use): process sử dụng tài nguyên
– Hoàn trả (release): process hoàn trả tài nguyên

Các tác vụ yêu cầu (request) và hoàn trả (release) đều là system call.
Ví dụ





request/release device
open/close file
allocate/free memory
wait/signal
-8.23-


Điều kiện cần để xảy ra deadlock
Bốn điều kiện cần (necessary condition) để xảy ra
deadlock
1. Mutual exclusion: ít nhất một tài nguyên được giữ theo
nonsharable mode.
2. Hold and wait: một process đang giữ ít nhất một tài
nguyên và đợi thêm tài nguyên do quá trình khác đang
giữ.

-8.24-


Điều kiện cần để xảy ra deadlock (tt)
3. No preemption: tài nguyên không thể bò lấy lại, mà chỉ có
thể được trả lại từ process đang giữ tài nguyên đó khi nó
muốn.
4. Circular wait: tồn tại một chu trình của các yêu cầu tài
nguyên và tài nguyên đã được cấp phát.

P1

P2

-8.25-


Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay

×