ĐỒ ÁN NGUYÊN LÝ HỆ ĐIỀU HÀNH

ĐÔ AN NGUYÊN LY HÊ ĐIÊU HANHNHOM 10 Trang 1

LỜI NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

........................................................................................................................................

GVHD: THẦY MAI VĂN HA SVTH: NGUYỄN THỊ MỸ DUNG


MỤC LỤCCHƯƠNG 1. TÌM HIỂU ĐÊ TAI-------------------------------------------------------------41.1 Bối cảnh đề tài:-----------------------------------------------------------------------------41.2 Mục tiêu đề tài-----------------------------------------------------------------------------51.3 Hướng giải quyết--------------------------------------------------------------------------5

CHƯƠNG 2. CƠ SỞ LY THUYẾT----------------------------------------------------------52.1 Tìm hiểu về hệ điều hành-----------------------------------------------------------------5

2.1.1 Định nghĩa hệ điều hành-------------------------------------------------------------52.1.2 Chức năng hệ điều hành-------------------------------------------------------------6

2.2 Giới thiệu về tiến trình--------------------------------------------------------------------62.2.1 Tiến trình là gì?-----------------------------------------------------------------------62.2.2 Quan hệ tiến trình.--------------------------------------------------------------------92.2.3 Các trạng thái tiến trình------------------------------------------------------------102.2.4 Chế độ xử lý của tiến trình---------------------------------------------------------122.2.5 Các thao tác điều khiển tiến trình-------------------------------------------------122.2.6 Điều phối tiến trình-----------------------------------------------------------------14

CHƯƠNG 3. THIẾT KẾ VA XÂY DỰNG CHƯƠNG TRÌNH-------------------------213.1 Phân tích yêu cầu-------------------------------------------------------------------------213.2 Các chức năng----------------------------------------------------------------------------22

3.2.1 Cài đặt thuật toán--------------------------------------------------------------------223.2.2 Phân tích đề:-------------------------------------------------------------------------223.2.3 Mô tả bài toán.-----------------------------------------------------------------------22

CHƯƠNG 4. TRIỂN KHAI VA ĐANH GIA KẾT QUẢ--------------------------------524.1 Môi trường triển khai:-------------------------------------------------------------------524.2 Kết quả và chức năng của chương trình-----------------------------------------------534.3 Đánh giá kết quả.-------------------------------------------------------------------------57



DANH SACH HÌNH ẢNHHình 1:Mô phỏng tiến trình song song độc lập-------------------------------------------------8Hình 2 Mô phổng tiến song song có quan hệ thông tin----------------------------------------8Hình 3: Mô phỏng tiến trình song song phân cấp-----------------------------------------------9Hình 4 : Mô phỏng tiến trình song song đồng mức---------------------------------------------9Hình 5 : Các trạng thái của một tiến trình------------------------------------------------------10Hình 6: Sơ đồ trạng của thái tiến trình----------------------------------------------------------11Hình 7 : Một cây tiến trình trong UNIX--------------------------------------------------------13Hình 8 : Danh sách chờ của các tiến trình trong hệ thống.-----------------------------------16Hình 9: Sơ đồ chuyển đổi giữa các danh sách điều phối-------------------------------------17Hình 10: Cấp độ điều phối-----------------------------------------------------------------------18Hình 11: kết quả thuật toán FIFO.---------------------------------------------------------------53Hình 12: Hiển thị các tiến trình vào.------------------------------------------------------------53Hình 13 : Quá trình xử lý.------------------------------------------------------------------------54Hình 14 : Kết quả.---------------------------------------------------------------------------------54Hình 15 : Kết quả thuật toán SJF.---------------------------------------------------------------55Hình 16 : Kết quả thuật toán SJF độc quyền---------------------------------------------------55Hình 17 : Kết quả thuật toán ưu tiên.-----------------------------------------------------------56Hình 18 : Kết quả thuật toán ưu tiên độc quyền-----------------------------------------------56



LỜI NÓI ĐẦU

Nguyên lý hệ điều hành là môn học quan trọng và cần thiết.Giúp người học hiểu về hệ điều hành của máy tính,hiểu cơ chế xử lý của các tiến trình đưa vào hệ điều hành của một máy tính điện tử bất kì. Quá trình xử lý của các tiến trong CPU là quá trình quan trọng,ảnh hưởng đến tốc độ,thời gian xử lý và công việc thường ngày trên máy tính.Vậy thiết nghĩ tiến trình và quan hệ giữa các tiến trình,cách điều phối tiến trình là quan trọng.Đặc biệt hiện nay một máy tính một lúc không phải đợi tiến trình này xử lý mà một lúc có thể xử lý nhiều tiến trình.Hiện nay em đang nhận được đề tài mô phỏng về chiến lược một hàng đợi nhiều tiến trình chờ phân phối xử lý.Trong chiến lược một hàng đợi này có 4 thuật toán chính FIFO,SJF,RR,thuật toán ƯU TIÊN.Sau khi tìm hiểu về đề tài này giúp em hiểu thêm vể các cơ chế điều phối tiến trình trong CPU,và cơ chế xử lý các tiến trình.

Em xin chân thành cám ơn thầy giáo Mai Văn Hà đả tận tình hướng dẫn,chỉ bảo em,để em có thể hoàn thành đồ án một cách tốt nhất.



CHƯƠNG 1. TÌM HIỂU ĐỀ TÀI

1.1 Bối cảnh đề tài:Trước đây tuỳ từng thời điểm, máy tính được xác định một nhiệm vụ chính; tất cả

các chương trình được bó lại thành gói (paket) và được gởi đi liên tục. Điều đó được gọi là xử lý đóng gói (pile processing) hay quản lý lô (batch manager). Ngày nay, không chỉ có một chương trình chạy trên máy tính, mà nhiều chương trình cùng thực hiện (multi-tasking). Cũng như thế, không chỉ có một người sử dụng làm việc, mà nhiều người sử dụng cùng làm việc (multi- user). Để hạn chế sự tranh chấp giữa chúng ở việc dùng máy tính, do đó sự phân bổ các phương tiện điều hành phải được điều chỉnh trên chương trình.Thêm vào đó, chương trình phải được lưu trữ khi cần thiết sử dụng phương tiện điều hành nào: không gian nhớ, thế hệ CPU, dùng lượng CPU… Từ đó ta hiểu, tiến trình là thông tin trạng thái của các phương tiện điều hành đối với một chương trình (thường gọi là một Job). Một tiến trình này có thể sinh ra một tiến trình khác, khi đó người ta gọi tiến trình đầu là tiến trình cha, còn tiến trình được sinh ra là tiến trình con.Cùng một lúc có thể có nhiều tiến trình được nhập vào hệ thống,lúc này cần phải có cơ chế để cac tiến trình thực hiện theo thứ tự.

Một hệ thống đa chương trình (multi-programming system) cho phép thực hiện đồng thời nhiều chương trình và nhiều tiến trình. Một chương trình (gọi là một job ) cũng có thể tự phát sinh ra nhiều tiến trình.

1.2 Mục tiêu đề tàiHiểu rỏ về tiến trình đặc biệt chiến lược một hàng đợi nhiều tiến trình chờ phân

phối xử lý.Xem cơ chế thuộc loại tiến trình nào và tìm hiểu về trạng thái của các cơ chế 1 hàng đợi và cơ chế điều phối.Cách quản lí tiến trình một hàng đợi.

1.3 Hướng giải quyếtTìm hiểu rỏ về tiến trình:Tiến trình các loại tiến trìnhmô hình tiến

trìnhcách thực hiện mô hìnhquản lý tiến trìnhcở ché điều phối một hàng đợi các tiến trình.Ngôn ngữ sử dụng:Sữ dụng ngôn ngữ lập trình C++



CHƯƠNG 2. CƠ SỞ LÝ THUYẾT

2.1 Tìm hiểu về hệ điều hành

2.1.1 Định nghĩa hệ điều hànhHệ điều hành (HĐH) là một phần quan trọng của mỗi hệ thống thông tin. Mõi hệ

thống thông tin gồm 4 thành phần quan trọng: Phần cứng, hệ điều hành, chương trình ứng dụng và người sử dụng.

Phần cứng: Gồm CPU, bộ nhớ, thiết bị vào ra cung cấp các tài nguyên thông tin cơ sở.

Các chương trình ứng dụng: Gồm chương trình dịch, hệ thống cơ sở dữ liệu, trình soạn thảo văn bản,… quy định cách sử dụng các tài nguyên đó để giả quyết những vấn đề của người sử dụng.

Hệ điều hành: Điều khiển và đồng bộ việc sử dụng phần cứng của các chương trình ứng dụng phục vụ các người sử dụng khác nhau với các mục đích phong phú đa dạng.

Người sử dụng: Hiểu theo nghĩa rộng bao gồm những người sử dụng thuần tuý và các cán bộ vận hành đặc biệt đối với các máy trung và các máy lớn.Ta có thể hiểu hệ điều hành là hệ thống các chương trình đảm bảo các chức năng giao tiếp người máy và và quản lý tài nguyên hệ thống tính toán.Tuy nhiên có nhiều người quan sát HĐH dưới các góc độ khác nhau vì thế tồn tại nhiều định nghĩa về HĐH.

Đối với người sử dụng : HĐH là tập hợp các chương trình, phục vụ khai thác hệ thống tính toán một cách dễ dàng, thuận tiện.Người sử dụng khi thực hiện một chương trình nào đó trên máy tính thì chỉ quan tâm đến việc hệ thống có đáp ứng được nhu cầu của hộ hay không? Họ không quan tâm đến việc hệ điều hành làm như thế nào, nhằm mục đích gì, có cấu trúc như thế nào?

Đối với người làm công tác quản lý: HĐH là một tập các chương trình phục vụ quản lý chặt chẽ và sử dụng tối ưu các tài nguyên của hệ thống.

Đối với cán bộ kỹ thuật: HĐH là hệ thống chương trình bao trùm lên một máy tính vật lý cụ thể để tạo ra một máy logic với những tài nguyên mới và khả năng mới.

2.1.2 Chức năng hệ điều hànhHệ điều hành là một chương trình đóng vai trò trung gian trong việc giao tiếp giữa

