asimstd.cc

NS2网络仿真软件是目前最为流行的网络仿真模拟软件

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <strings.h>
#include <assert.h>
#include <iostream>
#include "config.h"

// Integration of Ashish's RED and asim
#define _RED_ROUTER_MAIN_
#include "asim.h"

#define sp " " 

// Optimization
#include<vector>
using namespace std;

typedef struct c{
	int no; // no of edges in the connection
	double delay; // total delay;
	double drop; // total drop prob
	double p_tput;
	double t;
	// The short flow stuff
	int is_sflow; // boolean to indicate whether there is a short flow
	double slambda; // The arrival rate of the connections
	int snopkts; // average of no of packets each short flow givies
	RedRouter * red;
	int scaled; // Whether this flow has been scaled or not
}flow_stats;

typedef struct n{
	int red; // flag to notify whether its a red queue or not
	double pmin, pmax, minth, maxth; // RED parameters
	double lambda; // Arrival rate - Packets per second
	double plambda; // Temp lambda value. previous lambda
	double tlambda;
	double mu; // Consumption rate - Packets per second
	double prop; // Propagation delay of the link
	double qdelay; // Store the queuing delay for each link
	int    buffer; // Total buffer
	double drop; // probability of drop
	int nflows; // Number of flows through this link
	vector<int> theflows; // The flows through this link
	double scaled_lambda;
	double unscaled_lambda;
	
	double utput; // unscaled tput 
	double uc; // unscaled capacity
	
	// RED
	RedRouter * redrouter;
	
}link_stats;


class asim {

public:

	// data structures 
	int nConnections; // Number of connections
	int K, MaxHops; // 
	int nLinks; // Number of links 
	int **Adj; // Stores the edge list of each connection
	int *nAdj; // Stores the no of edges per connection
	
	link_stats* links;
	flow_stats* flows;
	
	double min(double x, double y){
		return (x<y)?x:y;
	}
	
	double padhye(double rtt, double p){
		
		double rto = 1;
		double t=1;
		t = rtt*sqrt(2*p/3)+rto*min(1,(3*sqrt(3*p/8)))*p*(1+32*p*p);
		return min(20/rtt,1/t);
		
	}
	
	double Po(double rho, int K){
		
		if(rho==1)
			return 1.0/(K+1);
		
		double t;
		t=(1.0*(1-rho))/(1.0-pow(rho,K));
		return t;
		
	}
	
	double Pk(double rho, int K, int k){
		
		if(rho==1)
			return 1.0/(K+1);

		if(rho==0)
			return 0;

		double t;
		// M/M/1/K
		t=((1-rho)*pow(rho,k))/(1-pow(rho,K+1));
		return t;
	}  
	
	double Lq(double rho, int K){
		
		double t1,t2;
		
		if(rho==1){
			return (1.0*K*(K-1))/(2.0*(K+1));
		}
		
		t1=rho*1.0/(1-rho);
		t2=rho*1.0/(1-pow(rho,K+1));
		t2*=K*pow(rho,K)+1;
		return (t1-t2)/2;
		
	}
	
	double get_link_drop(int x){
		assert(x<nLinks);
		return links[x].drop;
	}
	
	double get_link_delay(int x){
		assert(x<nLinks);
		return links[x].qdelay + links[x].prop ;
	}
	
	double get_link_qdelay(int x){
		assert(x<nLinks);
		return links[x].qdelay;
	}
	
	double get_link_pdelay(int x){
		assert(x<nLinks);
		return links[x].prop;
	}
	
	double get_link_tput(int x){
		assert(x<nLinks);
		return links[x].lambda;
	}
	
	double get_flow_delay(int x){
		assert(x<nConnections);
		return flows[x].delay;
	}
	
	double get_flow_tput(int x){
		assert(x<nConnections);
		return flows[x].p_tput;
	}
	
	double get_flow_drop(int x){
		assert(x<nConnections);
		return flows[x].drop;
	}
	
