/*
 * This function checks if there is free terminal
 * and generates arrival if there is free terminal
 */
static void generateArrEvent(int numTerminals)
{
  if((countInfo.terminalPool>0) && (countInfo.terminalPool<=numTerminals))
  {
    Elist.insert(clock + exp_rv(configInfo.arrivalRate),ARR);
    countInfo.terminalPool--;
  }
}
示例#2
0
/// Обновление
  void UpdateEvent (const char* name, ResourceState state)
  {
    EventMap::iterator iter = event_map.find (name);

    if (iter == event_map.end ())
    {
      EventPtr event = EventPtr (new EventDesc (name, state), false);

      EventList::iterator iter = event_list.insert (event_list.end (), event);

      event_map.insert_pair (name, iter);
    }
    else
    {
      EventPtr event = *iter->second;

      if (state == event->state)
        return;

      if (event->state == ResourceState_Ignore)
      {
        event_list.splice (event_list.end (), event_list, iter->second);

        event->state = state;

        return;
      }

      switch (state)
      {
        case ResourceState_Unloaded:
          event->state = ResourceState_Ignore;
          break;
        case ResourceState_Prefetched:
          if (event->state != ResourceState_Unloaded)
            return;

          event_list.splice (event_list.end (), event_list, iter->second);

          event->state = state;          

          break;
        case ResourceState_Loaded:
          if (event->state == ResourceState_Unloaded) event->state = ResourceState_Ignore;
          else 
          {
            event_list.splice (event_list.end (), event_list, iter->second);

            event->state = state;
          }

          break;
        default:
          break;
      }
    }    
  }
示例#3
0
	int Game::Run()
	{
		EventList eventList;
		this->window->setFramerateLimit(60);
		//clock.restart();
		sf::Time elapsed = clock.restart();

		while ( this->window->isOpen() )
		{

			sf::Event event;

			while ( window->pollEvent(event) )
			{
				if ( event.type == sf::Event::Closed )
					window->close();
	//       else if ( event.type = sf::Event::Resized )
	// 	this->windowResized = true;
			else
			  eventList.insert( std::pair< sf::Event::EventType,sf::Event >( event.type,event ) );

		}

			window->clear();

			this->Update( elapsed , &eventList );

			this->Draw();

			this->window->display();

			eventList.clear();

			elapsed = clock.restart();

		}


		return 0;
	}
