mac-timers2.cc

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

#include <delay.h>
#include <connector.h>
#include <packet.h>
#include <random.h>

#include <arp.h>
#include <ll.h>
#include <mac.h>
#include "mac-timers2.h"
#include "WiMedia.h"
#include "WiMedia_pnc.h"

void MacTimer2::start(double time) {
	Scheduler &s = Scheduler::instance();
	assert(busy_ == 0);

	busy_ = 1;
	paused_ = 0;
	stime = s.clock();
	rtime = time;
	assert(rtime >= 0.0);
	
	s.schedule(this, &intr, rtime);
}

void MacTimer2::stop(void) {
	Scheduler &s = Scheduler::instance();
	assert(busy_);
	
	if(paused_ == 0)
		s.cancel(&intr);
	
	busy_ = 0;	
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
}

// Beacon Timer
void BeaconTimer2::handle(Event *) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	
	mac->OnBeaconTimer();
}

// Sender Timer, TxTimer2
void TxTimer2::handle(Event *) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	
	mac->OnSendTimer();
}

// Interface Timer
void IFTimer2::handle(Event *) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	
	mac->OnIFTimer();
}

// Defer Timer
DeferTimer2::DeferTimer2(Mac_WiMedia *m) : MacTimer2(m) {
	timeout_ = 0;
	pktSend_ = 0;
}

void DeferTimer2::handle(Event *) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	
	mac->OnDeferTimer();
}

void RxTimer2::handle(Event *) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	
	mac->OnRxTimer();
}

void TDMATimer2::handle(Event *) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;

	mac->OnTDMATimer();
}

BackoffTimer2::BackoffTimer2(Mac_WiMedia *m) : MacTimer2(m) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	medium_was_idle_ = false;
	remaining_ = 0.0;
	end_time_ = 0.0;
}

void BackoffTimer2::handle(Event *) {
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	remaining_ = 0.0;
	end_time_ = 0.0;

	if(!medium_was_idle_)
		mac->OnBackoffTimer();
	else {
		if(mac->is_idle())
			mac->OnBackoffTimer();
		else {
		}
	}
}

void BackoffTimer2::start(int cw, bool idle) {
	Scheduler &s = Scheduler::instance();
	
	busy_ = 1;
	paused_ = 0;
	stime = s.clock();
	medium_was_idle_ = idle;
	if(!idle) {
		rtime = (Random::random()%cw)*SLOT_TIME + mac->macmib_->difs;
		remaining_ = rtime;
		end_time_ = s.clock() + remaining_;
		s.schedule(this, &intr, rtime);
	}
	else {
		rtime = mac->macmib_->difs;
		remaining_ = rtime;
		end_time_ = s.clock() + remaining_;
		s.schedule(this, &intr, rtime);
	}
}

void BackoffTimer2::pause() {
	if(paused_)
		return;
	if(!busy_)
		return;
	
	Scheduler &s = Scheduler::instance();
	rtime = remaining_ = end_time_ - s.clock();
	paused_ = 1;
	s.cancel(&intr);
}

void BackoffTimer2::resume() {
	if(paused_) {
		Scheduler &s = Scheduler::instance();
		paused_ = 0;
		busy_ = 1;
	
		stime = s.clock();
		remaining_ += mac->macmib_->difs;
		rtime = remaining_;
		end_time_ = s.clock() + remaining_;
	
		s.schedule(this, &intr, remaining_);
	}
}