TRƯỜNG ĐẠI HỌC GIAO THÔNG VẬN TẢI

TP.HCM
Khoa Công Nghệ Thông Tin
TIỂU LUẬN

CPU SCHEDULING
Nhóm 11
Lớp: CN22G

GVHD: Nguyễn Thanh Tiến

SVTH:

Châu Đức Thịnh – 2251120054

Đào Phan Anh Thái –2251120052

Tăng Gia Phát – 2251120038

Hoàng Minh Quân – 2251120042

Nguyễn An Hòa – 2251120012

 MỤC LỤC
MỤC LỤC...........................................................................................................................
DANH MỤC TỪ VIẾT TẮT...........................................................................................
LỜI MỞ ĐẦU....................................................................................................................
5.4 Thread Scheduling.......................................................................................................
5.4.1 Contention Scope............................................................................................................
5.4.2 Pthread Scheduling..........................................................................................................
5.5 Multi-Processor Scheduling........................................................................................
5.5.1 Approaches to Multiple-Processor Scheduling................................................................
5.5.2 Multicore Processors.......................................................................................................
5.5.3 Load Balancing...............................................................................................................
5.5.4 Processor Affinity............................................................................................................
5.5.5 Heterogeneous Multiprocessing....................................................................................
5.6 Real-Time CPU Scheduling......................................................................................
5.6.1 Minimizing Latency........................................................................................................
5.6.2 Priority-Based Scheduling..............................................................................................
5.6.3 Rate-Monotonic Scheduling...........................................................................................
5.6.4 Earliest-Deadline-First Scheduling................................................................................
5.6.5 Proportional Share Scheduling......................................................................................
5.6.6 POSIX Real-Time Scheduling........................................................................................
5.7 Operating-System Examples.....................................................................................
5.7.1 Example: Linux Scheduling............................................................................................
5.7.2 Example: Windows Scheduling.....................................................................................
5.7.3 Example: Solaris Scheduling.........................................................................................
5.8 Algorithm Evaluation................................................................................................
5.8.1 Deterministic Modeling...................................................................................................
5.8.2 Queueing Models...........................................................................................................
5.8.3 Simulations....................................................................................................................
5.8.4 Implementation..............................................................................................................
KẾT LUẬN......................................................................................................................
MIND MAP......................................................................................................................

i
BÀI TẬP...........................................................................................................................
DANH MỤC TÀI LIỆU THAM KHẢO.......................................................................

ii
 DANH MỤC TỪ VIẾT TẮT

Từ viết tắt Cụm từ tiếng anh Cụm từ tiếng việt

CPU Central Processing Unit Xử lý trung tâm

FCFS First-Come-First-Serve Vào trước, thực hiện trước

Non-Uniform Memory Truy cập bộ nhớ không đồng

NUMA
Access nhất
Giải thuật định thời luân
RR Round Robin
phiên
SJF Shortest Job First Công việc ngắn nhất trước

iii
 LỜI MỞ ĐẦU
Điều phối CPU, hay còn gọi là CPU scheduling, là một trong những
khía cạnh quan trọng của hệ thống máy tính và quản lý tài nguyên tính toán.
Trong thời đại số hóa và sự phát triển không ngừng của CNTT, việc tối ưu
hóa việc sắp xếp và chia sẻ thời gian CPU cho các tiến trình là một việc đầy
thách thức.

Điều phối CPU là một phần quan trọng của hệ điều hành, đóng vai trò
quyết định cách hệ thống phân phối thời gian xử lý CPU cho các tiến trình
hoặc nhiệm vụ khác nhau. Hiệu suất của hệ thống, đáng lẽ có thể được nâng
cao, hoặc giảm sút đột ngột, phục thuộc vào cách điều phối CPU được thực
hiện. Sự hiểu biết và nghiên cứu sâu về điều phối CPU là điều cần thiết để
đảm bảo hệ thống hoạt động hiệu quả, đáng tin cậy và đáp ứng được nhu cầu
ngày càng tăng về tính toán. Trong bài này, chúng ta sẽ khám phá về Thread
Scheduling, Multi-Processor Scheduling, Real-Time CPU Scheduling,
Operating-System Examples, Algorithm Evaluation.

4
5.4 Thread Scheduling
Trong mô hình luồng, có sự phân biệt giữa luồng ở cấp độ người dùng và cấp
độ nhân:

+ Luồng ở cấp độ người dùng (user-level): Được quản lý bởi thư viện
luồng và không được nhân hệ điều hành nhận biết trực tiếp. Để có thể
chạy trên CPU, luồng user-level cuối cùng sẽ được gán với một luồng
kernel-level liên kết, mặc dù phép gán này có thể là gián tiếp và có thể
dùng một LWP (tiến trình nhẹ).
+ Còn ở luồng ở cấp độ nhân (kernel-level): Trong hầu hết các hệ điều
hành hiện nay, luồng kernel-level (không phải tiến trình) được điều
phối trực tiếp bởi hệ điều hành.
5.4.1 Contention Scope
Phạm vi cạnh tranh (Contention Scope): Xác định phạm vi mà các luồng cạnh
tranh cho tài nguyên CPU.

Có 2 phạm vi cạnh tranh chính:

+ PCS (Process Contention Scope): Thường được sử dụng trên các mô

hình many-to-many, many-to one. Ở cơ chế này thư viện luồng sẽ
điều phối ho các luồng cấp độ người dùng chạy trên một LWP (tiến
trình nhẹ) có sẵn. Khi PCS cạnh tranh xảy ra giữa các luồng thuộc
cùng một tiến trình => Giảm chi phí chuyển đổi giữa các luồng.
+ SCS (System Contention Scpope): Các hệ thống chỉ sử dụng mỗi
mô hình one-to-one như Windows và Linux… thì các luồng điều
phối chỉ sử dụng duy nhất SCS. Cơ chế này được nhân hệ điều hành
sử dụng quyết định luồng cấp độ nhân nào sẽ được điều phối trên
CPU. Khi CSC cạnh tranh xảy ra giữa tất cả các luồng trên toàn bộ
hệ thống.
=> Tăng chi phí chuyển đổi giữa các luồng nhưng mang lại sự công
bằng giữa các tiến trình.

Sự quyết định phạm vi cạnh tranh sẽ ảnh hưởng đến cách điều phối và cạnh
tranh giữa các luồng. Điều này quan trọng trọng việc đảm bảo hiệu xuất và
công bằng trong việc phân bố tài nguyên hệ thống.

5.4.2 Pthread Scheduling

POSIX Pthread: Là một giao diện lập trình ứng dụng chuẩn được sử dụng để

5
tạo và quản lý luồng trong hệ điều hành POSIX. Có chức năng: Posix Pthread
API cung cấp các hàm để thiết lập và lấy thông tin về phạm vi cạnh tranh cho
các luồng.

Pthread API cho phép chỉ định PCS hoặc SCS trong quá trình tạo luồng.
Pthreads xác định các giá trị phạm vi tranh chấp sau:

• PTHREAD_SCOPE_PROCESS à Luồng điều phối sử dụng phạm vi cạnh

tranh PCS

• PTHREAD_SCOPE_SYSTEM à Luồng điều phối sử dụng phạm vi cạnh

tranh SCS

POSIX Pthread API cung cấp hàm IPC để quản lý phạm vi cạnh tranh:

• pthread attr setscope(pthread attr t *attr, int scope) à Hàm thiết lập phạm
vi cạnh tranh.

• pthread attr getscope(pthread attr t *attr, int *scope) à Hàm lấy thông tin
phạm vi cạnh tranh.

*Lưu ý: Trên một vài hệ thống, chỉ có một giá trị phạm vi tranh chấp được
cho phép (Như Linex, MacOS chỉ cho phép PTHREAD_SCOPE_SYSTEM).

5.5 Multi-Processor Scheduling

Khi có nhiều CPU, việc chia sẻ tải và nhiều luồng có thể chạy song song với
nhau điều này dẫn đến việc điều phối (Scheduling) trở nên phức tạp hơn.

