Ethernet MAC module which supports both half-duplex (CSMA/CD) and full-duplex operation. More...

#include <EtherMAC.h>

Inheritance diagram for inet::EtherMAC:

Classes
struct	PkIdRxTime

Public Member Functions
	EtherMAC ()

virtual	~EtherMAC ()

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 Types
typedef std::list< PkIdRxTime >	EndRxTimeList

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

enum	{ NUM_OF_ETHERDESCRS = 6 }

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	initializeFlags () override

virtual void	initializeStatistics () override

virtual void	handleMessage (cMessage *msg) override

virtual void	finish () override

virtual void	handleSelfMessage (cMessage *msg)

virtual void	handleEndIFGPeriod ()

virtual void	handleEndPausePeriod ()

virtual void	handleEndTxPeriod ()

virtual void	handleEndRxPeriod ()

virtual void	handleEndBackoffPeriod ()

virtual void	handleEndJammingPeriod ()

virtual void	handleRetransmission ()

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

virtual void	processFrameFromUpperLayer (EtherFrame *msg)

virtual void	processMsgFromNetwork (cPacket *msg)

virtual void	scheduleEndIFGPeriod ()

virtual void	fillIFGIfInBurst ()

virtual void	scheduleEndTxPeriod (int64_t sentFrameByteLength)

virtual void	scheduleEndRxPeriod (cPacket *)

virtual void	scheduleEndPausePeriod (int pauseUnits)

virtual void	beginSendFrames ()

virtual void	sendJamSignal ()

virtual void	startFrameTransmission ()

virtual void	frameReceptionComplete ()

virtual void	processReceivedDataFrame (EtherFrame *frame)

virtual void	processReceivedJam (EtherJam *jam)

virtual void	processReceivedPauseFrame (EtherPauseFrame *frame)

virtual void	processConnectDisconnect () override

virtual void	addReception (simtime_t endRxTime)

virtual void	addReceptionInReconnectState (long id, simtime_t endRxTime)

virtual void	processDetectedCollision ()

virtual void	printState ()

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	printParameters ()

virtual void	getNextFrameFromQueue ()

virtual void	requestNextFrameFromExtQueue ()

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
int	numConcurrentTransmissions = 0

int	backoffs = 0

long	currentSendPkTreeID = -1

cPacket *	frameBeingReceived = nullptr

cMessage *	endRxMsg = nullptr

cMessage *	endBackoffMsg = nullptr

cMessage *	endJammingMsg = nullptr

EndRxTimeList	endRxTimeList

simtime_t	totalCollisionTime

simtime_t	totalSuccessfulRxTxTime

simtime_t	channelBusySince

unsigned long	numCollisions = 0

unsigned long	numBackoffs = 0

unsigned int	framesSentInBurst = 0

long	bytesSentInBurst = 0

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

Static Protected Attributes
static simsignal_t	collisionSignal = registerSignal("collision")

static simsignal_t	backoffSignal = registerSignal("backoff")

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")

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")

Detailed Description

Ethernet MAC module which supports both half-duplex (CSMA/CD) and full-duplex operation.

(See also EtherMACFullDuplex which has a considerably smaller code with all the CSMA/CD complexity removed.)

See NED file for more details.

Member Typedef Documentation

typedef std::list<PkIdRxTime> inet::EtherMAC::EndRxTimeList

protected

Constructor & Destructor Documentation

inet::EtherMAC::EtherMAC ( )

inline

41 {}

inet::EtherMAC::~EtherMAC ( )

virtual

 {
     delete frameBeingReceived;
     cancelAndDelete(endRxMsg);
     cancelAndDelete(endBackoffMsg);
     cancelAndDelete(endJammingMsg);
 }

Member Function Documentation

void inet::EtherMAC::addReception ( simtime_t endRxTime )

protectedvirtual

Referenced by processMsgFromNetwork(), and scheduleEndRxPeriod().

 {
     numConcurrentTransmissions++;
 
     if (endRxMsg->getArrivalTime() < endRxTime) {
         cancelEvent(endRxMsg);
         scheduleAt(endRxTime, endRxMsg);
     }
 }

