fork() Experiments

1. Observe in what order the print statements come by running the program multiple times. Is it always in the same order or different? Is it different for different people?
2. Put a sleep of 5 seconds in parent and child and check the PIDs using the ps command. Check that the PPID of the child is indeed the PID of the parent process.
3. Remove the sleep in child while retaining it in parent. Using the ps command check the state of the child process.
4. Remove the sleep in parent and not in child. Verify if the child dies or is inherited by init.
5. Have two variables -- one global and one local to main(). Initialize them before fork(). Print the values in parent and child after fork(). What are the values?
7. Modify the values of both the local and global variables in first, the parent and then the child. In each case, print the values in both the processes. What are the values?
8. Open a file before fork(). After fork(), write to the file from parent and child the strings "From Parent" and "From Child" to the file. In what order are they written to the file? Are the strings overwritten or one after the other?
9. Add "\n" to the strings of the previous experiment. Is there any difference in observed output?

exec() Experiments

1. Write a program that simply calls execl() with some command without calling fork(). Have a variable for the return value of execl() and print it to stderr and then exit from your program. Observe if the printf() is executed in your program when a) command is a known and available command b) not a meaningful command.
2. Write a program that calls fork() and then call execl() in a) Parent and b) in Child. Is there any difference?
3. Open a file in your program using system call open() before fork(). Pass this file descriptor to execl() as an argument. Please remember that args are char*. So, you need to pass a string and not an integer. Are you able to use this fd and write to the file (you have to use the write system call) without opening it again after execl() in Child?

pipe() Experiments

1. Use pipe() to create two pipes. Then, fork(). Close the read side of one pipe and write side of one pipe in both processes to create a bidirectional IPC. Use the pipe to send messages from one process to another and print them.
2. When writing to pipes, have both processes first write to the pipe and then read from the other pipe.
3. Have one process first write and then read whereas the other process first reads and then sends back the same message back to the other process. Read in the first process and print the message to the display.
4. Have both processes first read from the pipe and then write to the pipe. What happens?
5. Open only one pipe before fork(). After fork(), have a sleep in parent for say 2 seconds. In child, close both fds and go to sleep for 5 seconds. In parent, after sleep, write to the pipe. What happens?

FIFO Experiments

Multithreading Experiments

1. Use the program demonstrated in the class where we pass the address of the variable i to the thread as a parameter. Print the value of this parameter from each thread created. What is the value printed? Why do you think it is so?
2. Write a program in which you create 2 threads and pass 1,2 to the thread as a parameter. In the thread function, print the value of the parameter passed 10 times. Have a global variable initialised to 0. In the thread function, increment this counter and print the value of the tid and counter value 10 times. Check the counter value printed from the threads. Is there any inconsistency in the value or is the output as you expected? Experiment the same by adding a mutex around the critical section of incrementing the counter. Print the values and check if there is any difference in output. Is there inconsistency in values? What is needed if we want to ensure that the value of the counter must be printed in a certain order?
3. File experiment: Write the counter value to the file strictly alternately from the two threads. How do you do this? Use two functions for the two threads. Use wait() in one and signal() in another.

Program for mimicking ps command

PID, PPID, STATE, COMMAND, No. of Files open

Since for all the root or privileged processes, you are not allowed to read the no. of files open, print NA for those. For all user processes, print the no. of files open.

Below are some Hints for the assignment.

• Use the systems calls - opendir, chdir, readdir for opening, changing to and reading the contents of a directory. If you do not change to the directory you are opening, make sure the path is correctly set by concatenating the path to the file/directory you are trying to open.
• Remember to check the return value of every system call you are using. This is most important for system calls. In fact, without this, you will find yourselves in a lot of trouble to debug or understand what is happening.
• Typically, system calls only return -1 when there is an error. They set a global error number variable called errno which is defined in errno.h. Since it is difficult to understand the number itself, Unix/Linux provides the function strerror(errno) to print a human-readable string which gives the error encountered. Use this to debug your code.
• Use fopen and fgets calls to read the contents of a directory. Then use either strchr, strtok or sscanf to parse the contents of the file and read the pid, ppid etc. values.
• Make sure your code is modular with different functions doing different logical pieces of work and unit test these functions as you build them to reduce bugs and help in debugging the code. If you write the complete program and only then try to debug, you may find yourself bogged down. For example, write the code to parse the file which contains the PID, PPID etc. first and write a main() stub which gives the file name as the command line prompt. Call this function from such a driver program and test the parsing. Once that is correct, write a function to navigate directories and get the file names. Now, you can call your previous function from this function with the current file name.

Implementation of Banker's Algorithm

The format of the first file is as follows:

-----------------------------------------------

#Number of resource types, Number of processes

M, N

# Total instances of each resource type

R1, R2, R3, ..., Rm

# Each line below gives the maximum requirement of a process

P1R1, P1R2, P1R3, ..., P1Rm

P1R1, P1R2, P1R3, ..., P1Rm

...

PnR1, PnR2, PnR3, ..., PnRm

# Each line below gives the current allocation to a process

P1R1, P1R2, P1R3, ..., P1Rm

P1R1, P1R2, P1R3, ..., P1Rm

...

PnR1, PnR2, PnR3, ..., PnRm

-----------------------------------------------

The format of the second file is as follows:

-----------------------------------------------

Pi: R1, R2, R3, ..., Rm

Pj: R1, R2, R3, ..., Rm

Pi: R1, R2, R3, ..., Rm

Pk: R1, R2, R3, ..., Rm

-----------------------------------------------

Memory Allocation Algorithms -- First, Best and Worst Fit

Contiguous Memory Allocation Algorithms

# Total Memory of the system in KB

4096

# Total number of holes

5

# Hole information in the form of start offset, hole size in KB

500,100

1024,256

2048,1024

# Process memory reqts

600

200

50

100

1000

You need to read this information from the file and allocate the memory to the processes in the order in which they appear. For the example above, first you have to allocate 600KB, then 200KB and so on. Remember that you will have to update the hole information as you allocate. This gives the initial hole information only. You need to use the updated hole information for allocating to subsequent processes.

Output: The output should consist of starting address where the process is allocated, the amount of memory lost to external fragmentation for each of first fit, best fit and worst fit algorithms.

NOTE: If something is not clear, do NOT make assumptions. Get clarification on the specification BEFORE implementation.

Paging Algorithm

The output of the program should be as follows:

PID virtualAddr operation pageno phyAddr

The operation is same as input if it is allowed; otherwise it should be "Invalid op". If the page no. is valid, print the page no; otherwise, NA. Finally, give the phyAddr for all valid cases.

The input file has the following format:

numProcesses pagesize

# PID

pageno frameBaseAddr perms

...

pageno frameBaseAddr perms

...

# PID

pageno frameBaseAddr perms

...

pageno frameBaseAddr perms

# VA

PID virtualAddr operation

PID virtualAddr operation

...

PID virtualAddr operation