router.cc

In this implementation of AntNet-3.0 one could get the behavior of both algorithms through a simple

	int sourceNode = msg->getSourceAddress();
	int lastNode = -1;

	// Find out from which neighbor this packet arrived
	// and in this case we only need to modify just ack
	// and send flags of the message already in the table


	if (sourceNode != myAddress)
	{
		cGate *arrivalGate = msg->arrivalGate();
		cGate *networkArrivalGate = arrivalGate->fromGate();
		cModule *neighborNetworkNode = networkArrivalGate->fromGate()->ownerModule();
		int lastNode = neighborNetworkNode->par("address");
	}

	if(probabilisticRouting)
	{
		if( numNeighbors == 1)
		{
			return neighborAtIndex[0];
		}

		else
		{
			double incrProb = 0.0;
			double binProb = uniform(0,1);
			int maxNeighbor = -1;
			double bestProb = 0.0;
			for(int i = 0; i < numNeighbors; i++)
			{
				int neighbor = neighborAtIndex[i];
				if( neighbor != lastNode)
				{

					double Pnd = rTable->getDestViaThisNeighborProb(destination, neighborAtIndex[i]);
					if (Pnd >= 0.7 && neighborAtIndex[i] != lastNode) // choose path with 70% or more porbabiltiy
					{
						return neighborAtIndex[i];
					}

					if( Pnd >= bestProb)
					{
						bestProb = Pnd;
						maxNeighbor = neighbor;
					}

					incrProb += Pnd;

					if(binProb <= incrProb)
					{
						return neighbor;
					}
				}
			}
			return maxNeighbor;
		}
	}

/*
			int port = lastNode;
			while( port == lastNode)
			{
				double incrProb = 0.0;
				double binProb = uniform(0,1);
				for(int i = 0; i < numNeighbors; i++)
				{
					double Pnd = rTable->getDestViaThisNeighborProb(destination, neighborAtIndex[i]);
					if (Pnd >= 0.7 && neighborAtIndex[i] != port) // choose path with 70% or more porbabiltiy
					{
						port = neighborAtIndex[i];
						return port;
					}

					incrProb += Pnd;

					if(binProb <= incrProb && neighborAtIndex[i] != port)
					{
						port = neighborAtIndex[i];
						return port;
					}
				}
			};
		}
	}*/

	// In case we do not want to do probabilistic routing then 
	// we simply route the packet throught highest probabilistic route

	int maxIndex = 0;
	double maxPnd = 0;
	
	for(int i = 0; i < numNeighbors; i++)
	{
		double Pnd = rTable->getDestViaThisNeighborProb(destination, neighborAtIndex[i]);

		if(Pnd >= maxPnd)
		{
			maxPnd = Pnd;
			maxIndex = i;
		}
	}
	return neighborAtIndex[maxIndex];
}

int Router::totalQueueLength()
{
	int totalQ = 0;
	for(int i = 0; i < numNeighbors; i++)
	{
		totalQ +=sendNormalQueue[i].length();
	}
	return totalQ;
}

void Router::deleteAllTimerEventsForThisID(int timerID)
{
	int numInstances = numberOfTimerInstances(timerID);

	if(numInstances != 0)
	{

		cMessage **tMsg = new cMessage*[numInstances];
		int i = 0;

		for(cQueueIterator iter(timerQueue,1); !iter.end(); iter++)
		{
			cMessage *hMsg = (cMessage *) iter();


			// get link State Packet

			if( hMsg->kind() == (int) timerID) 
			{
				tMsg[i++] = hMsg;
			}
		}


		for(int k = 0; k < numInstances; k++)
		{
			cMessage *temp = (cMessage *) timerQueue.remove(tMsg[k]);

			if( temp->isScheduled())
			{
				if( timeOutTimer(timerID))
				{

					// find out context of the pointer
					// and delte timerContext

					timerContextInfo *timerContext = (timerContextInfo *) temp->contextPointer();
					delete timerContext;

				}
				delete cancelEvent(temp);
			}

			else
			{
				delete temp; // simply delete this messages
			}
		}

		delete[] tMsg;
	}
}

