mac-gprs.cc

一个很好的LINUX底下的GPRS协议栈

/* -*-	Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */

/* By Richa Jain,
 * Indian Institute of Technology, Bombay.
 * June, 2001.
*/ 

/* Copyright (c) 2001 Indian Insitute of Technology, Bombay.  
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code and binary code must contain
 * the above copyright notice, this list of conditions and the following 
 * disclaimer.
 * 
 * 2. All advertising materials mentioning features or use of this software
 * must display the following acknowledgement: 
 * This product includes software developed at Indian Insitute of
 * Technology, Bombay. 
 *
 * 3. The name of the Institute may not be used to endorse or promote 
 * products derived from this software without specific prior written 
 * permission.
 * INDIAN INSTITUTE OF TECHNOLOGY, BOMBAY, MAKES NO REPRESENTATIONS 
 * CONCERNING EITHER THE MERCHANTABILITY OF THIS SOFTWARE OR THE 
 * SUITABILITY OF THIS SOFTWARE FOR ANY PARTICULAR PURPOSE.  The software 
 * is provided "as is" without express or implied warranty of any kind.
*/

/* A special slotted Aloha based MAC for GPRS/GSM  */ 

#include "delay.h"
#include "connector.h"
#include "packet.h"
#include "random.h"
#include "mobilenode.h"
#include "address.h"     

// #define DEBUG
//#include <debug.h>

#include "arp.h"
#include "ll.h"
#include "rlc.h"
#include "queue.h" 
#include "mac.h"
#include "mac-gprs.h"
#include "cmu-trace.h"


/* Phy specs similar to 802.11 */
static PHY_MIB PMIB = {
	DSSS_CWMin, DSSS_CWMax, DSSS_SlotTime, DSSS_CCATime,
	DSSS_RxTxTurnaroundTime, DSSS_SIFSTime, DSSS_PreambleLength,
	DSSS_PLCPHeaderLength
};	

/* Timers */
void MacGprsTimer::start(Packet *p, 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, p, rtime);
}

void MacGprsTimer::stop(Packet *p) 
{
	Scheduler &s = Scheduler::instance();
	assert(busy_);
  
	if(paused_ == 0)
		s.cancel((Event *)p);
  
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
}

void BackoffGprsTimer::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 BackoffGprsTimer::stop(void) 
{
	Scheduler &s = Scheduler::instance();
	assert(busy_);
  
	if(paused_ == 0)
		s.cancel(&intr);
  
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
}

void BackoffGprsTimer::handle(Event *e)
{       
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
  
    mac->backoffHandler();
} 
	
void SlotReleaseTimer::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 SlotReleaseTimer::stop(void) 
{
	Scheduler &s = Scheduler::instance();
	assert(busy_);
	if(paused_ == 0)
		s.cancel(&intr);
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
}

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

void WaitTimer::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 WaitTimer::stop(void) 
{
	Scheduler &s = Scheduler::instance();
	assert(busy_);
	if(paused_ == 0)
		s.cancel(&intr);
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
}

void WaitTimer::handle(Event *e)
{       
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
	mac->waitHandler();
}
/* Slot timer for TDMA scheduling - the downslot */
void DownSlotGprsTimer::handle(Event *e)
{       
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
  
	mac->downslotHandler(e);
}

void UpSlotGprsTimer::handle(Event *e)
{       
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
  
	mac->upslotHandler(e);
}
/* Receive Timer */
void RxPktGprsTimer::handle(Event *e) 
{       
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
  
	mac->recvHandler(e);
}

/* Send Timer */
void TxPktGprsTimer::handle(Event *e) 
{       
	busy_ = 0;
	paused_ = 0;
	stime = 0.0;
	rtime = 0.0;
  
	mac->sendHandler(e);
}

/* ======================================================================
   TCL Hooks for the simulator
   ====================================================================== */
static class MacGprsClass : public TclClass {
public:
	MacGprsClass() : TclClass("Mac/Gprs") {}
	TclObject* create(int, const char*const*) {
		return (new MacGprs(&PMIB));
	}
} class_mac_gprs;

