A simplified version of EtherMAC. More...

#include <EtherMACFullDuplex.h>

Inheritance diagram for inet::EtherMACFullDuplex:

Public Member Functions
	EtherMACFullDuplex ()

Public Member Functions inherited from inet::EtherMACBase
	EtherMACBase ()

virtual	~EtherMACBase ()

virtual MACAddress	getMACAddress ()

double	getTxRate ()

bool	isActive ()

MACTransmitState	getTransmitState ()

MACReceiveState	getReceiveState ()

virtual bool	handleOperationStage (LifecycleOperation operation, int stage, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

Public Member Functions inherited from inet::MACBase
	MACBase ()

virtual	~MACBase ()

Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	initializeStatistics () override

virtual void	initializeFlags () override

virtual void	handleMessage (cMessage *msg) override

virtual void	finish () override

virtual void	handleEndIFGPeriod ()

virtual void	handleEndTxPeriod ()

virtual void	handleEndPausePeriod ()

virtual void	handleSelfMessage (cMessage *msg)

virtual void	startFrameTransmission ()

virtual void	processFrameFromUpperLayer (EtherFrame *frame)

virtual void	processMsgFromNetwork (cPacket *pk)

virtual void	processReceivedDataFrame (EtherFrame *frame)

virtual void	processPauseCommand (int pauseUnits)

virtual void	scheduleEndIFGPeriod ()

virtual void	scheduleEndPausePeriod (int pauseUnits)

virtual void	beginSendFrames ()

Protected Member Functions inherited from inet::EtherMACBase
virtual void	initializeMACAddress ()

virtual void	initializeQueueModule ()

virtual bool	dropFrameNotForUs (EtherFrame *frame)
	Checks destination address and drops the frame when frame is not for us; returns true if frame is dropped. More...

virtual void	readChannelParameters (bool errorWhenAsymmetric)
	Calculates datarates, etc. More...

virtual void	printParameters ()

virtual void	getNextFrameFromQueue ()

virtual void	requestNextFrameFromExtQueue ()

virtual void	processConnectDisconnect ()

virtual EtherPhyFrame *	encapsulate (EtherFrame *phyFrame)

virtual EtherFrame *	decapsulate (EtherPhyFrame *phyFrame)

virtual InterfaceEntry *	createInterfaceEntry () override
	should create InterfaceEntry More...

virtual void	flushQueue () override
	should clear queue and emit signal "dropPkFromHLIfaceDown" with entire packets More...

virtual void	clearQueue () override
	should clear queue silently More...

virtual bool	isUpperMsg (cMessage *msg) override
	should return true if the msg arrived from upper layer, else return false More...

virtual void	refreshDisplay () const override

virtual void	receiveSignal (cComponent src, simsignal_t signalId, cObject obj, cObject *details) override

virtual void	refreshConnection ()

Protected Member Functions inherited from inet::MACBase
void	registerInterface ()

virtual void	updateOperationalFlag (bool isNodeUp)

virtual bool	isNodeUp ()

virtual void	handleMessageWhenDown (cMessage *msg)

Protected Attributes
simtime_t	totalSuccessfulRxTime

Protected Attributes inherited from inet::EtherMACBase
const EtherDescr *	curEtherDescr = nullptr

MACAddress	address

bool	connected = false

bool	disabled = false

bool	promiscuous = false

bool	duplexMode = false

bool	frameBursting = false

MacQueue	txQueue

cChannel *	transmissionChannel = nullptr

cGate *	physInGate = nullptr

cGate *	physOutGate = nullptr

cGate *	upperLayerInGate = nullptr

bool	channelsDiffer = false

MACTransmitState	transmitState = (MACTransmitState)-1

MACReceiveState	receiveState = (MACReceiveState)-1

simtime_t	lastTxFinishTime

int	pauseUnitsRequested = 0

EtherFrame *	curTxFrame = nullptr

cMessage *	endTxMsg = nullptr

cMessage *	endIFGMsg = nullptr

cMessage *	endPauseMsg = nullptr

unsigned long	numFramesSent = 0

unsigned long	numFramesReceivedOK = 0

unsigned long	numBytesSent = 0

unsigned long	numBytesReceivedOK = 0

unsigned long	numFramesFromHL = 0

unsigned long	numDroppedPkFromHLIfaceDown = 0

unsigned long	numDroppedIfaceDown = 0

unsigned long	numDroppedBitError = 0

unsigned long	numDroppedNotForUs = 0

unsigned long	numFramesPassedToHL = 0

unsigned long	numPauseFramesRcvd = 0

unsigned long	numPauseFramesSent = 0

Protected Attributes inherited from inet::MACBase
cModule *	hostModule = nullptr

bool	isOperational = false

InterfaceEntry *	interfaceEntry = nullptr

Additional Inherited Members
Public Types inherited from inet::EtherMACBase
enum	MACTransmitState { TX_IDLE_STATE = 1, WAIT_IFG_STATE, SEND_IFG_STATE, TRANSMITTING_STATE, JAMMING_STATE, BACKOFF_STATE, PAUSE_STATE }

enum	MACReceiveState { RX_IDLE_STATE = 1, RECEIVING_STATE, RX_COLLISION_STATE, RX_RECONNECT_STATE }

Static Public Attributes inherited from inet::EtherMACBase
static const double	SPEED_OF_LIGHT_IN_CABLE = 200000000.0

static simsignal_t	dropPkIfaceDownSignal = registerSignal("dropPkIfaceDown")

static simsignal_t	dropPkFromHLIfaceDownSignal = registerSignal("dropPkFromHLIfaceDown")

Protected Types inherited from inet::EtherMACBase
enum	SelfMsgKindValues { ENDIFG = 100, ENDRECEPTION, ENDBACKOFF, ENDTRANSMISSION, ENDJAMMING, ENDPAUSE }

enum	{ NUM_OF_ETHERDESCRS = 6 }

Static Protected Attributes inherited from inet::EtherMACBase
static const EtherDescr	etherDescrs [NUM_OF_ETHERDESCRS]

static const EtherDescr	nullEtherDescr

static simsignal_t	txPkSignal = registerSignal("txPk")

static simsignal_t	rxPkOkSignal = registerSignal("rxPkOk")

static simsignal_t	txPausePkUnitsSignal = registerSignal("txPausePkUnits")

static simsignal_t	rxPausePkUnitsSignal = registerSignal("rxPausePkUnits")

static simsignal_t	rxPkFromHLSignal = registerSignal("rxPkFromHL")

static simsignal_t	dropPkNotForUsSignal = registerSignal("dropPkNotForUs")

static simsignal_t	dropPkBitErrorSignal = registerSignal("dropPkBitError")

static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")

static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")

static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")

static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")

static simsignal_t	transmitStateSignal = registerSignal("transmitState")

static simsignal_t	receiveStateSignal = registerSignal("receiveState")

Detailed Description

A simplified version of EtherMAC.

Since modern Ethernets typically operate over duplex links where's no contention, the original CSMA/CD algorithm is no longer needed. This simplified implementation doesn't contain CSMA/CD, frames are just simply queued up and sent out one by one.

Constructor & Destructor Documentation

inet::EtherMACFullDuplex::EtherMACFullDuplex ( )

34 {

35 }

Member Function Documentation

void inet::EtherMACFullDuplex::beginSendFrames ( )

protectedvirtual

Referenced by handleEndIFGPeriod(), handleEndPausePeriod(), and initialize().

 {
     if (curTxFrame) {
         // Other frames are queued, transmit next frame
         EV_DETAIL << "Transmit next frame in output queue\n";
         startFrameTransmission();
     }
     else {
         // No more frames set transmitter to idle
         transmitState = TX_IDLE_STATE;
         emit(transmitStateSignal, TX_IDLE_STATE);
         if (!txQueue.extQueue) {
             // Output only for internal queue (we cannot be shure that there
             //are no other frames in external queue)
             EV_DETAIL << "No more frames to send, transmitter set to idle\n";
         }
     }
 }

void inet::EtherMACFullDuplex::finish ( )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::finish();
 
     simtime_t t = simTime();
     simtime_t totalRxChannelIdleTime = t - totalSuccessfulRxTime;
     recordScalar("rx channel idle (%)", 100 * (totalRxChannelIdleTime / t));
     recordScalar("rx channel utilization (%)", 100 * (totalSuccessfulRxTime / t));
 }

