Wiseroute is a simple loop-free routing algorithm that builds a routing tree from a central network point. More...

#include <WiseRoute.h>

Inheritance diagram for inet::WiseRoute:

Classes
struct	tRouteTableEntry

Public Member Functions
	WiseRoute ()

virtual int	numInitStages () const override
	Initialization of the module and some variables. More...

virtual void	initialize (int) override

virtual void	finish () override

virtual	~WiseRoute ()

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

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

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

Protected Types
enum	messagesTypes { DATA, ROUTE_FLOOD, SEND_ROUTE_FLOOD_TIMER }

enum	floodTypes { NOTAFLOOD, FORWARD, FORME, DUPLICATE }

typedef enum inet::WiseRoute::floodTypes	floodTypes

typedef struct inet::WiseRoute::tRouteTableEntry	tRouteTableEntry

typedef std::map< L3Address, tRouteTableEntry >	tRouteTable

typedef std::multimap< tRouteTable::key_type, unsigned long >	tFloodTable

Protected Member Functions
Handle Messages
Functions to redefine by the programmer These are the functions provided to add own functionality to your modules. These functions are called whenever a self message or a data message from the upper or lower layer arrives respectively.
virtual void	handleUpperPacket (cPacket *msg) override
	Handle messages from upper layer. More...

virtual void	handleLowerPacket (cPacket *msg) override
	Handle messages from lower layer. More...

virtual void	handleSelfMessage (cMessage *msg) override
	Handle self messages. More...

virtual void	updateRouteTable (const tRouteTable::key_type &origin, const L3Address &lastHop, double rssi, double ber)
	Update routing table. More...

cMessage *	decapsMsg (WiseRouteDatagram *msg)
	Decapsulate a message. More...

floodTypes	updateFloodTable (bool isFlood, const tFloodTable::key_type &srcAddr, const tFloodTable::key_type &destAddr, unsigned long seqNum)
	update flood table. More...

tFloodTable::key_type	getRoute (const tFloodTable::key_type &destAddr, bool iAmOrigin=false) const
	find a route to destination address. More...

virtual cObject *	setDownControlInfo (cMessage *const pMsg, const MACAddress &pDestAddr)
	Attaches a "control info" (NetwToMac) structure (object) to the message pMsg. More...

Protected Member Functions inherited from inet::NetworkProtocolBase
	NetworkProtocolBase ()

virtual void	handleUpperCommand (cMessage *message) override

virtual void	sendUp (cMessage *message, int transportProtocol)

virtual void	sendDown (cMessage *message, int interfaceId=-1)

virtual bool	isUpperMessage (cMessage *message) override

virtual bool	isLowerMessage (cMessage *message) override

virtual bool	isInitializeStage (int stage) override

virtual bool	isNodeStartStage (int stage) override

virtual bool	isNodeShutdownStage (int stage) override

Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override

virtual void	handleLowerCommand (cMessage *message)

Protected Member Functions inherited from inet::OperationalBase
virtual void	handleMessage (cMessage *msg) override

virtual void	handleMessageWhenDown (cMessage *msg)

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

virtual bool	handleNodeStart (IDoneCallback *doneCallback)

virtual bool	handleNodeShutdown (IDoneCallback *doneCallback)

virtual void	handleNodeCrash ()

virtual void	setOperational (bool isOperational)

Protected Attributes
tRouteTable	routeTable

tFloodTable	floodTable

IARP *	arp = nullptr

int	headerLength = 0
	Length of the NetwPkt header Read from omnetpp.ini. More...

L3Address	myNetwAddr

L3Address	sinkAddress

double	rssiThreshold = 0.0
	Minimal received RSSI necessary for adding source to routing table. More...

double	routeFloodsInterval = 0.0
	Interval [seconds] between two route floods. More...

unsigned long	floodSeqNumber = 0
	Flood sequence number. More...

cMessage *	routeFloodTimer = nullptr

long	nbDataPacketsForwarded = 0

long	nbDataPacketsReceived = 0

long	nbDataPacketsSent = 0

long	nbDuplicatedFloodsReceived = 0

