Bài giảng lập trình hệ điều hành chương 8 virtual memory

• Toàn bộ chương trình không phải được sử dụng cùng một lúc • Khả năng nạp chương trình từng phần vào bộ nhớ để thực thi: o Giải phóng sự ràng buộc với giới hạn của bộ nhớ thực o Nhiều c

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

Đại học Cần Thơ

Giảng viên: Hà Duy An

• Các mã lệnh phải trong bộ nhớ để thực thi, nhưng toàn bộ chương trình hiếm khi được dùng

o Các lệnh xử lý lỗi, các cấu trúc dữ liệu lớn, các tùy chọn và tínhnăng ít dùng

• Toàn bộ chương trình không phải được sử dụng cùng một lúc

• Khả năng nạp chương trình từng phần vào bộ nhớ để thực thi:

o Giải phóng sự ràng buộc với giới hạn của bộ nhớ thực

o Nhiều chương trình có thể thực thi đồng thời

o Thao tác I/O để nạp và hoán vị tiến trình cần ít hơn

• Bộ nhớ ảo (Virtual memory): tách biệt bộ nhớ luận lý của người

dùng ra khỏi bộ nhớ vật lý:

o Chỉ một phần của chương trình cần ở trong bộ nhớ để thực thi  không gian địa chỉ luận lý có thể lớn hơn nhiều so với không gian địa chỉ vật lý.

o Cho phép không gian địa chỉ có thể trải rộng ra với các khoảng trống dành cho việc sử dụng trong tương lai

o Các thư viện chia sẽ hay bộ nhớ chia sẽ có thể được cài đặt bằng cách ánh xạ đối tượng cần chia sẽ vào trong không gian luận lý của các tiến trình

o Các trang có thể được chia sẽ trong suốt thời gian tạo tiến trình với lời gọi hệ thống fork() => tăng tốc độ tạo tiến trình

o Nhiều chương trình có thể được đưa vào bộ nhớ để thực thi đồng thời

o Cần ít thao tác I/O hơn khi nạp hay khi hoán vị

• Bộ nhớ ảo có thể được cài đặt:

o Phân trang theo yêu cầu

o Phân đoạn theo yêu cầu

• Mang toàn bộ tiến trình vào trong bộ nhớ (phân trang thôngthường)

• Hay chỉ mang một trang vào bộ nhớ khi cần thiết (phân trang theo

yêu cầu – Demand Paging)

o Cần ít thao tác I/O hơn

o Cần ít bộ nhớ vật lý hơn

o Rút ngắn thời gian đáp ứng

o Phục vụ nhiều người dùng hơn

• Khi cần một trang ⇒ tham khảo tới nó

o Tham khảo không hợp lệ ⇒ thoát

o Trang không có trong bộ nhớ ⇒ đem nó vào bộ nhớ

• Lazy swapper (bộ hoán vị lười) – không bao giờ hoán vị một trang

vào bộ nhớ trừ khi trang đó cần dùng

o Swapper xử lý với các trang gọi là pager

• Kết hợp với mỗi mục từ trong bảng trang một bit valid/invalid (v (1)

⇒in-memory, i (0) ⇒ not-in-memory)

• Khởi đầu bit valid/invalid của mọi mục từ được đặt là i

• Ví dụ về thực trạng một bảng trang:

• Trong tiến trình dịch địa chỉ, nếu

bit valid/invalid trong một mục

từ của bảng trang = 0 ⇒

có lỗi trang (Page Fault).

v v v v i

i i

….

Frame # valid‐invalid bit

page table

• Nếu có một tham khảo đến một trang, tham khảo đầu tiên đến

trang đó luôn được giao cho hệ điều hành xử lý: lỗi trang

• Các bước xử lý lỗi trang của HĐH:

o Hệ điều hành sẽ nhìn vào internal table (chứa trong PCB)

để xác định:

• Tham khảo không hợp lệ ⇒ kết thúc tiến trình.

• Hay là trang không có trong bộ nhớ => mang nó vào

1 Tìm một khung trang còn trống

2 Hoán vị trang vào khung trang

3 Thiết lập lại bảng trang bằng cách đặt bit kiểm tra = v

4 Khởi động lại chỉ thị đã bị ngắt bởi lỗi trang

• Khi tiến trình bắt đầu được thực thi – không có trang nào trong