void inet::EtherMACFullDuplex::handleEndIFGPeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     ASSERT(nullptr == curTxFrame);
     if (transmitState != WAIT_IFG_STATE)
         throw cRuntimeError("Not in WAIT_IFG_STATE at the end of IFG period");
 
     // End of IFG period, okay to transmit
     EV_DETAIL << "IFG elapsed" << endl;
 
     getNextFrameFromQueue();
     beginSendFrames();
 }

void inet::EtherMACFullDuplex::handleEndPausePeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     ASSERT(nullptr == curTxFrame);
     if (transmitState != PAUSE_STATE)
         throw cRuntimeError("End of PAUSE event occurred when not in PAUSE_STATE!");
 
     EV_DETAIL << "Pause finished, resuming transmissions\n";
     getNextFrameFromQueue();
     beginSendFrames();
 }

void inet::EtherMACFullDuplex::handleEndTxPeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     // we only get here if transmission has finished successfully
     if (transmitState != TRANSMITTING_STATE)
         throw cRuntimeError("End of transmission, and incorrect state detected");
 
     if (nullptr == curTxFrame)
         throw cRuntimeError("Frame under transmission cannot be found");
 
     emit(packetSentToLowerSignal, curTxFrame);    //consider: emit with start time of frame
 
     if (dynamic_cast<EtherPauseFrame *>(curTxFrame) != nullptr) {
         numPauseFramesSent++;
         emit(txPausePkUnitsSignal, ((EtherPauseFrame *)curTxFrame)->getPauseTime());
     }
     else {
         unsigned long curBytes = curTxFrame->getByteLength();
         numFramesSent++;
         numBytesSent += curBytes;
         emit(txPkSignal, curTxFrame);
     }
 
     EV_INFO << "Transmission of " << curTxFrame << " successfully completed.\n";
     delete curTxFrame;
     curTxFrame = nullptr;
     lastTxFinishTime = simTime();
 
 
     if (pauseUnitsRequested > 0) {
         // if we received a PAUSE frame recently, go into PAUSE state
         EV_DETAIL << "Going to PAUSE mode for " << pauseUnitsRequested << " time units\n";
 
         scheduleEndPausePeriod(pauseUnitsRequested);
         pauseUnitsRequested = 0;
     }
     else {
         EV_DETAIL << "Start IFG period\n";
         scheduleEndIFGPeriod();
     }
 }