người sử dụng và phần cứng của máy tính. Mục tiêu của hệ điều hành là cung cấp một môi trường cho phép người sử dụng phát triển và thực hiện các ứng dụng của họ một cách dễ dàng và hiệu quả. Theo nguyên tắc, một hệ điều hành cần thoả mãn hai chức năng sau:

Quản lý, chia sẻ tài nguyên.Tài nguyên hệ thống, đặc biệt các tài nguyên phầ cứng như CPU, bộ nhớ, thiết bị

ngoại vi,.. hệ điều hành cần có các cơ chế và chiến lược thích hợp để quản lý việc phân phối tài nguyên.



Giả lập một máy tính.Chức năng thứ hai của hệ điều hành là che dấu các chi tiết phần cứng của máy tính

và giới thiệu với người dùng một máy tính mở rộng có đầy đủ các chức năng của máy tính.

Với đề tài Viết chương trình mô phỏng các giải thuật định thời trình bày về quá trình hoạt động của các tiến trình trong CPU, các trạng thái của hệ thống tính toán và việc chuyển từ trạng thái này sang trạng thái khác được thực hiện theo một chương trình nào đó.

Đã có nhiều chương trình nghiên cứu đề tài này và ứng dụng trong cuộc sống và nó có những ưu và khuyết điểm cố định:

Ưu điểm : Đã đưa ra được cách xử lý của các tiến trình .Chương trình đơn giản.

Khuyết điểm :Chưa nêu rõ việc tập hợp điều phối giữa các tiến trình.Hướng nghiên cứu giới thiệu.

2.2 Giới thiệu về tiến trình

2.2.1 Tiến trình là gì?Tất cả các máy tính hiện đại đều có thể thực hiện nhiều việc cùng một lúc. Trong

khi thực hiện chương trình của người sử dụng, máy tính có thể đọc dữ liệu từ đĩa và đưa ra màn hình hoặc máy in. Trong môi trường đa chương trình (multiprogramming system), một CPU có thể chuyển từ chương trình này sang chương trình khác, thực hiện mỗi chương trình trong khoảng 1% hoặc 1/10 mili giây. Nếu nói chính xác, thì tại một thời điểm, CPU chỉ thực hiện được một chương trình. Nhưng nếu xét trong khoảng thời gian phần trăm giây thì CPU có thể thực hiện nhiều công việc.

Để hổ trợ hoạt động đa nhiệm,hệ thống máy tính cần phải có khả năng thực hiện nhiều tác vụ xử lý đồng thời nhưng việc điều khiển hoạt động song hành ở cấp độ phần cứng là rất khó khăn.Vì vậy,các nhà thiết kế hệ điều hành đề xuất một mô hình song hành giả lập bằng cách chuyển đổi bộ xử lý qua lại giữa các chương trình để duy trì hoạt động của nhiều chương trình phải cùng một thời điểm.Trong mô hình này các chương trình của hệ thống được tổ chức thành các tiến trình(process).

Như vậy cá thể coi tiến trình là một chương trình đang xử lý,nó sử dụng một con trỏ lệnh,tập các thanh ghi và các biến.Để hoàn thành nhiệm vụ của mình,các tiến trình còn có thể yêu cầu một số tài nguyên hệ thống như: CPU,bộ nhớ và các thiết bị.

Chúng ta cần phân biệt rỏ tiến trình và chương trình.Chương trình là một thực thể thụ động chưa các chỉ thị điều khiển máy tính thi hành một tác vụ cụ thể nào đó.Khi thực hiện các chỉ thị này ,chương trình được chuyển thành các tiến trình là một thực thể hoạt động,với con trỏ lệnh xác định kèm them tài nguyên phục vụ cho hoạt động.



Vậy tóm lại ,tiến trình là một bộ phận của một chương trình đang thực hiện, đơn vị thực hiện tiến trình là processer.Hay có thể nói cách khác :

Saltzer: Tiến trình là một chương trình do một processor logic thực hiện.Horning & Rendell: Tiến trình là một quá trình chuyển từ trạng thái này sang trạng thái khác dưới tác động của hàm hành động, xuất phát từ một trạng thái ban đầu nào đó.

Các loại tiến trình:Có thể chia thành hai loại: tiến trình tuần tự (MS_DOS) và tiến trình song

song( uniprocesser và multiprocesser).

Tiến trình tuần tự: là các tiến trình mà điểm khởi tạo của nó là điểm kết thúc của tiến trình trước đó.

Tiến trình song song : là các tiến trình mà điểm khởi tạo của tiến trình này mằn ở thân của các tiến trình khác, tức là có thể khởi tạo một tiến trình mới khi các tiến trình trước đó chưa kết thúc.Trong này tiến trình song song được chia thành nhiều loại:

Tiến trình song song độc lập:Các tiến trình hoạt động song song nhưng không có quan hệ thông tin với nhau, trong trường hợp này hệ điều hành phải thiết lập cơ chế bảo vệ dữ liệu của các tiến trình, và cấp phát tài nguyên cho các tiến trình một cách hợp lý.

Hình 1:Mô phỏng tiến trình song song độc lập

Tiến trình song song có quan hệ thông tin :Trong quá trình hoạt động các tiến trình trao đổi thông tin với nhau.Hai tiến trình A

và B được gọi là có quan hệ thông tin với nhau nếu tiến trình này có gửi thông báo cho tiến trình kia. Tiến trình gửi thông báo có thể không cần biết tiến trình nhận có tồn tại hay không? ở đâu? và đang ở giai đoạn nào?



Hình 2 Mô phổng tiến song song có quan hệ thông tin

Tiến trình song song phấn cấp :Trong qua trình hoạt động một tiến trình có thể khởi tạo các tiến trình khác hoạt

động song song với nó, tiến trình khởi tạo được gọi là tiến trình cha, tiến trình được tạo gọi là tiến trình con. Trong mô hình này hệ điều hành phải giải quyết vấn đề cấp phát tài nguyên cho các tiến trình con. Tiến trình con nhận tài nguyên ở đâu? từ tiến trình cha hay từ hệ thống.

Ví dụ:

Hình 3: Mô phỏng tiến trình song song phân cấp

Tiến trình song song đồng mức:Là các tiến trình hoạt động song song sử dụng chung tài nguyên theo nguyên tắc lần lượt, mỗi tiến trình sau một khoảng thời gian chiếm giữ tài nguyên phải tự động trả lại tài nguyên cho tiến trình kia.



Hình 4 : Mô phỏng tiến trình song song đồng mức

2.2.2 Quan hệ tiến trình. Các tiến trình hoạt động trong hệ thống tồn tại hai mối quan hệ : Độc lập và hợp tác (song hành).

Quan hệ độc lập: Tiến trình được gọi là độc lập nếu hoạt động cả nó không gây ảnh hưởng hoặc

không bị ảnh hưởng bởi các tiến trình khác củng đàn hoạt động của hệ thống.Tiến trình độc lập có những đặc trưng sau:

Trạng thái của nó không bị chia sẻ với bất kí tiến trình nào khác.Việc thực hiện tiến trình là đơn định(kết quả chỉ phụ thuộc vào đầu vào)Tiến trình có thể dừng hoặc bắt đầu lại mà không gây ảnh hưởng tới các tiến trình

khác trong hệ thống.

Quan hệ hợp tác : Tiến trình được gọi là quan hệ hợp tác(song hành) nếu hoạt động của nó gây ảnh

hưởng đến các tiến trình khac củng đang hoạt động trong hệ thống.Tiến trình hợp tác có những đặc trưng sau:

Trạng thái của nó bị chia sẻ cho các tiến trình khácViệc thực hiện tiến trình không đơn định (kết quả phụ thuộc dãy thực hiện tương

ứng và không dự báo trước).Tiến trình không thể tái hiện.

2.2.3 Các trạng thái tiến trìnhTrạng thái của tiến trình tại một thời điểm được xác định bởi hoạt động hiện thời

của tiến trình tại thời điếm đó.Trong quá trình sống một tiến trình thay đổi trạng thái do nhiều nguyên nhân

như: phải chờ một sự kiện nào đó xảy ra,hay đợi một thao tá nhập xuất hoàn tất,buộc phải dừng hoạt động do hết thời gian xử lý……

Tại một thời điểm một tiến trình có thể nhận một trong các trạng thái sau đây:



Mới tạo(new): tiến trình đang được tạo lập Running: các chỉ thị của tiến trình đang được xử lý. Blocked: tiến trình chờ được cấp phát tài nguyên,hay chờ một sự kiện xảy

ra. Ready(ready): tiến trình chờ được cấp phát CPU để xử lý. Waiting (đợi):tiến trình phải dừng vì thiếu tài nguyên hoặc chờ một sự kiện

nào đó. Kết thúc(halt) : tiến trình hoàn tất xử lý.

Các trạng thái của tiến trình được biểu diễn qua sơ đồ sau:

Hình 5 : Các trạng thái của một tiến trình

Tại một thời điểm chỉ có một tiến trình có thể nhận trạng thái running trên một bộ xử lý bất kỳ.Trong khi đó,nhiều tiến trình có thể ở trạng thái blocked hay ready.

Các cung chuyển tiếp trong sơ đồ trạng thái biểu diễn 6 sự chuyển trạng thái có thể xảy ra trong các điều kiện sau:

Tiến trình mới tạo được đưa vào hệ thống Bộ điều phối cấp phát cho tiến trình một khoảng thời gian sử dụng CPU. Tiến trình kết thúc Tiến trình yêu cầu một tài nguyên chưa được đáp ứng vì tài nguyên chưa

được săn sàng để cấp phát tại thời điểm đó,hoặc tiến trình phải chờ một sự kiện hay thao tác nhập xuất.

Bộ điều phối chọn một tiến trình khác để chờ xử lý. Tài nguyên mà tiến trình yêu cầu trở nên săn sàng để cấp phát,hay sự kiện

thao tác nhập xuất tiến trình đang đợi hoàn tất.

Theo thời gian hoạt động tiến trình sẻ thay đổi trạng thái.Có 2 cấp độ trạng thái là:Trạng thái vĩ mô: do hệ điều hành đặt ra để quản lý process.