bộ nhớ, lỗi trang (page fault):

o Tham khảo đến lệnh đầu tiên của tiến trình

o Mỗi trang của tiến trình được truy cập lần đầu

 Pure demand paging

• Một lệnh có thể truy cập nhiều trang cùng lúc => nhiều lỗi trang

o Chương trình khuynh hướng tham chiếu cục bộ

• Phần cứng hỗ trợ phân trang theo yêu cầu:

o Bảng trang: valid/invalid bit

o Bộ nhớ phụ (thiết bị hoán vị với không gian hoán vị)

o Khởi động lại một lệnh

• Một lệnh có thể truy cập vài vị trí khác nhau:

o Lệnh move

o Lỗi trang khi đã di chuyển dữ liệu một phần?

o Nguồn và đích phủ lấp lên nhau?

• Phương pháp giải quyết:

o Truy cập thăm dò

o Lưu giữ giá trị bị ghi đè

• Các bước thực hiện phân trang theo yêu cầu:

1 Thông báo cho HĐH

2 Lưu lại các thanh ghi và trạng thái của tiến trình người dùng

3 Xác định ngắt là một lỗi trang

4 Kiểm tra tính hợp lệ của trang tham khảo, xác định vị trí của trang trên đĩa

5 Đọc trang từ đĩa vào khung trống:

a Chờ trong hàng đợi thiết bị cho đến khi yêu cầu đọc được phục vụ

b Chờ thiết bị tìm kiếm (độ trễ thời gian - latency time)

c Bắt đầu chuyển trang vào khung trống

6 Trong khi chờ đợi, cấp CPU cho người dùng khác

7 Nhận một ngắt từ hệ thống I/O đĩa (I/O completed)

8 Lưu các thanh ghi và trạng thái của tiến trình đang thực thi (của người dùng khác)

9 Xác định ngắt phát ra từ đĩa

10 Điều chỉnh bảng trang và các bảng khác có liên quan để cho thấy rằng trang bây

giờ đang nằm trong bộ nhớ

11 Chờ để được cấp phát CPU lần nữa

12 Khôi phục lại các thanh ghi, trạng thái của tiến trình, và bảng trang mới, sau đó

khởi động lại lệnh đã bị ngắt

• Tỉ lệ lỗi trang 0 ≤ p ≤ 1.0

o if p = 0 không có lỗi về trang

o if p = 1, mọi tham khảo trang đều bị lỗi

• Thời gian truy xuất thực (Effective Access Time - EAT)

EAT = (1 – p) x [memory access]

+ p x [page fault time]

• [ page fault time] = [page fault overhead] +

[swap page out ] + [swap page in] + [restart overhead] +

• Memory access time = 200 nanoseconds

• Average page-fault service time = 8 milliseconds

=> Chậm hơn 40 lần khi không dùng phân trang theo yêu cầu

• Nếu muốn truy xuất chỉ chậm hơn < 10%

220 > 200 + 7,999,800 x p

20 > 7,999,800 x p

p < 0000025

< một lỗi trang trong 400,000 lần truy xuất bộ nhớ

=> Cần giữ cho tỉ lệ lỗi trang thấp nhất có thể trong hệ thống phân trang theo yêu cầu, nếu không sự thực thi của tiến trình có thể rất chậm

• Sao chép toàn bộ ảnh của tiến trình vào không gian hoán

chuyển (swap space) vào thời gian nạp tiến trình

o Hoán vị trang vào/ra swap space

o Được dùng trong các phiên bản cũ của BSD Unix

• Lấy trang từ chương trình nhị phân trên đĩa, nhưng chỉ xóa trang (không hoán vị trang ra đĩa) khi cần khung trống

o Được dùng trong Soloris và BSD Unix hiện hành

• Điều gì xảy ra khi không còn khung trống?

• Ngăn chặn việc cấp phát bộ nhớ vượt quá mức bằng cách dùng giảipháp thay thế trang

o Chọn một trang đã được nạp và không đang được dùng, giải phóng nó bằng cách viết nội dung của nó vào không gian hoán chuyển (swap space).

o Dùng khung đã được giải phóng này để nạp trang được yêu cầu.

• Sử dụng bit modify (dirty) để làm giảm chi phí cho việc chuyển

1 Tìm vị trí của trang mong muốn trên đĩa.

