CIS 657 Principles of Operating Systems
Project 1: Fair Share Scheduling for FreeBSD 5.2
Milestone I : 10/13 Thu
II : 10/20 Thu
Submission: 10/24 Mon
This is an individual project. You may not pair up, give, receive, share or discuss
concepts, designs, programs, or any other part of your work.
Both 4.4 BSD scheduler and ULE scheduler prioritize I/O-bound interactive processes over CPU-
bound "noninteractive" processes.
When OS uses a threshold or cutoff for a binary decision, the user may notice a change in
behavior as a process crosses the boundary. For example, after a very small change in
interactivity score, ULE may delay scheduling a process significantly, by placing it in the next
(rather than current) queue.
In this project you will implement a version of Fair Share (FS) scheduler that resembles
"Completely Fair Share (CFS)" scheduling Linux uses (since June 2008). FS does not
categorize/classify, so there is no sudden change in behavior.
2. Very Fair Scheduler (VFS)
As "Completely" in CFS is not entirely true, and we won't fully implement CFS, we'll call this
"Very Fair Scheduling" (VFS). Our VFS falls somewhere between user and process based fair
share scheduling methods, and CFS (but could also be considered to be either one). In VFS, you
need to first divide CPU access evenly across users, and then also divide evenly between
processes of the same user.
For example, if user A has 2 processes and user B has 10 processes runnable, fair share for user
A's processes is 25% of CPU time each, whereas fair share for user B's processes is 5% of CPU
time each. We only care about runnable processes.
VFS makes sure that no user and no process will ever starve / be forgotten. Note that, even
though VFS tries to split CPU time evenly, some processes just sleep for long periods and will not
catch up (but will still be given all the time to catch up). VFS can be implemented quite simply,
without heuristics, categories (like interactive, noninteractive), decision making or binning. The
process farthest behind in having a proportional fair share is the one to schedule.
For this project, I would like you to ignore multiple CPU / multiple core cases; we'll only run tests