main.cc

模拟器提供了一个简单易用的平台

/*
 * File: main.cc
 * Author: Suman Banerjee <[e-mail]>
 * Date: July 31, 2001
 * Terms: GPL
 *
 * myns simulator
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <randomize.h>
#include "main.h"
#include "parser-event.h"

#include <rtoracle.h>
#include <rtoracle-ts.h>

#define LOG_SCHEDULER
#undef LOG_JUNK
#undef LOG_ECHO

ParserReturnInfo parser_events;
Node ** ptr_global_node_array;
Agent** ptr_global_agent_array;
RoutingType global_routing_type = ROUTE_ORACLE;
char global_ts_routing_sgb_filename [MAX_NAME_SIZE];

NamedConstant global_seed ("seed", -1);

extern void SpecificPrintSimulation (void);
extern Node * SpecificNewNode (void);
extern void SpecificAttachAgents (void);

extern int yyparse (void);

bool ProcessEvent (EventInfo *pevent)
{
  switch (pevent->et) {

  case EVENT_START :
    StartSimulation();
    break;

  case EVENT_STOP :
    StopSimulation();
    delete pevent;
    return true;

  case EVENT_PRINT_SIMULATION_STATUS :
    SpecificPrintSimulation();
    break;

  case EVENT_NODE :
    ((Node*)(pevent->object))->EventHandler((NodeEvent *)(pevent->params));
    break;

  case EVENT_AGENT :
    if ( ((AgentEvent *)(pevent->params))->t == AGENT_SOURCE) {
      if (((Agent*)(pevent->object))->started == false)
        break;
    }
    ((Agent*)(pevent->object))->EventHandler((AgentEvent *)(pevent->params));
    break;

  case EVENT_TIMER :
    ((Timer*)(pevent->object))->Handler();
    break;

  default :
    fprintf (stderr, "[Err] unknown event type\n");
    exit(0);
  }
  
  delete pevent;
  return false;
}

void StartSimulation (void) {
#ifdef LOG_SCHEDULER
  printf ("[Sch] simulator start\n");
#endif // LOG_SCHEDULER

#define MILLION 	1000000
  double start_time, end_time;
  struct timeval tv;
  struct timezone tz;

  gettimeofday(&tv,&tz);
  start_time = tv.tv_sec + ( (double)(tv.tv_usec)) / ( (double)MILLION );

  switch (global_routing_type) {
    case ROUTE_ORACLE :
      printf ("[Routing] oracle\n");
      createOracleRT(parser_events.num_nodes);
      break;

    case ROUTE_ORACLE_TS :
      printf ("[Routing] oracle ts %s\n", global_ts_routing_sgb_filename);
      createTSOracleRT(global_ts_routing_sgb_filename,parser_events.num_nodes);
      break;

    default :
      printf ("[Err] No routing mechanism found\n");
      exit(-1);
  }

  gettimeofday(&tv,&tz);
  end_time = tv.tv_sec + ( (double)(tv.tv_usec)) / ( (double)MILLION );
  printf ("[Routing] time to initialize routing: %f\n",end_time - start_time);

  EventInfo * pnext_event;
  while ((pnext_event = Scheduler::GetNextEvent()) != NULL) {
#ifdef LOG_JUNK
    printf ("[Junk] found event");
#endif // LOG_JUNK
    bool stop_found = ProcessEvent(pnext_event);
    if (stop_found)
      break;
  }

    return;
}

void StopSimulation (void) {
#ifdef LOG_SCHEDULER
    printf ("[Sch] simulator stop at %8.5f\n", Scheduler::Clock());
#endif // LOG_SCHEDULER

    for (int i = 0; i < parser_events.num_nodes; i++)
      ptr_global_node_array[i]->display_on_stop_simulation();

    // for (int i = 0; i < parser_events.num_agents; i++)
    //  delete ptr_global_agent_array[i];
    // for (int i = 0; i < parser_events.num_nodes; i++)
    //  delete ptr_global_node_array[i];

    delete [] ptr_global_node_array;
    delete [] ptr_global_agent_array;
    return;
}

void init_seed (void) {

  struct timeval tv;
  struct timezone tz;

  if (GLOBAL_SEED == -1) {
    gettimeofday(&tv,&tz);   
    init_generic_random(tv.tv_usec);
    init_random_for_pkt_sources(tv.tv_usec);
    printf ("[Seed] %d\n",(int)(tv.tv_usec));
  }
  else {
    init_generic_random(GLOBAL_SEED);
    init_random_for_pkt_sources(GLOBAL_SEED);
    printf ("[Seed] %d\n",GLOBAL_SEED);
  }
  return;
}

void init (void) {

  parser_events.num_nodes = -1;
  parser_events.num_agents = -1;
  parser_events.edge_list = new LinkedList<Edge *,int>;
  parser_events.attach_list = new LinkedList<Attachment*,int>;
  parser_events.ev_list = new LinkedList<AtEvent *,double>;
  Scheduler::SchedulerClassInit();
  return;
}

void InitParserEvents (void) {

  NamedConstant::display_all();

#ifdef LOG_ECHO
    printf ("[echo-parse] nodecount %d\n", parser_events.num_nodes);
#endif // LOG_ECHO
  ptr_global_node_array = new Node * [parser_events.num_nodes];
  for (int i = 0; i < parser_events.num_nodes; i++) {
    ptr_global_node_array[i] = SpecificNewNode();
    ptr_global_node_array[i]->index = i;
    ptr_global_node_array[i]->id = i;
  }

  parser_events.num_agents = parser_events.attach_list->GetSize();
  ptr_global_agent_array = new Agent * [parser_events.attach_list->GetSize()];

  SpecificAttachAgents();

  for (void *pos = parser_events.edge_list->GetHeadPosition();
       pos != NULL;
       parser_events.edge_list->GetNext(pos) ) {
    Edge *e = parser_events.edge_list->GetAt(pos);
    if (global_routing_type != ROUTE_ORACLE_TS) {
      if ( (e->node1 >= parser_events.num_nodes) || (e->node2 >= parser_events.num_nodes) ) {
        printf ("[Err] Node not defined in edge (%d %d) : Max node id %d\n", e->node1, e->node2, parser_events.num_nodes - 1);
        exit(-1);
      }
      if (e->node1 == e->node2) {
        printf ("[Err] Self loop is not allowed in edge (%d %d)\n",e->node1, e->node2);
        exit(-1);
      }

      Node *n1 = ptr_global_node_array[e->node1];
      Node *n2 = ptr_global_node_array[e->node2];
      if ( (n1->neighbor_list.Locate(n2->id) != NULL) ||
           (n2->neighbor_list.Locate(n1->id) != NULL) ) {

         printf ("[Err] Duplicated edge (%d %d\n", e->node1, e->node2);
         exit(-1);
      }
      n1->add_neighbor(n2,e->wt);
      n2->add_neighbor(n1,e->wt);

#ifdef LOG_ECHO
      printf ("[echo-parse] edge %d %d %8.5f\n", e->node1, e->node2, e->wt);
#endif // LOG_ECHO
    }

    delete e;
  }

  for (void *pos = parser_events.ev_list->GetHeadPosition();
       pos != NULL;
       parser_events.ev_list->GetNext(pos) ) {
    AtEvent *ae = parser_events.ev_list->GetAt(pos);

    EventInfo *sim_ev;

    switch (ae->t) {
      
    case STOP_SIMULATION :
      sim_ev = new EventInfo(EVENT_STOP,NULL,NULL);
      break;

    case PRINT_SIMULATION_STATUS:
      sim_ev = new EventInfo(EVENT_PRINT_SIMULATION_STATUS,NULL,NULL);
      break;

    case START_NODE : {
      NodeEvent *ne = new NodeEvent(NODE_START,NULL);
      sim_ev = new EventInfo(EVENT_NODE,(void*)(ptr_global_node_array[ae->node]),(void*)ne);
      break;
    }

    case START_AGENT : {
      AgentEvent *ag_e = new AgentEvent(AGENT_START);
      sim_ev = new EventInfo(EVENT_AGENT,(void*)(ptr_global_agent_array[ae->agent]),(void*)ag_e);
      break;
    }

    case STOP_NODE : {
      NodeEvent *ne = new NodeEvent(NODE_STOP,NULL);
      sim_ev = new EventInfo(EVENT_NODE,(void*)(ptr_global_node_array[ae->node]),(void*)ne);
      break;
    }

    case STOP_AGENT : {
      AgentEvent *ag_e = new AgentEvent(AGENT_STOP);
      sim_ev = new EventInfo(EVENT_AGENT,(void*)(ptr_global_agent_array[ae->agent]),(void*)ag_e);
      break;
    }

    case SOURCE_AGENT : {
      AgentEvent *ag_e = new AgentEvent(AGENT_SOURCE);
      ag_e->sdt = ae->sdt;
      ag_e->source_burst = ae->source_burst;
      ag_e->source_gap = ae->source_gap;
      sim_ev = new EventInfo(EVENT_AGENT,(void*)(ptr_global_agent_array[ae->agent]),(void*)ag_e);
      break;
    }

    default :
      printf ("[Err] Illegal event parsed\n");
      exit(-1);
    }

    Scheduler::AddAbsoluteEvent(ae->at,sim_ev);
    delete ae;
  }

  parser_events.edge_list->RemoveAll();
  parser_events.attach_list->RemoveAll();
  parser_events.ev_list->RemoveAll();

  return;
}

void simulator_main (int argc, char ** argv)
{
  init();

  // First we need to read some file that has scheduling info. This would
  // fill up a current set of events. Then we will execute the events in
  // sequence.
  yyparse();
  init_seed();
  InitParserEvents();
  StartSimulation();

  return;
}