	void GetInputs(char *argv) {
		
		// Init links and connections 
		nConnections = 0;
		nLinks = 0;
		
		// Start the reading process
		FILE *f;
		f = fopen(argv,"r");
		assert(f);
		
		char s[256];
		while (fgets(s, 255, f)) {
			
			// Read a token 
			char *t;
			t = strtok(s, " \t\n");
			
			// Ignore comments 
			if (!t || !t[0] || (t[0] == '#') || !strncasecmp(t, "comment", 6))
				continue;
			
			// Define the number of connections
			if (!strcasecmp(t,"n")) {
				t = strtok(NULL," \t");
				assert(t);
				nConnections = atoi(t);
				assert(nConnections > 0);
				assert(nConnections >= 0);
				nAdj = new int[nConnections];
				Adj = new int*[nConnections];
				flows = new flow_stats[nConnections];
				for (int i=0; i<nConnections; ++i)
					nAdj[i] = -1;
				continue;
			}
			
			// Define the number of links
			else if (!strcasecmp(t,"m")) {
				
				t = strtok(NULL," \t");
				assert(t);
				// #of links defined
				nLinks = atoi(t);
				assert(nLinks > 0);
				// Allocate space for sotring lambdas and mus
				links = new link_stats[nLinks];
				continue;
			}
			
			// Enter each route 
			else if (!strcasecmp(t,"route")) {
				
				assert (nConnections > 0);
				assert (nLinks > 0);
				t = strtok(NULL," \t");
				assert(t);
				int i = atoi(t);
				assert(i > 0 && i<= nConnections);
				i--;
				
				// We dunno whether this will be short flow specs
				flows[i].is_sflow = 0; // Lets assume its a normal flow
				flows[i].drop = 0; // Assume ideal case to start off
				flows[i].scaled = 0; // Not scaled as yet
				
				t = strtok(NULL," \t");
				assert(t);
				nAdj[i] = atoi(t);
				assert(nAdj[i] > 0 && nAdj[i] <= nLinks);
				// We know how many links it will use
				Adj[i] = new int[nAdj[i]];
				for (int j=0; j<nAdj[i]; ++j) {
					t = strtok(NULL," \t");
					assert(t);
					int l = atoi(t);
					assert(l > 0 && l <= nLinks);
					l--;
					Adj[i][j] = l;
				}
				
				if (MaxHops < nAdj[i]) MaxHops = nAdj[i];
				
				
				t = strtok(NULL," \t");
				// assert(t);
				
				// Short flows stuff 
				
				if (t && !strcasecmp(t,"sh")) {
					// There are short flows on this route.
					flows[i].is_sflow = 1;
					
					// read the slambda
					t = strtok(NULL," \t");
					assert(t);
					double  tmp = atof(t);
					flows[i].slambda = tmp;
					
					// read the snopkts
					t = strtok(NULL," \t");
					assert(t);
					int  tmpi = atoi(t);
					flows[i].snopkts = tmpi;
				}
				
				
				// For cbr 
				// Treat almost like a short flow!
				
				if (t && !strcasecmp(t,"cbr")) {
					// There are short flows on this route.
					flows[i].is_sflow = 2;
					
					// read the rate
					t = strtok(NULL," \t");
					assert(t);
					double  tmp = atof(t);
					flows[i].slambda = tmp;
					flows[i].snopkts = 1;
				}      
				
				
				// Now, let us put the flows in persective
				// Insert the flow id trhough all the links
				int l_;
				for(int j=0;j<nAdj[i];j++){
					l_ = Adj[i][j];
					(links[l_].theflows).push_back(i);
					links[l_].nflows++;
					if(flows[i].is_sflow){
						links[l_].lambda+=flows[i].slambda*flows[i].snopkts;
					}
				}
				
				continue;
			}
			
			else if(!strcasecmp(t,"link")){
				
				assert (nLinks > 0);
				
				// Get the link number
				t = strtok(NULL," \t");
				assert(t);
				int i = atoi(t);
				assert(i > 0 && i<= nLinks);
				i--;
				
				// Get the prop delay
				t = strtok(NULL," \t");
				assert(t);
				double p = atof(t);
				assert(p>=0); 
				links[i].prop = p;
				
				// Get the lambda for this link
				t = strtok(NULL," \t");
				assert(t);
				p = atof(t);
				assert(p>=0);
				links[i].lambda = 0;
				links[i].tlambda = p;
				links[i].plambda = p;
				
				// Get the mu for this link
				t = strtok(NULL," \t");
				assert(t);
				p = atof(t);
				assert(p>=0);
				links[i].mu = p;
				
				// Get the buffer for this link
				t = strtok(NULL," \t");
				assert(t);
				int t1 = atoi(t);
				assert(t1>0);
				links[i].buffer = t1;
				
				// Check for RED Q or not
				t = strtok(NULL," \t");
				if(t && !strcasecmp(t,"red")){
					
					// must be a red queue
					// input red parameters
					// all parameters between 0 and 1
					links[i].red=1;
					// get minth
					t = strtok(NULL," \t");
					double dt = atof(t); 
					//assert(dt>=0 && dt<=1);
					links[i].minth=dt;
					
					// get pmin
					t = strtok(NULL," \t");
					dt = atof(t); 
					//assert(dt>=0 && dt<=1);
					links[i].pmin=dt;
					
					// get maxth
					t = strtok(NULL," \t");
					dt = atof(t); 
					//assert(dt>=0 && dt<=1);
					links[i].maxth=dt;
					
					// get pmax
					t = strtok(NULL," \t");
					dt = atof(t); 
					//assert(dt>=0 && dt<=1);
					links[i].pmax=dt;
					
					// Invoke Ashish's RED module ... ignore pmin .....