Lab 3 of 7 Process Management Simulation L A B O V E R V I E W.docx

Lab 3 of 7: Process Management Simulation
L A B O V E R V I E W
Scenario/Summary
Process Management Simulation (Part 3 of 3)
The objective of this three section lab is to simulate four
process management functions:
process creation, replacing the current process image with a
new process image, process state transition,
and
process scheduling
.
This lab will be due over the first three weeks of this course.
The commander process program is due in Week 1. This
program will introduce the student to system calls and other
basic operating system functions. The process manager
functions
“
process creation
,
replacing the current process image with a new process image
and
process state transition
“
are due in Week 2. The scheduling section of the process
manager is due in Week 3.
You will use Linux system calls such as fork( ), exec(), wait( ),
pipe( ), and sleep( ). Read man pages of these system calls for
details.
This simulation exercise consists of three processes running on
a Linux environment:
commander

,
process manager
, and
reporter
. There is one commander process (this is the process that starts
your simulation), one process manager process that is created
by the commander process, and a number of reporter processes
that get created by the process manager, as needed.
1. Commander Process:
The commander process first creates a pipe and then the process
manager process. It then repeatedly reads commands from the
standard input and passes them to the process manager process
via the pipe. The commander process accepts four commands:
1.
Q
: End of one unit of time.
2.
U
: Unblock the first simulated process in blocked queue.
3.
P
: Print the current state of the system.
4.
T
: Print the average turnaround time, and terminate the system.
Command
T
can only be executed once.
1.1 Simulated Process:
Process management simulation manages the execution of
simulated processes. Each simulated process is comprised of a
program that manipulates the value of a single integer variable.
Thus the state of a simulated process at any instant is comprised
of the value of its integer variable and the value of its program
counter.
A simulated process™ program consists of a sequence of

instructions. There are seven types of instructions as follows:
1.
S
n: Set the value of the integer variable to n, where n is an
integer.
2.
A
n: Add n to the value of the integer variable, where n is an
integer.
3.
D
n: Subtract n from the value of the integer variable, where n is
an integer.
4.
B
: Block this simulated process.
5.
E
: Terminate this simulated process.
6.
F
n: Create a new (simulated) process. The new (simulated)
process is an exact copy of the parent (simulated) process. The
new (simulated) process executes from the instruction
immediately after this (
F
) instruction, while the parent (simulated) process continues its
execution n instructions after the next instruction.
7.
R
filename: Replace the program of the simulated process with
the program in the file filename, and set program counter to the
first instruction of this new program.
An example of a program for a simulated process is as follows:
S 1000
A 19

A 20
D 53
A 55
F 1
R file_a
F 1
R file_b
F 1
R file_c
F 1
R file_d
F 1
R file_e
E
You may store the program of a simulated process in an array,
with one array entry for each instruction.
2. Process Manager Process:
The process manager process simulates four process
management functions:
creation of new (simulated) processes
,
replacing the current process image of a simulated process with
a new process image
,
management of process state transitions
, and
process scheduling
. In addition, it spawns a reporter process whenever it needs to
print out the state of the system.
The process manager creates the first simulated process
(process ID = 0) program from an input file (filename: init).
This is the only simulated process created by the process
manager on its own. All other simulated processes are created in
response to the execution of the
F
instruction (read from the simulated processes).

2.1 Data structures:
The process manager maintains six data structures:
Time, Cpu, PcbTable, ReadyState, BlockedState,
and
RunningState
.
Time
is an integer variable initialized to zero.
Cpu
is used to simulate the execution of a simulated process that is
in running state. It should include data members to store a
pointer to the program array, current program counter value,
integer value, and time slice of that simulated process. In
addition, it should store the number of time units used so far in
the current time slice.
PcbTable
is an array with one entry for every simulated process that
hasn't finished its execution yet. Each entry should include data
members to store process ID, parent process ID, a pointer to
program counter value (initially 0), integer value, priority,
state, start time, and CPU time used so far.
ReadyState
stores all simulated processes (PcbTable indices) that are ready
to run. This can be implemented using a queue or priority queue
data structure.
BlockedState
stores all processes (PcbTable indices) that are currently
blocked. This can be implemented using a queue data structure.
RunningState
stores the PcbTable index of the currently running simulated
process.
2.2 Processing input commands:
After creating the first process and initializing all its data
structures, the process manager repeatedly receives and