//for the static variables:
Packet * MacGprs::rxQ[MAX_NUM_FREQ][SLOTS_PER_FRAME]={NULL};
Packet * MacGprs::txQ[MAX_NUM_FREQ][SLOTS_PER_FRAME]={NULL}; 
struct data_at_bs MacGprs::vlr_ = {0};

int MacGprs:: tx_rate = {0};
int MacGprs:: max_num_ms_ = {0};
int MacGprs:: max_num_freq_ = {0};
int MacGprs:: slot_packet_len_ = {0};
int MacGprs:: gprs_slots_per_frame_ = {0};

double MacGprs::slot_time_ = 0;
double MacGprs::start_time_ = 0;

int MacGprs::chan0_0 = {0};
int MacGprs::coll_count = {0}; 

int MacGprs::active_node_ = {0};

int MacGprs::verbose_ = {0};

//static variables for rlc_error
int MacGprs::rlc_error_  ={0};
int MacGprs::error_rate_ ={0};
int MacGprs::drop_gap_   ={0};
int MacGprs::drop_counter_ ={0};
int MacGprs::next_drop_  ={0};

//constructor

MacGprs::MacGprs(PHY_MIB* p) : Mac(), mhDownSlot_(this), 
	mhUpSlot_(this), mhTxPkt_(this), mhRxPkt_(this), 
    mhRel_(this), mhBackoff_(this),mhwait_(this)
{
	int i,j;

	phymib_ = p;

	bind("slot_packet_len_", &slot_packet_len_);
	bind("max_num_ms_", &max_num_ms_);
	bind("max_num_freq_", &max_num_freq_);
	bind("gprs_", &gprs_);
	bind("verbose_", &verbose_);
	bind("gprs_slots_per_frame_", &gprs_slots_per_frame_); 

	bind("rlc_error_", &rlc_error_);
	bind("error_rate_", &error_rate_);
	
	slot_time_= 0.000577 ;//gprs slot is of 576.9 microseconds
	tx_rate = (int) ((8*slot_packet_len_) / slot_time_) ;
		
	//printf("slot_time=%f, gprs_=%d  tx_rate=%d \n", slot_time_, gprs_, tx_rate);
	
	active_node_++;  
	
	//max_num_ms shud be less that MAX_NUM_MS
	if (max_num_ms_ > MAX_NUM_MS) {
		if (verbose_==1)
		   printf("Too many nodes taking part. shud be less than %d \n",  MAX_NUM_MS);
		exit (-1);
	}	
	if (active_node_ > max_num_ms_) {
		if (verbose_==1)
		   printf("Too many nodes taking part in the simulations, aborting...\n");
		exit(-1);
	} 
    
	radio_active_ = 0;
	wait_for_res=0;
	
	first_round_=1;
	down_slot_=0;
	up_slot_=0;
	
	for ( j=0 ; j< SLOTS_PER_FRAME ; j++) {
		pktTx[j] =NULL;
		pktRx[j] =NULL;
		tx_chan[j] = -10;
		rx_chan[j] = -10; 
		//-10 => no channel
	}
	tx_chan[0]=0;   // freq 0, slot 0 reserved. for broadcasts/isgnalling 
	rx_chan[0]=0;	// in either  direction. 

	txQ[0][0]=0;
	temp_reply=0;
	
	// initialising data_at_bs
	for ( j=0; j<max_num_ms_ ; j++) {  
		vlr_.hier_addr_[j]=-10;
	} 
	for ( j=0; j<SLOTS_PER_FRAME ; j++) {  
		 for (i=0; i<max_num_freq_ ; i++) {
			 //this freq/slot hasnt been alloted to any MS yet
	 		 vlr_.up_table[i][j]=-10;  
	 		 vlr_.down_table[i][j]=-10;
			 
		 }
	}


	if (rlc_error_==1 && index_==0) {
		drop_gap_ = Random::integer(error_rate_);
		next_drop_ = drop_gap_;
		if (verbose_==1) 
			printf("<%d> %f  first drop will be at %d \n", index_, NOW, next_drop_ );
    }
			
	if (verbose_==1)
 		printf("<%d> %f  initialised...; \n",index_, NOW);
	
	intr1_ = intr_ ; //reqd for the slot timers
	intr = intr_ ; 
	
	mhDownSlot_.start((Packet *) (& intr_), 0);  
}

