Lecture 6

The operating system utilizes signals as a form of asynchronous communication between processes. They are the operating system's system for notifying a process that an event has occurred. Signals allow for the interrupt of user process as well as inter-process communication (IPC) such as Pipes. When a process receives a signal, it calls its function specific signal handler, generally setting a few flags and returning to previously executing instruction, unless the process has been killed.

For example, if Process A calls write() and Process B calls read() through a pipe, when does Process B get the message?

Process B only gets the message when it reads on the pipe file descriptor.

Why would Process B not be reading?

• B is reading something else
• B is executing a CPU bound computation
• B called the sleep function

What if the message is urgent?

In the worst case, Process B gets the message at most in 1 sec (arbitrary number). This occurs because even during busy waiting/polling, ever second Process B will check for a message. If there is no message it will continue with its busy work.

Need User Level Interrupts

User Level Interrupts preemptively interrupt a running process to execute a specific signal handler. Once the receiver of the signal receives the interrupt, it halts all computation and jumps to its specific signal handler function with its own stack. The specific function is specified in the interrupt command.

kill ( pid_t p, int signo)
This delivers a user level interrupt number “signo” to the process with id “p”

Note: Kill must interrupt other system calls so the receiver of the signal, if it is in a system call, returns early.

If it is the case that the process was interrupted while in a system call, then the system call will return -1 on the error and also will set the global variable ERRNO == EINTR.

During the user level interrupt hardware and kernel interrupts are still active such as the timer interrupt.

OS Goal: To effectively multiplex the physical machine's resources among the abstract machines

A main task for the OS is to schedule the various processes on the machine and distribute the resources. The scheduling system must determine which of the runnable processes will run next and how much CPU time it will be given. There are numerous techniques to determine the order execution and amount of CPU time, which will be discussed below.

Process State Diagram

To schedule the various runnable processes, chunks of CPU time are assigned to each abstract machine. Scheduling problems arise because of the variety of execution deadlines and the difficulty to meet each of them.

Scheduling Metrics

Scheduling metrics are measurements that tell how good a schedule is. There are several different types of scheduling metrics:

1. CPU Utilization is the fraction of time spent executing application code. It is denoted by ρ where 0<=ρ<=1. In this case, 0 represents low CPU utilization while 1 represents high CPU utilization.
2. Responsiveness is the time between when a process enters the runnable state and when it starts running. It is denoted by w which stands for the average waiting time among all processes. We want w to be as low as possible (i.e. low latency). If we are measuring the waiting time of a single process i, then we use w(i) to represent its waiting time.
3. Turnaround time is the time from when a process becomes runnable until it becomes blocked or has exited. It is denoted by T_TRND which stands for the average turnaround time among all processes. We want T_TRND to be as low as possible. If we are measuring the turnaround time of a single process i, then we use T_TRND(i).
4. Throughput is the mean number of jobs that can be performed per second. It is denoted by μ where μ = 1/T_TRND. We want the throughput to be as high as possible. A job is a unit of work by a process (i.e. the period between when a process becomes RUNNABLE until it is blocked or has exited).

Preferences: We want to influence the schedulers decision in order to achieve the following user goals:

• We want to give some schedules priority over other schedules.
• We want to make sure each process is finished by a given deadline.

Scheduling 4 jobs

Let's say we are given the following four jobs to schedule along with their service times T:

We assume that all processes start running at the same time.

First Come First Serve (FCFS)

If we execute A, followed by B, followed by C, followed by D, we get the following Gantt Chart:

Note: When we switch from one process to another we encounter a delay known as the contact switch time. We will denote the contact switch by using C.

Analysis of responsiveness and turnaround time:

Analysis of CPU utilization: Since the CPU is not used during contact switches, the utilization is ρ = 20/(20+3C).

FCFS Predictions

We have stable load which means that we can always get a good idea of the average T_TRND. Lets says that L processes are waiting in a queue while 1 process is running. If we get a new job, we can easily estimate the new average turnaround time. Below is the formula that computes it:

L*T_TRND+T_TRND+.5*T_TRND

The first term is the turnaround time of the L queued jobs. The second term is the turnaround time of the new job. The third term is the turnaround time of the current running job.

Shortest Job First (SJF)

If we execute the jobs in order of the time they take, we get the following Gantt Chart:

Analysis of responsiveness and turnaround time:

Analysis of Shortest Job First Algorithm

• The algorithm minimizes the average wait time without preemption.
• A problem with the algorithm is starvation which means that you may never get to run a long job.

Example of Starvation:

Since job A takes 2 units of time, it will be executed after job B. However, if jobs that take 1 unit of time keep appearing each second (like C and D), job A might never be executed. In this example, at time t, t+2 units of work will remain. This is known as CPU saturation.

In practice, however, CPU starvation is generally unlikely.

The FCFS and SJF algorithms are examples of cooperative scheduling. This works great for some cases but not for other cases such as the following:

In this case, we want job B to preempt or interrupt job A.

Preemptive Scheduling

• Quantum: a quantum is a measure of how many units of jobs run before preempted.

Round Robin

• In round robin, we give time to each process in a given order, and every Q jobs we interrupt and switch to another process.

Example:
If Q = 3,
We get the following Gantt Chart:

Analysis of responsiveness and turnaround time:

If Q = 2,
We get:

W = 3 + 1.5C
T_TRND = 13.25 + 6C

• Quantum uses the clock timer interrupt frequency

Priority

• Priority allows the user to influence scheduling decisions
• Smaller number = higher priority = more important

Example:
While still using Q = 3,
We augment our process list:

• We schedule the most important processes first, and do round robin for processes with the same priority level

We get the following Gantt Chart:

Analysis of responsiveness and turnaround time:

Multi-Level Priority System

• Strict Priority
• Run processes with smallest(highest) priority, using round-robin
• Can lead to starvation (run a high priority job forever)

Priority Inversion

• What if C sends a message to A and wait for its response?
• Then D runs, since prio(D) < Prio(A)
  • Problem: C is waiting for D, although prio(C) < prio(D)
  • Solution: When C wait for A, set effective priority
    • effprio(A) = min( prio(A), prio(C) )

Privilege and Priority

• A, having prio(A), wants to set to priority "p"
• if p < prio(A) => need privilege
• if p ≥ prio(A) => no need for privilege

Multi-Level Feedback Queues

• Multiple priorities
• Get feedback from CPU utilization to avoid starvation
• More CPU utilization => larger priority number (lower priority)

p_estcpu: process's estimated CPU utilization
p_nice: normal priority

p_usrpri = 1/4 * ( 50 + 1/4 * p_estcpu + 2 * p_nice )