processes one command at a time from the commander process
(read via the pipe). On receiving a
Q
command, the process manager executes the next instruction of
the currently running simulated process, increments program
counter value (except for
F
or
R
instructions), increments
Time
, and then performs scheduling. Note that scheduling may
involve performing context switching.
On receiving a
U
command, the process manager moves the first simulated
process in the blocked queue to the ready state queue array. On
receiving a
P
command, the process manager spawns a new reporter process.
On receiving a
T
command, the process manager first spawns a reporter process
and then terminates after termination of the reporter process.
The process manager ensures that no more than one reporter
process is running at any moment.
2.3 Executing simulated processes:
The process manager executes the next instruction of the
currently running simulated process on receiving a
Q
command from the commander process. Note that this
execution is completely confined to the
Cpu
data structure, i.e.,
PcbTable
is not accessed.

Instructions
S
,
A,
and
D
update the integer value stored in
Cpu
. Instruction
B
moves the currently running simulated process to the blocked
state and moves a process from the ready state to the running
state. This will result in a context switch. Instruction
E
terminates the currently running simulated process, frees up all
memory (e.g., program array) associated with that process and
updates the
PcbTable
. A simulated process from the ready state is moved to running
state. This also results in a context switch.
Instruction
F
results in the creation of a new simulated process. A new entry
is created in the
PcbTable
for this new simulated process. A new (unique) process ID is
assigned and the parent process ID is the process ID of the
parent simulated process. Start time is set to the current
Time
value and CPU time used so far is set to 0. The program array
and integer value of the new simulated process are a copy of the
program array and integer value of the parent simulated process.
The new simulated process has the same priority as the parent
simulated process. The program counter value of the new
simulated process is set to the instruction immediately after the
F

instruction, while the program counter value of the of the
parent simulated process is set to
n
instructions after the next instruction (instruction immediately
after
F
). The new simulated process is created in the ready state.
Finally, the
R
instruction results in replacing the process image of the
currently running simulated process. Its program array is
overwritten by the code in file
filename
, program counter value is set to 0, and integer value is
undefined. Note that all these changes are made only in the
Cpu
data structure. Process ID, parent process ID, start time, CPU
time used so far, state, and priority remain unchanged.
2.4 Scheduling
The process manager also implements a scheduling policy. You
may experiment with a scheduling policy of multiple queues
with priority classes. In this policy, the first simulated process
(created by the process manager) starts with priority 0 (highest
priority). There are a maximum of four priority classes. Time
slice (quantum size) for priority class 0 is 1 unit of time; time
slice for priority class 1 is 2 units of time; time slice for
priority class 2 is 4 units of time; and time slice for priority
class 3 is 8 units of time. If a running process uses its time slice
completely, it is preempted and its priority is lowered. If a
running process blocks before its allocated quantum expires, its
priority is raised.
3. Reporter Process
The reporter process prints the current state of the system on the
standard output and then terminates. The output from the
reporter process appears as follows:
*****************************************************

***********
The current system state is as follows:
*****************************************************
***********
CURRENT TIME:
time
RUNNING PROCESS:
pid, ppid, priority, value, start time, CPU time used so far
BLOCKED PROCESSES:
Queue of blocked processes:
¦
PROCESSES READY TO EXECUTE:
Queue of processes with priority 0:
pid, ppid, value, start time, CPU time used so far
¦
¦
*****************************************************
***********
Deliverables
You will submit three separate files to the dropbox for Week 3:
C or C++ program (source code)
Executable file (object), and
Instructions to execute the program
L A B S T E P S
Process Manager Scheduling
(25 points)

The programs for the process scheduling and the reporter
process are due this week. These programs are to be written in
C or C++ programming languages on a Linux environment.
IMPORTANT: Please make sure that any questions or
clarification about these labs are addressed early.
2.4 Scheduling
The process manager also implements a scheduling policy. You
may experiment with a scheduling policy of multiple queues
with priority classes. In this policy, the first simulated process
(created by the process manager) starts with priority 0 (highest
priority). There are a maximum of four priority classes. Time
slice (quantum size) for priority class 0 is 1 unit of time; time
slice for priority class 1 is 2 units of time; time slice for
priority class 2 is 4 units of time; and time slice for priority
class 3 is 8 units of time. If a running process uses its time slice
completely, it is preempted and its priority is lowered. If a
running process blocks before its allocated quantum expires, its
priority is raised.
Reporter Process Requirements
(25 points)
3. Reporter Process
The reporter process prints the current state of the system on the
standard output and then terminates. The output from the
reporter process appears as follows:
*****************************************************
***********
The current system state is as follows:
*****************************************************
***********
CURRENT TIME:
time
RUNNING PROCESS:
BLOCKED PROCESSES:

Queue of blocked processes:
¦
PROCESSES READY TO EXECUTE:
¦
¦
*****************************************************
***********

Lab 3 of 7 Process Management Simulation L A B O V E R V I E W.docx

More Related Content

Similar to Lab 3 of 7 Process Management Simulation L A B O V E R V I E W.docx (20)

More from festockton (20)

Recently uploaded (20)

Lab 3 of 7 Process Management Simulation L A B O V E R V I E W.docx