c-sparsifier.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 _C_SPARSIFIER_H_
#define _C_SPARSIFIER_H_

#include "ClusteringModule.h"
#include "CSparsifierUtility.h"

////////////////////
// Stato del nodo //
////////////////////
typedef enum {
	CSPARISFIER_STATUS_CANDIDATE = 0x1,			// Il nodo sta ricevendo informazioni dai vicini sulle loro preferenze.
	CSPARISFIER_STATUS_CONNECT = 0x2,			// Il nodo sta ricevendo la conferma di connessione dai vicini scelti.
	CSPARISFIER_STATUS_END = 0x3				// Il nodo ha terminato l'algoritmo.
} CSparsifierStatus;

//////////////////////
// Tipi di messaggi //
//////////////////////
typedef enum
{
	CSPARSIFIER_CANDIDATE = 0x1,	// Messaggio di candidatura.
	CSPARSIFIER_CONNECT = 0x2,		// Messaggio di connessione.
	CSPARSIFIER_REQUEST = 0x3,		// Messaggio di richiesta.
	CSPARSIFIER_DATA = 0x4			// Messaggio di DATI.
} CSparsifierMessageType;

///////////////////
/// Timeout type //
///////////////////
typedef enum {
	TIMEOUT_CONNECT = 0x1,		// Timeout per il messaggio CONNECT.
	TIMEOUT_CANDIDATE = 0x2		// Timeout per il messaggio CANDIDATE.
} CSparsifierTimeoutType;

//////////////////////////
// Header del pacchetto //
//////////////////////////
struct hdr_c_sparsifier
{
	
	CSparsifierMessageType msg_type;	// Tipo di messaggio.
	NodeAddress sender_address;			// Mittente.
	NodeAddress destination_address;	// Destinatario: -1 per il broadcast.
	CSparsifierMessageType request;
	NodeList * selectedNodes;			// Nodi selezionati (nel processo di candidatura).
	
	////////////////////
	// Accessibilita' //
	////////////////////
	static int offset_;
	inline static int& offset() { return offset_; }
	inline static hdr_c_sparsifier* access(const Packet* p) {
		return (hdr_c_sparsifier*) p->access(offset_);
	}
};

///////////
// Timer //
///////////
class CSparsifierTimer;

///////////
// Agent //
///////////
class CSPARSIFIER_Agent : public ClusteringModule
{
public:
	
	CSPARSIFIER_Agent();

	/**
	 * Query if algorithm support a particular protocol:
	 * that method is probably called before a getData
	 * method.
	 */
	virtual bool supportProtocol(string protocol);
	
	/**
	 * That method is used to get data from an algorithm
	 * that was check to implements a particular protocol
	 */
	virtual void * getData(string data);
	
	// Funzione di ricezione del modulo.
	virtual void receive(Packet * p, Handler * h);
	
	// Fa partire il modulo.
	virtual void startModule();
	
	virtual NodeList & getNeighbors();
	
	// Termine del lavoro del modulo.
	virtual void endModule();
	
	// Segnala lo scadere di un timeout per un messaggio.
	void timeout(NodeAddress from, CSparsifierTimeoutType timeout);
	
	// Segnala il raggiungimento del massimo numero di timeout per un messaggio.
	void lastTimeout(NodeAddress from, CSparsifierTimeoutType timeout);
	
	// 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:
		
	map<NodeAddress, NodeList> selectedNodes;   // Nodi Selezionati da ogni vicino.
	NodeList neighbors;							// Vicini.
	NodeList candidateNeighbors;				// Subset di vicini candidati.
	NodeList sparseNeighbors;					// Subset di vicini finali.
	
	NodeList connect_nodes;						// Vicini che hanno inviato un messaggio CONNECT
												// mentre il nodo era ancora in fase di candidatura.
	
	CSparsifierStatus status;					// Stato dell'agente.
	CSparsifierTimer * timer;					// Gestore dei timeout.
	
protected:
		
	///////////////
	// Procedure //
	///////////////
		
	// Invia un messaggio di saluto ai vicini per richiedere i loro vicini.
	void send_CANDIDATE(NodeAddress to);
	
	// Invia un messaggio per confermare il link.
	void send_CONNECT(NodeAddress to);
	
	// Invia un richiesta di ritrasmessione
	void send_REQUEST(NodeAddress to, CSparsifierMessageType type);
	
	// Ricezione di un messaggio CANDIDATE.
	void receive_CANDIDATE(NodeAddress from, NodeList & selected);
	
public:
		
	static int _DEBUG_;

	static int virtual_neighbors;
	static double max_delay;
	static int max_timeout_connect;
	static double jitter_timeout_connect;
	static double timeout_connect;
	static int max_timeout_candidate;
	static double jitter_timeout_candidate;
	static double timeout_candidate;
	
};

/////////////////////////////////
// Timer per le ritrasmissioni //
/////////////////////////////////
class CSparsifierTimer: public Handler {
public:
	
	CSparsifierTimer(CSPARSIFIER_Agent * a) : Handler(), agent(a) {}
	
	void handle(Event* e);
	
	// Lancia tutti i timeout per i messaggi CANDIDATE.
	void launchCandidateTimeouts(NodeList & neighbors);
	
	// Lancia tutti i timeout per i messaggi CONNECT.
	void launchConnectTimeouts(NodeList & neighbors);
	
	// Viene segnalata la ricezione di un messaggio di CANDIDATE: si elimina il timeout.
	void receivedCandidate(NodeAddress from);
	
	// Viene segnalata la ricezione di un messaggio di CONNECT: si elimina il timeout.
	void receivedConnect(NodeAddress from);
	
protected:
		
		// Timeout attivi per i messaggi CONNECT.
		TimeoutMap connect_timeouts;
	
	// Timeout attivi per i messaggi CANDIDATE.
	TimeoutMap candidate_timeouts;
	
	// Agente proprietario del Timer.
	CSPARSIFIER_Agent * agent;
};

#endif