Scheduler processes with signals SIGTSTP and SIGCONT on linux - c++

Question

Write a scheduler Round-Robin with the following characteristics:
The scheduler must accept quantum qt time and the processes to be performed as parameters on the command line with the following format:
./scheduler qt path_process1 startTime1 executionTime1 path_process2 startTime2 executionTime2 ...
Each of the processes that create and will rotate the scheduler should be a separate program that prints a message every 0.5s in the following format:
Program i: Messages printed: 1.
Program i: Messages printed: 2.
Program i: Messages ...
...
When cyclic initiation and termination of each process itself will print messages:
Process pid is executing.
//Execution of process pid
Process pid is suspended.
Stopping and execution processes will be with signals SIGTSTP and SIGCONT .
Consider and comment system behavior for small and large values ​​of the quantum time (e.g. qt = 0.5s, 1s, 2s, 4s) for five processes with the following starting and running times.
startTimes = [0,2,4,6,8]
execTimes = [3,6,4,5,2]
Given Hint:
To carry out a process child as a separate program, use the command execl (...).
For measuring the time elapsed from the start of operation of the scheduler, use the command gettimeofday (...).
Code
Scheduler.cpp
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <cstdio>
#include <sys/types.h>
#include <sys/time.h>
#include <signal.h>
#include <sys/signal.h>
using namespace std;
float qt;
int k,j,i;
int total_time=0;
int pass_time=0;
void stp_handler(int signal){
}
void con_handler(int signal){
}
int main(int argc, char *argv[])
{
int p=2;
int s=3;
int e=4;
int count=0;
signal(SIGTSTP,stp_handler);
signal(SIGCONT,con_handler);
int start_time[(argc-2)/3];
float execution_time[(argc-2)/3];
char *path_process[(argc-2)/3];
float remaining_time[(argc-2)/3];
timeval time;
int start,end;
if (argc < 2)
{
cout<<"You didn't enter any arguments" << endl;
exit(0);
}
else{
qt = atoi(argv[1]);
while (count < ((argc-2)/3) ){
path_process[count] = argv[p];
start_time[count] = atoi(argv[s]);
execution_time[count] = atoi(argv[e]);
remaining_time[count] = execution_time[count];
total_time = total_time + execution_time[count];
cout << path_process[count] << " " << start_time[count] << " " << execution_time[count] << endl;
p+=3;
s+=3;
e+=3;
count++;
}
}
i=0;
pid_t pid[count];
while(i<count){
pid_t par,child;
child=fork();
if (child==0){
par = getppid();
cout << "Child pid: " << i << " " << getpid() << endl << "Parent pid: " << par << endl;
char num[100]={0x0};
sprintf(num,"%d",i+1);
char pi[100]={0x0};
sprintf(pi,"%d",getpid());
execl(path_process[i],path_process[i],pi,num,(char*)0);
exit(0);
}
else{
sleep(1);
pid[i] = child;
i++;
}
}
i=0;
cout << endl << "Processes time: " << total_time << endl << endl;
gettimeofday(&time,NULL);
start = time.tv_sec;
while(pass_time<total_time){
for(j=0;j<count;j++){
if (pass_time<start_time[j]){
continue;
}
else if (remaining_time[j]<=0){
continue;
}
else if (remaining_time[j]>= qt){
kill(pid[j],SIGCONT);
usleep(qt*1000000);
kill(pid[j],SIGTSTP);
pass_time = pass_time + qt;
remaining_time[j]=remaining_time[j]-qt;
i++;
}
else{
kill(pid[j],SIGCONT);
usleep(remaining_time[j]*1000000);
kill(pid[j],SIGTSTP);
pass_time = pass_time + remaining_time[j];
remaining_time[j]=0;
i++;
}
}
}
sleep(1);
gettimeofday(&time,NULL);
end = time.tv_sec;
cout << "Scheduler time: " << end - start << endl;
for(i=0;i<count;i++)
kill(pid[i],SIGKILL);
return 0;
}
Signals.cpp
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <iostream>
#include <time.h>
#include <sys/wait.h>
#include <sys/signal.h>
using namespace std;
int j=1;
char* pid;
void sig_handler(int signal){
if (signal == SIGCONT){
cout << endl << "Process " << pid << " is executing." << endl << endl;
j=0;
}
else if (signal == SIGTSTP){
cout << endl << "Process " << pid << " is suspended." << endl << endl;
j=1;
}
}
main(int argc, char *argv[])
{
signal(SIGTSTP,sig_handler);
signal(SIGCONT,sig_handler);
pid = argv[1];
int i=1;
while(1){
while(j==0){
cout << "Program: " << argv[2] << " messages printed: " << i << endl;
usleep(500000);
i++;
}
}
}
Output from Scheduler
(This is correct I guess)
process1 0 3
process2 2 6
process2 4 4
process3 6 5
process4 8 2
Child pid: 0 3406
Parent pid: 3405
Child pid: 1 3407
Parent pid: 3405
Child pid: 2 3408
Parent pid: 3405
Child pid: 3 3409
Parent pid: 3405
Child pid: 4 3410
Parent pid: 3405
Processes time: 20
Output from Signals
I get nothing but as I mentioned above I expect it to be somehow like this.
Program i: Messages printed: 1.
Program i: Messages printed: 2.
Program i: Messages ...
...
When cyclic initiation and termination of each process itself will print messages:
Process pid is executing.
//Execution of process pid
Process pid is suspended.
P.S: In order to get the scheduler to work I compile it and run it with
>./scheduler 0.5 process1 0 3 process2 2 6 process2 4 4 process3 6 5 process4 8 2
Why don't the signals cause any output?