2 Tìm một khung trang còn trống:

o Nếu còn khung trống, sử dụng nó

o Nếu không còn khung trống, sử dụng giải thuật thay thế trang

để tìm ra khung nạn nhân.

3 Đọc trang mong muốn vào khung trống mới tìm ra Cập nhật

lại trang và các bảng trang.

4 Tiếp tục tiến trình.

=> Có thể phải cần hai thao tác chuyển trang khi có một lỗi

trang xuất hiện -> EAT tăng

• Giải thuật cấp phát khung xác định:

o Bao nhiêu khung sẽ cấp phát cho mỗi tiến trình

• Giải thuật thay thế trang:

o Khung nào sẽ được thay thế

o Mong muốn tỉ lệ lỗi trang thấp nhất.

• Đánh giá giải thuật bằng cách chạy nó trên một chuỗi tham khảo bộ nhớ cụ thể và tính toán số lỗi về trang phát sinh.

o Chuỗi tham khảo chỉ là số hiệu của trang, không phải địa chỉ đầy đủ

o Ví dụ chuỗi tham khảo trang như sau:

7,0,1,2,0,3,0,4,2,3,0,3,0,3,2,1,2,0,1,7,0,1

• Nhận xét: khi số khung tăng lên, số lượng lỗi trang giảm

xuống một mức độ tối thiểu.

• Chuỗi tham khảo là: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

• Có 3 khung (3 trang có thể nằm trong bộ nhớ cho mỗi tiến

trình)

• 4 khung

1 2 3

1 2 3

4 1 2

5 3 4

9 page faults

1 2 3

1 2 3

5 1 2 4

5 10 page faults

• Có thể rất khác nhau với các chuỗi tham khảo trang khác nhau

• Thay thế trang kiểu FIFO ⇒ Nghịch lý Belady (Belady’s Anomaly)

o Càng nhiều khung trang ⇒ càng nhiều lỗi về trang

• Thay thế trang sẽ không được sử dụng trong một thời gian dài.

1 2 3

4

6 lỗi về trang

4 5

• Thay thế trang không đuợc dùng trong một khoảng thời gian dài nhất

• Chuỗi tham khảo trang: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

5

2 4 3

1 2 3 4

1 2

5

4

1 2 5

3

1 2

4

3

• Cài đặt bộ đếm:

o Mỗi một mục từ trong bảng trang có một bộ đếm (time-of-usedfield) , mỗi khi trang được tham khảo đến, chép nội dung củađồng hồ hệ thống vào bộ đếm này

o Khi một trang cần được thay đổi, nhìn vào các bộ đếm để quyếtđịnh trang sẽ được thay đổi

• Cài đặt stack – tạo một stack chứa các số thứ tự trang:

o Khi một trang được tham khảo:

• Di chuyển số thứ tự của nó lên đỉnh của stack => trang LRU nằm

ở đáy của stack

o Không phải tìm kiếm để thay thế trang

• LRU cần có phần cứng hỗ trợ

• Bit tham khảo (Reference Bit - RB)

o Bit tham khảo được đặt bởi phần cứng

o Mỗi trang được kết hợp với 1 bit, khởi đầu là 0

o Khi trang được tham khảo, bit này được đặt là 1

o Thực hiện thế trang có bit này là 0 (nếu có)

o Tuy nhiên chúng ta không biết thứ tự

• Giải thuật thêm vào bit tham khảo

o Ghi lại các bit tham khảo theo những thời gian đều đặn

o Dùng mục từ 8 bit (8-bits entry) cho mỗi trang

• 00000000 : trang không được dùng trong 8 chu kỳ.

• 11111111 : trang đã được dùng tại ít nhất một trong 8 chu kỳ.

Trang với số thấp nhất là trang LRU.

• Giải thuật Second- Chance

(second-chance)

• Đặt bit tham khảo là 0

• Để lại trang trong bộ nhớ

• Xét trang kế tiếp với cùng qui tắt

• Tạo bộ đếm đếm số lần một trang được truy cập.

o Ít được dùng

• Giải thuật LFU (Least Frequently Used): thay thế trang với

giá trị bộ đếm nhỏ nhất.

• Giải thuật MFU (Most Frequently Used): dựa trên lý luận là

một trang có giá trị bộ đếm là nhỏ nhất thì mới được đem vào bộ nhớ và sẽ còn được sử dụng nhiều hơn sau này.

