Download lect_3

Chapter three


An operating system executes a variety of
programs:
 A batch system executes jobs.
 A time-shared systems has user programs or
tasks.
 A single user system, such as MS windows, a
user may able to run several programs at one
time, such as MS-word, a web browser, and an
email.
 All these activities are called processes.
The terms job and process are used interchangeably
2






A process is a program in execution.
A process is more than the program code (text section), it
includes the current activity represented by the value of
the program counter and the contents of the processor's
registers.
A process also includes the process stack, which contains
temporary data, such as function parameters and local
variables.
In addition, a process contains a data section, which
contains global variables.
A process may also include a heap, which is memory
that’s dynamically allocated during process run time.
The structure of a process in memory is:
3
4




A process is not same as program.
A program is a passive entity (executable file),
because it is a file containing a list of instructions
stored on disk while a process is an active entity
(program in execution), with a program counter
specifying the next instruction to execute.
Many people can run the same program; and each
copy of this program corresponds to a distinct
process.
A program becomes a process when it is loaded into
memory for execution.
5


Two common techniques for loading executable files are
double clicking an icon representing the executable file
and entering the name of the executable file on the
command line.
Although two processes many be associated with the
same program, they nevertheless considered two
separate execution sequences. For instance, several users
may be running different copies of the mail program, or
the same user may invoke many copies of the web
browser. Each of theses is a separate processes with the
same text section, but the data, heap, and stack sections
vary.
6






Example:
main()
{ int i, prod=1;
for (i=0;i<100;i++)
prod*=i}
The above code is a program containing one
multiplication statement (passive). However, when it’s
loaded into memory for execution, it becomes a process
(active), which will execute 100 multiplication
statements, one at time through the for loop.
7

As a process executes, it changes state

new: The process is being created.

running: Instructions are being executed.

waiting: The process is waiting for some event to
occur, such as I/O completion or reception of signal.

ready: The process is waiting to be assigned to a
processor.

terminated: The process has finished execution.
8
Only one process can be running on any processor
at any instant. Many processors may be ready and
waiting.
9










In OS, each process is represented by a process control block
or task control block.
A PCB is a data structure that physically represents a
process in the memory of a computer system.
It contains information associated with a specific process:
Process state.
Program counter.
CPU registers.
CPU scheduling information.
Memory-management information.
Accounting information.
I/O status information.
10




Process state: may be new, ready, running, waiting, or
terminated.
Program counter: indicates the address of the next
instruction to be executed for this process.
CPU registers: they include index registers, stack
pointers, and general purpose registers, and condition
code information. Along with the program counter, this
information must be saved when an interrupt occurs, to
allow the process to be continued correctly.
CPU scheduling information: includes priority and
pointers to scheduling queues.
11





Memory-management information: includes the value
of the base and limit registers, page tables, or segment
tables.
Accounting information: includes the amount of cpu
and real time used and process numbers.
I/O status information: includes the list of I/O devices
allocated to the process, a list of open files.
The PCB serves as the respiratory for any information
that may vary from process to process.
The content, format, and name of this structure will
vary, but some characteristics will be similar from
system to system (Assignment: implement PCB).
12
13
14
Trace of Process
15





Switching from one process to another in a system
requires saving the state of the old one and loading the
saved for the new process. This task is known as
context switching.
The context of a process is represented in the PCB of a
process that includes various information.
When a context switch occurs, the kernel saves the
context of old process in its PCB and loads the context
of new process that is currently to run.
The system is idle while switching.
Switching is required when an interrupt occurs.
16
17



Job queue – set of all processes in the
system.
Ready queue – set of all processes
residing in main memory, ready and
waiting to execute.
Device queues – set of processes
waiting for an I/O device Processes
migrate among the various queues.
19

As processes enter the system, they are put into
a job queue.

The processes that are residing in main
memory and are ready and waiting to execute
are kept on a list called ready queue.

The processes waiting for a particular I/O
device are kept on a list called device queue.
21
22

A new process is initially put in the ready queue. It waits there
until it is selected for execution, or it’s dispatched.

Once the process is allocated the CPU and is executing, one of
several events could occur:

The process could issue an I/O request and then be placed in an
I/O queue.

The process could create a new subprocess and wait for the
subprocess’s termination.

The process could be removed forcibly from the CPU as a result of
an interrupt, and be put back in the ready queue.


In the first two cases, the process switches from the
waiting state to the ready state and is then put back in
the ready queue.
A process continues this cycle until it terminates, at
which time it’s removed from all queues and has its
PCB and resources deallocated.

The operating system must select, for scheduling
purposes, processes from these queues in some
fashion. The selection process is carried out by the
appropriate scheduler.

Long-term scheduler (or job scheduler) – selects which
processes should be brought into the ready queue.

Short-term scheduler (or CPU scheduler) – selects
which process should be executed next and allocates
CPU.


Short-term scheduler is invoked
very frequently (milliseconds) 
(must be fast).
Long-term scheduler is invoked
very infrequently (seconds, minutes)
 (may be slow).
26
27
28


The long-term scheduler controls the degree of
multiprogramming (the number of processes in
memory).
Processes can be described as either:
I/O-bound process – spends more time doing I/O
than computations.
 CPU-bound process – spends more time doing