void inet::EtherMAC::addReceptionInReconnectState	(	long	id,
		simtime_t	endRxTime
	)

protectedvirtual

Referenced by processConnectDisconnect(), and processMsgFromNetwork().

 {
     // note: packetTreeId==-1 is legal, and represents a special entry that marks the end of the reconnect state
 
     // housekeeping: remove expired entries from endRxTimeList
     simtime_t now = simTime();
     while (!endRxTimeList.empty() && endRxTimeList.front().endTime <= now)
         endRxTimeList.pop_front();
 
     // remove old entry with same packet tree ID (typically: a frame reception
     // doesn't go through but is canceled by a jam signal)
     auto i = endRxTimeList.begin();
     for ( ; i != endRxTimeList.end(); i++) {
         if (i->packetTreeId == packetTreeId) {
             endRxTimeList.erase(i);
             break;
         }
     }
 
     // find insertion position and insert new entry (list is ordered by endRxTime)
     for (i = endRxTimeList.begin(); i != endRxTimeList.end() && i->endTime <= endRxTime; i++)
         ;
     PkIdRxTime item(packetTreeId, endRxTime);
     endRxTimeList.insert(i, item);
 
     // adjust endRxMsg if needed (we'll exit reconnect mode when endRxMsg expires)
     simtime_t maxRxTime = endRxTimeList.back().endTime;
     if (endRxMsg->getArrivalTime() != maxRxTime) {
         cancelEvent(endRxMsg);
         scheduleAt(maxRxTime, endRxMsg);
     }
 }

void inet::EtherMAC::beginSendFrames ( )

protectedvirtual

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

 {
     if (curTxFrame) {
         // Other frames are queued, therefore wait IFG period and transmit next frame
         EV_DETAIL << "Will transmit next frame in output queue after IFG period\n";
         startFrameTransmission();
     }
     else {
         // No more frames, set transmitter to idle
         transmitState = TX_IDLE_STATE;
         emit(transmitStateSignal, TX_IDLE_STATE);
         EV_DETAIL << "No more frames to send, transmitter set to idle\n";
     }
 }

void inet::EtherMAC::fillIFGIfInBurst ( )

protectedvirtual

Referenced by handleEndTxPeriod(), and processFrameFromUpperLayer().

 {
     if (!frameBursting)
         return;
 
     EV_TRACE << "fillIFGIfInBurst(): t=" << simTime() << ", framesSentInBurst=" << framesSentInBurst << ", bytesSentInBurst=" << bytesSentInBurst << endl;
 
     if (curTxFrame
         && endIFGMsg->isScheduled()
         && (transmitState == WAIT_IFG_STATE)
         && (simTime() == lastTxFinishTime)
         && (simTime() == endIFGMsg->getSendingTime())
         && (framesSentInBurst > 0)
         && (framesSentInBurst < curEtherDescr->maxFramesInBurst)
         && (bytesSentInBurst + (INTERFRAME_GAP_BITS / 8) + PREAMBLE_BYTES + SFD_BYTES + curTxFrame->getByteLength()
             <= curEtherDescr->maxBytesInBurst)
         )
     {
         EtherFilledIFG *gap = new EtherFilledIFG("FilledIFG");
         bytesSentInBurst += gap->getByteLength();
         currentSendPkTreeID = gap->getTreeId();
         send(gap, physOutGate);
         transmitState = SEND_IFG_STATE;
         emit(transmitStateSignal, SEND_IFG_STATE);
         cancelEvent(endIFGMsg);
         scheduleAt(transmissionChannel->getTransmissionFinishTime(), endIFGMsg);
     }
     else {
         bytesSentInBurst = 0;
         framesSentInBurst = 0;
     }
 }

