[SOLVED] Cs 3305a assignment 1 to 5 solutions

Purpose
The goals of this assignment are the following:
• Learn about process creation and control in Linux environment
• Get experience with the fork(), wait() and execl() system functions
• Gain more experience with the C programming language from an OS perspective
Assignment-1: Parent and Child Processes (100 points)
Write a program in C that will perform the following tasks (must follow the task sequence/order below):
1. Your main program (i.e., parent process) will fork (create) a child process (e.g., child_1).
2. The parent process will wait for child_1 to complete before forking (creating) child_2.
3. child_1 will fork its own child_1.1 and wait for its completion.
4. child_1.1 will call an external program “external_program.out” (the source code of this file external_program.c
will be provided to you) and must pass its PID concatenated with the string “for child_1.1” to the external
program “external_program.out” (hint: execl()). As a result of this system call, child_1.1 will be replaced by
external_program.out. The path to the external program “external_program.out” should be passed into the main
program as a command line argument (hint: argc, argv).
5. After completion of child_1.1 process, child_1 should be completed, as no more jobs remain for child_1.
6. The parent will now fork child_2, and wait for the completion of child_2.
7. child_2 will make a call to the same external program “external_program.out”. child_2 must pass its PID
concatenated with the string “for child_2” to the external program “external_program.out”. As a result of this
system call, child_2 will be replaced by external_program.out (hint: execl()). The path to the external program
“external_program.out” should be passed into the main program as a command line argument (hint: argc,
argv).
8. The parent process will now terminate.
The expected output from your program should look like the following:
parent (PID 1655): process started
parent (PID 1655): forking child_1
parent (PID 1655): fork successful for child_1 (PID 1656)
parent (PID 1655): waiting for child_1 (PID 1656) to complete
child_1 (PID 1656): forking child_1.1
child_1 (PID 1656): fork success for child_1.1 (PID 1657)
child_1 (PID 1656): waiting for child_1.1 (PID 1657) to complete
child_1.1 (PID 1657): calling an external program [external_program.out]
From the external program: The PID was 1657 for child_1.1
child_1 (PID 1656): completed
2
parent (PID 1655): forking child_2
parent (PID 1655): fork successful for child_2 (PID 1658)
parent (PID 1655): waiting for child_2 (PID 1658) to complete
child_2 (PID 1658): calling an external program [external_program.out]
From the external program: The PID was 1658 for child_2
parent (PID 1655): completed
Hints: fork(), wait(), getpid(), getppid(), execl(), strcat()
Mark Distribution
This section describes a tentative allocation of marks assigned for the desired features. (100 points)
a) A parent process will create two child processes: 20 points
b) parent will wait for child_1 to complete before creating child_2: 15 points
c) child_1 will create its own child child_1.1: 15 points
d) child_1.1 will make a system call to an external program: 15 points
e) child_2 will make a system call to an external program: 15 points
f) parent process must not terminate until all child processes are completed: 20 points
Computing Platform for Assignments
You are responsible for ensuring that your program compiles and runs without error on the computing platform
mentioned below. Marks will be deducted if your program fails to compile, or your program runs into errors on
the specified computing platform (see below).
• Students have virtual access to the MC 244 lab, which contains 30 Fedora 28 systems. Linux machines available
to you are: linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca.
• It is your responsibility to ensure that your code compiles and runs on the above systems. You can SSH into
MC 244 machines.
• If you are off campus, you have to SSH to compute.gaul.csd.uwo.ca first (this server is also known
as sylvia.gaul.csd.uwo.ca, in honour of Dr. Sylvia Osborn), and then to one of the MC 244 systems
(linux01.gaul.csd.uwo.ca to linux30.gaul.csd.uwo.ca).
• https://wiki.sci.uwo.ca/sts/computer-science/gaul
Provided Files
• The source code for the external program “external_program.out” is provided to you as “external_program.c”.
DO NOT make any changes to “external_program.c”
• When running the program, you must provide the path to “external_program.out” as an argument (see
Assignment 1 tutorial powerpoint)
• If you have any questions, please contact the designated TAs or the Instructor
3
Assignment Submission
You need to submit only one C file. The name of your submitted C file must be “assignment1.c”. Marks will be
deducted if your submitted C file name is different. You must submit your assignment through OWL. Be sure to
test your code on one of MC 244 systems (see “Computing Platform for Assignments” section above). Marks will
be deducted if your program fails to compile or your program runs into errors on the computing platform mentioned
above.
Assignment 1 FAQ will be made available on OWL. Also, consult TAs, and the Instructor for any questions you
may have regarding this assignment.

