Question

Write a program that simulates a checkout line at a supermarket. The line is a queue object. Customers (i.e., customer objects) arrive in random integer intervals of from 1 to 4 minutes. Also, each customer is serviced in random integer intervals of from 1 to 4 minutes. Obviously, the rates need to be balanced. If the average arrival rate is larger than the average service rate, the queue will grow infinitely. Even with “balanced” rates, randomness can still cause long lines. Run the supermarket simulation for a 12-hour day (720 minutes), using the following algorithm:

a) Choose a random integer between 1 and 4 to determine the minute at which the first customer arrives

.

b) At the first customer’s arrival time, do the following:

Determine customer’s service time (random integer from 1 to 4).

Begin servicing the customer.

Schedule the arrival time of the next customer (random integer 1 to 4 added to the current time).

c) For each minute of the day, consider the following:

If the next customer arrives, proceed as follows:

Say so.

Enqueue the customer.

Schedule the arrival time of the next customer.

If service was completed for the last customer, do the following:

Say so.

Dequeue next customer to be serviced.

Determine customer’s service completion time (random integer from 1 to 4 added to the current time).

Now run your simulation for 720 minutes and answer each of the following:

a) What is the maximum number of customers in the queue at any time?

b) What is the longest wait any one customer experiences?

c) What happens if the arrival interval is changed from 1 to 4 minutes to 1 to 3 minutes?

Please note that a “minute “is what you define it to be. It could be an iteration etc. (I strongly suggest that it be “one iteration”)

Answer 1

solution;

#include <stdio.h>

#include <stdlib.h>

#include "genlib.h"

#include "strlib.h"

#include "random.h"

#include "queue.h"

#define SimulationTime     720

#define ArrivalProbability    0.1

#define MinServiceTime        1

#define MaxServiceTime       4

typedef struct {

    int customerNumber;

    int arrivalTime;

    int serviceTime;

} *customerT;

typedef struct {

    queueADT queue;

    customerT activeCustomer;

    int time;

    int numCustomers;

    int numServed;

    long totalWaitTime;

    long totalLineLength;

} simDataT;

static bool traceFlag = FALSE;

static void InitializeSimulation(simDataT *sdp);

static void RunSimulation(simDataT *sdp);

static void EnqueueCustomer(simDataT *sdp);

static void ProcessQueue(simDataT *sdp);

static void ServeCustomer(simDataT *sdp);

static void DismissCustomer(simDataT *sdp);

static void ReportResults(simDataT *sdp);

main()

{

    simDataT simData;

    Randomize();

    InitializeSimulation(&simData);

    RunSimulation(&simData);

    ReportResults(&simData);

}

static void InitializeSimulation(simDataT *sdp)

{

    sdp->queue = NewQueue();

    sdp->activeCustomer = NULL;

    sdp->numServed = 0;

    sdp->totalWaitTime = 0;

    sdp->totalLineLength = 0;

}

static void RunSimulation(simDataT *sdp)

{

    for (sdp->time = 0; sdp->time < SimulationTime; sdp->time++) {

        if (RandomChance(ArrivalProbability)) {

            EnqueueCustomer(sdp);

        }

        ProcessQueue(sdp);

    }

}

static void EnqueueCustomer(simDataT *sdp)

{

    customerT c;

    sdp->numCustomers++;

    c = New(customerT);

    c->customerNumber = sdp->numCustomers;

    c->arrivalTime = sdp->time;

    c->serviceTime = RandomInteger(MinServiceTime, MaxServiceTime);

    Enqueue(sdp->queue, c);

    if (traceFlag) {

        printf("%4d: Customer %d arrives and gets in line\n",

               sdp->time, sdp->numCustomers);

    }

}

static void ProcessQueue(simDataT *sdp)

{

    if (sdp->activeCustomer == NULL) {

        if (!QueueIsEmpty(sdp->queue)) {

            ServeCustomer(sdp);

        }

    } else {

        if (sdp->activeCustomer->serviceTime == 0) {

            DismissCustomer(sdp);

        } else {

            sdp->activeCustomer->serviceTime--;

        }

    }

    sdp->totalLineLength += QueueLength(sdp->queue);

}

static void ServeCustomer(simDataT *sdp)

{

    customerT c;

    c = Dequeue(sdp->queue);

    sdp->activeCustomer = c;

    sdp->numServed++;

    sdp->totalWaitTime += (sdp->time - c->arrivalTime);

    if (traceFlag) {

        printf("%4d: Customer %d reaches cashier\n",

               sdp->time, c->customerNumber);

    }

}

static void DismissCustomer(simDataT *sdp)

{

    if (traceFlag) {

        printf("%4d: Customer %d leaves cashier\n",

               sdp->time, sdp->activeCustomer->customerNumber);

    }

    FreeBlock(sdp->activeCustomer);

    sdp->activeCustomer = NULL;

}

static void ReportResults(simDataT *sdp)

{

    printf("Simulation results given the following parameters:\n");

    printf(" SimulationTime:     %4d\n", (int) SimulationTime);

    printf(" ArrivalProbability: %7.2f\n",

                                   (double) ArrivalProbability);

    printf(" MinServiceTime:     %4d\n", (int) MinServiceTime);

    printf(" MaxServiceTime:     %4d\n", (int) MaxServiceTime);

    printf("\n");

    printf("Customers served:     %4d\n", sdp->numServed);

    printf("Average waiting time: %7.2f\n",

           (double) sdp->totalWaitTime / sdp->numServed);

    printf("Average line length: %7.2f\n",

           (double) sdp->totalLineLength / SimulationTime);

}