Trạng thái vi mô:trạng thái chi tiết sau từng lệnh máy được thực thi. Trạng thái vĩ mô bao gồm: running (đang chiếm CPU và chạy),ready ( đang

chờ CPU ),blocked( bị giam vì chờ CPU).Sơ đồ trạng thái :



Hình 6: Sơ đồ trạng của thái tiến trình

1 .Thực hiện CPU tốc độ chậm.2.Chạy hết khe thời gian.3.Được chọn để chạy khe thời gian kế.4.I/O săn sàng phục vụ.

Trạng thái vi mô của tiến trình:Để quản lý trạng thái của từng process, HĐH sẽ dùng 1 record dữ liệu gồm nhiều

field, mỗi field chứa 1 thông tin trạng thái mà HĐH muốn quản lý.Một field đặc biệt trong record quản lý là field chứa mã trạng thái vĩ mô của process

tương ứng để HĐH biết process đang chạy hay đang Ready | Blocked.Các record quản lý của các process sẽ được hợp thành 1 bảng quản lý : bảng này rất

quan trọng của HĐHBảng quản lý trạng thái thường được hiện thực bằng danh sách liên kết để việc thêm/bớt từng record dễ dàng và hiệu quả (vì tần suất tạo/xóa process rất cao theo thời gian).

2.2.4 Chế độ xử lý của tiến trìnhĐể đảm bảo hệ thống hoạt động đúng đắn,hệ điều hành cần bảo vệ khỏi sự xâm phạm

của các tiến trình.Bản thâm các tiến trình cần được bảo vệ tránh khỏi sự ảnh hưởng qua lại giữa các tiến trình.Một cách để phân biệt đó là sử dụng 2 chế độ xử lý cho các tiến trình: chế độ xử lý đọc quyền và chế độ xử lý không đọc quyền nhờ vào sự hổ trợ của phần cứng.

2.2.5 Các thao tác điều khiển tiến trình

2.2.5.1 Tạo lập tiến trìnhTrong quá trình xử lý một tiến trình có thể tạo lập một tiến trình mới bằng cách gọi

lời gọi hệ thống tương ứng.Tiến trình gọi lới gọi hệ thống để tạo tiến trình mới được gọi là tiến trình cho,tiến trình được tạo là tiến trình con.Mỗi tiến trình con đến lượt nó có thể tạo tiến trình mới…quá trình này sẻ tiếp tục tạo ra cây tiến trình.



Các công việc hệ điều hành cần thực hiện khi tạo lập tiến trình: Định danh cho tiến trinh mới phát sinh. Đưa tiến trình vào dánh sách quản lý của hệ thống. Xác định độ ưu tiên cho tiến trình. Tạo PCB cho tiến trình. Cấp phát tài nguyên ban đầu cho tiến trình. Khi một tiến trình tạo lập một tiến trình con,tiến trình con có thể sẽ được hệ điều

hành trực tiếp cấp phát tài nguyên hoặc được tiến trình cha cho thừa hưởng một số tài nguyên ban đầu.

Khi một tiến trình tạo tiến trình mới ,tiến trình ban đầu có thể xử lý theo một trong hai khả năng sau:

Tiến trình cho tiếp tục xử lý đồng hành với tiến trình con.Tiến trình cha chờ đến khi một tiến trình con nào đó hoặc tất cả các tiến trình con có kết thúc xử lý.Các hệ điều hành khác nhau có thể lựa chọn các cài đặt khác nhau để thực hiện một thao tác lập trình một cây tiến trình.

Ví dụ về tạo lập cây tiến trình:

Hình 7 : Một cây tiến trình trong UNIX

2.2.5.2 Kết thúc tiến trìnhMột tiến trình kết thúc xử lý khi nó hoàn tất chỉ thị cuối cùng và sử dụng một lời gọi

hệ thống để yêu cầu hệ điều hành hủy bỏ nó.Đôi khi một tiến trình có thể yêu càu hệ điều hành kết thúc xử lý của một tiến trình khác.

Khi một tiến trình kết thúc,hệ điều hành thực hiện các công việc : Thu hồi các tài nguyên của hệ thống đả cấp phát cho tiến trình. Hủy tiến trình khỏi tất cả các danh sách quản lý của hệ thống. Hủy bỏ PCB của tiên trình.



Hầu hết các hệ điều hành không cho phép các tiến trình con tiếp tục tồn tại nếu tiến trình cha đả kết thúc.Trong những hệ thống như thế,hệ điều hành sẽ tự động phát sinh một loạt các thao tác kết thúc tiến trình con.

Một quá trình cha có thể kết thúc việc thực thi của một trong những quá trình con với nhiều ý do khác nhau:

Quá trình con sử dụng tài nguyên vượt quá mức được cấp. Điều này yêu cầu quá trình cha có một cơ chế để xem xét trạng thái của các quá trình con.

Công việc được gán tới quá trình con không còn cần thiết nữa. Quá trình cha đang kết thúc và hệ điều hành không cho phép một quá trình con

tiếp tục nếu quá trình cha kết thúc. Trên những hệ thống như thế, nếu một quá trình kết thúc (bình thường hoặc không bình thường), thì tất cả quá trình con cũng phải kết thúc. Trường hợp này được xem như kết thúc xếp tầng (cascading termination) thường được khởi tạo bởi hệ điều hành.

2.2.6 Điều phối tiến trình

2.2.6.1 Giới thiệu

Mục đích:Sự công bằng: Các tiến trình chia sẻ CPU một cách công bằng,không có tiến trình

nào phải chờ đợi vô hạn để được cấp phát CPU.Tính hiệu quả: Hệ thống phải tận dụng được CPU 100% thời gian.(thời gian chờ

trung bình ngắn).Thời gian đáp ứng hợp lý:Cực tiểu hóa thời gian hồi đáp cho các tương tác của

người sử dụng.Thời gian lưu lại trong hệ thống: Cực tiểu hóa thời gian hoàn tất các ác vụ xử lý.Thông lượng tối đa: Cực đại hóa số công việc được xử lý trong một đơn vị thời

gian .Tuy nhiên thường không thể thỏa mãn tất cả các mục tiêu kể trên vì bản thân chúng có sự mâu thuẩn nhau mà chỉ có thể dung hòa chúng ở mức độ nào đó.

Các đặc điểm của tiến trình:Điều phối hoạt động của các tiến trình là một vấn đề rát phức tạp,đòi hỏi hệ điều

hành khi giải quyết phải xem xét các yếu tố khác nhau để có thể đạt được mục tiêu đề ra.Một số đặc tính cần được quan tâm như tiêu chuẩn điều phối:

Tính hướng nhập xuất của tiến trình:khi một tiến trình nhận được CPU,chủ yếu nó chỉ sử dụng CPU cho đến khi phát sinh một yêu cầu nhập xuất.Hoạt động của các tiến trình như thế thường bao gốm nhiều lượt sử dụng CPU,mỗi lượt trong một thời gian khá ngắn.

Tính hướng xử lý của tiến trình: khi một tiên trình nhận dược CPU,nó có khuynh hướng sử dụng CPU đến khi hết thời gian dành cho nó.Hoạt động của tiến trình như thế thường bao gồm một số ít lượt sử dụng CPU,nhưng mỗi lượt trong một thời gian đủ dài.



Tiến trình tương tác hay xử lý theo lô: người sử dungjtheo kiểu tương tác thường yêu cầu được hồi đáp tức thời đối với các yêu cầu của họ,trong khi các tiesn trình của tác vụ được xử lý theo lô nói chungcos thể trì hoãn trong một thời gian chấp nhận được.

Độ ưu tiên của tiến trình: Các tiến trình có thể được phân cấp theo một đánh giá nào đó,một cách hợp lý,các tiến trình quan trọng hơn(có độ ưu tiên hơn) cần được ưu tiên hơn.

Thời gian sử dụng CPU của tiến trình:Một số quan điểm ưu tiên chọn những tiến trình đả sử dụng CPU nhiều thời gian nhất vì hy vọng chúng sẽ cần ít thời gian nhất đẻ hoàn tất và rời khỏi hệ thống.Tuy nhiên củng có quan điểm cho rắng các tiến trình nhận được CPU trong ít thời gian là những tiến trình đã phải chờ lâu nhất,do vậy ưu tiên chọn chúng.

Thời gian còn lại tiến trình cần để hoàn tất: có thể giảm thiểu thời gian chờ đợi trung bình của các tiến trình bằng cách cho các tiến trình cần ít thời gian nhất để hoàn tất được thực hiện trước.Tuy nhiên đáng tiếc là rất hiếm khi biết được tiến trình cần bao nhiêu thời gian nữa để kết thúc xử lý.

2.2.6.2 Cơ chế điều phối độc quyền và không độc quyền

Cơ chế điều phối độc quyềnNguyên lý: cơ chế này cho phép một tiến trình khi nhận được CPU sẻ có quyền đọc

chiếm CPU đến khi hoàn tất xử lý hoặc tự giải phóng CPU.Khi đó quyết định điều phối sẻ xảy ra các trường hợp sau.

Tiến trình chuyển từ trạng thái running blockit Kết thúc tiến trình.

Các giải thuật độc quyền dễ cài đặt thuật toán.Tuy nhiên lại không thích hợp cho hệ thống tổng quát nhiều người dùng.Vì nếu cho tiến trình thời gian chiếm giử CPU tùy ý thì sẻ ngăn cản quá trình xử lý của các tiến trình còn lại.

Cơ chế điều phối không độc quyền.Ngược với nguyên lý độc quyền ,điều phối theo nguyên lý không đọc quyền cho phép

tạm dừng hoạt động của tiến trình đang săn sang xử lý.Khi một tiến trình nhận CPU nó vấn được sử dụng CPU cho đến khi hoàn tất hoặc tự nguyện giải phóng CPU,nhưng một tiến trình khác có độ ưu tiên cao hơn có thể dành quyền sử dụng CPU của tiến trình ban đầu.Như vậy tiến trình có thể dừng hoạt động bắt cứ lúc nào mà không được báo trước để tiến trình khác xử lý.Các quyết định điều phối xảy ra khi:

Tiến trình chuyển từ trạng thái running blocked. Một tiến trình chờ trạng thái xử lý. Chuyển từ trạng thái chờ(blocked) ready. Khi một tiến trình kết thúc.

Các thuật toán điều phối theo nguyên tắc không đọc quyến ngăn cản tình trạng một tiến trình đọc chiếm CPU.



2.2.6.3 Tổ chức điều phối

Các loại danh sách sử dụng điều phối tiến trìnhHệ điều hành sử dụng hai loại danh sách để thực hiện điều phối các tiến trình là

danh sách sẵn sàng(ready list) và danh sách chờ đợi(waiting list).Khi một tiến trình bắt đầu đi vào hệ thống,nó được chèn vào danh sách tác vụ(job list).Danh sách này bao gồm tất cả các tiền trình của hệ thống.Nhưng chỉ các tiến trình đang thường trú trong bộ nhớ chính và ở trạng thái săn sàng tiếp nhận CPU để hoạt động mới được đưa vào danh sách sẵn sàng.

Bộ điều phối sẻ chọn một tiến trình trong danh sách săn sàng và cấp CPU cho tiến trình đó.Tiên trình được cấp CPU sẻ thực hiện xử lý,và có thể chuyển sang trạng thái chờ khi xảy ra các sự kiện như đợi một thao tác nhập/xuất hoàn tất,yêu cầu tài nguyên chưa được thỏa mãn,yêu cầu tạm dừng…Khi đó tiến trình sẻ được chuyển sang một danh sách chờ đợi.

Hệ điều hành chỉ sử dụng một danh sách săn sàng cho toàn hệ thống,nhưng mỗi một tài nguyên(thiết bị ngoại vi) có một danh sách chờ đợi riêng bao gốm các tiến trình chờ được cấp phát tài nguyên đó.

Hình 8 : Danh sách chờ của các tiến trình trong hệ thống.

Quá trình xử lý của một tiến trình trải qua những chu kì chuyển đổi qua lại giữa những danh sách săn sàng và danh sách chờ đợi.Sơ đồ dưới đây mô tả sự điều phối các tiến trình dựa trên các danh sách của hệ thống

Thoạt đầu tiến trình mới được đặt trong danh sách các tiến trình săn sàng(ready list),nó sẻ đợi trong danh sách này cho đến khi được chọn để cập phát CPU và bắt xử lý.Sau đó có thể xảy ra một trong các tình huống sau:

Tiến trình phát sinh một yêu cầu một tài nguyên mà hệ thống chưa thể đáp ứng,khi đó tiến trình sẽ được chuyển sang danh sách các tiến trình đang chờ tài nguyên tương ứng.



Tiến trình có thể bị bắt buộc tạm dừng xử lý do một lý do ngắt xảy ra,khi đó tiến trình được đưa trở lại vào danh sách săn sàng để chờ được cấp CPU cho lượt tiếp theo.

Hình 9: Sơ đồ chuyển đổi giữa các danh sách điều phối

Trường hợp đầu tiên,tiến trình cuối cùng sẻ chuyển từ trạng thái blocket sang trạng thasiready và lại được đưa vào danh sách săn sàng.Tiến trình lặp lại cho đến khi hoàn tất tác vụ thì được hệ thống hủy bỏ khỏi mọi danh sách điều phối.

Các cấp độ điều phối.Thực ra công việc điều phối được hệ điều hành thực hiện ở hai mức độ: Điều phối

tác vụ và điêu phối tiến trình.

Điều phối tác vụ Quyết đinh lựa chọn tác vụ nào được đưa vào hệ thống,và nạp những tiến trình của

tác vụ đó vào bộ nhớ chính để thực hiện.Chức năng điều phối tác vụ quyết định mức độ đa chương của hệ thống(số lượng tiến trình trong bộ nhớ chính).Khi hệ thống tạo lập tiến trinh,hay có một tiến trình kết thúc xử lý chức năng và điều phối tác vụ có tần suất hoạt động thấp.

Để hệ thống hoạt động tốt,bộ điều phối tác vụ cần biết tính chất của tiến trình là hướng nhập xuất hay hướng xử lý.Một tiến trình được gọi là hướng nhập xuất nếu nó chủ yếu chỉ sử dụng CPU để thực hiện thao tác nhập xuất.Ngược lại một tiến trình được gọi là hướng xử lý nếu nó chủ yếu chỉ sử dụng CPU để thực hiện các thao tác tính toán.Để cân bằng hoạt động của CPU và các thiết bị ngoại vi,bộ điều phối tác vụ nên lựa chọn các tiến trình để nạp vào bộ nhớ sao cho hệ thống là sự pha trộn hợp lý giữa các tiến trình hướng nhập xuất và các tiến trình hướng xử lý.

Điều phối tiến trìnhChọn một tiến trình ở trạng thái săn sàng(đả nạp vào bộ nhớ chính,và có đủ tài

nguyên để hoạt động) và cấp phát CPU cho tiến trình đó thực hiện.Bộ điều phối tiến



trình có tần suất hoạt động cao,sau mỗi lần xảy ra ngắt(do đồng hồ bào giờ,do các thiết bị ngoại vi…)thường là 1 lần trong khoảng 100ms.Do vậy để nâng cao hiệu suất của hệ thống,cần phải tăng tốc độ xử lý của bộ hệ điều phối tiến trình.Chức năng điều phối tiến trình là một trong chức năng cơ bản,quan trọng nhất của hệ điều hành.

Trong nhiều hệ điều hành,có thể không có bộ điều phối tác vụ hoặc tách biệt rất ít đối với bộ điều phối tiến trình.Một vài hệ điều hành lại đưa ra một cấp độ điều phối trung gian kết hợp cả hai cấp độ điều phối tác vụ và tiến trình.

Hình 10: Cấp độ điều phối

Các chiến lược điều phối Phân tích các điều phối sử dụng trong cơ chế một hàng đợi các tiến trình:

Chiến lược FIFONguyên tắc: CPU được cấp phát cho tiến trình đầu tiên trong danh sách săn sàng có

yêu cầu, là tiến trình được đưa vào hệ thống sớm nhất. Đây là một thuật toán điều phối theo nguyên tắc độc quyền. Một khi CPU được cấp phát cho tiến trình, CPU chỉ được tiến trình tự nguyện giải phóng khi kết thúc xử lí hay khi có một yêu cầu xuất/ nhập. Chiến lược này thì thời gian chờ trung bình không đạt cực tiểu và biến đổi đáng kể đối với các giá trị về thời gian yêu cầu xử lí và thứ tự khác nhau của cácd tiến trình trong danh sách săn sàng. Cá thể xảy ra hiện tượng tích luỹ thời gian chờ, khi tất cả các tiến trình phảI chờ đợi một tiến trình có yêu cầc thời gian dài kết thúc xử lí .Giải thuật này đặc biệt không phù hợp với các hệ phân chia thời gian, trong các hệ này, cần cho phếp mỗi tiến trình được cấp phát CPU đều đặn trong từng khoảng thời gian.

Vid dụ:



Tiến trình thời điểm vào t/g xử lýP1 0 24P2 1 3P3 2 3

Thứ tự cấp phát tiến trình:

Tiến trình P1 P2 P3

Thời điểm 0 24 27| 30

Thời gian chờ trung bình: 30/3=10.

Chiến lược xoay vòng (RR)Nguyên tắc: Danh sách săn sàng được xử lí như một danh sách vòng, bộ điều phối

lần lượt cấp phát cho từng tiến trình trong danh sách một khoảng thời gian sử dụng CPU đến hết thời gian quantum dành cho nó, hệ điều hành thu hồi và cấp phát cho quá trình kế tiếp trong danh sách. Nếu tiến trình bị khoá hay kết thúc trước khi sử dụng hết thời gian quantum, hệ điều hành cũng lập tức cấp phát CPU cho tiến trình khác. Khi tiến tình tiêu thụ hết thời gian CPU cấp phát dành cho nó mà chưa hoàn tất, tiến trình được đưa trở lại vào cuối danh sách săn sàng để được cấp CPU trong lượt kế tiếp.

Vấn đề quan tâm đối với giả thuật RR là độ dài quantum quá bé sẽ phát sinh quá nhiều sự chuyển đổi giữa các tiến trình và khiến cho việc sử dụng quantum quá lớn sẽ làm tăng thời gian hỏi đáp và giảm khả năng tương tác của hệ thống.

Ví dụ: Tiến trình thời điểm vào t/g xử lýP1 0 24P2 1 3P3 2 3 Quantum = 4

Thì thứ tự cấp processor cho các tiến trình lần lượt là:

Tiến trình P1 P2 P3 P1 P1 P1 P1 P1

Thời điểm 0 4 7 10 14 18 22 26

Vậy thời gian chờ đợi trung bình sẽ là: (0 + 6 + 3 + 5)/3 = 4.46Như vậy RR có thời gian chờ đợi trung bình nhỏ hơn so với FIFO.

Trong chiến lược này, vấn đề đặt ra đối với công tác thiết kế là: nên chon quantum bằng bao nhiêu là thích hợp, nếu quantum nhỏ thì hệ thống phải tốn nhiều thời gian cho việc cập nhật ready list và chuyển trạng thái tiến trình, dẫn đến vi phạm mục tiêu: khai thác tối đa thời gian xử lý của processor. Nếu quantum lớn thì thời gian chờ đợi trung bình vàthời gian hồi đáp sẽ tăng lên, dẫn đến tính tương tác của hệ thống bị giảm xuống.



Chiến lược điều phối với độ ưu tiênTrong chiến lược này, bộ phận điều phối tiến trình dựa vào độ ưu tiên của các tiến

trình để tổ chức cấp processor cho tiến trình. Tiến trình được chọn để cấp processor là tiến trình có độ ưu tiên cao nhất, tại thời điểm hiện tại.

Ở đây hệ điều hành thường tổ chức gán độ ưu tiên cho tiến trình theo nguyên tắc kết hợp giữ gán tĩnh và gán động. Khi khởi tạo tiến trình được gán độ ưu tiên tĩnh, sau đó phụ thuộc vào môi trường hoạt động của tiến trình và công tác điều phối tiến trình của bộ phận điều phối mà hệ điều hành có thể thay đổi độ ưu tiên của tiến trình.

