int main(int argc, char *argv[]) {
// Declare major variables
// node_t is a link-list of type process
node_t* dispatch_queue;
node_t* realtime_queue;
node_t* process_queue_1;
node_t* process_queue_2;
node_t* process_queue_3;
dispatch_queue = (node_t *)malloc(sizeof(node_t));
realtime_queue = (node_t *)malloc(sizeof(node_t));
process_queue_1 = (node_t *)malloc(sizeof(node_t));
process_queue_2 = (node_t *)malloc(sizeof(node_t));
process_queue_3 = (node_t *)malloc(sizeof(node_t));
dispatch_queue->proc.arrival_time = -1;
dispatch_queue->proc.priority = -1;
dispatch_queue->proc.processor_time = -1;
dispatch_queue->proc.Mbytes = -1;
dispatch_queue->proc.num_printers = -1;
dispatch_queue->proc.num_scanners = -1;
dispatch_queue->proc.num_modems = -1;
dispatch_queue->proc.num_cds = -1;
realtime_queue->proc.arrival_time = -1;
realtime_queue->proc.priority = -1;
realtime_queue->proc.processor_time = -1;
realtime_queue->proc.Mbytes = -1;
realtime_queue->proc.num_printers = -1;
realtime_queue->proc.num_scanners = -1;
realtime_queue->proc.num_modems = -1;
realtime_queue->proc.num_cds = -1;
process_queue_1->proc.arrival_time = -1;
process_queue_1->proc.priority = -1;
process_queue_1->proc.processor_time = -1;
process_queue_1->proc.Mbytes = -1;
process_queue_1->proc.num_printers = -1;
process_queue_1->proc.num_scanners = -1;
process_queue_1->proc.num_modems = -1;
process_queue_1->proc.num_cds = -1;
process_queue_2->proc.arrival_time = -1;
process_queue_2->proc.priority = -1;
process_queue_2->proc.processor_time = -1;
process_queue_2->proc.Mbytes = -1;
process_queue_2->proc.num_printers = -1;
process_queue_2->proc.num_scanners = -1;
process_queue_2->proc.num_modems = -1;
process_queue_2->proc.num_cds = -1;
process_queue_3->proc.arrival_time = -1;
process_queue_3->proc.priority = -1;
process_queue_3->proc.processor_time = -1;
process_queue_3->proc.Mbytes = -1;
process_queue_3->proc.num_printers = -1;
process_queue_3->proc.num_scanners = -1;
process_queue_3->proc.num_modems = -1;
process_queue_3->proc.num_cds = -1;
resources computer_resources;
computer_resources.max_printers = 2;
computer_resources.max_scanner = 1;
computer_resources.max_modems = 1;
computer_resources.max_cd = 3;
memset(computer_resources.max_memory, 0, MEMORY);
// Load the dispatch list file and create the dispatch queue.
load_dispatch("dispatchlist", dispatch_queue);
// Iterate through each item in the job dispatch list, add each process
// to the appropriate queues
while(1) {
process handle = pop(&dispatch_queue);
if (handle.arrival_time == NULL) {
break;
}
switch(handle.priority) {
case 0:
push(handle, realtime_queue);
case 1:
push(handle, process_queue_1);
case 2:
push(handle, process_queue_2);
case 3:
push(handle, process_queue_3);
}
}
// pop(&dispatch_queue);
// pop(&realtime_queue);
// pop(&process_queue_1);
// pop(&process_queue_2);
// pop(&process_queue_3);
// Allocate the resources for each process before it's executed
while (realtime_queue != NULL) {
_runprocess(computer_resources, realtime_queue);
}
while(process_queue_1 != NULL) {
_runprocess(computer_resources, process_queue_1);
}
while(process_queue_2 != NULL) {
_runprocess(computer_resources, process_queue_2);
}
while(process_queue_3 != NULL) {
_runprocess(computer_resources, process_queue_3);
}
free(dispatch_queue);
free(realtime_queue);
free(process_queue_1);
free(process_queue_2);
free(process_queue_3);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
// ==================== YOUR CODE HERE ==================== //
// Load the dispatchlist
char *dpFile = NULL;
if(argc > 1)
dpFile = argv[1];
// Read the dispatch file
load_dispatch(dpFile);
// Iterate through each item in the job dispatch list, add each process
// to the appropriate queues
dispTime = 0;
// Execute the block once
do {
// Iinitialize available resources
initializeAvaiableResources();
// queue data structure
structNode *poppedStruct;
// continually loop until dispatches aren't null
while ( listOfDispatches != NULL && seek(listOfDispatches)->process.arrival_time <= dispTime) {
// Check if the next list of dispatch is empty
if (listOfDispatches->next == NULL) {
// pop the first element from the list of dispatches
poppedStruct = listOfDispatches;
listOfDispatches = NULL;
}
else {
poppedStruct = pop(listOfDispatches);
}
// check if the popped dispatcher has arrival time that is less than the dispatched time
if (poppedStruct->process.arrival_time <= dispTime) {
// get the status of the realtime job
bool process_1 = poppedStruct->process.res.num_printers > 0 || poppedStruct->process.res.num_scanners > 0 || poppedStruct->process.res.num_modems > 0 || poppedStruct->process.res.num_CDs > 0;
bool process_2 = poppedStruct->process.res.num_printers > NUM_PRINTERS || poppedStruct->process.res.num_scanners > NUM_SCANNERS || poppedStruct->process.res.num_modems > NUM_MODEMS || poppedStruct->process.res.num_CDs > NUM_CDS;
// check if the process priority is 0
if (poppedStruct->process.priority == 0) {
// check if process 1 is true
if (process_1) {
printf("ERROR WITH THE REAL TIME JOB\n");
}
else {
// push the process to the queue
rtData = push(rtData, poppedStruct->process);
}
}
else {
// check if the second process is true
if (process_2) {
printf("ERROR WITH THE RESOURCE\n");
}
else {
// push the process onto the queue
userJobs = push(userJobs, poppedStruct->process);
}
}
}
}
// Allocate the resource necessary for the process
// check if the user jobs aren't null
// Check the amount of free space and return true if there is enough space for allocation
// check for the available resource
// continually loop until these above criteria meets
while(userJobs != NULL && checkForMemory(userJobs->process.res, userJobs->process.MBytes) && checkForResources(userJobs->process.res)) {
// set the memory index to the allocated memory
userJobs->process.memory_index = alloc_mem(userJobs->process.res, userJobs->process.MBytes);
// create temporary queue structure
structNode *temp;
// continually loop through the jobs
while( userJobs != NULL) {
// Check if the next element is null
if (userJobs->next == NULL){
// assign the job to the temporary queue
temp = userJobs;
userJobs = NULL;
}
else {
// pop the first element and add it to temp queue
temp = pop(userJobs);
}
// Allocate the resources for the temp process
allocateResources(temp->process);
// push the process to the queue
pushToQueue(temp->process);
}
}
// check if the active doesn't contain NULL
if (activeProcess != NULL) {
// decrement the active processes
activeProcess->process.processor_time--;
// check if the processor time is 0
if (activeProcess->process.processor_time == 0) {
// kill the active process
kill(activeProcess->process.pid, SIGINT);
// system call suspends execution of the calling process until a child specified by the pid
waitpid(activeProcess->process.pid, &status, WUNTRACED);
// free the memory
free_mem(activeProcess->process.res, activeProcess->process.memory_index, activeProcess->process.MBytes);
// Free the resources
freeResources(activeProcess->process.res);
// free the variable
free(activeProcess);
activeProcess = NULL;
} else if (activeProcess->process.priority > 0 && !(rtData == NULL && firstPriority == NULL && secondPriority == NULL && thirdPriority == NULL)) {
// kill the process
kill(activeProcess->process.pid , SIGTSTP);
// system call suspends execution of the calling process until a child specified by the pid
waitpid(activeProcess->process.pid + 1, &status, WUNTRACED);
// set the suspended state to true
activeProcess->process.suspended = true;
// check if the priority is less than 3
if(activeProcess->process.priority < 3) {
// increment the priority
activeProcess->process.priority++;
}
// push the process to queue
pushToQueue(activeProcess->process); // add back to the queue
activeProcess = NULL;
}
}
// Pop the first process from the queue
if (activeProcess == NULL && !(rtData == NULL && firstPriority == NULL && secondPriority == NULL && thirdPriority == NULL)) {
// check if the real time data is not null
if (rtData != NULL) {
// check if the next element is not null
if (rtData->next != NULL) {
// pop the first element and assign it to active
activeProcess = pop(rtData);
} else {
// set the active process
activeProcess = rtData;
rtData = NULL;
}
} else if (firstPriority != NULL) {
// check if the first priority is not null
if (firstPriority->next != NULL) {
// pop the first element
activeProcess = pop(firstPriority);
} else {
// set the first priority to an active process
activeProcess = firstPriority;
firstPriority = NULL;
}
} else if (secondPriority != NULL) {
// check if the second priority has next element
if (secondPriority->next != NULL) {
// pop the first element and assign it to the active process
activeProcess = pop(secondPriority);
} else {
// assign the second priority task to the process
activeProcess = secondPriority;
secondPriority = NULL;
}
} else if (thirdPriority != NULL) {
// check if the next element in third priority is not null
if (thirdPriority->next != NULL) {
// pop the first element and add it to active process
activeProcess = pop(thirdPriority);
} else {
// assign the third priority to the active process
activeProcess = thirdPriority;
thirdPriority = NULL;
}
}
// check if the process is suspended
if(activeProcess->process.suspended == true) {
// kill the suspended process
kill(activeProcess->process.pid, SIGCONT);
// set the state of suspended to false
activeProcess->process.suspended = false;
} else {
// create process id
pid_t pid;
// fork the process
pid = fork();
// check if the pid is less than 0, then throw error
if (pid < 0) {
printf("ERROR WITH FORK\n");
}
else if (pid == 0) {
// get the child process
execvp(procArgv[0], procArgv);
}
// set the active process id
activeProcess->process.pid = pid;
// print the process to the console
print_process(activeProcess->process);
}
}
// sleep for 1 second
sleep(1);
// increment the dispatcher time
dispTime ++;
//printf("Time: %d\n", dispTime);
} while (activeProcess != NULL || !(rtData == NULL && firstPriority == NULL && secondPriority == NULL && thirdPriority == NULL) || listOfDispatches != NULL);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
// Load the dispatchlist
// Add each process structure instance to the job dispatch list queue
node_t *tmp_head = NULL;
printf("Dispatch list: \n");
load_dispatch("dispatchlist", &tmp_head);
print_list(tmp_head);
// Iterate through each item in the job dispatch list, add each process
// to the appropriate queues
node_t *test = NULL;
while(tmp_head != NULL) {
proc current = pop(&tmp_head);
// get a segfault, so this is currently commented out
push(&head_dispatch_queues[current.priority], current);
}
// go through the queues from highest to lowest priority
for(int i = 0; i < 4; i++) {
// while this queue isn't empty
// it will keep pushing resources to the end of the queue until this on is completely empty
while(head_dispatch_queues[i] != NULL) {
proc current = pop(head_dispatch_queues[i]);
if(res_available(current, resources)) {
// Allocate the resources for each process before it's executed
int printer_start = alloc_res(&resources.printers, current.required_printers);
int scanner_start = alloc_res(&resources.scanners, current.required_scanners);
int modem_start = alloc_res(&resources.modems, current.required_modems);
int cd_start = alloc_res(&resources.cd_drives, current.required_cds);
int memory_start = alloc_res(&resources.memory, current.required_memory);
// Execute the process binary using fork and exec
// Perform the appropriate signal handling
// decrease the current.processor_time by the amount of time this process ran
run_for_time(¤t);
// Deallocate the resources
free_res(&resources.printers, printer_start, current.required_printers);
free_res(&resources.scanners, scanner_start, current.required_scanners);
free_res(&resources.modems, modem_start, current.required_modems);
free_res(&resources.cd_drives, cd_start, current.required_cds);
free_res(&resources.memory, memory_start, current.required_memory);
}
// if the process needs more time to run, add it back to the queue
if(current.processor_time > 0) {
push(head_dispatch_queues[i], current);
}
}
}
// make sure the queues are clear to avoid memory leaks
for(int i = 0; i < 4; i++)
while(head_dispatch_queues[i] != NULL)
pop(head_dispatch_queues[i]);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]){
//Init queues
q_dispatch = (queue*)malloc(sizeof(queue*));
q_dispatch->head=NULL;
q_dispatch->tail=NULL;
q_real = (queue*)malloc(sizeof(queue*));
q_real->head=NULL;
q_real->tail=NULL;
q_1 = (queue*)malloc(sizeof(queue*));
q_1->head=NULL;
q_1->tail=NULL;
q_2 = (queue*)malloc(sizeof(queue*));
q_2->head=NULL;
q_2->tail=NULL;
q_3 = (queue*)malloc(sizeof(queue*));
q_3->head=NULL;
q_3->tail=NULL;
//Init resources
for(int i=0;i<PRINTERS;i++){res_avail.printers[i]=0;}
for(int i=0;i<SCANNERS;i++){res_avail.scanners[i]=0;}
for(int i=0;i<MODEMS;i++){res_avail.modems[i]=0;}
for(int i=0;i<DRIVES;i++){res_avail.drives[i]=0;}
for(int i=0;i<MEMORY;i++){res_avail.memory[i]=0;}
// Load the dispatchlist adds to queue as well
load_dispatch(argv[1]);
int tick =0;
//Start dispatching
while(true){
//check dispatch list for processes that have arrived
node* dispatch_node = q_dispatch->head;
while(dispatch_node){
if(dispatch_node->process.arrival_time==tick){
//Push process to appropriate queue
switch(dispatch_node->process.priority){
case 0:
push(q_real,dispatch_node->process);
break;
case 1:
push(q_1,dispatch_node->process);
break;
case 2:
push(q_2,dispatch_node->process);
break;
case 3:
push(q_3,dispatch_node->process);
break;
}
}
dispatch_node=dispatch_node->next;
}
//Run processes
proc* get_proc;
bool find_proc = true;
int count;
//Real Time Queue
count = q_size(q_real);
//loop through queue if there is something in queue and no job has been found
while(find_proc&&count>0){
get_proc = pop(q_real);
//check if process can be allocated
if(alloc_resources(&res_avail,get_proc)){
//run
run_proc(get_proc);
find_proc=false;
}else{
push(q_real,*get_proc);
count--;
}
}
//1st Queue
count = q_size(q_1);
//loop through queue if there is something in queue and no job has been found
while(find_proc&&count>1){
get_proc = pop(q_1);
//Check if process can be allocated
if(alloc_resources(&res_avail,get_proc)){
//run if not completed during run push to next queue
if(run_proc(get_proc))
push(q_2,*get_proc);
find_proc=false;
}else{
//if resources not available push back onto queue
push(q_1,*get_proc);
count--;
}
}
//2nd Queue
count = q_size(q_2);
//loop through queue if there is something in queue and no job has been found
while(find_proc&&count>0){
get_proc = pop(q_2);
//if process is a new process
if(!get_proc->suspended){
//check if it can be allocated
if(alloc_resources(&res_avail,get_proc)){
//run if not completed during run push to next queue
if(run_proc(get_proc))
push(q_3,*get_proc);
find_proc=false;
}else{
//if resources not available push back onto queue
push(q_2,*get_proc);
count--;
}
}else{
//if processes has already been allocated just run it some more
if(run_proc(get_proc))
push(q_3,*get_proc);
find_proc=false;
}
}
//3rd Qeue
count = q_size(q_3);
while(find_proc&&count>0){
get_proc = pop(q_3);
if(!get_proc->suspended){
if(alloc_resources(&res_avail,get_proc)){
if(run_proc(get_proc))
push(q_3,*get_proc);
find_proc=false;
}else{
push(q_3,*get_proc);
count--;
}
}else{
if(run_proc(get_proc))
push(q_3,*get_proc);
find_proc=false;
}
}
//if no process was able to be run either system is hung or there are no jobs left
if(find_proc){
printf("TERMINATING: Could not find anymore processes\n");
break;
}
//increase tick count on dispatcher
tick++;
}
return EXIT_SUCCESS;
}