Purpose
The goals of this assignment are the following:
• Get experience with the fork(), wait() and pipe() system functions.
• Learn how to use pipe for bi-directional communication between parent and child process.
• Gain more experience with the C programming language from an OS perspective.
Inter-Processes Communications (100 points)
Write a C program that will accept three strings from the user as command-line arguments (for
example, X, Y, and Z). Your parent process will create a child. While the parent waits for the
message to be available in the pipe, the child will access X (“CS”) and write it in the pipe. Then
the parent will read the message from the pipe and access Y (“3305”). Now parent will concatenate
the read message and Y (“CS 3305”), and write it in the pipe. This time child will read the message
from the pipe and access Z (“is Fun!”). Then the child will concatenate the read message and Z
(“CS 3305 is Fun!”), and write it in the pipe. Now the child will be completed, and the parent will
read the message from the pipe. The expected output from your program should look like the
following for the arguments “CS”, “3305”, and “is fun!”:
parent (PID 1458): created child (PID 1459)
child (PID 1459): received X = “CS”
child (PID 1459): writing “CS” into pipe
parent (PID 1458): read from pipe “CS”
parent (PID 1458): received Y = “3305”
parent (PID 1458): “CS” + Y = “CS 3305”
parent (PID 1458): writing into pipe “CS 3305”
child (PID 1459): read from pipe “CS 3305”
child (PID 1459): received Z = “is Fun!”
child (PID 1459): “CS 3305” + Z = “CS 3305 is Fun!”
child (PID 1459): writing into pipe “CS 3305 is Fun!”
child (PID 1459): all tasks completed
parent (PID 1458): read from pipe “CS 3305 is Fun!”
parent (PID 1458): all tasks completed
Hints: fork(), wait(), pipe(), write(), read()
2
Mark Distribution
This section describes a tentative allocation of marks assigned for the desired features.
• Inter-Processes Communications (100 points)
a) Child reads X & Z from Command Line: 10 points
b) Parent reads Y from Command Line: 12 points
c) A pipe is created for communication between parent and child: 20 points
d) Child writes X into the pipe: 12 points
e) Parent reads X from the pipe: 12 points
f) Parent concatenates message and Y before writing into the pipe: 12 points
g) Child concatenates message and Z before writing into the pipe: 12 points
h) Output the correct string: 10 point
NOTE: Marks will be deducted if error handling is not implemented in your code.
Computing Platform for Assignments
You are responsible for ensuring that your program compiles and runs without error on the
computing platform mentioned below. Marks will be deducted if your program fails to compile,
or your program runs into errors on the specified computing platform (see below).
• Students have virtual access to the MC 244 lab, which contains 30 Fedora 28 systems. Linux
machines available to you are: linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca.
• It is your responsibility to ensure that your code compiles and runs on the above systems. You
can SSH into MC 244 machines (please see the Assignment 1 file transfer tutorial).
• If you are off campus, you have to SSH to compute.gaul.csd.uwo.ca first (this server is also
known as sylvia.gaul.csd.uwo.ca, in honour of Dr. Sylvia Osborn), and then to one of the MC
244 systems (linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca) (please see the
Assignment 1 file transfer tutorial).
• https://wiki.sci.uwo.ca/sts/computer-science/gaul
Assignment Submission
You need to submit only one C file. The name of your submitted C file must be “assignment2.c”.
Marks will be deducted if your submitted C file name is different. You must submit your
assignment through OWL. Be sure to test your code on one of MC 244 systems (see “Computing
Platform for Assignments” section above). Marks will be deducted if your program fails to
compile, or your program runs into errors on the computing platform mentioned above.
Assignment 2 FAQ will be made available on OWL, as needed. Also, consult TAs, and the
Instructor for any questions you may have regarding this assignment.