int Router::numberOfTimerInstances(int timerID)
{
	int i = 0;
	for(cQueueIterator iter(timerQueue,1); !iter.end(); iter++)
	{
		cMessage *hMsg = (cMessage *) iter();


		// get link State Packet

		if( hMsg->kind() == timerID) 
		{
			i++;
		}
	}
	return i;
}

void Router::deleteTimerEventFromQueueForThisID(int timerID)
{
	cMessage *tMsg = NULL;

	for(cQueueIterator iter(timerQueue,1); !iter.end(); iter++)
	{
		cMessage *hMsg = (cMessage *) iter();


		if( hMsg->kind() == timerID) 
		{
			tMsg = hMsg;
			break;
		}
	}

	if( tMsg!= NULL)
	{

		cMessage *temp = (cMessage *) timerQueue.remove(tMsg);
		if( timeOutTimer(timerID))
		{

			// find out context of the pointer
			// and delte timerContext

			timerContextInfo *timerContext = (timerContextInfo *) temp->contextPointer();
			delete timerContext;

		}

		delete temp; // simply delete this messages
	}
}



bool Router::timeOutTimer( int timerID)
{
	if(   timerID == HELLO_RESEND_TIMER
		||timerID == LINK_STATE_PACKET_RESEND_TIMER
	  )
	{
		return true;
	}

	else
	{
		return false;
	}
}

int Router::getOutGateID(int destRouter)
{
	cGate *outTempGate = gate("out");
	int vectorSize = outTempGate->size();

	for(int i=0; i<vectorSize; i++)
	{
		cGate *outRouterGate = gate("out", i); //access each gate of router
		int gateIDtoNode = outRouterGate->id();
		if(outRouterGate->isConnected())
		{
			
			//get the gate of networkNode to which this gate is connected

			cGate *networkNodeGate = outRouterGate->toGate();
			
			// get the address of the neighbor and then build the map

			if(networkNodeGate->isConnected())
			{
				cModule *neighborNetworkNode = networkNodeGate->toGate()->ownerModule();
				int neighborAddress = neighborNetworkNode->par("address");

				if( destRouter == neighborAddress)
				{
					if(debug)
					{
						ev << "Neighbor: " << neighborAddress << "connected to: "<< 
							myAddress << "at Port: " << gateIDtoNode;
					}
					return gateIDtoNode; //this is gateID
				}
			}
		}
	}

	throw new cException("Could not locate gate to router %d from %d in getOutGateID",
		destRouter, myAddress);
}

int Router::neighborPortID(int neighborAddress, bool dataPacket)
{
	pIter iter;
	for(iter = destGate.begin(); iter != destGate.end(); ++iter)
	{
		pairNumber *sPtr = (pairNumber*) *iter;
		if( sPtr->first == neighborAddress)
		{
			return sPtr->second;
		}
	}

	if (dataPacket )
	{
		return -1;
	}
	else
	{
		throw new cException("Could not locate gate to router %d from %d in neighborPortID",
			neighborAddress, myAddress);
	}
}

bool Router::existsNeighborGatePair(int neighbor)
{
	pIter iter;
	for(iter = destGate.begin(); iter != destGate.end(); ++iter)
	{

		pairNumber *sPtr = (pairNumber*) *iter;
		if( sPtr->first == neighbor)
		{
			return true;
		}
	}
	return false;
}