Khi hệ thống phát sinh một tiến trình ready mới, thì bộ phận điều phối sẽ so sánh độ ưu tiên của tiến trình mới phát sinh với độ ưu tiên của tiến trình đang sở hữu processor (tạm gọi là tiến trình hiện tại). Nếu tiến trình mới có độ ưu tiên thấp hơn tiến trình hiện tại thì bộ phận điều phối sẽ chèn nó vào ready list tại vị trí thích hợp. Nếu tiến trình mới có độ ưu tiên cao hơn tiến trình hiện tại thì bộ điều phối sẽ thu hồi processor từ tiến trình hiện tại để cấp cho tiến trình mới yêu cầu, nếu là điều phối không độc quyền, hoặc chèn tiến trình mới vào ready list tại vị trí thích hợp, nếu là điều phối độc quyền.

Chiến lược này cũng phải sử dụng ready list, và ready list luôn được xếp theothứ tự giảm dần của độ ưu tiên kể từ đầu danh sách. Điều này có nghĩa là tiến trìnhđược chọn để cấp processor là tiến trình ở đầu ready list.Ví dụ: Nếu hệ điều hành cần cấp processor cho 3 tiến trình P1, P2, P3 với độ ưu tiên và khoảng thời gian mỗi tiến trình cần processor được mô tả trong bảng sau:

Tiến trình độ ưu tiên thời gian xử lýP1 3 24P2 1 3P3 2 3

Thì thứ tự cấp processor (theo nguyên tắc độc quyền) cho các tiến trình lầnlượt là:

Tiến trình P1 P2 P3 P1

Thời điểm 0 1 4 7

Thời gian chờ trung bình:

Chiến lược công việc ngắn nhất SJF Nguyên tắc: Đây là một trường hợp đặp biệt của giải thuật điều phối với độ ưu tiên p được gán cho mỗi tiến trình là mỗi tiến trình là nghịch đảo của thời gian xử lí mà tiến trình yêu cầu: p=1/t. Khi CPU được tự do thì nó sẽ được cấp phát cho tiến trình yêu cầu ít thời gian nhất để kết thúc tiến trình ngắn nhất. Giải thuật này cũng có khả năng độc quyền hay không độc quyền. Sự lựa chọn xảy ra khi có một tiến trình mới đưa vào danh sách săn sàng trong khi một tiến trình khác đang xử lí. Tiến trình mới có thể sở hữu một yêu cầu thời gian sử dụng CPU cho lần tiếp theo ngắn hơn thời gian còn lại mà tiến trình hiện hành cần xử lí. GiảI thuật SJF không độc quyền sẽ dừng họat động của tiến



trình hiện hành, trong khi giải thuật độc quyền sẽ cho phép tiến trình hiện hành tiếp tục xử lí. Giải thụât này cho phép đạt được thời gian chờ trung bình cực tiểu. Khó khăn thực sự của giải thuật SJF là không thể biết được thời gian xử lí lần thứ n, tn+1 là giá trị dự đoán cho lần xử lí tiếp theo. Với hy vọng gia trị dữ đoán sẽ giống với các giá trị trước đó, có thể sử dụng công thức:Tn+1 = α tn+1(1-α)tn

Trong đó tn+1 chứa đựng thông tin gần nhất, tn chứa đựng các thông tin quá khứ được tích luỹ, tham số ỏ kiểm soát trọng số hiện tại gần hay quá khứ ảnh hưởng đến công thức dữ toán.



CHƯƠNG 3. THIẾT KẾ VÀ XÂY DỰNG CHƯƠNG TRÌNH

3.1 Phân tích yêu cầuTìm hiểu về bộ định thời trong quản lý tiến trình.Sử dụng các bộ điều phối

FIFO,SJF,RR,ƯU TIÊN.Để làm rỏ các giải thuật:Nhập vào n tiến trình.P1,P2,……Pn.Thời gian đến tăng dần theo theo thứ tự nhập tiến trinh.Đưa các tiến trình vào danh sách ban đầu.Sử dụng các thuật toán FIFO,SJF,RR,thuật toán ưu tiên để xử lý các tiến trinh.Xuất ra thời gian chờ trung bình của từng quá trình xử lý.

3.2 Các chức năng

3.2.1 Cài đặt thuật toán

3.2.1.1 Đề tài : Mô phỏng chiến lược một hàng đợi nhiều tiến trình chờ phần phối xử lý.

3.2.2 Phân tích đề:Nhập vào tên các tiến trình, thời gian đến và thời gian xử lý. Phân tích độ ưu tiên

của các tiến trình và thứ tự được đưa vào danh sách săn sàng.Tiến trình nào được ưu tiên sẻ thực hiện trước ,nếu một tiến trình đang xử lý mà có một tiến trình khác được nạp vào danh sách săn sàng,nếu tiến trình mới được ưu tiên thì sẻ được cung cấp CPU và tiến trình đang xử lý được xếp vào hàng đợi.Sau đó in ra thứ tự thực hiện của các tiến trình.Sữ dụng các thuật toán FIFO.SJF,độ ưu tiên,RR.

3.2.3 Mô tả bài toán.Chúng ta se xấy dựng chương trình đơn giản bằng C.Mô phỏng kết quả xử lý của các tiến trình thông qua thuật toán FIFO,SJF,ƯU TIÊN,RR.Đầu vào: Các tiến trình p0,p1,p2,p3,….

Thời gian đến của mỗi tiến trình.Thời gian xử lý của tiến trình.

Đầu ra: Thời gian môi tiến trình sử dụng CPU, thời gian chờ của mỗi tiến trình trong CPU,và thời gian chờ trung bình của cả quá trình xử lý.

-Khởi tạo một đối tượng là một tiến trình chứa các thuộc tính: tgvao,tgxuly,tentt,tgcho,stt.

Với thuật toán RR : cần có thời gian quan tum.

FIFO:#include <stdio.h>#include <conio.h>



typedef struct PR{ char ten[12]; int txly; int tcho; int tluu; int stt; } PROCESS;PROCESS a[20];int n, j, ok[20];float tb;void In(PROCESS a[20]);void FIFO();void Fuctions1(); //Main()main(){ Fuctions1();}//Fuctions()void Fuctions1(){ do{ printf("\n\t----------------GIAI THUAT DINH THOI FIFO---------------\n\n"); printf("\n So luong tien trinh: n = "); scanf("%d",&n); }while((n<=0)||(n>20)); In(a); FIFO(); getch();}//In()void In(PROCESS a[20]){ int i=1; while (i<=n) { fflush(stdin); printf("\n\tTen tien trinh : "); gets(a[i].ten); printf("\tThoi gian xu ly: "); scanf("%d",&a[i].txly); i++;



} }//FIFOvoid FIFO(){ printf("\n\nthuat toan FIFO"); int i,t,d,id,tt=0; PROCESS *k=a; for (i=0; i<=n;i++) ok[i]=0; ok[0]=-1; t=k[0].txly; k[0].tcho=0; k[0].stt=1; k[0].tluu=t; j=1; while(j<=n) { d=0; int tmin=99; for(i=1; i<=n; i++)//dua tien trinh vao cpu if(ok[i]!=-1) { d++; ok[i]=1; } if (d!=0) { d--; id=j; } ok[id]=-1; k[id].stt=j; k[id].tcho=t; t=t+k[id].txly; k[id].tluu=k[id].tcho + k[id].txly; j++; };



printf("\n\t----------------GIAI THUAT DINH THOI FIFO---------------\n\n"); printf("\n\t\t|TT | Ten TT | SD CPU | Tgluu| TgCho|\n"); printf("\t\t----------------------------------------"); for (i=1; i<=n; i++) { printf("\n\t\t| %2d | %6s | %6d | %4d | %4d |", i,k[i].ten,k[i].txly,k[i].tluu,k[i].tcho); tt=tt+k[i].tcho; } tb=(float)tt/n; printf("\nthoi gian cho trung binh la: %.2f",tb); getch();}// Với thuật toán này tiến nào vào trước sẻ được xử lý trước.Tiến trình nào vào sẻ được gán với chỉ số id=j; và xử lý.

Với 3 thuật toán còn lại do phải sử dụng hàng đợi,nên thuật toán được sử dụng danh sách liên kết.Trước hết để thuận tiện việc thao tác trên danh sách liên kết,cần tạo một lớp các hàm thao tác trên danh sách liên kết.

#include<conio.h>#include<iostream>#include<stdlib.h>typedef struct PR{ char ten[10]; //<<<--- int tvao; int txuly; int uutien; int tcho; int tluu; int stt; } PROCESS;struct process_element{ int stt; int tvao; int txuly; int ttong; process_element *next; };typedef process_element *process_list; //danh sách hang doi cac tien trinhstruct gantt_element{ int stt;



int tgian; int tbatdau; gantt_element *next; };typedef gantt_element *table_gantt;//tao bang gantt

void read_data_from_file(char fileName[], PROCESS a[], int *n, int *quantum){ FILE *file; if( (file=fopen(fileName,"r")) == NULL ) { printf("File not exist..."); getch(); exit(1); } char *s;

s=(char *)calloc(10,sizeof(char)); // :::||| int num; fscanf(file,"%d",n); for(int i=0;i<*n;i++) a[i].stt=i; for(int i=0;i<*n;i++) { fscanf(file,"%s",s); strcpy(a[i].ten,s); } for(int i=0;i<*n;i++) { fscanf(file,"%d",&num); a[i].tvao=num; } for(int i=0;i<*n;i++) { fscanf(file,"%d",&num); a[i].txuly=num; } for(int i=0;i<*n;i++) { fscanf(file,"%d",&num); a[i].uutien=num;



} fscanf(file,"%d",&num); *quantum=num; fclose(file);}

//overloading functionvoid read_data_from_file(char fileName[], PROCESS a[], int *n){ FILE *file; if( (file=fopen(fileName,"r")) == NULL ) { printf("File not exist..."); getch(); exit(1); } char *s;

