OperatingSystemsProject3/sched_sim.hpp at master · varun-projects/OperatingSystemsProject3 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/*
Author: Varun Garg     : varun_garg@student.uml.edu
Date              : 04/10/2018
Course            : Operating Systems (Spring 2018)
File Name         : sched_sim.h  , part of Module sched_sim
Code Version      : 3.02
*/

#ifndef SCHED_SIM_HPP
#define SCHED_SIM_HPP

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>    // to get the vector class definition
#include <algorithm>
#include <iomanip>

//#define QUEUE_SIZE 100

using namespace std;


typedef struct   {
    int *Q_space;
    int head;
    int tail;
} Q_struct;

typedef struct   {
    float value;
    string type;
} Comparison;


class Process {
public:
	// class variables
	int pid;
	int CPUburst;
	int priority;
	int arrivalTime;
	int startTime;
	int endTime;
	int waitingTime;
	int turnAroundtime;

	// class constructor
	Process(int id, int CPU, int prior, int arrv) {
		pid = id;
		CPUburst = CPU;
		priority = prior;
		arrivalTime = arrv;
		startTime = 0;
		endTime = 0;
		waitingTime = 0;
		turnAroundtime = 0;
	}
};

// structure for counting turn arround and waiting timmings
typedef struct {
    float TT_time;
    float WT_time;
    int   Context_c;
} P_metrics;

// structure for grouping the performance timmings for each algorithm
typedef struct {
    P_metrics SJF_alg;
    P_metrics STCF_alg;
    P_metrics RR_alg;
    P_metrics FCFS_alg;
    P_metrics Prior_alg;
}Summary;


//extern "C" void test(void);
extern Q_struct Queue;
extern P_metrics timmings;
extern Summary Sum_Timings;


// ----- Prototypes -----
void push(Q_struct *queue, int data);
int pop(Q_struct *queue);
int MinBurst(Q_struct *Q, vector<Process> &Processes);
int Arrived_Flag(int time, int Total_Processes_Num, vector<Process> &Processes);
void Queue_Init(Q_struct *Q, int Total_Processes_Num, vector<Process> &Processes);
void SortQ(Q_struct *queue, vector<Process> &Processes);
void Q_print(Q_struct *queue, vector<Process> &Processes, char *outputFile);
int sum_processes_burst( int numLine ,  vector<Process> &Processes);
int number_process_with_bursts(int number_lines, vector<Process> &Processes);
void TimeLogger(int total_Processes, int curr_PID, vector<Process> &Processes);

bool sortByArrivalTime(const Process &lhs, const Process &rhs);
bool sortByCPUburst(const Process &lhs, const Process &rhs);
bool sortByPriority(const Process &lhs, const Process &rhs);
bool sortByValue(const Comparison &lhs, const Comparison &rhs);

void runFCFS(vector<Process> processes, int timeStep, int numProc, char *outputFile, float stats[]);
void STCF(Q_struct *queue, vector<Process> &Processes, int total_Processes, char *outputFile, int int_bursts[], int snapStep, Summary *Sum_Timings);
void SJF(Q_struct * queue, vector<Process> &Processes, int total_Processes, char *outputFile, int int_bursts[], int snapStep, Summary *Sum_Timings);
void RoundRobin(Q_struct * queue, vector<Process> &Processes, int total_processes, char *outputFile, int int_bursts[], int snapStep, Summary *Sum_Timings);
void runPriority(vector<Process> processes, int timeStep, int numProc, char *outputFile, float stats[]);

void Statistic_Logs(vector<Process> &Processes, vector<int> &Context, int total_Processes, char *outputFile, int Burst_Array[], int context_Count, P_metrics *timmings);
void Performace_report(Summary * sum_time, char *outputFile, float stats[]);

#endif