CECS 326 – Lab Exercise 11/22//05 (20 points) – Due 12/6/05
Proper management of memory in a paging system relies on proper maintenance of the memory block table, which
records the number of free memory blocks and the allocation status of these blocks. This lab exercise simulates the
allocation and deallocation of memory blocks in a paged memory system. To complete this project you will need to use
ipc mechanisms provided on linux, including shmget, shmctl, shmop, and all others that you have used in previous lab
exercises. To help you learn about these systems calls, two sample programs named shmp.cpp and shmc.cpp are provided
for your reference. To understand this shared memory mechanism please reference manual pages for shmget, shmctl,
shmop.
Assume that there are a total of 50 memory blocks available to user processes. Initially all blocks are free. A memory
block table is used to keep track of the status of these memory blocks. Before a user process can begin its execution, the
kernel must first determine the number of memory blocks the process needs, create a page table, acquire all the memory
blocks for the user process, and record the page-to-memory block mapping in the process’ page table before the user
process is initiated. Since the memory block table may be accessed by a number of processes at a time, its access must
therefore be guarded via a mutual exclusion semaphore. A counting semaphore may be used to keep track of the number
of remaining free blocks. Blocks allocated to a process need not be contiguous.
For this project you will need to write two programs. One program serves as the parent process that starts by creating and
initializing the shared memory block table as well as the required semaphores. It should then create a number of identical
child processes each to perform the task as outlined below. Use a loop in the parent process to control the child process
creation. The number of child processes to be created is supplied by user in the command line, and a pause between 0 and
4 (number to be generated randomly) seconds will take place between each two consecutive loop iterations. And then
finally the parent process should remove the shared memory block table and the semaphores that it has created when all of
its child processes have terminated.
Logic of child process:
Generate an integer random number n between 5 and 25 (inclusive);
Allocate space big enough for a page table of size n;
Attach to the shared memory block table.
P(n_free, n); // n_free is a counting semaphore. This P operation attempts to decrement n_free by n.
P(mutex); // mutex is a mutual exclusion semaphore to guard the execution of the following critical section.
Update memory block table and record the block numbers of the n allocated blocks in the process’ page table;
V(mutex);
Detach from the shared memory block table;
Sleep for a random number of seconds; // simulates the execution of the user process
Attach to the shared memory block table;
P(mutex);
Update memory block table as a result of the memory release;
V(mutex);
V(n_free,n); // this V operation increments n_free by n & wakeup a waiting process, if any
Detach from the shared memory block table;
Release the space used for the page table;
Suggestion for output:
Sufficient output must be generated to allow the tracing of all activities. Specifically, a line of output in the format as
shown below for every event that occurs should be useful for tracing:
PID Event ( 50 bits representing the status of the 50 memory blocks, if event that causes status change )
where the output fields are defined as follows:
PID shows the process ID of the process that causes the event to occur.
Event is any one of the following list of relevant events:
REQ n : a process requests for n memory blocks
ALL n : a process is allocated n memory blocks
REL n : a process releases n memory blocks