void Router::deleteNeighborGatePair(int neighbor)
{
	pairNumber *desiredPair = NULL;
	pIter iter;
	pIter temp;
	for(iter = destGate.begin(); iter != destGate.end(); ++iter)
	{

		pairNumber *sPtr = (pairNumber*) *iter;
		if( sPtr->first == neighbor)
		{
			temp = iter;
			desiredPair = *iter;
			break;
		}
	}

	if(temp != destGate.end())
	{
		delete desiredPair;
		destGate.erase(temp);
		return;
	}

	throw new cException("Could not delete gate entry for neighbor %d in Router%d",
	neighbor, myAddress);

}



void Router::findSourceForAnt(Ant *msg)
{
	int source = msg->getSourceModule();

	if( source == ANT_NEST)
	{
		tcb.source = ANT_NEST;
	}

	else if (source = ROUTER)
	{
		tcb.source = ROUTER;
	}
}

int Router::getNumNeighbors() 
{ 
	return numNeighbors; 
}

double Router::getProb(int destination, int neighbor) 
{ 
	return rTable->getDestViaThisNeighborProb(destination, neighbor);
}

void Router::setProb(int destination, int neighbor, double prob) 
{ 
	rTable->setDestViaThisNeighborProb(destination, neighbor, prob);
}

int Router::findIndexForNeighbor(int neighbor) 
{ 
	return indexFromNeighbor[neighbor];
}

int Router::findNeighborAtIndex(int index) 
{ 
	if ( index < numNeighbors)
	{
		return neighborAtIndex[index];
	}
	
	else
	{
		throw new cException(" index %d is out of range, must be less than %d",
			index, numNeighbors);
	}

}

int Router::getNumNodes()
{
	return numNodes;
}

int Router::getMyAddress()
{
	return myAddress;
}

double Router::bitsInQueue(int neighbor)
{
	int index = findIndexForNeighbor(neighbor);
	double numBits = 0.0;


	for(cQueueIterator iter(sendNormalQueue[index],1); !iter.end(); iter++)
	{
		cMessage *sMsg = (cMessage*) iter();
		numBits += sMsg->length();
	}

	return numBits;
}

int Router::queueLength(int neighbor)
{
	int index = findIndexForNeighbor(neighbor);
	return sendNormalQueue[index].length();

}

int Router::getQueueMaxLen()
{
	return queueMaxLen;
}

double Router::getBandwidth()
{
	return dataRate;
}

bool Router::neighborExists(int node)
{
	vector<int>::iterator iter;
	for(iter = topology.begin(); iter != topology.end(); ++iter)
	{
		int neighbor = *iter;
		if(neighbor == node)
		{
			return true;
		}
	}
	return false;
}

void Router::deleteNeighbor(int node)
{
	vector<int>::iterator iter;
	for(iter = topology.begin(); iter != topology.end(); ++iter)
	{
		int neighbor = *iter;
		if(neighbor == node)
		{
			break;
		}
	}
	if(iter != topology.end())
	{
		topology.erase(iter);
	}
}


void Router::finish()
{
	ev << "Module: " << fullPath() << endl;

	for(int i = 0; i < numNeighbors; i++)
	{
	    ev << "Network packets still in queue for Neighbor : " 
			" " << findNeighborAtIndex(i) << "are  "<< sendNormalQueue[i].length() << endl;
		sPtr->incrPacketInQueue( sendNormalQueue[i].length() );
/*        ev << "Percentage dropped: " << (100*numPacketsToSendDropped[i]/(numPacketsToSend[i]-sendNormalQueue[i].length())) << "%" << endl;
		ev << "Total packets received at Router " << myAddress << " for switching to neighbor: "
			<< findNeighborAtIndex(i) << " are: " << numPacketsToSend[i] << endl;
	    ev << "Network packets dropped: " << numPacketsToSendDropped[i] << endl;
	
		ev << "Avg Packet Delay:    " << queueDelayPackets[i].mean() << endl;
		ev << "Max Packet Delay:    " << queueDelayPackets[i].max() << endl;
		ev << "Standard deviation:   "<< queueDelayPackets[i].stddev() << endl;
		ev << endl << endl;*/
	}
}