Bài giảng hệ điều hành chương đồng bộ hóa tiến trình

Giới thiệu BackgroundCạnh tranh và sự nhất quán dữ liệu Cạnh Tranh Và Sự Nhất Quan Dữ Liệu I Các tiến trình thực thi đồng thời, chia sẻ dữ liệu dùng chung có thểdẫn đến tình trạng không

Trang 1

CT107 Hệ Điều Hành

Chương 5 Đồng Bộ Hóa Tiến Trình

Giảng viên: Trần Công Án (tcan@cit.ctu.edu.vn)

Bộ môn Mạng máy tính & Truyền thông

Khoa Công Nghệ Thông Tin & Truyền Thông

Đại học Cần Thơ

2014

Trang 3

Nội Dung

Giới thiệu (Background)

Vấn đề miền tương trục (Critical-section problem)Các giải pháp cho vấn đề miền tương trục

Đồng bộ hóa bằng phần mềm (Software Sync.)

Đồng bộ hóa bằng phần cứng (Hardware Sync.)

Hiệu báo (Semaphores)

Các bài toán đồng bộ hóa

Monitors

Trang 4

Cạnh tranh và sự nhất quán dữ liệu

Cạnh Tranh Và Sự Nhất Quan Dữ Liệu

I Các tiến trình thực thi đồng thời, chia sẻ dữ liệu dùng chung có thểdẫn đến tình trạng không nhất quán(inconsistency) của dữ liệu

I Nhất quán = đúng đắn và chính xác; tùy thuộc vào ngữ cảnh, giaodịch

I Có2 lý do chính để thực hiện đồng thời (cạnh tranh) các tiến trình:

I Tăng hiệu suất sử dụng tài nguyên hệ thống.

I Giảm thời gian đáp ứng trung bình của hệ thống.

I Việc duy trì sự nhất quán của dữ liệuyêu cầu một cơ chế để đảm bảo

sự thực thi một cách có thứ tựcủa các tiến trình có hợp tác với nhau

Trang 5

Ví Dụ 1 – Giao Dịch Cạnh Tranh

I Cho hai giao dịch:

I T1: A mua hàng trị giá 50$ của P

P = P + 50 W(P)

T2

R(A)

A = A - 100 W(A) R(P)

P = P + 100 W(P)

I Yêu cầu về tính nhất quán: (A + B + P) không đổi; cụ thể hơn:

I giá trị A, B, P sau khi thực hiện T1, T2 là: A=450; B=400; P=1150

I Nhận xét:

I Nếu thực hiện tuần tự T1 → T2 hoặc T2 → T1, dữ liệu sẽ nhất quán

I Nếu thực hiện cạnh tranh (đồng thời), dữ liệu sẽ nhất quán???

Trang 6

R(P)

P = P + 100 W(P)

R(A)

A = A – 50

W(A) R(P)

P = P + 50 W(P)

R(B)

B = B - 100 W(B)

R(P)

P = P + 100 W(P)

400

450

1050

1150 Schedule 2

Trang 7

Ví Dụ 2 – Bài Toán Nhà SX - Người Tiêu Thụ

I Dữ liệu chia sẻ (kho hàng, có giới hạn):

Trang 8

I Nhà sản xuất (S):

while (true) {

/* produce an item in next produced */

while (counter == BUFFER SIZE) ; /* do nothing */

buffer[in_item] = next_produced;

in_item = (in_item + 1) % BUFFER SIZE;

counter++;

}

Trang 9

Trang 10

I Dữ liệu chia sẻ giữa producer và consumer: biếncounter

I Điều kiện đểđảm bảo tính nhất quán của biến counter: các câu lệnh

counter++ và counter phải được thực thi một cách “nguyên tử”

và “cô lập”

I Nguyên tử: không thể chia nhỏ (hoặc “hoặc tất cả, hoặc không”)

I Cô lập: các t/trình không truy xuất các g/trị không nhất quán của nhau

I Vấn đề gì có thể xảy ra đối với counter?