Thuật ngữ multiprocessor (đa bộ xử lý) được áp dụng cho các hệ thống cung
cấp nhiều bộ xử lý vật lý, nơi mỗi bộ xử lý chứa một CPU đơn lõi. Tuy nhiên,
định nghĩa của multiprocessor đã tiến hóa đáng kể, và trên các hệ thống tính
toán hiện đại, multiprocessor được áp dụng cho các kiến trúc hệ thống sau:

1. Multicore CPUs (CPU đa lõi).

2. Multithreaded cores (lõi đa luồng).
3. NUMA systems (các hệ thống NUMA).
4. Heterogeneous multiprocessing (Đa xử lý không đồng nhất).
Với những kiến trúc hệ thống khác nhau thì việc điều phối multiprocessor
cũng khác nhau. Đối với ba kiến trúc đầu tiên về hệ thống mà các bộ xử lý là

6
giống nhau – đồng nhất – về chức năng của chúng. Tuy nhiên đối với kiến
trúc hệ thống cuối cùng là một hệ thống mà các bộ xử lý không giống nhau về
khả năng của chúng.

5.5.1 Approaches to Multiple-Processor Scheduling

Có 2 cách tiếp cận:

1. Asymmetric multiprocessing là cách tiếp cận đơn giản bởi vì chỉ có

một lõi truy cập vào cấu trúc dữ liệu hệ thống.
Ưu điểm: giảm nhu cầu chia sẻ dữ liệu.

Nhược điểm của cách tiếp cận này là máy chủ chính trở thành một nút thắt cổ
chai tiềm năng => kéo theo hiệu suất hệ thống tổng thể bị giảm.

2. Symmetric multiprocessing (SMP) là các tiếp cận tiêu chuẩn để hỗ trợ

multiprocessor. Trong SMP: mỗi bộ xử lý tự điều phối.
Điều này dẫn đến có 2 chiến lược cho việc tổ chức các luồng đủ điều kiện để
được điều phối:

+ Tất cả các luồng có thể nằm trong một hàng đợi chung (common ready
queue) => Hay còn gọi là Global queue.

Ưu điểm: sử dụng hiệu quả CPU, công bằng với các tiến trình.

Nhược điểm: xảy ra tình huống 1 tiến trình được chọn bởi 2 bộ xử lý khác
nhau, tiến trình có thể bị thất lạc khỏi hàng đợi.

7
 + Mỗi bộ xử lý có thể có hàng đợi riêng của mình với các luồng (per-core
run queues) => Hay còn gọi là Local queue.

Ưu điểm: dễ tổ chức hoàn thiện, sử dụng bộ nhớ cache hiệu quả hơn.

Nhược điểm: một bộ xử lý rảnh rỗi với hàng đợi rỗng trong khi bộ xử lý
khác phải tính toán nhiều hơn.

è Đây cũng là cách tiếp cận phổ biến nhất trên các hệ thống hỗ trợ
SMP.

Để giải quyết nhược điểm của Local queue các thuật toán về cân bằng được
sử dụng để cân đối khối lượng công việc giữa tất cả các bộ xử lý. Hầu như tất
cả các hệ điều hành hiện đại, bao gồm Windows, Linux, MacOS, Androi và
IOS đều hỗ trợ SMP.

5.5.2 Multicore Processors

Ưu điểm của các hệ thống SMP sử dụng bộ xử lý đa lõi là nhanh hơn và tiêu
thụ ít năng lượng hơn so với các hệ thống mà mỗi CPU có chip vật lý riêng
của mình.

Nhược điểm là bộ xử lý đa lõi có thể làm phức tạp các vấn đề điều phối.

Hình 5.12 Sự chậm trễ bộ nhớ

8
Khi một bộ xử lý truy cập vào bộ nhớ, nó sẽ dành một khoảng thời gian đáng
kể để chờ dữ liệu có sẵn. Tình trạng này, được gọi là ngừng hoạt động bộ nhớ,
chủ yếu xảy ra do các bộ vi xử lý hiện đại hoạt động với tốc độ nhanh hơn
nhiều so với bộ nhớ. Tuy nhiên, sự cố bộ nhớ cũng có thể xảy ra do lỗi bộ nhớ
đệm (truy cập dữ liệu không có trong bộ nhớ đệm). Hình 5.12 minh họa một
lỗi bộ nhớ. Trong trường hợp này, bộ xử lý có thể dành tới 50 phần trăm thời
gian để chờ dữ liệu có sẵn từ bộ nhớ.

Để khắc phục được tình trạng này, ngày nay các kỹ sư thiết kế phần cứng đã
triển khai các lõi xử lý đa luồng trong đó hai (hoặc nhiều hơn) luồng phần
cứng được gán cho một lõi. Như vậy, nếu một luồng phần cứng bị đình trệ
trong khi chờ đợi bộ nhớ, lõi có thể chuyển sang một luồng khác. Hình 5.13
mô tả một lõi xử lý luồng kép trên đó xen kẽ việc thực thi luồng 0 và luồng 1.

Hình 5.13 Hệ thống đa lõi đa luồng

Từ quan điểm hệ điều hành, mỗi luồng phần cứng duy trì trạng thái kiến trúc
của nó, chẳng hạn như con trỏ lệnh và tập thanh ghi, và do đó xuất hiện như
một CPU logic sẵn có để chạy một luồng phần mềm. Kỹ thuật này - được gọi
là đa luồng chip (CMT) - được minh họa trong Hình 5.14. Ở đây, bộ xử lý
chứa bốn lõi điện toán, với mỗi lõi chứa hai luồng phần cứng. Từ quan điểm
của hệ điều hành, có tám CPU logic.

Trong các bộ xử lý Intel sử dụng thuật ngữ Hyper-threading (còn được gọi là
đa luồng đồng thời hoặc SMT).

9
 Hình 5.14 Đa luồng chip
Nói chung có hai cách để đa luồng một lõi xử lý:

Coarse-grained:

• Một luồng thực thi trên một lõi cho đến khi xảy ra sự kiện độ trễ dài
như một sự chậm trễ của bộ nhớ.

• Do đó, lõi phải chuyển sang một luồng khác để thực thi. Chi phí
chuyển đổi giữa các luồng là cao, vì ống dẫn lệnh phải được xả trước khi
luồng khác có thể bắt đầu thực thi trên lõi xử lý.

Fine-graine:

10
 • Chuyển đổi giữa các luồng ở một mức độ tỷ lệ hạt nhỏ hơn nhiều
thường là ở ranh giới của một lệnh.

Trong thiết kế kiến trúc của các hệ thống fine-grained bao gồm logic cho việc
chuyển đổi giữa các luồng. Một lưu ý quan trọng là tài nguyên của lõi vật lý
(bao gồm cache và đường ống) phải được chia sẻ giữa các luồng phần cứng
của nó, do đó một lõi xử lý chỉ có thể thực thi một luồng phần cứng tại một
thời điểm. Vì vậy, một bộ xử lý đa luồng, đa lõi thực tế yêu cầu 2 cấp độ điều
phối khác nhau, như được minh họa trong Hình 5.15, mô tả một lõi xử lý hai
luồng.

Hình 5.15 Hai cấp độ của việc điều phối

Trên cấp độ 1, hệ điều hành chọn luồng phần mềm nào để chạy trên mỗi
luồng phần cứng (logical CPU). Đối với cấp độ điều phối này hệ điều hành có
thể chọn bất kỳ thuật toán điều phối nào, bao gồm cả những thuật toán được
mô tả trong Phần 5.3

Trên cấp độ 2, xác định cách mà mỗi lõi quyết định chạy luồng phần cứng
nào. Có một số cách để áp dụng trong tình huống này:

• Sử dụng thuật toán Round-Robin để điều phối cho một luồng phần
cứng đến lõi xử lý. Được áp dụng bởi UltraSPACRC T3.

• Mỗi luồng phần cứng được gán một giá trị khẩn cấp động trong phạm

11
 vi từ 0 đến 7, trong đó 0 đại diện cho mức khẩn cấp thấp nhất và 7 đại