void inet::EtherMACFullDuplex::handleMessage ( cMessage * msg )

overrideprotectedvirtual

 {
     if (!isOperational) {
         handleMessageWhenDown(msg);
         return;
     }
 
     if (channelsDiffer)
         readChannelParameters(true);
 
     if (msg->isSelfMessage())
         handleSelfMessage(msg);
     else if (msg->getArrivalGate() == upperLayerInGate)
         processFrameFromUpperLayer(check_and_cast<EtherFrame *>(msg));
     else if (msg->getArrivalGate() == physInGate)
         processMsgFromNetwork(PK(msg));
     else
         throw cRuntimeError("Message received from unknown gate!");
 }

void inet::EtherMACFullDuplex::handleSelfMessage ( cMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     EV_TRACE << "Self-message " << msg << " received\n";
 
     if (msg == endTxMsg)
         handleEndTxPeriod();
     else if (msg == endIFGMsg)
         handleEndIFGPeriod();
     else if (msg == endPauseMsg)
         handleEndPausePeriod();
     else
         throw cRuntimeError("Unknown self message received!");
 }

void inet::EtherMACFullDuplex::initialize ( int stage )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::initialize(stage);
 
     if (stage == INITSTAGE_LOCAL) {
         if (!par("duplexMode").boolValue())
             throw cRuntimeError("Half duplex operation is not supported by EtherMACFullDuplex, use the EtherMAC module for that! (Please enable csmacdSupport on EthernetInterface)");
     }
     else if (stage == INITSTAGE_LINK_LAYER) {
         beginSendFrames();    //FIXME choose an another stage for it
     }
 }

void inet::EtherMACFullDuplex::initializeFlags ( )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::initializeFlags();
 
     duplexMode = true;
     physInGate->setDeliverOnReceptionStart(false);
 }

void inet::EtherMACFullDuplex::initializeStatistics ( )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::initializeStatistics();
 
     // initialize statistics
     totalSuccessfulRxTime = 0.0;
 }

virtual int inet::EtherMACFullDuplex::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

39 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::EtherMACFullDuplex::processFrameFromUpperLayer ( EtherFrame * frame )

protectedvirtual

