From e76832a30f8badca37aac1e64ffc3cdeb9c2f88a Mon Sep 17 00:00:00 2001
From: Syufan <zyf571635687@gmail.com>
Date: Tue, 18 Apr 2023 20:52:18 +1000
Subject: [PATCH] Create allocate.c
---
allocate.c | 792 +++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 792 insertions(+)
create mode 100644 allocate.c
diff --git a/allocate.c b/allocate.c
new file mode 100644
index 0000000..c143198
--- /dev/null
+++ b/allocate.c
@@ -0,0 +1,792 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <math.h>
+
+typedef struct node process_n;
+typedef struct memory memory_n;
+
+struct node {
+ int arrival_time;
+ char process_name[10];
+ int time_required;
+ int time_required_orgin;
+ int memory;
+ char state[10];
+ process_n* next;
+ process_n* pre;
+};
+
+typedef struct {
+ process_n* head;
+ process_n* foot;
+} queue_n;
+
+struct memory{
+ int memory_state;
+ int number;
+ char process_name[10];
+ memory_n* next;
+};
+
+typedef struct{
+ memory_n* head;
+ memory_n* foot;
+} queue_memory;
+
+//---------signature---------//
+void add_data(queue_n* q, int arrival_time, char* process_name, int time_required, int memory, char* state);
+void add_node(queue_n* q, process_n* new_node);
+void print_q(queue_n* q);
+void read_data(char* filename, queue_n* batch_list);
+void pickup_input(queue_n* batch_list, queue_n* input_list, int simulated_time);
+void pickup_input_task3(queue_n* batch_list, queue_n* input_list, int simulated_time, queue_memory* memory_list);
+void move_node(queue_n* q, process_n* node);
+void dele_node(queue_n* q, process_n* node);
+process_n* search_shortest_process(queue_n* q);
+void add_node_to_list(memory_n* new_node, queue_memory* list);
+memory_n* create_memory_node(int i);
+int count_memory(queue_memory* q);
+int allocate_memory(queue_memory* q, process_n* process, int simulated_time);
+int find_position(memory_n* current_node,queue_memory* q);
+void free_memory(queue_memory* q, process_n* process);
+void print_by_size(queue_memory* q, int start, int num);
+
+int count_list(queue_n* q);
+//---------signature end---------//
+
+int main(int argc, char *argv[]) {
+
+ int quantum;
+ char line[100];
+ char *filename = NULL;
+ int simulated_time = 0;
+ int remaining_time = 0;
+ char *scheduler_algorithm = NULL;
+ char *memory_strategy = NULL;
+
+ //create batch list, input list and ready list
+ queue_n* batch_list = (queue_n*)malloc(sizeof(queue_n));
+ batch_list->head = batch_list->foot = NULL;
+ queue_n* input_list = (queue_n*)malloc(sizeof(queue_n));
+ input_list->head = input_list->foot = NULL;
+ queue_n* ready_list = (queue_n*)malloc(sizeof(queue_n));
+ ready_list->head = ready_list->foot = NULL;
+
+ //read the input
+ for (int i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "-f") == 0 && i + 1 < argc) {
+ filename = argv[i + 1];
+ read_data(filename, batch_list);
+ } else if (strcmp(argv[i], "-s") == 0 && i + 1 < argc) {
+ scheduler_algorithm = argv[i + 1];
+ } else if (strcmp(argv[i], "-m") == 0 && i + 1 < argc) {
+ memory_strategy = argv[i + 1];
+ } else if (strcmp(argv[i], "-q") == 0 && i + 1 < argc) {
+ quantum = atoi(argv[i + 1]);
+ }
+ }
+
+ // create memory
+ queue_memory* memory_list = (queue_memory*)malloc(sizeof(queue_memory));
+ memory_list->foot = memory_list->head = NULL;
+ // create node
+ for(int i=0; i < 2048; i++){
+ memory_n* new_node = create_memory_node(i);
+ add_node_to_list(new_node,memory_list);
+ }
+
+ //=================================TASK 1=================================//
+ if(strcmp(scheduler_algorithm,"SJF") == 0 && strcmp(memory_strategy,"infinite") == 0 ){
+ // put all the process which arrive time <= simmulated time
+ pickup_input(batch_list, input_list, simulated_time);
+ double num = count_list(batch_list);
+ process_n* processing = NULL;
+ double turnaround_time = 0;
+ double end = 0;
+ double single = 0;
+ double time_overhead = 0;
+ double time_single = 0;
+ double max_time_overhead = 0;
+ while(input_list->head != NULL){
+ // pick up the shortest by time_required
+ processing = search_shortest_process(input_list);
+ strcpy(processing->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,processing->state,processing->process_name,processing->time_required);
+
+ remaining_time = processing->time_required;
+ while(remaining_time > 0){
+ simulated_time+=quantum;
+ remaining_time-=quantum;
+ }
+ // calculate time
+ end = simulated_time;
+ single = end - processing->arrival_time;
+ turnaround_time += single;
+ time_single = single/processing->time_required;
+ if(max_time_overhead<time_single){
+ max_time_overhead = time_single;
+ }
+ time_overhead += time_single;
+
+ strcpy(processing->state, "FINISHED");
+ // move finished process from input list
+ move_node(input_list, processing);
+ // add all process except this cycle
+ pickup_input(batch_list, input_list, simulated_time-quantum);
+ int proc_remaining = count_list(input_list);
+ printf("%d,%s,process_name=%s,proc_remaining=%d \n",simulated_time,processing->state,processing->process_name,proc_remaining);
+ // add all process
+ pickup_input(batch_list, input_list, simulated_time);
+ }
+ turnaround_time = round(turnaround_time/(num+1));
+ time_overhead = time_overhead/(num+1);
+ printf("Turnaround time %0.f\nTime overhead %.2f %.2f \nMakespan %d\n",turnaround_time,max_time_overhead,time_overhead,simulated_time);
+ }
+ //================================TASK 1 END================================//
+
+ //==================================TASK 2==================================//
+ else if(strcmp(scheduler_algorithm,"RR") == 0 && strcmp(memory_strategy,"infinite") == 0 ){
+ double num = count_list(batch_list);
+ pickup_input(batch_list,ready_list,simulated_time);
+ process_n* current = ready_list->head;
+ process_n* box = NULL;
+
+
+ double turnaround_time = 0;
+ double end = 0;
+ double single = 0;
+ double time_overhead = 0;
+ double time_single = 0;
+ double max_time_overhead = 0;
+
+ while(ready_list->head != NULL || batch_list->head != NULL){
+ //pickup_input_task3(batch_list, ready_list, simulated_time, memory_list);
+ //print_q(ready_list);
+ if(ready_list->head == NULL){
+ current = NULL;
+ goto finish;
+ }
+ if(current == NULL){
+ current = ready_list->head;
+ }
+ int moved = 0;
+ // if process is compeleted
+ if(current->time_required <= 0){
+ strcpy(current->state, "FINISHED");
+
+ end = simulated_time;
+ single = end - current->arrival_time;
+ turnaround_time += single;
+ time_single = single / current->time_required_orgin;
+ if(max_time_overhead < time_single){
+ max_time_overhead = time_single;
+ }
+ time_overhead += time_single;
+ //int proc_remaining = count_list(ready_list);
+
+ process_n* temp = ready_list->head;
+ int proc_remaining = 0;
+ while(temp != NULL){
+ if(temp->arrival_time < simulated_time - quantum){
+ proc_remaining ++;
+ }
+ temp = temp->next;
+ }
+ proc_remaining = proc_remaining - 1;
+ printf("%d,%s,process_name=%s,proc_remaining=%d\n",simulated_time,current->state,current->process_name,proc_remaining);
+ if(current->next != NULL){
+ box = current->next;
+ }else if(current == ready_list->foot){
+ box = ready_list->head;
+ }
+ dele_node(ready_list,current);
+ current = box;
+ moved = 1;
+ }
+ if(ready_list->foot != ready_list->head){
+ // many nodes
+ if(strcmp(current->state,"null") == 0){
+ // if there are many same nodes, just modify first one
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ current->time_required -= quantum;
+ goto finish;
+ }
+ strcpy(current->state, "READY");
+ if(moved != 1){
+ if(current->next != NULL){
+ current = current->next;
+ }else if(current == ready_list->foot){
+ current = ready_list->head;
+ }
+ }
+ if(strcmp(current->state,"null") == 0){
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ current->time_required -= quantum;
+ }else if(strcmp(current->state,"READY") == 0){
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ current->time_required -= quantum;
+ }
+
+ }
+ if(current == ready_list->head && current == ready_list->foot){
+ // there are only one process
+ if(strcmp(current->state,"RUNNING") != 0){
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ }
+ current->time_required -= quantum;
+ }
+ finish:
+ simulated_time += quantum;
+ pickup_input(batch_list, ready_list, simulated_time);
+ }
+ printf("turnaround time = %f \n", num);
+ turnaround_time = ceil(turnaround_time/(num));
+ time_overhead = time_overhead/(num);
+ printf("Turnaround time %0.f\nTime overhead %.2f %.2f \nMakespan %d\n",turnaround_time,max_time_overhead,time_overhead,simulated_time-quantum);
+
+ }
+ //==================================TASK 2 END==================================//
+
+ //==================================TASK 3==================================//
+ else if(strcmp(scheduler_algorithm,"RR") == 0 && strcmp(memory_strategy,"best-fit") == 0){
+
+ // pick up the process who's arrive time is suitable
+ pickup_input_task3(batch_list,ready_list,simulated_time,memory_list);
+ process_n* current = ready_list->head;
+ process_n* box = NULL;
+
+ // make sure no process in ready list and batch list
+ while(ready_list->head != NULL || batch_list->head != NULL){
+ // printf("\n===================start=============\n");
+ // printf("%d\n", simulated_time);
+ // print_q(ready_list);
+ //int turn_on = 0;
+ // pickup_input_task3(batch_list, ready_list, simulated_time, memory_list);
+ while(ready_list->head == NULL && batch_list->head != NULL){
+
+ simulated_time+=quantum;
+ pickup_input_task3(batch_list,ready_list,simulated_time,memory_list);
+ //urn_on = 1;
+ }
+ if(current == NULL && ready_list->head != NULL){
+ current = ready_list->head;
+ }
+ // if(ready_list->head==NULL){
+ // pickup_input(batch_list,ready_list,simulated_time,memory_list);
+ // }
+ //printf("%d\n", simulated_time);
+ //printf("xxxxxx current name = %s , arrive time = %d \n",current->process_name,current->arrival_time);
+ // if(ready_list->head == NULL){
+ // printf("马上运行\n");
+ // current = NULL;
+ // goto finish_task3;
+ // }
+ // printf("马上运行\n");
+ // if(current == NULL){
+ // current = ready_list->head;
+ // //printf("890809current = null\n");
+ // //printf("current name = %s , arrive time = %d \n",current->process_name,current->arrival_time);
+ // }
+ // int moved = 0;
+
+ // if process is compeleted
+ if(current->time_required <= 0){
+
+ strcpy(current->state, "FINISHED");
+ free_memory(memory_list,current);
+ int proc_remaining = count_list(ready_list) - 1;
+ printf("%d,%s,process_name=%s,proc_remaining=%d\n",simulated_time,current->state,current->process_name,proc_remaining);
+
+
+ if (proc_remaining == 0){
+ box = NULL;
+ }else{
+ if(current->next != NULL && current != ready_list->foot){
+ box = current->next;
+ }
+ else if(current == ready_list->foot){
+ box = ready_list->head;
+ }
+ }
+
+ dele_node(ready_list,current);
+ current = box;
+ //moved = 1;
+ if(current == NULL){
+ pickup_input_task3(batch_list,ready_list,simulated_time,memory_list);
+ if(ready_list->head != NULL){
+ current = ready_list->head;
+ }
+ else{
+ goto finish_task3;
+ }
+ }
+ }
+ if(ready_list->foot != ready_list->head){
+ // many nodes
+ if(strcmp(current->state,"null") == 0){
+ // if there are many same nodes, just modify first one
+ // start
+ //printf("%d,%s,process_name=%s,assigned_at=%d",simulated_time,current->state,);
+ //strcpy(current->state, "READY");
+ //printf("======allocate memory\n");
+ //print_by_size(memory_list,0,80);
+ //allocate_memory(memory_list,current,simulated_time);
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ current->time_required -= quantum;
+ //goto finish;
+ }
+ strcpy(current->state, "READY");
+ //if(moved != 1){
+ if(current->next != NULL){
+ current = current->next;
+ }else if(current == ready_list->foot){
+ current = ready_list->head;
+ }
+ //}
+ if(strcmp(current->state,"null") == 0){
+ //printf("======allocate memory\n");
+ //strcpy(current->state, "READY");
+ //allocate_memory(memory_list,current,simulated_time);
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ current->time_required -= quantum;
+ }else if(strcmp(current->state,"READY") == 0){
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ current->time_required -= quantum;
+ }
+
+ }
+ if(current == ready_list->head && current == ready_list->foot){
+ // there are only one process
+ if(strcmp(current->state,"RUNNING") != 0){
+ //printf("马上运行\n");
+ //printf("process_name=,assigned_at=\n");
+ //strcpy(current->state, "READY");
+ //print_by_size(memory_list,0,40);
+ //printf("allocation one process memory\n");
+ //allocate_memory(memory_list,current,simulated_time);
+ strcpy(current->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,current->state,current->process_name,current->time_required);
+ }
+ current->time_required -= quantum;
+ }
+ finish_task3:
+ //if(turn_on == 0){
+ pickup_input_task3(batch_list, ready_list, simulated_time, memory_list);
+ simulated_time += quantum;
+ //}
+
+ // printf("提前减少的下半时区\n");
+ if(current == NULL && ready_list->head != NULL){
+ current = ready_list->head;
+ }
+ // printf("\n\nready List:\n");
+ // print_q(ready_list);
+ }
+
+ }
+ // 打印解析的参数
+ // printf("memory_strategy = %s ", memory_strategy);
+ // printf("quantum = %d\n", quantum);
+
+ //=====================Task 3 sjf===================//
+ if(strcmp(scheduler_algorithm,"SJF") == 0 && strcmp(memory_strategy,"best-fit") == 0){
+ // put all the process which arrive time <= simmulated time
+ pickup_input_task3(batch_list, input_list, simulated_time,memory_list);
+
+ process_n* processing = NULL;
+ while(input_list->head != NULL){
+ // pick up the shortest by time_required
+ processing = search_shortest_process(input_list);
+ strcpy(processing->state, "RUNNING");
+ printf("%d,%s,process_name=%s,remaining_time=%d \n",simulated_time,processing->state,processing->process_name,processing->time_required);
+
+ remaining_time = processing->time_required;
+ while(remaining_time > 0){
+ simulated_time+=quantum;
+ remaining_time-=quantum;
+ }
+ strcpy(processing->state, "FINISHED");
+ // move finished process from input list
+ move_node(input_list, processing);
+ // add all process except this cycle
+ pickup_input_task3(batch_list, input_list, simulated_time-quantum,memory_list);
+ int proc_remaining = count_list(input_list);
+ printf("%d,%s,process_name=%s,proc_remaining=%d \n",simulated_time,processing->state,processing->process_name,proc_remaining);
+ // add all process
+ pickup_input_task3(batch_list, input_list, simulated_time,memory_list);
+ }
+ }
+ return 0;
+}
+
+//---------------functions---------------//
+
+int allocate_memory(queue_memory* q, process_n* process, int simulated_time){
+ int min = -1;
+ memory_n* min_start = NULL;
+ memory_n* min_end = NULL;
+ memory_n* temp = q->head;
+
+ //printf("**************memory**************\n");
+ while(temp->next != NULL && temp != NULL){
+ //printf("bug121\n");
+ // find the start of 0
+ while(temp->memory_state != 0 && temp->next != NULL){
+ temp = temp->next;
+ }
+ memory_n* temp_start = temp;
+
+ // find the end of 0/
+ int count_memory = 1;
+ while(temp->memory_state != 1 && temp->next!=NULL){
+ temp = temp->next;
+ count_memory++;
+ }
+ memory_n* temp_end = temp;
+
+ //printf("start = %d, end = %d \n",temp_start->number,temp_end->number);
+ // printf("count_memory end = %d \n",temp->number);
+ //printf("count_memory = %d \n",count_memory);
+
+ // check the memeory size
+ if(count_memory < process->memory){
+ return 0;
+ }
+ if (count_memory == process->memory){
+ //printf("true\n");
+ // 直接赋值，用temp start开始
+ //printf("go in to ready 1 start = %d, end = %d process memory%d\n\n",temp_start->number,temp_end->number, process->memory);
+ memory_n* temp_allocate = temp_start;
+ for (int i = 0; i < process->memory; i++){
+ //循环正常
+
+ temp_allocate -> memory_state = 1;
+ strcpy(temp_allocate->process_name,process->process_name);
+ temp_allocate = temp_allocate->next;
+ // temp = temp_start;
+ // temp->memory_state = 1;
+ // strcpy(temp_start->process_name,process->process_name);
+ // temp = temp->next;
+ }
+ //int location = find_position(temp_start,q);
+ //printf("finish ready 1 start = %d memory state = %d process name = %s \n\n",temp_start->number,temp_start->memory_state,temp_start->process_name);
+ //printf("finish ready 1 start = %d memory state = %d process name = %s \n\n",temp_start->next->number,temp_start->next->memory_state,temp_start->next->process_name);
+ //printf("finish ready 1 start = %d memory state = %d process name = %s \n\n",temp_start->next->next->number,temp_start->next->next->memory_state,temp_start->next->next->process_name);
+ printf("%d,READY,process_name=%s,assigned_at=%d\n",simulated_time, process->process_name, temp_start->number);
+ return 1;
+ }else if(count_memory > process->memory){
+ if(min == -1){
+ min = count_memory;
+ min_start = temp_start;
+ min_end = temp_end;
+ }else{
+ // compare to get min
+ if(min > count_memory){
+ min = count_memory;
+ min_start = temp_start;
+ min_end = temp_end;
+ }
+ }
+ }
+ }
+ //printf("bug2\n");
+
+ int position = find_position(min_start,q);
+ // printf("===========min = %d start=%d %d\n", min, position,process->memory);
+ int size = min_end->number - min_start->number + 1;
+ if(min != -1){
+ //printf("enter min, process size = %d memory size = %d\n",process->memory,size);
+ if (process->memory){
+ for (size_t i = 0; i < process->memory; i++){
+ min_start->memory_state = 1;
+ strcpy(min_start->process_name,process->process_name);
+ //printf("number %d state = %d name= %s\n",min_start->number,min_start->memory_state, min_start->process_name);
+ min_start = min_start->next;
+ // temp = min_start;
+ // temp = temp->next;
+ }
+ printf("%d,READY,process_name=%s,assigned_at=%d\n",simulated_time, process->process_name, position);
+ return 1;
+ }
+ return 0;
+ }
+ // print_by_size(q,0,50);
+ // printf("\n\n\n\n");
+ return 0;
+}
+void print_by_size(queue_memory* q, int start, int num){
+ memory_n* temp = q->head;
+ // find the start point
+ while(temp->number != start){
+ temp = temp->next;
+ }
+ for(int i = 0; i < num; i++){
+ printf("number = %d memory state = %d,process name = %s\n",temp->number,temp->memory_state, temp->process_name);
+ temp = temp->next;
+ }
+
+}
+
+void free_memory(queue_memory* q, process_n* process){
+ memory_n* temp = q->head;
+ // firstly, find the location where need free
+ while(strcmp(temp->process_name,process->process_name) != 0 && temp->next != NULL){
+ temp = temp->next;
+ }
+
+ while(strcmp(temp->process_name,process->process_name)==0 && temp->next != NULL){
+ temp->memory_state = 0;
+ strcpy(temp->process_name,"null");
+ temp = temp->next;
+ }
+}
+int find_position(memory_n* current_node,queue_memory* q){
+ int position = 0;
+ memory_n* temp = q->head;
+ while(temp != current_node){
+ temp = temp->next;
+ position++;
+ }
+ return position;
+}
+
+int count_memory(queue_memory* q){
+ memory_n* temp = q->head;
+ int num = 0;
+ while(temp != NULL){
+ if(temp->memory_state == 0){
+ temp = temp->next;
+ num ++;
+ }
+ }
+ return num;
+}
+
+// add node to list
+void add_node_to_list(memory_n* new_node, queue_memory* list) {
+ if (list->head == NULL) {
+ list->head = new_node;
+ list->foot = new_node;
+ } else {
+ list->foot->next = new_node;
+ list->foot = new_node;
+ }
+}
+
+// create node
+memory_n* create_memory_node(int i) {
+ memory_n* node = (memory_n*)malloc(sizeof(memory_n));
+ strcmp(node->process_name,"null");
+ node->number = i;
+ node->memory_state = 0;
+ node->next = NULL;
+ return node;
+}
+
+// delete node
+// received list and node need to dispare, disconnect current node from current list
+void dele_node(queue_n* q, process_n* node){
+ // In the head
+ if (node == q->head) {
+ // Only one node in the list
+ if (q->head == q->foot) {
+ q->head = q->foot = NULL;
+ } else {
+ // More than one node in the list
+ q->head = node->next;
+ node->next->pre = NULL;
+ node->next = NULL;
+ }
+ }
+ // In the middle
+ else {
+ // In the foot
+ if (node == q->foot) {
+ node->pre->next = NULL;
+ q->foot = node->pre;
+ node->pre = NULL;
+ } else {
+ // In the middle
+ node->pre->next = node->next;
+ node->next->pre = node->pre;
+ node->pre = node->next = NULL;
+ }
+ }
+ free(node);
+}
+
+int count_list(queue_n* q){
+ process_n* temp = q->head;
+ int num = 0;
+ while(temp != NULL){
+ temp = temp->next;
+ num ++;
+ }
+ return num;
+}
+
+// receive a list find the shortest.
+process_n* search_shortest_process(queue_n* q){
+ process_n* shortest = q->head;
+ process_n* temp = q->head->next;
+ while (temp != NULL) {
+ if (temp->time_required < shortest->time_required) {
+ shortest = temp;
+ }
+ else if (temp->time_required == shortest->time_required && temp->arrival_time < shortest->arrival_time){
+ shortest = temp;
+ } else if (temp->time_required == shortest->time_required && temp->arrival_time == shortest->arrival_time && (strcmp(temp->process_name,shortest->process_name)<0)) {
+ shortest = temp;
+ }
+ temp = temp->next;
+ }
+ return shortest;
+}
+// receive two list, put the process which arrived time is <= simulated_time
+void pickup_input_task3(queue_n* batch_list, queue_n* input_list, int simulated_time, queue_memory* memory_list){
+ process_n* temp = batch_list->head;
+ while (temp != NULL) {
+ //find arrive time <=> simulated-time
+ if(temp->arrival_time <= simulated_time){
+ process_n* temp_next = temp->next;
+ int sta = allocate_memory(memory_list,temp,simulated_time);
+
+ //cleaprintf("allocate memory: %d \n",temp->memory);
+ // printf("============%d\n", sta);
+ if (sta==1){
+ //1.delete node from current list
+ move_node(batch_list, temp);
+ //2.add node to aim list
+ add_node(input_list, temp);
+ //allocate_memory(memory_list,temp,simulated_time);
+ }
+ temp = temp_next;
+ }else{
+ temp = temp->next;
+ }
+ }
+
+}
+
+// receive two list, put the process which arrived time is <= simulated_time
+void pickup_input(queue_n* batch_list, queue_n* input_list, int simulated_time){
+ process_n* temp = batch_list->head;
+ while (temp != NULL) {
+ //find arrive time <=> simulated-time
+ if(temp->arrival_time <= simulated_time){
+ process_n* temp_next = temp->next;
+
+ //cleaprintf("allocate memory: %d \n",temp->memory);
+ // printf("============%d\n", sta);
+ //1.delete node from current list
+ move_node(batch_list, temp);
+ //2.add node to aim list
+ add_node(input_list, temp);
+ //allocate_memory(memory_list,temp,simulated_time);
+ temp = temp_next;
+ }else{
+ temp = temp->next;
+ }
+ }
+
+}
+
+// received list and node need to dispare, disconnect current node from current list
+void move_node(queue_n* q, process_n* node){
+ // In the head
+ if (node == q->head) {
+ // Only one node in the list
+ if (q->head == q->foot) {
+ q->head = q->foot = NULL;
+ } else {
+ // More than one node in the list
+ q->head = node->next;
+ node->next->pre = NULL;
+ node->next = NULL;
+ }
+ }
+ // In the middle
+ else {
+ // In the foot
+ if (node == q->foot) {
+ node->pre->next = NULL;
+ q->foot = node->pre;
+ node->pre = NULL;
+ } else {
+ // In the middle
+ node->pre->next = node->next;
+ node->next->pre = node->pre;
+ node->pre = node->next = NULL;
+ }
+ }
+
+}
+
+// receive filename and linked list, then save all the input into list
+void read_data(char* filename, queue_n* batch_list) {
+ char line[100];
+ FILE *fp;
+ fp = fopen(filename, "r");
+ if (fp == NULL) {
+ printf("can't open file %s\n", filename);
+ exit(1);
+ }
+
+ //save data into batch_list
+ while (fgets(line, sizeof(line), fp)) {
+ int arrival_time, time_required, memory_size;
+ char process_name[10];
+ sscanf(line, "%d %s %d %d", &arrival_time, process_name, &time_required, &memory_size);
+ add_data(batch_list, arrival_time, process_name, time_required, memory_size, "null");
+ }
+
+ fclose(fp);
+}
+
+// receive data, save in node add then save into linked list
+void add_data(queue_n* q, int arrival_time, char* process_name, int time_required, int memory, char* state) {
+ process_n* new_node = (process_n*)malloc(sizeof(process_n));
+ new_node->arrival_time = arrival_time;
+ //strncpy(new_node->process_name, process_name, 9);
+ strcpy(new_node->process_name, process_name);
+ //new_node->process_name[9] = '\0';
+ new_node->time_required = time_required;
+ new_node->time_required_orgin = time_required;
+ new_node->memory = memory;
+ strcpy(new_node->state, state);
+ new_node->next = new_node->pre = NULL;
+ add_node(q, new_node);
+}
+
+// receive q linked list and new node, add node into linked list
+void add_node(queue_n* q, process_n* new_node) {
+ if (q->head == NULL){
+ q->head = new_node;
+ q->foot = new_node;
+ }else{
+ new_node->pre = q->foot;
+ q->foot->next = new_node;
+ q->foot = new_node;
+ }
+}
+
+// receive linked list then print it
+void print_q(queue_n* q) {
+ process_n* temp = q->head;
+ while (temp != NULL) {
+ printf("arrival_time = %d, process_name = %s, time_required = %d, memory = %d, state = %s\n", temp->arrival_time, temp->process_name, temp->time_required, temp->memory, temp->state);
+ temp = temp->next;
+ }
+}
+
+//---------------functions end---------------//
\ No newline at end of file
--
GitLab