void inet::EtherMAC::finish ( )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::finish();
 
     simtime_t t = simTime();
     simtime_t totalChannelIdleTime = t - totalSuccessfulRxTxTime - totalCollisionTime;
     recordScalar("rx channel idle (%)", 100 * (totalChannelIdleTime / t));
     recordScalar("rx channel utilization (%)", 100 * (totalSuccessfulRxTxTime / t));
     recordScalar("rx channel collision (%)", 100 * (totalCollisionTime / t));
     recordScalar("collisions", numCollisions);
     recordScalar("backoffs", numBackoffs);
 }

void inet::EtherMAC::frameReceptionComplete ( )

protectedvirtual

Referenced by handleEndRxPeriod(), and processMsgFromNetwork().

 {
     EtherTraffic *msg = check_and_cast<EtherTraffic *>(frameBeingReceived);
     frameBeingReceived = nullptr;
 
     if (dynamic_cast<EtherFilledIFG *>(msg) != nullptr) {
         delete msg;
         return;
     }
 
     bool hasBitError = msg->hasBitError();
 
     EtherFrame *frame = decapsulate(check_and_cast<EtherPhyFrame *>(msg));
     emit(packetReceivedFromLowerSignal, frame);
 
     if (hasBitError) {
         numDroppedBitError++;
         emit(dropPkBitErrorSignal, frame);
         delete frame;
         return;
     }
 
     if (dropFrameNotForUs(frame))
         return;
 
     if (dynamic_cast<EtherPauseFrame *>(frame) != nullptr) {
         processReceivedPauseFrame((EtherPauseFrame *)frame);
     }
     else {
         EV_INFO << "Reception of " << frame << " successfully completed.\n";
         processReceivedDataFrame(check_and_cast<EtherFrame *>(frame));
     }
 }

void inet::EtherMAC::handleEndBackoffPeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     if (transmitState != BACKOFF_STATE)
         throw cRuntimeError("At end of BACKOFF and not in BACKOFF_STATE");
 
     if (curTxFrame == nullptr)
         throw cRuntimeError("At end of BACKOFF and no frame to transmit");
 
     if (receiveState == RX_IDLE_STATE) {
         EV_DETAIL << "Backoff period ended, wait IFG\n";
         scheduleEndIFGPeriod();
     }
     else {
         EV_DETAIL << "Backoff period ended but channel is not free, idling\n";
         transmitState = TX_IDLE_STATE;
         emit(transmitStateSignal, TX_IDLE_STATE);
     }
 }

void inet::EtherMAC::handleEndIFGPeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     if (transmitState != WAIT_IFG_STATE && transmitState != SEND_IFG_STATE)
         throw cRuntimeError("Not in WAIT_IFG_STATE at the end of IFG period");
 
     currentSendPkTreeID = 0;
 
     EV_DETAIL << "IFG elapsed\n";
 
     if (frameBursting && (transmitState != SEND_IFG_STATE)) {
         bytesSentInBurst = 0;
         framesSentInBurst = 0;
     }
 
     // End of IFG period, okay to transmit, if Rx idle OR duplexMode ( checked in startFrameTransmission(); )
 
     // send frame to network
     beginSendFrames();
 }

void inet::EtherMAC::handleEndJammingPeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     if (transmitState != JAMMING_STATE)
         throw cRuntimeError("At end of JAMMING but not in JAMMING_STATE");
 
     EV_DETAIL << "Jamming finished, executing backoff\n";
     handleRetransmission();
 }

void inet::EtherMAC::handleEndPausePeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     if (transmitState != PAUSE_STATE)
         throw cRuntimeError("At end of PAUSE and not in PAUSE_STATE");
 
     EV_DETAIL << "Pause finished, resuming transmissions\n";
     beginSendFrames();
 }