Referenced by handleMessage().

 {
     ASSERT(frame->getByteLength() >= MIN_ETHERNET_FRAME_BYTES);
 
     EV_INFO << "Received " << frame << " from upper layer." << endl;
 
     emit(packetReceivedFromUpperSignal, frame);
 
     if (frame->getDest().equals(address)) {
         throw cRuntimeError("logic error: frame %s from higher layer has local MAC address as dest (%s)",
                 frame->getFullName(), frame->getDest().str().c_str());
     }
 
     if (frame->getByteLength() > MAX_ETHERNET_FRAME_BYTES) {    //FIXME two MAX FRAME BYTES in specif...
         throw cRuntimeError("packet from higher layer (%d bytes) exceeds maximum Ethernet frame size (%d)",
                 (int)(frame->getByteLength()), MAX_ETHERNET_FRAME_BYTES);
     }
 
     if (!connected || disabled) {
         EV_WARN << (!connected ? "Interface is not connected" : "MAC is disabled") << " -- dropping packet " << frame << endl;
         emit(dropPkFromHLIfaceDownSignal, frame);
         numDroppedPkFromHLIfaceDown++;
         delete frame;
 
         requestNextFrameFromExtQueue();
         return;
     }
 
     // fill in src address if not set
     if (frame->getSrc().isUnspecified())
         frame->setSrc(address);
 
     bool isPauseFrame = (dynamic_cast<EtherPauseFrame *>(frame) != nullptr);
 
     if (!isPauseFrame) {
         numFramesFromHL++;
         emit(rxPkFromHLSignal, frame);
     }
 
     if (txQueue.extQueue) {
         ASSERT(curTxFrame == nullptr);
         ASSERT(transmitState == TX_IDLE_STATE || transmitState == PAUSE_STATE);
         curTxFrame = frame;
     }
     else {
         if (txQueue.innerQueue->isFull())
             throw cRuntimeError("txQueue length exceeds %d -- this is probably due to "
                                 "a bogus app model generating excessive traffic "
                                 "(or if this is normal, increase txQueueLimit!)",
                     txQueue.innerQueue->getQueueLimit());
         // store frame and possibly begin transmitting
         EV_DETAIL << "Frame " << frame << " arrived from higher layers, enqueueing\n";
         txQueue.innerQueue->insertFrame(frame);
 
         if (!curTxFrame && !txQueue.innerQueue->isEmpty() && transmitState == TX_IDLE_STATE)
             curTxFrame = (EtherFrame *)txQueue.innerQueue->pop();
     }
 
     if (transmitState == TX_IDLE_STATE)
         startFrameTransmission();
 }

void inet::EtherMACFullDuplex::processMsgFromNetwork ( cPacket * pk )

protectedvirtual

Referenced by handleMessage().

 {
     EtherTraffic *msg = check_and_cast<EtherTraffic *>(pk);
 
     EV_INFO << msg << " received." << endl;
 
     if (!connected || disabled) {
         EV_WARN << (!connected ? "Interface is not connected" : "MAC is disabled") << " -- dropping msg " << msg << endl;
         if (EtherPhyFrame *phyFrame = dynamic_cast<EtherPhyFrame *>(msg)) {    // do not count JAM and IFG packets
             EtherFrame *frame = decapsulate(phyFrame);
             emit(dropPkIfaceDownSignal, frame);
             delete frame;
             numDroppedIfaceDown++;
         }
         else
             delete msg;
 
         return;
     }
 
     EtherPhyFrame *phyFrame = dynamic_cast<EtherPhyFrame *>(msg);
     if (!phyFrame) {
         if (dynamic_cast<EtherFilledIFG *>(msg))
             throw cRuntimeError("There is no burst mode in full-duplex operation: EtherFilledIFG is unexpected");
         else
             throw cRuntimeError("Unexpected ethernet traffic: %s", msg->getClassName());
     }
 
     totalSuccessfulRxTime += phyFrame->getDuration();
 
     bool hasBitError = msg->hasBitError();
 
     EtherFrame *frame = decapsulate(phyFrame);
     emit(packetReceivedFromLowerSignal, frame);
 
     if (hasBitError) {
         numDroppedBitError++;
         emit(dropPkBitErrorSignal, frame);
         delete frame;
         return;
     }
 
     if (dropFrameNotForUs(frame))
         return;
 
     if (dynamic_cast<EtherPauseFrame *>(frame) != nullptr) {
         int pauseUnits = ((EtherPauseFrame *)frame)->getPauseTime();
         delete frame;
         numPauseFramesRcvd++;
         emit(rxPausePkUnitsSignal, pauseUnits);
         processPauseCommand(pauseUnits);
     }
     else {
         EV_INFO << "Reception of " << frame << " successfully completed." << endl;
         processReceivedDataFrame((EtherFrame *)frame);
     }
 }

