Let us say, we have two queues, regular queue and special queue in a super-marke

Question

Let us say, we have two queues, regular queue and special queue in a super-market. Let us say, when server becomes available, (s)he services the next person in the special queue, if one exists in that queue. Otherwise, (s)he services the next person in the regular queue. Model this scenario, make the necessary code changes, find waiting time for both regular customers and special customers for various special customer% values as mentioned below and create an Excel chart using that data. Use the following configuration: # of servers: 1, inter-arrival time: 5 and service time: 4. Run each simulation for 10,000 time units.

- 10% of incoming customers are special customers
- 20% …
- 30%
- 40%
- 50%
- 100%
- 0%

I have the code for a single queue supermarket. But I'm stuck on where to modify to add the second special queue. Here's the simulationImp.cpp file:



#include <iostream>
#include <string>
#include <cstdlib>

#include "Simulation.h"
#include "queueAsArray.h"

using namespace std;


//*************** customerType ************

customerType::customerType(int customerN, int arrvTime, int wTime,
int tTime)
{
setCustomerInfo(customerN, arrvTime, wTime, tTime);
}

int customerType::getWaitingTime() const
{
return waitingTime;
}

void customerType::incrementWaitingTime()
{
waitingTime++;
}

void customerType::setWaitingTime(int time)
{
waitingTime = time;
}

void customerType::setCustomerInfo(int customerN, int arrvTime,
int wTime, int tTime)
{
customerNumber = customerN;
arrivalTime = arrvTime;
waitingTime = wTime;
transactionTime = tTime;
}

int customerType::getArrivalTime()
{
return arrivalTime;
}

int customerType::getTransactionTime()
{
return transactionTime;
}

int customerType::getCustomerNumber()
{
return customerNumber;
}
//**************** serverType **********

serverType::serverType()
{
status = "free";
transactionTime = 0;
}

bool serverType::isFree() const
{
return (status == "free");
}

void serverType::setBusy()
{
status = "busy";
}

void serverType::setFree()
{
status = "free";
}

void serverType::setTransactionTime(int t)
{
transactionTime = t;
}

void serverType::setTransactionTime()
{
int time;

time = currentCustomer.getTransactionTime();

transactionTime = time;
}


void serverType::decreaseTransactionTime()
{
transactionTime--;
}

int serverType::getRemainingTransactionTime()
{
return transactionTime;
}

void serverType::setCurrentCustomer(customerType cCustomer)
{
currentCustomer = cCustomer;
}

int serverType::getCurrentCustomerNumber()
{
return currentCustomer.getCustomerNumber();
}

int serverType::getCurrentCustomerArrivalTime()
{
return currentCustomer.getArrivalTime();
}

int serverType::getCurrentCustomerWaitingTime()
{
return currentCustomer.getWaitingTime();
}

int serverType::getCurrentCustomerTransactionTime()
{
return currentCustomer.getTransactionTime();
}


//************** serverListType ***********

serverListType::serverListType(int num)
{
numOfServers = num;
servers = new serverType[num];
}

serverListType::~serverListType()
{
delete [] servers;
}

int serverListType::getFreeServerID()
{
int serverID = -1;

int i;

for(i = 0; i < numOfServers; i++)
if(servers[i].isFree())
{
serverID = i;
break;
}
return serverID;
}

int serverListType::getNumberOfBusyServers()
{
int busyServers = 0;

int i;

for(i = 0; i < numOfServers; i++)
if(!servers[i].isFree())
busyServers++;
return busyServers;
}

void serverListType::setServerBusy(int serverID,
customerType cCustomer,
int tTime)
{
servers[serverID].setBusy();
servers[serverID].setTransactionTime(tTime);
servers[serverID].setCurrentCustomer(cCustomer);
}

void serverListType::setServerBusy(int serverID,
customerType cCustomer)
{
int time;

time = cCustomer.getTransactionTime();

servers[serverID].setBusy();
servers[serverID].setTransactionTime(time);
servers[serverID].setCurrentCustomer(cCustomer);
}

void serverListType::updateServers()
{
int i;

for(i = 0; i < numOfServers; i++)
if(!servers[i].isFree())
{
servers[i].decreaseTransactionTime();
if(servers[i].getRemainingTransactionTime() == 0)
{
cout<<"Server No: "<<(i+1)<<" Customer number "
<<servers[i].getCurrentCustomerNumber()
<<" departed at "<<endl
<<" clock unit "
<<servers[i].getCurrentCustomerArrivalTime()
+ servers[i].getCurrentCustomerWaitingTime()
+ servers[i].getCurrentCustomerTransactionTime()
<<endl;
servers[i].setFree();
}
}
}