void inet::EtherMAC::handleEndRxPeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     simtime_t dt = simTime() - channelBusySince;
 
     switch (receiveState) {
         case RECEIVING_STATE:
             frameReceptionComplete();
             totalSuccessfulRxTxTime += dt;
             break;
 
         case RX_COLLISION_STATE:
             EV_DETAIL << "Incoming signals finished after collision\n";
             totalCollisionTime += dt;
             break;
 
         case RX_RECONNECT_STATE:
             EV_DETAIL << "Incoming signals finished or reconnect time elapsed after reconnect\n";
             endRxTimeList.clear();
             break;
 
         default:
             throw cRuntimeError("model error: invalid receiveState %d", receiveState);
     }
 
     receiveState = RX_IDLE_STATE;
     emit(receiveStateSignal, RX_IDLE_STATE);
     numConcurrentTransmissions = 0;
 
     if (transmitState == TX_IDLE_STATE)
         scheduleEndIFGPeriod();
 }

void inet::EtherMAC::handleEndTxPeriod ( )

protectedvirtual

Referenced by handleSelfMessage().

 {
     // we only get here if transmission has finished successfully, without collision
     if (transmitState != TRANSMITTING_STATE || (!duplexMode && receiveState != RX_IDLE_STATE))
         throw cRuntimeError("End of transmission, and incorrect state detected");
 
     currentSendPkTreeID = 0;
 
     if (curTxFrame == nullptr)
         throw cRuntimeError("Frame under transmission cannot be found");
 
     emit(packetSentToLowerSignal, curTxFrame);    //consider: emit with start time of frame
 
     if (EtherPauseFrame *pauseFrame = dynamic_cast<EtherPauseFrame *>(curTxFrame)) {
         numPauseFramesSent++;
         emit(txPausePkUnitsSignal, pauseFrame->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();
     getNextFrameFromQueue();  // note: cannot be moved into handleEndIFGPeriod(), because in burst mode we need to know whether to send filled IFG or not
 
     // only count transmissions in totalSuccessfulRxTxTime if channel is half-duplex
     if (!duplexMode) {
         simtime_t dt = simTime() - channelBusySince;
         totalSuccessfulRxTxTime += dt;
     }
 
     backoffs = 0;
 
     // check for and obey received PAUSE frames after each transmission
     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();
         if (!txQueue.extQueue)
             fillIFGIfInBurst();
     }
 }

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

overrideprotectedvirtual

 {
     if (!isOperational) {
         handleMessageWhenDown(msg);
         return;
     }
 
     if (channelsDiffer)
         readChannelParameters(true);
 
     printState();
 
     // some consistency check
     if (!duplexMode && transmitState == TRANSMITTING_STATE && receiveState != RX_IDLE_STATE)
         throw cRuntimeError("Inconsistent state -- transmitting and receiving at the same time");
 
     if (msg->isSelfMessage())
         handleSelfMessage(msg);
     else if (msg->getArrivalGate() == upperLayerInGate)
         processFrameFromUpperLayer(check_and_cast<EtherFrame *>(msg));
     else if (msg->getArrivalGate() == physInGate)
         processMsgFromNetwork(check_and_cast<cPacket *>(msg));
     else
         throw cRuntimeError("Message received from unknown gate");
 
     printState();
 }

void inet::EtherMAC::handleRetransmission ( )

protectedvirtual

Referenced by handleEndJammingPeriod().

 {
     if (++backoffs > MAX_ATTEMPTS) {
         EV_DETAIL << "Number of retransmit attempts of frame exceeds maximum, cancelling transmission of frame\n";
         delete curTxFrame;
         curTxFrame = nullptr;
         transmitState = TX_IDLE_STATE;
         emit(transmitStateSignal, TX_IDLE_STATE);
         backoffs = 0;
         getNextFrameFromQueue();
         beginSendFrames();
         return;
     }
 
     EV_DETAIL << "Executing backoff procedure\n";
     int backoffRange = (backoffs >= BACKOFF_RANGE_LIMIT) ? 1024 : (1 << backoffs);
     int slotNumber = intuniform(0, backoffRange - 1);
 
     scheduleAt(simTime() + slotNumber * curEtherDescr->slotTime, endBackoffMsg);
     transmitState = BACKOFF_STATE;
     emit(transmitStateSignal, BACKOFF_STATE);
 
     numBackoffs++;
     emit(backoffSignal, 1L);
 }

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

protectedvirtual

Referenced by handleMessage().

 {
     // Process different self-messages (timer signals)
     EV_TRACE << "Self-message " << msg << " received\n";
 
     switch (msg->getKind()) {
         case ENDIFG:
             handleEndIFGPeriod();
             break;
 
         case ENDTRANSMISSION:
             handleEndTxPeriod();
             break;
 
         case ENDRECEPTION:
             handleEndRxPeriod();
             break;
 
         case ENDBACKOFF:
             handleEndBackoffPeriod();
             break;
 
         case ENDJAMMING:
             handleEndJammingPeriod();
             break;
 
         case ENDPAUSE:
             handleEndPausePeriod();
             break;
 
         default:
             throw cRuntimeError("Self-message with unexpected message kind %d", msg->getKind());
     }
 }

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

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::initialize(stage);
 
     if (stage == INITSTAGE_LOCAL) {
         endRxMsg = new cMessage("EndReception", ENDRECEPTION);
         endBackoffMsg = new cMessage("EndBackoff", ENDBACKOFF);
         endJammingMsg = new cMessage("EndJamming", ENDJAMMING);
 
         // initialize state info
         backoffs = 0;
         numConcurrentTransmissions = 0;
         currentSendPkTreeID = 0;
 
         WATCH(backoffs);
         WATCH(numConcurrentTransmissions);
     }
 }