• Mỗi tiến trình cần một số lượng khung trang tối thiểu

• Ví dụ: IBM 370 – 6 trang để xử lý lệnh SS MOVE:

o Lệnh dài 6 bytes => có thể trãi dài 2 trang

o 2 trang để xử lý from

o 2 trang để xử lý to

• Số khung tối đa là số tổng số khung có trong hệ thống

• Có hai chiến lược cấp phát khung trang chính:

o Cấp cố định

o Cấp theo độ ưu tiên

• Có nhiểu biến thể khác nhau

• Cấp công bằng - ví dụ: nếu có 100 khung trang và 5 tiến trình, thì cấp cho mỗi tiến trình 20 khung trang.

• Cấp tương xứng – cấp khung trang dựa trên kích cỡ của tiến trình.

m S

s p

a

m

s S

p s

i i

i

i

i i

frames of

number total

process of

size

59

64137

127

5

64137

101271064

2 1

2 1

s s m

• Sử dụng sơ đồ cấp phát tương xứng, nhưng thay vì sử dụng kích cỡcủa tiến trình, ta dùng độ ưu tiên.

• Nếu tiến trình Pi sinh ra lỗi về trang thì

o Chọn một khung trang của chính tiến trình này làm nạn nhân (thay thế cục bộ - local replacement)

o Chọn một khung trang của tiến trình khác có độ ưu tiên thấp hơn làm nạn nhân (thay thế toàn cục – global replacement).

• Thay thế toàn cục: tiến trình chọn một khung từ tập hợp tất cả các

khung; một tiến trình có thể lấy một khung từ tiến trình khác => cóthể ảnh hưởng đến sự thực thi trên toàn hệ thống

• Thay thế cục bộ: mỗi tiến trình chỉ có thể sử dụng từ các khung

trang mà nó được cấp phát

o Sự thực thi của mỗi tiến trình được đảm bảo độc lập

Nhưng có thể không tận dụng tốt bộ nhớ

• Nếu một tiến trình không có đủ các trang theo yêu cầu, thì tỉ lệ lỗitrang sẽ rất cao

o Bởi vì các trang trong trạng thái đang dùng, bất kỳ lỗi trang nào cũng dẫn đến thay thế một trang cần lại ngay sau đó.

o Tiến trình tiếp tục lỗi, thay thế các trang mà sẽ lại bị lỗi và phải được mang vào trở lại ngay sau đó.

o Điều này sẽ dẫn đến:

• Hiệu năng sử dụng CPU thấp.

• Hệ điều hành nghĩ rằng nó cần phải tăng mức độ đa chương lên bởi vì

bộ định thời CPU thấy rằng việc sử dụng CPU thấp.

• Tiến trình khác được thêm vào hệ thống  mỗi tiến trình nhận ít khung trang hơn  lỗi trang càng nhiều hơn.

• Thrashing ≡ tiến trình luôn bận rộn cho việc chuyển các trang ra và

vào

• Khi mức độ đa chương tăng

lên, việc sử dụng CPU cũng

tăng lên, mặc dù chậm hơn, đến

một ngưỡng cực đại.

• Nếu mức độ đa chương tiếp

tục tăng, thrashing sẽ xảy ra.

• Giải thuật thế trang cục bộ có thể giới hạn ảnh hưởng của thrashing

o Nếu một tiến trình bắt đầu thrashing, nó không được lấy cáckhung từ các tiến trình khác và gây ra thrashing cho tiến trìnhsau

o Nhưng một tiến trình thrashing có thể ảnh hưởng đến các tiếntrình không thrashing vì nó làm chậm đi hàng đợi thiết bị phân

• Để ngăn ngừa thrashing, chúng ta phải cung cấp cho tiến trình

số khung mà nó cần

o Vấn đề là làm sao biết được số khung mà tiến trình cần

o Một vài kỹ thuật được sử dụng

• Hai giải pháp ngăn ngừa thrashing

o Mô hình tập làm việc (Working set model)

o Sơ đồ tần suất lỗi trang (Page-fault frequency scheme)

• Mô hình tập làm việc bắt đầu bằng cách xem xét có bao nhiêu khungmột tiến trình đang dùng.

o Phương pháp này định nghĩa mô hình cục bộ (locality model) của việc

