wimedia_stats.cc

ns2.31下的UWB（Ultra WideBand）实现

#include "WiMedia_stats.h"

extern PNC *pnc_;
extern MacMib global_macmib_;

MacStatsGenerator::MacStatsGenerator() {
	for(int i = 0; i < MAX_NODE_COUNT; i++) {
		NodeStats &ns = stats_[i];
		ns.index = -1;
		
		ns.in_flow_count = 0;
		ns.out_flow_count = 0;
		
		ns.s_total = 0;
		ns.s_beacon = 0;
		ns.s_data = 0;
		ns.s_ack = 0;
		
		ns.c_total = 0;	
		ns.c_beacon = 0;
		ns.c_data = 0;
		ns.c_ack = 0;
		
		for(int j = 0; j < MAX_FLOWS; j++) {
			ns.in_stats[j].flowid = -1;
			ns.out_stats[j].flowid = -1;
		
			bzero(&ns.in_stats[j].frag_counter, sizeof(FragStats));
			bzero(&ns.in_stats[j].frame_counter, sizeof(FrameStats));
			bzero(&ns.out_stats[j].frag_counter, sizeof(FragStats));
                        bzero(&ns.out_stats[j].frame_counter, sizeof(FrameStats));
		}
	}
}

MacStatsGenerator::~MacStatsGenerator() {
}

int MacStatsGenerator::NodeIndex(int index) {
	// Dapeng Debug
	// printf("node_count_ is %d\n", node_count_);
	for(int i = 0; i < node_count_; i++) {
		// Dapeng Debug
		// printf("i == %d, stats_[i].index == %d, index == %d\n", i, stats_[i].index, index);
		if(stats_[i].index == index)
			return i;
	}
	printf("WiMedia_stats.cc->NodeIndex() Node idex %d not found!\n", index);
	exit(1);
	return -1;
}

void MacStatsGenerator::ReceiveCorruptedFromLower(int index, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];

//	hdr_cmn *ch = HDR_CMN(p);
	hdr_mac *mh = HDR_MAC(p);
	
	switch(mh->ftype_) {
	case MF_BEACON:
		++ns.c_total;
		++ns.c_beacon;
		break;
	case MF_ACK:
		++ns.c_total;
		++ns.c_ack;
		break;
	case MF_DATA:
		if((HDR_IP(p)->dst_).addr_ == index) {
			++ns.c_total;
			++ns.c_data;
		}// End of if
		break;
	default:
		break;
	}
}	

void MacStatsGenerator::ReceiveBeaconFromLower(int index, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];

	++ns.s_beacon;
}

void MacStatsGenerator::ReceiveAckFromLower(int index, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	
	++ns.s_beacon;
}

void MacStatsGenerator::ReceiveFragFromLower(int index, int flowidx, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	FlowStats &fs = ns.in_stats[flowidx];
	FragStats &counter = fs.frag_counter;

	++ns.s_total;
	++counter.s_total;
}

void MacStatsGenerator::ReceiveDuplicateFragFromLower(int index, int flowidx, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	FlowStats &fs = ns.in_stats[flowidx];
	FragStats &counter = fs.frag_counter;

	++counter.s_dup;
}

void MacStatsGenerator::ReceiveFrameFromLower(int index, int flowidx, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	FlowStats &fs = ns.in_stats[flowidx];
	FrameStats &counter = fs.frame_counter;

	hdr_cmn *ch = HDR_CMN(p);
	
	if(counter.peak_pkt_size < ch->size())
		counter.peak_pkt_size = ch->size();
	
	counter.total_bytes += ch->size();
	++counter.s_total;

	packet_t t = ch->ptype();
	if(t == PT_MPEG_B)
		++counter.s_Mpeg_B;
	else if(t == PT_MPEG_P)
		++counter.s_Mpeg_P;
	else if(t == PT_MPEG_I)
		++counter.s_Mpeg_I;
	
	hdr_mac *mh = HDR_MAC(p);
	double total_time = Scheduler::instance().clock() - mh->timestamp_;
	
	if(mh->fragged_) {
		int total_len = mh->frag_count_ * pnc_->mac_->TotalLen_Header() + ch->size();
		double tx_time = pnc_->mac_->TxTime_Bytes(total_len) + ((global_macmib_.sifs * 2 + pnc_->mac_->TxTime_ACK()) * (mh->frag_count_ -1));
		counter.response_time += (total_time - tx_time);
	}
	else {
		int total_len = pnc_->mac_->TotalLen_Header() + ch->size();
		double tx_time = pnc_->mac_->TxTime_Bytes(total_len);
		counter.response_time += (total_time - tx_time);
	}
}		

void MacStatsGenerator::ReceiveFrameFromUpper(int index, int flowidx, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	FlowStats &fs = ns.out_stats[flowidx];
	FrameStats &counter = fs.frame_counter;
	
	hdr_cmn *ch = HDR_CMN(p);
	
	if(counter.peak_pkt_size < ch->size())
		counter.peak_pkt_size = ch->size();
	counter.total_bytes += ch->size();
	++counter.s_total;

	packet_t t = ch->ptype();
	
	if(t == PT_MPEG_B)
		++counter.s_Mpeg_B;
	else if(t == PT_MPEG_P)
		++counter.s_Mpeg_P;
	else if(t == PT_MPEG_I)
		++counter.s_Mpeg_I;
}

void MacStatsGenerator::FailedDefragmentation(int index, int flowidx, Packet *p) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	FlowStats &fs = ns.in_stats[flowidx];
	FrameStats &counter = fs.frame_counter;
	
	++counter.f_total;
	
	hdr_cmn *ch = hdr_cmn::access(p);
	packet_t t = ch->ptype();
	
	if(t == PT_MPEG_B)
		++counter.f_Mpeg_B;
	else if(t == PT_MPEG_P)
		++counter.f_Mpeg_P;
	else if(t == PT_MPEG_I)
		++counter.f_Mpeg_I;
}

void MacStatsGenerator::AddFlowIn(int index, int flowid, int flowidx) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	++ ns.in_flow_count;
	ns.in_stats[flowidx].flowid = flowid;
}

void MacStatsGenerator::AddFlowOut(int index, int flowid, int flowidx) {
	int node_index = NodeIndex(index);
	NodeStats &ns = stats_[node_index];
	++ns.out_flow_count;
	ns.out_stats[flowidx].flowid = flowid;
}

void MacStatsGenerator::AddNode(int index) {
	stats_[node_count_].index = index;
	stats_[node_count_].in_flow_count = 0;
	stats_[node_count_].out_flow_count = 0;
	
	++ node_count_;
}