void inet::EtherMAC::initializeFlags ( )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::initializeFlags();
 
     duplexMode = par("duplexMode").boolValue();
     frameBursting = !duplexMode && par("frameBursting").boolValue();
     physInGate->setDeliverOnReceptionStart(true);
 }

void inet::EtherMAC::initializeStatistics ( )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     EtherMACBase::initializeStatistics();
 
     framesSentInBurst = 0;
     bytesSentInBurst = 0;
 
     WATCH(framesSentInBurst);
     WATCH(bytesSentInBurst);
 
     // initialize statistics
     totalCollisionTime = 0.0;
     totalSuccessfulRxTxTime = 0.0;
     numCollisions = numBackoffs = 0;
 
     WATCH(numCollisions);
     WATCH(numBackoffs);
 }

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

inlineoverrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

45 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::EtherMAC::printState ( )

protectedvirtual

Referenced by handleMessage(), and startFrameTransmission().

 {
 #define CASE(x)    case x: \
         EV_DETAIL << #x; break
 
     EV_DETAIL << "transmitState: ";
     switch (transmitState) {
         CASE(TX_IDLE_STATE);
         CASE(WAIT_IFG_STATE);
         CASE(SEND_IFG_STATE);
         CASE(TRANSMITTING_STATE);
         CASE(JAMMING_STATE);
         CASE(BACKOFF_STATE);
         CASE(PAUSE_STATE);
     }
 
     EV_DETAIL << ",  receiveState: ";
     switch (receiveState) {
         CASE(RX_IDLE_STATE);
         CASE(RECEIVING_STATE);
         CASE(RX_COLLISION_STATE);
         CASE(RX_RECONNECT_STATE);
     }
 
     EV_DETAIL << ",  backoffs: " << backoffs;
     EV_DETAIL << ",  numConcurrentRxTransmissions: " << numConcurrentTransmissions;
 
     if (txQueue.innerQueue)
         EV_DETAIL << ",  queueLength: " << txQueue.innerQueue->getLength();
 
     EV_DETAIL << endl;
 
 #undef CASE
 }

void inet::EtherMAC::processConnectDisconnect ( )

overrideprotectedvirtual

Reimplemented from inet::EtherMACBase.

 {
     if (!connected) {
         delete frameBeingReceived;
         frameBeingReceived = nullptr;
         cancelEvent(endRxMsg);
         cancelEvent(endBackoffMsg);
         cancelEvent(endJammingMsg);
         bytesSentInBurst = 0;
         framesSentInBurst = 0;
     }
 
     EtherMACBase::processConnectDisconnect();
 
     if (connected) {
         if (!duplexMode) {
             // start RX_RECONNECT_STATE
             receiveState = RX_RECONNECT_STATE;
             emit(receiveStateSignal, RX_RECONNECT_STATE);
             simtime_t reconnectEndTime = simTime() + 8 * (MAX_ETHERNET_FRAME_BYTES + JAM_SIGNAL_BYTES) / curEtherDescr->txrate;
             endRxTimeList.clear();
             addReceptionInReconnectState(-1, reconnectEndTime);
         }
     }
 }

