dsred.cc.svn-base

diff serve for ns-2, work for version 2.29

		if (strcmp(argv[2], "edrops") == 0)
         return (stats.edrops*1.0);
		if (strcmp(argv[2], "pkts") == 0)
         return (stats.pkts*1.0);

		if (strcmp(argv[2], "%drops") == 0)
         return (stats.pkts>0?stats.drops*100.0/stats.pkts:0);
		if (strcmp(argv[2], "%edrops") == 0)
         return (stats.pkts>0?stats.edrops*100.0/stats.pkts:0);
   }
	if (argc == 4) {

		int arg3 = (int)strtod(argv[3], NULL);
		double s_pkts   = stats.pkts_CP[arg3];
		double s_drops  = stats.drops_CP[arg3];
		double s_edrops = stats.edrops_CP[arg3];
		double s_TCPcwnd= stats.TCPcwnd_CP[arg3];
		double s_TCPrtt = stats.TCPrtt_CP[arg3];
		double s_TCPbReTX=stats.TCPbReTX_CP[arg3];
		double s_TCPbGoTX=stats.TCPbGoTX_CP[arg3];
		double s_TCPnReTX=stats.TCPnReTX_CP[arg3];

		if (strcmp(argv[2], "drops") == 0)
         return (s_drops);
		if (strcmp(argv[2], "edrops") == 0)
         return (s_edrops);
		if (strcmp(argv[2], "pkts") == 0)
         return (s_pkts);
		if (strcmp(argv[2], "TCPcwnd") == 0)
         return (s_TCPcwnd);
		if (strcmp(argv[2], "TCPrtt") == 0)
         return (s_TCPrtt);
		if (strcmp(argv[2], "TCPbReTX") == 0)
         return (s_TCPnReTX);
		if (strcmp(argv[2], "TCPbGoTX") == 0)
         return (s_TCPbGoTX);
		if (strcmp(argv[2], "TCPnReTX") == 0)
         return (s_TCPbReTX);

	 	if (strcmp(argv[2], "%drops") == 0)
         return (s_pkts>0?s_drops*100/s_pkts:0);
		if (strcmp(argv[2], "%edrops") == 0)
         return (s_pkts>0?s_edrops*100/s_pkts:0);
	}
	return -1.0;
}


/*------------------------------------------------------------------------------
void setNumPrec(int prec) 
    Sets the current number of drop precendences.  The number of precedences is
the number of virtual queues per physical queue.
------------------------------------------------------------------------------*/
void dsREDQueue::setNumPrec(int queue, int numPrec) {


	if (numPrec > MAX_PREC) 
		printf("ERROR: Cannot declare more than %d prcedence levels (as defined by MAX_PREC)\n",MAX_PREC);
	else 
                if (numPrec==0) for (int i=0; i<MAX_PREC; i++) redq_[i].numPrec = numPrec;
		else redq_[queue].numPrec = numPrec;
}

/*------------------------------------------------------------------------------
void setMREDMode(const char* mode)
   sets up the average queue accounting mode.
----------------------------------------------------------------------------*/
void dsREDQueue::setMREDMode(const char* mode, const char* queue) {
	int i;
	mredModeType tempMode;

	if (strcmp(mode, "RIO-C") == 0)
   	tempMode = rio_c;
	else if (strcmp(mode, "RIO-D") == 0)
		tempMode = rio_d;
	else if (strcmp(mode, "WRED") == 0)
		tempMode = wred;
	else if (strcmp(mode, "DROP") == 0)
		tempMode = dropTail;
	else {
		printf("Error: MRED mode %s does not exist\n",mode);
      return;
   }
	if (!queue) for (i = 0; i < MAX_QUEUES; i++) redq_[i].mredMode = tempMode; 
	else redq_[ (int)strtod(queue, NULL) ].mredMode = tempMode;

}


