ns-2.29 » indep-utils » cmu-scen-gen » setdest

calcdest.cc File Reference

#include <assert.h>
#include <fcntl.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include "../../../tools/rng.h"
#include "setdest.h"

Include dependency graph for calcdest.cc:

Go to the source code of this file.

Defines

#define GOD_FORMAT   "$ns_ at %.12f \"$god_ set-dist %d %d %d\"\n"
#define GOD_FORMAT2   "$god_ set-dist %d %d %d\n"
#define INFINITY   0x00ffffff
#define INVERSE_M   ((double)4.656612875e-10)
#define M   2147483647L
#define max(x, y)   ((x) > (y) ? (x) : (y))
#define min(x, y)   ((x) < (y) ? (x) : (y))
#define NODE_FORMAT   "$ns_ at %.12f \"$node_(%d) setdest %.12f %.12f %.12f\"\n"
#define NODE_FORMAT2   "$node_(%d) setdest %.12f %.12f %.12f\n"
#define NODE_FORMAT3   "$node_(%d) set %c_ %.12f\n"
#define ROUND_ERROR   1e-9
#define SANITY_CHECKS

Functions

void ComputeW (void)
void dumpall (void)
void floyd_warshall (void)
void init (void)
int main (int argc, char **argv)
void OpenAndReadHeader (char *in_filename, char *out_filename)
void ReadInMovementPattern ()
void show_counters (void)
void show_diffs (void)
void show_routes (void)
double uniform (void)
void usage (char **)

Variables

static int count = 0
u_int32_t * D1 = 0
u_int32_t * D2 = 0
u_int32_t DestUnreachableCount = 0
FILE * in_file
u_int32_t LinkChangeCount = 0
double MAXSPEED = 0.0
double MAXTIME = 0.0
double MAXX = 0.0
double MAXY = 0.0
Node * NodeList = 0
u_int32_t NODES = 0
char * optarg
FILE * out_file
double PAUSE = 0.0
char random_state [32]
double RANGE = 250.0
RNG * rng
u_int32_t RouteChangeCount = 0
double TIME = 0.0

Define Documentation

#define GOD_FORMAT   "$ns_ at %.12f \"$god_ set-dist %d %d %d\"\n"
 

Definition at line 22 of file calcdest.cc.

#define GOD_FORMAT2   "$god_ set-dist %d %d %d\n"
 

Definition at line 23 of file calcdest.cc.

#define INFINITY   0x00ffffff
 

Definition at line 29 of file calcdest.cc.

Referenced by RouteLogic::alloc(), RouteLogic::compute_routes(), God::ComputeW(), ComputeW(), JoBS::deque(), RouteLogic::hier_alloc(), RouteLogic::hier_compute_routes(), RouteLogic::hier_print_hadj(), RouteLogic::hier_reset(), JoBS::JoBS(), JoBS::minRatesNeeded(), RouteLogic::reset(), and show_diffs().

#define INVERSE_M   ((double)4.656612875e-10)
 

Definition at line 80 of file calcdest.cc.

#define M   2147483647L
 

Definition at line 79 of file calcdest.cc.

Referenced by Friis(), and Propagation::Friis().

#define max (  x,
y   )     ((x) > (y) ? (x) : (y))
 

Definition at line 31 of file calcdest.cc.

#define min (  x,
y   )     ((x) < (y) ? (x) : (y))
 

Definition at line 30 of file calcdest.cc.

#define NODE_FORMAT   "$ns_ at %.12f \"$node_(%d) setdest %.12f %.12f %.12f\"\n"
 

Definition at line 24 of file calcdest.cc.

#define NODE_FORMAT2   "$node_(%d) setdest %.12f %.12f %.12f\n"
 

Definition at line 25 of file calcdest.cc.

#define NODE_FORMAT3   "$node_(%d) set %c_ %.12f\n"
 

Definition at line 26 of file calcdest.cc.

#define ROUND_ERROR   1e-9
 

Definition at line 32 of file calcdest.cc.

Referenced by Node::UpdateNeighbors().

#define SANITY_CHECKS
 

Definition at line 18 of file calcdest.cc.

Referenced by Node::UpdateNeighbors().

Function Documentation

void ComputeW (  void   ) 
 

Definition at line 661 of file calcdest.cc.

References D2, INFINITY, and NodeList.

Referenced by floyd_warshall().

