Total members 11791 |It is currently Sun Aug 18, 2019 12:23 am Login / Join Codemiles

Java

C/C++

PHP

C#

HTML

CSS

ASP

Javascript

JQuery

AJAX

XSD

Python

Matlab

R Scripts

Weka





This is A queuing System Simulator program that simulate the system that support services for more than one customer(Queue) for some time depending on randamization (Good Simulator).

cpp code
#include<iostream>
#include <cmath>
#include "lcgrand.h"
using namespace std;

/////////////////////////////////////////////////////////////////////////
const int Queu_Limit=100;
const int BUSY=1;
const int IDLE=0;

int
choice,
Num_Completed_Customers, //Number of Completed Customers
Number_of_Events, //Number of Events 1.Arriving 2.Completion
Number_in_Queue, //Number of Customers In Queue
Server_Status; //Server Status ( Idle , Busy )

double
End_Time,
Type_Next_Event,
Mean_interArrival_Time,
Mean_service_Time,
Clock,
Time_Arrival[Queu_Limit + 1],
Service_Time[Queu_Limit + 1],
Next_Arrival_Time,
Next_Completion_Time,
Next_Service_Time,
Total_Flow_Time,
Progres_Arrival_Time,
Progres_Completion_Time,
Waiting_Time;


////////////////////////////////////////////////////////////////////////////
// Prototype of the System Function

void initialize();
void Timing();
void Arrival();
void Completition();
float expon(float mean);
void Search_Min(double[],double[]);

////////////////////////////////////////////////////////////////////////////////////
//Main Function

int main()
{

initialize(); // Intialization of the System

cout<<" * Single-server queueing system with fixed run *\n";

cout<<" _________________________________________________"<<endl;

cout<<"\n 1.First In First Out"<<endl;

cout<<" 2.Minimum Processing Time"<<endl<<endl;

do
{
cout<<"\tEnter your Policy: ";

cin>>choice;

}while(choice>2||choice<1);

cout<<"\nMean Inter arrival Time: "<<Mean_interArrival_Time;

cout<<"\nMean Service Time: "<<Mean_service_Time<<endl;

cout<<"The End of Simulation Time: "<<End_Time<<endl<<endl;


while(true)
{

Timing(); // Timing Routine To Determine The Next Event

if(Clock>End_Time)
break;

switch (int(Type_Next_Event))
{

case 1:
Arrival();
break;

case 2:
Completition();
break;
}
}

// Print Summary Statistics.

cout<<"\nTotal Flow Time: "<<Total_Flow_Time;

cout<<"\nTotal Waiting Time in Queue: "<<Waiting_Time;

cout<<"\nAverage Waiting Time in Queue: "<<Waiting_Time / Num_Completed_Customers;

cout<<"\nAverage Flow Time: "<<Total_Flow_Time / Num_Completed_Customers;

cout<<"\nNumber of Completed Customers: "<<Num_Completed_Customers;

cout<<"\nAverage Number of Customers In System / Unit Time: "<<Num_Completed_Customers / Clock<<endl<<endl;

return 0;
}

//////////////////////////////////////////////////////////////////////////////
//Intialization Function

void initialize()
{

Number_of_Events = 2; // Arrival , Completion

Mean_interArrival_Time=1.0;

Mean_service_Time=0.5;

End_Time=100.0;

Clock = 0.0;

Server_Status = IDLE;

Number_in_Queue = 0;

Num_Completed_Customers = 0;

Total_Flow_Time = 0.0;

Waiting_Time = 0.0;

Next_Arrival_Time = Clock + expon(Mean_interArrival_Time);//Arriving

Next_Service_Time = expon(Mean_service_Time);

Next_Completion_Time = 1.0e+10; // Completing Guarantening that the first event is arriving

Progres_Arrival_Time=0.0;

Progres_Completion_Time = 0.0;
}
//////////////////////////////////////////////////////////////////////////////
// Timing Routine Function

void Timing()
{
Type_Next_Event = 0;

if(Next_Arrival_Time < Next_Completion_Time)
{

Type_Next_Event = 1;

Clock=Next_Arrival_Time;

}

else
{
Type_Next_Event = 2;

Clock = Next_Completion_Time;

}

if (Type_Next_Event == 0)
{
cout<<"\nEvent List Empty at Time: "<<Clock;

exit(1);
}

}

////////////////////////////////////////////////////////////////////////////
// Arriving Customer function

void Arrival()
{
if (Server_Status == BUSY)
{
++Number_in_Queue;

if (Number_in_Queue > Queu_Limit)
{
cout<<"\nOverflow of the array time_arrival at";

cout<<"time: "<<Clock;

exit(2);
}

Time_Arrival[Number_in_Queue] = Clock;

Service_Time[Number_in_Queue] = Next_Service_Time;

}

else
{
Server_Status = BUSY;

Next_Completion_Time = Clock + Next_Service_Time;

Progres_Arrival_Time = Next_Arrival_Time;

Progres_Completion_Time = Next_Completion_Time;

}

Next_Arrival_Time = Clock + expon(Mean_interArrival_Time);

Next_Service_Time = expon(Mean_service_Time);


}
/////////////////////////////////////////////////////////////////////////////
// Completion Customer Function