diện cho mức khẩn cấp cao nhât. Từ đó, Itanium có thể xác định và so
sánh mức độ khẩn cấp của mỗi luồng từ đó đưa ra quyết định kích hoạt
việc chuyển đổi luồng. Được áp dụng bởi Intel Itanium.

5.5.3 Load Balancing

Trên các hệ thống SMP, việc duy trì cân bằng công việc giữa các bộ xử lý rất
quan trọng để tận dụng được đầy đủ lợi ích của việc có nhiều bộ xử lý. Cân
bằng tải giúp phân phối công việc đồng đều trên các bộ xử lý => không xảy ra
tình trạng một hoặc nhiều bộ xử lý có thể không hoạt động trong khi các bộ
xử lý khác đang có khối lượng công việc cao.

Lưu ý rằng cân bằng tải thường chỉ cần thiết trên các hệ thống mà mỗi bộ xử
lý có hàng đợi riêng của các luồng riêng để thực thi.

Có 2 phương pháp chung để cân bằng tải:

 Đẩy di chuyển - kiểm tra tác vụ định kỳ tải trên từng bộ xử lý và nếu
được tìm thấy sẽ đẩy tác vụ từ CPU quá tải sang các CPU khác. Với di
chuyển đẩy, một tác vụ cụ thể định kỳ kiểm tra tải trên mỗi bộ xử lý và
nếu phát hiện thấy sự mất cân bằng sẽ phân bổ đều tải bằng cách di
chuyển (hoặc đẩy) các luồng từ bộ xử lý quá tải sang bộ xử lý nhàn rỗi
hoặc ít bận hơn.

 Kéo di chuyển - bộ xử lý nhàn rỗi kéo tác vụ chờ từ bộ xử lý bận. Di

chuyển kéo xảy ra khi một bộ xử lý nhàn rỗi kéo một tác vụ đang chờ từ
một bộ xử lý bận. Di chuyển đẩy và kéo không cần phải loại trừ lẫn nhau
và trên thực tế, thường được thực hiện song song trên các hệ thống cân
bằng tải. Ví dụ, bộ điều phối CFS của Linux và bộ điều phối ULE có sẵn
cho các hệ thống FreeBSD thực hiện cả hai kỹ thuật.

5.5.4 Processor Affinity

Do chi phí cao của việc vô hiệu quá và lấp đầy lại bộ nhớ cache khi một luồng
di chuyển sang một bộ xử lý khác. Nên hầu hết các hệ điều hành hỗ trợ SMP
cố gắng tránh việc di chuyển của luồng từ một bộ xử lý này sang một bộ xử lý
khác và thay vào đó là cố gắng duy trì cho luồng chạy trên cùng một bộ xử lý
để tận dụng warm cache. Điều này được gọi là “sự gắn kết với bộ xử lý”.

12
Sự gắn kết với bộ xử lý cũng có nhiều hình thức khác nhau. Có 2 hình thức:

 Sự gắn kết mềm (soft affinit): là khi hệ điều hành sẽ cố gắng giữ một
tiến trình chạy trên cùng một bộ xử lý nhưng không có sự đảm bảo rằng
nó sẽ như vậy.

 Sự gắn kết cứng (hard affinit): cho phép một quy trình chỉ định tập con
của các bộ xử lý mà nó có thể chạy trên.

Có nhiều hệ thống cung cấp cả sự gắn kết cứng và mềm. ví dụ, Linux thực
hiện sự gắn kết mềm, nhưng cũng cung cấp cuộc gọi hệ thống
sched_setaffinity(), hỗ trợ sự gắn kết cứng bằng cách cho phép một luồng chỉ
định tập hợp các CPU mà nó có thể thực thi trên.

Kiến trúc bộ nhớ chính của hệ thống cũng có thể ảnh hưởng đến các vấn đề về
mối quan hệ của bộ xử lý. Hình 5.16 minh họa một kiến trúc có tính năng truy
cập bộ nhớ không đồng nhất (NUMA) trong đó có hai chip xử lý vật lý, mỗi
chip có CPU và bộ nhớ cục bộ riêng. Mặc dù kết nối hệ thống cho phép tất cả
các CPU trong hệ thống NUMA chia sẻ một không gian địa chỉ vật lý, nhưng
một CPU có quyền truy cập vào bộ nhớ cục bộ của nó nhanh hơn so với bộ
nhớ cục bộ của một CPU khác. Nếu bộ điều phối CPU và thuật toán vị trí bộ
nhớ của hệ điều hành nhận biết NUMA và hoạt động cùng nhau, thì một
luồng đã được điều phối rên một CPU cụ thể có thể được cấp phát bộ nhớ gần

Hình 5.16 NUMA và điều phối CPU

nơi CPU cư trú nhất, do đó cung cấp cho luồng truy cập bộ nhớ nhanh nhất có
thể.

Kết hợp hai kiểu hàng đợi:

13
  Dùng cả local và global queue.

 Chia sẻ tải từ các hàng đợi.

 Mỗi CPU làm việc với local queue của mình.

5.5.5 Heterogeneous Multiprocessing

Trong các ví dụ chúng ta đã thảo luận đến nay, tất cả các bộ xử lý đều giống
nhau về khả năng của chúng, do đó cho phép bất kỳ luồng nào chạy trên bất
kỳ lõi xử lý nào. Sự khác biệt duy nhất là thời gian truy cập bộ nhớ có thể
thay đổi dựa trên các chính sách cân bằng tải và sự ưu tiên của bộ xử lý, cũng
như trên các hệ thống NUMA. Mặc dù các hệ thống di động giờ đây đã bao
gồm các kiến trúc đa lõi, một số hệ thống hiện nay được thiết kế sử dụng các
lõi chạy cùng một bộ lệnh, nhưng lại khác nhau về tốc độ đồng hồ và quản lý
năng lượng, bao gồm khả năng điều chỉnh mức tiêu thụ năng lượng của một
lõi đến mức làm cho lõi đó nghỉ. Các hệ thống như vậy được gọi là đa xử lý
không đồng nhất (HMP). Lưu ý rằng đây không phải là một dạng đa xử lý
không đối xứng như được mô tả trong Mục 2.1 vì cả các tác vụ hệ thống và
người dùng đều có thể chạy trên bất kỳ lõi nào. Thay vào đó, mục đích đằng
sau HMP là quản lý tốt hơn việc tiêu thụ năng lượng bằng cách gán các tác vụ
cho các lõi cụ thể dựa trên yêu cầu cụ thể của tác vụ.

Đối với các bộ xử lý ARM hỗ trợ nó, kiểu kiến trúc này được biết đến là
big.LITTLE nơi các lõi lớn có hiệu suất cao hơn được kết hợp với các lõi
LITTLE tiết kiệm năng lượng. Lõi lớn tiêu thụ năng lượng lớn hơn và do đó
chỉ nên được sử dụng trong thời gian ngắn. Tương tự, các lõi nhỏ sử dụng ít
năng lượng hơn và do đó có thể được sử dụng trong thời gian dài hơn.

Có một số lợi ích với cách tiếp cận này. Bằng cách kết hợp một số lõi chậm
với những lõi nhanh hơn, một bộ điều phối CPU có thể gán các tác vụ không
yêu cầu hiệu suất cao, nhưng có thể cần chạy trong thời gian dài hơn, (như
các tác vụ nền) cho các lõi nhỏ, do đó giúp bảo tồn năng lượng pin. Tương tự,
các ứng dụng tương tác yêu cầu nhiều sức mạnh xử lý hơn, nhưng có thể chạy
trong thời gian ngắn hơn, có thể được gán cho các lõi lớn. Ngoài ra, nếu thiết
bị di động đang ở chế độ tiết kiệm năng lượng, các lõi lớn tiêu thụ năng lượng
có thể bị vô hiệu hóa và hệ thống có thể chỉ dựa vào các lõi nhỏ tiết kiệm
năng lượng. Windows 10 hỗ trợ điều phối HMP bằng cách cho phép một

14
luồng chọn một chính sách điều phối phù hợp nhất với yêu cầu quản lý năng
lượng của nó.

5.6 Real-Time CPU Scheduling