long	nbFloodsSent = 0

long	nbPureUnicastSent = 0

long	nbRouteFloodsSent = 0

long	nbRouteFloodsReceived = 0

long	nbUnicastFloodForwarded = 0

long	nbPureUnicastForwarded = 0

long	nbGetRouteFailures = 0

long	nbRoutesRecorded = 0

long	nbHops = 0

cOutVector	receivedRSSI

cOutVector	routeRSSI

cOutVector	allReceivedRSSI

cOutVector	allReceivedBER

cOutVector	routeBER

cOutVector	receivedBER

cOutVector	nextHopSelectionForSink

bool	trace = false

Protected Attributes inherited from inet::NetworkProtocolBase
ProtocolMapping	protocolMapping

IInterfaceTable *	interfaceTable

Protected Attributes inherited from inet::OperationalBase
bool	isOperational

simtime_t	lastChange

Private Member Functions
	WiseRoute (const WiseRoute &)
	Copy constructor is not allowed. More...

WiseRoute &	operator= (const WiseRoute &)
	Assignment operator is not allowed. More...

Additional Inherited Members
Static Public Attributes inherited from inet::LayeredProtocolBase
static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")

static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")

static simsignal_t	packetFromUpperDroppedSignal = registerSignal("packetFromUpperDropped")

static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")

static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")

static simsignal_t	packetFromLowerDroppedSignal = registerSignal("packetFromLowerDropped")

Detailed Description

Wiseroute is a simple loop-free routing algorithm that builds a routing tree from a central network point.

It is especially useful for wireless sensor networks and convergecast traffic, hence its name (Wireless Sensors Routing). The sink (the device at the center of the network) broadcasts a route building message. Each network node that receives it selects the sink as parent in the routing tree, and rebroadcasts the route building message. This procedure maximizes the probability that all network nodes can join the network, and avoids loops.

Author: Jerome Rousselot

Member Typedef Documentation

typedef enum inet::WiseRoute::floodTypes inet::WiseRoute::floodTypes

protected

typedef std::multimap<tRouteTable::key_type, unsigned long> inet::WiseRoute::tFloodTable

protected

typedef std::map<L3Address, tRouteTableEntry> inet::WiseRoute::tRouteTable

protected

typedef struct inet::WiseRoute::tRouteTableEntry inet::WiseRoute::tRouteTableEntry

protected

Member Enumeration Documentation

enum inet::WiseRoute::floodTypes

protected

Enumerator
NOTAFLOOD
FORWARD
FORME
DUPLICATE

                             {
         NOTAFLOOD,
         FORWARD,
         FORME,
         DUPLICATE
     } floodTypes;

enum inet::WiseRoute::messagesTypes

protected

Enumerator
DATA
ROUTE_FLOOD
SEND_ROUTE_FLOOD_TIMER

                        {
         DATA,
         ROUTE_FLOOD,
         SEND_ROUTE_FLOOD_TIMER
     };

Constructor & Destructor Documentation

inet::WiseRoute::WiseRoute ( const WiseRoute & )

private

Copy constructor is not allowed.

inet::WiseRoute::WiseRoute ( )

inline

62 {}

inet::WiseRoute::~WiseRoute ( )

virtual

 {
     cancelAndDelete(routeFloodTimer);
 }

Member Function Documentation

cMessage * inet::WiseRoute::decapsMsg ( WiseRouteDatagram * msg )

protected

Decapsulate a message.

Referenced by handleLowerPacket().

 {
     cMessage *m = msg->decapsulate();
     SimpleNetworkProtocolControlInfo *const controlInfo = new SimpleNetworkProtocolControlInfo();
     controlInfo->setSourceAddress(msg->getInitialSrcAddr());
     controlInfo->setTransportProtocol(msg->getTransportProtocol());
     m->setControlInfo(controlInfo);
     nbHops = nbHops + msg->getNbHops();
     // delete the netw packet
     delete msg;
     return m;
 }

void inet::WiseRoute::finish ( )

overridevirtual

 {
     recordScalar("nbDataPacketsForwarded", nbDataPacketsForwarded);
     recordScalar("nbDataPacketsReceived", nbDataPacketsReceived);
     recordScalar("nbDataPacketsSent", nbDataPacketsSent);
     recordScalar("nbDuplicatedFloodsReceived", nbDuplicatedFloodsReceived);
     recordScalar("nbFloodsSent", nbFloodsSent);
     recordScalar("nbPureUnicastSent", nbPureUnicastSent);
     recordScalar("nbRouteFloodsSent", nbRouteFloodsSent);
     recordScalar("nbRouteFloodsReceived", nbRouteFloodsReceived);
     recordScalar("nbUnicastFloodForwarded", nbUnicastFloodForwarded);
     recordScalar("nbPureUnicastForwarded", nbPureUnicastForwarded);
     recordScalar("nbGetRouteFailures", nbGetRouteFailures);
     recordScalar("nbRoutesRecorded", nbRoutesRecorded);
     recordScalar("meanNbHops", (double)nbHops / (double)nbDataPacketsReceived);
 }

WiseRoute::tFloodTable::key_type inet::WiseRoute::getRoute	(	const tFloodTable::key_type &	destAddr,
		bool	iAmOrigin = `false`
	)		const

protected

find a route to destination address.

Referenced by handleLowerPacket(), and handleUpperPacket().

 {
     // Find a route to dest address. As in the embedded code, if no route exists, indicate
     // final destination as next hop. If we'are lucky, final destination is one hop away...
     // If I am the origin of the packet and no route exists, use flood, hence return broadcast
     // address for next hop.
     tRouteTable::const_iterator pos = routeTable.find(destAddr);
     if (pos != routeTable.end())
         return pos->second.nextHop;
     else
         return myNetwAddr.getAddressType()->getBroadcastAddress();
 }

void inet::WiseRoute::handleLowerPacket ( cPacket * msg )

overrideprotectedvirtual

Handle messages from lower layer.

Implements inet::LayeredProtocolBase.

 {
     WiseRouteDatagram *netwMsg = check_and_cast<WiseRouteDatagram *>(msg);
     const L3Address& finalDestAddr = netwMsg->getFinalDestAddr();
     const L3Address& initialSrcAddr = netwMsg->getInitialSrcAddr();
     const L3Address& srcAddr = netwMsg->getSrcAddr();
     check_and_cast<IMACProtocolControlInfo *>(netwMsg->getControlInfo());
     // KLUDGE: TODO: get rssi and ber
     EV_ERROR << "Getting RSSI and BER from the received frame is not yet implemented. Using default values.\n";
     double rssi = 1;    // TODO: ctrlInfo->getRSSI();
     double ber = 0;    // TODO: ctrlInfo->getBitErrorRate();
     // Check whether the message is a flood and if it has to be forwarded.
     floodTypes floodType = updateFloodTable(netwMsg->getIsFlood(), initialSrcAddr, finalDestAddr,
                 netwMsg->getSeqNum());
     allReceivedRSSI.record(rssi);
     allReceivedBER.record(ber);
     if (floodType == DUPLICATE) {
         nbDuplicatedFloodsReceived++;
         delete netwMsg;
     }
     else {
         const cObject *pCtrlInfo = nullptr;
         // If the message is a route flood, update the routing table.
         if (netwMsg->getKind() == ROUTE_FLOOD)
             updateRouteTable(initialSrcAddr, srcAddr, rssi, ber);
 
         if (finalDestAddr == myNetwAddr || finalDestAddr.isBroadcast()) {
             WiseRouteDatagram *msgCopy;
             if (floodType == FORWARD) {
                 // it's a flood. copy for delivery, forward original.
                 // if we are here (see updateFloodTable()), finalDestAddr == IP Broadcast. Hence finalDestAddr,
                 // initialSrcAddr, and destAddr have already been correctly set
                 // at origin, as well as the MAC control info. Hence only update
                 // local hop source address.
                 msgCopy = check_and_cast<WiseRouteDatagram *>(netwMsg->dup());
                 netwMsg->setSrcAddr(myNetwAddr);
                 pCtrlInfo = netwMsg->removeControlInfo();
                 setDownControlInfo(netwMsg, MACAddress::BROADCAST_ADDRESS);
                 netwMsg->setNbHops(netwMsg->getNbHops() + 1);
                 sendDown(netwMsg);
                 nbDataPacketsForwarded++;
             }
             else
                 msgCopy = netwMsg;
             if (msgCopy->getKind() == DATA) {
                 int protocol = msgCopy->getTransportProtocol();
                 sendUp(decapsMsg(msgCopy), protocol);
                 nbDataPacketsReceived++;
             }
             else {
                 nbRouteFloodsReceived++;
                 delete msgCopy;
             }
         }
         else {
             // not for me. if flood, forward as flood. else select a route
             if (floodType == FORWARD) {
                 netwMsg->setSrcAddr(myNetwAddr);
                 pCtrlInfo = netwMsg->removeControlInfo();
                 setDownControlInfo(netwMsg, MACAddress::BROADCAST_ADDRESS);
                 netwMsg->setNbHops(netwMsg->getNbHops() + 1);
                 sendDown(netwMsg);
                 nbDataPacketsForwarded++;
                 nbUnicastFloodForwarded++;
             }
             else {
                 L3Address nextHop = getRoute(finalDestAddr);
                 if (nextHop.isBroadcast()) {
                     // no route exist to destination, attempt to send to final destination
                     nextHop = finalDestAddr;
                     nbGetRouteFailures++;
                 }
                 netwMsg->setSrcAddr(myNetwAddr);
                 netwMsg->setDestAddr(nextHop);
                 pCtrlInfo = netwMsg->removeControlInfo();
                 MACAddress nextHopMacAddr = arp->resolveL3Address(nextHop, nullptr);    //FIXME interface entry pointer needed
                 if (nextHopMacAddr.isUnspecified())
                     throw cRuntimeError("Cannot immediately resolve MAC address. Please configure a GenericARP module.");
                 setDownControlInfo(netwMsg, nextHopMacAddr);
                 netwMsg->setNbHops(netwMsg->getNbHops() + 1);
                 sendDown(netwMsg);
                 nbDataPacketsForwarded++;
                 nbPureUnicastForwarded++;
             }
         }
         if (pCtrlInfo != nullptr)
             delete pCtrlInfo;
     }
 }

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

overrideprotectedvirtual

Handle self messages.

Reimplemented from inet::LayeredProtocolBase.

 {
     if (msg->getKind() == SEND_ROUTE_FLOOD_TIMER) {
         // Send route flood packet and restart the timer
         WiseRouteDatagram *pkt = new WiseRouteDatagram("route-flood", ROUTE_FLOOD);
         L3Address broadcastAddress = myNetwAddr.getAddressType()->getBroadcastAddress();
         pkt->setByteLength(headerLength);
         pkt->setInitialSrcAddr(myNetwAddr);
         pkt->setFinalDestAddr(broadcastAddress);
         pkt->setSrcAddr(myNetwAddr);
         pkt->setDestAddr(broadcastAddress);
         pkt->setNbHops(0);
         floodTable.insert(make_pair(myNetwAddr, floodSeqNumber));
         pkt->setSeqNum(floodSeqNumber);
         floodSeqNumber++;
         pkt->setIsFlood(1);
         setDownControlInfo(pkt, MACAddress::BROADCAST_ADDRESS);
         sendDown(pkt);
         nbFloodsSent++;
         nbRouteFloodsSent++;
         scheduleAt(simTime() + routeFloodsInterval + uniform(0, 1), routeFloodTimer);
     }
     else {
         EV << "WiseRoute - handleSelfMessage: got unexpected message of kind " << msg->getKind() << endl;
         delete msg;
     }
 }

void inet::WiseRoute::handleUpperPacket ( cPacket * msg )

overrideprotectedvirtual

Handle messages from upper layer.

