operating system concepts and techniques lecture 3 process m. naghibzadeh reference m. naghibzadeh,...
Post on 20-Jan-2016
220 Views
Preview:
TRANSCRIPT
Operating System Concepts and
Techniques Lecture 3
Process
M. Naghibzadeh
ReferenceM. Naghibzadeh, Operating System Concepts and Techniques, First ed., iUniverse Inc., 2011.
To order: www.iUniverse.com, www.barnesandnoble.com, or www.amazon.com
2
ProcessProcess: born to run programs
Inside a computer there is a little society of processes; Processes are
born, live, and dieOperating system is the governing
body of processesIt must keep information about
processes, called process attributes, to be able to manage them
Some attributes
3
Process identification information
Process ID
Parent process
User identifier
Group identifier
Process state information
Process-visible registers
Location counter
Condition code flags
Stack pointers
Process control information
Status
Priority
Process start time
CPU time used
Children’s CPU time used
Scheduling parameters
Links
Process privileges
Memory pointers
Devices assigned to the process
Open files
Flags
Process Control Block (PCB)
Process attributes are kept in an operating system structure called PCB;
One for each processThere is one process table in the
system Each row is for one process; it either has all PBC information of the process or some of it and a pointer to the PCB; the latter is
our conventionWhen process is terminated its PCB is
removed
4
Process table
5
Properties of P1blocked
Properties of P2ready
Properties of P3blocked
Properties of P4running
Properties of P5ready
Properties of P6ready
Properties of P7blocked
Properties of P8ready
Properties of P9ready
Properties of P10blocked
Process properties State Link Link to PCB
Front of ready queue
Rear of ready queue
System callsKernel is robust, fault-free, and efficientIt includes numerous useful procedures
Some we can call from application programs, these are called system
calls, supervisor calls, or kernel services
Kernel is protected from outside world, entering and leaving is via an strict
controlled mechanism.
6
Breaking into kernel
7
…call a kernel service from an application program….
Other layers of
the operatin
g system
A kernel service
Kernel Barrier
Kernel
A B
Kernel barrier is busted twice as shown at points A and B
Although a kernel routine is used by an application program, it is like taking a prisoner to an outside hospital for medical services while handcuffed and accompanied by two guards
Some system calls
8
Process Management
pid = fork()
pid = waitpid (pid, &static, options)
s = execve (name, argv, envp)
exit (status)
s = kill (pid, sig)
pause ()
wait (&status)
alarm (sec)
Interprocess Communication
qid = msgget(queueid, rights)
msgsnd(qid, &mymsg, size, flags)
msgrcv(qid, &mymsg, size, type, flags)
semid = semget(key, nsems, rights)
semop( semid, operation)
File System
fd = create (name, mode)
fd = open (file, how)
s = close (fd)
n = read (fd, buffer, nbytes)
n = write (fp, buffer, nbytes)
pos = lseek (fd, offset, whence)
s = stat (name, &buf)
s = mkdir (path, mode)
s = rmdir (path)
s = unlink (name)
s = chdir (name)
s = chmode (name, mode)
Unix Process State Transition Model
9
UNIX StatesThe corresponding state in the 3-stae model
Ready to Run Swapped
Ready to Run in Memory
Preempted
Sleep SwappedAsleep
In Memory
User Running
Created
Zombie
Kernel Running
Ready
Wait/
Blocked
Running
Process birth
Interrupt, Interrupt return
A process is picked to
run
Memory needed, swap out
Running obstacle is vanished
Preempt
System call or interrupt
Return
Not enough main memory
Main memory assigned
Sleep condition
ended
Exit, but not disappeared
Imaginary line
Back to running
Needs I/O or circumstance
Memory shortage swap out
Swap in
Why are Processes Created?
Processes are the means of running programs to perform tasks
Processes are created from executable files
10
When is a Process Created?
At computer start or restart, by OSExplicit request by a computer user
double clicking on an executable file opening an executable program file
issuing a command to run a program, etc.
In response to a request from a running process to create a child
process
11
Process creation/termination
Why are processes created?When is a process created?
What is done to create a process?What are the tools for creating a
process?What are common in parent and child
processes?What are different between parent and
child processes?How is a process terminated?
12
What is done to create a process?
Ensure the degree of multiprogramming does not been exceeds its maximum
Generate a unique process IDUse one row of Process table
Allocate space for the PCB and initialize proper fields; then make the connection between the corresponding
row of the process table and this PCBAllocate space for process context
Allocate space for other preliminary structures such as stacks and stack pointers and initialize the related fields
in PCBPut the process in one of the queues, usually ready
queue
13
Process creation using fork()
void main(void){
int pid; int retval;
int status; // Pointer to the value returned by the child process pid = fork(); // It is assume that, there is no obstacle in creating
// the child process if (pid != 0) // This is the parent process
{ proc1; // Parent process will continue running procedure proc1
wait (&status); // Wait until the child process is terminated } else {
proc2; // Child process will continue running procedure proc2 status = …; // Provide a valid value for the returned status to parent process
exit (status); }
}
14
How is a Process Terminated?
When its execution is completed it is logically terminated
For the physical termination of a process, all memory occupied as process images and stacks are first
freed. Then, the process control block is freed and the process is removed from the process table
Logical termination of a process takes less processing time than its physical termination. For logical
termination it suffices to change the terminating process’s state to terminated and to actually add this
process to the set of terminated processes.
It could be killed by OS or user
15
SummaryProcesses are one of the central issues of every operating
systemProcesses are created to run programs
Process state transition diagram shows the living states of process and its transactions
The request to create a process could come from a user, an application process, or the operating system itself
The same requesters could order the destruction of a process or it could be terminated automatically when its duty is
finished or when a fatal fault has occurred A process that requests the creation of another process
becomes the parent process and the created process is called the child process
A child process goes its own way right after it is createdAs UNIX is a process-based operating system, this chapter was
able to use actual examples from this operating system.
16
17
Find outThe purpose of system calls
The purpose of the transitions from kernel to itself
Complete set of Unix system callsThe deficiencies of process
How we can create a child process to run a different program (not a different
procedure)Whether Linux is a process-based
operating system or a thread-based one
18
Any questions?
top related