void inet::EtherMAC::processDetectedCollision ( )

protectedvirtual

Referenced by processMsgFromNetwork(), and processReceivedJam().

 {
     if (receiveState != RX_COLLISION_STATE) {
         delete frameBeingReceived;
         frameBeingReceived = nullptr;
 
         numCollisions++;
         emit(collisionSignal, 1L);
         // go to collision state
         receiveState = RX_COLLISION_STATE;
         emit(receiveStateSignal, RX_COLLISION_STATE);
     }
 }

void inet::EtherMAC::processFrameFromUpperLayer ( EtherFrame * msg )

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) {
         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);
         curTxFrame = frame;
         fillIFGIfInBurst();
     }
     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 layer, enqueueing\n";
         txQueue.innerQueue->insertFrame(frame);
 
         if (!curTxFrame && !txQueue.innerQueue->isEmpty())
             curTxFrame = (EtherFrame *)txQueue.innerQueue->pop();
     }
 
     if ((duplexMode || receiveState == RX_IDLE_STATE) && transmitState == TX_IDLE_STATE) {
         EV_DETAIL << "No incoming carrier signals detected, frame clear to send\n";
         startFrameTransmission();
     }
 }

void inet::EtherMAC::processMsgFromNetwork ( cPacket * msg )

protectedvirtual

Referenced by handleMessage().

 {
     EV_DETAIL << "Received " << msg << " from network.\n";
 
     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;
     }
 
     // detect cable length violation in half-duplex mode
     if (!duplexMode) {
         simtime_t propagationTime = simTime() - msg->getSendingTime();
         if (propagationTime >= curEtherDescr->maxPropagationDelay) {
             throw cRuntimeError("Very long frame propagation time detected, maybe cable exceeds "
                                 "maximum allowed length? (%lgs corresponds to an approx. %lgm cable)",
                     SIMTIME_STR(propagationTime),
                     SIMTIME_STR(propagationTime * SPEED_OF_LIGHT_IN_CABLE));
         }
     }
 
     simtime_t endRxTime = simTime() + msg->getDuration();
     EtherJam *jamMsg = dynamic_cast<EtherJam *>(msg);
 
     if (duplexMode && jamMsg) {
         throw cRuntimeError("Stray jam signal arrived in full-duplex mode");
     }
     else if (!duplexMode && receiveState == RX_RECONNECT_STATE) {
         long treeId = jamMsg ? jamMsg->getAbortedPkTreeID() : msg->getTreeId();
         addReceptionInReconnectState(treeId, endRxTime);
         delete msg;
     }
     else if (!duplexMode && (transmitState == TRANSMITTING_STATE || transmitState == SEND_IFG_STATE)) {
         // since we're half-duplex, receiveState must be RX_IDLE_STATE (asserted at top of handleMessage)
         if (jamMsg)
             throw cRuntimeError("Stray jam signal arrived while transmitting (usual cause is cable length exceeding allowed maximum)");
 
         // set receive state and schedule end of reception
         receiveState = RX_COLLISION_STATE;
         emit(receiveStateSignal, RX_COLLISION_STATE);
 
         addReception(endRxTime);
         delete msg;
 
         EV_DETAIL << "Transmission interrupted by incoming frame, handling collision\n";
         cancelEvent((transmitState == TRANSMITTING_STATE) ? endTxMsg : endIFGMsg);
 
         EV_DETAIL << "Transmitting jam signal\n";
         sendJamSignal();    // backoff will be executed when jamming finished
 
         numCollisions++;
         emit(collisionSignal, 1L);
     }
     else if (receiveState == RX_IDLE_STATE) {
         if (jamMsg)
             throw cRuntimeError("Stray jam signal arrived (usual cause is cable length exceeding allowed maximum)");
 
         channelBusySince = simTime();
         EV_INFO << "Reception of " << msg << " started.\n";
         scheduleEndRxPeriod(msg);
     }
     else if (receiveState == RECEIVING_STATE
              && !jamMsg
              && endRxMsg->getArrivalTime() - simTime() < curEtherDescr->halfBitTime)
     {
         // With the above condition we filter out "false" collisions that may occur with
         // back-to-back frames. That is: when "beginning of frame" message (this one) occurs
         // BEFORE "end of previous frame" event (endRxMsg) -- same simulation time,
         // only wrong order.
 
         EV_DETAIL << "Back-to-back frames: completing reception of current frame, starting reception of next one\n";
 
         // complete reception of previous frame
         cancelEvent(endRxMsg);
         frameReceptionComplete();
 
         // calculate usability
         totalSuccessfulRxTxTime += simTime() - channelBusySince;
         channelBusySince = simTime();
 
         // start receiving next frame
         scheduleEndRxPeriod(msg);
     }
     else {    // (receiveState==RECEIVING_STATE || receiveState==RX_COLLISION_STATE)
               // handle overlapping receptions
         if (jamMsg) {
             processReceivedJam(jamMsg);
         }
         else {    // EtherFrame or EtherPauseFrame
             EV_DETAIL << "Overlapping receptions -- setting collision state\n";
             addReception(endRxTime);
             // delete collided frames: arrived frame as well as the one we're currently receiving
             delete msg;
             processDetectedCollision();
         }
     }
 }

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