I counter++ trong ngôn ngữ máy:

Trang 11

I Xét một lịch trình thực thi xen kẽ (cạnh tranh) của hai tiến trìnhS và

T trong hệ thống, với giá trịcounter = 5:

S1: register1 = counter (register1 = 5)

S2: register1 = register1 + 1 (register1 = 6)

P1: register2 = counter (regster2 = 5)

P2: register2 = register2 - 1 (register2 = 4)

S3: counter = register1 (counter = 6)

P3: counter = register2 (counter = 4)

⇒ giá trị cuối cùng của counterlà4 (hoặc 6nếu S3 sau P3), trongkhi giá trị nhất quáncủacounter trong trường hợp này là 5

Trang 12

Tình trạng tranh đua (Race condition)

Tình Trạng “Tranh Đua” (Race Condition)

I Là tình trạng mà nhiều tiến trình cùngtruy cập và thay đổi lên dữ liệuđược chia sẻ, và giá trị cuối cùng của dữ liệu chia sẻphụ thuộc vào

quá trình hoàn thành sau cùng

I giá trị của P trong ví dụ 1

I hoặc giá trị biến counter trong ví dụ 2

I Tình trạng tranh đua có thể dẫn đến tình trạng không nhất quán

I Để ngăn chặn tình trạng tranh đua, các quá trình cạnh tranh cần phảiđược đồng bộ hóa (synchronize)

Trang 13

Vấn đề miền tương trục (Critical-section problem)

Vấn Đề Miền Tương Trục (CSP)

I Xét 1 hệ thống có n tiến trình đang cạnh tranh {P0, P1, , Pn−1}

I Miền tương trục (critical section): là một đoạn mã lệnhcủa cáctiến trình có chứa các hành động truy cập dữ liệu được chia sẻ như:thay đổi các biến dùng chung, cập nhật CSDL, ghi tập tin,

⇒ Để tránh tình trạng tranh đua, các hệ thống phải đảm bảo khi mộttiến trình đang trong miền tương trục, không có một tiến trình nàokhác được phép chạy trong miền tương trục của nó

I Vấn đề miền tương trục (critical-section problem): Thiết kế các

giao thức để các tiến trình có thể sử dụng để hợp tác/cạnh tranhvớinhau

Trang 14

Vấn đề miền tương trục (Critical-section problem)

Vấn Đề Miền Tương Trục (CSP)

I Cần phải xác định được phầnentry section

và exit section

I Mỗi tiến trình phải xin phép để được vào

miền tương trục (đi qua vùngentry

section), và sau đó thoát khỏi miền tương

trục (đi qua vùngexit section) và thực hiện

phần còn lại (remainder section)

I Giải pháp cho vấn đề miền tương trục

tương đốiphức tạpvới với các hệ thống

Trang 15

Các giải pháp cho vấn đề miền tương trục

Yêu Cầu Đối Với Các Giải Pháp Cho CSP

I Một giải pháp cho vấn đề miền tương trục phải thỏa 3 yêu cầu:

1 Loại trừ hỗ tương (mutual exclusion): Nếu 1 t/trình đang thực thi trong miền tương trục, không một tiến trình nào khác được đi vào miền tương trục của chúng.

2 Tiến triển (progress): Nếu không có tiến trình nào đang thực thi trong miền tương trục và tồn tại tiến trình đang chờ được thực thi trong miền tương trục của chúng, thì việc lựa chọn cho một quá trình bước vào miền tương trục không thể bị trì hoãn vô hạn

3 Chờ đợi hữu hạn (bounded wait): Mỗi t/trình chỉ phải chờ để được vào miền tương trục trong một khoảng t/gian có hạn định (không xảy

ra tình trạng “chết đói” – starvation).

Trang 16

Các giải pháp cho vấn đề miền tương trục

Phân Loại Các Giải Pháp

I Các giải pháp phần mềm: dựa trên các giải thuật phần mềm, như:

I Cho trường hợp chỉ có 2 tiến trình cạnh tranh :

