asim.cc

来自「NS2网络仿真软件是目前最为流行的网络仿真模拟软件」· CC 代码 · 共 1,021 行 · 第 1/2 页

/*
 * asim.cc
 * Copyright (C) 2000 by the University of Southern California
 * $Id: asim.cc,v 1.11 2005/08/25 18:58:01 johnh Exp $
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 *
 *
 * The copyright of this module includes the following
 * linking-with-specific-other-licenses addition:
 *
 * In addition, as a special exception, the copyright holders of
 * this module give you permission to combine (via static or
 * dynamic linking) this module with free software programs or
 * libraries that are released under the GNU LGPL and with code
 * included in the standard release of ns-2 under the Apache 2.0
 * license or under otherwise-compatible licenses with advertising
 * requirements (or modified versions of such code, with unchanged
 * license).  You may copy and distribute such a system following the
 * terms of the GNU GPL for this module and the licenses of the
 * other code concerned, provided that you include the source code of
 * that other code when and as the GNU GPL requires distribution of
 * source code.
 *
 * Note that people who make modified versions of this module
 * are not obligated to grant this special exception for their
 * modified versions; it is their choice whether to do so.  The GNU
 * General Public License gives permission to release a modified
 * version without this exception; this exception also makes it
 * possible to release a modified version which carries forward this
 * exception.
 *
 */

#include "config.h"

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

#include "agent.h"

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

#define sp " " 

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
  int *theflows; // The flows through this link
  double scaled_lambda;
  double unscaled_lambda;

  double utput; // unscaled tput 
  double uc; // unscaled capacity

  // For ashish
  RedRouter * redrouter;

}link_stats;


class asim : public NsObject{

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);
    
    double t;
    t=(1-rho)*pow(rho,k);
    t/=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;
    
  }
  
  int command (int argc, const char*const* argv){

    if (strcmp(argv[1], "run") == 0) {
      int niter=0;
      for(int i=0; i<20; i++){
	CalcLinkDelays(1);
	CalcPerFlowDelays();
	newupdate(niter);
      }
      //PrintResults();  
      return (TCL_OK);
    }
    
    if (strcmp(argv[1], "readinput") == 0) {
      GetInputs((char*)argv[2]);
      //cout << "All inputs properly obtained from " << argv[2] <<endl ; 
      return (TCL_OK);
    }

    if (strcmp(argv[1], "get-link-drop") == 0) {
      cout << "Hi";
      Tcl& tcl = Tcl::instance();
      tcl.resultf("%lf",get_link_drop(atoi(argv[2])));
      return (TCL_OK);
    }

    if (strcmp(argv[1], "get-link-delay") == 0) {
      Tcl& tcl = Tcl::instance();
      tcl.resultf("%lf",get_link_delay(atoi(argv[2])));
      return (TCL_OK);
    }  

    if (strcmp(argv[1], "get-link-tput") == 0) {
      Tcl& tcl = Tcl::instance();
      tcl.resultf("%lf",get_link_tput(atoi(argv[2])));
      return (TCL_OK);
    }  

    if (strcmp(argv[1], "get-flow-tput") == 0) {
      Tcl& tcl = Tcl::instance();
      tcl.resultf("%lf",get_flow_tput(atoi(argv[2])));
      return (TCL_OK);
    }

    if (strcmp(argv[1], "get-flow-delay") == 0) {
      Tcl& tcl = Tcl::instance();
      tcl.resultf("%lf",get_flow_delay(atoi(argv[2])));
      return (TCL_OK);
    }      

    if (strcmp(argv[1], "get-flow-drop") == 0) {
      Tcl& tcl = Tcl::instance();
      tcl.resultf("%lf",get_flow_drop(atoi(argv[2])));
      return (TCL_OK);
    }
	return 0;
  }
  
  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) {
    
    // error if usage is wrong 
    /*    
    if (argc != 2) {
      fprintf(stderr,"Usage: %s  <InputFile>\n", argv[0]);
      exit(-1); 
      }*/
    
  // No error 
  MaxHops = 0;
  // K = atoi(argv[1]);
  // assert(K >= 1);


  // 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);
      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;
      }
      
      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 .....

	links[i].redrouter = new RedRouter((int)links[i].minth, 
					   (int)links[i].maxth,
					   links[i].pmax);
	assert(links[i].red);

      }
      else{
	links[i].red=0;
      }
	
      continue;

    }

    assert(0);
  }

  // Check whether everything is all right 
  assert (nConnections > 0);
  assert (nLinks > 0);
  int i;
  for (i=0; i<nConnections; ++i)
    assert(nAdj[i] > 0);

  
  // check all the edges and store all the connections that flow 
  // through a particular link
  
  for(i=0;i<nLinks;i++){

    //    cout << i << sp;
    int c=0; links[i].tlambda=0;

    for(int j=0;j<nConnections;j++){
      for(int k=0;k<nAdj[j];k++){
	if(Adj[j][k]==i){
	  c++;
	}
      }
    }
    links[i].nflows=c;
    //cout << c << sp;

    if(c){
      links[i].theflows = new int[c];
      c = 0;
      // Store teh flows
      for(int j=0;j<nConnections;j++){
	for(int k=0;k<nAdj[j];k++){
	  if(Adj[j][k]==i){