der ju goł

server
---------------------------------------------

#include <omnetpp.h>

class Server : public cSimpleModule
{
  private:
    cQueue queue;    //the queue; first job in the queue is being serviced
    cMessage *departure; //message-reminder of the end of service (job departure)
    simtime_t departure_time;  //time of the next departure
    int N;
    int acc;
    int lost;
    cStdDev lr; // loss ratio
    simtime_t bufferOverflowPeriod;
    cDoubleHistogram ofPeriod;
    bool ofPeriodToggled;
    int consecutiveLosses;
    cLongHistogram consLosses;
    simtime_t timeToBufferOverflow;
    cDoubleHistogram timToBufOf;

  protected:
    virtual void initialize();
    virtual void handleMessage(cMessage *msgin);

};

Define_Module(Server);

void Server::initialize()
{
    departure = new cMessage("Departure");
    N = 10;
    lost = 0;
    acc = 0;
    ofPeriodToggled = false;
    consecutiveLosses = 0;
    ofPeriod.setName("OverflowPeriod");
    consLosses.setName("ConsecutiveLosses");
    timToBufOf.setName("TimeToBufferOverflow");
    lr.setName("LossRatio");
}


void Server::handleMessage(cMessage *msgin)
{
    if (msgin==departure) //job departure
    {
        cMessage *msg = (cMessage *)queue.pop(); //remove job from the head of the queue
        if(queue.empty())
        {
            timeToBufferOverflow = simTime();
        }

        if((queue.length() == N-1) && ofPeriodToggled)
        {
            bufferOverflowPeriod = simTime() - bufferOverflowPeriod;
            ofPeriodToggled = false;
            ofPeriod.collect(bufferOverflowPeriod);
        }

        if(queue.length() == N-1)
        {
            consLosses.collect(consecutiveLosses);
            consecutiveLosses = 0;
        }

        send(msg,"out");
        if (!queue.empty()) //schedule next departure event
        {
            departure_time=simTime()+par("service_time");
            scheduleAt(departure_time,departure);
        }
    }
    else if (queue.length() < N) //job arrival
    {
        if (queue.empty())
        {
            departure_time=simTime()+par("service_time");
            scheduleAt(departure_time,departure);
        }
        queue.insert(msgin); //put job at the end of the queue

        if(queue.length()==N)
        {
            timeToBufferOverflow = simTime() - timeToBufferOverflow;
            timToBufOf.collect(timeToBufferOverflow);
            bufferOverflowPeriod = simTime();
            ofPeriodToggled = true;
        }

        acc++;
    }
    else
    {
        consecutiveLosses++;
        delete msgin;
        lost++;
    }
    lr.collect((double)lost/(lost+acc));
}

----------------------------------------------------------------------------
source
----------------------------------------------------------------------------
#include <omnetpp.h>

class Source : public cSimpleModule
{
	cMessage *send_event; //message-reminder: send next job

  protected:
	virtual void initialize();
	virtual void handleMessage(cMessage *msgin);
};

Define_Module(Source);

void Source::initialize()
{
	for(int i=0;i<(int)par("initial_queue");i++) //this loop builds the initial queue
	{
		cMessage *job = new cMessage(" Job");
		send(job, "out" );
	}

	send_event = new cMessage("Send!");
    scheduleAt(par("interarrival_time"), send_event);
}

void Source::handleMessage(cMessage *msgin) //send next job
{
    cMessage *job = new cMessage(" Job");
	send(job, "out" );
	scheduleAt(simTime()+par("interarrival_time"), send_event); //schedule next send event
}

------------------------------------------------------------------------------
sink
-----------------------------------------------------------------------------
#include <omnetpp.h>

class Sink : public cSimpleModule
{
  protected:
    virtual void handleMessage(cMessage *msgin);
};


Define_Module(Sink);


void Sink::handleMessage(cMessage *msgin)
{
	delete msgin;
}
--------------------------------------------------------------------------------
omnetpp.ini
------------------------------------------------------------------------------
[General]
network = gg1

cpu-time-limit = 60s


gg1.source.interarrival_time = exponential(0.5)
gg1.server.service_time = uniform(0,1)
gg1.source.initial_queue = 5