Có thể phân biệt điều phối CPU theo thời gian thực thành 2 loại:

+ Điều phối thời gian thực mềm (Soft real-time systems): không có đảm
bảo nào về thời điểm các nhiệm vụ sẽ được điều phối, chỉ đảm bảo các
nhiệm vụ thời gian thực quan trọng có mức độ ưu tiên cao nhất.
+ Điều phối thời gian thực cứng (Hard real-time systems): Các nhiệm vụ
phải hoàn thành đúng thời hạn, quá trình phải được điều phối trước thời
hạn.

5.6.1 Minimizing Latency

Hệ thống thường chờ một sự kiện trong thời gian thực xảy ra, như khi đồng
hồ reo khi đến giờ,… Khi có một sự kiện xảy ra, hệ thống phải phản hồi và
giải quyết nó càng nhanh càng tốt. Độ trễ của sự kiện là khoảng thời gian trôi
qua từ khi sự kiện xảy ra đến khi nó được thực hiện.

Sơ đồ độ trễ sự kiện

Thông thường các sự kiện khác nhau sẽ có các yêu cầu độ trễ khác nhau.

Ví dụ: Yêu cầu độ trễ hệ thống chống bó cứng phanh (Anti Lock Braking
System – ABS) có thể mất từ 3-5 mili giây.

15
Có 2 loại độ trễ ảnh hưởng đến hiệu suất của hệ thống thời gian thực (real-
time systems):

+ Độ trễ ngắt (Interrupt latency): Thời gian từ khi xuất hiện ngắt đến khi
bắt đầu quy trình mà các dịch vụ làm gián đoạn. Khi một ngắt xảy ra,
trước tiên hệ điều hành phải hoàn thành lệnh mà nó đang thực thi và
xác định loại ngắt đã xảy ra. Sau đó, nó phải lưu trạng thái của tiến
trình hiện tại trước khi sửa chữa ngắt bằng cách sử dụng quy trình dịch
vụ ngắt cụ thể (ISR). Tổng thời gian cần thiết để thực hiện các tác vụ
này là độ trễ ngắt .
+ Độ trễ gửi (Dispatch latency): Thời gian cho lịch trình để ngắt quy trình
hiện tại khỏi CPU và chuyển sang xử lý quy trình khác. Khoảng thời
gian cần thiết để người điều phối điều phối dừng một quá trình và bắt
đầu một quá trình khác gọi là độ trễ gửi. Việc cung cấp các tác vụ thời
gian thực với quyền truy cập ngay vào CPU có nghĩa là hệ điều hành
thời gian thực cũng giảm thiểu độ trễ này. Kỹ thuật hiệu quả nhất để
giữ cho độ trễ gửi thấp là cung cấp các hạt nhân ưu tiên. Đối với các hệ
thống thời gian thực cứng, độ trễ gửi thường được đo bằng vài micro
giây.
Điều quan trọng đối với các hệ điều hành thời gian thực là giảm thiểu độ trễ
liên tục để đảm bảo rằng các tác vụ thời gian thực nhận được sự chú ý ngay
lập tức. Đối với các hệ thống thời gian thực cứng, độ trễ ngắt không chỉ là
được giảm thiểu, mà nó phải được giới hạn để đáp ứng các yêu cầu nghiêm
ngặt của các hệ thống.

Giai đoạn xung đột về độ trễ điều phối có 2 phần:

+ Ưu tiên bất kì tiến trình nào đang chạy trong kernel

+ Giải phóng theo quy trình có mức độ ưu tiên thấp các tài nguyên cần
thiết cho mức độ ưu tiên cao.
Sau giai đoạn xung đột, giai đoạn kiều phối sẽ điều phối ưu tiên cao trên một
CPU có sẵn

16
 Sơ đồ của độ trễ gửi đi
5.6.2 Priority-Based Scheduling
Tính năng có tính quan trọng nhất của hệ thời gian thực là đáp ứng ngay lập
tức quy trình thời gian thực ngay khi quy trình đó yêu cầu CPU. Do đó, bộ
điều phối cho hệ điều hành thời gian thực phải hỗ trợ thuật toán dựa trên mức
độ ưu tiên với quyền ưu tiên. Thuật toán điều phối dựa trên mức độ ưu tiên
chỉ định mỗi quá trình một mức độ ưu tiên dựa trên tầm quan trọng của nó;
những nhiệm vụ quan trọng hơn được giao mức độ ưu tiên cao hơn những
nhiệm vụ được coi là ít quan trọng hơn. Nếu bộ điều phối biểu cũng hỗ trợ
quyền ưu tiên, một quá trình hiện đang chạy trên CPU sẽ được ưu tiên nếu
một quá trình có mức độ ưu tiên cao hơn khả dụng để chạy.

Trước khi tiến hành chi tiết về các bộ điều phối riêng lẻ, thì phải xác định các
đặc điểm nhất định của các quá trình sẽ được điều phối. Đầu tiên, các quy
trình được coi là định kỳ (periodic). Nó yêu cầu CPU ở những khoảng thời
gian không đổi (chu kỳ-periods). Khi một quá trình định kỳ đã có được CPU,
nó có thời gian xử lý cố định t, thời hạn d mà nó phải được CPU hỗ trợ và
khoảng thời gian p. Mối quan hệ của thời gian xử lý, thời hạn và khoảng thời
gian có thể được biểu thị bằng 0 ≤ t ≤ d ≤ p. Tỷ lệ (rate) của một nhiệm vụ
tuần hoàn là 1 ∕ p. Người điều phối có thể tận dụng những đặc điểm này và chỉ
định mức độ ưu tiên theo thời hạn hoặc yêu cầu tỷ lệ của quy trình

17
 Sơ đồ nhiệm vụ định kỳ

Điều bất thường về hình thức điều phối này là một quy trình có thể phải thông
báo các yêu cầu về thời hạn của nó cho người điều phối. Tiếp đó, bằng cách
sử dụng một kỹ thuật được gọi là thuật toán kiểm soát nhập học (admission-
control), bộ điều phối thực hiện một trong hai việc. Nó hoặc thừa nhận quá
trình, đảm bảo rằng quá trình sẽ hoàn thành đúng thời hạn, hoặc từ chối yêu
cầu là không thể nếu nó không thể đảm bảo rằng nhiệm vụ sẽ được hoàn
thành trước thời hạn của nó.

Việc cung cấp bộ điều phối dựa trên ưu tiên, ưu tiên chỉ đảm bảo chức năng
thời gian thực mềm. Các hệ thống thời gian thực cứng phải đảm bảo hơn nữa
rằng các tác vụ thời gian thực sẽ được phục vụ theo yêu cầu thời hạn của
chúng và việc đảm bảo như vậy yêu cầu các tính năng điều phối bổ sung.

Điều quan trọng nhất là các quá trình được coi là định kỳ, tức là quá trình sẽ
tự lặp lại sau một khoảng thời gian cố định. Khoảng thời gian của một quá
trình được ký hiệu là p. Đặc điểm tiếp theo là thời gian xử lý t tức là thời gian
mà tiến trình yêu cầu CPU trong mỗi khoảng thời gian. Nói cách khác thời
gian xử lý đề cập đến thời lượng sử dụng. Đặc điểm cuối cùng là thời hạn d,
tức là thời gian trước khi quy trình phải được hỗ trợ. Nói chung, mối quan hệ
giữa ba đặc điểm này là thực hiện một quá trình tuần hoàn theo thời gian.

5.6.3 Rate-Monotonic Scheduling

Thuật toán điều phối đơn điệu tỷ lệ(rate-monotonic) điều phối các tiến trình
định kỳ bằng cách sử dụng chính sách ưu tiên tĩnh với quyền ưu tiên. Nếu một
tiến trình có mức độ ưu tiên thấp hơn đang được chạy và một tiến trình có
mức độ ưu tiên cao hơn có sẵn để chạy, nó sẽ chặn trước tiến trình có mức độ
ưu tiên thấp hơn. Khi vào hệ thống, mỗi tiến trình định kỳ được chỉ định một
mức độ ưu tiên nghịch đảo dựa trên chu kỳ của nó. Khoảng thời gian càng

