Processes (Tasks) and
operating systems
Motivation for processes.
The process abstraction.
Context switching.
Multitasking.
Processes and UML.
Operating systems
Based on slides © Morgan Kaufman
Why multiple processes?
Processes help us manage timing
complexity:
ִmultiple rates
multimedia
automotive
ִasynchronous input
user interfaces
communication systems
Based on slides © Morgan Kaufman
Example: engine control
Tasks:
ִspark control
ִcrankshaft sensing
ִfuel/air mixture
ִoxygen sensor
ִKalman filter
ִstate machine
engine
controller
Based on slides © Morgan Kaufman
1
Life without processes
Code turns into a
mess:
ִinterruptions of one
task for another
ִspaghetti code
time
A
B
C
A
C
Based on slides © Morgan Kaufman
A_code();
…
B_code();
…
if (C) C_code();
…
A_code();
…
switch (x) {
case C: C();
case D: D();
...
Co-routine methodology
Co-routines are cooperating subroutines
where:
Unlike a subroutine, the caller determines
the return address.
Co-routines voluntarily give up control to
other co-routines.
Pattern of control transfers is embedded
in the code.
Based on slides © Morgan Kaufman
Co-routine Example
Co-routine 1
ADR r14,co2a
co1a …
ADR r13,co1b
MOV r15,r14
co1b …
ADR r13,co1c
MOV r15,r14
co1c ...
Co-routine 2
co2a …
ADR r13,co2b
MOV r15,r13
co2b …
ADR r13,co2c
MOV r15,r13
co2c …
Based on slides © Morgan Kaufman
2
Processes / Tasks
A process is a unique execution of a program.
ִSeveral copies of a program may run
simultaneously or at different times.
A process has its own state:
ִregisters;
ִmemory.
The operating system manages processes.
Based on slides © Morgan Kaufman
Processes and CPUs
Activation record:
copy of process state.
Context switch:
ִcurrent CPU context
goes out;
ִnew CPU context goes
in.
process 1
process 2
PC
registers
...
CPU
memory
Based on slides © Morgan Kaufman
Terms
Thread = lightweight process: a process
that shares memory space with other
processes.
Reentrancy: ability of a program to be
executed several times with the same
results.
Based on slides © Morgan Kaufman
3
Processes in POSIX
Create a process with
fork:
ִparent process keeps
executing old
program;
ִchild process executes
new program.
process a
process a
process b
Based on slides © Morgan Kaufman
POSIX – fork()
The fork process creates child:
childid = fork();
if (childid == 0) {
/* child operations */
} else {
/* parent operations */
}
Based on slides © Morgan Kaufman
POSIX – execv()
Overlays child code:
childid = fork();
if (childid == 0) {
execv(“mychild”,childargs);
perror(“execv”);
exit(1);
}
file with child code
Based on slides © Morgan Kaufman
4
Context switching
A context switch is the transfer of use of the
CPU from one executing process to another.
Who controls when the context is
switched?
How is the context switched?
Based on slides © Morgan Kaufman
Co-operative multitasking
Improvement on co-routines:
ִhides context switching mechanism;
ִstill relies on processes to give up CPU.
Each process allows a context switch at
cswitch() call.
Separate scheduler chooses which
process runs next.
Based on slides © Morgan Kaufman
Problems with co-operative
multitasking
Programming errors can keep other
processes out:
ִprocess never gives up CPU;
ִprocess waits too long to switch, missing
input.
Based on slides © Morgan Kaufman
5
Context switching
Must copy all registers to activation record,
keeping proper return value for PC.
Must copy new activation record into CPU state.
How does the program that copies the context
keep its own context?
- stack for fixed number of processes.
- task control block for a dynamic or
indeterminate number of processes.
Based on slides © Morgan Kaufman
Preemptive multitasking
Most powerful form of multitasking:
ִOS controls when contexts switches;
ִOS determines what process runs next.
Use timer to call OS, switch contexts:
timer
interrupt
CPU
Based on slides © Morgan Kaufman
Flow of control with
preemption
interrupt
P1
interrupt
OS
P1
OS
P2
time
Based on slides © Morgan Kaufman
6
Preemptive context
switching
Timer interrupt gives control to OS, which
saves interrupted process’s state in an
activation record.
OS chooses next process to run.
OS installs desired activation record as
current CPU state.
Based on slides © Morgan Kaufman
Why not use interrupts?
We could change the interrupt vector at
every period, but:
ִwe would need management code anyway;
ִwe would have to know the next period’s
process at the start of the current process.
Based on slides © Morgan Kaufman
Operating systems
The operating system controls resources:
ִwho gets the CPU;
ִwhen I/O takes place;
ִhow much memory is allocated.
The most important resource is the CPU
itself.
ִCPU access controlled by the scheduler.
Based on slides © Morgan Kaufman
7
Process State or Task Control
Model
A process can be in
one of three states:
ִexecuting on the CPU;
ִready to run;
ִwaiting for data.
executing
gets
CPU
preempted
gets data
and CPU
needs
data
gets data
ready
waiting
needs data
Based on slides © Morgan Kaufman
Operating system
structure
OS needs to keep track of:
ִprocess priorities;
ִscheduling state;
ִprocess activation record.
Processes may be created:
ִstatically before system starts;
ִdynamically during execution.
Based on slides © Morgan Kaufman
Embedded vs. generalpurpose scheduling
Workstations try to avoid starving
processes of CPU access.
ִ Fairness implies that all processes have
equal access to CPU.
Embedded systems must meet deadlines.
ִ Low-priority processes may not run for a
long time.
Based on slides © Morgan Kaufman
8
Time quanta
Quantum: unit of time for scheduling.
Based on slides © Morgan Kaufman
Priority-driven scheduling
Each process has a priority.
CPU goes to highest-priority process that
is ready.
Priorities determine scheduling policy:
ִfixed priority;
ִtime-varying priorities.
Based on slides © Morgan Kaufman
Priority-driven scheduling
example
Rules:
ִeach process has a fixed priority (1 highest);
ִhighest-priority ready process gets CPU;
ִprocess continues until done or wait state.
Processes
ִP1: priority 1, execution time 10
ִP2: priority 2, execution time 30
ִP3: priority 3, execution time 20
Initially: P2 is ready to run when the system is
started. P1’s data arrives at time=15. P3’s data arrives
at time=18
Based on slides © Morgan Kaufman
9
Priority-driven scheduling
example
P3 ready t=18
P2 ready t=0 P1 ready t=15
P2
0
P1
10
20
P2
30
P3
40
60
50
time
Based on slides © Morgan Kaufman
The scheduling problem
Can we meet all deadlines?
ִMust be able to meet deadlines in all cases.
How much CPU horsepower do we need
to meet our deadlines?
Based on slides © Morgan Kaufman
Process initiation disciplines
Periodic process: executes on (almost)
every period.
Aperiodic process: executes on demand.
Analyzing aperiodic process sets is harder--must consider worst-case combinations
of process activations.
Based on slides © Morgan Kaufman
10
Timing requirements on
processes
Execution time: amount of time it takes for
a process to run.
Period: interval between process activations.
Initiation interval: reciprocal of period.
Initiation time: time at which process
becomes ready.
Deadline: time at which process must finish.
(generally, period = deadline)
Based on slides © Morgan Kaufman
Timing violations
What happens if a process doesn’t finish
by its deadline?
ִHard deadline: system fails if missed.
ִSoft deadline: user may notice, but system
doesn’t necessarily fail.
Based on slides © Morgan Kaufman
Example: Space Shuttle
software error
Space Shuttle’s first launch was delayed
by a software timing error:
ִPrimary control system PASS and backup
system BFS.
ִBFS failed to synchronize with PASS.
ִChange to one routine added delay that
threw off start time calculation.
ִ1 in 67 chance of timing problem.
Based on slides © Morgan Kaufman
11
Interprocess communication
Interprocess communication (IPC): OS
provides mechanisms so that processes
can pass data.
Two types of semantics:
ִblocking: sending process waits for response;
ִnon-blocking: sending process continues.
Based on slides © Morgan Kaufman
IPC styles
Shared memory:
ִprocesses have some memory in common;
ִmust cooperate to avoid destroying/missing
messages.
Message passing:
ִprocesses send messages along a
communication channel---no common
address space.
Based on slides © Morgan Kaufman
Shared memory
Shared memory on a bus:
CPU 1
memory
CPU 2
Based on slides © Morgan Kaufman
12
Race condition in shared
memory
Problem when two CPUs try to write the
same location:
ִCPU 1 reads flag and sees 0.
ִCPU 2 reads flag and sees 0.
ִCPU 1 sets flag to one and writes location.
ִCPU 2 sets flag to one and overwrites
location.
Based on slides © Morgan Kaufman
Atomic test-and-set
Problem can be solved with an atomic
(un-interruptable) test-and-set:
ִsingle bus operation reads memory location,
tests it, writes it.
ARM test-and-set provided by SWP:
ADR r0,SEMAPHORE
LDR r1,#1
GETFLAG SWP r1,r1,[r0]
BNZ GETFLAG
Based on slides © Morgan Kaufman
Critical regions
Critical region: section of code that cannot
be interrupted by another process.
Examples:
ִwriting shared memory;
ִaccessing I/O device.
Based on slides © Morgan Kaufman
13
Semaphores
Semaphore: OS primitive for controlling
access to critical regions.
Protocol:
ִGet access to semaphore with P().
ִPerform critical region operations.
ִRelease semaphore with V().
Based on slides © Morgan Kaufman
Message passing
Message passing on a network:
CPU 1
CPU 2
message
message
message
Based on slides © Morgan Kaufman
Process data
dependencies
One process may not
be able to start until
another finishes.
Data dependencies
defined in a task
graph.
All processes in one
task run at the same
rate.
P1
P2
P3
P4
Based on slides © Morgan Kaufman
14
Other operating system
functions
Date/time.
File system.
Networking.
Security.
Based on slides © Morgan Kaufman
15