Đồ án mẫu NGUYÊN LÍ HỆ ĐIỀU HÀNH ( khoa CNTT)
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (1.05 MB, 32 trang )
ĐẠI HỌC ĐÀ NẴNG
ĐẠI HỌC BÁCH KHOA
KHOA CÔNG NGHỆ THÔNG TIN
ĐỒ ÁN
NGUYÊN LÍ HỆ ĐIỀU HÀNH
Đề tài : Tìm hiểu cơ chế liên lạc đường ống PIPE giữa các
tiến trình và mô phỏng lệnh “bc” trong Shell của Linux
GVHD
SVTH
LỚP
NHÓM
: Th.S Trần Hồ Thủy Tiên
:
: 15TCLC2
:
Đà Nẵng 12-2017
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Lời cảm ơn
Lần đầu thực hiện đồ án môn học, bước đầu làm quen với việc tự tìm hiểu tự nghiên
cứu những kiến thức chuyên môn, em không tránh khỏi những bỡ ngỡ sai sót bước
đầu. Thành công của đồ án lần này ít nhiều có sự giúp đỡ trực tiếp và gián tiếp của
thầy cô, gia đình và bạn bè.
Trước hết em xin được cảm ơn cô Trần Hồ Thủy Tiên, người đã giúp đỡ em rất
nhiều trong quá trình thực hiện đồ án. Nhờ những buổi giảng dạy bộ môn trên lớp
cùng những buổi thảo luận về đề tài đã mang lại cho em kiến thức nền tảng vững chắc
để thực hiện thành công đề tài lần này. Nếu không có sự giúp đỡ quí giá đó, em khó
lòng hoàn thiện đồ án đúng tiến độ.
Em cũng xin cảm ơn các thầy cô ở ‘Khoa Công Nghệ Thông Tin’ – Trường Đại
Học Bách Khoa – Đại Học Đà Nẵng” đã mang đến các kiến thức bổ ích cho sinh
viên chúng em, góp phần gián tiếp cho thành công của đồ án.
Em xin kính chúng cô Trần Hồ Thủy Tiên cùng các thầy cô dồi dào sức khỏe, tâm
huyết tràn đầy để tiếp tục dẫn dắt sinh viên đến những thành công vang dội mới.
Đà Nẵng, ngày 26 tháng 12 năm 2017
Sinh viên thực hiện (ký và ghi họ tên)
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Nhận xét của giáo viên hướng dẫn
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
Đà Nẵng, ngày … tháng … năm 2017
Giáo viên hướng dẫn
(ký và ghi rõ họ tên)
ThS. Trần Hồ Thủy Tiên
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Nhận xét của giáo viên phản biện
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
.................................................................................................................................................
Đà Nẵng, ngày … tháng … năm 2017
Giáo viên phản biện
(ký và ghi rõ họ tên)
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Mục lục
Mục lục...................................................................................................................1
Danh mục các hình vẽ ...........................................................................................3
Mở Đầu ..................................................................................................................4
1. Mục đích của đồ án Nguyên lí Hệ điều hành: ................................................4
2. Mục tiêu của đề tài:.........................................................................................4
3. Nội dung báo cáo: ...........................................................................................4
Chương I. TIẾN TRÌNH VÀ CƠ CHẾ LIÊN LẠC LIÊN TIẾN TRÌNH ..............5
1. Giới thiệu: .......................................................................................................5
2. Tiến trình: .......................................................................................................5
3. Hoạt động của tiến trình .................................................................................6
3.1. Khởi tạo tiến trình: ...................................................................................6
3.2. Kết thúc tiến trình: ...................................................................................7
3.3. Thực thi chương trình: .............................................................................7
4. Liên lạc giữa các tiến trình: ............................................................................7
4.1. Nhu cầu liên lạc giữa các tiến trình và các vấn đề nảy sinh: ...................7
4.2. Tín hiệu (Signals): ...................................................................................8
4.3. Pipes: ........................................................................................................8
4.4. Sockets: ....................................................................................................9
4.5. Message Queues: .....................................................................................9
4.6. Semaphores: ...........................................................................................10
4.7. Shared Memory: ....................................................................................11
Chương II. PHƯƠNG PHÁP PIPE ......................................................................12
1. Đường ống một chiều(Half-duplex): ............................................................12
1.1. Khái niệm cơ bản: ..................................................................................12
1.2. Tạo đường ống một chiều: .....................................................................13
1.3. Một vài lưu ý: ........................................................................................14
2. Đường ống đặt tên (Named pipes):...............................................................15
2.1. Khái niệm cơ bản: ..................................................................................15
2.2. Tạo một FIFO: .......................................................................................15
Chương III. MÔ PHỎNG ĐƠN GIẢN LỆNH “BC” TRONG SHELL...............15
1. Mô tả vấn đề: ................................................................................................15
2. Lệnh “bc”: .....................................................................................................16
3. Thuật toán: ....................................................................................................16
4. Chương trình: ................................................................................................17
1
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
4.1. Các hàm chính sử dụng:.........................................................................17
4.2. Cơ chế hoạt động của chương trình: ......................................................18
5. Thực thi và kết quả: ......................................................................................20
Chương IV. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN........................................20
1. Kết luận .........................................................................................................20
2. Hướng phát triển: ..........................................................................................21
Tài liệu tham khảo ..............................................................................................22
Phụ lục .................................................................................................................23
2
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Danh mục các hình vẽ
Hình I.1: Mô hình các tiến trình ............................................................................. 5
Hình I.2: Cây phả hệ của tiến trình ......................................................................... 7
Hình I.3: Các loại tín hiệu trong hệ thống. ............................................................. 8
Hình I.4: Mô tả đường ống ..................................................................................... 9
Hình I.5: Mô tả Message Queue ........................................................................... 10
Hình I.6: Mô tả Semaphore. ................................................................................. 11
Hình I.7: Mô tả Shared Memory........................................................................... 12
Hình II.1: Mô tả tiến trình và nhân sau khi một đường ống khởi tạo. .................. 12
Hình II.2: Liên lạc giữa tiến trình cha và con. ...................................................... 13
Hình II.3: Sau khi đóng các cổng thích hợp ......................................................... 13
Hình III.1: Giao diện của lệnh bc. ........................................................................ 16
Hình III.2: Sau khi khởi tạo tiến trình và đường ống. .......................................... 18
Hình III.3: Sau khi đóng các cổng không cần thiết. ............................................. 20
Hình III.4: Tính toán đơn giản .............................................................................. 20
Hình III.5: Biểu thị kí tự không hợp lệ ................................................................. 20
3
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Mở Đầu
1. Mục đích của đồ án Nguyên lí Hệ điều hành:
Nguyên lí Hệ điều hành là môn học tập trung nghiên cứu chuyên sâu về quản lí và
phân phối các tài nguyên máy tính cho các chương trình của người dùng. Môn học
chứa đựng nhiều kiến thức bổ ích cho sinh viên về các khía cạnh nằm ở lớp nền của
một hệ thống máy tính bao gồm tiến trình và giao tiếp giữa các tiến trình, cấp phát tài
nguyên, lưu trữ dữ liệu, giải quyết tắc nghẽn,… Đồ án này nhằm mục đích giúp cho
sinh viên tiếp cận và hiện thực hóa các kiến thức liên quan đến môn học Nguyên lý
Hệ điều hành đồng thời tạo điều kiện rèn luyện nâng cao các kĩ năng:
Tổng hợp các kiến thức đã học trên mọi phương diện
Tính tự chủ và tinh thần trách nhiệm trong công việc
Khả năng thiết kế và lập trình
Khả năng báo cáo bằng luận văn
Khả năng thuyết trình và bảo vệ đồ án
2. Mục tiêu của đề tài:
Từ khi các hệ điều hành hiện đại cung cấp khả năng đa chương trình, các tiến trình
không thể hoạt động độc lập với nhau nữa và phải có những phương thức cho chúng
liên lạc với nhau để đảm bảo sự toàn vẹn của hệ thống. Một đề tài tìm hiểu về vấn đề
này là cần thiết.
Đề tài “Tìm hiểu cơ chế liên lạc đường ống PIPE giữa các tiến trình và mô
phỏng lệnh “bc” trong Shell của Linux” lần này mục tiêu chính là tiếp cận và đào
sâu các kiến thức nền tảng về Nguyên lí Hệ điều hành nói chung và tiến trình cũng
như cơ chế liên lạc đường ống PIPE giữa các tiến trình nói riêng. Qua đó, một chương
trình mô phỏng nhỏ được tạo nên để giúp sinh viên nắm vững các kiến thức nêu trên,
rèn luyện kĩ năng vận dụng và hiện thực hóa các kiến thức mình học hỏi và nghiên
cứu được.
3. Nội dung báo cáo:
Báo cáo này gồm 4 chương:
Chương I: Tiến trình và cơ chế liên lạc liên tiến trình giúp ta có cái nhìn tổng quan
về tiến trình, và giao tiếp giữa chúng trong hệ điều hành Linux.
Chương II: Phương pháp PIPE làm rõ và đào sâu về cơ chế liên lạc bằng đường
ống PIPE giữa các tiến trình.
Chương III: Mô phỏng đơn giản lệnh “bc” trong Shell vận dụng các kiến thức tìm
hiểu được để xây dựng chương trình mô phỏng ứng dụng.
Chương IV: Kết luận và hướng phát triển nêu ra các thành quả đạt được và phương
hướng sắp tới của đề tài.
4
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Chương I. TIẾN TRÌNH VÀ CƠ CHẾ LIÊN LẠC LIÊN TIẾN TRÌNH
1. Giới thiệu:
Tiến trình là một trong những khái niệm trừu tượng lâu đời và quan trọng nhất của
hệ điều hành. Chúng cung cấp khả năng thực thi (ảo) cùng một lúc nhiều thao tác dù
chỉ có một CPU (central processing unit), biến CPU đó thành nhiều CPU ảo. Nếu
không có khái niệm này, hệ điều hành hiện đại đã không tồn tại.
Khi các máy tính còn sử dụng các hệ điều hành cũ, công việc được xử lí tuần tự :
Người dùng thực hiện từng câu lệnh trên màn hình cửa sổ chính, hệ điều hành liên
tục thực thi các lệnh đó cho đến khi nó thực hiện xong hay buộc phải ngừng lại khi
có yêu cầu tự chương trình buộc người dùng phải nhập vào câu lệnh hoặc thông tin
mới. Những lúc như vậy, khi nào người dùng còn chưa nhập vào, thì CPU vẫn dừng
hoạt động theo đúng nghĩa đen của nó. Không một chương trình nào khác có thể thực
thi, mọi yêu cầu khác từ hệ điều hành hoặc máy chủ đều phải đợi chừng nào con trỏ
lệnh vẫn còn nhấp nháy. Điều này tạo ra một sự phí phạm lớn khi tốc độ xử lí của
CPU ngày càng nhanh khiến thời gian đợi người người dùng nhập vào như hàng thiên
niên kỉ so với thời gian CPU xử lí các công việc.
Trong các hệ thống đa chương trình (multiprogramming) một CPU, CPU chuyển
đổi việc thực thi giữa các tiến trình rất nhanh, dành khoảng vài chục đến vài trăm
mili-giây cho mỗi tiến trình. Vì khoảng thời gian thực thi này rất ngắn, nên trong một
giây, nhiều công việc có thể được xử lí, tạo ra một ảo giác về thực thi song song. Trái
ngược với ảo giác này là các hệ thống với nhiều CPU chia sẻ chung một bộ nhớ vật
lí để tạo ra một sự song song thật sự. Việc nắm bắt nhiều hoạt động, chương trình
cùng diễn ra một lúc rất khó khăn nên qua nhiều năm, một mô hình khái niện(tiến
trình tuần tự) đã hình thành và phát triển để giúp thực thi song song dễ hiểu hơn.
2. Tiến trình:
Trong các hệ điều hành hiện đại như Linux, mọi chương trình có thể thực thi trên
máy tính và thỉnh thoảng bao gồm cả hệ điều hành được chia thành các tiến trình tuần
tự hay nói ngắn gọn là tiến trình.
Tiến trình là thực thể (instance) của các chương trình đang thực thi, chứa đựng
trong đó là các giá trị của bộ đếm chương trình (program counter), của thanh ghi
(registers) và biến. Nếu như các chương trình chỉ là những dòng lệnh và dữ liệu được
lưu trữ trên máy tính, thì tiến trình có thể được xem như là chính chương trình ấy
đang xử lí.
Hình I.1: Mô hình các tiến trình
5
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Hình (a) là một chương trình đa chương trình gồm 4 chương trình trong bộ nhớ.
Hình (b) là 4 tiến trình với mỗi tiến trình có một bộ đếm chương trình logic riêng của
nó. Do vậy chúng thực thi hoàn toàn độc lập so với nhau. Tuy nhiên chỉ có môt bộ
đếm chương trình vật lí, nên khi thực thi bộ đếm chương trình logic sẽ được nạp bộ
đếm vật lí. Khi tiến trình thực thi xong (tạm thời), thì bộ đếm vật lí được lưu trữ vào
bộ đếm logic của tiến trình tương ứng trong bộ nhớ. Còn trong hình (c), nếu xét trong
một khoảng thời gian dài thì mọi tiến trình đều thực hiện công việc, nhưng trong chỉ
có một chương trình được thực thi tại một thời điểm bất kì. Dù sử dụng mô hình nào,
trong một thời điểm bất kì chỉ có một tiến trình thực thi.
Luồng(Thread) là một bộ phận của tiến trình. Nó là các tiểu trình (microprocess)
nằm bên trong các tiến trình để đảm nhiệm các nhiệm vụ khác nhau của tiến trình.
Các luồng tuy có vùng nhớ riêng nhưng những luồng trong cùng một tiến trình thì sử
dụng chung vùng nhớ. Điều này cho phép các luồng sử dụng bất cứ tài nguyên nào
nằm trong vùng nhớ đó.
Các lợi ích của luồng:
Một số tiến trình phải xử lí nhiều công việc cùng một lúc. Các công việc này
thường chặn lẫn nhau. Chia nhỏ tiến trình thành các tiểu trình đảm nhiệm các
công việc riêng biệt khiến việc lập trình trở nên đơn giản hơn.
Cơ chế liên lạc đơn giản hơn tiến trình khiến việc chuyển đổi ngữ cảnh giữa các
luồng tốn ít chi phí hơn.
Khi các hệ thống trở nên nhanh và mạnh hơn, luồng khiến các công việc có thể
chạy chồng lên nhau. Điều này tăng cao hiệu năng của toàn bộ hệ thống.
Đồng thời luồng cũng dễ dàng khỏi tạo và phá hủy hơn tiến trình. Khi công việc
không còn cần nữa, việc phá hủy luồng đơn giản và ít ảnh hưởng hơn tiến trình.
Nhược điểm:
Các luồng không hoạt động độc lập như tiến trình. Sự đổ vở của một luồng có
thể kéo theo sự sụp đổ của cả tiến trình.
Các luồng dùng chung vùng nhớ và các tài nguyên của tiến trình. Điều này dễ
gây xung đột, nhảy cóc giữa các luồng.
3. Hoạt động của tiến trình
3.1. Khởi tạo tiến trình:
Tiến trình chỉ có thể khởi tạo bằng một tiến trình khác. Ta gọi tiến trình khởi tạo
là tiến trình cha và tiến trình được khởi tạo là tiến trình con. Khi hệ thống (Linux)
khởi động, chỉ có một tiến trình được tạo ra. Tiến này liên tục tạo ra các tiến trình
khác bằng các lời gọi hệ thống như fork(), vfork(), clone(), wait() và exec() để thực
thi các công việc rồi sau đó quay trở về trạng thái nghỉ(idle). Tùy thuộc vào lời gọi
hàm, các tiến trình con nhận các nội dung giống với các tiến trình cha và chia sẻ một
số tài nguyên, điểm khác duy nhất là PID của chúng và vị trí chúng được lưu trong
bộ nhớ, riêng đối với exec() thì tiến trình con nhận luôn PID của cha.
6
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Hình I.2: Cây phả hệ của tiến trình
Có bốn thời điểm chính khi tiến trình được khởi tạo:
Khởi động hệ thống
Thực thi các lời gọi hệ thống để tạo tiến trình thông qua một tiến trình khác đang
chạy
Yêu cầu của người dùng
Khởi động của khối công việc (batch job).
3.2. Kết thúc tiến trình:
Sau khi được khởi tạo, tiến trình bắt đầu vận hành và làm các nhiệm vụ của nó.
Tuy nhiên sớm hay muộn tiến trình sẽ phải kết thúc, thường là do các điều kiện sau:
Thoát bình thường (tự nguyện).
Thoát lỗi (tự nguyện).
Lỗi định mệnh (không tự nguyện).
Bị tắt bởi tiến trình khác (không tự nguyện).
Hầu hết tiến trình kết thúc bởi nó đã thực hiện xong công việc của mình. Lúc này
tiến trình báo cho hệ điều hành biết nó đã làm xong việc thông qua một lời gọi hàm.
Lí do thứ hai là khi tiến trình phát hiện ra một lỗi định mệnh, ví dụ như tìm không
thấy file hay cúp điện.
Lí do thứ ba là lỗi gây nên bởi tiến trình thường do bởi lênh lỗi của chương trình
như tham chiếu tới vùng nhớ không tồn tại hay chia cho không.
Lí do thứ tư khiến chương trình kết thúc là khi một chương trình thực hiện các lời
gọi hàm như kill() để chấm dứt các tiến trình khác. Khi một tiến trình bị chấm dứt,
các tiến trình con của nó nhận một tiến trình cha mới hoặc nhận nuôi bởi tiến trình
init.
3.3. Thực thi chương trình:
Trong Linux, cũng giống UNIX, chương trình và lệnh được thực thi bởi một trình
thông dịch lệnh. Trình thông dịch đó cũng là một tiến trình, gọi là shell. Shell thực
thi các chương trình bằng cách tạo ra các chương trình con nhận nó làm cha qua lời
gọi fork(), các chương trình con sau đó thay thế nội dung của mình bằng nội dung
của chương trình cần thực thi.
4. Liên lạc giữa các tiến trình:
4.1. Nhu cầu liên lạc giữa các tiến trình và các vấn đề nảy sinh:
Trong hệ điều hành hiện đại đa chương trình như Linux, không một tiến trình nào
hoạt động hoàn toàn độc lập. Chúng vẫn có nhu cầu liên lạc với nhau:
7
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Chia sẻ thông tin: nhiều tiến trình có thể cùng quan tâm đến những dữ liệu nào
đó, do vậy hệ điều hành cần cung cấp một môi trường cho phép sự truy cập đồng
thời đến các dữ liệu chung.
Hợp tác hoàn thành tác vụ: đôi khi để đạt được một sự xử lý nhanh chóng, người
ta phân chia một tác vụ thành các công việc nhỏ có thể tiến hành song song.
Như vậy, trong một hệ thống mà các tiến trình tác động lẫn nhau, đầu vào của tiến
trình này có thể là đầu ra của tiến trình khác, thì cần có những cơ chế liên lạc hiệu
quả và cấu trúc tốt hơn việc sử dụng các ngắt (interupts) đẻ giao tiếp giữa các tiến
trình với nhau. Tuy nhiên, khi các tiến trình có những cơ chế liên lạc, ảnh hưởng tới
tiến trình khác thì xung đột là không thể tránh khỏi.
Một số vấn đề nảy sinh khi liên lạc giữa các tiến trình:
Cách các tiến trình liên lạc với nhau
Tránh xung đột giữa các tiến trình
Sắp xếp tuần tự thực thi của các tiến trình khi chúng có những phụ thuộc vào
nhau.
Linux cung cấp một số các cơ chế để các tiến trình liên lạc lẫn nhau và liên lạc với
nhân(kernel).
4.2. Tín hiệu (Signals):
Tín hiệu là một trong những phương thức liên lạc liên tiến trình lâu đời nhất được
sử dụng bởi Unix. Chúng được sử dụng để phát tín hiệu về các sự kiện không đồng
bộ, sự kiện mà tiến trình nhận không biết trước thời điểm nhận, đến một hoặc nhiều
các tiến trình. Một tín hiệu có thể được tạo ra bởi một ngắt bàn phím hoặc một điều
kiện lỗi như một tiến trình cố gắng truy nhập một vị trí không tồn tại trong bộ nhớ ảo
của nó. Một nhược điểm của tín hiệu là chúng hoàn toàn không có ưu tiên thừa kế
tương đối(inherent relative priority).Nếu hai tín hiệu được tạo ra cùng lúc thì chúng
có thể được đưa đến hoặc xử lí bởi tiến trình theo thứ tự bất kì. Cơ chế để xử lí nhiều
tín hiệu cùng một kiểu cũng không hề tồn tại, một tiến trình không thể biết số lượng
tín hiệu giống nhau mình nhận. Cuối cùng, các tiến trình chỉ có thể thông báo cho
nhau về một biến cố nào đó, mà không trao đổi dữ liệu theo cơ chế này được.
Hình I.3: Các loại tín hiệu trong hệ thống.
4.3. Pipes:
Cũng là một trong những cơ chế cũ và đơn giản nhất trong liên lạc giữa các tiến
trình. Liên lạc bằng pipe là một cơ chế liên lạc một chiều (unidirectional), nghĩa là
một tiến trình kết nối với một pipe chỉ có thể thực hiện một trong hai thao tác đọc
hoặc ghi, nhưng không thể thực hiện cả hai. Các ống (pipes) nối đầu ra chuẩn của tiến
trình này đến đầu vào chuẩn của tiến trình khác. Cơ chế liên lạc này sẽ được trình bày
rõ hơn ở phần tiếp theo.
8
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Hình I.4: Mô tả đường ống
4.4. Sockets:
Là một thiết bị truyền thông hai chiều tương tự như tập tin, chúng ta có thể đọc
hay ghi lên nó, tuy nhiên mỗi socket là một thành phần trong một mối nối nào đó giữa
các máy trên mạng máy tính và các thao tác đọc/ghi chính là sự trao đổi dữ liệu giữa
các ứng dụng trên nhiều máy khác nhau. Sử dụng socket có thể mô phỏng hai phương
thức liên lạc trong thực tế: liên lạc thư tín (socket đóng vai trò bưu cục) và liên lạc
điện thoại (socket đóng vai trò tổng đài).
4.5. Message Queues:
Hệ điều hành còn cung cấp một cơ chế liên lạc giữa các tiến trình không thông qua
việc chia sẻ một tài nguyên chung, mà thông qua việc gửi thông điệp. Để hỗ trợ cơ
chế liên lạc bằng thông điệp, hệ điều hành cung cấp các hàm IPC (Inter Process
Communication) chuẩn, cơ bản là hai hàm:
Send(message): gửi một thông điệp
Receive(message): nhận một thông điệp
9
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Hình I.5: Mô tả Message Queue
4.6. Semaphores:
Ở dạng đơn giản nhất semaphores là một vị trí trong bộ nhớ mà giá trị của nó có
thể được kiểm tra và thiết lập (test and set) bởi một hoặc nhiều tiến trình. Quá trình
kiểm tra và thiết lập là không thể dừng lại được. Kết quả của quá trình này là tổng giá
trị hiện tại của semaphore và giá trị thiết lập, có thể âm hoặc dương. Phụ thuộc vào
giá trị này, một tiến trình có thể phải đợi cho đến khi giá trị semaphore bị thay đổi
bởi tiến trình khác. Semephore có thể được sử dụng để cài đặt đoạn găng (critical
regions), vùng chứa những đoạn code quan trọng mà chỉ một tiến trình tại một thời
điểm thực thi nó.
10
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Hình I.6: Mô tả Semaphore.
4.7. Shared Memory:
Đây là phương pháp nhanh nhất để trao đổi dữ liệu giữa các tiến trình. Nhưng
phương thức này cũng làm phát sinh các khó khăn trong việc bảo đảm sự toàn vẹn dữ
liệu (coherence).
Ví dụ: làm sao biết được dữ liệu mà một tiến trình truy xuất là dữ liệu mới nhất mà
tiến trình khác đã ghi? Làm thế nào ngăn cản hai tiến trình cùng đồng thời ghi dữ liệu
vào vùng nhớ chung? … Rõ ràng vùng nhớ chia sẻ cần được bảo vệ bằng những cơ
chế đồng bộ hóa thích hợp. Một khuyết điểm của phương pháp liên lạc này là không
thể áp dụng hiệu quả trong các hệ phân tán, để trao đổi thông tin giữa các máy tính
khác nhau.
11
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Hình I.7: Mô tả Shared Memory
Chương II. PHƯƠNG PHÁP PIPE
1. Đường ống một chiều(Half-duplex):
1.1. Khái niệm cơ bản:
Một cách đơn giản, đường ống là một phương thức để nối đầu vào của một tiến
trình này đến đầu ra của một tiến trình khác. Đường ống là công cụ liên lạc lâu đời
giữa các tiến trình, xuất hiện từ các phiên bản đầu tiên của UNIX, cha đẻ của Linux.
Chúng cung cấp phương thức liên lạc một chiều( nên mới có tên ống một chiều) giữa
các tiến trình.
Khi tiến trình tạo một đường ống, nhân (kernel) dựng lên hai bộ mô tả file (file
descriptors) để đường ống sử dụng. Một bộ dùng để cho phép một luồng các đầu vào
vào trong đường ống (ghi), trong khi bộ kia dành cho việc lấy dữ liệu từ đường ống
(đọc).
Hình II.1: Mô tả tiến trình và nhân sau khi một đường ống khởi tạo.
Ta có thể dễ dàng thấy hai bộ mô tả được kết nối với nhau. Nếu tiến trình gửi dữ
liệu qua đường ống ghi thì nó cũng có thể lấy được dữ liệu qua đó qua ống đọc.
Một đường ống được tạo ra chỉ giúp tiến trình giao tiếp với chính nó. Tuy nhiên,
khi khởi tạo một tiến trình con từ tiến trình cha có sẵn một đường ống, thì tiến trình
12
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
con sẽ sao chép tất cả các bộ mô tả file đang mở mà tiến trình cha có, ở đây bao gồm
đường ống đã được khởi tạo từ trước.
Hình II.2: Liên lạc giữa tiến trình cha và con.
Lúc này, cả hai tiến trình phải cùng quyết định rằng đâu là chiều mà dữ liệu được
truyền đi. Từ tiến trình cha về tiến trình con hay ngược lại ? Sau khi quyết định, các
tiến trình tiến hành việc đóng các đường ống mà không cần thiết, . Ở đây,đầu ghi của
tiến trình cha và đầu đọc của tính trình con bị đóng, dữ liệu sẽ được truyền từ tiến
trình con sang tiến trình cha.
Hình II.3: Sau khi đóng các cổng thích hợp
1.2. Tạo đường ống một chiều:
Để tạo ra một đường ống một chiều, lời gọi hệ thống pipe() được sử dụng. Lời gọi
này dùng một tham số là một mảng gồm hai số nguyên, nếu thành công, mảng này sẽ
chứa hai bộ mô tả file dùng cho đường ống. Lời gọi pipe() chi tiết như sau:
Nguyên mẫu hàm: int pipe( int fd[2] );
Trả về:
o 0 nếu thành công
o -1 nếu lỗi: errno =
EMFILE ( không tồn tại bộ mô tả file)
EMFILE( bảng file hệ thống đầy)
EFAULT(mảng fd không hợp lệ)
Lưu ý: fd[0] dùng để đọc, fd[1] dùng để ghi.
Phần tử đầu tiên trong mảng được khởi tạo và mở sẵn cho việc đọc dữ liệu, trong
khi phần tử thứ hai dành cho việc ghi dữ liệu. Hay nói cách khác đầu ra của phần tử
thứ hai chính là đầu vào của phần tử thứ nhất.
#include <stdio.h>
13
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
#include <unistd.h>
#include <sys/types.h>
main()
{
int fd[2];
pipe(fd);
}
Sau đó chúng ta tiếp tục sử dụng lời gọi fork() để khởi tạo tiến trình con. Cần lưu
ý rằng, nói một cách đơn giản, fork() trả về một giá trị nguyên dương lớn hơn 0 khi
tiến trình cha thực thi, và giá trị 0 khi tiến trình con thực thi. Khi giá trị trả về là -1,
thì việc khởi tạo thất bại. Bởi chúng ta muốn gửi thông tin từ tiến trình con về cha,
nên cần đóng đầu đọc của đường ống ở con và đầu ghi của đường ống ở cha.
if((childpid = fork()) == -1)
{
/* In lỗi */
perror("fork");
exit(1);
}
if(childpid == 0)
{
/* Đóng đầu vào ở tiến trình con */
close(fd[0]);
}
else
{
/* Đóng đầu ra ở tiến trình cha */
close(fd[1]);
}
1.3. Một vài lưu ý:
Các đường ống hai chiều có thể được tạo ra bằng cách tạo hai đường ống, sau
đó đóng các cổng thích hợp để có chiều truyền dữ liệu tương ứng.
Lời gọi pipe() phải được gọi trước lời gọi fork() để tiến trình con có thể thừa kế
đường ống được tạo.
Với đường ống một chiều, các tiến trình liên kết với nhau phải chia sẻ cùng một
nguồn gốc mà sinh ra đường ống đó. Nếu các tiến trình khác nguồn gốc, thì
chúng hoàn toàn không thể sử dụng đường ống.
14
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
2. Đường ống đặt tên (Named pipes):
2.1. Khái niệm cơ bản:
Đường ống đặt tên, hay còn gọi là FIFO (Vào trước ra trước – First In First Out),
hoạt động rất giống đường ống thông thường. Tuy nhiên nó có một vài điểm khác
biệt cần lưu ý:
Đường ống đặt tên tồn tại như là một file thiết bị đặc biệt (device special file)
trong hệ thống file.
Các tiến trình không cùng nguồn gốc có thể chia sẻ dữ liệu thông qua đường
ống này.
Khi mọi quá trình vào/ra đã được hoàn thành bởi tiến trình, các đường ống đặt
tên này không mất đi mà ở trong hệ thống file để sử dụng sau này.
2.2. Tạo một FIFO:
Trong Shell, ta có thể tạo bằng hai cách:
mknod MYFIFO p
mkfifo a=rw MYFIFO
Cả hai cách hoạt động gần như giống nhau. Tuy nhiên mkfifo cho phép thay đổi
quyền hạn(đọc-ghi-thực thi) ngay sau khi khởi tạo còn với mknod, thì lệnh chmod là
cần thiết.
Trong ngôn ngữ lập trình C, lời gọi mknod như sau:
PROTOTYPE: int mknod( char *pathname, mode_t mode, dev_t dev);
RETURNS:
o 0 on success,
o -1 on error: errno =
EFAULT (đường dẫn không hợp lệ)
EACCES (từ chối truy cập)
ENAMETOOLONG (tên đường dẫn quá dài)
ENOENT (đường dẫn không hợp lệ)
ENOTDIR (đường dẫn không hợp lệ)
Một ví dụ đơn giản khởi tạo FIFO:
mknod("/tmp/MYFIFO", S_IFIFO|0666, 0);
Ở đây file “/tmp/MYFIFO” được tạo ra dưới dạng một file FIFO, quyền hạn được
yêu cầu là “0666”, tham số thứ ba có thể được bỏ qua khi ta khởi tạo một FIFO.
Chương III. MÔ PHỎNG ĐƠN GIẢN LỆNH “BC” TRONG SHELL
1. Mô tả vấn đề:
Sau khi tìm hiểu về các phương thức liên lạc giữa các tiến trình, đặc biệt là liên lạc
bằng đường ống PIPE, một ứng dụng để trình bày cách thức hoạt động của đường
ống trong hệ thống là cần thiết. Ở báo cáo này, một chương trình sẽ được dựng lên
để mô tả câu lệnh “bc” trong Shell sử dụng hai tiến trình cùng thuật toán nghịch đảo
Ba Lan.
15
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Tiến trình thứ nhất sẽ cho phép người dùng nhập từ bàn phím một chuỗi biểu diễn
các phép tính gồm các toán tử “+” (cộng), “-“ (trừ), “*” (nhân), “/” (chia), “(“ (ngoặc
trái), “)” (ngoặc phải) và các số nguyên không dấu. Các phép cộng trừ có cùng độ ưu
tiên, các phép nhân chia có độ ưu tiên lớn hơn cộng trừ, tuy nhiên phép tính trong
ngoặc có độ ưu tiên lớn nhất.
Ví dụ: 1+2+(2-3-4)-((3+4)-5)
Tiến trình thứ hai được truyền chuỗi dữ liệu này sang bằng đường ống, thực hiện
các tính toán rồi truyền chuỗi kết quả về cho tiến trình thứ nhất rồi thể hiện ra cho
người dùng biết.
2. Lệnh “bc”:
bc là một ngôn ngữ hỗ trợ số chính xác tùy ý cùng với việc thực thi các câu lệnh
có tính tương tác. bc thực hiện các đoạn mã trong các file được liệt kê ra trong giao
diện dòng lệnh một cách lần lượt. Ngôn ngữ này cho phép tính toán chính xác các số
cực lớn hoặc cực nhỏ mà không gặp vấn đề nào.
Hình III.1: Giao diện của lệnh bc.
Trong giao diện dòng lệnh, bc cung cấp một số chức năng:
-- help: Hiện thị hỗ trợ
-h, --help: In ra cách sử dụng rồi thoát
file: Một file chứa các tính toán/hàm cần thực hiện. File này có thể đưa đến từ
đầu vào chuẩn (standard input) thông qua đường ống.
-l, --interactive: Định nghĩa thư viện toán chuẩn.
-v, --version: Hiển thị phiên bản, copyright sau đó thoát.
Báo cáo này chỉ mô phỏng đơn giản một ứng dụng của bc trên giao diện dòng lệnh:
Xử lí biểu thức tính toán trung tố và thoát khi nhập “quit”.
3. Thuật toán:
Ở đây để mô phỏng bc, ta cần phải làm việc với các biểu thức trung tố. Tuy nhiên
các biểu thức trung tố thường gây khó khăn cho máy tính trong việc tính toán bởi
phải bỏ ra một lượng công việc đáng kể xác định thứ tự ưu tiên các phép tính. Vì vậy
các biểu thức này cần được chuyển sang tiền tố hoặc hậu tố (hay còn gọi là kí pháp
Ba Lan) để tính toán đơn giản hơn. Ở đây ta sử dụng thuật toán bẻ ghi của Edgar
Dijkstra để chuyển từ biểu thức trung tố sang biểu thức hậu tố. Bằng cách sử dụng
hai ngăn xếp để chứa lần lượt toán tử và toán hạng, thuật toán này có thể cài đặt vào
ngôn
ngữ
C.
Thuật
toán
này
được
miêu
tả
kĩ
ở
/>Dưới đây trình bày lại thuật toán:
1. Khi vẫn còn kí tự đọc vào
16
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
1.1. Đọc kí tự tiếp theo.
1.2. Nếu kí tự tiếp theo là:
1.2.1.
Số: đẩy vào ngăn xếp giá trị.
1.2.2.
Dấu ngoặc trái: đẩy vào ngăn xếp toán tử.
1.2.3.
Dấu ngoặc phải:
1. Khi đỉnh ngăn xếp toán tử không phải là dấu ngoặc trái,
1. Lấy một toán tử ra khỏi ngăn xếp toán tử.
2. Lấy ngăn xếp ra hai lần, nhận hai toán hạng.
3. Tính toán hai giá trị dựa theo toán tử, theo đúng thứ tự.
4. Đẩy kết quả tìm được vào ngăn xếp giá trị.
2. Lấy dấu ngoặc trái ra khỏi ngăn xếp toán tử, vứt bỏ nó.
1.2.4.
Toán tử(gọi toán tử này là thisOp):
1. Khi ngăn xếp toán tử không rỗng, và đỉnh của ngăn xếp toán tử có ưu
tiên lớn hơn hoặc bằng thisOp,
1. Lấy một toán tử ra khỏi ngăn xếp toán tử.
2. Lấy ngăn xếp ra hai lần, nhận hai toán hạng.
3. Tính toán hai giá trị dựa theo toán tử, theo đúng thứ tự.
4. Đẩy kết quả tìm được vào ngăn xếp giá trị.
2. Đẩy thisOP vào trong ngăn xếp toán tử.
2. Khi ngăn xếp toán tử không rỗng,
2.1. Lấy một toán tử ra khỏi ngăn xếp toán tử.
2.2. Lấy ngăn xếp ra hai lần, nhận hai toán hạng.
2.3. Tính toán hai giá trị dựa theo toán tử, theo đúng thứ tự.
2.4. Đẩy kết quả tìm được vào ngăn xếp giá trị.
3. Đến đây, ngăn xếp toán tử sẽ rỗng, và ngăn xếp giá trị chỉ còn một giá trị chính
là kết quả cuối cùng.
4. Chương trình:
4.1. Các hàm chính sử dụng:
Các hàm ngăn xếp để cài đặt một ngăn xếp dựa vào mảng trong C, bao gồm các
hàm:
push(): đẩy phần tử vào ngăn xếp.
pop(): lấy phần tử ra khỏi ngăn xếp.
top(): trả về phần tử trên cùng của ngăn xếp.
isEmpty(): kiểm tra ngăn xếp có rỗng hay không.
Các lời gọi hệ thống sau được sử dụng để liên lạc giữa các chương trình:
17
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
pipe(): tạo đường ống với tham số đầu vào là một mảng có 2 phần tử
fork(): tạo tiến trình con từ tiến trình cha
read(): đọc chuỗi kí tự từ một đường ống
write(): ghi chuỗi kí tự vào một đường ống
close(): đóng đầu đối diện của đường ống đang đọc/ghi để tránh trường hợp ống
rỗng hoặc đầy ống khiến hai tiến trình bị xung đột đợi nhau mãi mãi.
wait(): sử dụng cho tiến trình cha, đợi đến khi tiến trình con kết thúc rồi quay
lại thực thi.
exit(): thoát khỏi tiến trình đang thực thi.
Ngoài ra còn sử dụng một số hàm thao tác trên chuỗi trong thư viện string.h.
4.2. Cơ chế hoạt động của chương trình:
Để liên lạc hai chiều giữa hai tiến trình cha con, cần thiết phải tạo hai đường ống
riêng biệt bằng cách sử dụng lời gọi hàm pipe() lên hai mảng fd1 và fd2, sau đó sử
dụng lời gọi hàm fork() để tiến trình con cũng nhận được hai đường ống tương tự.
Hình III.2: Sau khi khởi tạo tiến trình và đường ống.
Tiến trình cha sau khi nhận biểu thức tính toán đầu vào, ghi biểu thức tính toán đó
và fd1[1] rồi gửi qua tiến trình con, tiến trình con đọc dữ liệu từ fd1[0], tất cả đều ở
ống thứ nhất. Dưới đây là câu lệnh mô tả:
// Tiến trình cha
else if (p > 0)
{
close(fd1[0]); // Đóng cổng đọc của ống 1
// Ghi đoạn biểu thức nhập vào và đóng ống
// một
write(fd1[1], str, strlen(str)+1);
close(fd1[1]);
// Đợi đến khi hàm con thực thi xong
wait(NULL);
…
}
// Tiến trình con
else
{
18
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
close(fd1[1]); // Đóng đầu ghi của ống 1
// Đọc chuỗi string từ đầu đọc của ống 1
read(fd1[0], str, 20);
…
}
Sau đó, các biểu thức được tính toán ở tiến trình con thông qua phần Thuật toán
đã được trình ở trên và được gửi bằng cách ghi vào đầu fd2[1] và tiến trình cha đọc
dữ liệu từ fd2[0]. Tuy nhiên trước khi thực hiện các thao tác đọc hoặc ghi, cần phải
đóng các cổng đối diện của ống cần đọc hoặc ghi lại để tránh tràn ống hoặc ống rỗng,
ví dụ khi đọc đầu fd1[0] cần phải đóng fd2[0] bằng lệnh close(). Mô tả bằng lệnh
dưới:
// Tiến trình cha
else if (p > 0)
{
…
close(fd2[1]); // Đóng đầu ghi của ống thứ 2
// Đọc chuỗi kết quả từ tiến trình con và đóng
// đầu đọc
read(fd2[0], ans_str, 20);
printf("%s\n", ans_str);
close(fd2[0]);
}
// Tiến trình con
else
{
…
// Đóng hai đầu đọc
close(fd1[0]);
close(fd2[0]);
// Gửi kết quả tính toán về tiến trình cha
write(fd2[1], str, strlen(str)+1);
close(fd2[1]);
exit(0);
}
19
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
Hình III.3: Sau khi đóng các cổng không cần thiết.
5. Thực thi và kết quả:
Chương trình thực hiện được các biểu thức công trừ nhân chia đơn giản với các số
tự nhiên.
Hình III.4: Tính toán đơn giản
Khi gặp phải các kí tự lạ thì chương trình trả về chuỗi “Khong hop le” trên màn
hình.
Hình III.5: Biểu thị kí tự không hợp lệ
Chương trình thực hiện tốt khi chương trình không nhận số nguyên có dấu và toán
hạng nhập vào không vượt quá giới hạn của kiểu int trong ngôn ngữ lập trình C.
Chương IV. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN
1. Kết luận
Đồ án lần này là cơ sở tiền đề cho việc tìm hiểu sâu hơn về một mảng quan trọng
của Nguyên lí hệ điều hành. Qua đó một số kết quả đã đạt được trong quá trình tìm
hiểu và nghiên cứu:
Nắm được các khái niệm cơ bản về tiến trình, giao tiếp giữa các tiến trình trong
Linux.
Có kiến thức nền tảng về giao tiếp bằng đường ống PIPE ở Linux.
Mô phỏng đơn giản thành công lệnh bc trên Shell qua đó nâng cao khả năng lập
trình trên Linux và sử dụng các lời gọi hệ thống.
Khả năng tự học, tự nghiên cứu, giải quyết vấn đề.
Tuy nhiên còn một số hạn chế cần phải khắc phục như chưa hoàn toàn đào sâu về
các phương thức giao tiếp PIPE khác, chương trình chỉ mới khai thác giao tiếp giữa
các tiến trình ở mức độ đơn giản, tính toán số lớn còn chưa hoàn thiện.
20
Đồ Án Nguyên lí Hệ Điều Hành
GVHD: Trần Hồ Thủy Tiên
2. Hướng phát triển:
Tiếp tục nghiên cứu để giải quyết các vấn đề trên:
Tính các số lớn và cực lớn
Đào sâu khai thác giao tiếp giữa các tiến trình
21