00662 {
00663     u_int32_t i, j;
00664     u_int32_t *W = D2;
00665 
00666     memset(W, '\xff', sizeof(int) * NODES * NODES);
00667 
00668     for(i = 1; i < NODES; i++) {
00669         for(j = i; j < NODES; j++) {
00670             Neighbor *m = &NodeList[i].neighbor[j];
00671             if(i == j)
00672                 W[i*NODES + j] = W[j*NODES + i] = 0;
00673             else
00674                 W[i*NODES + j] = W[j*NODES + i] = m->reachable ? 1 : INFINITY;  
00675         }
00676     }
00677 }

void dumpall (  void   ) 
 

Definition at line 649 of file calcdest.cc.

References NodeList, and TIME.

00650 {
00651     u_int32_t i;
00652 
00653     fprintf(stdout, "\nTime: %.2f\n", TIME);
00654 
00655     for(i = 1; i < NODES; i++) {
00656         NodeList[i].Dump();
00657     }
00658 }

void floyd_warshall (  void   ) 
 

Definition at line 680 of file calcdest.cc.

References ComputeW(), D2, and min.

00681 {
00682     u_int32_t i, j, k;
00683 
00684     ComputeW(); // the connectivity matrix
00685 
00686     for(i = 1; i < NODES; i++) {
00687         for(j = 1; j < NODES; j++) {
00688             for(k = 1; k < NODES; k++) {
00689                 D2[j*NODES + k] = min(D2[j*NODES + k], D2[j*NODES + i] + D2[i*NODES + k]);
00690             }
00691         }
00692     }
00693 
00694 #ifdef SANITY_CHECKS
00695     for(i = 1; i < NODES; i++)
00696         for(j = 1; j < NODES; j++) {
00697             assert(D2[i*NODES + j] == D2[j*NODES + i]);
00698             assert(D2[i*NODES + j] <= INFINITY);
00699         }
00700 #endif
00701 }

Here is the call graph for this function:

void init (  void   ) 
 

Definition at line 112 of file calcdest.cc.

References D1, D2, NodeList, and NODES.

Referenced by PolicyClassifier::addPolicyEntry(), main(), and Tcl_AppInit().

00113 {
00114     /*
00115      * Initialized the Random Number Generation
00116      */
00117 
00118     /*
00119      * Allocate memory for globals
00120      */
00121     NodeList = new Node[NODES];
00122     if(NodeList == 0) {
00123         perror("new");
00124         exit(1);
00125     }
00126 
00127     D1 = new u_int32_t[NODES * NODES];
00128     if(D1 == 0) {
00129         perror("new");
00130         exit(1);
00131     }
00132     memset(D1, '\xff', sizeof(u_int32_t) * NODES * NODES);
00133 
00134     D2 = new u_int32_t[NODES * NODES];
00135     if(D2 == 0) {
00136         perror("new");
00137         exit(1);
00138     }
00139     memset(D2, '\xff', sizeof(u_int32_t) * NODES * NODES);
00140 }

int main (  int  argc,
char **  argv
) 
 

Definition at line 236 of file calcdest.cc.

References RNG::HEURISTIC_SEED_SOURCE, init(), MAXTIME, NodeList, NODES, OpenAndReadHeader(), optarg, ReadInMovementPattern(), rng, RNG::set_seed(), TIME, and usage().

