topo_gen.cc

topo_gen基于NS2的场景自动生成软件源代码

  }
  processed.clear();

  return max_diameter;;
}

bool TopoGen::checkConfig()
{
  NodeList::iterator node_iterator;
  NodeInfo *node_entry;
  int start_node, node_id;

  // Pick one source as our start node
  start_node = (*(sources_.begin()))->node_id_;

  // Node can connect to itself, so we add it to the connected list
  connected_.push_back(start_node);

  // Build list of connected nodes
  checkConnected(start_node);

  // All sinks and sources must be connected

  // Start with sinks
  for (node_iterator = sinks_.begin();
       node_iterator != sinks_.end(); node_iterator++){
    node_entry = *node_iterator;

    if (!isConnected(&connected_, node_entry->node_id_)){
      return false;
    }
  }

  // Now check sources
  for (node_iterator = sources_.begin();
       node_iterator != sources_.end(); node_iterator++){
    node_entry = *node_iterator;

    if (!isConnected(&connected_, node_entry->node_id_)){
      return false;
    }
  }

  return true;
}

void TopoGen::checkConnected(int node_id)
{
  NodeList::iterator node_iterator;
  NodeInfo *node_entry;
  double node_x, node_y;

  node_entry = findNode(&topology_, node_id);

  if (!node_entry){
    fprintf(stderr, "Cannot find node !\n");
    exit(-1);
  }

  node_x = node_entry->node_x_;
  node_y = node_entry->node_y_;

  for (node_iterator = topology_.begin();
       node_iterator != topology_.end(); node_iterator++){

    node_entry = *node_iterator;

    // Check if the node is within radio range of node_id
    if (Distance(node_x, node_y,
         node_entry->node_x_,
         node_entry->node_y_) < COMMUNICATION_RANGE){
      // We can reach this guy
      if (!isConnected(&connected_, node_entry->node_id_)){
    // This node is connected, add it to the list
    connected_.push_back(node_entry->node_id_);

    // Repeat this for its neighbors
    checkConnected(node_entry->node_id_);
      }
    }
  }
}

bool TopoGen::isConnected(TopoList *topology_list, int node_id)
{
  TopoList::iterator node_iterator;

  for (node_iterator = topology_list->begin();
       node_iterator != topology_list->end(); node_iterator++){
    
    if (*node_iterator == node_id)
      return true;
  }

  // Not found
  return false;
}

void TopoGen::doIt()
{
  struct timeval tmv;

  while(number_of_runs_ > 0){

    // Initialize
    initialize();
    fprintf(stderr, "Starting run %d, using seed %d\n",
        number_of_runs_, seed_);

    // Create all nodes
    createNodes();

    // Pick locations a and b in the region
    if (position_ & DIAGONAL){
      // If the user wants diagonally opposite sources and sinks
      // a should be in the lower-left corner
      a_x_ = 0.0;
      a_y_ = 0.0;
      // b should be in the upper-right corner
      b_x_ = size_x_;
      b_y_ = size_y_;
    }
    else{
      // a should be in the left-lower quadrant
      a_x_ = 1.0 * size_x_ / 4 * (GetRand() * 1.0 / RAND_MAX);
      a_y_ = 1.0 * size_y_ / 4 * (GetRand() * 1.0 / RAND_MAX);

      // b must be in the right-upper quadrant
      b_x_ = 1.0 * size_x_ / 4 * (GetRand() * 1.0 / RAND_MAX);
      b_y_ = 1.0 * size_y_ / 4 * (GetRand() * 1.0 / RAND_MAX);

      // Move it up, right
      b_x_ = b_x_ + (size_x_ * 3 / 4);
      b_y_ = b_y_ + (size_y_ * 3 / 4);
    }

    if (position_ & CLUSTERED_SINKS){
      if (!pickClusteredSinks(a_x_, a_y_)){
        fprintf(stderr, "Error, Cannot pick clustered sinks !\n");
        exit(-1);
      }
    }
    else{
      if (!pickRandomSinks()){
        fprintf(stderr, "Error, Cannot pick random sinks !\n");
        exit(-1);
      }
    }

    if (position_ & CLUSTERED_SOURCES){
      if (!pickClusteredSources(b_x_, b_y_)){
        fprintf(stderr, "Error, Cannot pick clustered sources !\n");
        exit(-1);
      }
    }
    else{
      if (!pickRandomSources()){
        fprintf(stderr, "Error, Cannot pick random sources !\n");
        exit(-1);
      }
    }


    // Check if topology is usable
    if (checkConfig()){

      if (test_only_){
    // We only check the topology and print out information
    statsConfig();
      }
      else{
        // Yes, generate configuration files for this topology
        if(gen_ns2_files_)
          printTrafficFile();
        else
      printConfig();
      }

      // Move to other runs
      number_of_runs_--;
    }

    // Increment seed
    seed_++;
  }

  // We are done !
  GetTime(&tmv);
  fprintf(stderr, "Done at %ld.%06ld\n", tmv.tv_sec, tmv.tv_usec);
}