// similar to 802.11
int MacGprs::command(int argc, const char*const* argv)
{
	if (argc == 3) {
		if (strcmp(argv[1], "log-target") == 0) {
			logtarget_ = (NsObject*) TclObject::lookup(argv[2]);
			if(logtarget_ == 0)
				return TCL_ERROR;
			return TCL_OK;
		}
	}
	return Mac::command(argc, argv);
}


/* ======================================================================
   Debugging Routines
   ====================================================================== */
void MacGprs::trace_pkt(Packet *p) 
{
	struct hdr_cmn *ch = HDR_CMN(p);
	struct hdr_mac_gprs* dh = HDR_MAC_GPRS(p);
	u_int16_t *t = (u_int16_t*) &dh->dh_fc;

	fprintf(stderr, "\t[ %2x %2x %2x %2x ] %x %s %d\n",
		*t, dh->dh_duration,
		ETHER_ADDR(dh->dh_da), ETHER_ADDR(dh->dh_sa),
		index_, packet_info.name(ch->ptype()), ch->size());
}

void MacGprs::dump(char *fname)
{
	fprintf(stderr, "\n%s --- (INDEX: %d, time: %2.9f)\n", fname, 
		index_, Scheduler::instance().clock());
	
	fprintf(stderr, "\tpktTx_: %x, pktRx_: %x, callback: %x\n", 
		(int) pktTx_, (int) pktRx_, (int) callback_);
}


/* ======================================================================
   Packet Headers Routines
   ====================================================================== */
int MacGprs::hdr_dst(char* hdr, int dst )
{
	struct hdr_mac_gprs *dh = (struct hdr_mac_gprs*) hdr;
	if(dst > -2)
		STORE4BYTE(&dst, (dh->dh_da));
	return ETHER_ADDR(dh->dh_da);
}

int MacGprs::hdr_src(char* hdr, int src )
{
	struct hdr_mac_gprs *dh = (struct hdr_mac_gprs*) hdr;
	if(src > -2)
		STORE4BYTE(&src, (dh->dh_sa));
  
	return ETHER_ADDR(dh->dh_sa);
}

int MacGprs::hdr_type(char* hdr, u_int16_t type) 
{
	struct hdr_mac_gprs *dh = (struct hdr_mac_gprs*) hdr;
	if(type)
		STORE2BYTE(&type,(dh->dh_body));
	return GET2BYTE(dh->dh_body);
}


/*double DATA_Time(int len) { 
	double 
	return (8*(len) / tx_rate);
}   */   

double MacGprs::TX_Time(Packet *p) {
    
	int len=	(HDR_CMN(p))->size();
	double t = (double)(len*8)/tx_rate;
//	printf("< >, %f len=%d tx_time = %f \n", NOW,len, t);
	if(t < 0.0) {
	    drop(p, "XXX");
        exit(1);
    } 
    return t;
}   
		
/* Resource allocation:*/
void MacGprs::slot_allot( int  ms_, int &freq, int &slot)
{ // Allocation is sequential - first empty slot is alloted.
	
	int i,j;
	start_time_ = NOW;

		if (gprs_==1) { //ie its a gprs node
			//fnd the first free slot/freq
			for ( i=0; i<max_num_freq_ ; i++) {  
			    for ( j=1; j<(gprs_slots_per_frame_+1) ; j++){
					//slot0 resv for signalling on ALL freqs
					if (vlr_.up_table[i][j] == -10) {
						//ie this slot's not been alloted to anyone 
						break;