开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
setdest2.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：14k
源码类别：

通讯编程

开发平台：

Visual C++

setdest2.cc：源码内容
  1. /*
  2.  * a simplified version of setdest which bypass the computation of route length.
  3.  */
  5. extern "C" {
  6. #include <assert.h>
  7. #include <fcntl.h>
  8. #include <math.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <sys/time.h>
  13. #include <sys/types.h>
  14. #include <sys/uio.h>
  15. #include <unistd.h>
  16. #if !defined(sun) && !defined(__CYGWIN__)
  17. #include <err.h>
  18. #endif
  19. };
  20. #include "../../../rng.h"
  22. #include "setdest.h"
  25. // #define DEBUG
  26. #define SANITY_CHECKS
  27. //#define SHOW_SYMMETRIC_PAIRS
  30. #define GOD_FORMAT "$ns_ at %.12f "$god_ set-dist %d %d %d"n"
  31. #define GOD_FORMAT2 "$god_ set-dist %d %d %dn"
  32. #define NODE_FORMAT "$ns_ at %.12f "$node_(%d) setdest %.12f %.12f %.12f"n"
  33. #define NODE_FORMAT2 "$node_(%d) setdest %.12f %.12f %.12fn"
  34. #define NODE_FORMAT3 "$node_(%d) set %c_ %.12fn"
  36. #define INFINITY 0x00ffffff
  37. #define min(x,y) ((x) < (y) ? (x) : (y))
  38. #define max(x,y) ((x) > (y) ? (x) : (y))
  39. #define ROUND_ERROR 1e-9
  41. static int count = 0;
  43. /* ======================================================================
  44.    Function Prototypes
  45.    ====================================================================== */
  46. void usage(char**);
  47. void init(void);
  48. double uniform(void);
  50. void dumpall(void);
  51. void ComputeW(void);
  52. void floyd_warshall(void);
  54. void show_diffs(void);
  55. void show_routes(void);
  56. void show_counters(void);
  59. /* ======================================================================
  60.    Global Variables
  61.    ====================================================================== */
  62. const double RANGE = 250.0; // transmitter range in meters
  63. double TIME = 0.0; // my clock;
  64. double MAXTIME = 0.0; // duration of simulation
  66. double MAXX = 0.0;
  67. double MAXY = 0.0;
  68. double MAXSPEED = 0.0;
  69. double PAUSE = 0.0;
  70. u_int32_t NODES = 0;
  71. u_int32_t RouteChangeCount = 0;
  72. u_int32_t       LinkChangeCount = 0;
  73. u_int32_t DestUnreachableCount = 0;
  75. Node *NodeList = 0;
  76. u_int32_t *D1 = 0;
  77. u_int32_t *D2 = 0;
  80. /* ======================================================================
  81.    Random Number Generation
  82.    ====================================================================== */
  83. #define M 2147483647L
  84. #define INVERSE_M ((double)4.656612875e-10)
  86. char random_state[32];
  87. RNG *rng;
  89. double
  90. uniform()
  91. {
  92.         count++;
  93.         return rng->uniform_double() ;
  94. } 
  97. /* ======================================================================
  98.    Misc Functions...
  99.    ====================================================================== */
  100. void
  101. usage(char **argv)
  102. {
  103. fprintf(stderr,
  104. "nusage: %st-n <nodes> -p <pause time> -s <max speed>n",
  105. argv[0]);
  106. fprintf(stderr,
  107. "tt-t <simulation time> -x <max X> -y <max Y>nn");
  108. }
  110. void
  111. init()
  112. {
  113. /*
  114.  * Initialized the Random Number Generation
  115.  */
  116. "
  117. /*"
  118.  * Allocate memory for globals
  119.  */
  120. NodeList = new Node[NODES];
  121. if(NodeList == 0) {
  122. perror("new");
  123. exit(1);
  124. }
  126. D1 = new u_int32_t[NODES * NODES];
  127. if(D1 == 0) {
  128. perror("new");
  129. exit(1);
  130. }
  131. memset(D1, 'xff', sizeof(u_int32_t) * NODES * NODES);
  133. D2 = new u_int32_t[NODES * NODES];
  134. if(D2 == 0) {
  135. perror("new");
  136. exit(1);
  137. }
  138. memset(D2, 'xff', sizeof(u_int32_t) * NODES * NODES);
  139. }
  141. extern "C" char *optarg;
  143. int
  144. main(int argc, char **argv)
  145. {
  146. char ch;
  148. while ((ch = getopt(argc, argv, "n:p:s:t:x:y:i:o:")) != EOF) {       
  150. switch (ch) { 
  152. case 'n':
  153. NODES = atoi(optarg);
  154. break;
  156. case 'p':
  157. PAUSE = atof(optarg);
  158. break;
  160. case 's':
  161. MAXSPEED = atof(optarg);
  162. break;
  164. case 't':
  165. MAXTIME = atof(optarg);
  166. break;
  168. case 'x':
  169. MAXX = atof(optarg);
  170. break;
  172. case 'y':
  173. MAXY = atof(optarg);
  174. break;
  176. default:
  177. usage(argv);
  178. exit(1);
  179. }
  180. }
  182. if(MAXX == 0.0 || MAXY == 0.0 || NODES == 0 || MAXTIME == 0.0) {
  183. usage(argv);
  184. exit(1);
  185. }
  187. fprintf(stdout, "#n# nodes: %d, pause: %.2f, max speed: %.2f  max x = %.2f, max y: %.2fn#n",
  188. NODES , PAUSE, MAXSPEED, MAXX, MAXY);
  190. // The more portable solution for random number generation
  191. rng = new RNG;
  192. rng->set_seed(RNG::HEURISTIC_SEED_SOURCE); 
  194. init();
  196. while(TIME <= MAXTIME) {
  197. double nexttime = 0.0;
  198. u_int32_t i;
  200. for(i = 0; i < NODES; i++) {
  201. NodeList[i].Update();
  202. }
  203. /*
  204. for(i = 0; i < NODES; i++) {
  205. NodeList[i].UpdateNeighbors();
  206. }
  207. */
  208. for(i = 0; i < NODES; i++) {
  209. Node *n = &NodeList[i];
  211. if(n->time_transition > 0.0) {
  212. if(nexttime == 0.0)
  213. nexttime = n->time_transition;
  214. else
  215. nexttime = min(nexttime, n->time_transition);
  216. }
  218. if(n->time_arrival > 0.0) {
  219. if(nexttime == 0.0)
  220. nexttime = n->time_arrival;
  221. else
  222. nexttime = min(nexttime, n->time_arrival);
  223. }
  224. }
  226. // floyd_warshall();
  228. #ifdef DEBUG
  229. show_routes();
  230. #endif
  232.   // show_diffs();
  234. #ifdef DEBUG
  235. dumpall();
  236. #endif
  238. assert(nexttime > TIME + ROUND_ERROR);
  239. TIME = nexttime;
  240. }
  242. show_counters();
  244. int of;
  245. if ((of = open(".rand_state",O_WRONLY | O_TRUNC | O_CREAT, 0777)) < 0) {
  246.   fprintf(stderr, "open rand staten");
  247.   exit(-1);
  248.   }
  249. for (unsigned int i = 0; i < sizeof(random_state); i++)
  250.           random_state[i] = 0xff & (int) (uniform() * 256);
  251. if (write(of,random_state, sizeof(random_state)) < 0) {
  252.   fprintf(stderr, "writing rand staten");
  253.   exit(-1);
  254.   }
  255. close(of);
  256. }
  259. /* ======================================================================
  260.    Node Class Functions
  261.    ====================================================================== */
  262. u_int32_t Node::NodeIndex = 0;
  264. Node::Node()
  265. {
  266. u_int32_t i;
  268. index = NodeIndex++;
  270. //if(index == 0)
  271. // return;
  273. route_changes = 0;
  274.         link_changes = 0;
  276.         /*
  277.          * For the first PAUSE seconds of the simulation, all nodes
  278.          * are stationary.
  279.          */
  280. time_arrival = TIME + PAUSE;
  281. time_update = TIME;
  282. time_transition = 0.0;
  284. position.X = position.Y = position.Z = 0.0;
  285. destination.X = destination.Y = destination.Z = 0.0;
  286. direction.X = direction.Y = direction.Z = 0.0;
  287. speed = 0.0;
  289. RandomPosition();
  291. fprintf(stdout, NODE_FORMAT3, index, 'X', position.X);
  292. fprintf(stdout, NODE_FORMAT3, index, 'Y', position.Y);
  293. fprintf(stdout, NODE_FORMAT3, index, 'Z', position.Z);
  295. neighbor = new Neighbor[NODES];
  296. if(neighbor == 0) {
  297. perror("new");
  298. exit(1);
  299. }
  301. for(i = 0; i < NODES; i++) {
  302. neighbor[i].index = i;
  303. neighbor[i].reachable = (index == i) ? 1 : 0;
  304. neighbor[i].time_transition = 0.0;
  305. }
  306. }
  310. void
  311. Node::RandomPosition()
  312. {
  313.         position.X = uniform() * MAXX;
  314.         position.Y = uniform() * MAXY;
  315. position.Z = 0.0;
  316. }
  319. void
  320. Node::RandomDestination()
  321. {
  322.         destination.X = uniform() * MAXX;
  323.         destination.Y = uniform() * MAXY;
  324. destination.Z = 0.0;
  325. assert(destination != position);
  326. }
  328. void
  329. Node::RandomSpeed()
  330. {
  331.         speed = uniform() * MAXSPEED;
  333. assert(speed != 0.0);
  334. }
  337. void
  338. Node::Update()
  339. {
  340. position += (speed * (TIME - time_update)) * direction;
  342. if(TIME == time_arrival) {
  343. vector v;
  345. if(speed == 0.0 || PAUSE == 0.0) {
  347.                         RandomDestination();
  348. RandomSpeed();
  350. v = destination - position;
  351. direction = v / v.length();
  352. time_arrival = TIME + v.length() / speed;
  353. }
  354. else {
  356. destination = position;
  357. speed = 0.0;
  359. time_arrival = TIME + PAUSE;
  360. }
  362. fprintf(stdout, NODE_FORMAT,
  363. TIME, index, destination.X, destination.Y, speed);
  365. }
  367. time_update = TIME;
  368. time_transition = 0.0;
  369. }
  372. void
  373. Node::UpdateNeighbors()
  374. {
  375. static Node *n2;
  376. static Neighbor *m1, *m2;
  377. static vector D, B, v1, v2;
  378. static double a, b, c, t1, t2, Q;
  379. static u_int32_t i, reachable;
  381. v1 = speed * direction;
  383. /*
  384.  *  Only need to go from INDEX --> N for each one since links
  385.  *  are symmetric.
  386.  */
  387. for(i = index+1; i < NODES; i++) {
  389. m1 = &neighbor[i];
  390. n2 = &NodeList[i];
  391. m2 = &n2->neighbor[index];
  393. assert(i == m1->index);
  394. assert(m1->index == n2->index);
  395. assert(index == m2->index);
  396.                 assert(m1->reachable == m2->reachable);
  398.                 reachable = m1->reachable;
  400. /* ==================================================
  401.    Determine Reachability
  402.    ================================================== */
  403. { vector d = position - n2->position;
  405. if(d.length() < RANGE) {
  406. #ifdef SANITY_CHECKS
  407. if(TIME > 0.0 && m1->reachable == 0)
  408. assert(RANGE - d.length() < ROUND_ERROR);
  409. #endif
  410. m1->reachable = m2->reachable = 1;
  411. }
  412. // Boundary condition handled below.
  413. else {
  414. #ifdef SANITY_CHECKS
  415. if(TIME > 0.0 && m1->reachable == 1)
  416. assert(d.length() - RANGE < ROUND_ERROR);
  417. #endif
  418. m1->reachable = m2->reachable = 0;
  419. }
  420. #ifdef DEBUG
  421.                         fprintf(stdout, "# %.6f (%d, %d) %.2fmn",
  422.                                 TIME, index, m1->index, d.length());
  423. #endif
  424. }
  426. /* ==================================================
  427.    Determine Next Event Time
  428.    ================================================== */
  429. v2 = n2->speed * n2->direction;
  431. D = v2 - v1;
  432. B = n2->position - position;
  434. a = (D.X * D.X) + (D.Y * D.Y) + (D.Z * D.Z);
  435. b = 2 * ((D.X * B.X) + (D.Y * B.Y) + (D.Z * B.Z));
  436. c = (B.X * B.X) + (B.Y * B.Y) + (B.Z * B.Z) - (RANGE * RANGE);
  438. if(a == 0.0) {
  439. /*
  440.  *  No Finite Solution
  441.  */
  442. m1->time_transition= 0.0;
  443. m2->time_transition= 0.0;
  444. goto  next;
  445. }
  447. Q = b * b - 4 * a * c;
  448. if(Q < 0.0) {
  449. /*
  450.  *  No real roots.
  451.  */
  452. m1->time_transition = 0.0;
  453. m2->time_transition = 0.0;
  454. goto next;
  455. }
  456. Q = sqrt(Q);
  458. t1 = (-b + Q) / (2 * a);
  459. t2 = (-b - Q) / (2 * a);
  461. // Stupid Rounding/Boundary Cases
  462. if(t1 > 0.0 && t1 < ROUND_ERROR) t1 = 0.0;
  463. if(t1 < 0.0 && -t1 < ROUND_ERROR) t1 = 0.0;
  464. if(t2 > 0.0 && t2 < ROUND_ERROR) t2 = 0.0;
  465. if(t2 < 0.0 && -t2 < ROUND_ERROR) t2 = 0.0;
  467. if(t1 < 0.0 && t2 < 0.0) {
  468. /*
  469.  *  No "future" time solution.
  470.  */
  471. m1->time_transition = 0.0;
  472. m2->time_transition = 0.0;
  473. goto next;
  474. }
  476. /*
  477.  * Boundary conditions.
  478.  */
  479. if((t1 == 0.0 && t2 > 0.0) || (t2 == 0.0 && t1 > 0.0)) {
  480. m1->reachable = m2->reachable = 1;
  481. m1->time_transition = m2->time_transition = TIME + max(t1, t2);
  482. }
  483. else if((t1 == 0.0 && t2 < 0.0) || (t2 == 0.0 && t1 < 0.0)) {
  484. m1->reachable = m2->reachable = 0;
  485. m1->time_transition = m2->time_transition = 0.0;
  486. }
  488. /*
  489.  * Non-boundary conditions.
  490.  */
  491. else if(t1 > 0.0 && t2 > 0.0) {
  492. m1->time_transition = TIME + min(t1, t2);
  493. m2->time_transition = TIME + min(t1, t2);
  494. }
  495. else if(t1 > 0.0) {
  496. m1->time_transition = TIME + t1;
  497. m2->time_transition = TIME + t1;
  498. }
  499. else {
  500. m1->time_transition = TIME + t2;
  501. m2->time_transition = TIME + t2;
  502. }
  504. /* ==================================================
  505.    Update the transition times for both NODEs.
  506.    ================================================== */
  507. if(time_transition == 0.0 || (m1->time_transition &&
  508.    time_transition > m1->time_transition)) {
  509. time_transition = m1->time_transition;
  510. }
  511. if(n2->time_transition == 0.0 || (m2->time_transition &&
  512.    n2->time_transition > m2->time_transition)) {
  513. n2->time_transition = m2->time_transition;
  514. }
  515.         next:
  516.                 if(reachable != m1->reachable && TIME > 0.0) {
  517.                         LinkChangeCount++;
  518.                         link_changes++;
  519.                         n2->link_changes++;
  520.                 }
  521. }
  522. }
  524. void
  525. Node::Dump()
  526. {
  527. Neighbor *m;
  528. u_int32_t i;
  530. fprintf(stdout,
  531. "Node: %dtpos: (%.2f, %.2f, %.2f) dst: (%.2f, %.2f, %.2f)n",
  532. index, position.X, position.Y, position.Z,
  533. destination.X, destination.Y, destination.Z);
  534. fprintf(stdout, "tdir: (%.2f, %.2f, %.2f) speed: %.2fn",
  535. direction.X, direction.Y, direction.Z, speed);
  536. fprintf(stdout, "tArrival: %.2f, Update: %.2f, Transition: %.2fn",
  537. time_arrival, time_update, time_transition);
  539. for(i = 0; i < NODES; i++) {
  540. m = &neighbor[i];
  541. fprintf(stdout, "tNeighbor: %d (%x), Reachable: %d, Transition Time: %.2fn",
  542. m->index, (int) m, m->reachable, m->time_transition);
  543. }
  544. }
  547. /* ======================================================================
  548.    Dijkstra's Shortest Path Algoritm
  549.    ====================================================================== */
  550. void dumpall()
  551. {
  552. u_int32_t i;
  554. fprintf(stdout, "nTime: %.2fn", TIME);
  556. for(i = 0; i < NODES; i++) {
  557. NodeList[i].Dump();
  558. }
  559. }
  561. void
  562. ComputeW()
  563. {
  564. u_int32_t i, j;
  565. u_int32_t *W = D2;
  567. memset(W, 'xff', sizeof(int) * NODES * NODES);
  569. for(i = 0; i < NODES; i++) {
  570. for(j = i; j < NODES; j++) {
  571. Neighbor *m = &NodeList[i].neighbor[j];
  572. if(i == j)
  573. W[i*NODES + j] = W[j*NODES + i] = 0;
  574. else
  575. W[i*NODES + j] = W[j*NODES + i] = m->reachable ? 1 : INFINITY;
  576. }
  577. }
  578. }
  580. void
  581. floyd_warshall()
  582. {
  583. u_int32_t i, j, k;
  585. ComputeW(); // the connectivity matrix
  587. for(i = 0; i < NODES; i++) {
  588. for(j = 0; j < NODES; j++) {
  589. for(k = 0; k < NODES; k++) {
  590. D2[j*NODES + k] = min(D2[j*NODES + k], D2[j*NODES + i] + D2[i*NODES + k]);
  591. }
  592. }
  593. }
  595. #ifdef SANITY_CHECKS
  596. for(i = 0; i < NODES; i++)
  597. for(j = 0; j < NODES; j++) {
  598. assert(D2[i*NODES + j] == D2[j*NODES + i]);
  599. assert(D2[i*NODES + j] <= INFINITY);
  600. }
  601. #endif
  602. }
  605. /*
  606.  *  Write the actual GOD entries to a TCL script.
  607.  */
  608. void
  609. show_diffs()
  610. {
  611. u_int32_t i, j;
  613. for(i = 0; i < NODES; i++) {
  614. for(j = i + 1; j < NODES; j++) {
  615. if(D1[i*NODES + j] != D2[i*NODES + j]) {
  617. if(D2[i*NODES + j] == INFINITY)
  618. DestUnreachableCount++;
  620.                                 if(TIME > 0.0) {
  621.                                         RouteChangeCount++;
  622.                                         NodeList[i].route_changes++;
  623.                                         NodeList[j].route_changes++;
  624.                                 }
  626. if(TIME == 0.0) {
  627. fprintf(stdout, GOD_FORMAT2,
  628. i, j, D2[i*NODES + j]);
  629. #ifdef SHOW_SYMMETRIC_PAIRS
  630. fprintf(stdout, GOD_FORMAT2,
  631. j, i, D2[j*NODES + i]);
  632. #endif
  633. }
  634. else {
  635. fprintf(stdout, GOD_FORMAT, 
  636. TIME, i, j, D2[i*NODES + j]);
  637. #ifdef SHOW_SYMMETRIC_PAIRS
  638. fprintf(stdout, GOD_FORMAT, 
  639. TIME, j, i, D2[j*NODES + i]);
  640. #endif
  641. }
  642. }
  643. }
  644. }
  646. memcpy(D1, D2, sizeof(int) * NODES * NODES);
  647. }
  650. void
  651. show_routes()
  652. {
  653. u_int32_t i, j;
  655. fprintf(stdout, "#n# TIME: %.12fn#n", TIME);
  656. for(i = 0; i < NODES; i++) {
  657. fprintf(stdout, "# %2d) ", i);
  658. for(j = 0; j < NODES; j++)
  659. fprintf(stdout, "%3d ", D2[i*NODES + j] & 0xff);
  660. fprintf(stdout, "n");
  661. }
  662. fprintf(stdout, "#n");
  663. }
  665. void
  666. show_counters()
  667. {
  668. u_int32_t i;
  670. fprintf(stdout, "#n# Destination Unreachables: %dn#n",
  671. DestUnreachableCount);
  672. fprintf(stdout, "# Route Changes: %dn#n", RouteChangeCount);
  673.         fprintf(stdout, "# Link Changes: %dn#n", LinkChangeCount);
  674.         fprintf(stdout, "# Node | Route Changes | Link Changesn");
  675. for(i = 0; i < NODES; i++)
  676. fprintf(stdout, "# %4d |          %4d |         %4dn",
  677.                         i, NodeList[i].route_changes,
  678.                         NodeList[i].link_changes);
  679. fprintf(stdout, "#n");
  680. }