Operating Systems CSE 411

1
Operating SystemsCSE 411

• CPU Management
• Sept. 15 2006 - Lecture 5
• Instructor Bhuvan Urgaonkar

2
Today

• Quickly revisit
• Timer interrupt, system clock
• CPU management related data structures
• Process creation and termination
• Start CPU scheduling
• Quiz 1

3
Timer Interrupt, System Clock
Oscillator
CLK
CPU
TSC reg.
IRQ3
Slower clocks to other components (e.g., memory,
PCI bus)
IRQ2
IRQ1
IRQ0
tick tick (Set by
OS at bootup coming soon)
jiffies (Linux)

• System clock drives the CPU circuit, no interrupt
  processing
• Timer interrupt handled by OS, less frequent

4
Today

• Quickly revisit
• Timer interrupt, system clock
• CPU management related data structures
• Process creation and termination
• Start CPU scheduling
• Quiz 1

5
Data Structure 1 PCB
Main Memory (RAM)

Process id
OS
Program Counter
Other registers
Process state
Processes
Ptr to linked list

• Can PCBs be swapped out?
• Depends on the OS design .. so sometimes YES

6
Data Structure 2 Linked Lists based on Process
States
7
Running
Ready
Lock
Waiting
Disk
8
Timer interrupt
Running
Ready
Lock
Waiting
Disk
9
Running
Ready
Lock
Waiting
Disk
10
I/O call
Running
Ready
Lock
Waiting
Disk
11
Hmm .. Who should I pick to run?
Running
OS (scheduler)
Ready
Lock
Waiting
Disk
12
Lets pick the second process in the ready queue
Running
OS (scheduler)
Ready
Lock
Waiting
Disk
13
Today

• Quickly revisit
• Timer interrupt, system clock
• CPU management related data structures
• Process creation and termination
• Start CPU scheduling

14
Process Creation

• When would a new process be created?
• When a user of the computer asks one to be
  created
• That is, when an existing process asks for one to
  be created
• Therefore, there is going to be a parent-child
  relation among processes
• There must be a first process, then - the OS
  creates it during boot-up
• Who is going to create it? The OS
• What does the OS need to do?
• Needs to create a PCB
• Assign a unique id to the new process
• Bring in the code and data for the new process
  into RAM
• Move the new process to the ready queue, so the
  OS can schedule it on the CPU

15
Process Creationfork()

• Recall Processes use system calls to request
  services from the OS
• OS provides a system call called fork() that a
  process can use to request the creation of a new
  process
• OS creates a new PCB when fork() is called with a
  unique id for the new process
• The calling process is the parent, the new
  process is the child
• Then adds the childs PCB to the ready queue
• The child process is ready to go!
• What code is the child going to execute?

16
Specifying the Code theChild should
executeexec()

• Recall Processes use system calls to request
  services from the OS
• OS provides a system call called exec() that a
  process can use to tell the OS what code it would
  like to execute
• Once the code and data are loaded into memory,
  the OS sets the PC (in the PCB) to the beginning
  of the childs code
• What happens to the parent now???

17
Process CreationWhat happens to the parent?

• The parent could wait for the child to finish
• This is what a shell does
• Or it could go about its business

18
Process CreationParent wants to wait

• Again, the parent process has to request the OS
  via a system call
• The wait() system call
• The OS moves the parent to a waiting queue
• It would be moved to ready again when the child
  terminates

19
Process CreationParent doesnt want to wait

• Both the parent and the child would run whenever
  they are ready

20
Process Creation

• Why/when are processes created?
• A user wants to run a program
• An existing process needs another process to run
  the same code
• Why? More parallelism, make use of CPU even when
  it gets moved to the waiting state
• So most OSes initialize the child process to have
  the same state as the parent
• Except the process id and a few other things

21
RAM
Id2001
Id2000 Stateready
1. PCB with new id created
Stateready
OS
PCB of parent
PCB of child
2. Memory allocated for child Initialized by
copying over from the parent
Process calls fork
3. If parent had called wait, it is moved to
a waiting queue
4. If child had called exec, its memory
overwritten with new code data
Processes
Parents memory
Childs memory
5. Child added to ready queue, all set to go
now!
22

• else if (pID lt 0) // failed to fork
• cerr ltlt "Failed to fork" ltlt endl
• exit(1)
• // Throw exception
• else // parent
• // Code only executed by parent process
• sIdentifier "Parent Process"
• // Code executed by both parent and child.
• cout ltlt sIdentifier
• cout ltlt " Global variable " ltlt
  globalVariable
• cout ltlt " Stack variable " ltlt
  iStackVariable ltlt endl

• include ltiostreamgt
• include ltstringgt
• include ltsys/types.hgt
• include ltunistd.hgt
• using namespace std
• int globalVariable 2
• main()
• string sIdentifier
• int iStackVariable 20
• pid_t pID fork()
• if (pID 0) // child
• // Code only executed by child process
• sIdentifier "Child Process "