protectedvirtual

Referenced by frameReceptionComplete().

 {
     // 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::EtherMAC::processReceivedJam ( EtherJam * jam )

protectedvirtual

Referenced by processMsgFromNetwork().

 {
     simtime_t endRxTime = simTime() + jam->getDuration();
     delete jam;
 
     numConcurrentTransmissions--;
     if (numConcurrentTransmissions < 0)
         throw cRuntimeError("Received JAM without message");
 
     if (numConcurrentTransmissions == 0 || endRxMsg->getArrivalTime() < endRxTime) {
         cancelEvent(endRxMsg);
         scheduleAt(endRxTime, endRxMsg);
     }
 
     processDetectedCollision();
 }

void inet::EtherMAC::processReceivedPauseFrame ( EtherPauseFrame * frame )

protectedvirtual

Referenced by frameReceptionComplete().

 {
     int pauseUnits = frame->getPauseTime();
     delete frame;
 
     numPauseFramesRcvd++;
     emit(rxPausePkUnitsSignal, pauseUnits);
 
     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::EtherMAC::readChannelParameters ( bool errorWhenAsymmetric )

overrideprotectedvirtual

Calculates datarates, etc.

Verifies the datarates on the incoming/outgoing channels, and throws error when they differ and the parameter errorWhenAsymmetric is true.

Reimplemented from inet::EtherMACBase.

Referenced by handleMessage().

 {
     EtherMACBase::readChannelParameters(errorWhenAsymmetric);
 
     if (connected && !duplexMode) {
         if (curEtherDescr->halfDuplexFrameMinBytes < 0.0)
             throw cRuntimeError("%g bps Ethernet only supports full-duplex links", curEtherDescr->txrate);
     }
 }

void inet::EtherMAC::scheduleEndIFGPeriod ( )

protectedvirtual

Referenced by handleEndBackoffPeriod(), handleEndRxPeriod(), and handleEndTxPeriod().

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

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

protectedvirtual

Referenced by handleEndTxPeriod(), and processReceivedPauseFrame().

 {
     // 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::EtherMAC::scheduleEndRxPeriod ( cPacket * frame )

protectedvirtual

Referenced by processMsgFromNetwork().

 {
     ASSERT(frameBeingReceived == nullptr);
     ASSERT(!endRxMsg->isScheduled());
 
     frameBeingReceived = frame;
     receiveState = RECEIVING_STATE;
     emit(receiveStateSignal, RECEIVING_STATE);
     addReception(simTime() + frame->getDuration());
 }

void inet::EtherMAC::scheduleEndTxPeriod ( int64_t sentFrameByteLength )

protectedvirtual

Referenced by startFrameTransmission().

 {
     // update burst variables
     if (frameBursting) {
         bytesSentInBurst += sentFrameByteLength;
         framesSentInBurst++;
     }
 
     scheduleAt(transmissionChannel->getTransmissionFinishTime(), endTxMsg);
     transmitState = TRANSMITTING_STATE;
     emit(transmitStateSignal, TRANSMITTING_STATE);
 }

void inet::EtherMAC::sendJamSignal ( )

protectedvirtual

Referenced by processMsgFromNetwork(), and startFrameTransmission().

 {
     if (currentSendPkTreeID == 0)
         throw cRuntimeError("Model error: sending JAM while not transmitting");
 
     EtherJam *jam = new EtherJam("JAM_SIGNAL");
     jam->setByteLength(JAM_SIGNAL_BYTES);
     jam->setAbortedPkTreeID(currentSendPkTreeID);
 
     transmissionChannel->forceTransmissionFinishTime(SIMTIME_ZERO);
     //emit(packetSentToLowerSignal, jam);
     send(jam, physOutGate);
 
     scheduleAt(transmissionChannel->getTransmissionFinishTime(), endJammingMsg);
     transmitState = JAMMING_STATE;
     emit(transmitStateSignal, JAMMING_STATE);
 }

void inet::EtherMAC::startFrameTransmission ( )

protectedvirtual

Referenced by beginSendFrames(), and processFrameFromUpperLayer().

 {
     ASSERT(curTxFrame);
 
     EV_INFO << "Transmission of " << curTxFrame << " started.\n";
 
     EtherFrame *frame = curTxFrame->dup();
 
     if (frame->getSrc().isUnspecified())
         frame->setSrc(address);
 
     bool inBurst = frameBursting && framesSentInBurst;
     int64 minFrameLength = duplexMode ? curEtherDescr->frameMinBytes : (inBurst ? curEtherDescr->frameInBurstMinBytes : curEtherDescr->halfDuplexFrameMinBytes);
 
     if (frame->getByteLength() < minFrameLength)
         frame->setByteLength(minFrameLength);
 
     // add preamble and SFD (Starting Frame Delimiter), then send out
     EtherPhyFrame *phyFrame = encapsulate(frame);
 
     currentSendPkTreeID = phyFrame->getTreeId();
     int64_t sentFrameByteLength = phyFrame->getByteLength();
     send(phyFrame, physOutGate);
 
     // check for collisions (there might be an ongoing reception which we don't know about, see below)
     if (!duplexMode && receiveState != RX_IDLE_STATE) {
         // During the IFG period the hardware cannot listen to the channel,
         // so it might happen that receptions have begun during the IFG,
         // and even collisions might be in progress.
         //
         // But we don't know of any ongoing transmission so we blindly
         // start transmitting, immediately collide and send a jam signal.
         //
         EV_DETAIL << "startFrameTransmission(): sending JAM signal.\n";
         printState();
 
         sendJamSignal();
         // numConcurrentRxTransmissions stays the same: +1 transmission, -1 jam
 
         if (receiveState == RECEIVING_STATE) {
             delete frameBeingReceived;
             frameBeingReceived = nullptr;
 
             numCollisions++;
             emit(collisionSignal, 1L);
         }
         // go to collision state
         receiveState = RX_COLLISION_STATE;
         emit(receiveStateSignal, RX_COLLISION_STATE);
     }
     else {
         // no collision
         scheduleEndTxPeriod(sentFrameByteLength);
 
         // only count transmissions in totalSuccessfulRxTxTime if channel is half-duplex
         if (!duplexMode)
             channelBusySince = simTime();
     }
 }