18
ngắn, mức độ ưu tiên càng cao; thời gian càng dài, mức độ ưu tiên càng thấp.
Lý do đằng sau chính sách này là chỉ định mức độ ưu tiên cao hơn cho các tác
vụ yêu cầu CPU thường xuyên hơn. Hơn nữa, điều phối đơn điệu tỷ lệ giả
định rằng thời gian xử lý của một tiến trình định kỳ là như nhau đối với mỗi
cụm CPU. Có nghĩa là, mỗi khi một tiến trình lấy được CPU, thời lượng của
CPU nó là như nhau.

Ví dụ: Giả sử có hai tiến trình P1 và P2. Khoảng thời gian cho P1 và P2 là 50
và 100. Thời gian xử lý là t1 = 20 cho P1 và t2 = 35 cho P2. Thời hạn cho mỗi
tiến trình yêu cầu nó phải hoàn thành CPU burst trước khi bắt đầu giai đoạn
tiếp theo.

Sơ đồ điều phối các tác vụ khi P2 có mức độ ưu tiên cao hơn P1

Mô tả phương thức: Mức độ ưu tiên của P1 cao hơn P2 vì P1 có giá trị nhỏ
hơn trong khoảng thời gian. Do đó, tại thời điểm 0, P1 sẽ bắt đầu thực hiện.
P1 sẽ kết thúc ở 20 và sau đó P2 sẽ bắt đầu thực hiện. Tại thời điểm 50 P1,
tiết thứ hai sẽ bắt đầu. Đồng thời P2 đã hoàn thành 30. Nhưng vì mức độ ưu
tiên của P1 cao hơn, do đó P1 sẽ xếp trước P2 và chạy từ 50-70. P2 hoàn
thành 5 còn lại từ 70-75 nhưng vẫn đáp ứng thời hạn 100. Hệ thống vẫn
không hoạt động cho đến 100, khi khoảng thời gian thứ 3 của P1 và khoảng
thời gian thứ hai của P2 sẽ bắt đầu và P1 sẽ bắt đầu thực hiện tại thời điểm đó.
Phần còn lại của quá trình thực hiện sẽ tuân theo cùng một thứ tự thực hiện
như từ 0-100.

Sơ đồ thuật toán điều phối đơn điệu tỷ lệ

19
 5.6.4 Earliest-Deadline-First Scheduling
Điều phối theo thời hạn sớm nhất (Earliest-deadline firs-EDF) nó sẽ chỉ định
mức độ ưu tiên một cách linh hoạt theo thời gian. Thời hạn càng sớm thì mức
độ ưu tiên càng cao hoặc ngược lại. Theo các điều khoản của EDF, khi có một
quy trình trở lên chạy được thì nó phải thông báo các yêu cầu về thời hạn của
nó cho hệ thống. Mức độ ưu tiên có thể phải được điều chỉnh để phản ánh thời
hạn của quy trình mới có thể chạy được. Nó khác với việc lập kế hoạch đơn
điệu theo tỷ lệ, trong đó các ưu tiên được cố định.

Sơ đồ lập kế hoạch sớm nhất thời hạn đầu tiên

Không như thuật toán đơn điệu tốc dộ, việc lập kế hoạc EDF không yêu cầu
các quá trình diễn ra một cách định kỳ và một quá trình cũng không cần yêu
cầu một mượng CPU không đổi cho môi lần sử dụng. Yêu cầu duy nhất là
một quy trình phải thông báo thời hạn của nó tới bộ điều phối khi có thể chạy
được. Sự hấp dẫn của việc lập kế hoạch EDF à nó tối ưu về mặt lý thuyết, nó
có thể lập kế hoạch cho quy trình sao cho mỗi quy trình có thể đáp ứng được
các yêu cầu về thời hạn và việc sử dụng CPU sẽ được 100%. Tuy nhiên, về
thực tế không thể đạt được mức CPU này do việc chuyển đổi ngữ cảnh giữa
các tiến trình và xử lý ngắt.

5.6.5 Proportional Share Scheduling

Các bộ điều phối chia sẻ (Proportional share) theo tỷ lệ hoạt động bằng cách
phân bổ T cổ phần giữa tất cả các thiết bị. Một ứng dụng có thể nhận N lượt
chia sẻ thời gian, do đó đảm bảo rằng ứng dụng sẽ có N∕T trong tổng thời gian
xử lý, trong đó N<T. Ví dụ, giả sử rằng tổng số T = 100 cổ phiếu được chia
cho ba quá trình, A, B và C. A được chuyển nhượng 50 cổ phiếu, B được giao
15 cổ phiếu và C được chia 20 cổ phiếu. Đề án này đảm bảo rằng A sẽ có 50
phần trăm tổng thời gian xử lý, B sẽ có 15 phần trăm và C sẽ có 20 phần trăm.

Những người điều phối cổ phiếu theo tỷ lệ phải làm việc kết hợp với chính

20
sách kiểm soát tiếp nhận để đảm bảo rằng ứng dụng nhận được cổ phiếu được
phân bổ trong thời gian. Chính sách kiểm soát thu nhận sẽ chỉ chấp nhận một
khách hàng yêu cầu một số lượng cổ phiếu cụ thể nếu có đủ cổ phiếu. Trong
ví dụ hiện tại, đã phân bổ 50 + 15 + 20 = 85 cổ phiếu trong tổng số 100 cổ
phiếu. Nếu một quy trình mới D yêu cầu 30 lượt chia sẻ, bộ điều khiển nhập
học sẽ từ chối cho D nhập vào hệ thống.

5.6.6 POSIX Real-Time Scheduling

POSIX (Portable Operating System Interface) là một chuẩn hệ điều hành biến
thể của hệ điều hành Unix được định ra bởi IEEE Computer Society để duy trì
tính tương thích giữa các hệ điều hành. Chuẩn POSIX định nghĩa API
(Application Programming Interface), cùng với commandline shells và những
giao diện hữu ích (utility interfaces) khác.

Một số API POSIX liên quan đến việc điều phối các chuỗi thời gian thực.
POSIX định nghĩa hai lớp điều phối cho các luồng thời gian thực

 FIFO lịch trình (SCHED FIFO)

 Lịch trình (SCHED RR)
SCHED FIFO điều phối các luồng theo chính sách ai đến trước được phục vụ
trước bằng cách sử dụng hàng đợi FIFO. Tuy nhiên, không có thời gian cắt
giữa các luồng có mức độ ưu tiên như nhau. Do đó, luồng thời gian thực có
mức ưu tiên cao nhất ở phía trước hàng đợi FIFO sẽ được cấp cho CPU cho
đến khi nó kết thúc hoặc khối.

SCHED RR sử dụng chính sách quay vòng. Nó tương tự như SCHED FIFO
ngoại trừ việc nó cung cấp phân chia thời gian giữa các luồng có mức độ ưu
tiên như nhau. POSIX cung cấp một lớp điều phối bổ sung SCHED OTHER
nhưng việc triển khai nó là không xác định và dành riêng cho hệ thống; nó có
thể hoạt động khác nhau trên các hệ thống khác nhau.

API POSIX chỉ định hai chức năng sau để nhận và thiết lập chính sách điều
phối:

 Pthread _ attr _ getschedpolicy(pthread _ attr t *attr_t, int *policy)

 pthread _ attr _ setschedpolicy(pthread _ attr t *attr_t, int policy)

21
5.7 Operating-System Examples
Các chính sách điều phối của các hệ điều hành Linux, Windows và Solaris.
Đáng lưu ý rằng ở đây chúng ta sử dụng thuật ngữ điều phối quy trình một
cách tổng quát. Trên thực tế, chúng ta đang mô tả việc điều phối cho các
luồng hạt nhân trong các hệ thống Solaris và Windows và cho các tác vụ với
điều phối Linux.

5.7.1 Example: Linux Scheduling