Implements inet::LayeredProtocolBase.

 {
     L3Address finalDestAddr;
     L3Address nextHopAddr;
     MACAddress nextHopMacAddr;
     WiseRouteDatagram *pkt = new WiseRouteDatagram(msg->getName(), DATA);
     INetworkProtocolControlInfo *cInfo = check_and_cast<INetworkProtocolControlInfo *>(msg->removeControlInfo());
 
     pkt->setByteLength(headerLength);
 
     if (cInfo == nullptr) {
         EV << "WiseRoute warning: Application layer did not specifiy a destination L3 address\n"
            << "\tusing broadcast address instead\n";
         finalDestAddr = myNetwAddr.getAddressType()->getBroadcastAddress();
     }
     else {
         EV << "WiseRoute: CInfo removed, netw addr=" << cInfo->getDestinationAddress() << endl;
         finalDestAddr = cInfo->getDestinationAddress();
     }
 
     pkt->setFinalDestAddr(finalDestAddr);
     pkt->setInitialSrcAddr(myNetwAddr);
     pkt->setSrcAddr(myNetwAddr);
     pkt->setNbHops(0);
     pkt->setTransportProtocol(cInfo->getTransportProtocol());
     delete cInfo;
 
     if (finalDestAddr.isBroadcast())
         nextHopAddr = myNetwAddr.getAddressType()->getBroadcastAddress();
     else
         nextHopAddr = getRoute(finalDestAddr, true);
     pkt->setDestAddr(nextHopAddr);
     if (nextHopAddr.isBroadcast()) {
         // it's a flood.
         nextHopMacAddr = MACAddress::BROADCAST_ADDRESS;
         pkt->setIsFlood(1);
         nbFloodsSent++;
         // record flood in flood table
         floodTable.insert(make_pair(myNetwAddr, floodSeqNumber));
         pkt->setSeqNum(floodSeqNumber);
         floodSeqNumber++;
         nbGetRouteFailures++;
     }
     else {
         pkt->setIsFlood(0);
         nbPureUnicastSent++;
         nextHopMacAddr = arp->resolveL3Address(nextHopAddr, nullptr);    //FIXME interface entry pointer needed
         if (nextHopMacAddr.isUnspecified())
             throw cRuntimeError("Cannot immediately resolve MAC address. Please configure a GenericARP module.");
     }
     setDownControlInfo(pkt, nextHopMacAddr);
     pkt->encapsulate(static_cast<cPacket *>(msg));
     sendDown(pkt);
     nbDataPacketsSent++;
 }

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

overridevirtual

Reimplemented from inet::NetworkProtocolBase.

 {
     NetworkProtocolBase::initialize(stage);
     if (stage == INITSTAGE_LOCAL) {
         arp = getModuleFromPar<IARP>(par("arpModule"), this);
         headerLength = par("headerLength");
         rssiThreshold = par("rssiThreshold").doubleValue();
         rssiThreshold = math::dBm2mW(rssiThreshold);
         routeFloodsInterval = par("routeFloodsInterval");
 
         floodSeqNumber = 0;
 
         nbDataPacketsForwarded = 0;
         nbDataPacketsReceived = 0;
         nbDataPacketsSent = 0;
         nbDuplicatedFloodsReceived = 0;
         nbFloodsSent = 0;
         nbPureUnicastSent = 0;
         nbRouteFloodsSent = 0;
         nbRouteFloodsReceived = 0;
         nbUnicastFloodForwarded = 0;
         nbPureUnicastForwarded = 0;
         nbGetRouteFailures = 0;
         nbRoutesRecorded = 0;
         nbHops = 0;
         receivedRSSI.setName("receivedRSSI");
         routeRSSI.setName("routeRSSI");
         allReceivedRSSI.setName("allReceivedRSSI");
         receivedBER.setName("receivedBER");
         routeBER.setName("routeBER");
         allReceivedBER.setName("allReceivedBER");
         nextHopSelectionForSink.setName("nextHopSelectionForSink");
 
         routeFloodTimer = new cMessage("route-flood-timer", SEND_ROUTE_FLOOD_TIMER);
     }
     else if (stage == INITSTAGE_NETWORK_LAYER_3) {
         L3AddressResolver addressResolver;
         sinkAddress = addressResolver.resolve(par("sinkAddress"));
 
         IInterfaceTable *interfaceTable = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
         myNetwAddr = interfaceTable->getInterface(1)->getNetworkAddress();
 
         // only schedule a flood of the node is a sink!!
         if (routeFloodsInterval > 0 && myNetwAddr == sinkAddress)
             scheduleAt(simTime() + uniform(0.5, 1.5), routeFloodTimer);
     }
 }

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