Compile g -o ForkTest ForkTest.cpp Run
ForkTest Parent Process Global variable 2
Stack variable 20 Child Process Global
variable 3 Stack variable 21
23
Process Creation and Termination
24
C Program Forking Separate Process
int main( ) pid_t pid / fork another
process / pid fork( ) if (pid lt 0) /
error occurred / fprintf(stderr, "Fork
Failed") exit(-1) else if (pid 0) /
child process / execlp("/bin/ls", "ls",
NULL) else / parent process / /
parent will wait for the child to complete
/ wait (NULL) printf ("Child
Complete") exit(0)
25
Process Termination

• Process executes last statement and asks the
  operating system to delete it (exit)
• Output data from child to parent (via wait)
• Process resources are deallocated by operating
  system
• Parent may terminate execution of children
  processes (abort)
• Child has exceeded allocated resources
• Task assigned to child is no longer required
• If parent is exiting
• Some operating system do not allow child to
  continue if its parent terminates
• All children terminated - cascading termination

26
Today

• Quickly revisit
• Timer interrupt, system clock
• CPU management related data structures
• Process creation and termination
• Start CPU scheduling
• Quiz 1

27
Hmm .. Who should I pick to run?
Running
OS (scheduler)
Ready
Lock
Waiting
Disk
28
First-Come, First-Served Scheduling(FCFS)

• Process Run Time
• P1 24
• P2 3
• P3 3
• Suppose that the processes arrive in the order
  P1 , P2 , P3 The Gantt Chart for the schedule
  is
• Waiting time for P1 0 P2 24 P3 27
• Average waiting time (0 24 27)/3 17

29
FCFS Scheduling (Cont.)

• Suppose that the processes arrive in the order
• P2 , P3 , P1
• The Gantt chart for the schedule is
• Waiting time for P1 6 P2 0 P3 3
• Average waiting time (6 0 3)/3 3
• Much better than previous case
• Convoy effect short process behind long process

30
Shortest-Job-First (SJF) Scheduling

• Associate with each process the length of its
  next CPU burst. Use these lengths to schedule
  the process with the shortest time
• SJF is optimal for avg. waiting time gives
  minimum average waiting time for a given set of
  processes
• In class Compute average waiting time for the
  previous example with SJF
• Prove it (Homework 1, Will be handed out next
  Friday)
• Two schemes
• nonpreemptive once CPU given to the process it
  cannot be preempted until completes its CPU burst
• preemptive if a new process arrives with CPU
  burst length less than remaining time of current
  executing process, preempt. This scheme is know
  as the Shortest-Remaining-Time-First (SRTF)

31
Choosing the Right Scheduling Algorithm/Scheduling
Criteria

• CPU utilization keep the CPU as busy as
  possible
• Throughput of processes that complete their
  execution per time unit
• Turnaround time amount of time to execute a
  particular process
• Waiting time amount of time a process has been
  waiting in the ready queue
• Response time amount of time it takes from when
  a request was submitted until the first response
  is produced, not output (for time-sharing
  environment)
• Fairness

32
When is the scheduler invoked?

• CPU scheduling decisions may take place when a
  process
• 1. Switches from running to waiting state
• 2. Switches from running to ready state
• 3. Switches from waiting to ready
• 4. Terminates
• Scheduling only under 1 and 4 nonpreemptive
  scheduling
• All other scheduling is preemptive

33
Dispatcher

• Dispatcher module gives control of the CPU to the
  process selected by the short-term scheduler
  this involves
• switching context
• switching to user mode
• jumping to the proper location in the user
  program to restart that program
• Dispatch latency time it takes for the
  dispatcher to stop one process and start another
  running

34
Example from Linux 2.6.x

• asmlinkage void __sched schedule(void)
• . . .
• prepare_arch_switch(rq, next)
• prev context_switch(rq, prev, next)
• barrier()
• finish_task_switch(prev)
• . . .
• task_t context_switch(runqueue_t rq, task_t
  prev, task_t next)
• struct mm_struct mm next-gtmm
• struct mm_struct oldmm prev-gtactive_mm
• / Here we just switch the register state and
  the stack. /
• switch_to(prev, next, prev)

define switch_to(prev,next,last) \ asm
volatile(SAVE_CONTEXT
\ "movq
rsp,Pthreadrsp(prev)\n\t" / saveRSP /
\ "movq Pthreadrsp(next),rsp\n\t" /
restore RSP / \ "call __switch_to\n\t"
\ ".globl
thread_return\n"
\ "thread_return\n\t"
\ "movq gsPpda_pcurrent,
rsi\n\t" \ "movq
Pthread_info(rsi),r8\n\t"
\ LOCK "btr tif_fork,Pti_flags(r8)\
n\t" \ "movq rax,rdi\n\t"
\ "jc
ret_from_fork\n\t"
\ RESTORE_CONTEXT
\ "a" (last)
\ next
"S" (next), prev "D" (prev),
\ threadrsp "i" (offsetof(struct
task_struct, thread.rsp)), \ ti_flags "i"
(offsetof(struct thread_info, flags)),\
tif_fork "i" (TIF_FORK),
\ thread_info "i" (offsetof(struct
task_struct, thread_info)), \ pda_pcurrent "i"
(offsetof(struct x8664_pda, pcurrent)) \
"memory", "cc" __EXTRA_CLOBBER)
35
Shortest Remaining Time First (SRTF)
36
Priority-based Scheduling

• UNIX

37
Deadline-based Algorithms
38
Proportional-Share Schedulers
39
Lottery Scheduling

• Project 1

40
Work Conservation
41
Reservation-based Schedulers
42
Rate Regulation
43
Hierarchical Schedulers
44
Problem introduced by I/O-bound processes
45
Scheduler Considerations Context-Switch Overhead
46
Scheduler Considerations Quantum Length
47
Scheduler Considerations Setting Parameters
48
Scheduler ConsiderationsCPU Accounting
49
Scheduler ConsiderationsTime and Space
Requirements
50
Algorithm Evaluation
51
A Look at the Linux CPU Scheduler

• Show a timer interrupt, blocking due to I/O etc.

52
Threads
53
Thread Libraries
54
Thread or Process?
55
Event-driven Programming

• Synchronous vs NS I/O

56
Multi-processor Scheduling
57
CPUs with Hyper-threading
58
Process Synchronization
59
Inter-process Communication
60
Deadlocks
61
System Boot-up
62
Booting a Linux Kernel
63

• Next Memory Management