/*------------------------------------------------------------------------------
void printPHBTable()
    Prints the PHB Table, with one entry per line.
------------------------------------------------------------------------------*/
void dsREDQueue::printPHBTable() {
   printf("PHB Table:\n");
   for (int i = 0; i < phbEntries; i++)
      printf("Code Point %d is associated with Queue %d, Precedence %d\n", phb_[i].codePt_, phb_[i].queue_, phb_[i].prec_);
   printf("\n");
}


/*------------------------------------------------------------------------------
void printStats()
    An output method that may be altered to assist debugging.
------------------------------------------------------------------------------*/
void dsREDQueue::printStats() {
	printf("\nPackets Statistics\n");
	printf("=======================================\n");
	printf(" CP  TotPkts   TxPkts   ldrops   edrops\n");
	printf(" --  -------   ------   ------   ------\n");

	for (int i = 0; i < MAX_CP; i++)
		if (stats.pkts_CP[i] != 0)
			printf("%3d %8d  %6.2f%%  %6.2f%%   %6.2f%%\n",i,stats.pkts_CP[i],(stats.pkts_CP[i]-stats.drops_CP[i]-stats.edrops_CP[i])*100.0/stats.pkts_CP[i],stats.drops_CP[i]*100.0/stats.pkts_CP[i],stats.edrops_CP[i]*100.0/stats.pkts_CP[i]);

	printf("----------------------------------------\n");
        if (stats.pkts != 0) 
		printf("All %8d  %6.2f%%  %6.2f%%   %6.2f%%\n",stats.pkts,(stats.pkts-stats.drops-stats.edrops)*100.0/stats.pkts,stats.drops*100.0/stats.pkts,stats.edrops*100.0/stats.pkts);


}


/*------------------------------------------------------------------------------
void setSchedularMode(int schedtype)
   sets up the schedular mode.
----------------------------------------------------------------------------*/
void dsREDQueue::setSchedularMode(int argc, const char*const* argv) {

	const char* schedtype=argv[2];	   

	delete QScheduler;
	if (strcmp(schedtype, "RR") == 0)
   		QScheduler = new dsRR(numQueues_);
	else if (strcmp(schedtype, "WRR") == 0)
		QScheduler = new dsWRR(numQueues_);
	else if (strcmp(schedtype, "WIRR") == 0)
		QScheduler = new dsWIRR(numQueues_);
	else if (strcmp(schedtype, "WFQ") == 0)
	        QScheduler = new dsWFQ(numQueues_,link_->bandwidth());
	else if (strcmp(schedtype, "SCFQ") == 0)
	        QScheduler = new dsSCFQ(numQueues_,link_->bandwidth());
	else if (strcmp(schedtype, "SFQ") == 0)
	        QScheduler = new dsSFQ(numQueues_, link_->bandwidth());
	else if (strcmp(schedtype, "WF2Qp") == 0)
	        QScheduler = new dsWF2Qp(numQueues_,link_->bandwidth());
	else if (strcmp(schedtype, "LLQ") == 0)
		if (argc==5) QScheduler = new dsLLQ(numQueues_,atof(argv[4]),argv[3]);
		else printf("wrong parameter number for LLQ scheduler\n");
	else if (strcmp(schedtype, "PRI") == 0)
		if (argc==4) QScheduler = new dsPQ(numQueues_,atof(argv[3]));
		else QScheduler = new dsPQ(numQueues_,1);
	else
		printf("Error: Scheduler type %s does not exist\n",schedtype);
}


/*------------------------------------------------------------------------------
void addQueueWeight(int queueNum, double weight)
   An input method to set the individual Queue Weights.
----------------------------------------------------------------------------*/
void dsREDQueue::addQueueWeight(int queueNum, double weight) {
   if(queueNum < MAX_QUEUES)      
      QScheduler->AddParam(queueNum,weight);	
   else 
      printf("The queue number is out of range.\n");
}


/*------------------------------------------------------------------------------
void addQueueRate(int queueNum, int rate)
   An input method to set the individual Queue Max Rates for Priority Queueing.
----------------------------------------------------------------------------*/
void dsREDQueue::addQueueRate(int queueNum, int rate) {

   if(queueNum < MAX_QUEUES) QScheduler->AddParam(queueNum,rate);
   else printf("The queue number is out of range.\n");
}

