The project deals with three problems related to operating systems:...
Question
The project deals with three problems related to operating systems:
1. CPU Scheduling
2. Process Synchronization
The background material required to solve these problems has been covered in chapters 3-6 of the textbook. You can choose either Java or C++ as a programming language for the project. Solutions to each of these problems will be graded separately. You are required to submit the following by the deadline. You will submit a single directory that has two subdirectories for each of the problems. The directory you submit will have the following structure:
PROJECT (main dir)
-------------- CPUSCHED (subdir 1)
-------------- README file with directions (make sure to include actual commands that can be copied and pasted to run)
-------------- SOURCE code (well documented)
-------------- Executable code
-------------- Sample input data files
-------------- Sample output file(s)
--------------- PRODUCER-CONSUMER (subdir 2)
-------------- README file with directions (make sure to include actual commands that can be copied and pasted to run)
-------------- SOURCE code (well documented)
-------------- Executable code
-------------- Sample input data files
-------------- Sample output file(s) Details of each of these problems are in the appendix.
Appendix
Problem 1: CPU Scheduling
This part of the projects simulates a CPU scheduler. Since it is a simulation, there are no real processes/threads to be scheduled. Instead, you simulate the arrival of new processes and threads. Whenever a new process/thread arrives (in simulation) into the ready queue, the CPU scheduler is invoked. Each simulated process (or thread) has the following parameters: <Process ID, Arrival time, Priority, CPU burst units>. Each CPU unit is equivalent to CPU time needed to execute the following loop:
for (int i=0, int temp =0; i < 10000; i++) if (i mod 2 ==0) temp= i/2 + 1;
else temp=2*i;}
At the time of invocation of the scheduler, the user indicates the type of scheduling to be enforced. You are required to implement the following scheduling types:
1. FIFO
2. SJF with preemption
3. RR (with specified time quantum)
4. Priority with preemption
Each run will handle scheduling of 10,000 (simulated) processes. In other words, as soon as the number of processes that have completed CPU execution reaches 10,000, you can stop running the program and print the following statistics.
Hint: Since the processes to be scheduled are not real but simulated, you need a generator to generate the process requests to the CPU scheduler. The generator generates and stores the process requests in a file. Your scheduler program reads the file and simulates real process arrives. In order to control the process arrivals and the CPU burst time for each process, your generator requires two inputs: Average number of process arrivals per unit time and average number of burst units. You need to vary these two parameters and run different cases. A sample generator function is available for you under the project directory.
Statistics for the Run Number of processes: 10,000
Total elapsed time (for the scheduler):
Throughput:
CPU utilization:
Average waiting time:
Average turnaround time:
Average response time:
All times in the statistics are measured in milliseconds (in decimal notation).
Problem 2: Producer-Consumer Problem
This follows the description in pages 265-269 of the 9th edition of the textbook. Develop the producer-consumer problem using Pthreads or Winn32 API. Test the program with several inputs (the three parameters to the main program are shown in the textbook).
Definitely, test the following parameters. Try with different sleep times. Measure the performance of the time in terms of overall turnaround time. Tabulate your results along with the parameters used. Finally, summarize your results and give an explanation for the results.
Test case, Number of producers, Number of consumers
1 1 1
2 4 1
3 16 1
4 1 2
5 4 2
6 16 2
7 1 4
8 4 4
9 16 4
10 1 16
11 4 16
12 16 16
1. CPU Scheduling
2. Process Synchronization
The background material required to solve these problems has been covered in chapters 3-6 of the textbook. You can choose either Java or C++ as a programming language for the project. Solutions to each of these problems will be graded separately. You are required to submit the following by the deadline. You will submit a single directory that has two subdirectories for each of the problems. The directory you submit will have the following structure:
PROJECT (main dir)
-------------- CPUSCHED (subdir 1)
-------------- README file with directions (make sure to include actual commands that can be copied and pasted to run)
-------------- SOURCE code (well documented)
-------------- Executable code
-------------- Sample input data files
-------------- Sample output file(s)
--------------- PRODUCER-CONSUMER (subdir 2)
-------------- README file with directions (make sure to include actual commands that can be copied and pasted to run)
-------------- SOURCE code (well documented)
-------------- Executable code
-------------- Sample input data files
-------------- Sample output file(s) Details of each of these problems are in the appendix.
Appendix
Problem 1: CPU Scheduling
This part of the projects simulates a CPU scheduler. Since it is a simulation, there are no real processes/threads to be scheduled. Instead, you simulate the arrival of new processes and threads. Whenever a new process/thread arrives (in simulation) into the ready queue, the CPU scheduler is invoked. Each simulated process (or thread) has the following parameters: <Process ID, Arrival time, Priority, CPU burst units>. Each CPU unit is equivalent to CPU time needed to execute the following loop:
for (int i=0, int temp =0; i < 10000; i++) if (i mod 2 ==0) temp= i/2 + 1;
else temp=2*i;}
At the time of invocation of the scheduler, the user indicates the type of scheduling to be enforced. You are required to implement the following scheduling types:
1. FIFO
2. SJF with preemption
3. RR (with specified time quantum)
4. Priority with preemption
Each run will handle scheduling of 10,000 (simulated) processes. In other words, as soon as the number of processes that have completed CPU execution reaches 10,000, you can stop running the program and print the following statistics.
Hint: Since the processes to be scheduled are not real but simulated, you need a generator to generate the process requests to the CPU scheduler. The generator generates and stores the process requests in a file. Your scheduler program reads the file and simulates real process arrives. In order to control the process arrivals and the CPU burst time for each process, your generator requires two inputs: Average number of process arrivals per unit time and average number of burst units. You need to vary these two parameters and run different cases. A sample generator function is available for you under the project directory.
Statistics for the Run Number of processes: 10,000
Total elapsed time (for the scheduler):
Throughput:
CPU utilization:
Average waiting time:
Average turnaround time:
Average response time:
All times in the statistics are measured in milliseconds (in decimal notation).
Problem 2: Producer-Consumer Problem
This follows the description in pages 265-269 of the 9th edition of the textbook. Develop the producer-consumer problem using Pthreads or Winn32 API. Test the program with several inputs (the three parameters to the main program are shown in the textbook).
Definitely, test the following parameters. Try with different sleep times. Measure the performance of the time in terms of overall turnaround time. Tabulate your results along with the parameters used. Finally, summarize your results and give an explanation for the results.
Test case, Number of producers, Number of consumers
1 1 1
2 4 1
3 16 1
4 1 2
5 4 2
6 16 2
7 1 4
8 4 4
9 16 4
10 1 16
11 4 16
12 16 16
Solution Preview
These solutions may offer step-by-step problem-solving explanations or good writing examples that include modern styles of formatting and construction of bibliographies out of text citations and references.
Students may use these solutions for personal skill-building and practice.
Unethical use is strictly forbidden.
#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <ctime>
#include <vector>
#include <stack>
#include <string>
#include <atomic>
using namespace std;
int num_producers;
int num_consumers;
int sleep_time; // in miliseconds
const int consumer_max_wait_time = 200; // in miliseconds - max time that a consumer can wait for a product to be produced.
const int max_production = 16; // When producers has produced this quantity they will stop to produce
const int max_products = 16; // Maximum number of products that can be stored
atomic<int> num_producers_working(
0); // When there's no producer working the consumers will stop, and the program will stop.
stack<int> products; // The products stack, here we will store our products
mutex xmutex; // Our mutex, without this mutex our program will cry
condition_variable is_not_full; // to indicate that our stack is not full between the thread operations
condition_variable is_not_empty; // to indicate that our stack is not empty between the thread operations
/**
* Produce function
* @param producer_id
*/
void produce(int producer_id) {
unique_lock <mutex> lock(xmutex);
int product;
is_not_full.wait(lock, [] { return products.size() != max_products; });
product = products.size();
products.push(product);
is_not_empty.notify_all();
}
/**
* Consume
* @param consumer_id
*/
void consume(int consumer_id) {
unique_lock <mutex> lock(xmutex);
int product;
if (is_not_empty.wait_for(lock, chrono::milliseconds(consumer_max_wait_time),
[] { return products.size() > 0; })) {
product = products.top();
products.pop();
is_not_full.notify_all();
}
}
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <ctime>
#include <vector>
#include <stack>
#include <string>
#include <atomic>
using namespace std;
int num_producers;
int num_consumers;
int sleep_time; // in miliseconds
const int consumer_max_wait_time = 200; // in miliseconds - max time that a consumer can wait for a product to be produced.
const int max_production = 16; // When producers has produced this quantity they will stop to produce
const int max_products = 16; // Maximum number of products that can be stored
atomic<int> num_producers_working(
0); // When there's no producer working the consumers will stop, and the program will stop.
stack<int> products; // The products stack, here we will store our products
mutex xmutex; // Our mutex, without this mutex our program will cry
condition_variable is_not_full; // to indicate that our stack is not full between the thread operations
condition_variable is_not_empty; // to indicate that our stack is not empty between the thread operations
/**
* Produce function
* @param producer_id
*/
void produce(int producer_id) {
unique_lock <mutex> lock(xmutex);
int product;
is_not_full.wait(lock, [] { return products.size() != max_products; });
product = products.size();
products.push(product);
is_not_empty.notify_all();
}
/**
* Consume
* @param consumer_id
*/
void consume(int consumer_id) {
unique_lock <mutex> lock(xmutex);
int product;
if (is_not_empty.wait_for(lock, chrono::milliseconds(consumer_max_wait_time),
[] { return products.size() > 0; })) {
product = products.top();
products.pop();
is_not_full.notify_all();
}
}
This is only a preview of the solution.
Please use the purchase button to see the entire solution.
Please use the purchase button to see the entire solution.
By purchasing this solution you'll be able to access the following files:
Solution.zip
Purchase Solution
$75.00
$37.5
View Available
Computer Science Tutors 529 tutors matched
Ionut
(ionut)
Hi! MSc Applied Informatics & Computer Science Engineer. Practical experience in many CS & IT branches.Research work & homework
5/5 (5,654+ sessions)
2 hours avg response
Leo
(Leo)
Hi!
I have been a professor in New York and taught in a math department and in an applied math department.
4.9/5 (5,652+ sessions)
2 hours avg response
Pranay
(math1983)
Ph.D. in mathematics and working as an Assistant Professor in University. I can provide help in mathematics, statistics and allied areas.
4.6/5 (5,512+ sessions)
1 hour avg response