void inet::EtherMACFullDuplex::processPauseCommand ( int pauseUnits )

protectedvirtual

Referenced by processMsgFromNetwork().

 {
     if (transmitState == TX_IDLE_STATE) {
         EV_DETAIL << "PAUSE frame received, pausing for " << pauseUnitsRequested << " time units\n";
         if (pauseUnits > 0)
             scheduleEndPausePeriod(pauseUnits);
     }
     else if (transmitState == PAUSE_STATE) {
         EV_DETAIL << "PAUSE frame received, pausing for " << pauseUnitsRequested
                   << " more time units from now\n";
         cancelEvent(endPauseMsg);
 
         if (pauseUnits > 0)
             scheduleEndPausePeriod(pauseUnits);
     }
     else {
         // transmitter busy -- wait until it finishes with current frame (endTx)
         // and then it'll go to PAUSE state
         EV_DETAIL << "PAUSE frame received, storing pause request\n";
         pauseUnitsRequested = pauseUnits;
     }
 }

void inet::EtherMACFullDuplex::processReceivedDataFrame ( EtherFrame * frame )

protectedvirtual

Referenced by processMsgFromNetwork().

 {
     // statistics
     unsigned long curBytes = frame->getByteLength();
     numFramesReceivedOK++;
     numBytesReceivedOK += curBytes;
     emit(rxPkOkSignal, frame);
 
     numFramesPassedToHL++;
     emit(packetSentToUpperSignal, frame);
     // pass up to upper layer
     EV_INFO << "Sending " << frame << " to upper layer.\n";
     send(frame, "upperLayerOut");
 }

void inet::EtherMACFullDuplex::scheduleEndIFGPeriod ( )

protectedvirtual

Referenced by handleEndTxPeriod().

 {
     ASSERT(nullptr == curTxFrame);
     transmitState = WAIT_IFG_STATE;
     emit(transmitStateSignal, WAIT_IFG_STATE);
     simtime_t endIFGTime = simTime() + (INTERFRAME_GAP_BITS / curEtherDescr->txrate);
     scheduleAt(endIFGTime, endIFGMsg);
 }

void inet::EtherMACFullDuplex::scheduleEndPausePeriod ( int pauseUnits )

protectedvirtual

Referenced by handleEndTxPeriod(), and processPauseCommand().

 {
     ASSERT(nullptr == curTxFrame);
     // length is interpreted as 512-bit-time units
     simtime_t pausePeriod = ((pauseUnits * PAUSE_UNIT_BITS) / curEtherDescr->txrate);
     scheduleAt(simTime() + pausePeriod, endPauseMsg);
     transmitState = PAUSE_STATE;
     emit(transmitStateSignal, PAUSE_STATE);
 }

void inet::EtherMACFullDuplex::startFrameTransmission ( )

protectedvirtual

Referenced by beginSendFrames(), and processFrameFromUpperLayer().

 {
     ASSERT(curTxFrame);
     EV_DETAIL << "Transmitting a copy of frame " << curTxFrame << endl;
 
     EtherFrame *frame = curTxFrame->dup();    // note: we need to duplicate the frame because we emit a signal with it in endTxPeriod()
     if (frame->getSrc().isUnspecified())
         frame->setSrc(address);
 
     if (frame->getByteLength() < curEtherDescr->frameMinBytes)
         frame->setByteLength(curEtherDescr->frameMinBytes);     // extra padding
 
     // add preamble and SFD (Starting Frame Delimiter), then send out
     EtherPhyFrame *phyFrame = encapsulate(frame);
 
     // send
     EV_INFO << "Transmission of " << frame << " started.\n";
     send(phyFrame, physOutGate);
 
     scheduleAt(transmissionChannel->getTransmissionFinishTime(), endTxMsg);
     transmitState = TRANSMITTING_STATE;
     emit(transmitStateSignal, TRANSMITTING_STATE);
 }

Member Data Documentation

simtime_t inet::EtherMACFullDuplex::totalSuccessfulRxTime

protected

Referenced by finish(), initializeStatistics(), and processMsgFromNetwork().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation