Assignment question, submitted solution and professor's solution

ass2.c

@@ -0,0 +1,725 @@
+/* License: AGPLv3 or later. https://www.gnu.org/licenses/licenses.html
+ * 
+ * Assignment 2 - Discrete Simulation
+ * Manish
+ * Student Login: *****
+ * 
+ * Compile it as:
+ * gcc -Wall -std=c11 -o ass2 ass2.c
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum category
+{
+    TOURIST = 0,
+    BUSINESS = 1,
+};
+
+typedef struct event
+{
+    // 0 for arrival 1+ for unique server ids
+    int id;
+    double time;
+    int class; // 0 for tourist and 1 for business
+    // service time for customer arrival and busy time for servers
+    double duration;
+} event;
+
+// customers_queue is dynamically scaled
+typedef struct customers_queue
+{
+    int first;
+    int next;
+    int size; // memory in use
+    int capacity; // memory allocated to queue
+    event* queue;
+} customers_queue;
+
+typedef struct id_busy
+{
+    int id; // unique server ID
+    double busy; // time server was busy
+} id_busy;
+
+// servers_queue are dynamically infantilized than not re-scaled
+typedef struct servers_queue
+{
+    int first;
+    int next;
+    int available;
+    int capacity;
+    id_busy* queue;
+} servers_queue;
+
+// Used as temporary storages for processing
+event arrival;
+event customer_in_queue;
+id_busy server;
+
+// Dynamically initialized than not re-scaled
+event* heap;
+int heap_size = 0;
+
+customers_queue business_q;
+customers_queue tourist_q;
+
+servers_queue business_servers;
+servers_queue tourist_servers;
+
+bool dummy_arrival(const event* arrival);
+int read_next_arrival(FILE* file, event* e);
+void read_back_next_arrival(FILE* file, event* e);
+void read_front_next_arrival(FILE* file, event* e);
+void shiftdown(int i);
+void shiftup(int i);
+void swap(event* i, event* j);
+
+event dequeue_customers(customers_queue* q);
+void enqueue_customers(customers_queue* q, const event* e);
+/* Used for sorting servers by id before printing output
+ * Heap sort is used since we do not need stable sorting as all ids are unique
+ * and heap sort sorts in place therefore require less memory than merge sort
+ */
+void server_shiftdown(servers_queue* heap, int i);
+void server_makeheap(servers_queue* q);
+void server_sort(servers_queue* q);
+void server_swap(id_busy* i, id_busy* j);
+
+id_busy dequeue_servers(servers_queue* q);
+void enqueue_servers(servers_queue* q, const id_busy* s);
+void free_server(servers_queue* q);
+
+int max(int i, int j);
+
+int main(void)
+{
+    printf("Enter file name: ");
+    char filename[257];
+    // Assuming filename/file path won't be longer than 256 characters
+    scanf("%256s", filename);
+
+    FILE* file = fopen(filename, "r");
+    if (!file)
+    {
+        perror(filename);
+        exit(EXIT_FAILURE);
+    }
+
+    for (int pass = 1; pass <= 2; pass++)
+    {
+        rewind(file); // move file pointer back to beginning
+
+        // Read no. of business and & tourist servers
+        fscanf(
+            file,
+            "%d %d",
+            &business_servers.available,
+            &tourist_servers.available);
+
+        arrival.id = 0;
+        if (read_next_arrival(file, &arrival) == EOF)
+        {
+            fprintf(stderr, "Error in reading 1st arrival. Exiting\n");
+            return 1;
+        }
+
+        // INITIALIZE/RESET VARIABLES
+        heap = malloc(
+            sizeof(event)
+            * (1 + business_servers.available + tourist_servers.available));
+
+        business_servers.first = 0;
+        business_servers.next = 0;
+        business_servers.capacity = business_servers.available;
+        business_servers.queue = malloc(
+            sizeof(event) * business_servers.capacity);
+
+        tourist_servers.first = 0;
+        tourist_servers.next = 0;
+        tourist_servers.capacity = tourist_servers.available;
+        tourist_servers.queue = malloc(
+            sizeof(event) * tourist_servers.capacity);
+
+        if (heap == NULL
+            || business_servers.queue == NULL
+            || tourist_servers.queue == NULL)
+        {
+            fprintf(
+                stderr,
+                "Failed to allocate memory for all data structures\n");
+            return 1;
+        }
+
+        business_q.first = 0;
+        business_q.next = 0;
+        business_q.size = 0;
+        business_q.capacity = 0;
+        // Memory is allocated only if needed
+        business_q.queue = NULL;
+        tourist_q.first = 0;
+        tourist_q.next = 0;
+        tourist_q.size = 0;
+        tourist_q.capacity = 0;
+        // Memory is allocated only if needed
+        tourist_q.queue = NULL;
+
+        for (int i = 0; i < business_servers.capacity; i++)
+        {
+            business_servers.queue[i].id = i + 1;
+            business_servers.queue[i].busy = 0;
+        }
+        for (int i = 0; i < tourist_servers.capacity; i++)
+        {
+            tourist_servers.queue[i].id = i + business_servers.capacity + 1;
+            tourist_servers.queue[i].busy = 0;
+        }
+
+        heap[heap_size++] = arrival;
+
+        // Statistics Variables
+        double time = 0;
+
+        int max_q_length = 0;
+
+        int no_of_business_customers = 0;
+        double business_service_time = 0;
+        double business_q_time = 0;
+        int max_business_q_length = 0;
+
+        int no_of_tourist_customers = 0;
+        double tourist_service_time = 0;
+        double tourist_q_time = 0;
+        int max_tourist_q_length = 0;
+
+        // MAIN LOOP
+        while (heap_size > 0)
+        {
+            time = heap[0].time;
+            if (heap[0].id == 0) // Arrival
+            {
+                if (heap[0].class == TOURIST)
+                {
+                    no_of_tourist_customers++;
+                    tourist_service_time += heap[0].duration;
+                    if (tourist_servers.available)
+                    {
+                        // Time when server will finish serving
+                        heap[0].time += heap[0].duration;
+                        server = dequeue_servers(&tourist_servers);
+                        heap[0].id = server.id;
+                        // Total busy time of server
+                        heap[0].duration += server.busy;
+                        shiftdown(0);
+                        read_back_next_arrival(file, &arrival);
+                    }
+                    /* Available/free business servers will serve tourist
+                     * customer in 2nd pass if no business customer in q
+                     * NOTE: free server implies business_q is empty
+                     */
+                    else if (pass == 2 && business_servers.available)
+                    {
+                        // Time when server will finish serving
+                        heap[0].time += heap[0].duration;
+                        server = dequeue_servers(&business_servers);
+                        heap[0].id = server.id;
+                        // Total busy time of server
+                        heap[0].duration += server.busy;
+                        shiftdown(0);
+                        read_back_next_arrival(file, &arrival);
+                    }
+                    // All relevant servers busy, add to tourist customers queue
+                    else
+                    {
+                        enqueue_customers(&tourist_q, &heap[0]);
+                        max_tourist_q_length = max(
+                            max_tourist_q_length, tourist_q.size);
+                        max_q_length = max(
+                            max_q_length, tourist_q.size + business_q.size);
+                        read_front_next_arrival(file, &arrival);
+                    }
+                }
+                else if (heap[0].class == BUSINESS)
+                {
+                    no_of_business_customers++;
+                    business_service_time += heap[0].duration;
+                    if (business_servers.available)
+                    {
+                        // Time when server will finish serving
+                        heap[0].time += heap[0].duration;
+                        server = dequeue_servers(&business_servers);
+                        heap[0].id = server.id;
+                        // Total busy time of server
+                        heap[0].duration += server.busy;
+                        shiftdown(0);
+                        read_back_next_arrival(file, &arrival);
+                    }
+                    // All relevant servers busy, add to tourist customers queue
+                    else
+                    {
+                        enqueue_customers(&business_q, &heap[0]);
+                        max_business_q_length = max(
+                            max_business_q_length, business_q.size);
+                        max_q_length = max(
+                            max_q_length, tourist_q.size + business_q.size);
+                        read_front_next_arrival(file, &arrival);
+                    }
+                }
+                else
+                {
+                    fprintf(
+                        stderr,
+                        "Impossible scenario: Event = Arrival but Class = %d",
+                        heap[0].class);
+                    exit(1);
+                }
+            }
+            else if ( // Business server finished serving
+                heap[0].id >= 1 && heap[0].id <= business_servers.capacity)
+            {
+                if (business_q.size > 0) // Customers waiting in queue
+                {
+                    customer_in_queue = dequeue_customers(&business_q);
+                    business_q_time += time - customer_in_queue.time;
+                    // Time when server will finish serving
+                    heap[0].time += customer_in_queue.duration;
+                    // Total busy time of server
+                    heap[0].duration += customer_in_queue.duration;
+                    shiftdown(0);
+                }
+                /* Freed business servers will serve tourist customer
+                 * 2nd pass if no business customer in q
+                 */
+                else if (pass == 2 && tourist_q.size > 0)
+                {
+                    customer_in_queue = dequeue_customers(&tourist_q);
+                    // Time when server will finish serving
+                    tourist_q_time += time - customer_in_queue.time;
+                    heap[0].time += customer_in_queue.duration;
+                    // Total busy time of server
+                    heap[0].duration += customer_in_queue.duration;
+                    shiftdown(0);
+                }
+                else // free server at heap[0] and enqueue to business_servers
+                    free_server(&business_servers);
+            }
+            else if (
+                heap[0].id > business_servers.capacity
+                && heap[0].id <= (business_servers.capacity
+                                  + tourist_servers.capacity))
+            {
+                if (tourist_q.size > 0) // Customers waiting in queue
+                {
+                    customer_in_queue = dequeue_customers(&tourist_q);
+                    // Time when server will finish serving
+                    tourist_q_time += time - customer_in_queue.time;
+                    heap[0].time += customer_in_queue.duration;
+                    // Total busy time of server
+                    heap[0].duration += customer_in_queue.duration;
+                    shiftdown(0);
+                }
+                else // free server at heap[0] and enqueue to tourist_servers
+                    free_server(&tourist_servers);
+            }
+            else
+            {
+                fprintf(
+                    stderr,
+                    "Impossible scenario Heap[0].id = %d is out of range\n",
+                    heap[0].id);
+                exit(1);
+            }
+        }
+
+        // COMPUTE REMAINING STATISTICS FROM TRACKED STATISTICS
+        int total_customers = (
+            no_of_business_customers + no_of_tourist_customers);
+        double avg_q_time = (
+            (business_q_time + tourist_q_time) / total_customers);
+        double avg_q_length = ((business_q_time + tourist_q_time) / time);
+        double avg_service_time = (
+            (business_service_time
+            + business_q_time
+            + tourist_q_time
+            + tourist_service_time)
+            / total_customers);
+
+        double avg_business_q_time = (
+            business_q_time / no_of_business_customers);
+        double avg_business_q_length = (business_q_time / time);
+        double avg_business_service_time = (
+            (business_service_time + business_q_time)
+            / no_of_business_customers);
+
+        double avg_tourist_q_time = (tourist_q_time / no_of_tourist_customers);
+        double avg_tourist_q_length = (tourist_q_time / time);
+        double avg_tourist_service_time = (
+            (tourist_service_time + tourist_q_time) / no_of_tourist_customers);
+
+        // SIMULATION OUTPUT/PRINT SIMULATION STATISTICS
+        char pass_title[80];
+        if (pass == 1)
+            strncpy(
+                pass_title,
+                "Pass 1: Business servers exclusively serve business class",
+                80);
+        else if (pass == 2)
+            strncpy(
+                pass_title,
+                "Pass 2: Idle business servers may serve tourist class",
+                80);
+
+        printf(
+            "%s\n\n"
+            "%-50s % 5d\n"
+            "%-50s % 8.2lf\n\n"
+            "%s\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 5d\n\n"
+            "%s\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 5d\n\n"
+            "%s\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 8.2lf\n"
+            "%-50s % 5d\n"
+            "\n",
+            pass_title,
+            "Number of people served: ",
+            total_customers,
+            "Time last service is completed: ",
+            time,
+            "Business class customers: ",
+            "Average total service time: ",
+            avg_business_service_time,
+            "Average total time in queue: ",
+            avg_business_q_time,
+            "Ave length of queue: ",
+            avg_business_q_length,
+            "Maximum number queued: ",
+            max_business_q_length,
+            "Tourist class customers:",
+            "Average total service time: ",
+            avg_tourist_service_time,
+            "Average total time in queue: ",
+            avg_tourist_q_time,
+            "Ave length of queue: ",
+            avg_tourist_q_length,
+            "Maximum number queued: ",
+            max_tourist_q_length,
+            "All customers:",
+            "Average total service time: ",
+            avg_service_time,
+            "Average total time in queue: ",
+            avg_q_time,
+            "Ave length of queue: ",
+            avg_q_length,
+            "Maximum number queued: ",
+            max_q_length);
+
+        // Sort servers by ID before printing
+        server_sort(&business_servers);
+        printf("Business class servers:\n");
+        for (int i = 0; i < business_servers.capacity; i++)
+            printf(
+                "Total idle time for business class server %3d: %13.2lf\n",
+                business_servers.queue[i].id,
+                time - business_servers.queue[i].busy);
+
+        // Sort servers by ID before printing
+        server_sort(&tourist_servers);
+        printf("\nTourist class servers:\n");
+        for (int i = 0; i < tourist_servers.capacity; i++)
+            printf(
+                "Total idle time for tourist class server %3d: %14.2lf\n",
+                tourist_servers.queue[i].id - business_servers.capacity,
+                time - tourist_servers.queue[i].busy);
+
+        printf("\n\n\n");
+
+        // FREE DYNAMICALLY ALLOCATED MEMORY
+        free(heap);
+        free(business_servers.queue);
+        free(tourist_servers.queue);
+        free(business_q.queue);
+        free(tourist_q.queue);
+    }
+
+    fclose(file);
+    return 0;
+}
+
+bool dummy_arrival(const event* arrival)
+{
+    return (
+        arrival->time == 0 && arrival->duration == 0);
+}
+
+int read_next_arrival(FILE* file, event* e)
+{
+    return fscanf(file, "%lf %d %lf", &e->time, &e->class, &e->duration);
+}
+
+void read_back_next_arrival(FILE* file, event* e)
+{
+    // WARNING: Potential BUG: dummy_arrival(e) gets old arrival or new?
+    if (fscanf(file, "%lf %d %lf", &e->time, &e->class, &e->duration) != EOF
+        && dummy_arrival(e) == false)
+    {
+        heap[heap_size++] = *e;
+        shiftup(heap_size - 1);
+    }
+}
+
+void read_front_next_arrival(FILE* file, event* e)
+{
+    if (fscanf(file, "%lf %d %lf", &e->time, &e->class, &e->duration) != EOF
+        && dummy_arrival(e) == false)
+    {
+        heap[0] = *e;
+    }
+    else
+    { // Since dummy arrival or EOF reached, pop heap[0]
+        swap(&heap[0], &heap[--heap_size]);
+    }
+    shiftdown(0);
+}
+
+void shiftdown(int i)
+{
+    int child = (i * 2) + 1; // left child
+    if (child < heap_size) // has at least one child
+    {
+        if (child < heap_size - 1) // has both children
+        {
+            // if right child smaller
+            if (heap[child].time > heap[child + 1].time)
+                child++; // pick right child
+        }
+        if (heap[i].time > heap[child].time)
+        {
+            swap(&heap[i], &heap[child]);
+            shiftdown(child);
+        }
+    }
+}
+
+void shiftup(int i)
+{
+    if (i == 0)
+        return;
+    int parent = (i - 1) / 2;
+    if (heap[parent].time > heap[i].time)
+    {
+        swap(&heap[parent], &heap[i]);
+        shiftup(parent);
+    }
+}
+
+void swap(event* i, event* j)
+{
+    event tmp = *i;
+    *i = *j;
+    *j = tmp;
+}
+
+event dequeue_customers(customers_queue* q)
+{
+    if (q->size-- == 0)
+    {
+        fprintf(
+            stderr,
+            "Impossible scenario: dequeue_customers when queue empty");
+        exit(1);
+    }
+    event customer = q->queue[q->first++];
+    q->first %= q->capacity;
+    if (q->size < q->capacity / 4)
+    {
+        int new_capacity = (q->capacity / 2) + (q->capacity % 2);
+        if (q->size != 0
+            && (q->first >= new_capacity || q->next >= new_capacity))
+        {
+            /* Original queue:
+             * XX--------|-------XXX
+             * OR
+             * --------XX|XXX-------
+             * OR
+             * -----------|-XXXXX----
+             * Where X has some number, - is empty place & | is new_capacity
+             * Than, copy queue to next location and free old space
+             */
+            event* new_q = malloc(sizeof(event) * new_capacity);
+            if (new_q == NULL)
+            {
+                fprintf(
+                    stderr,
+                    "Failed to reallocate memory for customer_queue\n");
+                exit(1);
+            }
+            int j = 0;
+            for (int i = q->first; i != q->next; i = (i + 1) % q->capacity)
+            {
+                new_q[j++] = q->queue[i];
+            }
+            free(q->queue);
+            q->queue = new_q;
+            q->first = 0;
+            q->next = j;
+        }
+        else
+        {
+            q->queue = realloc(q->queue, sizeof(event) * new_capacity);
+            if (q->queue == NULL) // Probably unnecessary since shrinking
+            {
+                fprintf(
+                    stderr, "Failed to reallocate memory for customer_queue\n");
+                exit(1);
+            }
+            if (q->size == 0)
+            {
+                q->first = 0;
+                q->next = 0;
+            }
+        }
+        q->capacity = new_capacity;
+    }
+    return customer;
+}
+
+void enqueue_customers(customers_queue* q, const event* e)
+{
+    if (q->size == q->capacity) // Queue full
+    {
+        // Double queue and adjust pointers
+        // max() for when no space allocated previously i.e. capacity == 0
+        int new_capacity = max(q->capacity * 2, 1);
+        q->queue = realloc(q->queue, sizeof(event) * new_capacity);
+        if (q->queue == NULL)
+        {
+            fprintf(
+                stderr, "Failed to reallocate memory for customer_queue\n");
+            exit(1);
+        }
+        if (q->first != 0)
+        {
+            /* Original queue:
+             * XXX|XXXXXXX
+             * After realloc:
+             * XX|XXXXXXXX----------
+             * After this loop:
+             * XX----------|XXXXXXXX
+             * Where X has some number, - is empty place
+             * and | is q->first pointer
+             */
+            for (int i = q->first; i < q->capacity; i++)
+            {
+                q->queue[i + q->capacity] = q->queue[i];
+            }
+            q->first += q->capacity;
+        }
+        /// MISSING THIS CORNER CASE WAS CAUSE OF A MAJOR BUG
+        else
+            q->next = q->size;
+
+        q->capacity = new_capacity;
+    }
+    q->size++;
+    q->queue[q->next++] = *e;
+    q->next %= q->capacity;
+}
+
+id_busy dequeue_servers(servers_queue* q)
+{
+    if (q->available-- == 0)
+    {
+        fprintf(
+            stderr,
+            "Impossible scenario: dequeue_servers when queue empty");
+        exit(1);
+    }
+    server = q->queue[q->first++];
+    q->first %= q->capacity;
+    return server;
+}
+
+void enqueue_servers(servers_queue* q, const id_busy* s)
+{
+    if (q->available++ == q->capacity)
+    {
+        fprintf(
+            stderr, "Impossible scenario: enqueue_servers when queue full");
+        exit(1);
+    }
+    q->queue[q->next++] = *s;
+    q->next %= q->capacity;
+}
+
+void free_server(servers_queue* q)
+{
+    server.id = heap[0].id;
+    server.busy = heap[0].duration;
+    enqueue_servers(q, &server);
+    heap[0] = heap[--heap_size];
+    shiftdown(0);
+}
+
+int max(int i, int j)
+{
+    return (i > j) ? i : j;
+}
+
+void server_shiftdown(servers_queue* heap, int i)
+{
+    int child = (i * 2) + 1; // left child
+    if (child < heap->available) // has at least one child
+    {
+        if (child < heap->available - 1) // has both children
+        {
+            // if right child smaller
+            if (heap->queue[child].id < heap->queue[child + 1].id)
+                child++; // pick right child
+        }
+        if (heap->queue[i].id < heap->queue[child].id)
+        {
+            server_swap(&heap->queue[child], &heap->queue[i]);
+            server_shiftdown(heap, child);
+        }
+    }
+}
+
+void server_makeheap(servers_queue* q)
+{
+    // Shiftdown Method
+    int shiftdowns_required = (q->capacity / 2)-1;
+    for (int i = shiftdowns_required; i >= 0; i--)
+    {
+        server_shiftdown(q, i);
+    }
+}
+
+void server_sort(servers_queue* q)
+{
+    server_makeheap(q);
+    while(q->available > 0)
+    {
+        server_swap(q->queue, &q->queue[--q->available]);
+        server_shiftdown(q, 0);
+    }
+    q->available = q->capacity;
+}
+
+void server_swap(id_busy* i, id_busy* j)
+{
+    id_busy tmp = *i;
+    *i = *j;
+    *j = tmp;
+}