wuli.h

clustering for ns-2 simulation

/**
 * Copyright (c) 2006 Michele Mastrogiovanni.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 */
 
#ifndef _WULI_H_
#define _WULI_H_

#include <vector>

////////////////////
// Stato del nodo //
////////////////////
typedef enum {
	WULI_STATUS_HELLO = 0x1,			// Il nodo sta ricevendo informazioni dai vicini.
	WULI_STATUS_FIRST_DECISION = 0x2,  	// Il nodo si e' colorato la prima volta.
	WULI_STATUS_LAST_DECISION = 0x3,  	// Il nodo si e' colorato l'ultima volta.
	WULI_STATUS_END = 0x4				// Il nodo ha terminato l'algoritmo di colorazione.
} WuliStatus;

//////////////////////
// Tipi di messaggi //
//////////////////////
typedef enum
{
	WULI_NEIGHBORS = 0x0,			// Messaggio per comunicare la propria lista dei vicini.
	WULI_COLOR = 0x1,				// Messaggio per comunicare il colore.
	WULI_REQUEST = 0x2,				// Messaggio di richiesta di ritrasmissione.
	WULI_DATA = 0x3					// Messaggio di dati.
} WuliMessageType;

//////////////////////////
// Header del pacchetto //
//////////////////////////
struct hdr_wuli 
{
	
	WuliMessageType msg_type;			// Tipo di messaggio.
	WuliStatus status;					// Stato del nodo all'invio del messaggio (usato per le ritrasmissioni).
	NodeList * node_list;               // Lista dei vicini del mittente (solo per messaggio di tipo WULI_NEIGHBORS).
	Color color;                        // Informazioni sul colore (messaggio WULI_COLOR).
	
	////////////////////
	// Accessibilita' //
	////////////////////
	static int offset_;
	inline static int& offset() { return offset_; }
	inline static hdr_wuli* access(const Packet* p) {
		return (hdr_wuli*) p->access(offset_);
	}
};

///////////
// Timer //
///////////
class WuliTimer;

///////////
// Agent //
///////////
class WULI_Agent : public ClusteringModule
{
public:
	
	WULI_Agent();
	
	// Funzione di ricezione dell'algoritmo di clustering.
	virtual void receive(Packet * p, Handler * h);
	
	// Fa partire il modulo.
	virtual void startModule();
	
	// Termine del lavoro del modulo.
	virtual void endModule();
		
	// Segnala lo scadere di un timeout per un messaggio.
	void timeout(WuliStatus type, NodeAddress from);
	
	// Segnala il raggiungimento del massimo numero di timeout per un messaggio.
	void lastTimeout(WuliStatus type, NodeAddress from);
	
	// Verifica che un pacchetto sia di tipo DATA.
	virtual bool isDataPacket(Packet * p);
	
	// Preparazione all'invio di un messaggio al layer inferiore
	virtual void prepareSendDataDown(Packet * p);
		
protected:
		
	Color firstColor;				// Primo colore del nodo (memorizzato per le ritrasmissioni).
	Color lastColor;				// Ultimo colore del nodo (memorizzato per le ritrasmissioni).
	WuliStatus status;				// Stato dell'agente.
	NodeColor firstColorNeighbors;	// Mappa del primo colore dei vicini.
	NodeColor lastColorNeighbors;	// Mappa dell'ultimo colore dei vicini (e il clusterHead).
	NodeNeighbors nodeNeighbors;	// Vicini dei vicini.
	NodeNeighbors shortNeighbors;	// Vicini dei vicini che sono anche vicini del nodo. Il nodo escluso.
	WuliTimer * timer;				// Gestore dei timeout.
	
protected:
		
	///////////////
	// Procedure //
	///////////////
		
	// Gestione della fase di transisione da uno stato all'altro
	void processStatus();
		
	// Invia la propria lista dei vicini ad un nodo o a tutti.
	void send_NEIGHBORS(NodeAddress to);
	
