Báo Cáo Giữa Kỳ Hệ Điều Hành: Mô Phỏng Quản Lý Bộ Nhớ Ảo | Hệ điều hành | Trường Đại học Bách khoa Hà Nội
Trong thời đại ngày nay, với sự phát triển vượt bậc của công nghệ, máy tính và hệ điều hành đã trở thành một phần không thể thiếu trong cuộc sống. Một trong nhữngkhía cạnh quan trọng nhất trong hoạt động của hệ điều hành là khả năng quản lý bộnhớ hiệu quả. Bộ nhớ ảo (Virtual Memory) đóng vai trò trọng yếu trong việc tối ưuhóa tài nguyên bộ nhớ vật lý, giúp hệ điều hành xử lý đồng thời nhiều tiến trình và chương trình một cách trơn tru. Tài liệu được sưu tầm và soạn thảo dưới dạng file PDF để gửi tới các bạn cùng tham khảo, ôn tập đầy đủ kiến thức, chuẩn bị cho các buổi học thật tốt. Mời bạn đọc đón xem!
Môn: Hệ điều hành hust 26 tài liệu
Trường: Đại học Bách Khoa Hà Nội 4.9 K tài liệu
Tác giả:
Preview text:
ĐẠI HỌC BÁCH KHOA HÀ NỘI
TRƯỜNG ĐIỆN – ĐIỆN TỬ -----🙞🙜🕮🙞🙜-----
BÁO CÁO BÀI TẬP LỚN HỆ ĐIỀU HÀNH
ĐỀ TÀI: MÔ PHỎNG QUẢN LÝ BỘ NHỚ ẢO
Giảng viên hướng dẫn: TS. Nguyễn Thanh Bình Họ tên sinh viên MSSV Lớp Nguyễn Minh Quân 20210705 Điện tử 09 - K66 Lê Văn Dũng 20213837 Điện tử 06 - K66 Trần Nhật Minh 20214012 Điện tử 03 - K66 Hoàng Tiến Mạnh 20213992 Điện tử 03 - K66
Hà Nội, 9/2024 MỤC LỤC
MỤC LỤC................................................................................................................2
DANH MỤC HÌNH VẼ...........................................................................................4
DANH MỤC BẢNG BIỂU.....................................................................................5
MỞ ĐẦU...................................................................................................................6
CHƯƠNG 1: CƠ SỞ LÝ THUYẾT.......................................................................7
1.1. Bộ nhớ ảo............................................................................................................7
1.1.1. Khái niệm................................................................................................7
1.1.2. Ý nghĩa của bộ nhớ ảo.............................................................................7
1.1.3. Ứng dụng của bộ nhớ ảo trong hệ thống thực tế.....................................8
1.2. Các khái niệm liên quan.....................................................................................8
1.2.1. Bảng trang (Page Table)..........................................................................8
1.2.2. Khung trang (Frame)...............................................................................9
1.2.3. Lỗi trang (Page Fault)..............................................................................9
1.2.4. Mối liên hệ giữa bộ nhớ vật lý và bộ nhớ ảo...........................................9
1.3. Phân trang và quản lý bộ nhớ ảo......................................................................10
1.3.1. Phân trang (Paging)...............................................................................10
1.3.2. Chính sách phân trang...........................................................................10
1.4. Các thuật toán thay thế trang............................................................................11
1.4.1. FIFO (First-in, First-out).......................................................................11
1.4.2. LRU (Least Recently Used)..................................................................11
1.4.3. Clock.....................................................................................................12
CHƯƠNG 2: THIẾT KẾ VÀ TRIỂN KHAI......................................................14
2.1. Tổng quan.........................................................................................................14
2.1.1. Dữ liệu đầu vào.....................................................................................14
2.1.2. Mô phỏng hệ thống quản lý bộ nhớ ảo..................................................14
2.1.3. Kết quả đầu ra........................................................................................14
2.2. Các thành phần của hệ thống............................................................................14
2.2.1. Giao diện người dùng............................................................................14
2.2.2. Thành phần xử lý chính:........................................................................15
2.2.3. Thành phần tạo kết quả mô phỏng........................................................16
2.2.4. Các thư viện và định nghĩa....................................................................16
2.3. Luồng hoạt động...............................................................................................16
CHƯƠNG 3: KẾT QUẢ VÀ ĐÁNH GIÁ...........................................................18
3.1. Số lỗi trang theo kích thước trang....................................................................18
3.2. Chính sách phân trang và thuật toán thay thế trang..........................................21
3.2.1. Kết quả..................................................................................................21
3.2.2. So sánh..................................................................................................23
KẾT LUẬN............................................................................................................24
TÀI LIỆU THAM KHẢO.....................................................................................25 DANH MỤC HÌNH VẼ
Hình 2.1: Giao diện bắt đầu............................................................................14
Hình 2.2: Giao diện kết quả............................................................................14
Hình 3.1:Demand + FIFO...............................................................................17
Hình 3.2:PRE + FIFO.....................................................................................17
Hình 3.3:Demand + LRU................................................................................18
Hình 3.4:PRE + LRU......................................................................................18
Hình 3.5:Demand + Clock..............................................................................19
Hình 3.6:PRE + Clock.....................................................................................19
Hình 3.7:Biểu đồ so sánh số lỗi trang giữa các chính sách phân trang
(Demand Paging, Prepaging) và các thuật toán thay thế trang (FIFO, LRU, Clock).
.................................................................................................................................20
DANH MỤC BẢNG BIỂU
Bảng 3-1:Số lỗi trang khi sử dụng Demand Paging.......................................21
Bảng 3-2:Số lỗi trang khi sử dụng Pre-Paging...............................................21 MỞ ĐẦU
Trong thời đại ngày nay, với sự phát triển vượt bậc của công nghệ, máy tính và hệ
điều hành đã trở thành một phần không thể thiếu trong cuộc sống. Một trong những
khía cạnh quan trọng nhất trong hoạt động của hệ điều hành là khả năng quản lý bộ
nhớ hiệu quả. Bộ nhớ ảo (Virtual Memory) đóng vai trò trọng yếu trong việc tối ưu
hóa tài nguyên bộ nhớ vật lý, giúp hệ điều hành xử lý đồng thời nhiều tiến trình và
chương trình một cách trơn tru.
Dự án "Mô phỏng quản lý bộ nhớ ảo" được thực hiện nhằm giúp nhóm sinh viên
chúng em hiểu rõ hơn về cách hoạt động của bộ nhớ ảo, các thuật toán thay thế
trang, cũng như những yếu tố ảnh hưởng đến hiệu quả của hệ thống khi sử dụng bộ
nhớ ảo. Qua đó, bài tập lớn không chỉ cung cấp kiến thức lý thuyết mà còn giúp
chúng em thực hành và mô phỏng thực tế, từ đó có thể áp dụng vào các bài toán thực tiễn sau này.
CHƯƠNG 1:CƠ SỞ LÝ THUYẾT 1.1. Bộ nhớ ảo 1.1.1. Khái niệm
Bộ nhớ ảo (Virtual Memory) là một kỹ thuật quản lý bộ nhớ được sử dụng
trong hệ điều hành, giúp tạo ra một không gian địa chỉ ảo cho mỗi tiến trình, lớn
hơn không gian bộ nhớ vật lý thực sự của hệ thống. Điều này cho phép mỗi tiến
trình có cảm giác như chúng có toàn bộ bộ nhớ máy tính để sử dụng mà không cần
phải quan tâm đến giới hạn vật lý của bộ nhớ.
Bộ nhớ ảo sử dụng các cơ chế ánh xạ địa chỉ để chuyển đổi giữa địa
chỉ logic (do CPU tạo ra) và địa chỉ vật lý (RAM thực sự).
Khi một tiến trình yêu cầu dữ liệu mà không nằm trong RAM, hệ điều
hành sử dụng kỹ thuật hoán đổi (swapping) để tải dữ liệu từ ổ đĩa vào bộ nhớ vật lý.
1.1.2. Ý nghĩa của bộ nhớ ảo
Bộ nhớ ảo đóng vai trò quan trọng trong hệ điều hành và hệ thống máy tính
hiện đại nhờ những lợi ích sau:
Khả năng mở rộng bộ nhớ:
- Cho phép các chương trình có kích thước lớn hơn bộ nhớ vật lý vẫn có thể chạy được.
- Bằng cách sử dụng một phần ổ đĩa làm không gian hoán đổi (swap
space), bộ nhớ ảo cung cấp một cách để "mở rộng" bộ nhớ thực tế. Cách ly tiến trình:
Bộ nhớ ảo tạo ra không gian địa chỉ ảo riêng biệt cho mỗi tiến trình,
đảm bảo rằng các tiến trình không truy cập nhầm vào bộ nhớ của nhau
cũng như ránh được lỗi ghi đè và tăng tính bảo mật. Hỗ trợ đa nhiệm:
- Nhiều tiến trình có thể chạy đồng thời mà không cần toàn bộ dữ liệu
của chúng phải nằm trong RAM cùng một lúc.
- Bộ nhớ ảo cho phép hệ điều hành nạp các phần cần thiết của tiến
trình vào RAM khi cần thiết, nhờ cơ chế phân trang (paging) hoặc
phân đoạn (segmentation). Hiệu suất tối ưu:
Bộ nhớ ảo cho phép hệ điều hành sử dụng RAM hiệu quả hơn, bằng
cách chỉ tải những phần cần thiết của chương trình vào RAM (demand paging).
Giảm thiểu lãng phí bộ nhớ và cải thiện hiệu suất tổng thể của hệ thống.
1.1.3. Ứng dụng của bộ nhớ ảo trong hệ thống thực tế
Bộ nhớ ảo được ứng dụng rộng rãi trong các hệ điều hành hiện đại để đáp ứng
nhu cầu của cả người dùng thông thường và các ứng dụng phức tạp. Các ứng dụng cụ thể bao gồm:
Hỗ trợ lập trình viên:
- Lập trình viên không cần phải lo lắng về kích thước bộ nhớ vật lý của hệ thống.
- Có thể viết các chương trình lớn mà không phải tính toán xem chúng
sẽ sử dụng vùng nhớ nào.
Đa nhiệm và quản lý nhiều tiến trình:
- Cho phép hệ điều hành chạy đồng thời nhiều tiến trình mà không cần
lo lắng về giới hạn bộ nhớ vật lý.
- Hệ điều hành sử dụng bảng trang (Page Table) và cơ chế thay thế
trang (Page Replacement Algorithms) để quản lý tài nguyên bộ nhớ.
Hỗ trợ các hệ thống máy tính hiện đại:
- Quản lý các tiến trình phức tạp như trình biên dịch, trình duyệt web,
và các chương trình đồ họa.
- Xử lý các ứng dụng đa phương tiện yêu cầu bộ nhớ lớn (như chỉnh sửa video và chơi game). Tăng tính bảo mật:
Bộ nhớ ảo cách ly không gian địa chỉ của các tiến trình, ngăn chặn
các lỗi xâm phạm hoặc tấn công từ các tiến trình khác.
1.2. Các khái niệm liên quan
1.2.1. Bảng trang (Page Table)
Bảng trang là một cấu trúc dữ liệu được hệ điều hành sử dụng để ánh
xạ giữa địa chỉ ảo (logical address) của một tiến trình và địa chỉ vật lý
(physical address) trong bộ nhớ thực.
Mỗi tiến trình có một bảng trang riêng, trong đó mỗi mục (entry) đại
diện cho một trang (page) của tiến trình và chứa thông tin ánh xạ đến
một khung trang (frame) trong bộ nhớ vật lý.
Bảng trang bao gồm các thành phần chính:
- Page Number (Số trang): Số thứ tự của trang trong không gian địa chỉ ảo.
- Frame Number (Số khung trang): Số thứ tự khung trang tương
ứng trong bộ nhớ vật lý.
- Validity Bit (Bit hợp lệ):
1: Trang đang nằm trong bộ nhớ vật lý.
0: Trang không nằm trong bộ nhớ vật lý (có thể nằm
trong swap space hoặc chưa được nạp).
Bảng trang có vai trò:
- Giúp hệ điều hành xác định vị trí thực tế của một trang trong bộ
nhớ vật lý hoặc không gian hoán đổi (swap space).
- Hỗ trợ cách ly giữa các tiến trình bằng cách cung cấp bảng
trang riêng biệt cho từng tiến trình.
1.2.2. Khung trang (Frame)
Frame là đơn vị lưu trữ trong bộ nhớ vật lý. Bộ nhớ vật lý được chia
thành các khung trang có kích thước cố định, và mỗi khung trang có thể
chứa dữ liệu của một trang từ bộ nhớ ảo.
Kích thước của khung trang bằng với kích thước của một trang trong
bộ nhớ ảo. Khi một trang được nạp vào bộ nhớ, nó sẽ được ánh xạ vào một khung trang trống.
Giúp tổ chức bộ nhớ vật lý theo các khối cố định, dễ dàng quản lý và
ánh xạ với các trang trong bộ nhớ ảo, bên cạnh đó tối ưu hóa sử dụng
bộ nhớ bằng cách nạp trang khi cần thiết.
1.2.3. Lỗi trang (Page Fault)
Page Fault xảy ra khi một tiến trình yêu cầu truy cập một trang không
có trong bộ nhớ vật lý (RAM). Trang này có thể nằm trong không gian
hoán đổi (swap space) hoặc chưa được nạp.
Quy trình xử lý Page Fault:
- Hệ điều hành tạm dừng tiến trình đang thực thi.
- Xác định vị trí của trang bị thiếu trong không gian hoán đổi hoặc tệp nguồn.
- Tìm một khung trang trống trong bộ nhớ vật lý để nạp trang vào.
Nếu không có khung trống, áp dụng thuật toán thay thế trang để giải phóng khung.
- Cập nhật bảng trang để ánh xạ địa chỉ ảo của trang với khung trang mới.
- Tiếp tục thực thi tiến trình.
Lỗi trang làm giảm hiệu suất vì hệ điều hành cần thời gian để tải trang
từ ổ đĩa vào RAM. Số lượng lỗi trang là một thước đo quan trọng để
đánh giá hiệu quả của quản lý bộ nhớ ảo.
1.2.4. Mối liên hệ giữa bộ nhớ vật lý và bộ nhớ ảo Nguyên lý hoạt động:
Địa chỉ ảo (Virtual Address):
- Được CPU tạo ra khi tiến trình yêu cầu truy cập dữ liệu. - Bao gồm:
Page Number: Xác định trang cần truy cập.
Offset: Xác định vị trí dữ liệu bên trong trang.
Địa chỉ vật lý (Physical Address):
- Là địa chỉ thực trong RAM, bao gồm số khung trang (Frame Number) và offset.
Vai trò của bộ nhớ ảo:
- Cho phép ánh xạ giữa địa chỉ ảo và địa chỉ vật lý thông qua bảng trang.
- Cung cấp cảm giác "bộ nhớ lớn hơn" bằng cách sử dụng ổ đĩa để
lưu trữ các trang không nằm trong RAM.
Quy trình ánh xạ địa chỉ:
- CPU tạo địa chỉ ảo và gửi nó tới MMU (Memory Management Unit).
- MMU sử dụng bảng trang để tìm địa chỉ vật lý tương ứng:
Nếu trang hợp lệ và nằm trong RAM, MMU trả về địa chỉ vật lý.
Nếu trang không hợp lệ (Page Fault), hệ điều hành xử lý và cập nhật bảng trang.
- CPU sử dụng địa chỉ vật lý để truy cập dữ liệu trong RAM.
1.3. Phân trang và quản lý bộ nhớ ảo
1.3.1. Phân trang (Paging)
Phân trang là phương pháp chia nhỏ không gian địa chỉ ảo và bộ nhớ
vật lý thành các đơn vị có kích thước bằng nhau gọi là trang (page) và khung trang (frame).
Phân trang giúp loại bỏ sự lãng phí bộ nhớ (internal fragmentation)
cũng như dễ dàng ánh xạ giữa địa chỉ ảo và địa chỉ vật lý.
1.3.2. Chính sách phân trang Demand Paging:
- Trang chỉ được nạp vào bộ nhớ vật lý khi có yêu cầu truy cập. - Ưu điểm:
Tiết kiệm bộ nhớ vật lý vì chỉ nạp các trang cần thiết.
Phù hợp với các chương trình có nhiều phần mã không được sử dụng thường xuyên. - Nhược điểm:
Có thể gây ra nhiều lỗi trang nếu tiến trình yêu cầu nhiều trang liên tiếp. Prepaging:
- Ngoài việc nạp trang yêu cầu, hệ điều hành còn nạp thêm một số trang liền kề. - Ưu điểm:
Giảm số lỗi trang nếu tiến trình truy cập tuần tự các trang. - Nhược điểm:
Tiêu tốn bộ nhớ vật lý hơn Demand Paging.
1.4. Các thuật toán thay thế trang
1.4.1. FIFO (First-in, First-out)
Cách hoạt động của thuật toán FIFO
- Khi một trang cần được nạp vào bộ nhớ nhưng không còn đủ
chỗ, hệ điều hành sẽ chọn trang đã vào bộ nhớ lâu nhất (tức là
trang được nạp vào đầu tiên) để thay thế, bất kể trang đó có đang
được sử dụng hay không.
- Bộ nhớ duy trì một hàng đợi các trang theo thứ tự thời gian mà
chúng được nạp vào. Khi một trang mới cần thêm vào, trang ở
đầu hàng đợi sẽ bị loại bỏ để nhường chỗ cho trang mới. Ưu điểm của FIFO
- Dễ dàng triển khai: Vì chỉ cần theo dõi thứ tự các trang được nạp
vào, FIFO dễ dàng áp dụng trong các hệ thống đơn giản.
- Hiệu quả trong một số trường hợp: Trong trường hợp hệ thống
chỉ sử dụng ít trang hoặc có mô hình truy cập đơn giản, FIFO có
thể hoạt động hiệu quả.
Nhược điểm của FIFO
- Hiệu ứng Belady: Một trong những hạn chế lớn của FIFO là hiệu
ứng Belady, khi tăng kích thước bộ nhớ có thể dẫn đến tăng số
lần thiếu trang (page faults), điều này trái ngược với trực giác.
- Không phân biệt trang hay sử dụng: FIFO không quan tâm đến
tần suất hoặc thời gian gần đây của việc sử dụng trang. Có thể
trang cần bị thay thế vẫn đang được sử dụng thường xuyên, gây
ra tình trạng thiếu trang nhiều hơn002E
1.4.2. LRU (Least Recently Used)
Cách hoạt động của thuật toán LRU:
- Kiểm tra trang cần nạp: Khi cần nạp một trang mới vào bộ nhớ,
kiểm tra xem nó có sẵn trong bộ nhớ hay không.
Nếu có sẵn: Đưa trang đó lên vị trí "được sử dụng gần đây nhất".
Nếu không có: Tiến hành thay thế trang.
- Thay thế trang ít sử dụng gần nhất: Khi bộ nhớ đầy và cần nạp
trang mới, trang ít được sử dụng gần nhất sẽ bị thay thế. Điều
này có thể được thực hiện bằng cách:
Duy trì một danh sách hoặc hàng đợi, trong đó các trang
được sắp xếp theo thời gian sử dụng.
Trang nào lâu nhất không sử dụng sẽ nằm cuối danh sách và sẽ bị thay thế.
- Cập nhật danh sách sử dụng: Mỗi khi một trang được truy cập,
cập nhật danh sách để đưa trang đó lên đầu (vị trí "sử dụng gần đây nhất").
Ưu và Nhược điểm của LRU: - Ưu điểm:
Tối ưu hóa tốt hơn so với FIFO trong hầu hết các trường
hợp vì nó dự đoán rằng các trang ít được sử dụng sẽ tiếp
tục ít được sử dụng.
Giảm số lần lỗi trang so với FIFO, đặc biệt là trong các hệ
thống thực thi đa nhiệm. - Nhược điểm:
Tốn kém tài nguyên tính toán hơn so với FIFO, đặc biệt
nếu thực hiện bằng cách duy trì danh sách sắp xếp các trang.
Khó thực hiện trên phần cứng do cần theo dõi thời gian sử dụng của mỗi trang. 1.4.3. Clock 1. Cấu trúc dữ liệu
Danh sách vòng tròn (circular list): Lưu trữ các khung trang
(frames) hiện có trong bộ nhớ.
Bit tham chiếu (Reference Bit):
- Được gắn với mỗi khung trang, biểu thị trạng thái gần đây của trang.
- Ban đầu, tất cả các bit tham chiếu được khởi tạo là 0.
Con trỏ vòng (Clock Hand): Duyệt qua danh sách các khung trang để tìm khung thay thế.
2. Nguyên tắc hoạt động
Trường hợp 1: Khi một trang được truy cập:
Nếu trang đã có trong bộ nhớ: đặt bit tham chiếu của khung chứa
trang đó thành 1 (biểu thị trang vừa được sử dụng).
Trường hợp 2: Khi một trang mới cần nạp vào và bộ nhớ đã đầy:
- Con trỏ vòng bắt đầu quét các khung trang theo thứ tự.
- Với mỗi khung trang được kiểm tra:
Nếu bit tham chiếu = 0:
Khung trang này sẽ bị thay thế bởi trang mới.
Thay thế hoàn tất, dừng quá trình.
Nếu bit tham chiếu = 1:
Đặt lại bit tham chiếu = 0.
Di chuyển con trỏ vòng đến khung tiếp theo.
- Quy trình lặp lại cho đến khi tìm thấy một khung trang có bit tham chiếu bằng 0.
CHƯƠNG 2:THIẾT KẾ VÀ TRIỂN KHAI 2.1. Tổng quan
2.1.1. Dữ liệu đầu vào
Hai tệp dữ liệu: plist.txt (danh sách tiến trình) và ptrace.txt (truy cập bộ nhớ của tiến trình).
Các chính sách phân trang và thay thế trang được chọn bởi người dùng thông qua giao diện
2.1.2. Mô phỏng hệ thống quản lý bộ nhớ ảo
Quản lý và phân phối tài nguyên bộ nhớ vật lý và bộ nhớ ảo.
Xử lý lỗi trang bằng cách sử dụng các thuật toán thay thế trang (FIFO, LRU, Clock).
Mô phỏng chính sách phân trang (Demand Paging, Prepaging)
2.1.3. Kết quả đầu ra
Hiển thị trực quan kết quả mô phỏng thông qua các biểu đồ và giao diện người dùng.
2.2. Các thành phần của hệ thống
2.2.1. Giao diện người dùng menuGUI.py:
Cung cấp giao diện để người dùng:
Chọn tệp dữ liệu plist.txt và ptrace.txt.
Lựa chọn chính sách phân trang (Demand Paging, Prepaging).
Lựa chọn thuật toán thay thế trang (FIFO, LRU, Clock).
Thiết lập kích thước trang (Page Size).
Hình 2.1: Giao diện bắt đầu resultsGUI.py:
Hiển thị kết quả mô phỏng:
Tổng quan thông tin cấu hình (số tiến trình, chính sách được chọn, lỗi trang, v.v.).
Biểu đồ so sánh hiệu suất các chính sách phân trang và thay thế trang.
Hình 2.2: Giao diện kết quả
2.2.2. Thành phần xử lý chính: simulator.cpp:
Thực hiện toàn bộ logic mô phỏng:
- Quản lý bộ nhớ vật lý và ảo. - Xử lý lỗi trang.
- Thực thi các thuật toán thay thế trang (FIFO, LRU, Clock).
- Ánh xạ địa chỉ ảo sang địa chỉ vật lý.
Đọc và xử lý dữ liệu từ plist.txt và ptrace.txt.
2.2.3. Thành phần tạo kết quả mô phỏng generateResults.py:
Tổng hợp kết quả từ quá trình mô phỏng trong simulator.cpp.
Tạo các biểu đồ kết quả mô phỏng:
- Plot 1: So sánh số lỗi trang theo kích thước trang.
- Plot 2: So sánh số lỗi trang giữa các chính sách phân trang và thay thế trang.
2.2.4. Các thư viện và định nghĩa simClass.h:
Định nghĩa các cấu trúc dữ liệu chính như Page, PageTableEntry,
Process, MemoryEntry, và ProcessTraceEntry. simConstants.h:
Định nghĩa các hằng số như kích thước bộ nhớ, các loại thuật toán
(FIFO, LRU, Clock), và chính sách phân trang (Demand, Prepaging). simInput.h:
Xử lý dữ liệu đầu vào từ các tệp plist.txt và ptrace.txt.
2.3. Luồng hoạt động
Bước 1: Giao diện chọn cấu hình (menuGUI.py) Người dùng chọn:
Tệp dữ liệu đầu vào: plist.txt và ptrace.txt.
Chính sách phân trang: Demand Paging hoặc Prepaging.
Thuật toán thay thế trang: FIFO, LRU, Clock.
Kích thước trang: 1, 2, 4, 8, 16, hoặc 32 KB.
Dữ liệu đầu ra được chuyển cho bước tiếp theo.
Bước 2: Mô phỏng (simulator.cpp)
Mô phỏng quản lý bộ nhớ:
Đọc và phân tích tệp đầu vào.
Xử lý lỗi trang và thay thế trang bằng thuật toán được chọn.
Kết quả mô phỏng (số lỗi trang, thông tin tiến trình) được trả về cho generateResults.py.
Bước 3: Tạo kết quả (generateResults.py)
Tổng hợp kết quả mô phỏng từ simulator.cpp.
Tạo biểu đồ trực quan:
Biểu đồ 1: So sánh lỗi trang theo kích thước trang.
Biểu đồ 2: So sánh lỗi trang giữa các chính sách phân trang và thay thế trang.
Bước 4: Hiển thị kết quả (resultsGUI.py) Giao diện hiển thị:
Tổng quan thông tin mô phỏng.
Các biểu đồ trực quan.
Cấu trúc file hệ thống như sau: ├── Data/ │ ├── plist.txt # Danh sách tiến trình │ ├── ptrace.txt
# Truy cập bộ nhớ của tiến trình ├── Plots/ # Thư mục lưu biểu đồ │ ├── plot1.png
# Biểu đồ 1: Lỗi trang vs Kích thước trang │ ├── plot2.png
# Biểu đồ 2: So sánh chính sách ├── menuGUI.py
# Giao diện chọn cấu hình ├── resultsGUI.py
# Giao diện hiển thị kết quả ├── generateResults.py
# Tổng hợp kết quả và tạo biểu đồ ├── simulator.cpp # Logic mô phỏng chính ├── simClass.h
# Định nghĩa các lớp dữ liệu ├── simConstants.h # Hằng số hệ thống ├── simInput.h
# Xử lý dữ liệu đầu vào ├── driver.py
# Điều khiển luồng hoạt động
CHƯƠNG 3:KẾT QUẢ VÀ ĐÁNH GIÁ
3.1. Số lỗi trang theo kích thước trang Hình 3.3:Demand + FIFO Hình 3.4:PRE + FIFO Hình 3.5:Demand + LRU Hình 3.6:PRE + LRU
Hình 3.7:Demand + Clock Hình 3.8:PRE + Clock
Tài liệu liên quan:
-
Tìm hiểu về Hệ điều hành Linux và Driver | Môn Hệ điều hành - Đại học Bách Khoa Hà Nội
37 19 -
Bài Tập Lớn: Quản Lý Bộ Nhớ Ngoài | Môn Hệ điều hành - Đại học Bách Khoa Hà Nội
36 18 -
Đề cương ôn tập giữa kỳ Môn Hệ điều hành | Đại học Bách Khoa Hà Nội
45 23 -
Ôn Tập Môn Hệ điều hành | Đại học Bách Khoa Hà Nội
40 20