void TopoGen::initialize()
{
  nodes_.clear();
  sinks_.clear();
  sources_.clear();
  topology_.clear();
  connected_.clear();
}

TopoGen::TopoGen(int argc, char **argv)
{
  struct timeval tmv;

  // Initialize default values
  size_x_ = 0;
  size_y_ = 0;
  mode_ = 0;
  position_ = RANDOM;
  user_position_ = 1;
  number_of_sinks_ = 1;
  number_of_sources_ = 1;
  number_of_nodes_ = 2;
  output_filename_ = NULL;
  seed_ = 0;
  send_rate_ = 0;
  send_lambda_ = 0;
  number_of_runs_ = 1;
  use_custom_filter_ = false;
  equalize_events_ = true;
  gen_topo_files_ = false;
  gen_ns2_files_ = false;
  test_only_ = false;
  filenames_with_send_rate_ = false;

  // Parse command line options
  parseCommandLine(argc, argv);

  // Initialize Topology Generator
  GetTime(&tmv);

  if (seed_ == 0){
    SetSeed(&tmv);
    seed_ = tmv.tv_usec;
  }
  else
    srand(seed_);
  
  if (send_rate_ > 0){
    // Calculate send_lambda for the poisson model on how often source
    // nodes send events. If we want to send the same number of events
    // when having different number of sources in the network,
    // send_lambda_ has to be divided by the number of sources in order
    // to have the same overall number of events.
    if (equalize_events_)
      send_lambda_ = (float) 1.0 / (number_of_sources_ * send_rate_);
    else
      send_lambda_ = (float) 1.0 / send_rate_;
  }

  fprintf(stderr, "Initializing at %ld.%06ld\n",
      tmv.tv_sec, tmv.tv_usec);
}

void TopoGen::parseCommandLine(int argc, char **argv)
{
  int opt;
  
  opterr = 0;

  while (1){
    opt = getopt(argc, argv, "htegicdza:b:m:x:y:f:n:s:r:k:p:");

    switch (opt){

    case 'x':
      size_x_ = atoi(optarg);
      if (size_x_ < MIN_X || size_x_ > MAX_X){
        fprintf(stderr, "Error: Invalid X size !\n");
        usage(argv[0]);
      }
      break;

    case 'y':
      size_y_ = atoi(optarg);
      if (size_y_ < MIN_Y || size_y_ > MAX_Y){
        fprintf(stderr, "Error: Invalid Y size !\n");
        usage(argv[0]);
      }
      break;

    case 'n':
      number_of_nodes_ = atoi(optarg);
      if (number_of_nodes_ < MIN_NODES || number_of_nodes_ > MAX_NODES){
        fprintf(stderr, "Error: Invalid number of nodes !\n");
        usage(argv[0]);
      }
      break;

    case 's':
      seed_ = atoi(optarg);
      if (seed_ < 0){
        fprintf(stderr, "Error: Invalid seed !\n");
        usage(argv[0]);
      }
      break;

    case 'r':
      number_of_runs_ = atoi(optarg);
      if (number_of_runs_ < 1){
        fprintf(stderr, "Error: Number of runs must be > 0 !\n");
        usage(argv[0]);
      }
      break;

    case 'a':
      number_of_sinks_ = atoi(optarg);
      if (number_of_sinks_ < MIN_SINKS || number_of_sinks_ > MAX_SINKS){
        fprintf(stderr, "Error: Invalid number of sinks !\n");
        usage(argv[0]);
      }
      break;

    case 'b':
      number_of_sources_ = atoi(optarg);
      if (number_of_sources_ < MIN_SOURCES || number_of_sources_ > MAX_SOURCES){
        fprintf(stderr, "Error: Invalid number of sources !\n");
        usage(argv[0]);
      }
      break;

    case 'm':
      mode_ = atoi(optarg);
      if (mode_ < MIN_MODE || mode_ > MAX_MODE){
        fprintf(stderr, "Error: Invalid mode !\n");
        usage(argv[0]);
      }
      break;

    case 'p':
      user_position_ = atoi(optarg);
      if (user_position_ < MIN_POS || user_position_ > MAX_POS){
        fprintf(stderr, "Error: Invalid position !\n");
        usage(argv[0]);
      }
      if (user_position_ == 1)
        position_ = RANDOM;
      else if (user_position_ == 2)
        position_ = CLUSTERED_SINKS;
      else if (user_position_ == 3)
        position_ = CLUSTERED_SOURCES;
      else if (user_position_ == 4)
        position_ = CLUSTERED_SINKS|CLUSTERED_SOURCES;
      else if (user_position_ == 5)
        position_ = DIAGONAL|CLUSTERED_SINKS|CLUSTERED_SOURCES;
      break;

    case 'k':
      send_rate_ = atoi(optarg);
      if (send_rate_ < MIN_SEND_RATE || send_rate_ > MAX_SEND_RATE){
        fprintf(stderr, "Error: Invalid send rate !\n");
        usage(argv[0]);
      }
      break;

    case 'f':
      if (!strncasecmp(optarg, "-", 1)){
        fprintf(stderr, "Error: Parameter is missing !\n");
        usage(argv[0]);
      }
      output_filename_ = strdup(optarg);
      break;

    case 'c':
      use_custom_filter_ = true;
      break;

    case 'e':
      equalize_events_ = false;
      break;

    case 'g':
      gen_topo_files_ = true;
      break;

    case 't':
      test_only_ = true;
      break;

    case 'i':
      filenames_with_send_rate_ = true;
      break;

    case 'h':
      usage(argv[0]);
      break;

    case 'z':
      gen_ns2_files_ = true;
      break;

    case '?':
      fprintf(stderr,
          "Error: %c isn't a valid option or its parameter is missing !\n", optopt);
      usage(argv[0]);
      break;

    case ':':
      fprintf(stderr, "Error: Parameter missing !\n");
      usage(argv[0]);
      break;
    }

    if (opt == -1)
      break;
  }

  if (size_x_ == 0 || size_y_ == 0 || mode_ == 0 ||
      number_of_sinks_ == 0 || number_of_sources_ == 0 ||
      number_of_nodes_ == 0)
    usage(argv[0]);

  if (output_filename_ && number_of_runs_ > 1)
    usage(argv[0]);
}