I Giải thuật 1 và 2

I Giải thuật Peterson (Peterson’s algorithm)

I Cho trường hợp có n ≥ 2 tiến trình cạnh tranh :

I Giải thuật Bakery

I Các giải pháp phần cứng:

I Lệnh vô hiệu hóa ngắt (disable interrupt)

I Lệnh máy đặc biệt: TestAndSet

Trang 17

Giải thuật cho trường hợp có 2 tiến trình

GT1 – Giải Thuật Chờ Bận 1 (Busy Wait)

I Điều khiển cạnh tranh giữa 2 tiến trình Pi và Pj

I Dùng 1biến khóa chia sẻ để đ/khiển việc vào miền tương trục

I turn = i ⇒ P i có thể vào miền tương trục.

I Tổ chức đoạn mã của 1 tiến trình Pi:

Trang 18

GT2 – Giải Thuật Chờ Bận 2 (Busy Wait)

I Dùng các biến khóa riêngđể đ/khiển việc vào miền tương trục

I boolean flag[2];

I Khởi tạo: flag[0] = flag[1] = false

I flag[i] = true ⇒ P i sẵn sàng vào miền tương trục.

⇒ Giống giải thuật 1.

I Tuy nhiên, mức độ cạnh tranh cao hơn.

Trang 19

Giải Thuật Peterson

I Kết hợp cảbiến khóa chia sẻ (GT1) vàbiến khóa riêng(GT2):

I int turn; //turn = i: P i được phép vào miền tương trục.

I boolean flag[2]; //flag[i] = true: P i sẵn sàng vào miền tương trục.

Trang 20

Giải thuật cho trường hợp có n tiến trình

Giải Thuật Bakery

I Miền tương trục cho n tiến trình:

I Mỗi t/trình sẽ nhận được 1 số trước khi vào miền tương trục.

I Tiến trình có số nhỏ nhất sẽ có quyền ưu tiên cao nhất

I Nếu hai tiến trình P i và P j nhận được cùng một số, nếu i < j thì P i

Trang 21

Giải thuật cho trường hợp có n tiến trình

Trang 22

I Không có tiến trình nào khác có thể thực thi khi một tiến trình đã vào miền tương trục ⇒ tránh tình trạng cạnh tranh.

I Chỉ có thể áp dụng cho hệ thống không trưng dụng

I Không khả thi cho hệ thống đa xử lý (vô hiệu hóa các ngắt trên hệ thống đa xử lý mất nhiều chi phí ⇒ hiệu năng giảm).

Trang 23

Trang 24

Chỉ thị test_and_set

Chỉ Thị test_and_set

I Cho phép đọc và sửa nội dung của một word một cách nguyên tử

I Định nghĩa của chỉ thị test_and_set:

boolean test_and_set( boolean *target) {

boolean rv = *target;

*target = true ;

return rv;

}

Trang 25

Chỉ thị test_and_set

Loại Trừ Hỗ Tương Với test_and_set

I Dữ liệu chia sẻ: boolean lock = false;

Trang 26

Chỉ thị compare_and_swap

Chỉ Thị compare_and_swap

I Dùng để hoán chuyển (swap) hai biến

I Định nghĩa của chỉ thị swap:

void swap( boolean &oldValue, boolean expected, boolean newValue) {

boolean temp = *oldValue;

Trang 27

Chỉ thị compare_and_swap

Loại Trừ Hỗ Tương Với compare_and_swap

I Dữ liệu chia sẻ: boolean lock = false;

Trang 28

Chờ đợi hữu hạn với test_and_set

Chờ Đợi Hữu Hạn Với test_and_set

while (waiting[i] && key) key = test_and_set(&lock);

waiting[i] = false ; critical section

Trang 29

Hiệu Báo (Semaphores)

I Semephore là công cụ đồng bộ hóa tránh được chờ đợi bận:

I Tiến trình chờ đợi vào miền tương trục sẽ ngủ/nghẽn

I Tiến trình đang ngủ/nghẽn sẽ được đánh thức bởi các tiến trình khác.

I Semaphore S: là một biến integer, được truy cập qua 2 thao tácnguyên tử:

Trang 30

I Semaphore nhị phân (binary

semaphore): có giá trị 0 hoặc

1, còn gọi là mutex lock ; cài

đặt đơn giản hơn.

I Dữ liệu chia sẻ:

semaphore mutex = 1;

I Tiến trình Pi:

do { wait(mutex);

critical section singal(mutex);

remainder section } while ( true );

Trang 31

Đồng bộ hóa dùng Semaphore

Đồng Bộ Hóa Dùng Semaphore – Ví Dụ

I Có 2 tiến trình: P1 với lệnh S1 và P2 với lệnh S2

I Yêu cầu: S2 phải thực thi sau khi S1 hoàn thành

S2

Trang 32

Semaphore không chờ đợi bận

Cài đặt Semaphore Không Chờ Đợi Bận

I Thao tác signal(S) và wait(S) không tránh được chờ đợi bận

I Hai thao tác cần được cung cấp bởi HĐH:

I block() : ngưng (block) tạm thời tiến trình gọi chỉ thị này.

I wakeup(P) : khởi động lại tiến trình đang bị ngưng P.

Trang 33

Các Thao Tác Semaphore Không Chờ Đợi Bận

I Các thao tác semaphore wait(S) và signal(S)được định nghĩa lạinhư sau:

I Giá trị semaphore có thể âm (trong tr/hợp chờ đợi bận thì không).

I Giá trị âm thể hiện số lượng tiến trình đang chờ đợi trên semaphore.

Trang 34

Cài Đặt wait() Và signal()

I Yêu cầu: không thể có nhiều hơn 1 tiến trình thực thi wait() hoặcsignal() đồng thời ⇒ critical-section problem

I Hệ thống đơn xử lý: vô hiệu hóa các ngắt khi thực thi wait() và signal().

I Hệ thống đa xử lý: dùng chờ đợi bận (spinlock) hay các lệnh nguyên tử (e.g compare_and_swap()).

⇒ Không hoàn toàn loại bỏ được chờ đợi bận: di chuyển chờ đợi bận vào bên trong chỉ thị wait() và signal() – thường là ngắn – nên thời gian chờ đợi bận được giảm đi.

Trang 35

Khóa chết (deadlock) và chết đói (starvation)

wait(S);

signal(Q);

signal(S);

I Chết đói: tiến trình bị ngưng (block) không hạn định (không bao giờđược xóa khỏi hàng đợi semaphore)

Trang 36

Các Bài Toán Đồng Bộ Hóa

1 Bài toánNhà sản xuất – Người tiêu dùng với vùng đệm giới hạn

(Producer–Consummer with Bounded-Buffer)

2 Bài toánBộ đọc – Bộ ghi (Readers–Writers)

3 Bài toánCác triết gia ăn tối (Dining-Philosophy)

Trang 37

Bài toán Nhà sản xuất – Người tiêu dùng

Bài Toán Nhà Sản Xuất – Người Tiêu Dùng

I Hai tiến trình (nhà SX, người TD)chia sẻ chung vùng đệm có kíchthước n (xem mô tả trong phần giới thiệu)

I Dữ liệu chia sẻ đồng bộ hóa:

I Semaphore mutex : dùng để loại trừ hỗ tương, khởi tạo bằng 1.

I Semaphore empty và full : dùng để đếm số khe trống và đầy trên bộ đệm, khởi tạo empty = n và full = 0

Trang 38

Cấu Trúc Tiến Trình Nhà Sản Xuất

Trang 39

Cấu Trúc Tiến Trình Người Tiêu Dùng

Trang 40

Bài toán Bộ đọc – Bộ ghi (Readers–Writers Problem)

Bài Toán Bộ Đọc – Bộ Ghi

I Nhiều tiến trình thực thi đồng thời cạnh tranh một đối tượng dữ liệu(tập tin, mẫu tin):

I Bộ đọc (readers) : tiến trình chỉ đọc dữ liệu.

I Bộ ghi (writers) : tiến trình đọc và ghi dữ liệu.

I Vấn đề:

I Nhiều readers có thể đọc dữ liệu chia sẻ đồng thời.

I Chỉ có 1 writer được phép truy cập dữ liệu chia sẻ tại 1 thời điểm.

⇒ Các bộ đọc, ghi phải loại trừ hỗ tương trên các đối tượng chia sẻ

Trang 41

Giải Pháp

I Dữ liệu chia sẻ:

I Đối tượng dữ liệu chia sẻ (tập tin, mẫu tin, ).

I Biến read_count : đếm số tiến trình đang đọc, khởi tạo bằng 0.

I Semaphore mutex : dùng để loại trừ hỗ tương khi cập nhật biến

read_count , khởi tạo bằng 1.

I Semaphore rw_mutex : dùng để loại trừ hỗ tương cho các bộ ghi, khởi tạo bằng 1 Semaphore này cũng được sử dụng bởi các bộ đọc đầu tiên vào vùng tương trục và bộ đọc cuối cùng ra khỏi vùng tương trục.

Trang 42

Cấu Trúc Các Tiến Trình Đọc – Ghi

read_count++;

if (read_count == 1) wait(rw_mutex);

signal(mutex);

reading is performed

wait(mutex);

read_count ;

if (read_count == 0) signal(rw_mutex);

signal(mutex);

} while ( true );

