dca_mastro.h

来自「clustering for ns-2 simulation」· C头文件 代码 · 共 244 行

/**
 * 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 _DCA_MASTRO_H_
#define _DCA_MASTRO_H_

#include "ClusteringModule.h"
#include "ClusteringUtility.h"

#include <vector>

////////////////////
// Stato del nodo //
////////////////////
typedef enum {
	DCA_STATUS_HELLO		= 0x1,		// Invio il peso a miei vicini (HELLO)
	DCA_STATUS_CLUSTERING   = 0x2,		// Decisione del clustering (JOIN, CH).
	DCA_STATUS_SIGNAL		= 0x3,		// Fine della ricezione dello stato di ogni vicino (JOIN, CH).
	DCA_STATUS_END			= 0x4		// Fine dell'algoritmo.
} DcaStatus;

//////////////////////
// Tipi di messaggi //
//////////////////////
typedef enum
{
	DCA_HELLO			= 0x1,			// Per comunicare il peso ai vicini
	DCA_CH				= 0x2,			// Per la segnalazione dello stato di clusterHead
	DCA_JOIN			= 0x3,			// Per segnalare il cluster a cui ci si lega.
	DCA_SIGNAL			= 0x4,			// Per segnalare la propria situazione di fine clustering ai vicini.
	DCA_CONFIRM			= 0x5,			// Per confermare la ricezione di un messaggio.
	DCA_REQUEST			= 0x6,			// Request HELLO message.
	DCA_DATA			= 0x7			// Per inviare dati per il livello superiore.
} DcaMessageType;

//
// Struttura utilizzata per mantenere le informazioni 
// per l'invio di un messaggio di INTER e sul proprio stato.
//
struct INTERInfo {
	NodeAddress		node_ID;		// ID nodo
	int				node_WT;		// WT nodo
	NodeAddress		cluster_ID;		// ID del suo clusterHead.
	int				cluster_WT;		// WT del suo clusterHead.
};

//
// Informazioni sui vicini durante la fase di clustering.
//
struct NodeInfo {
	int				WT;					// WT del nodo
	NodeAddress		clusterHead;		// ID clusterHead del nodo
	int				clusterHeadWT;		// WT clusterHead del nodo
	NodeList		cluster;			// Nodi nel suo cluster.
	bool			JOIN;				// True se ha inviato un messaggio di JOIN.
	bool			CH;					// True se ha inviato un messaggio di CH.
};

//////////////////////////
// Header del pacchetto //
//////////////////////////
struct hdr_dca
{
	
	DcaMessageType msg_type;					// Tipo di messaggio.
	DcaMessageType confirm;						// Tipo di messaggio confermato.
	
	struct INTERInfo my_status;					// Stato del mittente e del suo clusterHead.
	
	////////////////////
	// Accessibilita' //
	////////////////////
	static int offset_;
	inline static int& offset() { return offset_; }
	inline static hdr_dca* access(const Packet* p) {
		return (hdr_dca*) p->access(offset_);
	}
};

///////////
// Timer //
///////////
class DcaTimer;

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

	/*
	virtual inline NodeAddress getClusterHead(NodeAddress node) {
		return backbone_situation[node].cluster_ID;
	}
	*/

	// 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(DcaMessageType type, NodeAddress from);
	
	// Segnala il raggiungimento del massimo numero di timeout per un messaggio.
	void lastTimeout(DcaMessageType 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:
		
	///////////////
	// Procedure //
	///////////////
		
	// Gestione della fase di transisione da uno stato all'altro
	void processStatus();
	
	// Invia il peso ai vicini (info[myAddress].WT).
	void send_HELLO(NodeAddress to);
	
	// Invia richiesta di HELLO.
	void send_REQUEST(NodeAddress to);
	
	// Invia il messaggio CH (cache_ch_message).
	void send_CH(NodeAddress to);
	
	// Invia il messaggio JOIN (cache_join_message).
	void send_JOIN(NodeAddress to);
	
	// Invia la conferma di ricezione (backbone_situation[myAddress]).
	void send_SIGNAL(NodeAddress to);
	
	// Invia la conferma di ricezione.
	void send_CONFIRM(NodeAddress to, DcaMessageType type);
	
protected:

	//
	// Verifica il passaggio di fase.
	//
	void processPhase();
	
	//
	// Verifica la terminazione del clustering
	//
	void processClustering();
	
	// 
	// Restituisce true se il primo nodo e'maggiore del secondo.
	//
	bool higherThan(NodeAddress node, int nodeWT, NodeAddress other, int otherWT);

	//
	// Restituisce il degree di un vicino.
	//
	map<int, int> getDegreeOfNeighbor();
			
protected:
	
	//	
	// Stato dell'algoritmo
	//
	DcaStatus status;
	
	//
	// Timer per le ritrasmissioni.
	//
	DcaTimer * timer;		

	// Neighbors degree.
	map<int, int> degrees;

	//
	// Informazioni sul nodo e i vicini nella fase di clustering.
	//
	map<NodeAddress, struct NodeInfo> info;

	//
	// Situazione al termine del clustering: dati su ogni vicino.
	//
	map<NodeAddress, struct INTERInfo> backbone_situation;

	//--------------------------------------------------------
	// Messaggi inviati: utilizzati per le ritrasmissioni.
	//--------------------------------------------------------
	
	// 
	// Messaggio CH.
	//
	NodeAddress cache_ch_message_ID;
	int cache_ch_message_WT;
	
	// 
	// Messaggio JOIN.
	//
	NodeAddress cache_join_message_ID;
	int cache_join_message_WT;
	
private:

	/*
	float msgClustering;
	float bytesClustering;
	float msgBackbone;
	float bytesBackbone;
	
	float beginClusteringE;
	float beginClusteringT;
	float beginBackboneE;
	float beginBackboneT;
	*/
			
public:

	//
	// Attiva la variante "degree": il peso di
	// un nodo