thực thi tiến trình.

o Một cục bộ là tập hợp các trang được dùng cùng với nhau.

o Khi một tiến trình thực thi, nó sẽ di chuyển từ cục bộ này sang cục bộ khác.

o Một chương trình nói chung được tạo thành từ một vài cục bộ khác nhau, có thể phủ lấp nhau.

• Giả sử cấp phát khung đủ cho một cục bộ

o Tiến trình sẽ lỗi (fault) cho các trang của nó đến khi các trang này trong bộ nhớ.

o Tiến trình sẽ không lỗi nữa cho đến khi nó thay đổi cục bộ.

o Nếu cấp phát số khung ít hơn kích thước cục bộ, thrashing sẽ xảy ra.

• Δ≡ cửa sổ tập làm việc (working-set window) ≡ một số lượng

cố định các tham khảo trang

o Xác định Δ tham khảo trang mới nhất

o Ví dụ: 10,000 tham khảo

• WSi (tập làm việc của tiến trình Pi) = tập hợp các trang trong

Δ tham khảo trang gần đây nhất

o Nếu trang đang được dùng, nó sẽ trong tập làm việc Nếu khôngcòn dùng nữa, nó sẽ ra khỏi tập làm việc sau Δ đơn vị thời gian

o Nếu Δ quá nhỏ: không bao quát được toàn bộ nhóm cục bộ

o Nếu Δ quá lớn: có thể đã phủ lấp vài nhóm cục bộ

o Nếu Δ = ∞⇒ ta sẽ xem xét toàn bộ chương trình

• Thuộc tính quan trọng nhất của tập làm việc là kích thước của nó.

o Gọi WSSi là kích thước tập làm việc cho tiến trình i

o D = Σ WSSi ≡ tổng số các khung cần thiết

o m là tổng số khung bộ nhớ sẵn dùng

o Nếu D > m  thrashing

• Chính sách: nếu D > m, tạm dừng một số tiến trình.

• Sử dụng bộ định thời + bit tham khảo

• Ví dụ: Δ = 10,000

o Bộ định thời phát ra ngắt mỗi 5000 tham khảo.

o Giữ trong bộ nhớ 2 bit cho một trang.

o Mỗi khi bộ định thời phát ra ngắt thì chép và xóa nội dung của các bit tham khảo.

o Khi có một lỗi trang xuất hiện, kiểm tra bit tham khảo hiện tại và 2 bit trong bộ nhớ để xác định là trang có được dùng trong khoảng 10,000 đến 15,000 tham khảo cuối cùng không.

o Nếu có ít nhất 1 trong các bit bằng 1 ⇒ trang nằm trong tập làm việc.

• Giải pháp trên không thật sự chính xác, bởi vì không thể biết đượctham khảo trang xuất hiện lúc nào trong khoảng 5,000 tham khảo

• Cải tiến: dùng 10 bits và phát ngắt mỗi 1000 tham khảo

• Thrashing được xem như là hiện tượng tỷ lệ lỗi trang cao  kiểm soát tỷ lệ lỗi trang để hạn chế thrashing.

• Page-Fault Frequency Scheme (PFF) = số lỗi trang / số chỉ

thị đã thực thi

• Nếu PFF quá cao, tiến trình cần thêm khung Ngược lại, nếu PFF quá thấp, tiến trình có quá nhiều khung.

• Đặt cận trên và dưới (upper and lower bound) cho PFF.

• Nếu PFF > cận trên, cấp thêm khung cho tiến trình Nếu không

có khung sẵn dùng  chuyển tiến trình ra ngoài.

• Nếu PFF < cận dưới  có thể lấy bớt bộ nhớ của tiến trình này.

• Copy-on-Write (COW) cho phép cả tiến trình cha và con ban

đầu chia sẻ cùng các trang trong bộ nhớ.

o Nếu một tiến trình cha hoặc con sửa đổi một trang được chia sẻ,thì chỉ trang đó được sao chép thành một bản mới Trang mớinày sẽ được đưa vào không gian địa chỉ của tiến trình đã đã sửađổi nó

• COW cho phép việc tạo tiến trình hiệu quả hơn bởi vì nó chỉ sao chép các trang bị sửa đổi.

• Được dùng bởi các nhiều HĐH, bao gồm Windows XP, Linux, Solaris