Purpose
The goals of this assignment are the following:
• Get experience with the pipe and pthread system functions.
• Learn how to create multiple threads for different tasks.
• Learn how to share data between threads using the pipe.
• Gain more experience with the C programming language from an OS perspective.
Inter-Thread Communications (100 points)
Write a C program that will accept two integers from the user as command-line arguments (for
example, X and Y where X ,Y are positive integers & X>Y). The parent process will read X and
Y from the command line. The parent process will create three threads (i.e., pthread_t 1, pthread_t
2, and pthread_t 3). The parent process will write X and Y to the shared memory using pipe. The
first thread (i.e., 1) will read X and Y from the pipe and perform the subtract, S = X-Y, and then
the result S will be written to the pipe. Next, the second thread (i.e., 2) will read S from the pipe
and determine whether S is a prime number, and then S will be written again to the pipe by the
second thread. Finally, the third thread (i.e., 3) will read S from the pipe and reverse the number
S. The expected output from your program should look like the following (for this example below,
X and Y represent 33 and 4, respectively):
1. parent (PID 1729) receives X = 33 and Y = 4 from the user
2. parent(PID 1729) writes X = 33 and Y = 4 to the pipe
3. thread(TID 1) reads X = 33 and Y = 4 from the pipe
4. thread(TID 1) writes X-Y = 29 to the pipe
5. thread(TID 2) reads X-Y = 29 from the pipe
6. thread(TID 2) identified that 29 is a prime number
7. thread(TID 2) writes 29 to the pipe
8. thread(TID 3) reads X-Y = 29 from the pipe
9. thread(TID 3) reversed number is 92
In the above example, if S is NOT a prime number, then the phrase “identified that xx is a prime
number” in line number 6 above must be replaced with the phrase “identified that xx is NOT a
prime number”. You must control the execution of the threads to follow the sequence according to
the expected output above. You must not use more than one pipe for this assignment. In case of
passing multiple parameters through a single pipe, concatenate the parameters using any delimiter
so that you can parse it later accordingly. This assignment will be tested given only positive integers
where X > Y. Your implementation must have the following functions:
1. void *subtract(void *thread_id): This function is executed by thread 1. This function reads
X and Y from the pipe, performs subtraction i.e., S = X-Y, and writes S to the pipe.
2
2. void *prime_check(void *thread_id): This function is executed by thread 2. This function
reads S from the pipe and determines if S is a prime number or not.
3. void *reverse_num(void *thread_id): This function is executed by thread 3. This function
reverses the number S.
Mark Distribution
This section describes a tentative allocation of marks assigned for the desired features.
• Inter-Thread Communications (100 points)
a) Parent reads X and Y from user: 10 points
b) The first thread reads X and Y from pipe: 15 points
c) The first thread writes results to the pipe: 10 points
d) The second thread reads the result from the pipe: 10
e) The second thread identifies if it is a prime number: 15
f) The third thread reads the result from the pipe: 10
g) The third thread reverses the number: 15
h) Control the thread execution flow: 15 points
You must pass the input to the program using the command line argument. The hardcoded input
will not be accepted and considered for deducting marks accordingly. Also, marks will be deducted
if error handling is not implemented in your code.
Computing Platform for Assignments
You are responsible for ensuring that your program compiles and runs without error on the
computing platform mentioned below. Marks will be deducted if your program fails to compile
or runs into errors on the specified computing platform (see below).
• Students have virtual access to the MC 244 lab, which contains 30 Fedora 28 systems. Linux
machines available to you are linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca.
• It is your responsibility to ensure that your code compiles and runs on the above systems. You
can SSH into MC 244 machines (please see the Assignment 1 file transfer tutorial).
• If you are off-campus, you have to SSH to compute.gaul.csd.uwo.ca first (this server is also
known as sylvia.gaul.csd.uwo.ca, in honor of Dr. Sylvia Osborn), and then to one of the MC
244 systems (linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca) [please see the
Assignment 1 file transfer tutorial].
• https://wiki.sci.uwo.ca/sts/computer-science/gaul
Assignment Submission
You need to submit only one C file. The name of your submitted C file must be “assignment3.c”.
Marks will be deducted if your submitted C file name is different. You must submit your
assignment through OWL. Be sure to test your code on one of MC 244 systems (see “Computing
Platform for Assignments” section above). Marks will be deducted if your program fails to
compile or runs into errors on the computing platform mentioned above.
Assignment 3 FAQ will be made available on OWL as needed. Also, consult TAs and the Instructor
for any questions you may have regarding this assignment.

