Vous êtes sur la page 1sur 15


Andrew Whitaker
 Multiprogramming: Running multiple programs
“at the same time”
Requires multiplexing (sharing) the CPU

Firefox Word javac Firefox Word


 Transfer of control is called a context switch

The Process
 The process is an OS
kernel space
abstraction for a running
program stack
(dynamic allocated mem)
 Process is associated
with an address space
(dynamic allocated mem)
 Preview: Thread is a static data
running program without (data segment)
its own address space code PC
(text segment)
How Do Processes Share the CPU?

The OS maintains a per-process Process

Control Block (PCB)
Which stores state for non-running processes
On a context switch
Save state of the old process
Restore state of the new process
What’s in the PCB?
 The PCB is a data structure with many fields:
process ID (PID)
execution state (Ready, Running, Blocked)
program counter, stack pointer, registers
memory management info
UNIX username of owner
scheduling priority
accounting info
 In linux:
defined in task_struct (include/linux/sched.h)
over 95 fields!!!
States of a process

dispatch interrupt

ready blocking I/O

(I/O complete)

State queues

The OS maintains a set of queues that

represent the state of processes in the
e.g., ready queue: all runnable processes
e.g., wait queue: processes blocked on some
As a process changes state, its PCB is
unlinked from one queue, and linked onto
State queues
Ready queue header

head ptr netscape pcb emacs pcb ls pcb

tail ptr

Wait queue header

head ptr cat pcb netscape pcb

tail ptr

 There may be many wait queues, one for each

type of wait (particular device, timer, message,
Walking Through a Context Switch
 Process A enters the kernel
 Due to a system call, interrupt, or exception
 The kernel scheduler is invoked:
 Is it time to context switch?
 If so, which is the next process to run?
 Assembly routine exchanges hardware state
 Save process A’s state to its PCB
 Load process B’s state from its PCB
 (Process B now running)
 OS returns control to user mode
The Guts of Context Switching (x86)

1. define switch_to(prev,next,last) do {
2. unsigned long esi,edi;
3. asm volatile("pushl %%ebp\n\t"
4. "movl %%esp,%0\n\t /* save stackptr */
5. "movl %5,%%esp\n\t /* restore stackptr */
6. "movl $1f,%1\n\t" /* save instr_ptr */
7. "pushl %6\n\t" /* restore instr_ptr */
8. "jmp __switch_to\n” /* Return to C */
9. "1:\t" /* 1: is $1f*/
10. "popl %%ebp\n\t"
11. :"=m" (prev->thread.esp), /* %0 */
12. "=m" (prev->thread.eip), /* %1 */
13. "=a" (last), /* %2 */
14. "=S" (esi),"=D" (edi)
15. :"m" (next->thread.esp), /* %5 */
16. "m" (next->thread.eip), /* %6 */
17. "2" (prev), "d" (next));
18. } while (0)
UNIX Process API

How do user programs interact with

Fork: create a new process
Exec: run a program
Kill: destroy a process
Wait: wait for a process to exit
UNIX process creation
 Via the fork() system call
 Fork essentially clones the parent process
Child receives identical (but separate) address space
Child inherits open files from its parent
 The fork() system call “returns twice”
Returns the child’s PID to the parent
Returns 0 to the child
Fork example
int value = 5;

int main () {
pid_t pid ; What value is printed to
the screen?
value = 7;

pid = fork();
if (pid == 0) { /* Child */
value += 15;
else { /* Parent */
wait (NULL); /* Wait for child to terminate */
printf("PARENT: value = %d\n",value );
Exec vs. fork
 So how do we start a new program, instead of
just forking the old program?
the exec() system call!
int exec(char *prog, char ** argv)
 exec()
stops the current process
loads program ‘prog’ into the address space
initializes hardware context, args for new program
places PCB onto ready queue
note: does not create a new process!
UNIX shells
int main(int argc, char **argv)
while (1) {
char *cmd = get_next_command();
int child_pid = fork();
if (child_pid == 0) {
panic(“exec failed!”);
} else {