inlineoverridevirtual

Initialization of the module and some variables.

Reimplemented from inet::OperationalBase.

64 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

WiseRoute& inet::WiseRoute::operator= ( const WiseRoute & )

private

Assignment operator is not allowed.

cObject * inet::WiseRoute::setDownControlInfo	(	cMessage *const	pMsg,
		const MACAddress &	pDestAddr
	)

protectedvirtual

Attaches a "control info" (NetwToMac) structure (object) to the message pMsg.

Attaches a "control info" structure (object) to the down message pMsg.

This is most useful when passing packets between protocol layers of a protocol stack, the control info will contain the destination MAC address.

The "control info" object will be deleted when the message is deleted. Only one "control info" structure can be attached (the second setL3ToL2ControlInfo() call throws an error).

Parameters

pMsg	The message where the "control info" shall be attached.
pDestAddr	The MAC address of the message receiver.

Referenced by handleLowerPacket(), handleSelfMessage(), and handleUpperPacket().

 {
     SimpleLinkLayerControlInfo *const cCtrlInfo = new SimpleLinkLayerControlInfo();
     cCtrlInfo->setDest(pDestAddr);
     pMsg->setControlInfo(cCtrlInfo);
     return cCtrlInfo;
 }

WiseRoute::floodTypes inet::WiseRoute::updateFloodTable	(	bool	isFlood,
		const tFloodTable::key_type &	srcAddr,
		const tFloodTable::key_type &	destAddr,
		unsigned long	seqNum
	)

protected

update flood table.

returns detected flood type (general or unicast flood to forward, duplicate flood to delete, unicast flood to me

Referenced by handleLowerPacket().

 {
     if (isFlood) {
         auto pos = floodTable.lower_bound(srcAddr);
         auto posEnd = floodTable.upper_bound(srcAddr);
 
         while (pos != posEnd) {
             if (seqNum == pos->second)
                 return DUPLICATE; // this flood is known, don't forward it.
             ++pos;
         }
         floodTable.insert(make_pair(srcAddr, seqNum));
         if (destAddr == myNetwAddr)
             return FORME;
         else
             return FORWARD;
     }
     else
         return NOTAFLOOD;
 }

void inet::WiseRoute::updateRouteTable	(	const tRouteTable::key_type &	origin,
		const L3Address &	lastHop,
		double	rssi,
		double	ber
	)

protectedvirtual

Update routing table.

The tuple provided in argument gives the next hop address to the origin. The table is updated only if the RSSI value is above the threshold.

Referenced by handleLowerPacket().

 {
     auto pos = routeTable.find(origin);
     receivedRSSI.record(rssi);
     receivedBER.record(ber);
     if (pos == routeTable.end()) {
         // A route towards origin does not exist yet. Insert the currently discovered one
         // only if the received RSSI is above the threshold.
         if (rssi > rssiThreshold) {
             tRouteTableEntry newEntry;
 
             // last hop from origin means next hop towards origin.
             newEntry.nextHop = lastHop;
             newEntry.rssi = rssi;
             routeRSSI.record(rssi);
             routeBER.record(ber);
             routeTable.insert(make_pair(origin, newEntry));
             nbRoutesRecorded++;
             if (origin.isUnspecified()) {
                 // TODO: nextHopSelectionForSink.record(static_cast<double>(lastHop));
             }
         }
     }
     else {
         // A route towards the node which originated the received packet already exists.
         // Replace its entry only if the route proposal that we just received has a stronger
         // RSSI.
 //        tRouteTableEntry entry = pos->second;
 //        if (entry.rssi > rssiThreshold) {
 //            entry.nextHop = lastHop;
 //            entry.rssi = rssi;
 //            if (origin == 0)
 //                nextHopSelectionForSink.record(lastHop);
 //        }
     }
 }