示例#4
0
int main()
{
    using namespace std;
    EventList Elist;                // Create event list
    enum {ARR,DEP1,DEP2,DEP3,TRANSFER11,TRANSFER13,TRANSFER23,TRANSFER32,TDEP1,TDEP2,TDEP3};                 // Define the event types
    enum{Q1,Q2,Q3};
    
    double lambda=1;            // Arrival rate
    double mu1 = 6.0;
    double mu2 = 25.0;
    double mu3 = 30.0;
    
        exp_rv(lambda);
    double rs1 = (double)1/4;
    double rs2 = (double)3/4;
    double r11 = (double)1/2,r13 = (double)1/2,r3d = (double)2/5,r32 =(double)3/5;
    
    int N = 0;                      // Number of customers in system
    int Ndep = 0;                   // Number of departures from system
    
                      // End condition satisfied?
    
    Event* CurrentEvent;
    
    
    for(lambda = 1; lambda <= 10 ; lambda++ )
    {
        
        int n1 = 0;
        int n2=0;
        int n3=0;
        int tn1 = 0;
        int tn2=0;
        int tn3=0;
        
        int qe1=0,qe2=0,qe3=0; //to keep total entering each queue. for throughput calculation
        double util1=0,util2=0,util3=0, rho1=0, rho2=0, rho3=0;
        
        if(randomGenerator() <= rs1)
            Elist.insert(exp_rv(lambda),ARR,Q1);
        else
            Elist.insert(exp_rv(lambda),ARR,Q2);

        double clock = 0.0;             // System clock
        Ndep = 0;
        double EN1 = 0.0, EN2 = 0.0, EN3 = 0.0;
        int done = 0;
        while (!done)
        {
            CurrentEvent = Elist.get();
            double prev = clock;
            clock=CurrentEvent->time;
            EN1 += (double)((n1+tn1)*(clock-prev));
            EN2 += (double)((n2+tn2)*(clock-prev));
            EN3 += (double)((n3+tn3)*(clock-prev));
            
            if((n1+tn1)>0)
            util1+=(clock-prev);
            if((n2+tn2)>0)
            util2+=(clock-prev);
            if((n3+tn3)>0)
            util3+=(clock-prev);
            
            
            switch (CurrentEvent->type)
            {
            case ARR:
                if(CurrentEvent->queue == 0)
                {
                    n1++;
                    qe1++;
                    //generate next arrival
                    if(randomGenerator() <= rs1)
                        Elist.insert(clock+exp_rv(lambda),ARR, Q1);
                    else
                        Elist.insert(clock+exp_rv(lambda),ARR, Q2);
                
                    if (n1==1)
                    {
                        Elist.insert(clock+exp_rv(mu1),DEP1, Q1);
                    }
                }
                else if(CurrentEvent->queue == 1)
                {
                    n2++;
                    qe2++;
                    //generate next arrival
                    if(randomGenerator() <= rs1)
                        Elist.insert(clock+exp_rv(lambda),ARR, Q1);
                    else
                        Elist.insert(clock+exp_rv(lambda),ARR, Q2);
                    
                    if (n2==1)
                    {
                        Elist.insert(clock+exp_rv(mu2),DEP2, Q2);
                    }
                }
                
                break;
                
                case DEP2:
                n2--;
                if (n2 > 0)
                {
                    Elist.insert(clock+exp_rv(mu2),DEP2,Q2);
                }
                
                Elist.insert(clock+exp_rv(mu2),TRANSFER23, Q3);
                break;
                
                
                case TRANSFER11:
                    tn1++;
                    qe1++;
                    if(tn1>0)
                    {
                        //Generate TDEP for this transfer event
                        Elist.insert(clock+exp_rv(mu1), TDEP1, Q1);
                    }
                    break;
                
                    
                case TDEP1:
                    tn1--;
                    if(randomGenerator()<=r11)
                    {
                    //Its going back to the same queue. Don't generate new arrival event. generate transfer event
                        Elist.insert(clock+exp_rv(mu1),TRANSFER11,Q1);
                    }
                    else
                    {
                        Elist.insert(clock+exp_rv(mu1),TRANSFER13,Q3);
                    
                    }
                break;
                
                    
                case TRANSFER13:
                    tn3++;
                    qe3++;
                    if(tn3>0)
                    {
                        //Generate TDEP for this transfer event
                        Elist.insert(clock+exp_rv(mu3), TDEP3, Q3);
                    }
                    break;
                    
                case TDEP3:
                    tn3--;
                    if(randomGenerator()<=r3d)
                    {
                        //Exits the system
                        Ndep++;
                    }
                    else
                    {
                        Elist.insert(clock+exp_rv(mu3),TRANSFER32,Q2);
                    }
                    break;
                
                case TRANSFER23:
                    tn3++;
                    qe3++;
                    if(tn3>0)
                    {
                        //Generate TDEP for this transfer event
                        Elist.insert(clock+exp_rv(mu3), TDEP3, Q3);
                    }
                    break;
                    
                    
                case TRANSFER32:
                    tn2++;
                    qe2++;
                    if(tn2>0)
                    {
                        //Generate TDEP for this transfer event
                        Elist.insert(clock+exp_rv(mu2), TDEP2, Q2);
                    }
                    break;
                    
                case TDEP2:
                    tn2--;
                    Elist.insert(clock+exp_rv(mu2),TRANSFER23, Q3);
                    break;
                
                case DEP1:
                    n1--;
                    if (n1 > 0)
                    {
                        Elist.insert(clock+exp_rv(mu1),DEP1,Q1);
                    }
                
                    
                    if(randomGenerator()<=r11)
                    {
                    //Its going back to the same queue. Don't generate new arrival event. generate transfer event
                        Elist.insert(clock+exp_rv(mu1),TRANSFER11,Q1);
                    
                    }
                    else
                    {
                        Elist.insert(clock+exp_rv(mu1),TRANSFER13,Q3);
                    }
                    break;
                
                }
            
            EN1=(double)(((qe1/clock)/mu1)/(1-((qe1/clock)/mu1)))*clock; EN2 = (double)(((qe2/clock)/mu2)/(1-((qe2/clock)/mu2)))*clock; EN3=(double)(((qe3/clock)/mu3)/(1-((qe3/clock)/mu3)))*clock;
            //cout<<CurrentEvent->type<<endl;
            //cout<<"N1 : "<<n1+tn1<<"    N2 : "<<n2+tn2<<"    N3 : "<<n3+tn3<<"    Ndep : "<<Ndep<<endl;
            
        delete CurrentEvent;
        if (Ndep > 500000) done=1;        // End condition
    }
        
        
        
        /*Printing Output for each iteration */
        
        
        
        rho1=(double)(qe1/clock)/mu1;
        rho2=(double)(qe2/clock)/mu2;
        rho3=(double)(qe3/clock)/mu3;
        cout<<"Lambda "<<lambda<<endl;
        cout<<"TP1 : "<<qe1/clock<<"    TP2 : "<<qe2/clock<<"    TP3 : "<<qe3/clock<<endl;
        cout<<"Util1 : "<<(rho1)<<"    Util2 : "<<rho2<<"    Util3 : "<<rho3<<endl;
        cout<<"EN1 : "<<EN1/clock<<"    EN2 : "<<EN2/clock<<"    EN3 : "<<EN3/clock<<endl;
        cout<<"E[T1] : "<<(double)(EN1/qe1)<<"    E[T2] : "<<(double)(EN2/qe2)<<"    E[T3] : "<<(double)(EN3/qe3)<<endl;
        
        cout<<endl<<endl;
        
        Elist.clear();
        
}
    
}
int main()
{
  bool    done             = false;
  double  EN               = 0.0;     // For calculating E[N]
  double  Util             = 0.0;
  Event*  CurrentEvent;

  //Get system configuration inputs from user
  getUserInputs();

  countInfo.terminalPool = configInfo.numTerminals;

  //this will initialize the queuing system
  initializeQSystem(configInfo.numTerminals);

  /*
   * This while loop represents the finite population system where
   * customer arrive (from the event list in our case),
   * get accepted if the system has capacity, get served
   * by the next available server and then depart
   */
  while (!done)
  {
    CurrentEvent = Elist.get();               // Get next Event from list
    double prev = clock;                      // Store old clock value
    clock=CurrentEvent->time;                 // Update system clock

    switch (CurrentEvent->type)
    {
      case ARR:
        countInfo.NArr++;
        EN += countInfo.NSys*(clock-prev);

        if(countInfo.NSys<configInfo.numCPU)
          Util += countInfo.NSys*(clock-prev);
        else
          Util += configInfo.numCPU*(clock-prev);

        if(countInfo.serverPool<configInfo.numCPU)
        {
          //Server is idle, accept the element in the system and depart it
          countInfo.serverPool++;
          countInfo.NSys++;
          Elist.insert(clock+exp_rv(configInfo.serviceRate),DEP);
        }
        else if((countInfo.serverPool==configInfo.numCPU) &&
                (countInfo.NQueue<configInfo.queueSize))
        {
          //All servers are occupied, accept the element and queue it
          countInfo.NSys++;
          countInfo.NQueue++;
        }
        else if((countInfo.serverPool==configInfo.numCPU) &&
                (countInfo.NQueue == configInfo.queueSize))
        {
          //system is full to its capacity. Block the customer and free a terminal
          countInfo.NBlocked++;
          countInfo.terminalPool++;
          generateArrEvent(configInfo.numTerminals);
        }
        break;
      case DEP:
        EN += countInfo.NSys*(clock-prev);

        if(countInfo.NSys<configInfo.numCPU)
          Util += countInfo.NSys*(clock-prev);
        else
          Util += configInfo.numCPU*(clock-prev);

        if(countInfo.NSys)
        {
          countInfo.NSys--;
          countInfo.serverPool--;
          countInfo.terminalPool++;
          countInfo.NDep++;
          if ((countInfo.serverPool < configInfo.numCPU) && (countInfo.NQueue>0))
          {
            //If a server is idle and customer is waiting in queue then generate dep
            countInfo.serverPool++;
            countInfo.NQueue--;
            Elist.insert(clock+exp_rv(configInfo.serviceRate),DEP);
          }
        }
        //triger new arrival. If a terminal is free then it will generate arr
        generateArrEvent(configInfo.numTerminals);
        break;
    }
    delete CurrentEvent;
    if (countInfo.NDep > 100000)
      done=true;        // End condition
  }
  cout<<endl<<"****Statistical Output with lambda="<<configInfo.arrivalRate<<"****"<<endl;
  cout <<"Expected number of customers (simulation)= " << EN/clock << endl;
  cout<<"Expected time spent in the system= "<<EN/100000<<endl;
  cout<<"P(Blocking)= "<<(double)countInfo.NBlocked/countInfo.NArr<<endl;
  cout<<"Utilization= "<<(double)Util/(clock*configInfo.numCPU)<<endl;
}
int main()
{
    using namespace std;
    EventList Elist;
    enum{ARR,DEP1,DEP2,DEP3};

    double rs1,rs2,r11,r13,r3d,r32,mu1,mu2,mu3;
    double clock;                 // System clock
    double EN1;
    double EN2;
    double EN3;
    int N1;                      // Number of customers in queue1
    int N2;
    int N3;
    int Ndep1;                   // Number of departures from queue1
    int Ndep2;
    int Ndep3;
    int Ndep_system;                //# of departures from system
    double U1;
    double U2;
    double U3;
	double lambda;


    cout << "Please input a lambda value(1 to 10): "<< endl;
	cin >> lambda;
    cout << "Please input the rs1 : " << endl;
	cin >> rs1;
	cout << "Please input the rs2 : " << endl;
	cin >> rs2;
	cout << "Please input the r11 : " << endl;
	cin >> r11;
	cout << "Please input the r13 : " << endl;
	cin >> r13;
	cout << "Please input the r3d : " << endl;
	cin >> r3d;
	cout << "Please input the r32 : " << endl;
	cin >> r32;
	cout << "Please input the mu1 : " << endl;
	cin >> mu1;
	cout << "Please input the mu2 : " << endl;
	cin >> mu2;
	cout << "Please input the mu3 : " << endl;
	cin >> mu3;

    int done = 0;                   // End condition satisfied?
    int i;

   
		clock = 0.0;
		N1 = 0;
		N2 = 0;
		N3 = 0;
		EN1 = 0.0;
        EN2 = 0.0;
        EN3 = 0.0;
		Ndep1 = 0;
		Ndep2 = 0;
		Ndep3 = 0;
		Ndep_system = 0;
		U1 = 0.0;
		U2 = 0.0;
		U3 = 0.0;        

		Event* CurrentEvent;
		
		Elist.insert(exp_rv(lambda),ARR);

		while (!done)
		{

		    CurrentEvent = Elist.get();               // Get next Event from list
            double prev = clock;                      // Store old clock value
            clock = CurrentEvent->time;                 // Update system clock
            EN1 += N1*(clock-prev);
            EN2 += N2*(clock-prev);
            EN3 += N3*(clock-prev);
            if(N1>0) U1+=1*(clock-prev);
            if(N2>0) U2+=1*(clock-prev);
            if(N3>0) U3+=1*(clock-prev);

            switch (CurrentEvent->type){
            case ARR:
               if(uni_rv()<rs1)
               {
			      ///EN1 += N1*(clock-prev);  /////
                  N1 += 1;
                  Elist.insert(clock+exp_rv(lambda),ARR);
                  if(N1==1)
                  {
                    Elist.insert(clock+exp_rv(mu1),DEP1);  // A DEPARTURE FROM QUEUE1
                  }
               }
              else
               {
                  N2+=1;
                  Elist.insert(clock+exp_rv(lambda),ARR);
                  if(N2==1)
                  {
                    Elist.insert(clock+exp_rv(mu2),DEP2);  //A DEPARTURE FROM QUEQUE2
                  }
               }
               break;

            case DEP1:
			    ///EN1 += N1*(clock-prev);  
                N1-=1;
                Ndep1+=1;
                if(N1>0)
                {
                     Elist.insert(clock+exp_rv(mu1),DEP1);
                }
                if(uni_rv()<r11)
                {
                    N1+=1;
                    if(N1==1)
                    {
                      Elist.insert(clock+exp_rv(mu1),DEP1);
                    }
                }
                else{
                    N3+=1;
                    if(N3==1)
                    {
                        Elist.insert(clock+exp_rv(mu3),DEP3);  //A DEPARTURE FROM QUEQUE3
                    }
                }
                break;

            case DEP2:
			     ///EN2 += N2*(clock-prev); 
                 N2-=1;
                 Ndep2+=1;
                 N3+=1;
                 if(N3==1)
                 {
                    Elist.insert(clock+exp_rv(mu3),DEP3);
                 }
                 if(N2>0)
                 {
                     Elist.insert(clock+exp_rv(mu2),DEP2);
                 }
                 break;

            case DEP3:
			      ///EN3 += N3*(clock-prev);
                  N3-=1;
                  Ndep3+=1;
                  if(uni_rv()<=r3d)
                  {
                      Ndep_system+=1;
                  }
                  else{
                    N2+=1;
                    if(N2==1)
                    {
                        Elist.insert(clock+exp_rv(mu2),DEP2);
                    }
                  }
                  if(N3>0)
                  {
                      Elist.insert(clock+exp_rv(mu3),DEP3);
                  }
                  break;
            }

            delete CurrentEvent;

            if (Ndep_system > 500000)   done=1;
		}
		// output simulation results
  cout << "lambda: " << lambda << endl;
  cout << "Throughput of each queue(simulation): \n" << Ndep1/clock << endl << Ndep2/clock << endl << Ndep3/clock<< endl;
  cout << "Expected # of each queue(simulation): \n" << EN1/clock <<endl << EN2/clock << endl << EN3/clock << endl;
  cout << "Expected time of each queue(simulation): \n" << EN1/(double)Ndep1 << endl << EN2/(double)Ndep2 << endl << EN3/(double)Ndep3 <<endl;
  cout << "Utilization of each queue(simulation): \n" << U1/clock << endl << U2/clock << endl << U3/clock << endl;
 

}
示例#7
0
int main()
{
	// Bedien-Schalter:
	const int nS = 3;				// Anzahl Bank-Schalter
	Queue<Event> bankSchalter[nS];	// Warteschlangen für Bank-Schalter

	// EreignisListe
	EventList eList;

	// kunden.dat
	ifstream fin("kunden.dat");

	Event e;

	// Hole aus Datei erstes Ankunftsereignis
	// und füge es in Ereignisliste ein:
	e.type = 'i';
	fin >> e.time;
	fin >> e.d;
	if (fin.eof())
		return 0;
	eList.insert(e);

    // Daten fuer Statistik
    int numKunden          = 0;
    float gesamtBedienzeit = 0.0;
    float minBedienzeit    = 10000.0;
    float maxBedienzeit    = 0.0;
    float gesamtWartezeit  = 0.0;
    float minWartezeit     = 10000.0;
    float maxWartezeit     = 0.0;

	while (eList.next(e))
	{
        // Verzoegern und Anzeige loeschen
        system("usleep 150000");
        system("clear");
        
		// Ausgabe des aktuellen Zeitpunktes
		cout << "Zeit:\t\t" << e.time << " Min" << endl;
        cout.flush();

		if (e.type == 'i')
		{
			//////
			// e ist Ankunftsereignis:
			//////

			// füge e in kürzeste Warteschlange ein:
			// Kürzeste Schlange min bestimmen
            int min = 0;
            for (int i = 0; i < nS; ++i)
            {
                if (bankSchalter[i].length() < bankSchalter[min].length())
                {
                    min = i;
                }
            }

			bankSchalter[min].add(e);

			// Falls e einziger Kunder (d.h. Warteschlangenlänge == 1),
			// dann wird er gleich bedient. Erzeuge daher neues
			// Abgangsereignis und füge es in Ereignisliste ein:
			if (bankSchalter[min].length() == 1)
			{
				Event eo;
				eo.type = 'o';
				eo.time = e.time + e.d;	// Zeitpunkt des Abgangs = Bedien-Ende
				eo.nrSchalter = min;
				eList.insert(eo);

                // Statistik aktualisieren
                minWartezeit = 0.0;     // minimal Wartezeit ist = 0, da Kunde allein am Schalter
			}

			// Hole aus Datei neues Ankunftsereignis
			// und füge es in Ereignisliste ein:
			Event ei;
			ei.type = 'i';
			fin >> ei.time;
			fin >> ei.d;
			if (!fin.eof())
			{
				eList.insert(ei);
            }

            cout << "Ereignis:\tKunde trifft ein und reiht sich an Schalter " << (min+1) << " ein." << endl;

            // Statistik aktualisieren
            if (maxBedienzeit < e.d)
            {
                maxBedienzeit = e.d;    // e.d = Bedienzeit des akt. Events
            }

            if (minBedienzeit > e.d)
            {
                minBedienzeit = e.d;
            }

            gesamtBedienzeit += e.d;
		}
		else // e.type == 'o'
		{