Purpose:
The main goal of this assignment is to gain hands-on experience with the CPU scheduling
algorithms using C language in Linux environment.
Performance Evaluation of CPU Scheduling Algorithms
You will develop CPU Scheduling Algorithms using the C programming language in Linux. A
sample input file is provided with the assignment, which must be used to develop the Round Robin
(RR) CPU Scheduling Algorithm.
Format of the Input File:
You must use the same input file name (i.e., rr_input.txt) in your code. The input file contains
several test cases for this assignment. Every line of the input file represents one individual test case.
For example, if there are four lines inside the input file, it means your program must execute four
different test cases. Every input line consists of several processes and their corresponding
information, such as process name, arrival time (art_1), burst time (brt_1), and quantum time
(q_time), and the following format is used:
Input format: process_1 art_1 brt_1 process_2 art_2 brt_2 process_n art_n brt_n q_time
Input example: p1 0 23 p2 1 3 p3 2 3 4
In the example input given above, there are three processes such as p1, p2, and p3. The arrival and
burst time of process p1 is 0 and 23, process p2 is 1 and 3, and process p3 is 2 and 3. The quantum
time is 4. The individual entries in the input line are separated by space.
What you need to do:
You must supply given rr_input.txt file to your program. At first, parse the input file line-wise,
meaning every line in the input file is a test case. For every test case in the input file, apply Round
Robin Scheduling and output the process schedule details. The output of your program for the
sample test cases in the given input file must follow the format of the sample output given below.
You must consider two decimal points for printing the fractional number; marks will be deducted
otherwise.
Sample Content in rr_input.txt :
p1 0 24 p2 2 3 p3 6 3 4
p1 1 10 p2 2 5 p3 2 8 p4 6 9 2
Sample Output:
Test case #1: p1 0 24 p2 2 3 p3 6 3 4
Number of Processes: 3, Quantum: 4
Process Scheduling Started:
2
CPU Time 0: [p1 Arrived] p1 [1/24]
CPU Time 1: p1 [2/24]
CPU Time 2: [p2 Arrived] p1 [3/24]
CPU Time 3: p1 [4/24]
CPU Time 4: p2 [1/3]
CPU Time 5: p2 [2/3]
CPU Time 6: [p3 Arrived] p2 [3/3]
Process p2 completed with Turn Around Time: 5, Waiting Time: 2
CPU Time 7: p1 [5/24]
CPU Time 8: p1 [6/24]
CPU Time 9: p1 [7/24]
CPU Time 10: p1 [8/24]
CPU Time 11: p3 [1/3]
CPU Time 12: p3 [2/3]
CPU Time 13: p3 [3/3]
Process p3 completed with Turn Around Time: 8, Waiting Time: 5
CPU Time 14: p1 [9/24]
CPU Time 15: p1 [10/24]
CPU Time 16: p1 [11/24]
CPU Time 17: p1 [12/24]
CPU Time 18: p1 [13/24]
CPU Time 19: p1 [14/24]
CPU Time 20: p1 [15/24]
CPU Time 21: p1 [16/24]
CPU Time 22: p1 [17/24]
CPU Time 23: p1 [18/24]
CPU Time 24: p1 [19/24]
CPU Time 25: p1 [20/24]
CPU Time 26: p1 [21/24]
CPU Time 27: p1 [22/24]
CPU Time 28: p1 [23/24]
CPU Time 29: p1 [24/24]
Process p1 completed with Turn Around Time: 30, Waiting Time: 6
Process scheduling completed with Avg Turn Around Time: 14.33, Avg Waiting Time:4.33
Test case #2: p1 1 10 p2 2 5 p3 2 8 p4 6 9 2
Number of Processes: 4, Quantum: 2
Process Scheduling Started:
CPU Time 0: None
CPU Time 1: [p1 Arrived] p1 [1/10]
CPU Time 2: [p2 Arrived] [p3 Arrived] p1 [2/10]
CPU Time 3: p2 [1/5]
CPU Time 4: p2 [2/5]
CPU Time 5: p3 [1/8]
CPU Time 6: [p4 Arrived] p3 [2/8]
CPU Time 7: p1 [3/10]
CPU Time 8: p1 [4/10]
CPU Time 9: p2 [3/5]
3
CPU Time 10: p2 [4/5]
CPU Time 11: p4 [1/9]
CPU Time 12: p4 [2/9]
CPU Time 13: p3 [3/8]
CPU Time 14: p3 [4/8]
CPU Time 15: p1 [5/10]
CPU Time 16: p1 [6/10]
CPU Time 17: p2 [5/5]
Process p2 completed with Turn Around Time: 16, Waiting Time: 11
CPU Time 18: p4 [3/9]
CPU Time 19: p4 [4/9]
CPU Time 20: p3 [5/8]
CPU Time 21: p3 [6/8]
CPU Time 22: p1 [7/10]
CPU Time 23: p1 [8/10]
CPU Time 24: p4 [5/9]
CPU Time 25: p4 [6/9]
CPU Time 26: p3 [7/8]
CPU Time 27: p3 [8/8]
Process p3 completed with Turn Around Time: 26, Waiting Time: 18
CPU Time 28: p1 [9/10]
CPU Time 29: p1 [10/10]
Process p1 completed with Turn Around Time: 29, Waiting Time: 19
CPU Time 30: p4 [7/9]
CPU Time 31: p4 [8/9]
CPU Time 32: p4 [9/9]
Process p4 completed with Turn Around Time: 27, Waiting Time: 18
Process scheduling completed with Avg Turn Around Time: 24.50, Avg Waiting Time:16.50
Mark Distribution
This section describes a tentative allocation of points assigned for the desired features.
A. Supplying rr_input.txt to the program: 5 points
B. Parsing the input file correctly: 10 points
C. Printing the number of process and quantum for every test case: 5 points
D. Detecting process arrival correctly: 15 points
E. Detecting process completion correctly: 15 points
F. Calculating Turn Around Time and Waiting Time for every process: 15 points
G. Maintaining Round Robin sequence and quantum: 25 points
H. Calculating Avg Turn Around Time and Avg Waiting Time for every test case: 10 points
Computing Platform for Assignments
You are responsible for ensuring that your program compiles and runs without error on the
computing platform mentioned below. Marks will be deducted if your program fails to compile
or runs into errors on the specified computing platform (see below).
4
• Students have virtual access to the MC 244 lab, which contains 30 Fedora 28 systems. Linux
machines available to you are linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca.
• It is your responsibility to ensure that your code compiles and runs on the above systems. You
can SSH into MC 244 machines (please see the Assignment 1 file transfer tutorial).
• If you are off-campus, you have to SSH to compute.gaul.csd.uwo.ca first (this server is also
known as sylvia.gaul.csd.uwo.ca, in honor of Dr. Sylvia Osborn), and then to one of the MC
244 systems (linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca) (please see the
Assignment 1 file transfer tutorial).
• https://wiki.sci.uwo.ca/sts/computer-science/gaul
Assignment Submission
You need to submit only one C file. The name of your submitted C file must be “assignment4.c”.
Marks will be deducted if your submitted C file name is different. You must submit your
assignment through OWL. Be sure to test your code on one of MC 244 systems (see “Computing
Platform for Assignments” section above). Marks will be deducted if your program fails to
compile or runs into errors on the computing platform mentioned above.
Assignment 4 FAQ will be made available on OWL as needed. Also, consult TAs and the Instructor
for any questions you may have regarding this assignment.