computations and generates infrequently I/O
requests.
 The long-term scheduler select a good process mix of
I/O bound and CPU bound.

29


If all processes are I/O bound, the ready queue
will always be empty, and the short-term
scheduler will have little to do.
If all processes are cpu bound, the I/O waiting
queue will almost always be empty, devices will
go unused, and again the system will be
unbalanced. The system with the best
performance will have a combination of cpu
bound and I/O bound processes.
30

Microsoft Windows is a time-sharing system,
hence every process is put in memory for the
short-term scheduler. Therefore MS windows
have no long-term scheduler.
31

In most system, the processes can execute
concurrently, and they may be created and
deleted dynamically. Thus systems must
provide a mechanism for process creation
and termination.
32



If a user requests that a file be printed, the
OS can create a process that will manage the
printing.
A process is created when a new user
attempts to log on .
Created by OS to provide a service


a process to control printing.
a process to control network connection.
33




When a new process is to be added to those
currently being managed, the OS builds the data
structures that are used to manage the process and
allocates address space in main memory to the
process.
A process may create several processes, via a createprocess system call, during its time of execution
The creating process is called a parent process and
the new processes are called the children of that
process.
Each of these new processes may further create
other process, forming a tree of processes.
34



OSes, such as windows and Unix identify
processes according to a unique process
identifier (pid), which is a integer number.
A process needs certain resources, such as
CPU, memory, or I/O devices to
accomplish its task.
When a process creates a subprocess, it
obtains its resources form the OS, or it
obtains a subset of the resources of its
parent.
35



The parent may partition its resources
among its children, or it may share some
resources, such as memory or files.
The sharing is better, to allow child to
create subprocesses.
For Execution


Parent and children execute concurrently, then
Parent waits until children terminate.
36

Address space


Child duplicate of parent, then
Child has a program loaded into it.
37











An UNIX example:
int main()
{ int pid;
pid=fork();// fork a child process
if(pid<0) {cout<<“fork failed”; return 1;}
// child process
else if(pid==0){execlp(“/bin/ls”,”ls”,NULL);}
else {// parent process
wait(NULL); cout<<“child complete”;}
return 0;
}
38



A new process is created by the fork()
system call.
The new process (child) duplicates the
parent process. Therefore, there are two
processes running the same c++ program
with the same data.
Both processes (parent and child) continue
execution concurrently at the fork(), with
one difference: the return code (pid) for
fork() is zero for new process (child), but
nonzero for parent program.
39


In a child program, execlp() system call replaces
the process’s memory space (program copy of
child) with a new program. execlp() loads a
binary file into memory and destroys the
memory image of the program containing
execlp() (parent’s program). Therefore, the new
process has a new program loaded into memory.
The parent can create more children; or if it has
nothing to do while the child runs, it can call
wait() system call to move itself to the ready
queue until the termination of all the children.
40
41

When the child completes, exit() system
call is invoked, and the parent resumes
from the calling of wait().
42




A process terminates when it finishes
executing its final instruction and asks the OS
to delete it by calling exit() system call
The child process returns the output value to
its parent via a wait() system call.
All the resources are deallocated by the OS.
Only the parent process can terminate its
children processes by calling abort() system
call. Hence, the parent must know the pids of
all its children at the time of termination.
Thus, when a new child process is created, its
identity is passed to its parent.
43




A parent may terminate one of its children
for:
Exceeding usage of resources.
The task assigned is completed or no longer
required.
The parent want to exist from the system,
and the OS doesn’t allow a child to
continue if it’s parent terminates. In these
systems, if a process terminates, then all its
children must also be terminated. It’s called
cascading termination.
44




Processes executing concurrently within a
system
may
be
independent
or
cooperating.
Independent process cannot affect or be
affected by the execution of another
process.
Cooperating process can affect or be
affected by other processes.
Any process sharing data with other
processes is a cooperating process.
45

Reasons for cooperating processes:




Information sharing: several users interested in
same information.
Computation speedup: a task is broken into
subtasks to run faster (needs multi processing
elements).
Modularity: function separation processes or
threads.
Convenience:user work on many tasks in
parallel.
46



Cooperating processes need interprocess
communication (IPC) mechanism to:
Allow exchange data and information
Two models of IPC


Shared memory.
Message passing.
47

A region of memory that’s shared by cooperating
processes is established by one of them.

Processes can exchange information by reading
and writing data to the shared region.
48

Mechanism for processes to communicate
without shared memory.

Like chat programs.

IPC facility provides two operations:

send(message) – message size fixed or
variable.

receive(message).
49
50



Sockets
Remote Procedure Calls
Remote Method Invocation (Java)
51




A socket is defined as an endpoint for
communication
Concatenation of IP address and port
The socket 161.25.19.8:1625 refers to
port 1625 on host 161.25.19.8
Communication consists between a
pair of sockets
53
54




Remote procedure call (RPC) abstracts
procedure calls between processes on
networked systems
Stubs – client-side proxy for the actual
procedure on the server
The client-side stub locates the server and
marshalls the parameters
The server-side stub receives this message,
unpacks the marshalled parameters, and
peforms the procedure on the server


Remote Method Invocation (RMI) is a Java
mechanism similar to RPCs
RMI allows a Java program on one machine to
invoke a method on a remote object