OMNeT++

OMNeT++ is a framework for building simulators, including communication networks, on-chip networks and queueing networks.

#include <string.h>
#include <math.h>
#include <omnetpp.h>

class WaitingLine : public cSimpleModule
{
  protected:
    virtual void initialize();
    virtual void handleMessage( cMessage * );
    virtual void finish();

private:
    cMessage *newArrival;
    int usersCounter, numberOfServers;
    int *availableServers;
    double *serverTimestamps;
    simtime_t nextArrivalTime;
    double simulationTimeRemaining, totalWaitingTime, totalUnusedTime;
};

Define_Module( WaitingLine );

void WaitingLine::initialize()
{
  char buffer[ 128 ] = { '\0' };
  int counter;
  
  usersCounter = 0;
  nextArrivalTime = 0.0;
  simulationTimeRemaining = par( "maxSimulationDuration" );
  totalWaitingTime = 0.0;
  totalUnusedTime = 0.0;

numberOfServers = par( "numberOfServers" );
  availableServers = new int[ numberOfServers ];
  serverTimestamps = new double[ numberOfServers ];
  for ( counter = 0; counter < numberOfServers; counter++ )
  {
    availableServers[ counter ] = 1;
    serverTimestamps[ counter ] = 0.0;
  }

sprintf( buffer, "Arrival of new %s", par("strUserDescription").stringValue() );
  newArrival = new cMessage( buffer );
  scheduleAt( simTime(), newArrival );
}

void WaitingLine::handleMessage(cMessage *user)
{
  char buffer[ 128 ] = { '\0' };
  int nextServerGateIndex, counter;
  cMessage *nextUser;

if ( user == newArrival )
  {
    printf( "%s %d arrived after %.0lf %s\n", par("strUserDescription").stringValue(), usersCounter + 1, nextArrivalTime.dbl(), par("strSimulationTimeUnit").stringValue() );
    simulationTimeRemaining = simulationTimeRemaining - nextArrivalTime.dbl();
    sprintf( buffer, "%s %d", par("strUserDescription").stringValue(), usersCounter + 1 );
    nextUser = new cMessage( buffer );
    scheduleAt( simTime(), nextUser );
    usersCounter++;

nextArrivalTime = par( "newUserArrivalRate" );
    if ( ( simulationTimeRemaining - nextArrivalTime.dbl() ) > 0 ) scheduleAt( simTime() + nextArrivalTime, newArrival );
  }
  else if ( user->isSelfMessage() )
  {
    nextServerGateIndex = numberOfServers;
    for ( counter = numberOfServers - 1; counter >= 0; counter-- )
    {
      if ( availableServers[ counter ] == 1 )
      {
        nextServerGateIndex = counter;
        totalUnusedTime = totalUnusedTime + nearbyint( simTime().dbl() - serverTimestamps[ counter ] );
        serverTimestamps[ counter ] = simTime().dbl();
      }
    }
    
    if ( nextServerGateIndex < numberOfServers )
    {
      printf( "%s is assigned to %s %d\n", user->getName(), par("strServerDescription").stringValue(), nextServerGateIndex + 1 );
      availableServers[ nextServerGateIndex ] = 0;
      send( user, "toServer", nextServerGateIndex );
    }
    else
    {
      printf( "%s waiting ...\n", user->getName() );
      totalWaitingTime = totalWaitingTime + 1.0;
      scheduleAt( simTime() + 1.0, user );
    }
  }
  else if ( user->arrivedOn( "toExit" ) )
  {
    printf( "%s is done\n", user->getName() );
    for ( nextServerGateIndex = 0; nextServerGateIndex < numberOfServers; nextServerGateIndex++ )
    {
      if ( user->arrivedOn( "toExit", nextServerGateIndex ) )
      {
        availableServers[ nextServerGateIndex ] = 1;
        serverTimestamps[ nextServerGateIndex ] = simTime().dbl();
      }
      else if ( availableServers[ nextServerGateIndex ] == 1 )
      {
        totalUnusedTime = totalUnusedTime + nearbyint( simTime().dbl() - serverTimestamps[ nextServerGateIndex ] );
        serverTimestamps[ nextServerGateIndex ] = simTime().dbl();
      }
    }
    delete user;
  }
}

void WaitingLine::finish()
{
  delete newArrival;
  delete []availableServers;
  delete []serverTimestamps;
  printf( "Served %d %s\n", usersCounter, par("strUserDescription").stringValue() );
  printf( "Total waiting time was %.0lf %s\n", totalWaitingTime, par("strSimulationTimeUnit").stringValue() );
  printf( "Total unused time was %.0lf %s\n", totalUnusedTime, par("strSimulationTimeUnit").stringValue() );
}

class Server : public cSimpleModule
{
  protected:
    virtual void handleMessage( cMessage * );

private:
    simtime_t serviceDuration;
};

Define_Module( Server );

void Server::handleMessage(cMessage *user)
{
  if ( user->isSelfMessage() )
  {
    printf( "%s spent %.0lf %s using %s\n", user->getName(), serviceDuration.dbl(), par("strSimulationTimeUnit").stringValue(), par("strServerDescription").stringValue() );
    send( user, "serviceEnd" );
  }
  else
  {
    serviceDuration = par( "serviceDuration" );
    scheduleAt( simTime() + serviceDuration, user );
  }
}

Reference documents