void Completition()
{

double Delay;

++Num_Completed_Customers;

Total_Flow_Time+= ( Progres_Completion_Time - Progres_Arrival_Time );


if (Number_in_Queue == 0)
{
Server_Status= IDLE;

Next_Completion_Time = 1.0e+10; // High Value
}

else
{

if(choice==2)
Search_Min(Time_Arrival,Service_Time); // Minimum Processing Time

Delay= Clock - Time_Arrival[1];

Waiting_Time+= Delay;

Next_Completion_Time = Clock + Service_Time[1];

Progres_Arrival_Time = Time_Arrival[1];

Progres_Completion_Time = Next_Completion_Time;

--Number_in_Queue;

for (int i=1;i<=Number_in_Queue;i++)
{
Time_Arrival[i] = Time_Arrival[i + 1];

Service_Time[i] = Service_Time[i + 1];
}

}
}

/////////////////////////////////////////////////////////////////////////
//Sort Functtion
void Search_Min(double A_time[],double S_time[])
{
int Min=1;

double temp;

for(int i=1;i<Number_in_Queue;i++)
if(S_time[Min]>S_time[i+1])
Min=i+1;

temp=S_time[1];
S_time[1]=S_time[Min];
S_time[Min]=temp;

temp=A_time[1];
A_time[1]=A_time[Min];
A_time[Min]=temp;

}

///////////////////////////////////////////////////////////////////////////
// Generate The Rondom Number

float expon(float mean)
{
return (-mean * log(lcgrand(1)));
}


lcgrand.h:
cpp code
float lcgrand(int stream);

/* Prime modulus multiplicative linear congruential generator
Z[i] = (630360016 * Z[i-1]) (mod(pow(2,31) - 1)), based on Marse and Roberts'
portable FORTRAN random-number generator UNIRAN. Multiple (100) streams are
supported, with seeds spaced 100,000 apart. Throughout, input argument
"stream" must be an int giving the desired stream number. The header file
lcgrand.h must be included in the calling program (#include "lcgrand.h")
before using these functions.

Usage: (Three functions)

1. To obtain the next U(0,1) random number from stream "stream," execute
u = lcgrand(stream);
where lcgrand is a float function. The float variable u will contain the
next random number.

2. To set the seed for stream "stream" to a desired value zset, execute
lcgrandst(zset, stream);
where lcgrandst is a void function and zset must be a long set to the
desired seed, a number between 1 and 2147483646 (inclusive). Default
seeds for all 100 streams are given in the code.

3. To get the current (most recently used) integer in the sequence being
generated for stream "stream" into the long variable zget, execute
zget = lcgrandgt(stream);
where lcgrandgt is a long function. */

/* Define the constants. */

#define MODLUS 2147483647
#define MULT1 24112
#define MULT2 26143

/* Set the default seeds for all 100 streams. */

static long zrng[] =
{ 1,
1973272912, 281629770, 20006270,1280689831,2096730329,1933576050,
913566091, 246780520,1363774876, 604901985,1511192140,1259851944,
824064364, 150493284, 242708531, 75253171,1964472944,1202299975,
233217322,1911216000, 726370533, 403498145, 993232223,1103205531,
762430696,1922803170,1385516923, 76271663, 413682397, 726466604,
336157058,1432650381,1120463904, 595778810, 877722890,1046574445,
68911991,2088367019, 748545416, 622401386,2122378830, 640690903,
1774806513,2132545692,2079249579, 78130110, 852776735,1187867272,
1351423507,1645973084,1997049139, 922510944,2045512870, 898585771,
243649545,1004818771, 773686062, 403188473, 372279877,1901633463,
498067494,2087759558, 493157915, 597104727,1530940798,1814496276,
536444882,1663153658, 855503735, 67784357,1432404475, 619691088,
119025595, 880802310, 176192644,1116780070, 277854671,1366580350,
1142483975,2026948561,1053920743, 786262391,1792203830,1494667770,
1923011392,1433700034,1244184613,1147297105, 539712780,1545929719,
190641742,1645390429, 264907697, 620389253,1502074852, 927711160,
364849192,2049576050, 638580085, 547070247 };

/* Generate the next random number. */

float lcgrand(int stream)
{
long zi, lowprd, hi31;

zi = zrng[stream];
lowprd = (zi & 65535) * MULT1;
hi31 = (zi >> 16) * MULT1 + (lowprd >> 16);
zi = ((lowprd & 65535) - MODLUS) +
((hi31 & 32767) << 16) + (hi31 >> 15);
if (zi < 0) zi += MODLUS;
lowprd = (zi & 65535) * MULT2;
hi31 = (zi >> 16) * MULT2 + (lowprd >> 16);
zi = ((lowprd & 65535) - MODLUS) +
((hi31 & 32767) << 16) + (hi31 >> 15);
if (zi < 0) zi += MODLUS;
zrng[stream] = zi;
return (zi >> 7 | 1) / 16777216.0;
}




_________________
Please recommend my post if you found it helpful


Author:
Beginner
User avatar Posts: 109
Have thanks: 5 time

updated.


Author:
Mastermind
User avatar Posts: 2707
Have thanks: 74 time
Post new topic Reply to topic  [ 2 posts ] 

  Related Posts  to : Queuing System Simulator (C++)
 Bar Simulator in Java     -  
 Fixed Quantity Inventory model Simulator (C++)     -  
 Java code for DTN Protocol NECTAR evaluation-one simulator     -  
 Write to system log     -  
 Own an antivirus system in C#     -  
 System.currentTimeMillis as Id     -  
 The operating system using PHP     -  
 Full Encription System (DES-AES,RSA and more)     -  
 Abbreviations System java     -  
 php user registration system     -  



Topic Tags

C++ Projects






Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
All copyrights reserved to codemiles.com 2007-2011
mileX v1.0 designed by codemiles team
Codemiles.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to Amazon.com