removing comments and printfs

Author: amine-a11

CMakeLists.txt

@@ -2,11 +2,10 @@ cmake_minimum_required(VERSION 3.0)
 project(multitasking-scheduling-algorithm-simulation-system C)
 set(CMAKE_C_STANDARD 99)
 
-# Adding Raylib
 include(FetchContent)
 set(FETCHCONTENT_QUIET FALSE)
-set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) # don't build the supplied examples
-set(BUILD_GAMES    OFF CACHE BOOL "" FORCE) # don't build the supplied example games
+set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(BUILD_GAMES    OFF CACHE BOOL "" FORCE)
 
 FetchContent_Declare(
     raylib
@@ -18,7 +17,6 @@ FetchContent_Declare(
 
 FetchContent_MakeAvailable(raylib)
 
-# adding raygui
 FetchContent_Declare(
     raygui
     GIT_REPOSITORY "https://github.com/raysan5/raygui.git"
@@ -27,18 +25,4 @@ FetchContent_Declare(
     GIT_SHALLOW 1
 )
 
-FetchContent_MakeAvailable(raygui)
-
-# Adding our source files
-# file(GLOB_RECURSE PROJECT_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_LIST_DIR}/sources/*.c") # Define PROJECT_SOURCES as a list of all source files
-# set(PROJECT_INCLUDE "${CMAKE_CURRENT_LIST_DIR}/sources/") # Define PROJECT_INCLUDE to be the path to the include directory of the project
-
-# Declaring our executable
-# add_executable(${PROJECT_NAME})
-# target_sources(${PROJECT_NAME} PRIVATE ${PROJECT_SOURCES})
-# target_include_directories(${PROJECT_NAME} PRIVATE ${PROJECT_INCLUDE})
-# target_link_libraries(${PROJECT_NAME} PRIVATE raylib)
-
-# Setting ASSETS_PATH
-# target_compile_definitions(${PROJECT_NAME} PUBLIC ASSETS_PATH="${CMAKE_CURRENT_SOURCE_DIR}/assets/") # Set the asset path macro to the absolute path on the dev machine
-#target_compile_definitions(${PROJECT_NAME} PUBLIC ASSETS_PATH="./assets") # Set the asset path macro in release mode to a relative path that assumes the assets folder is in the same directory as the game executable
+FetchContent_MakeAvailable(raygui)

build/algorithms/FIFO

@@ -29,5 +29,5 @@ update:
 	@echo 'MSASS has been updated successfully !'
 
 run:  
-	@./build/main
-	@echo 'Welcome to MSASS !'
+	@echo 'Welcome to MSASS !'
+	@./build/main

build/algorithms/SRT

@@ -0,0 +1 @@
+0

build/algorithms/multilevel

@@ -3,13 +3,12 @@
 #include <stdbool.h>
 #include "../utils/process.h"
 #include "../utils/ReadyQueueElements.h"
-// structure to represent the priority queue
 typedef struct {
-	void** data; // table of void* elements in order to make a generic pirority_queue
-	int size; // size of the priority_queue
-	int capacity; // maximum size of the priority_queue
-	int dataSize; // size of each element to be added to the priority_queue
-	int (*compare)(const void *, const void *); // function pointer for custom comparison function
+	void** data;
+	int size;
+	int capacity;
+	int dataSize;
+	int (*compare)(const void *, const void *);
 } PriorityQueue;
 
 int compare_process_runTime(const void *a, const void *b) {
@@ -28,7 +27,6 @@ int compare_process_priority(const void *a, const void *b);
 ReadyQueueElements getPriorityQueueElements(PriorityQueue* pq);
 void free_created_array_from_pq(ReadyQueueElements readyqueue);
 
-// function to initialize an empty priority queue
 PriorityQueue *init_priority_queue(int capacity, int dataSize, int (*compare)(const void *, const void *)) {
     PriorityQueue *pq = (PriorityQueue *)malloc(sizeof(PriorityQueue)); // allocating the priority_queue
     pq->data = (void **)malloc(sizeof(void*) * (capacity)); // allocating the data table
@@ -39,31 +37,26 @@ PriorityQueue *init_priority_queue(int capacity, int dataSize, int (*compare)(co
     return pq;
 }
 
-// function to swap two elements in the priority queue
 void swap_pq(void **a, void **b) {
     void *temp = *a;
     *a = *b;
     *b = temp;
 }
 
-// function to push an element into the priority queue
 void push(PriorityQueue *pq, void *data) {
     if (pq->size == pq->capacity) {
         printf("Priority queue overflow\n");
         return;
     }
-	pq->data[pq->size] = malloc(pq->dataSize); // allocating needed memory for the new element to be pushed
-    memcpy(pq->data[pq->size], data, pq->dataSize); // copy the data into the priority_queue
-    // perform heapify-up to maintain the heap property
+	pq->data[pq->size] = malloc(pq->dataSize);
+    memcpy(pq->data[pq->size], data, pq->dataSize);
     int i = pq->size;
     while (i > 0 && pq->compare(pq->data[i], pq->data[(i-1) / 2]) > 0) {
         swap_pq(&pq->data[i], &pq->data[(i-1) / 2]);
         i = (i-1) / 2;
     }
-    pq->size++; // incrementing the size of the priority_queue
+    pq->size++;
 }
-
-// function to check if the priority_queue is empty
 bool is_empty_pq(PriorityQueue* pq) {
 	return !pq->size;
 }
@@ -78,7 +71,6 @@ ReadyQueueElements getPriorityQueueElements(PriorityQueue* pq) {
     }
     for(int i=0;i<idx;i++) {
         push(pq, i[array]);
-        // push(pq, array[i]);
     }
     return (ReadyQueueElements){array, pq->size};
 }
@@ -88,16 +80,14 @@ void free_created_array_from_pq(ReadyQueueElements readyqueue) {
     }
     free(readyqueue.readyQueue);
 }
-// function to pop the element with the highest priority from the priority_queue
 void* pop(PriorityQueue *pq) {
     if (is_empty_pq(pq)) {
         printf("Priority queue underflow\n");
 		exit(0);
     }
-	pq->size--; // decrementing the size of the priority_queue
-    swap_pq(&pq->data[0], &pq->data[pq->size]); // swap the root with the last element
-    void* poppedData = pq->data[pq->size];  // store the poppedData
-    // perform heapify-down to maintain the heap property
+	pq->size--;
+    swap_pq(&pq->data[0], &pq->data[pq->size]);
+    void* poppedData = pq->data[pq->size];
     int i = 0;
     while (1) {
         int leftChild = 2 * i + 1;
@@ -130,7 +120,6 @@ void* top(PriorityQueue* pq) {
     return pq->data[0];
 }
 
-// function to free the memory allocated for the priority_queue
 void free_priority_queue(PriorityQueue *pq) {
     for (int i = 0; i < pq->size; ++i) {
         free(pq->data[i]);
@@ -139,45 +128,10 @@ void free_priority_queue(PriorityQueue *pq) {
     free(pq);
 }
 
-// example custom comparison function for integers
 int compare_int(const void *a, const void *b) {
     return (*(int *)a - *(int *)b);
 }
 
-// example custom comparison function for process priority
 int compare_process_priority(const void *a, const void *b) {
     return ((Process*)a)->priority > ((Process*)b)->priority;
-}
-
-
-
-
-
-// int main(void) {
-// 	// PriorityQueue *pq = init_priority_queue(11, sizeof(int), compare_int);
-//    PriorityQueue *pq = init_priority_queue(11, sizeof(Process), compare_process_priority);
-
-//    // int values[] = {50, 19, 0, 14, 6, 3, 8, 16};
-// 	Process values[] = {{"pqrs", 0, 7, 8}, {"a", 5, 4, 2}, {"b", 12, 15, 88}, {"c", 8, 14, 3}, {"d", 10, 17, 18}, {"e", 5, 4, 0}};
-    
-//    for (int i = 0; i < sizeof(values) / sizeof(values[0]); ++i) {
-//        push(pq, &values[i]); // push elements into the priority_queue
-//    }
-//    ReadyQueueElements readyqueue = getPriorityQueueElements(pq);
-//    for(int i=0;i<readyqueue.readyQueueSize;i++) {
-//       void* e = readyqueue.readyQueue[i];
-//       printf("Popped: value=%s %d %d %d\n", ((Process *)e)->processName, ((Process *)e)->arrivalTime, ((Process *)e)->runTime, ((Process *)e)->priority);	
-//       // printf("Popped: value=%d\n", *((int*)e));
-//    }
-//    printf("\n");
-// 	while(pq->size) {
-// 		void* e = pop(pq); // pop element from the priority_queue
-//    	printf("Popped: value=%s %d %d %d\n", ((Process *)e)->processName, ((Process *)e)->arrivalTime, ((Process *)e)->runTime, ((Process *)e)->priority);	
-// 		// printf("Popped: value=%d\n", *((int*)e));
-//    	free(e); // don't forget to free the popped element
-// 	}
-	
-//    free_priority_queue(pq); // free the priority_queue
-//    free_created_array_from_pq(readyqueue); // free the created array from pq
-//    return 0;
-// }
+}

build/algorithms/multilevel_v2

@@ -2,7 +2,6 @@
 #include "../utils/process.h"
 
 
-//------------ Define structures
 typedef struct Node {
     Process data;
     struct Node* next;
@@ -25,12 +24,10 @@ int size_q(Queue* queue);
 char** create_array_from_queue(Queue* queue, int size);
 void free_queue(Queue* q);
 
-//------------ Check if the queue is empty or not
 int is_empty_q(Queue* queue){
     return (queue->front == NULL);
 }
 
-//------------ Initialize an empty queue
 Queue* create_queue(){
 
     Queue* queue = (Queue*)malloc(sizeof(Queue)); 
@@ -43,7 +40,6 @@ Queue* create_queue(){
         return queue;
     }
 }
-//------------ Create a node for the queue
 Node* create_node(Process process){
     Node* new_node = (Node*)malloc(sizeof(Node)); 
     if(!new_node){
@@ -56,7 +52,6 @@ Node* create_node(Process process){
         return new_node;
     }
 }
-//------------ Add an element to the queue
 void enqueue(Queue* queue, Process process) {
     Node* new_node = create_node(process);
     if(is_empty_q(queue)){
@@ -69,7 +64,6 @@ void enqueue(Queue* queue, Process process) {
     }
 }
 
-//------------ Remove an element from the queue and return its data ( whish is a process)
 Process dequeue(Queue* queue) {
     if(is_empty_q(queue)){
         printf("[ERROR] : Queue is already empty\n");
@@ -84,14 +78,12 @@ Process dequeue(Queue* queue) {
     }
 };
 
-// Function to swap two processes
 void swap_q( Process* a,  Process* b){
     Process temp = *a;
     *a = *b;
     *b = temp;
 }
 
-//------------- Sort the array by Arrival time
 void sort_by_arrival_time(Process* processes, int numProcesses){
     for (int i = 0; i < numProcesses - 1; i++) {
         for (int j = 0; j < numProcesses - i - 1; j++){
@@ -102,7 +94,6 @@ void sort_by_arrival_time(Process* processes, int numProcesses){
     }
 }
 
-//------------ Create a queue from an array
 Queue* create_queue_from_array( Process* processes,int numProcesses){
     Process* copy_from_processes = (Process*)malloc(numProcesses * sizeof(Process));
     memcpy(copy_from_processes, processes, numProcesses * sizeof(Process));
@@ -141,34 +132,4 @@ void free_queue(Queue* q) {
         dequeue(q);
     }
     free(q);
-}
-// An example where we define a static table of processes and then we create a queue from it. We add( enqueue)
-// another process and then we dequeue them all while reading the processes names
-// #include<stdio.h>
-// #include<stdlib.h>
-// #include "./queue.h"
-// int main(void){
-//     Process processes[] = {
-//         {"Process1", 2, 10, 1},
-//         {"Process2", 5, 8, 2},
-//         {"Process3", 1, 15, 3},
-//         {"Process4", 10, 15, 3},
-//         {"Process5", 7, 5, 13},
-//         {"Process6", 5, 4, 3},
-//         {"Process7", 3, 7, 2},
-//         {"Process8", 9, 4, 3},
-//     };
-//     Queue* q = create_queue_from_array(processes,8);
-//     enqueue(q,(Process){"Process9",14, 4, 3});
-//     char**t = create_array_from_queue(q,size_q(q));
-//     for(int i=0;i<size_q(q);i++){
-//         printf(t[i]);
-//     }
-//     while(!is_empty_q(q)){
-//         Process p = dequeue(q);
-//         printf("%s arrives at %d \n",p.processName , p.arrivalTime);
-//     }
-//     return 0;
-// }
-
-
+}

build/algorithms/nonpreemptive_priority

@@ -4,9 +4,6 @@
 #include <string.h>
 #include "../utils/process.h"
 
-// This C program will be :
-// 1- parsing the processes file
-// 2- Generate a static table of a convenient format of the Process details
 
 struct processesTable {
     int processesNumber;
@@ -20,12 +17,10 @@ Process* getTableOfProcesses(const char* file_path);
 void freeProcesses();
 
 int getNbProcesses(const char* file_path) {
-    // if(processesTable.processesNumber != -1) return processesTable.processesNumber;
     FILE *fPointer= fopen(file_path,"r");
     char content[255];
 
     if (fPointer != NULL ) {
-        //Getting the number of processes
         fgets(content,255,fPointer);
         return processesTable.processesNumber = atoi(content);
     }
@@ -37,17 +32,14 @@ int getNbProcesses(const char* file_path) {
 }
 
 
-//The function that tokenizes a string and return a Process struct.
 Process tokenize (char ch[255],char del[]) {
     Process result;
     ch[strcspn(ch, "\n")] = '\0';
 
     char *token;
 
-    //an integer to determine which Process Attribute we are parsing;
     int nb=1;
 
-    // Tokenize the string using strtok
     token = strtok(ch, del);
 
     while (token != NULL) {
@@ -72,28 +64,21 @@ Process tokenize (char ch[255],char del[]) {
 
 
 Process *getTableOfProcesses(const char* file_path) {
-    // if(processesTable.processes != NULL) return processesTable.processes;
-
-    //Choosing the seperator character 
     char sep[] = ";";
 
-    //The size of the processes table
     int sizeTable;
     int i=0;
 
     FILE *fPointer= fopen(file_path,"r");
     char content[255];
 
     if (fPointer != NULL ) {
-            //Getting the number of processes
             fgets(content,255,fPointer);
             sizeTable = atoi(content);
             Process* processes = (Process*)malloc(sizeTable * sizeof(Process));
-            //printf("Size of the table is : %d \n",sizeTable);
 
             while(!feof(fPointer) && i < sizeTable){
                 fgets(content,255,fPointer);
-                // tokenize(content, sep, &processes[i]);
                 processes[i]=tokenize(content,sep);
                 i++;
             }