Purpose
The goals of this assignment are the following:
• Get hands-on experience in developing mutual exclusion/semaphore/critical section
techniques and algorithms.
• Gain experience with the C programming language from an OS’s process synchronization
perspective.
Assignment Description
Using C programming language, you will develop a mutual exclusion algorithm for a process
synchronization problem. You must ensure that your mutual exclusion algorithm guarantees only
one process access to the critical section portion of your code at a given time. You are allowed to
use any mutual exclusion/semaphore related C function calls.
Description of the problem:
Assume that there are a set of n bank accounts (n ≥ 1) shared by a set of x clients (x ≥ 1). Clients
can perform two different types of transactions with each bank account: deposit and withdraw
funds. If a particular transaction results in a negative account balance, the transaction should be
ignored (i.e., an account balance should never be less than 0).
Example and structure of the input file:
In the following example, there are two bank accounts (account1 and account2) shared by a total
of ten clients (c1 to c10). The clients are allowed to deposit money into both accounts and withdraw
money from both the accounts. The initial balances of the accounts are specified in the input file.
An input file is provided below for illustrative purposes.
account1 balance 7000
account2 balance 4500
c1 deposit account1 100 withdraw account2 500
c2 withdraw account1 2500
…
…
c9 withdraw account1 1000 withdraw account2 500
c10 deposit account1 50 deposit account2 200
2
Illustration:
(i) account1 balance 7000
The above line specifies the initial balance of account #1 as $7000
(ii) c1 deposit account1 100 withdraw account2 500
The above line specifies the operations performed by client #1. client #1 deposits $100 into account
#1, then withdraws $500 from Account #2.
The input file will be provided as “assignment_5_input.txt”, and it must be hard-coded inside your
program as “assignment_5_input.txt”. A different input file will be used to evaluate your program
for marking purposes where the structure of this input file name will remain the same, and only the
data will be different.
For every client, you must use a separate thread. The transactions for a unique client should be
handled by a distinct thread. For appropriate synchronization among the threads (i.e., critical
sections are protected against random access by the threads) you must use mutual exclusion-related
system functions (such as pthread_mutex_lock(), pthread_mutex_unlock() etc. which will be
discussed in lecture #14). You must output the balances of each bank account after all the
transactions have been performed. For each bank account, your output should display the account
followed by the account balance. For example:
account1 balance 500
account2 balance 300
Your C program should output results to the screen.
Sample Input and Output File
You must not use any other format, such as user input from the terminal, command-line argument,
etc., for providing input to the program. Also, you must not modify the format of the provided
input file. The output of your program must follow the format of the sample output given above.
For testing purposes, we have designed the sample input in a way where the final account balances
will always remain the same after completing the transactions. However, when testing your
program with another input file, note that due to the non-deterministic nature of threads, the final
account balances may vary when running your program multiple times.
Mark Distribution
This section describes a tentative allocation of points assigned for the desired features.
A. Supplying assignment_5_input.txt to the program: 10 points
B. Parsing the input file correctly: 10 points
C. Printing the correct number of accounts and clients: 10 points
D. Using semaphore or mutual exclusion technique: 20 points
E. Using a separate thread for each client: 25 points
F. Correct balance of the accounts after all transactions: 25 points
3
Computing Platform for Assignments
You are responsible for ensuring that your program compiles and runs without error on the
computing platform mentioned below. Marks will be deducted if your program fails to compile
or runs into errors on the specified computing platform (see below).
• Students have virtual access to the MC 244 lab, which contains 30 Fedora 28 systems. Linux
machines available to you are linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca.
• It is your responsibility to ensure that your code compiles and runs on the above systems. You
can SSH into MC 244 machines (please see the Assignment 1 file transfer tutorial).
• If you are off-campus, you have to SSH to compute.gaul.csd.uwo.ca first (this server is also
known as sylvia.gaul.csd.uwo.ca, in honor of Dr. Sylvia Osborn), and then to one of the MC
244 systems (linux01.gaul.csd.uwo.ca through linux30.gaul.csd.uwo.ca) (please see the
Assignment 1 file transfer tutorial).
• https://wiki.sci.uwo.ca/sts/computer-science/gaul
Assignment Submission
You need to submit only one C file. The name of your submitted C file must be “assignment5.c”.
Marks will be deducted if your submitted C file name is different. You must submit your
assignment through OWL. Be sure to test your code on one of MC 244 systems (see “Computing
Platform for Assignments” section above). Marks will be deducted if your program fails to
compile or runs into errors on the computing platform mentioned above.
Assignment 5 FAQ will be made available on OWL as needed. Also, consult TAs and the Instructor
for any questions you may have regarding this assignment.