Trước phiên bản 2.5, hạt nhân Linux chạy một biến thể của thuật toán điều
phối UNIX truyền thống. Tuy nhiên, vì thuật toán này không được thiết kế
với các hệ thống SMP trong tâm trí, nó không hỗ trợ đủ cho các hệ thống có
nhiều bộ xử lý. Ngoài ra, nó dẫn đến hiệu suất kém cho các hệ thống có một
số lượng lớn các tiến trình có thể chạy.

Với phiên bản 2.5 của hạt nhân, lập trình viên đã thay đổi toàn bộ lịch trình để
bao gồm một thuật toán điều phối - được biết đến với tên gọi O(1) - chạy
trong thời gian hằng số bất kể số lượng nhiệm vụ trong hệ thống. Lịch trình
O(1) cũng cung cấp hỗ trợ tăng lên cho các hệ thống SMP, bao gồm sự gắn
kết với bộ xử lý và cân bằng tải giữa các bộ xử lý.

+ Lịch trình O(1) cũng cung cấp hỗ trợ tăng lên cho các hệ thống SMP,
bao gồm sự gắn kết với bộ xử lý và cân bằng tải giữa các bộ xử lý.

22
 + Tuy nhiên, trong thực tế, mặc dù lịch trình O(1) mang lại hiệu suất
xuất sắc trên các hệ thống SMP, nó dẫn đến thời gian phản hồi kém cho các
tiến trình tương tác phổ biến trên nhiều hệ thống máy tính desktop.

Trong quá trình phát triển của hạt nhân 2.6, lịch trình đã được sửa đổi lại; và
trong phiên bản 2.6.23 của hạt nhân, lịch trình CFS (Completely Fair
Scheduler) trở thành thuật toán điều phối Linux mặc định.

+ Điều phối trong hệ thống Linux dựa trên các lớp điều phối. Mỗi lớp
được gán một ưu tiên cụ thể. Bằng cách sử dụng các lớp điều phối khác nhau,
hạt nhân có thể phù hợp với các thuật toán điều phối khác nhau dựa trên nhu
cầu của hệ thống và các tiến trình của nó.

Để quyết định nhiệm vụ nào sẽ được chạy tiếp theo, điều phối chọn ra nhiệm
vụ có ưu tiên cao nhất thuộc lớp điều phối có ưu tiên cao nhất. Các hạt nhân
Linux tiêu biểu triển khai hai lớp điều phối:

(1) Một lớp điều phối mặc định sử dụng thuật toán điều phối CFS

(2) Một lớp điều phối thời gian thực.

Thay vì sử dụng các quy tắc nghiêm ngặt liên kết một giá trị ưu tiên tương đối
với độ dài của một đoạn thời gian, điều phối CFS gán một phần trăm thời gian
xử lý CPU cho mỗi nhiệm vụ

5.7.2 Example: Windows Scheduling

Windows điều phối cho các luồng bằng cách sử dụng một thuật toán điều phối
dựa trên ưu tiên và có tính chất preemptive. Bộ điều phối của Windows đảm
bảo rằng luồng có ưu tiên cao nhất sẽ luôn chạy.

Phần của hạt nhân Windows xử lý điều phối được gọi là bộ phân phối. Một
luồng được chọn để chạy bởi bộ phân phối sẽ chạy cho đến khi nó bị
preempted bởi một luồng có ưu tiên cao hơn, cho đến khi nó kết thúc, cho đến
khi khoảng thời gian của nó kết thúc, hoặc cho đến khi nó gọi một cuộc gọi hệ
thống chặn, như cho I/O.

+ Nếu một luồng thời gian thực có ưu tiên cao hơn trở nên sẵn sàng
trong khi một luồng có ưu tiên thấp hơn đang chạy, luồng có ưu tiên thấp hơn
sẽ bị preempted. Sự preempt này cho phép một luồng thời gian thực truy cập

23
ưu tiên vào CPU khi luồng cần truy cập đó.

Bộ phân phối sử dụng một hệ thống ưu tiên 32 cấp độ để xác định thứ tự thực
thi của luồng. Các ưu tiên được chia thành hai lớp. Lớp biến chứa các luồng
có ưu tiên từ 1 đến 15, và lớp thời gian thực chứa các luồng có ưu tiên từ 16
đến 31. (Cũng có một luồng đang chạy ở ưu tiên 0 được sử dụng cho quản lý
bộ nhớ.) Bộ phân phối sử dụng một hàng đợi cho mỗi ưu tiên điều phối và
duyệt qua tập hợp các hàng đợi từ cao nhất đến thấp nhất cho đến khi nó tìm
thấy một luồng sẵn sàng để chạy. Nếu không tìm thấy luồng sẵn sàng, bộ
phân phối sẽ thực thi một luồng đặc biệt được gọi là idle thread

Có một mối quan hệ giữa các ưu tiên số của hạt nhân Windows và Windows
API. Có một mối quan hệ giữa các ưu tiên số của hạt nhân Windows và
Windows API. Windows API xác định các lớp ưu tiên sau đây mà một tiến
trình có thể thuộc về:

 (IDLE_PRIORITY_CLASS)
 (BELOW_NORMAL_PRIORITY_CLASS)
 (NORMAL_PRIORITY_CLASS)
 (ABOVE_NORMAL_PRIORITY_CLASS)
 (HIGH_PRIORITY_CLASS)
 (REALTIME_PRIORITY_CLASS)lớp ưu ti
Một luồng trong một lớp ưu tiên cụ thể cũng có một ưu tiên tương đối. Các
giá trị cho các ưu tiên tương đối bao gồm:

IDLE

 LOWEST
 BELOW NORMAL
 NORMAL
 ABOVE NORMAL
 HIGHEST
 TIME CRITICAL
Hơn nữa, mỗi luồng có một ưu tiên cơ bản đại diện cho một giá trị trong
phạm vi ưu tiên cho lớp mà luồng thuộc về. Mặc định, ưu tiên cơ bản là giá trị

24
của ưu tiên tương đối NORMAL cho lớp đó. Các ưu tiên cơ bản cho mỗi lớp
ưu tiên được liệt kê như sau:

 REALTIME PRIORITY CLASS—24

 HIGH PRIORITY CLASS—13
 ABOVE NORMAL PRIORITY CLASS—10
 NORMAL PRIORITY CLASS—8
 BELOW NORMAL PRIORITY CLASS—6
 IDLE PRIORITY CLASS—4
Ưu tiên ban đầu của một luồng thường là ưu tiên cơ bản của quy trình mà
luồng thuộc về, tuy nhiên, hàm SetThreadPriority() trong Windows API cũng
có thể được sử dụng để điều chỉnh ưu tiên cơ bản của một luồng.

Khi hết thời gian lượng tử của một luồng, luồng đó sẽ bị gián đoạn. Nếu
luồng đó thuộc lớp ưu tiên biến đổi, ưu tiên của nó sẽ giảm. Tuy nhiên, ưu
tiên không bao giờ được giảm dưới ưu tiên cơ bản. Việc giảm ưu tiên thường
giới hạn việc tiêu thụ CPU của các luồng tính toán.

Khi một luồng biến đổi được giải phóng từ một hoạt động chờ đợi, bộ phân
phối sẽ tăng ưu tiên của nó. Số lượng tăng này phụ thuộc vào những gì mà
luồng đã chờ đợi.

Khi một người dùng đang chạy một chương trình tương tác, hệ thống cần
cung cấp hiệu suất đặc biệt tốt. Vì lý do này, Windows có một quy tắc điều
phối đặc biệt cho các quy trình thuộc lớp ưu tiên NORMAL.

Windows phân biệt giữa quy trình nền hiện đang được chọn trên màn hình và
các quy trình nền không được chọn hiện tại. Khi một quy trình chuyển vào
nền, Windows tăng lượng tử điều phối bằng một hệ số nào đó - thường là
bằng 3. Sự tăng này cho phép quy trình nền chạy dài hơn ba lần trước khi xảy
ra sự gián đoạn thời gian chia sẻ.

5.7.3 Example: Solaris Scheduling

Solaris sử dụng điều phối luồng dựa trên ưu tiên. Mỗi luồng thuộc về một
trong sáu lớp sau:

1. Time sharing (TS)

25
 2. Interactive (IA)

3. Real time (RT)

4. System (SYS)

5. Fair share (FSS)

6. Fixed priority (FP)

Trong mỗi lớp, có các ưu tiên và các thuật toán điều phối khác nhau.

Lớp điều phối mặc định cho một quy trình là chia sẻ thời gian. Chính sách
điều phối cho lớp chia sẻ thời gian điều chỉnh độ ưu tiên động và gán các
đoạn thời gian có độ dài khác nhau bằng cách sử dụng một hàng đợi phản hồi
đa cấp.

Theo mặc định, có một mối quan hệ nghịch đảo giữa độ ưu tiên và các đoạn
thời gian. Độ ưu tiên càng cao, đoạn thời gian càng nhỏ; và độ ưu tiên càng
thấp, đoạn thời gian càng lớn. Các quy trình tương tác thường có độ ưu tiên
cao hơn; các quy trình ràng buộc CPU có độ ưu tiên thấp hơn.

Chính sách điều phối này mang lại thời gian phản hồi tốt cho các quy trình
tương tác và hiệu suất tốt cho các quy trình ràng buộc CPU. Lớp tương tác sử
dụng cùng một chính sách điều phối như lớp chia sẻ thời gian, nhưng nó cung
cấp ưu tiên cao hơn cho các ứng dụng cửa sổ - như những ứng dụng được tạo
ra bởi các quản lý cửa sổ KDE hoặc GNOME - để cải thiện hiệu suất.

5.8 Algorithm Evaluation

Giới thiệu các thuật toán xếp lịch

 First-Come, First-Served (FCFS): Tiến trình đến trước được phục vụ trước.
Đây là thuật toán đơn giản nhất nhưng có thể dẫn đến hiệu quả thấp nếu có
tiến trình dài cần chờ đợi.
 Shortest Job First (SJF): Tiến trình có thời gian thực thi ngắn nhất được ưu
tiên điều phối trước. Điều này giúp giảm thời gian chờ đợi trung bình.
 Shortest Remaining Time First (SRTF): Một biến thể của SJF, nơi thời gian
thực thi còn lại nhỏ nhất được ưu tiên thay vì thời gian thực thi dự kiến ban
đầu.

26
 Round Robin (RR): Mỗi tiến trình được phục vụ trong một khoảng thời gian
cố định được gọi là quantum (lượng tử). Nếu một tiến trình không hoàn thành
trong quantum đó, nó được đưa ra sau đó trong hàng đợi.
Tại sao phải đánh giá thuật toán ?

Giúp xác định các tiêu chí được sử dụng để lựa chọn một thuật toán. Tiêu chí
có thể gồm :

- Tối đa hóa việc sử dụng CPU theo rang buộc rằng mức thời gian phản
hồi tối đa là 1 giây.
- Tối đa hóa thông lượng sao cho thời gian hoàn thành trung bình tỷ lệ
tuyến tính với tổng thời gian thực hiện.
5.8.1 Deterministic Modeling
Đánh giá phân tích (sử dụng thuật toán đã cho và khối lượng công việc của
hệ thống để tạo ra một công thức hoặc thông số đánh giá hiệu suất của thuật
toán)

Mô hình xác định thuộc loại đánh giá phân tích. Phương pháp này nhận một
khối lượng công việc xác định trước cụ thể và xác định hiệu suất của từng
thuật toán cho khối lượng công việc đó

Ví dụ: giả sử rằng có khối lượng công việc như bên dưới, tất cả năm tiến trình
đều đến tại thời điểm 0, theo thứ tự đã cho, với chu kỳ thực hiện tính bằng
mili giây

Đối với mỗi thuật toán, tính thời gian chờ đợi trung bình tối thiểu:

 FCFS (First-Come, First-Served): 28 ms

27
  SJF (Shortest Job First ) không trưng dụng: 13 ms

 RR (Round Robin): 23 ms

5.8.2 Queueing Models

Là một phương pháp phân tích được sử dụng để mô hình hóa hệ thống điều
phối CPU dưới dạng một chuỗi các tiến trình đang chờ đợi để được thực thi
bởi CPU.

Trong mô hình hàng đợi CPU, các tiến trình được đặt vào hàng đợi theo thứ
tự đến và phục vụ, tương tự như cách một hàng đợi hoạt động trong cuộc sống
hàng ngày. Các mô hình hàng đợi có thể mô tả các yếu tố như thời gian chờ
đợi, thời gian phản hồi, và sự sử dụng của CPU.

Các yếu tố quan trọng trong mô hình hàng đợi CPU bao gồm:

 Tỷ lệ đến (Arrival Rate): Số lượng tiến trình đến hệ thống trong một đơn vị
thời gian.
 Tỷ lệ phục vụ (Service Rate): Tốc độ mà CPU có thể xử lý các tiến trình
trong một đơn vị thời gian.
 Số lượng CPU: Số lượng CPU có sẵn để xử lý tiến trình. Một số mô hình
cũng có thể xem xét việc có nhiều hơn một CPU (multi-core systems).
 Hàng đợi: Cơ chế lưu trữ các tiến trình đang chờ đợi để được thực thi bởi
CPU. Các thuật toán điều phối sẽ quyết định tiến trình nào sẽ được lựa chọn từ
hàng đợi để thực thi tiếp theo.

28
Little’s Formula - ở trạng thái ổn định, các tiến trình rời hàng đợi = các tiến
trình đến

công thức : n = λ x W

Trong đó :

n: độ dài hang đợi trung bình

W: thời gian chờ đợi trung bình trong hàng đợi

λ: tỷ lệ trung bình vào hàng đợi

Ví dụ: nếu trung bình có 7 tiến trình đến mỗi giây và thông thường có 14 tiến
trình trong hàng đợi, thì thời gian chờ trung bình cho mỗi tiến trình bằng 2
giây.

5.8.3 Simulations
Xây dựng một mô hình máy tính chạy thuật toán và giả lập quá trình điều
phối và thực thi các tiến trình. Điều này cho phép đánh giá hiệu suất của thuật
toán trong một môi trường điều kiện thực tế

Dữ liệu để điều khiển mô phỏng có thể được tạo ra bằng nhiều cách. Phương
pháp phổ biến nhất sử dụng một bộ sinh số ngẫu nhiên được lập trình để tạo
ra các tiến trình, thời gian CPU burst, sự xuất hiện, sự ra đi, và những điều
tương tự, theo các phân phối xác suất

Mô phỏng có thể tốn kém, thường đòi hỏi nhiều giờ máy tính. Một mô phỏng
chi tiết hơn cung cấp kết quả chính xác hơn, nhưng nó cũng tốn nhiều thời
gian hơn của máy tính.

5.8.4 Implementation
Viết mã và triển khai nó trong hệ thống điều hành, sau đó quan sát cách nó
hoạt động trong điều kiện hoạt động thực tế. Phương pháp này đặt thuật toán
thực tế vào hệ thống thực sự để đánh giá dưới các điều kiện vận hành thực tế.

29
 KẾT LUẬN
FCFS là thuật toán điều phối đơn giản nhất, nhưng có thể khiến các tiến trình
ngắn phải chờ các tiến trình rất dài
SJF là thuật toán tối ưu nhất có thể, có thời gian chờ đợi trung bình ngắn nhất,
tuy nhiên việc triển khai thuật toán SJF là rất khó vì khó điều chỉnh độ dài của
chu kỳ thực hiện CPU tiếp theo.
Điều phối theo vòng (RR) thích hợp hơn cho việc chia sẻ thời gian hệ thống.
RR phân bổ CPU cho tiến trình đầu tiên ở trạng thái sẵn sàng xếp hàng cho q
đơn vị thời gian, trong đó q là lượng tử thời gian.
Nhiều hệ thống máy tính hiện đại hỗ trợ nhiều bộ xử lý và cho phép mỗi bộ
xử lý tự điều phối một cách độc lập. Thông thường, mỗi bộ xử lý duy trì hàng
đợi tiến trình (hoặc luồng) riêng tư của riêng nó, tất cả đều có sẵn để chạy.

30
MIND MAP

31
 BÀI TẬP
1. Một thuật toán điều phối CPU xác định một thứ tự cho việc thực thi
các quy trình đã được điều phối của nó. Cho n quy trình cần được điều
phối trên một bộ xử lý, có bao nhiêu lịch trình khác nhau có thể có? Hãy
cung cấp một công thức dựa trên n.
Đáp án:
n! (n factorial = n × n – 1 × n – 2 × ... × 2 × 1).

2. Giải thích sự khác biệt giữa điều phối chủ động và điều phối không chủ
động.
Đáp án:
Điều phối chủ động cho phép một quy trình bị gián đoạn giữa quá trình thực
thi của nó, lấy CPU đi và cấp nó cho một quy trình khác. Điều phối không
chủ động đảm bảo rằng một quy trình chỉ từ bỏ kiểm soát của CPU khi nó
hoàn thành với chuỗi thời gian CPU hiện tại của nó.
3. Giả sử các quy trình sau đây đến để thực thi vào các thời điểm được
chỉ ra. Mỗi quy trình sẽ chạy trong thời gian được liệt kê. Trong việc trả
lời các câu hỏi, sử dụng điều phối không chủ động và dựa trên tất cả
thông tin bạn có tại thời điểm quyết định phải được thực hiện.

a. Trong thuật toán điều phối FCFS, thời gian trung bình để hoàn thành
cho các quy trình này là bao nhiêu?

b. Trong thuật toán điều phối SJF, thời gian trung bình để hoàn thành cho
các quy trình này là bao nhiêu?

c. Thuật toán SJF được cho là cải thiện hiệu suất, nhưng hãy chú ý rằng
chúng tôi đã chọn để chạy quy trình P1 vào thời điểm 0 vì chúng tôi không
biết rằng hai quy trình ngắn hơn sẽ đến sớm. Tính toán thời gian trung

32
 bình hoàn thành sẽ là bao nhiêu nếu CPU được để trống trong thời gian
đó?

Đáp án:
a. Biểu đồ Gantt:
P1 P2 P3

0 8 12
13

Time turnaround:

P1=8-0=8 ms
P2=12-0.4=11.6 ms

P3=13-1=12 ms
=> Time average Turnaround = (8+11.6+12)/3=10.53 ms

b. Biểu đồ Gantt:

P1 P3 P2

0 8 9
13

Time Turnaround:
P1=8-0=8 ms
P2=9-1=8 ms
P=13-0.4=12.6 ms
=>Time average Turnaround = (8+8+12.6)/3=9.53ms

c. Biểu đồ Gantt:

P3 P2 P1

33
1 2 6
14

Time Turnaround:

P1=14-0=14 ms

P2=6-0.4=5.6 ms

P3=2-1=1 ms

Time average turnaround= (14+5.6+1)/3=6.87 ms

4. Sử dụng thuật toán điều phối của Windows, xác định ưu tiên số của
mỗi luồng sau đây:

a. Một luồng trong REALTIME PRIORITY CLASS với ưu tiên tương đối là
HIGHEST

b. Một luồng trong NORMAL PRIORITY CLASS với ưu tiên tương đối là
NORMAL

c. Một luồng trong HIGH PRIORITY CLASS với ưu tiên tương đối là
ABOVE NORMAL

Đáp án:

a. 26

b. 8

c. 14

5. Giả sử không có luồng nào thuộc REALTIME PRIORITY CLASS và

không có luồng nào được gán ưu tiên TIME CRITICAL, tổ hợp nào của
lớp ưu tiên và ưu tiên tương ứng với ưu tiên tương đối cao nhất có thể
trong điều phối Windows?

Đáp án:

34
HIGH PRIORITY CLASS và HIGH PRIORITY trong lớp đó. (ưu tiên số là
15)
6. Xem xét thuật toán điều phối trong hệ điều hành Solaris cho các luồng
time-sharing
a. Thời lượng lượng tử (tính bằng mili giây) cho một luồng có độ ưu tiên 10 là
bao nhiêu? Với độ ưu tiên 55?
b. Giả sử một luồng có độ ưu tiên 35 đã sử dụng hết thời lượng lượng tử của
mình mà không bị chặn. Hệ thống sẽ gán độ ưu tiên mới cho luồng này là gì?
c. Giả sử một luồng có độ ưu tiên 35 bị chặn I/O trước khi thời lượng lượng
tử của nó kết thúc. Hệ thống sẽ gán độ ưu tiên mới cho luồng này là gì?

Đáp án:

a. 160 and 40
b. 35
c. 54
7. Trong một hệ thống SMP, việc sử dụng một hàng đợi sẵn sàng chung
cho tất cả các CPU có thể dẫn đến vấn đề về hiệu suất?

Đáp án:

Lý do chủ yếu là cạnh trang tài nguyên.

 Khi nhiều CPU cố gắng truy cập  các CPU phải đợi nhau, làm giảm
hiệu quả tổng thể.

 Trong hệ thống SMP, bộ nhớ chính thường được chia sẻ giữa các CPU.
CPU gặp phải độ trễ nếu dữ liệu của hàng đợi nằm trên bộ nhớ của một
CPU khác  làm chậm quá trình tìm nạp và cập nhật hàng đợi.

8. Giả sử một hệ thống SMP có các hàng đợi chạy riêng cho từng bộ xử
lý. Khi một tiến trình mới được tạo, nó có thể được đặt vào cùng hàng
đợi với tiến trình cha hoặc một hàng đợi riêng biệt. Lợi ích của từng
trường hợp?

Đáp án:

35
Lợi ích của việc đặt tiến trình mới vào cùng hàng đợi với tiến trình cha:

 Tiến trình con có thể tận dụng bộ nhớ cache của bộ xử lý đang chạy
tiến trình cha  hiệu suất thực thi có thể được cải thiện đáng kể.

 Giảm thiểu chi phí chuyển đổi ngữ cảnh.

Đơn giản hóa quản lý tài nguyên .

Lợi ích của việc đặt tiến trình mới vào một hàng đợi khác:

 Việc đặt tiến trình con vào một hàng đợi khác trên một bộ xử lý nhàn
rỗi có thể giúp cải thiện hiệu suất tổng thể của hệ thống.

 Trong một số trường hợp, việc tách biệt các tiến trình theo loại bằng
cách đặt chúng vào các hàng đợi khác nhau có thể cải thiện khả năng
đáp ứng của hệ thống

9. Khi một luồng (thread) bị chặn chờ I/O mạng và giờ đây đã sẵn sàng
chạy trở lại, thuật toán điều phối có nhận thức NUMA (Non-Uniform
Memory Access - Truy cập bộ nhớ không đồng nhất) nên điều phối lại
luồng đó trên cùng một CPU mà nó đã chạy trước đó. Vì sao?

Đáp án:

 Bằng cách chạy lại luồng trên cùng một CPU, luồng có thể tận dụng lợi
thế của dữ liệu được lưu trong cache, dẫn đến hiệu suất cao hơn do
tránh được độ trễ truy cập bộ nhớ chính chậm hơn.

 Giảm thiểu chi phí chuyển đổi ngữ cảnh .

36
 DANH MỤC TÀI LIỆU THAM KHẢO
1. https://cs.lth.se/fileadmin/cs/EDAF35/lectures/2020/
EDAF35_5A_2020.pdf
2. https://os.ecci.ucr.ac.cr/slides/Abraham-Silberschatz-Operating-
System-Concepts-10th-2018.pdf (217-249).
3. https://www.studocu.com/vn/document/truong-dai-hoc-bach-khoa-ha-
noi/he-dieu-hanh/nlhdh-bao-cao-chuong-6-cpu-scheduling-doc-va-tom-
tat-tu-tai-lieu-operating-systems-concepts/28424494
4. https://www.studocu.com/vn/document/truong-dai-hoc-cong-nghe-
thong-tin-dai-hoc-quoc-gia-thanh-pho-ho-chi-minh/operating-system/
chapter-5-slides-cpu-scheduling/21027321
5. https://daynhauhoc.com/t/thac-mac-posix-la-gi/41170

37