s=(char *)calloc(10,sizeof(char)); // :::||| int num; fscanf(file,"%d",n); for(int i=0;i<*n;i++) a[i].stt=i; for(int i=0;i<*n;i++) { fscanf(file,"%s",s); strcpy(a[i].ten,s); } for(int i=0;i<*n;i++) { fscanf(file,"%d",&num); a[i].tvao=num; } for(int i=0;i<*n;i++) { fscanf(file,"%d",&num); a[i].txuly=num; } for(int i=0;i<*n;i++) { fscanf(file,"%d",&num); a[i].uutien=num;



} fclose(file);}

void show_process_all(PROCESS a[], int n){ printf("\n"); printf("n=%d\n",n); printf("Ten tien trinh: "); for(int i=0;i<n;i++) printf("%6s",a[i].ten); printf("\nThoi gian vao: "); for(int i=0;i<n;i++) printf("%6d",a[i].tvao); printf("\nThoi gian xu ly:"); for(int i=0;i<n;i++) printf("%6d",a[i].txuly); printf("\nDo uu tien "); for(int i=0;i<n;i++) printf("%6d",a[i].uutien); printf("\n");}void show_process_list(process_list p)//hi?n thi danh sach cac tien trinh ban dau :D{ process_list tem=p; process_list trace=p; printf("\n"); printf("\tstt\t tvao\t txuly\t ttong\n"); while(tem!=NULL) { printf("%10d%10d%10d%8d\n",(*tem).stt,(*tem).tvao,(*tem).txuly,(*tem).ttong); tem=(*tem).next; if(tem==trace) break; //tranh lap vo han voi danh sach vong }}void make_node_process(process_list &node,int stt, int tvao, int txuly, int ttong)//tao node chua cua tien trinh chua : stt,txuly,ttong{ (*node).stt=stt; (*node).tvao=tvao; (*node).txuly=txuly; (*node).ttong=ttong; (*node).next=NULL;}



void add_element_to_head_process_list(process_list &list, int stt, int tvao, int txuly, int ttong){ process_list node=new process_element; make_node_process(node,stt,tvao,txuly,ttong); (*node).next = list; list=node;}void add_element_to_tail_process_list(process_list &list,int stt, int tvao, int txuly, int ttong){ process_list node=new process_element; make_node_process(node,stt,tvao,txuly,ttong); process_list tail=list; if(tail==NULL) { list=node; } else { while( (*tail).next != NULL) tail=(*tail).next; (*tail).next=node; }}//them mot phan t vao dau danh sach cac tien trinhvoid add_element_before_node_process_list(process_list &list, process_list &trace, int stt, int tvao, int txuly, int ttong){ if(list==trace) add_element_to_head_process_list(list,stt,tvao,txuly,ttong); else { process_list tem=list; while( (*tem).next != trace ) tem=(*tem).next; process_list node=new process_element; make_node_process(node,stt,tvao,txuly,ttong); (*node).next=trace; (*tem).next=node; }}//them mot tien trinh vao cuoi danh sach các tien trình



void add_element_after_node_process_list(process_list &list, process_list &trace, int stt, int tvao, int txuly, int ttong){ if( (*trace).next==NULL ) add_element_to_tail_process_list(list,stt,tvao,txuly,ttong); else { process_list node=new process_element; make_node_process(node,stt,tvao,txuly,ttong); (*node).next=(*trace).next; (*trace).next=node; }}//xoa tien trinh dau danh sach void delete_element_in_head_process_list(process_list &list){ list=(*list).next;}//xoa tien trinh tail(o cuoi danh sach :D)void delete_element_in_tail_process_list(process_list &list){ process_list tem=list; while( (*tem).next!= NULL ) tem=(*tem).next; (*tem).next=NULL;}//xoa mot tien trinh truoc mot tien trinh khac(khong phai dau danh sach)void delete_element_before_node_process_list(process_list &list, process_list &trace){ if( list==trace ) list=NULL; if( (*list).next==trace ) list=trace; else { process_list tem=list; while( (*(*tem).next).next!=trace) tem=(*tem).next; (*tem).next=trace; }}

void delete_element_after_node_process_list(process_list &list, process_list &trace){ if( trace!=NULL ) (*trace).next=(*(*trace).next).next;



}

void swap_node_process_list(process_list &l1, process_list &l2){ int stt=(*l2).stt; int tvao=(*l2).tvao; int txuly=(*l2).txuly; int ttong=(*l2).ttong; (*l2).stt=(*l1).stt; (*l2).tvao=(*l1).tvao; (*l2).txuly=(*l1).txuly; (*l2).ttong=(*l1).ttong; (*l1).stt=stt; (*l1).tvao=tvao; (*l1).txuly=txuly; (*l1).ttong=ttong;}////circle list//void make_circle_process_list(process_list &list){ process_list tem=list; while( (*tem).next!=NULL) tem=(*tem).next; (*tem).next=list;}

void delete_element_before_node_circle_process_list(process_list &list){ process_list tem=list; while( (*(*tem).next).next != list ) tem=(*tem).next; (*tem).next=list;}

void add_element_after_node_circle_process_list(process_list &list,int stt, int tvao, int txuly, int ttong){ process_list node=new process_element; make_node_process(node,stt,tvao,txuly,ttong); (*node).next=(*list).next; (*list).next=node;



}// cac ham lam viec voi danh sach lien ket // table_gantt////void show_table_gantt(table_gantt g){ table_gantt tem=g; printf("\n"); printf("\tstt\ttbatdau\t tgian\n"); while(tem!=NULL) { printf("%10d%10d%10d\n",(*tem).stt,(*tem).tbatdau,(*tem).tgian); tem=(*tem).next; } printf("\n");}void make_node_gantt(table_gantt &node,int stt, int tbatdau, int tgian){ (*node).stt=stt; (*node).tgian=tgian; (*node).tbatdau=tbatdau; (*node).next=NULL;}void add_element_to_head_table_gantt(table_gantt &gantt, int stt, int tbatdau, int tgian){ table_gantt node=new gantt_element; make_node_gantt(node,stt,tbatdau,tgian); (*node).next = gantt; gantt=node;}void add_element_to_tail_table_gantt(table_gantt &gantt,int stt, int tbatdau, int tgian){ table_gantt node=new gantt_element; make_node_gantt(node,stt,tbatdau,tgian); if(gantt==NULL) gantt=node; else { table_gantt tail=gantt; while( (*tail).next != NULL) tail=(*tail).next; (*tail).next=node;



}}void add_element_before_node_table_gantt(table_gantt &gantt, table_gantt &trace, int stt, int tbatdau, int tgian){ if(gantt==trace) add_element_to_head_table_gantt(gantt,stt,tbatdau,tgian); else { table_gantt tem=gantt; while( (*tem).next != trace ) tem=(*tem).next; table_gantt node=new gantt_element; make_node_gantt(node,stt,tbatdau,tgian); (*node).next=trace; (*tem).next=node; }}

void add_element_after_node_table_gantt(table_gantt &gantt, table_gantt &trace, int stt, int tbatdau, int tgian){ if( (*trace).next==NULL ) add_element_to_tail_table_gantt(gantt,stt,tbatdau,tgian); else { table_gantt node=new gantt_element; make_node_gantt(node,stt,tbatdau,tgian); (*node).next=(*trace).next; (*trace).next=node; }}

void delete_element_in_head_table_gantt(table_gantt &gantt){ gantt=(*gantt).next;}

void delete_element_in_tail_table_gantt(table_gantt &gantt){ table_gantt tem=gantt; while( (*tem).next!= NULL ) tem=(*tem).next; (*tem).next=NULL;}



void delete_element_before_node_table_gantt(table_gantt &gantt, table_gantt &trace){ if( gantt==trace ) gantt=NULL; if( (*gantt).next==trace ) gantt=trace; else { table_gantt tem=gantt; while( (*(*tem).next).next!=trace) tem=(*tem).next; (*tem).next=trace; }}

void delete_element_after_node_table_gantt(table_gantt &list, table_gantt &trace){ if( trace!=NULL ) (*trace).next=(*(*trace).next).next;}

void swap_node_table_gantt(table_gantt &l1, table_gantt &l2){ int stt=(*l2).stt; int tbatdau=(*l2).tbatdau; int tgian=(*l2).tgian; (*l2).stt=(*l1).stt; (*l2).tbatdau=(*l1).tbatdau; (*l2).tgian=(*l1).tgian; (*l1).stt=stt; (*l1).tbatdau=tbatdau; (*l1).tgian=tgian;}//in ra bang thoi gian cap phat CPUvoid show_CPU_time_table(table_gantt gantt, PROCESS a[]){ printf("\n"); table_gantt tem=gantt; printf(" \t| Thoi gian Ten tien trinh|\n"); printf("\n\t|----------------------------------|\n"); while( tem!=NULL ) { if( (*tem).stt==-1 )



{ printf("\t|%4d - %4d\t\t%s|\n", (*tem).tbatdau, (*tem).tbatdau + (*tem).tgian, " CPU ranh"); printf("\t|----------------------------------|\n"); } else { printf("\t|%4d - %4d\t\t%s|\n", (*tem).tbatdau, (*tem).tbatdau + (*tem).tgian, a[(*tem).stt].ten); printf("\t|----------------------------------|\n"); } tem=(*tem).next; } printf("\n");}

//in ra thoi gian cho, thoi gian luuvoid show_count_time(PROCESS a[], int n){ int sum=0; for(int i=0;i<n;i++) sum+=a[i].tcho; printf("|Ten tien trinh | Thoi gian cho | Thoi gian luu | tg su dung CPU| \n"); printf("|-----------------------------------------------------------------------|\n"); for(int i=0;i<n;i++) printf("|\t%s\t|\t%4d\t |\t%4d\t\t| \t%4d\t|\n",a[i].ten,a[i].tcho,a[i].tluu,a[i].txuly); printf("|-----------------------------------------------------------------------|\n"); printf("\nThoi gian cho trung binh = %d/%d = %d\n",sum,n,sum/n);}void tinh_tcho_tluu(table_gantt gantt, PROCESS a[], int n){ table_gantt tem=gantt; int time=0; int mark_last_time_excute[n]; int i; for(i=0;i<n;i++) mark_last_time_excute[i]=a[i].tvao; for(i=0;i<n;i++) a[i].tcho=0; while( tem!=NULL) { i=(*tem).stt; if(i!=-1) {