void TopoGen::usage(char *s)
{
  fprintf(stderr, "Usage: %s -x x_size -y y_size -m mode [-n #nodes] [-a #sinks] [-b #sources] [-p position] [-r #runs] [-c] [-f outputfile] [-s seed] [-k sendrate] [-i] [-e] [-g] [-t] [-h] [-z]\n\n", s);
  fprintf(stderr, "\t-x - Sets region X size\n");
  fprintf(stderr, "\t-y - Sets region Y size\n");
  fprintf(stderr, "\t-m - Selects mode: 1 - Push Diffusion\n");
  fprintf(stderr, "\t                   2 - OnePhasePull Diffusion\n");
  fprintf(stderr, "\t                   3 - TwoPhasePull Diffusion\n");
  fprintf(stderr, "\t-n - Selects number of nodes (default=2)\n");
  fprintf(stderr, "\t-a - Selects number of sinks (default=1)\n");
  fprintf(stderr, "\t-b - Selects number of sources (default=1)\n");
  fprintf(stderr, "\t-p - Selects Position: 1 - Random Sources and Sinks (default)\n");
  fprintf(stderr, "\t                       2 - Clustered Sinks\n");
  fprintf(stderr, "\t                       3 - Clustered Sources\n");
  fprintf(stderr, "\t                       4 - Clustered Sources and Sinks\n");
  fprintf(stderr, "\t                       5 - Diagonally Opposite Sources and Sinks\n");
  fprintf(stderr, "\t-r - Selects number of runs (default=1)\n");
  fprintf(stderr, "\t-c - Add a custom filter\n");
  fprintf(stderr, "\t-f - Selects output file (default=autogenerated)\n");
  fprintf(stderr, "\t-s - Sets the random number generation seed (default=TOD)\n");
  fprintf(stderr, "\t-k - Selects send rate in seconds (default=none specified)\n");
  fprintf(stderr, "\t-i - Writes filenames with send rate information\n");
  fprintf(stderr, "\t-e - Disables event equalization (default=enabled)\n");
  fprintf(stderr, "\t-g - Enables generation of topology position files\n");
  fprintf(stderr, "\t-t - Generates/Tests the topology (doesn't output config file)\n");
  fprintf(stderr, "\t-h - Prints this information\n");
  fprintf(stderr, "\t-z - Output ns-2 files (default is EmSim)\n");
  fprintf(stderr, "\n");
  exit(0);
}

int main(int argc, char **argv)
{
  TopoGen *topo;

  topo = new TopoGen(argc, argv);
  topo->doIt();

  return 0;
}