	// Invia la segnalazione di colore (BIANCO o NERO) per una fase dell'algoritmo.
	void send_COLOR(WuliStatus status, NodeAddress to, Color color);
	
	// Invia la richiesta di un certo messaggio ad un vicino.
	void send_REQUEST(WuliStatus message, NodeAddress to);
	
	// Ricezione della lista dei vicini di un vicino.
	void receive_NEIGHBORS(NodeAddress from, NodeList & neighbors);
	
	// Ricezione del colore NERO di un vicino per una fase del protocollo.
	void receive_COLOR(NodeAddress from, WuliStatus status, Color color);
	
	// Ricezione di una richiesta di ritrasmissione per un messaggio da parte di un vicino.
	void receive_REQUEST(NodeAddress from, WuliStatus message);
	
	////////////////////
	// Interrogazioni //
	////////////////////
	
	// Verifica se due vicini del nodo solo NON connessi.
	bool twoNeighborsAreUnlinked();
	
	// Verifica se il nodo passato come parametro copre tutti i vicini del nodo (REGOLA 1).
	bool neighborsCoversMyNeighbors(NodeList & nodes);
	
	// Verifica la REGOLA sulla base delle lunghezze specificate.
	bool checkRule(int max);

	bool neighborsConnected(NodeList & nodes);
	
	// Crea un vettore di combinazioni.
	void makeCombinations(NodeList & elements, Combinations & combinations, NodeList & lengths);
	
	void printDecoloredMessage(NodeList & nodi);

	// Restituisce il piu'grande vicino NERO.
	NodeAddress greaterCluster();

public:

	static int degree;			// Variante degree.
	static int stojmenovic;		// Variation Stojmenovic (no second communication phase).
	static int _DEBUG_;
	static int limit;
	static double max_delay;
	static int max_timeout_hello;
	static double jitter_timeout_hello;
	static double timeout_hello;
	static int max_timeout_first_decision;
	static double jitter_timeout_first_decision;
	static double timeout_first_decision;
	static int max_timeout_last_decision;
	static double jitter_timeout_last_decision;
	static double timeout_last_decision;

};

/////////////////////////////////
// Timer per le ritrasmissioni //
/////////////////////////////////
class WuliTimer: public Handler {
public:
	
	WuliTimer(WULI_Agent * a) : Handler(), agent(a) {}
	
	void handle(Event* e);
	
	// Inizializza i timeout di un nodo
	void initTimeouts(NodeList & neighbors);
	
	// Lancia tutti i timeout per i messaggi HELLO.
	void launchHelloTimeouts();
	
	// Lancia tutti i timeout per i messaggi FIRST DECISION.
	void launchFirstDecisionTimeouts();
	
	// Lancia tutti i timeout per i messaggi SECOND DECISION.
	void launchLastDecisionTimeouts();
	
	// Viene segnalata la ricezione di un messaggio di HELLO: si elimina il timeout.
	void receivedHello(NodeAddress from);
	
	// Viene segnalata la ricezione di un messaggio di FIRST DECISION: si elimina il timeout.
	void receivedFirstDecision(NodeAddress from);
	
	// Viene segnalata la ricezione di un messaggio di SECOND DECISION: si elimina il timeout.
	void receivedLastDecision(NodeAddress from);
	
	// Verifica che il timeout sia per il messaggio di HELLO.
	bool isHelloTimeout(Event * e);
	
	// Verifica che il timeout sia per il messaggio di FIRST DECISION.
	bool isFirstDecisionTimeout(Event * e);
	
	// Verifica che il timeout sia per il messaggio di LAST DECISION.
	bool isLastDecisionTimeout(Event * e);
	
protected:
		
	// Timeout attivi per i messaggi HELLO.
	TimeoutMap hello_timeouts;
	
	// Timeout attivi per i messaggi FIRST DECISION.
	TimeoutMap first_decision_timeouts;
	
	// Timeout attivi per i messaggi LAST DECISION.
	TimeoutMap last_decision_timeouts;
	
	// Agente proprietario del Timer.
	WULI_Agent * agent;

};

#endif