a[i].tcho+=time-mark_last_time_excute[i];//tinh thoi gian cho time+=(*tem).tgian; a[i].tluu=time; //tim thoi gian luu lai he thong mark_last_time_excute[i]=time; } else time+=(*tem).tgian; tem=(*tem).next; } for(i=0;i<n;i++) a[i].tluu-=a[i].tvao;}

RR#include"pre.cpp"#include<conio.h>#include<iostream>#include<stdlib.h>

PROCESS a[20];int n; //number of processesint quantum;process_list queue;table_gantt gantt;

void round_robin(){ int i; int time=0; process_list buffer; //tao buffer //dua cac process tu a[] vao buffer buffer=NULL; for(i=0;i<n;i++) { add_element_to_tail_process_list(buffer,a[i].stt,a[i].tvao,a[i].txuly,a[i].tvao+a[i].txuly); } //sap xep tang gian buffer theo tvao process_list tem_p1=buffer, tem_p2; while(tem_p1!=NULL) {



tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao<(*tem_p1).tvao ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } gantt=NULL; queue=NULL; add_element_to_tail_process_list(queue,-1,0,0,0); make_circle_process_list(queue); //tao bieu do gantt //loai node co tconlai=0 //table_gantt node_g, tem_g; //tem_g=new gantt_element; //gantt=tem_g; do { //kiem tra trong buffer process nao co tvao <= time thi cho vao hang doi while( buffer!=NULL && (*buffer).tvao <= time ) { if( (*queue).txuly==0 ) //(truong hop queue rong) tao queue moi gom 1 phan tu { queue=NULL; add_element_to_tail_process_list( queue, (*buffer).stt,(*buffer).tvao, (*buffer).txuly, (*buffer).ttong); make_circle_process_list(queue); buffer=(*buffer).next; } else { //dua process vao queue //dua vao ngay sau queue (de xu ly ngay lan tiep theo) //neu (*queue).next chua xu ly lan nao(co txuly nhu cu) thi dua vao sau (*queue).next



process_list tem=queue; while( (*(*tem).next).txuly == a[(*(*tem).next).stt].txuly && (*tem).next != queue ) tem=(*tem).next; add_element_after_node_circle_process_list(tem,(*buffer).stt,(*buffer).tvao,(*buffer).txuly,(*buffer).ttong); buffer=(*buffer).next; //neu queue da xu ly va queue.next chua xu ly thi nhuong cho queue.next //biet duoc bang cach so sanh txuly int id1=(*queue).stt, id2=(*(*queue).next).stt, txl1=(*queue).txuly, txl2=(*(*queue).next).txuly; if( txl1 < a[id1].txuly && txl2 == a[id2].txuly ) queue=(*queue).next; } } //neu queue rong va buffer.tvao > time //cho cpu "nghi viec" trong khoang thoi gian (tvao-time) //dua process tiep theo gan nhat vao if( (*queue).txuly==0 && buffer!=NULL) { add_element_to_tail_table_gantt(gantt,-1,time,(*buffer).tvao-time); time=(*buffer).tvao; queue=NULL; add_element_to_tail_process_list(queue,(*buffer).stt,(*buffer).tvao,(*buffer).txuly,(*buffer).ttong); make_circle_process_list(queue); buffer=(*buffer).next; } //xu ly process o hang doi queue //dua them node vao bang gantt //(doan chuong trinh chinh xu ly cac process) if( (*queue).tvao <= time ) { if( quantum>=(*queue).txuly ) { add_element_to_tail_table_gantt(gantt,(*queue).stt,time,(*queue).txuly); time+=(*queue).txuly; (*queue).txuly=0; queue=(*queue).next;



delete_element_before_node_circle_process_list(queue); } else { add_element_to_tail_table_gantt(gantt,(*queue).stt,time,quantum); (*queue).txuly-=quantum; queue=(*queue).next; time+=quantum; } } } while( (*queue).txuly!=0 || buffer !=NULL ); //khi tconlai=0 tuc la queue rong (do tinh chat danh sach lien ket vong phai co >=1 phan tu)}