void serverListType::updateServers(ofstream& outFile)
{
int i;

for(i = 0; i < numOfServers; i++)
if(!servers[i].isFree())
{
servers[i].decreaseTransactionTime();
if(servers[i].getRemainingTransactionTime() == 0)
{
outFile<<"Server No: "<<(i+1)<<" Customer number "
<<servers[i].getCurrentCustomerNumber()
<<" departed at "<<endl
<<" clock unit "
<<servers[i].getCurrentCustomerArrivalTime()
+ servers[i].getCurrentCustomerWaitingTime()
+ servers[i].getCurrentCustomerTransactionTime()
<<endl;
servers[i].setFree();
}
}
}

//*************** waitQueue ************


waitingCustomerQueueType::waitingCustomerQueueType(int size)
:queueType<customerType>(size)
{
}

waitingCustomerQueueType::~waitingCustomerQueueType()
{
}

void waitingCustomerQueueType::updateWaitingQueue()
{
customerType cust;

cust.setWaitingTime(-1);
int wTime = 0;

addQueue(cust);

while(wTime != -1)
{
cust = front();
deleteQueue();

wTime = cust.getWaitingTime();
if(wTime == -1)
break;
cust.incrementWaitingTime();
addQueue(cust);
}
}

Explanation / Answer

#include
#include
#include
#include

#include "Simulation.h"
#include "queueAsArray.h"

using namespace std;

void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival);
bool isCustomerArrived(double arvTimeDiff);

void generateStatistics(serverListType& serverList,
waitingCustomerQueueType& CQueue,
int numOfCustArrived,
int waitTimeServedCustomers);
void runSimulation();

int main()
{
runSimulation();

system("pause");
return 0;
}

void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival)
{
cout<<"Enter the simulation time: "< cin>>sTime;
cout<
cout<<"Enter the number of servers: "< cin>>numOfServers;
cout<
cout<<"Enter the transaction time: "< cin>>transTime;
cout<
cout<<"Enter the time between customer arrivals: "< cin>>tBetweenCArrival;
cout<}

bool isCustomerArrived(double arvTimeDiff)
{
double value;

value = static_cast (rand()) / static_cast(RAND_MAX);

return (value > exp(- 1.0/arvTimeDiff));
}

void runSimulation()
{

int simulationTime;
int numberOfServers;
int transactionTime;
int timeBetweenCustomerArrival;

waitingCustomerQueueType customerQueue;

customerType customer;

int custNumber = 0;

int totalWaitTimeServedCustomers = 0;
int totalWaitTime = 0;
int numberOfCustomersServed = 0;
int customersLeftInServers = 0;
int clock = 0;
int serverID;

setSimulationParameters(simulationTime, numberOfServers,
transactionTime, timeBetweenCustomerArrival);

serverListType serverList(numberOfServers);

for(clock = 1; clock <= simulationTime; clock++)
{
serverList.updateServers();

if(!customerQueue.isEmptyQueue())
customerQueue.updateWaitingQueue();

if(isCustomerArrived(timeBetweenCustomerArrival))
{
custNumber++;
customer.setCustomerInfo(custNumber,clock,0,
transactionTime);
customerQueue.addQueue(customer);
cout<<"Customer number "< <<" arrived at time unit "< }

serverID = serverList.getFreeServerID();
if(serverID != -1 && !customerQueue.isEmptyQueue())
{
customer = customerQueue.front();
customerQueue.deleteQueue();
totalWaitTimeServedCustomers = totalWaitTimeServedCustomers
+ customer.getWaitingTime();
serverList.setServerBusy(serverID, customer);
}
}

cout<
cout<<"Simulation ran for "< <<" time units"< cout<<"Number of servers: "< cout<<"Average transaction time: "
< cout<<"Average arrival time difference between customers: "
<
generateStatistics(serverList, customerQueue,
custNumber, totalWaitTimeServedCustomers);
}

void generateStatistics(serverListType& serverList,
waitingCustomerQueueType& CQueue,
int numOfCustArrived,
int waitTimeServedCustomers)
{
int customersLeftInQueue = 0;

int totalWaitTime = waitTimeServedCustomers;

customerType customer;

while(!CQueue.isEmptyQueue())
{
customer = CQueue.front();
CQueue.deleteQueue();
totalWaitTime = totalWaitTime + customer.getWaitingTime();
customersLeftInQueue++;
}

//Find number of customers left in servers
int customersLeftInServers = serverList.getNumberOfBusyServers();
//Find number of customers completely served
int numberOfCustomersServed = numOfCustArrived - customersLeftInServers -
customersLeftInQueue;

double averageWaitTime = 0;

cout<<"Total wait time: "< cout<<"Number of customers who completed a transaction: "
< cout<<"Number of customers left in the servers: "
< cout<<"Number of customers left in the queue: "< <
if(numOfCustArrived > 0) // If number of customers arrived is > 0
averageWaitTime = (static_cast(totalWaitTime)) / numOfCustArrived;

cout< cout< cout<<"Average wait time: "< cout<< endl;
cout<<"************** END SIMULATION *************"< cout<< endl;

Related Questions

Navigate

• Browse (All)
• Browse L
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.