00237 {
00238     char ch;
00239     char *in_filename = NULL;
00240     char *out_filename = NULL;
00241 
00242     while ((ch = getopt(argc, argv, "n:t:i:o:")) != EOF) {       
00243 
00244         switch (ch) { 
00245 
00246         case 'n':
00247             NODES = atoi(optarg) + 1;
00248             break;
00249 
00250         case 't':
00251             MAXTIME = atof(optarg);
00252             break;
00253     
00254         case 'i':
00255             in_filename = optarg;
00256             break;
00257 
00258         case 'o':
00259             out_filename = optarg;
00260             break;
00261 
00262         default:
00263             usage(argv);
00264             exit(1);
00265         }
00266     }
00267 
00268     if (NULL == in_filename || NULL == out_filename) {
00269             usage(argv);
00270         exit(1);
00271     }
00272 
00273     OpenAndReadHeader(in_filename, out_filename);
00274 
00275     if(NODES == 0 || MAXTIME == 0.0) {
00276         usage(argv);
00277         exit(1);
00278     }
00279     // A more portable solution for random number generation
00280         rng = new RNG;
00281         rng->set_seed(RNG::HEURISTIC_SEED_SOURCE); 
00282     init();
00283 
00284     ReadInMovementPattern();
00285 
00286     while(TIME <= MAXTIME) {
00287         double nexttime = 0.0;
00288         u_int32_t i;
00289 
00290         for(i = 1; i < NODES; i++) {
00291             NodeList[i].Update();
00292         }
00293 
00294         for(i = 1; i < NODES; i++) {
00295             NodeList[i].UpdateNeighbors();
00296         }
00297 
00298         for(i = 1; i < NODES; i++) {
00299             Node *n = &NodeList[i];
00300     
00301             if(n->time_transition > 0.0) {
00302                 if(nexttime == 0.0)
00303                     nexttime = n->time_transition;
00304                 else
00305                     nexttime = min(nexttime, n->time_transition);
00306             }
00307 
00308             if(n->time_arrival > 0.0) {
00309                 if(nexttime == 0.0)
00310                     nexttime = n->time_arrival;
00311                 else
00312                     nexttime = min(nexttime, n->time_arrival);
00313             }
00314         }
00315 
00316         floyd_warshall();
00317 
00318 #ifdef DEBUG
00319         show_routes();
00320 #endif
00321 
00322         show_diffs();
00323 
00324 #ifdef DEBUG
00325         dumpall();
00326 #endif
00327 
00328         if (nexttime <= TIME + ROUND_ERROR) 
00329           TIME = MAXTIME + 1;   /* we're done */
00330         else 
00331           TIME = nexttime;
00332 #ifdef OLD
00333         assert(nexttime > TIME + ROUND_ERROR);
00334         TIME = nexttime;
00335 #endif
00336 
00337     }
00338 
00339     show_counters();
00340 
00341     int of;
00342     if ((of = open(".rand_state",O_WRONLY | O_TRUNC | O_CREAT, 0777)) < 0)
00343       fprintf(stderr,"open rand state");
00344     for (unsigned int i = 0; i < sizeof(random_state); i++)
00345       random_state[i] = 0xff & (int) (uniform() * 256);
00346     if (write(of,random_state, sizeof(random_state)) < 0)
00347       fprintf(stderr,"writing rand state");
00348     close(of);
00349 }

Here is the call graph for this function:

void OpenAndReadHeader (  char *  in_filename,
char *  out_filename
) 
 

Definition at line 143 of file calcdest.cc.

References in_file, MAXTIME, NODES, out_file, and RANGE.

Referenced by main().

00146 {
00147   char buf[256];
00148   
00149   in_file = fopen(in_filename,"r");
00150   out_file = fopen(out_filename,"w");
00151   
00152   if (NULL == in_file) 
00153     fprintf(stderr, "*** can't open inputfile %s",in_filename);
00154   if (NULL == out_file) 
00155     fprintf(stderr,"can't open outputfile %s",out_filename);
00156   
00157   while (!feof(in_file)) {
00158 
00159     *buf = fgetc(in_file);
00160     ungetc(*buf,in_file);
00161     if (*buf != '#') break;
00162 
00163     fgets(buf, sizeof(buf), in_file);
00164 
00165     /* check to see if we need data from the line */
00166     sscanf(buf, "# nodes: %d, max time: %lf", &NODES, &MAXTIME);
00167     sscanf(buf, "# nominal range: %lf", &RANGE);
00168     
00169     fprintf(out_file, "%s", buf);
00170   }
00171   NODES += 1;           // correct for 1-based indexs
00172   fflush(out_file);
00173 }

void ReadInMovementPattern (  void   ) 
 

Definition at line 176 of file calcdest.cc.

References in_file, LIST_INSERT_HEAD, MAXTIME, NodeList, NODES, out_file, Node::position, vector::X, vector::Y, and vector::Z.

Referenced by main().

00177 {
00178   char buf[256];
00179   u_int n;
00180   double x,y,z,t,s;
00181   struct setdest *setdest;
00182 
00183   while (!feof(in_file)) {
00184 
00185     fgets(buf, sizeof(buf), in_file);
00186     fprintf(out_file, "%s", buf);
00187     if (*buf == '#') continue;
00188     if (*buf == '\n') continue;
00189 
00190     /* check to see if we need data from the line */
00191     if (2 == sscanf(buf,"$node_(%d) set Z_ %lf", &n, &z)) 
00192       {
00193     assert(n < NODES);
00194     NodeList[n].position.Z = z;
00195       }
00196     else if (2 == sscanf(buf,"$node_(%d) set X_ %lf", &n, &x)) 
00197       {
00198     assert(n < NODES);
00199     NodeList[n].position.X = x;
00200       }
00201     else if (2 == sscanf(buf,"$node_(%d) set Y_ %lf", &n, &y)) 
00202       {
00203     assert(n < NODES);
00204     NodeList[n].position.Y = y;
00205       }
00206     else if (5 == sscanf(buf,"$ns_ at %lf \"$node_(%d) setdest %lf %lf %lf\"", 
00207             &t, &n, &x, &y, &s)) 
00208       {
00209     assert(n < NODES);
00210     assert(t <= MAXTIME);
00211     setdest = (struct setdest *)malloc(sizeof(*setdest));
00212     assert(setdest);
00213     setdest->X = x; setdest->Y = y; setdest->Z = 0;
00214     setdest->time = t;
00215     setdest->speed = s;
00216     if (NodeList[n].traj.lh_first 
00217         && t > NodeList[n].traj.lh_first->time)
00218       {
00219         printf("setdest's must be in anti-chronological order in input file!\n");
00220         printf("failed on node %d\n",n);
00221         exit(-1);
00222       }
00223     LIST_INSERT_HEAD(&NodeList[n].traj,setdest,traj);
00224       }
00225     else 
00226       {
00227     printf("unparsable line: '%s'", buf);
00228     continue;
00229       }
00230   }  
00231   fflush(out_file);  
00232 }