Trang 43

Bài toán Năm triết gia ăn tối

Bài Toán Năm Triết Gia Ăn Tối

I Các triết giangồi suy nghĩ,không giao tiếp

với các triết gia khác

I Khi đói, họ sẽ cố gắng lấy 2 chiếc đũa(lần

lượt mỗi chiếc) gần nhất để ăn cơm

I Một triết giakhông thể lấy đũa đang được

dùngbởi triết gia khác

I Khi có được 2 chiếc đũa, triết gia sẽ ăn và

đặt đũa xuống sau khi ăn xong; sau đó suy

nghĩ tiếp

222 Chapter 5 Process Synchronization

RICE

Figure 5.13 The situation of the dining philosophers.

• In applications where it is easy to identify which processes only read shared data and which processes only write shared data.

• In applications that have more readers than writers This is because reader– writer locks generally require more overhead to establish than semaphores

or mutual-exclusion locks The increased concurrency of allowing multiple readers compensates for the overhead involved in setting up the reader– writer lock.

5.7.3 The Dining-Philosophers Problem Consider five philosophers who spend their lives thinking and eating The philosophers share a circular table surrounded by five chairs, each belonging

to one philosopher In the center of the table is a bowl of rice, and the table is laid with five single chopsticks (Figure 5.13) When a philosopher thinks, she does not interact with her colleagues From time to time, a philosopher gets hungry and tries to pick up the two chopsticks that are closest to her (the chopsticks that are between her and her left and right neighbors) A philosopher may pick

up only one chopstick at a time Obviously, she cannot pick up a chopstick that

is already in the hand of a neighbor When a hungry philosopher has both her chopsticks at the same time, she eats without releasing the chopsticks When she is finished eating, she puts down both chopsticks and starts thinking again Thedining-philosophers problemis considered a classic synchronization problem neither because of its practical importance nor because computer scientists dislike philosophers but because it is an example of a large class

of concurrency-control problems It is a simple representation of the need

to allocate several resources among several processes in a deadlock-free and starvation-free manner.

One simple solution is to represent each chopstick with a semaphore A philosopher tries to grab a chopstick by executing a wait() operation on that semaphore She releases her chopsticks by executing the signal() operation

on the appropriate semaphores Thus, the shared data are

3 4 0

I Dữ liệu chia sẻ: semaphorechopstick[5], khởi tạo bằng 1

TS Trần Công Án (Khoa CNTT&TT) [CT107] Ch5 Đồng Bộ Hóa Tiến Trình 43

Định dạng
Số trang	56
Dung lượng	1,21 MB