main(){ read_data_from_file("input2.txt",a,&n,&quantum); show_process_all(a,n); printf("\nquantum=%d\n",quantum); printf("\n"); round_robin(); //printf("\ngantt:\n"); //show_table_gantt(gantt); printf("\nbang thoi gian cap phat cpu:\n"); show_CPU_time_table(gantt,a); tinh_tcho_tluu(gantt, a ,n); printf("\n"); show_count_time(a, n); getch();}

Thuật toán ưu tiên không độc quyền//cai nao uu tien cao hon giai quyet truoc ngay khi co the#include"pre.cpp"#include<conio.h>#include<iostream>#include<stdlib.h>

PROCESS a[20];int n;

process_list list;



table_gantt gantt;

//ttong la do uu tien :">//dua cac process vao buffer//sap xep buffer//tang dan theo tvao, cung tvao thi tang dan theo do uu tien////tim tiep uutien lon hon gan nhat xu ly truoc//phan chua xu ly dua vao stack

void UuTien_KhongDocQuyen(){ int i; int time; process_list buffer=NULL, stack=NULL; gantt=NULL; //dua process tu a[] vao buffer for(i=0;i<n;i++) add_element_to_tail_process_list(buffer, a[i].stt, a[i].tvao, a[i].txuly, a[i].uutien); //sap xep tang dan theo tvao process_list tem_p1=buffer, tem_p2; while( tem_p1!=NULL ) { tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao < (*tem_p1).tvao ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //neu tvao bang nhau sap xep tang dan theo uu tien tem_p1=buffer; while( tem_p1!=NULL ) { tem_p2=tem_p1; while(tem_p2!=NULL) {



if( (*tem_p2).tvao == (*tem_p1).tvao && (*tem_p2).ttong < (*tem_p1).ttong ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //printf("\nbuffer:\n"); //show_process_list(buffer); //getch(); time = (*buffer).tvao; if(time>0) add_element_to_tail_table_gantt( gantt, -1, 0, time); while( buffer !=NULL || stack !=NULL ) { if( stack==NULL && buffer!=NULL ) { //dua process tu buffer vao stack neu stack rong add_element_to_head_process_list(stack, (*buffer).stt, (*buffer).tvao, (*buffer).txuly, (*buffer).ttong ); buffer=(*buffer).next; } //tim process trong buffer co uu tien lon hon process tai stack process_list tem=buffer; while( tem!=NULL && (*stack).ttong<=(*tem).ttong ) { tem=(*tem).next; } if( tem!=NULL) //ton tai process co uu tien lon hon { if( time + (*stack).txuly < (*tem).tvao ) { add_element_to_tail_table_gantt(gantt, (*stack).stt, time, (*stack).txuly); time += (*stack).txuly; delete_element_in_head_process_list(stack); //dua process o buffer vao stack if( stack==NULL ) {



add_element_to_head_process_list(stack, (*buffer).stt, (*buffer).tvao, (*buffer).txuly, (*buffer).ttong); buffer=(*buffer).next; } } else { add_element_to_tail_table_gantt(gantt, (*stack).stt, time, (*tem).tvao-time); int txuly=time+(*stack).txuly-(*tem).tvao; int stt=(*stack).stt; int tvao=(*stack).tvao; int ttong=(*stack).ttong; time = (*tem).tvao; //cap nhat time delete_element_in_head_process_list(stack); if( txuly>0 ) add_element_to_head_process_list(stack, stt, tvao, txuly, ttong ); //dua process *tem dang tro toi vao *stack va //xoa process nay add_element_to_head_process_list( stack, (*tem).stt, (*tem).tvao, (*tem).txuly, (*tem).ttong ); tem=(*tem).next; delete_element_before_node_process_list(buffer,tem); } } else //xu ly process tai stack { if( time < (*stack).tvao ) { add_element_to_tail_table_gantt(gantt, -1, time, (*stack).tvao-time); time=(*stack).tvao; } add_element_to_tail_table_gantt(gantt, (*stack).stt, time, (*stack).txuly ); time+= (*stack).txuly; delete_element_in_head_process_list(stack); } } }



main(){ read_data_from_file("input4.txt",a,&n); show_process_all(a,n); //getch(); UuTien_KhongDocQuyen(); //printf("\ngantt:\n"); //show_table_gantt(gantt); //getch(); printf("\nbang thoi gian cap phat cpu:\n"); show_CPU_time_table(gantt, a); //getch(); tinh_tcho_tluu(gantt, a, n); show_count_time(a, n); getch();}

Thuật toán ưu tiên độc quyền//Uu tien doc quyen//cai nao da giai quyet la giai quyet den khi hoan thanh#include"pre.cpp"#include<conio.h>#include<iostream>#include<stdlib.h>


process_list buffer;table_gantt gantt;

//process vao truoc se thuc hien cho xen khi hoan thanh//khong nhuong CPU cho process vao sau du uu tien cao hon//(doc quyen CPU)void uu_tien_doc_quyen(){ int i; int time=0; buffer = NULL; gantt = NULL; //dua process tu a[] vao buffer



for(i=0;i<n;i++) add_element_to_tail_process_list(buffer, a[i].stt, a[i].tvao, a[i].txuly, a[i].uutien); //sap xep tang dan theo tvao process_list tem_p1=buffer, tem_p2; while( tem_p1!=NULL ) { tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao < (*tem_p1).tvao ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //neu tvao bang nhau sap xep tang dan theo uu tien tem_p1=buffer; while( tem_p1!=NULL ) { tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao == (*tem_p1).tvao && (*tem_p2).ttong < (*tem_p1).ttong ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //printf("\nbuffer:\n"); //show_process_list(buffer); time = 0; while( buffer !=NULL ) { if( time < (*buffer).tvao) { add_element_to_tail_table_gantt(gantt, -1, time, (*buffer).tvao-time ); time = (*buffer).tvao;



} else { process_list tem=buffer; process_list max_priority=buffer; //tim process trong buffer xu ly process co uu tien cao nhat //co tvao <= time //cho process tim duoc vao gantt va xoa khoi buffer while( tem!=NULL && (*tem).tvao <= time ) { if( (*max_priority).ttong > (*tem).ttong ) max_priority = tem; tem=(*tem).next; } //xu ly process tim duoc ( max_priority dang tro toi) add_element_to_tail_table_gantt( gantt, (*max_priority).stt, time, (*max_priority).txuly ); time+=(*max_priority).txuly; //xoa process max_priority dang tro toi max_priority=(*max_priority).next; delete_element_before_node_process_list( buffer, max_priority); } }}

main(){ read_data_from_file("input4.txt",a,&n); show_process_all(a,n); //getch(); uu_tien_doc_quyen(); //printf("\ngantt:\n"); //show_table_gantt(gantt); //getch(); printf("\nbang thoi gian cap phat cpu:\n"); show_CPU_time_table(gantt, a); //getch(); tinh_tcho_tluu(gantt, a, n);



show_count_time(a, n); getch();}

Thuật toán SJF không độc quyền//SJF ko doc quyen//cai nao co the xong truoc giai quyet truoc ngay khi co the#include"pre.cpp"#include<conio.h>#include<iostream>#include<stdlib.h>


process_list list;table_gantt gantt;

//dua cac process vao buffer//sap xep buffer tang dan theo tvao, cung tvao thi tang dan theo do uu tien////tim tiep uutien lon hon gan nhat xu ly truoc//phan chua xu ly dua vao stack

void SJF_KhongDocQuyen(){ int i; int time; process_list buffer=NULL, stack=NULL; gantt=NULL; //dua process tu a[] vao buffer //SJF giong phuong phap lap lich uu tien //do uu tien la thoi gian ket thuc tien trinh = tvao +txuly for(i=0;i<n;i++) add_element_to_tail_process_list(buffer, a[i].stt, a[i].tvao, a[i].txuly, a[i].tvao + a[i].txuly); //sap xep tang dan theo tvao process_list tem_p1=buffer, tem_p2; while( tem_p1!=NULL ) {



tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao < (*tem_p1).tvao ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //neu tvao bang nhau sap xep tang dan theo uu tien tem_p1=buffer; while( tem_p1!=NULL ) { tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao == (*tem_p1).tvao && (*tem_p2).ttong < (*tem_p1).ttong ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //printf("\nbuffer:\n"); //show_process_list(buffer); //neu thoi gian vao lon hon 0 > CPU ranh time = (*buffer).tvao; if(time>0) add_element_to_tail_table_gantt( gantt, -1, 0, time); while( buffer !=NULL || stack !=NULL ) { //dua process tu buffer vao stack if( stack==NULL && buffer!=NULL ) { add_element_to_head_process_list(stack, (*buffer).stt, (*buffer).tvao, (*buffer).txuly, (*buffer).ttong ); buffer=(*buffer).next; }



//tim process tiep theo co uu tien nho hon //uu tien dc tinh bang thoi gian ket thuc neu duoc xu ly ngay process_list tem=buffer; while( tem!=NULL ) { int stack_ttong = time + (*stack).txuly; int tem_ttong = (*tem).tvao > time ? (*tem).ttong : time + (*tem).txuly; if( tem_ttong < stack_ttong ) break; tem=(*tem).next; } if( tem!=NULL) //tim duoc process uu tien hon process tai stack, dua process nay vao stack { if( time + (*stack).txuly < (*tem).tvao ) { add_element_to_tail_table_gantt(gantt, (*stack).stt, time, (*stack).txuly); time += (*stack).txuly; //time delete_element_in_head_process_list(stack); //dua process o buffer vao stack neu stack rong if( stack==NULL ) { add_element_to_head_process_list(stack, (*buffer).stt, (*buffer).tvao, (*buffer).txuly, (*buffer).ttong); buffer=(*buffer).next; } } else { if( (*tem).tvao - time > 0 ) { add_element_to_tail_table_gantt(gantt, (*stack).stt, time, (*tem).tvao-time); int txuly=time+(*stack).txuly-(*tem).tvao; int stt=(*stack).stt; int tvao=(*stack).tvao; // int ttong=(*stack).ttong; // dieu chinh lai ttong (tuc la dieu chinh lai do uu tien) //



delete_element_in_head_process_list(stack); if( txuly>0 ) add_element_to_head_process_list(stack, stt, tvao, txuly, ttong ); time = (*tem).tvao; //cap nhat tine } //dua process *tem dang tro toi vao *stack va xoa process nay add_element_to_head_process_list( stack, (*tem).stt, (*tem).tvao, (*tem).txuly, (*tem).ttong ); tem=(*tem).next; delete_element_before_node_process_list(buffer,tem); } } else //xu ly process tai stack { if( time < (*stack).tvao ) { add_element_to_tail_table_gantt(gantt, -1, time, (*stack).tvao-time); time=(*stack).tvao; } add_element_to_tail_table_gantt(gantt, (*stack).stt, time, (*stack).txuly ); time += (*stack).txuly; /// delete_element_in_head_process_list(stack); } /*printf("time=%d-------\nbuffer:\n",time); show_process_list(buffer); printf("gantt:\n"); show_table_gantt(gantt); printf("stack:\n"); show_process_list(stack); getch();*/ } }

main(){ read_data_from_file("input4.txt",a,&n); show_process_all(a,n); //getch();



SJF_KhongDocQuyen(); printf("\ngantt:\n"); show_table_gantt(gantt); //getch(); printf("\nbang thoi gian cap phat cpu:\n"); show_CPU_time_table(gantt, a); //getch(); tinh_tcho_tluu(gantt, a, n); show_count_time(a, n); getch();

}

SJF độc quyền//SJF doc quyen//#include"pre.cpp"#include<conio.h>#include<iostream>#include<stdlib.h>


process_list buffer;table_gantt gantt;//process vao truoc se thuc hien cho xen khi hoan thanh//khong nhuong CPU cho process vao sau du thoi gian thuc hien ngan hon//(doc quyen CPU)//thuc hien giong uu tien doc quyen//thay uu tien =tvao+txulyvoid SJF_doc_quyen(){ int i; int time=0; buffer = NULL; gantt = NULL; //dua process tu a[] vao buffer for(i=0;i<n;i++) add_element_to_tail_process_list(buffer, a[i].stt, a[i].tvao, a[i].txuly, a[i].tvao + a[i].txuly); //sap xep tang dan theo tvao



process_list tem_p1=buffer, tem_p2; while( tem_p1!=NULL ) { tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao < (*tem_p1).tvao ) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //neu tvao bang nhau sap xep tang dan theo thoi gian tong tem_p1=buffer; while( tem_p1!=NULL ) { tem_p2=tem_p1; while(tem_p2!=NULL) { if( (*tem_p2).tvao == (*tem_p1).tvao && (*tem_p2).ttong < (*tem_p1).ttong) swap_node_process_list(tem_p1,tem_p2); tem_p2=(*tem_p2).next; } tem_p1=(*tem_p1).next; } //printf("\nbuffer:\n"); //show_process_list(buffer); time = 0; while( buffer !=NULL ) { if( time < (*buffer).tvao) { add_element_to_tail_table_gantt(gantt, -1, time, (*buffer).tvao-time ); time = (*buffer).tvao; } else { process_list tem=buffer; process_list max_priority=buffer; //tim process trong buffer xu ly process co uu tien cao nhat



//co tvao <= time //cho process tim duoc vao gantt va xoa khoi buffer while( tem!=NULL && (*tem).tvao <= time ) { if( (*max_priority).ttong > (*tem).ttong ) max_priority = tem; tem=(*tem).next; } //xu ly process tim duoc ( max_priority dang tro toi) add_element_to_tail_table_gantt( gantt, (*max_priority).stt, time, (*max_priority).txuly ); time+=(*max_priority).txuly; //xoa process max_priority dang tro toi max_priority=(*max_priority).next; delete_element_before_node_process_list( buffer, max_priority); } }}main(){ read_data_from_file("input4.txt",a,&n); show_process_all(a,n); //getch(); SJF_doc_quyen(); //printf("\ngantt:\n"); //show_table_gantt(gantt); //getch(); printf("\nbang thoi gian cap phat cpu:\n"); show_CPU_time_table(gantt, a); //getch(); tinh_tcho_tluu(gantt, a, n); show_count_time(a, n); getch();}

CHƯƠNG 4. TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ

4.1 Môi trường triển khai:Ngôn ngữ lập trình C. Chạy mô phỏng trên hệ điều hành windown.



4.2 Kết quả và chức năng của chương trình

4.2.1.1 Kết quả thuật toán FIFO

Hình 11: kết quả thuật toán FIFO.

4.2.1.2 Thuật toán RRHiển thị tiến trình vào:

Hình 12: Hiển thị các tiến trình vào.

Quá trình xử lý các tiến trình:



Hình 13 : Quá trình xử lý.

Kết quả:

Hình 14 : Kết quả.

4.2.1.3 Thuật toán SJF không độc quyền



Hình 15 : Kết quả thuật toán SJF không độc quyền

4.2.1.4 Thuật toán SJF độc quyền

Hình 16 : Kết quả thuật toán SJF độc quyền

4.2.1.5 Thuật toán Ưu tiênkhông đôc quyền



Hình 17 : Kết quả thuật toán ưu tiên không độc quyền

4.2.1.6 Thuật toán ưu tiên độc quyền

Hình 18 : Kết quả thuật toán ưu tiên độc quyền

4.3 Đánh giá kết quả.Đối với 4 thuật toán điều phối một hàng đợi ta nhận thấy thuật toán FIFO có thời gian chờ lớn,các tiến trình phải xử lý lần luợt mặc dù thuật toán đơn giản dễ phân tích.



Thuật toán SJF được đánh giá là thuật toán có thời gian chờ trung bình trong CPU ngắn nhất.


ĐỒ ÁN NGUYÊN LÝ HỆ ĐIỀU HÀNH

Documents

Transcript of ĐỒ ÁN NGUYÊN LÝ HỆ ĐIỀU HÀNH