void show_counters (  void   ) 
 

Definition at line 765 of file calcdest.cc.

References DestUnreachableCount, LinkChangeCount, NodeList, out_file, and RouteChangeCount.

00766 {
00767     u_int32_t i;
00768 
00769     fprintf(out_file, "#\n# Destination Unreachables: %d\n#\n",
00770         DestUnreachableCount);
00771     fprintf(out_file, "# Route Changes: %d\n#\n", RouteChangeCount);
00772         fprintf(out_file, "# Link Changes: %d\n#\n", LinkChangeCount);
00773         fprintf(out_file, "# Node | Route Changes | Link Changes\n");
00774     for(i = 1; i < NODES; i++)
00775         fprintf(out_file, "# %4d |          %4d |         %4d\n",
00776                         i, NodeList[i].route_changes,
00777                         NodeList[i].link_changes);
00778     fprintf(out_file, "#\n");
00779 }

void show_diffs (  void   ) 
 

Definition at line 708 of file calcdest.cc.

References D1, D2, DestUnreachableCount, INFINITY, NodeList, Node::route_changes, RouteChangeCount, and TIME.

00709 {
00710     u_int32_t i, j;
00711 
00712     for(i = 1; i < NODES; i++) {
00713         for(j = i + 1; j < NODES; j++) {
00714             if(D1[i*NODES + j] != D2[i*NODES + j]) {
00715 
00716                 if(D2[i*NODES + j] == INFINITY)
00717                     DestUnreachableCount++;
00718 
00719                                 if(TIME > 0.0) {
00720                                         RouteChangeCount++;
00721                                         NodeList[i].route_changes++;
00722                                         NodeList[j].route_changes++;
00723                                 }
00724 
00725                 if(TIME == 0.0) {
00726                     fprintf(out_file, GOD_FORMAT2,
00727                         i, j, D2[i*NODES + j]);
00728 #ifdef SHOW_SYMMETRIC_PAIRS
00729                     fprintf(out_file, GOD_FORMAT2,
00730                         j, i, D2[j*NODES + i]);
00731 #endif
00732                 }
00733                 else {
00734                     fprintf(out_file, GOD_FORMAT, 
00735                         TIME, i, j, D2[i*NODES + j]);
00736 #ifdef SHOW_SYMMETRIC_PAIRS
00737                     fprintf(out_file, GOD_FORMAT, 
00738                         TIME, j, i, D2[j*NODES + i]);
00739 #endif
00740                 }
00741             }
00742         }
00743     }
00744 
00745     memcpy(D1, D2, sizeof(int) * NODES * NODES);
00746 }

void show_routes (  void   ) 
 

Definition at line 750 of file calcdest.cc.

References D2, and TIME.

00751 {
00752     u_int32_t i, j;
00753 
00754     fprintf(stdout, "#\n# TIME: %.12f\n#\n", TIME);
00755     for(i = 1; i < NODES; i++) {
00756         fprintf(stdout, "# %2d) ", i);
00757         for(j = 1; j < NODES; j++)
00758             fprintf(stdout, "%3d ", D2[i*NODES + j] & 0xff);
00759         fprintf(stdout, "\n");
00760     }
00761     fprintf(stdout, "#\n");
00762 }

double uniform (  void   ) 
 

Definition at line 86 of file calcdest.cc.

References count, rng, and RNG::uniform_double().

Referenced by Node::RandomDestination(), Node::RandomPosition(), and Node::RandomSpeed().

00087 {
00088     count++;
00089     return rng->uniform_double();
00090 }

Here is the call graph for this function:

void usage (  char **   ) 
 

Definition at line 97 of file calcdest.cc.

Referenced by main().

00098 {
00099     fprintf(stderr,
00100         "\nusage: %s\t[-n <nodes>] \n",
00101         argv[0]);
00102     fprintf(stderr,
00103         "\t\t[-t <simulation time>]\n");
00104     fprintf(stderr,
00105         "\t\t-i <input_file> -o <output file>\n");
00106     fprintf(stderr,
00107 "\t\t #nodes, max time, and range read from scenario file if possible\n\n");
00108     
00109 }

Variable Documentation

int count = 0 [static]
 

Definition at line 34 of file calcdest.cc.

Referenced by PrefixTree::calculateLowerBound(), TfrcSinkAgent::command(), ConnectionsActive(), God::Fill_for_Sink(), God::Fill_for_Source(), AllocAddr::find_free(), AllocAddr::free_field(), RateLimitSessionList::getMySubsetCount(), Rmst::holeInFragMap(), PrefixTree::identifyAggregate(), RateLimitSessionList::mergeSessions(), God::NextOIFs(), RateLimitSessionList::noMySessions(), DiffusionRouting::processRmst(), PushbackAgent::pushbackCheck(), PushbackAgent::refreshUpstreamLimits(), Rmst::rmstComplete(), GTSSpec::setCount(), GTSSpec::size(), uniform(), God::UpdateNodeStatus(), and TcpSessionAgent::who_to_snd().

u_int32_t* D1 = 0
 

Definition at line 69 of file calcdest.cc.

Referenced by init(), and show_diffs().

u_int32_t* D2 = 0
 

Definition at line 70 of file calcdest.cc.

Referenced by ComputeW(), floyd_warshall(), init(), show_diffs(), and show_routes().

u_int32_t DestUnreachableCount = 0
 

Definition at line 66 of file calcdest.cc.

Referenced by show_counters(), and show_diffs().

FILE* in_file
 

Definition at line 72 of file calcdest.cc.

Referenced by OpenAndReadHeader(), and ReadInMovementPattern().

u_int32_t LinkChangeCount = 0
 

Definition at line 65 of file calcdest.cc.

Referenced by show_counters().

double MAXSPEED = 0.0
 

Definition at line 61 of file calcdest.cc.

Referenced by main(), and Node::RandomSpeed().

double MAXTIME = 0.0
 

Definition at line 57 of file calcdest.cc.

Referenced by main(), OpenAndReadHeader(), ReadInMovementPattern(), and Node::Update().

double MAXX = 0.0
 

Definition at line 59 of file calcdest.cc.

Referenced by compute_EXP_R(), main(), Node::RandomDestination(), and Node::RandomPosition().

double MAXY = 0.0
 

Definition at line 60 of file calcdest.cc.

Referenced by compute_EXP_R(), main(), Node::RandomDestination(), and Node::RandomPosition().

Node* NodeList = 0
 

Definition at line 68 of file calcdest.cc.

Referenced by ComputeW(), dumpall(), init(), main(), ReadInMovementPattern(), show_counters(), show_diffs(), and Node::UpdateNeighbors().

u_int32_t NODES = 0
 

Definition at line 63 of file calcdest.cc.

Referenced by init(), main(), OpenAndReadHeader(), and ReadInMovementPattern().

char* optarg
 

Definition at line 234 of file calcdest.cc.

Referenced by DiffusionCoreAgent::DiffusionCoreAgent(), main(), GearSenderApp::parseCommandLine(), GearReceiverApp::parseCommandLine(), and DiffApp::parseCommandLine().

FILE* out_file
 

Definition at line 73 of file calcdest.cc.

Referenced by OpenAndReadHeader(), ReadInMovementPattern(), and show_counters().

double PAUSE = 0.0
 

Definition at line 62 of file calcdest.cc.

Referenced by main().

char random_state[32]
 

Definition at line 82 of file calcdest.cc.

double RANGE = 250.0
 

Definition at line 55 of file calcdest.cc.

RNG* rng
 

Definition at line 83 of file calcdest.cc.

Referenced by main(), and uniform().

u_int32_t RouteChangeCount = 0
 

Definition at line 64 of file calcdest.cc.

Referenced by show_counters(), and show_diffs().

double TIME = 0.0
 

Definition at line 56 of file calcdest.cc.

Referenced by dumpall(), main(), show_diffs(), show_routes(), Node::Update(), and Node::UpdateNeighbors().

Generated on Tue Mar 6 16:49:45 2007 for ns2 Network Simulator 2.29 by  doxygen 1.4.6