Operating

Systems
Lecture 6
 Agenda for Today
 Process scheduling concepts
 Process creation and termination
 Process management in UNIX/Linux—
system calls: fork, exec, wait, exit
 Sample codes
 Recap of the lecture
 Schedulers
 Long term scheduler
 Short term scheduler
 Medium term scheduler
Queues in a Computer
System
 Long Term Scheduler
 Long-term scheduler (or job scheduler) –
selects processes from the job pool to be
brought into the ready queue.
 Long-term scheduler is invoked very
infrequently (seconds, minutes)  (may be
slow).
 The long-term scheduler controls the degree
of multiprogramming.
 More processes, smaller percentage of time
each process is executed
 Short Term Scheduler
 Short-term scheduler (or CPU scheduler) –
selects which process should be executed
next and allocates it the CPU through the
dispatcher.
 Short-term scheduler is invoked very frequently
(milliseconds)  (must be fast).
 Invoked when following events occur
 CPU slice of the current process finishes
 Current process needs to wait for an event
 Clock interrupt
 I/O interrupt
 System call
 Signal
 Medium Term
Scheduler
 Also known as swapper
 Selects an in-memory process and swaps
it out to the disk temporarily
 Swapping decision is based on several
factors
 Arrival of a higher priority process but no
memory available
 Poor mix of jobs
 Memory request of a process cannot be met
Addition of Medium
Term Scheduling
 Context Switch
 When CPU switches to another process,
the system must save the state (context)
of the ‘current’ (old) process and load the
saved state for the new process.
 Context-switch time is overhead; the
system does no useful work while
switching.
 Time dependent on hardware support;
typically in microseconds
 Process Creation
 Parent process create children processes,
which, in turn create other processes,
forming a tree of processes.
 Resource sharing
 Parent and children share all resources.
 Children share a subset of parent’s resources.
 Parent and child share no resources.
 Execution
 Parent and children execute concurrently.
 Parent waits until children terminate.
 Process Creation …
 Address space
 Child duplicate of parent.
 Child has a program loaded onto it.
 UNIX examples
 fork system call creates a new process
 exec system call used after a fork to
replace the process’ memory image with
a new executable.
Processes Tree on a
UNIX System
 Process Termination
 Process executes the last statement and
requests the operating system to terminate
it (exit).
 Output data from child to parent (via wait).
 Process resources are deallocated by the
operating system, to be recycled later.
Process Termination …
 Parent may terminate execution of
children processes (abort).
 Child has exceeded allocated resources
(main memory, execution time, etc.).
 Parent needs to create another child but has
reached its maximum children limit
 Task performed by the child is no longer
required.
 Parent exits.
 Operating system does not allow child to continue
if its parent terminates.
 Cascaded termination
Process Management in
UNIX/Linux
Important process-related UNIX/Linux
system calls
 fork
 wait
 exec
 exit
fork()
 When the fork system call is executed, a new
process is created which consists of a copy of the
address space of the parent.
 This mechanism allows the
parent process to communicate easily with the child
process.
SYNOPSIS
#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
fork() ...
 The return code for fork is zero for the child process
and the process identifier of child is returned to the
parent process.
 On success, both processes continue execution at the
instruction after the fork call.
 On failure, -1 is returned to the parent process and
errno is set appropriately to indicate the reason of
failure; no child is created
fork()—Sample Code
main()
{
int pid; • Pid 1234
Parent Process pid = 1234

...
pid = fork();
if (pid == 0) {
/* Code for child */ Child Process pid = 0
... • Pid=0
}
else {
/* Code for parent */
...
}
Kernel Space
...
}
fork()—Inherits from
the Parent
The child process inherits the following attributes
from the parent:
 Environment
 Open file descriptor table
 Signal handling settings
 Nice value
 Current working directory
 Root directory
 File mode creation mask (umask)
 Etc.
fork()—Child Differs
from the Parent
The child process differs from the parent
process:
 Different process ID (PID)
 Different parent process ID (PPID)
 Child has its own copy of parent’s file
descriptors
 Etc.
fork()—Reasons for
Failure
 Maximum number of processes allowed to execute
under one user has exceeded
 Maximum number of processes allowed on the
system has exceeded
 Not enough swap space
 wait()
 The wait system call suspends the
calling process until one of its
immediate children terminates, or until
a child that is being traced stops
because it has hit an event of interest.
 wait returns prematurely if a signal is
received. If all children processes
stopped or terminated prior to the call
on wait, return is immediate.
 Synopsis of wait()
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *stat_loc);

<sys/types.h>:
/usr/include/sys/types.h
 wait() ...
 If the call is successful, the
process ID of the terminating child
is returned.
 If parent terminates all its children
have assigned as their new
parent, the init process. Thus the
children still have a parent to
collect their status and execution
statistics.
 wait() ...
 Zombie process—a process that
has terminated but whose exit
status has not yet been received
by its parent process or by init.
 Sample Code—fork
#include <stdio.h>
void main()
{
int pid, status;

pid = fork();
if(pid == -1) {
printf(“fork failed\n”);
exit(1);
}
 Sample Code—fork
if(pid == 0) { /* Child */
printf(“Child here!\n”);
exit(0);
}
else { /* Parent */
wait(&status);
printf(“Well done kid!\n”);
exit(0);
}
}
Semantics of fork

fork

P
 exec()
 Typically the exec system call is used
after a fork system call by one of the
two processes to replace the process’
memory space with a new executable
program.
 The new process image is
constructed from an ordinary,
executable file.
 exec()
 There can be no return from a
successful exec because the
calling process image is overlaid
by the new process image
 Synopsis of exec()

#include <unistd.h>
int execlp (const char *file, const
char *arg0, ..., const char *argn,
(char *)0);
 Sample Code—fork
and exec
#include <stdio.h>
void main()
{
int pid, status;

pid = fork();
if(pid == -1) {
printf(“fork failed\n”);
exit(1);
}
 Sample Code—fork
and exec
if(pid == 0) { /* Child */
if (execlp(“/bin/ls”, “ls”, NULL)< 0) {
printf(“exec failed\n”);
exit(1);
}
}
else { /* Parent */
wait(&status);
printf(“Well done kid!\n”);
exit(0);
}
}
 Semantics of fork
parent parent parent

P P P

fork

P P ls ls
exec
child child child
1 2 3