void dsREDQueue::setQSize(int queueNum, int qMaxSize) { 
    if(queueNum < MAX_QUEUES) redq_[queueNum].qlim = phisQueueLimit[queueNum]=qMaxSize;
    else printf("The queue number is out of range.\n");
}

void dsREDQueue::FDinit(const char *const DSCPstr) {

    char FN1[20]="FDcwnd_DSCP";
    strcat(FN1 ,DSCPstr);
    strcat(FN1 ,".tr");
    stats.TCPcwndFD_CP[ (int)strtod(DSCPstr, NULL) ] = new dsFD( 1, FN1);
	
    char FN2[20]="FDrtt_DSCP";
    strcat(FN2 ,DSCPstr);
    strcat(FN2 ,".tr");
    stats.TCPrttFD_CP[  (int)strtod(DSCPstr, NULL) ]  = new dsFD( 1, FN2);
	
}

/*------------------------------------------------------------------------------
int command(int argc, const char*const* argv)
    Commands from the ns file are interpreted through this interface.
------------------------------------------------------------------------------*/
int dsREDQueue::command(int argc, const char*const* argv)
{

	if (strcmp(argv[1], "configQ") == 0) {
                // NB: if num of parameters wrong, then seg fault
		redq_[ (int)strtod(argv[2], NULL) ].config( (int)strtod(argv[3], NULL), argc, argv);
		return(TCL_OK);
	}
	if (strcmp(argv[1], "addPHBEntry") == 0) {
		addPHBEntry( (int)strtod(argv[2], NULL),  (int)strtod(argv[3], NULL),  (int)strtod(argv[4], NULL) );
		return (TCL_OK);
	}
	if (strcmp(argv[1], "meanPktSize") == 0) {
		for (int i = 0; i < MAX_QUEUES; i++)
			redq_[i].setMPS( (int)strtod(argv[2], NULL) );
		return(TCL_OK);
	}
	if (strcmp(argv[1], "setNumPrec") == 0) {
		if (argc == 3) setNumPrec( (int)strtod(argv[2], NULL),0);
		else setNumPrec( (int)strtod(argv[2], NULL),  (int)strtod(argv[3], NULL));
		return(TCL_OK);
	}
	if (strcmp(argv[1], "setQSize") == 0) {
		setQSize( (int)strtod(argv[2], NULL),  (int)strtod(argv[3], NULL));
		return(TCL_OK);
	}
	if (strcmp(argv[1], "getAverage") == 0) {
		Tcl& tcl = Tcl::instance();
		tcl.resultf("%f", redq_[ (int)strtod(argv[2], NULL)].getWeightedLength() );
		return(TCL_OK);
	}
	if (strcmp(argv[1], "getDepartureRate") == 0) {
		Tcl& tcl = Tcl::instance();
		if (argc==4) tcl.resultf("%f", QScheduler->GetDepartureRate( (int)strtod(argv[2], NULL), (int)strtod(argv[3], NULL)) );
		else 	     tcl.resultf("%f", QScheduler->GetDepartureRate( (int)strtod(argv[2], NULL), -1) );
		return(TCL_OK);
	}
	if (strcmp(argv[1], "getStat") == 0) {
		Tcl& tcl = Tcl::instance();
		tcl.resultf("%.2f", getStat(argc,argv));
		return(TCL_OK);
	}
	if (strcmp(argv[1], "getQueueLen") == 0) {
		Tcl& tcl = Tcl::instance();
		tcl.resultf("%d", redq_[ (int)strtod(argv[2], NULL) ].getRealLength());
		return(TCL_OK);
	}
	if (strcmp(argv[1], "getVirtQueueLen") == 0) {
		Tcl& tcl = Tcl::instance();
		tcl.resultf("%d", redq_[ (int)strtod(argv[2], NULL) ].getVirtQueueLen( (int)strtod(argv[3], NULL) ));
		return(TCL_OK);
	}
	if (strcmp(argv[1], "printStats") == 0) {
		printStats();
		return (TCL_OK);
	}
	if (strcmp(argv[1], "printWRRcount") == 0) {
		((dsWIRR*)QScheduler)->printWRRcount();
		return (TCL_OK);
	}
	if (strcmp(argv[1], "printPHBTable") == 0) {
		printPHBTable();
		return (TCL_OK);
	}
	if (strcmp(argv[1], "link") == 0) {
		Tcl& tcl = Tcl::instance();
		LinkDelay* del = (LinkDelay*) TclObject::lookup(argv[2]);
		if (del == 0) {
			tcl.resultf("RED: no LinkDelay object %s",
			argv[2]);
			return(TCL_ERROR);
		}
		link_ = del;
		return (TCL_OK);
	}
	if (strcmp(argv[1], "early-drop-target") == 0) {
		Tcl& tcl = Tcl::instance();
		NsObject* p = (NsObject*)TclObject::lookup(argv[2]);
		if (p == 0) {
			tcl.resultf("no object %s", argv[2]);
			return (TCL_ERROR);
		}
		de_drop_ = p;
		return (TCL_OK);
	}
   if (strcmp(argv[1], "setSchedularMode") == 0) {
  		setSchedularMode(argc, argv);
      return(TCL_OK);
   }
   if (strcmp(argv[1], "setMREDMode") == 0) {
		if (argc == 3)
	      setMREDMode(argv[2],0);
		else
			setMREDMode(argv[2],argv[3]);
      return(TCL_OK);
   }
   	if (strcmp(argv[1], "addQueueWeight") == 0) {
      		addQueueWeight( (int)strtod(argv[2], NULL), atof(argv[3]));
      		return(TCL_OK);
 	}
	if (strcmp(argv[1], "setQueueBW") == 0) {
		redq_[ (int)strtod(argv[2], NULL) ].setPTC(atof(argv[3]));
		//printf(" setting PTC %d %f\n",  (int)strtod(argv[2], NULL),atof(argv[3]));
      		return(TCL_OK);
   	}
        // debug 
	if (strcmp(argv[1], "getPTC") == 0) {
		redq_[1].getPTC();
		redq_[2].getPTC();
		redq_[3].getPTC();
      return(TCL_OK);
   }
   if (strcmp(argv[1], "addQueueRate") == 0) {
      addQueueRate( (int)strtod(argv[2], NULL),  (int)strtod(argv[3], NULL));
      return(TCL_OK);
   }
	if (strcmp(argv[1], "frequencyDistribution") == 0) {
		FDinit(argv[2]);
		return(TCL_OK);
	}
	if (strcmp(argv[1], "flushFD") == 0) {
		stats.TCPcwndFD_CP[ (int)strtod(argv[2], NULL) ]->flush(1,0);
		stats.TCPrttFD_CP[ (int)strtod(argv[2], NULL) ]->flush(10,0);
		return(TCL_OK);
	}
	return(Queue::command(argc, argv));
}


/*-----------------------------------*/
dsFD::dsFD(double RL, char* FN):RangeLenght(RL)
{	strcpy(FileName, FN);
	counter=0;
}

void dsFD::occurency(double Value)
{   	unsigned int Position=(unsigned int)ceil(Value/RangeLenght);
	if (Position>=FDtable.size()) FDtable.resize(Position+1,0);
	FDtable[Position]++;
	counter++;
}


void dsFD::flush(double norm, double threshold)
{	
	ofstream fileFD;
	fileFD.open(FileName,fstream::out);
	for (unsigned int i=0; i<FDtable.size(); i++) {
		double FDpercentage=FDtable[i]*100.0/counter;
		if (FDpercentage>threshold) 
			fileFD << i*RangeLenght/norm << " " << FDpercentage << endl;
	}
	fileFD.close();	
}