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

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

通讯编程

开发平台：

Visual C++

god.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*-
  2.  *
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaim
  13. er in the
  14.  *    documentation and/or other materials provided with the distribution.
  15.  * 3. All advertising materials mentioning features or use of this software
  16.  *    must display the following acknowledgement:
  17.  * This product includes software developed by the Computer Systems
  18.  * Engineering Group at Lawrence Berkeley Laboratory.
  19.  * 4. Neither the name of the University nor of the Laboratory may be used
  20.  *    to endorse or promote products derived from this software without
  21.  *    specific prior written permission.
  22.  *
  23.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33.  * SUCH DAMAGE.
  34.  *
  35.  * $Header: /cvsroot/nsnam/ns-2/mobile/god.cc,v 1.20 2006/12/27 14:57:23 tom_henderson Exp $
  36.  */
  38. /* Ported from CMU/Monarch's code, nov'98 -Padma.*/
  40. /*
  41.  * god.cc
  42.  *
  43.  * General Operations Director
  44.  *
  45.  * perform operations requiring omnipotence in the simulation
  46.  *
  47.  * NOTE: Tcl node indexs are 0 based, NS C++ node IP addresses (and the
  48.  * node->index() are 1 based.
  49.  *
  50.  */
  52. #include <object.h>
  53. #include <packet.h>
  54. #include <ip.h>
  55. #include <god.h>
  56. #include <sys/param.h>  /* for MIN/MAX */
  58. #include "diffusion/hash_table.h"
  59. #include "mobilenode.h"
  61. God* God::instance_;
  63. static class GodClass : public TclClass {
  64. public:
  65.         GodClass() : TclClass("God") {}
  66.         TclObject* create(int, const char*const*) {
  67.                 return (new God);
  68.         }
  69. } class_God;
  72. God::God()
  73. {
  74.         min_hops = 0;
  75.         num_nodes = 0;
  77.         data_pkt_size = 64;
  78. mb_node = 0;
  79. next_hop = 0;
  80. prev_time = -1.0;
  81. num_alive_node = 0;
  82. num_connect = 0;
  83. num_recv = 0;
  84. num_compute = 0;
  85. num_data_types = 0;
  86. source_table = 0;
  87. sink_table = 0;
  88. num_send = 0;
  89. active = false;
  90. allowTostop = false;
  91. }
  94. // Added by Chalermek 12/1/99
  96. int God::NextHop(int from, int to)
  97. {
  98.   if (active == false) {
  99.     perror("God is off.n");
  100.     exit(-1);
  101.   }
  103.   if (from >= num_nodes) {
  104.     perror("index from higher than the maximum number of nodes.n");
  105.     return -1;
  106.   }
  108.   if (to >= num_nodes) {
  109.     perror("index to higher than the maximum number of nodes.n");
  110.     return -1;
  111.   }
  113.   return NEXT_HOP(from,to);
  114. }
  117. void God::ComputeNextHop()
  118. {
  119.   if (active == false) {
  120.     return;
  121.   }
  123.   int from, to, neighbor;
  125.   for (from=0; from<num_nodes; from++) {
  126.     for (to=0; to<num_nodes; to++) {
  128.       NEXT_HOP(from,to) = UNREACHABLE;
  130.       if (from==to) {
  131. NEXT_HOP(from,to) = from;     // next hop is itself.
  132.       }
  134.       if (MIN_HOPS(from, to) == UNREACHABLE) {
  135. continue;
  136.       }
  138.       for (neighbor=0; neighbor<num_nodes; neighbor++){
  139. if ( MIN_HOPS(from, neighbor) != 1) {
  140.   continue;
  141. }
  143. if ( MIN_HOPS(from, to) == (MIN_HOPS(neighbor,to) +1) ) {
  144.   NEXT_HOP(from, to) = neighbor;
  145.   break;
  146. }
  147.       }
  149.     }
  150.   }
  151. }
  154. void God::UpdateNodeStatus()
  155. {
  156.   int i,j;
  157.   int count, cur, sk, srcid, dt;
  159.    for (i=0; i<num_data_types; i++) {
  160.      for (j=0; j<num_nodes; j++) {
  161.        if (SRC_TAB(i,j) != NULL) {
  162.  node_status[j].is_source_ = true;
  163.        }
  164.      }
  165.    }
  167.    for (i=0; i<num_data_types; i++) {
  168.      for (j=0; j<num_nodes; j++) {
  169.        if (SK_TAB(i,j) > 0) {
  170.  node_status[j].is_sink_ = true;
  171.        }
  172.      }
  173.    }
  175.    for (dt=0; dt < num_data_types; dt++) {
  176.      for (srcid=0; srcid < num_nodes; srcid++) {
  177.        if (SRC_TAB(dt,srcid) == NULL) 
  178.  continue;
  179.        for (sk = 0; sk < num_nodes; sk++) {
  180.  if (SK_TAB(dt, sk) == 0)
  181.    continue;
  182.  cur = srcid;
  183.  count = 0;
  184.  node_status[cur].is_on_trees_ = true;
  185.  while (cur != sk) {
  186.    if (NextHop(cur, sk) == UNREACHABLE)
  187.      break;
  189.    assert(NextHop(cur,sk) >= 0 && NextHop(cur, sk) < num_nodes);
  191.    cur = NextHop(cur, sk);      
  192.    node_status[cur].is_on_trees_ = true;
  194.    count ++;
  195.    assert(count < num_nodes);
  196.  }
  197.        }
  198.      }
  199.    }
  201.    Dump();
  202.    DumpNodeStatus();
  203. }
  206. void God::DumpNodeStatus()
  207. {
  208.   for (int i=0; i < num_nodes; i++) {
  209.     printf("Node %d status (sink %d, source %d, on_tree %d)n", i, 
  210.    node_status[i].is_sink_, node_status[i].is_source_, 
  211.    node_status[i].is_on_trees_);
  212.   }
  213. }
  215. void God::DumpNumSend()
  216. {
  217. #ifdef DEBUG_OUTPUT
  218.   for (int i=0; i < num_data_types; i++) {
  219.     fprintf(stdout, "God: data type %d distinct events %dn", i, num_send[i]);
  220.   }
  221. #endif
  222. }
  225. void God::Dump()
  226. {
  227.    int i, j, k, l;
  229.    // Dump min_hops array
  231.    fprintf(stdout,"Dump min_hopsn");
  232.    for(i = 0; i < num_nodes; i++) {
  233.       fprintf(stdout, "%2d) ", i);
  234.       for(j = 0; j < num_nodes; j++)
  235.           fprintf(stdout, "%2d ", min_hops[i * num_nodes + j]);
  236.           fprintf(stdout, "n");
  237.   }
  239.    // How many times the god compute routes ?
  241.    fprintf(stdout, "God computes routes %d times.n", num_compute);
  244.    // The following information can be found only when god is active.
  246.    if (active == false) {
  247.      return;
  248.    }
  250.    // Dump next_hop array
  252.    fprintf(stdout, "Dump next_hopn");
  253.    for (i = 0; i < num_nodes; i++) {
  254.      for (j = 0; j < num_nodes; j++) {
  255.        fprintf(stdout,"NextHop(%d,%d):%dn",i,j,NEXT_HOP(i,j));
  256.      }
  257.    }
  260.    // What is inside SRC_TAB ?
  262.    fprintf(stdout, "Dump SRC_TABn");
  263.    for (i=0; i<num_data_types; i++) {
  264.      fprintf(stdout,"%2d) ",i);
  265.      for (j=0; j<num_nodes; j++) {
  266.        fprintf(stdout,"%2d ", SRC_TAB(i,j) ? 1:0);
  267.      }
  268.      fprintf(stdout,"n");
  269.    }
  272.    // What is inside OIF_MAP ?
  274.    int *oif_map;
  276.    fprintf(stdout, "Dump OIF_MAPn");
  277.    for (i=0; i<num_data_types; i++) {
  278.      for (j=0; j<num_nodes; j++) {
  279.        if (SRC_TAB(i,j)!=NULL) {
  280.  oif_map = SRC_TAB(i,j);
  281.  fprintf(stdout,"(%2d,%2d)n",i,j);
  282.  for (k=0; k<num_nodes; k++) {
  283.    for (l=0; l<num_nodes; l++) {
  284.      fprintf(stdout,"%2d ", oif_map[k*num_nodes +l]);
  285.    }
  286.    fprintf(stdout,"n");
  287.  }
  288.        }
  289.      }
  290.    }
  294.    // What is inside SK_TAB ?
  296.    fprintf(stdout, "Dump SK_TABn");
  297.    for (i=0; i<num_data_types; i++) {
  298.      fprintf(stdout,"%2d) ",i);
  299.      for (j=0; j<num_nodes; j++) {
  300.        fprintf(stdout,"%2d ", SK_TAB(i,j));
  301.      }
  302.      fprintf(stdout,"n");
  303.    }
  305. }
  308. void God::AddSink(int dt, int skid)
  309. {
  310.   if (active == false) {
  311.     return;
  312.   }
  314.   assert(num_data_types > 0);
  315.   assert(num_nodes > 0);
  316.   assert(dt >= 0 && dt < num_data_types);
  317.   assert(skid >= 0 && skid < num_nodes);
  319.   if (SK_TAB(dt,skid) == 1)
  320.      return;
  322.   SK_TAB(dt,skid) = 1;
  323.   Fill_for_Source(dt, skid);
  324. }
  327. void God::AddSource(int dt, int srcid)
  328. {
  329.   if (active == false) {
  330.     return;
  331.   }
  333.   assert(num_data_types > 0);
  334.   assert(num_nodes > 0);
  335.   assert(dt >= 0 && dt < num_data_types);
  336.   assert(srcid >= 0 && srcid < num_nodes);
  338.   if (SRC_TAB(dt,srcid) != 0)
  339.       return;
  341.   SRC_TAB(dt,srcid) = new int[num_nodes * num_nodes];
  342.   bzero((char*) SRC_TAB(dt, srcid), sizeof(int) * num_nodes * num_nodes);
  343.   Fill_for_Sink(dt, srcid);
  344.   //  Dump();
  345. }
  348. void God::Fill_for_Sink(int dt, int srcid)
  349. {
  350.   int sk, cur, count;
  351.   int *oif_map = SRC_TAB(dt, srcid);
  353.   assert(oif_map != NULL);
  355.   for (sk = 0; sk < num_nodes; sk++) {
  356.     if (SK_TAB(dt, sk) == 0)
  357.       continue;
  358.     cur = srcid;
  359.     count = 0;
  360.     while (cur != sk) {
  361.       if (NextHop(cur, sk) == UNREACHABLE)
  362. break;
  364.       assert(NextHop(cur,sk) >= 0 && NextHop(cur, sk) < num_nodes);
  366.       oif_map[cur*num_nodes + NextHop(cur, sk)] = 1;
  367.       cur = NextHop(cur, sk);      
  368.       count ++;
  369.       assert(count < num_nodes);
  370.     }
  371.   }
  372. }
  375. void God::Fill_for_Source(int dt, int skid)
  376. {
  377.   int src, cur, count;
  378.   int *oif_map;
  380.   for (src = 0; src < num_nodes; src++) {
  381.     if (SRC_TAB(dt, src) == 0)
  382.       continue;
  383.    
  384.     oif_map = SRC_TAB(dt, src);
  385.     cur = src;
  386.     count = 0;
  387.     while (cur != skid) {
  388.       if (NextHop(cur, skid) == UNREACHABLE)
  389. break;
  391.       assert(NextHop(cur,skid) >= 0 && NextHop(cur, skid) < num_nodes);
  393.       oif_map[cur*num_nodes + NextHop(cur, skid)] = 1;
  394.       cur = NextHop(cur, skid);      
  395.       count ++;
  396.       assert(count < num_nodes);
  397.     }
  399.   }
  400. }
  403. void God::Rewrite_OIF_Map()
  404. {
  405.   for (int dt = 0; dt < num_data_types; dt++) {
  406.     for (int src = 0; src < num_nodes; src++) {
  407.       if (SRC_TAB(dt, src) == NULL)
  408. continue;
  410.       memset(SRC_TAB(dt,src),'x00', sizeof(int) * num_nodes * num_nodes);
  411.       Fill_for_Sink(dt, src);
  412.     }
  413.   }
  414. }
  417. int *God::NextOIFs(int dt, int srcid, int curid, int *ret_num_oif) 
  418. {
  420.   if (active == false) {
  421.     perror("God is inactive.n");
  422.     exit(-1);
  423.   }  
  425.   int *oif_map = SRC_TAB(dt, srcid);
  426.   int count=0;
  427.   int i;
  429.   for (i=0; i<num_nodes; i++) {
  430.     if (oif_map[curid*num_nodes +i] == 1)
  431.       count++;
  432.   }
  434.   *ret_num_oif = count;
  436.   if (count == 0)
  437.     return NULL;
  439.   int *next_oifs = new int[count];
  440.   int j=0;
  441.   
  442.   for (i=0; i<num_nodes; i++) {
  443.     if (oif_map[curid*num_nodes +i] == 1) {
  444.       next_oifs[j] = i;
  445.       j++;    
  446.     }
  447.   }
  449.   return next_oifs;
  450. }
  454. bool God::IsReachable(int i, int j)
  455. {
  457. //  if (MIN_HOPS(i,j) < UNREACHABLE && MIN_HOPS(i,j) >= 0) 
  458.   if (NextHop(i,j) != UNREACHABLE)
  459.      return true;
  460.   else
  461.      return false;
  462. }
  465. bool God::IsNeighbor(int i, int j)
  466. {
  467.   assert(i<num_nodes && j<num_nodes);
  469.   //printf("i=%d, j=%dn", i,j);
  470.   if (mb_node[i]->energy_model()->node_on() == false ||
  471.       mb_node[j]->energy_model()->node_on() == false ||
  472.       mb_node[i]->energy_model()->energy() <= 0.0 ||
  473.       mb_node[j]->energy_model()->energy() <= 0.0 ) {
  474.     return false;
  475.   }
  477.   vector a(mb_node[i]->X(), mb_node[i]->Y(), mb_node[i]->Z());
  478.   vector b(mb_node[j]->X(), mb_node[j]->Y(), mb_node[j]->Z());
  479.   vector d = a - b;
  481.   if (d.length() < RANGE)
  482.     return true;
  483.   else
  484.     return false;  
  485. }
  488. void God::CountConnect()
  489. {
  490.   int i,j;
  492.   num_connect = 0;
  494.   for (i=0; i<num_nodes; i++) {
  495.     for (j=i+1; j<num_nodes; j++) {
  496.       if (MIN_HOPS(i,j) != UNREACHABLE) {
  497. num_connect++;
  498.       }
  499.     }
  500.   }
  501. }
  504. void God::CountAliveNode()
  505. {
  506.   int i;
  508.   num_alive_node = 0;
  510.   for (i=0; i<num_nodes; i++) {
  511.     if (mb_node[i]->energy_model()->energy() > 0.0) {
  512.       num_alive_node++;
  513.     }
  514.   }
  516. }
  519. bool God::ExistSource()
  520. {
  521.   int dtype, i;
  523.   for (dtype = 0; dtype < num_data_types; dtype++) {
  524.     for (i=0; i<num_nodes; i++) {
  525.       if (SRC_TAB(dtype, i) != 0)
  526. return true;
  527.     }
  528.   }
  530.   return false;
  531. }
  534. bool God::ExistSink()
  535. {
  536.   int dtype, i;
  538.   for (dtype = 0; dtype < num_data_types; dtype++) {
  539.     for (i=0; i<num_nodes; i++) {
  540.       if (SK_TAB(dtype, i) != 0)
  541. return true;
  542.     }
  543.   }
  545.   return false;
  546. }
  549. bool God::IsPartition()
  550. {
  551.   int dtype, i, j, k;
  552.   int *oif_map;
  554.   for (dtype = 0; dtype < num_data_types; dtype ++) {
  555.     for (i = 0; i < num_nodes; i++) {
  556.       if (SRC_TAB(dtype,i) == NULL)
  557. continue;
  558.       oif_map = SRC_TAB(dtype, i);
  559.       for (j = 0; j < num_nodes; j++) {
  560. for (k = 0; k < num_nodes; k++) {
  561.   if (oif_map[j*num_nodes + k] != 0)
  562.     return false;
  563. }
  564.       }
  565.     }
  566.   }
  568.   return true;
  569. }
  572. void God::ComputeRoute() 
  573. {
  574.   if (active == false) {
  575.     return;
  576.   }
  578.   floyd_warshall();
  579.   ComputeNextHop();
  580.   Rewrite_OIF_Map();
  581.   CountConnect();
  582.   CountAliveNode();
  583.   prev_time = NOW;
  584.   num_compute++;
  586.   if (allowTostop == false)
  587.     return;
  589.   if ( ExistSink() == true && ExistSource() == true && IsPartition() == true)
  590.     StopSimulation();
  591. }
  594. void God::CountNewData(int *attr)
  595. {
  596.   if (dtab.GetHash(attr) == NULL) {
  597.     num_send[attr[0]]++;
  598.     dtab.PutInHash(attr);
  599.   }
  600. }
  603. void God::IncrRecv()
  604. {
  605.   num_recv++;
  607.   //  printf("God: num_connect %d, num_alive_node %d at recv pkt %dn",
  608.   // num_connect, num_alive_node, num_recv);
  609. }
  612. void God::StopSimulation() 
  613. {
  614.   Tcl& tcl=Tcl::instance();
  616.   printf("Network parition !! Exiting... at time %fn", NOW);
  617.   tcl.evalf("[Simulator instance] at %lf "finish"", (NOW)+0.000001);
  618.   tcl.evalf("[Simulator instance] at %lf "[Simulator instance] halt"", (NOW)+0.000002);
  619. }
  622. // Modified from setdest.cc -- Chalermek 12/1/99
  624. void God::ComputeW()
  625. {
  626.   int i, j;
  627.   int *W = min_hops;
  629.   memset(W, 'xff', sizeof(int) * num_nodes * num_nodes);
  631.   for(i = 0; i < num_nodes; i++) {
  632.      W[i*num_nodes + i] = 0;     
  633.      for(j = i+1; j < num_nodes; j++) {
  634. W[i*num_nodes + j] = W[j*num_nodes + i] = 
  635.                      IsNeighbor(i,j) ? 1 : INFINITY;
  636.      }
  637.   }
  638. }
  640. void God::floyd_warshall()
  641. {
  642.   int i, j, k;
  644.   ComputeW(); // the connectivity matrix
  646.   for(i = 0; i < num_nodes; i++) {
  647.      for(j = 0; j < num_nodes; j++) {
  648.  for(k = 0; k < num_nodes; k++) {
  649.     MIN_HOPS(j,k) = MIN(MIN_HOPS(j,k), MIN_HOPS(j,i) + MIN_HOPS(i,k));
  650.  }
  651.      }
  652.   }
  655. #ifdef SANITY_CHECKS
  657.   for(i = 0; i < num_nodes; i++)
  658.      for(j = 0; j < num_nodes; j++) {
  659. assert(MIN_HOPS(i,j) == MIN_HOPS(j,i));
  660. assert(MIN_HOPS(i,j) <= INFINITY);
  661.      }
  662. #endif
  664. }
  666. // --------------------------
  669. int
  670. God::hops(int i, int j)
  671. {
  672.         return min_hops[i * num_nodes + j];
  673. }
  676. void
  677. God::stampPacket(Packet *p)
  678. {
  679.         hdr_cmn *ch = HDR_CMN(p);
  680.         struct hdr_ip *ih = HDR_IP(p);
  681.         nsaddr_t src = ih->saddr();
  682.         nsaddr_t dst = ih->daddr();
  684.         assert(min_hops);
  686.         if (!packet_info.data_packet(ch->ptype())) return;
  688.         if (dst > num_nodes || src > num_nodes) return; // broadcast pkt
  689.    
  690.         ch->opt_num_forwards() = min_hops[src * num_nodes + dst];
  691. }
  694. void 
  695. God::recv(Packet *, Handler *)
  696. {
  697.         abort();
  698. }
  700. int
  701. God::load_grid(int x, int y, int size)
  702. {
  703. maxX =  x;
  704. maxY =  y;
  705. gridsize_ = size;
  707. // how many gridx in X direction
  708. gridX = (int)maxX/size;
  709. if (gridX * size < maxX) gridX ++;
  711. // how many grid in Y direcion
  712. gridY = (int)maxY/size;
  713. if (gridY * size < maxY) gridY ++;
  715. printf("Grid info:%d %d %d (%d %d)n",maxX,maxY,gridsize_,
  716.        gridX, gridY);
  718. return 0;
  719. }
  720.  
  721. // return the grid that I am in
  722. // start from left bottom corner, 
  723. // from left to right, 0, 1, ...
  725. int
  726. God::getMyGrid(double x, double y)
  727. {
  728. int xloc, yloc;
  730. if (x > maxX || y >maxY) return(-1);
  732. xloc = (int) x/gridsize_;
  733. yloc = (int) y/gridsize_;
  735. return(yloc*gridX+xloc);
  736. }
  738. int
  739. God::getMyLeftGrid(double x, double y)
  740. {
  742. int xloc, yloc;
  744. if (x > maxX || y >maxY) return(-1);
  746. xloc = (int) x/gridsize_;
  747. yloc = (int) y/gridsize_;
  749. xloc--;
  750. // no left grid
  751. if (xloc < 0) return (-2);
  752. return(yloc*gridX+xloc);
  753. }
  755. int
  756. God::getMyRightGrid(double x, double y)
  757. {
  759. int xloc, yloc;
  761. if (x > maxX || y >maxY) return(-1);
  763. xloc = (int) x/gridsize_;
  764. yloc = (int) y/gridsize_;
  766. xloc++;
  767. // no left grid
  768. if (xloc > gridX) return (-2);
  769. return(yloc*gridX+xloc);
  770. }
  772. int
  773. God::getMyTopGrid(double x, double y)
  774. {
  776. int xloc, yloc;
  778. if (x > maxX || y >maxY) return(-1);
  780. xloc = (int) x/gridsize_;
  781. yloc = (int) y/gridsize_;
  783. yloc++;
  784. // no top grid
  785. if (yloc > gridY) return (-2);
  786. return(yloc*gridX+xloc);
  787. }
  789. int
  790. God::getMyBottomGrid(double x, double y)
  791. {
  793. int xloc, yloc;
  795. if (x > maxX || y >maxY) return(-1);
  797. xloc = (int) x/gridsize_;
  798. yloc = (int) y/gridsize_;
  800. yloc--;
  801. // no top grid
  802. if (yloc < 0 ) return (-2);
  803. return(yloc*gridX+xloc);
  804. }
  806. int 
  807. God::command(int argc, const char* const* argv)
  808. {
  809. Tcl& tcl = Tcl::instance(); 
  810. if ((instance_ == 0) || (instance_ != this))
  811.            instance_ = this; 
  813.         if (argc == 2) {
  815.         if(strcmp(argv[1], "update_node_status") == 0) {
  816.   UpdateNodeStatus();
  817.   return TCL_OK;
  818. }
  820.         if(strcmp(argv[1], "compute_route") == 0) {
  821.   ComputeRoute();
  822.   return TCL_OK;
  823. }
  825.                 if(strcmp(argv[1], "dump") == 0) {
  826.         Dump();
  827.                         return TCL_OK;
  828.                 }
  830. if (strcmp(argv[1], "dump_num_send") == 0) {
  831.   DumpNumSend();
  832.   return TCL_OK;
  833. }
  835. if (strcmp(argv[1], "on") == 0) {
  836.   active = true;
  837.   return TCL_OK;
  838. }
  840. if (strcmp(argv[1], "off") == 0) {
  841.   active = false;
  842.   return TCL_OK;
  843. }
  845. if (strcmp(argv[1], "allow_to_stop") == 0) {
  846.   allowTostop = true;
  847.   return TCL_OK;
  848. }
  850. if (strcmp(argv[1], "not_allow_to_stop") == 0) {
  851.   allowTostop = false;
  852.   return TCL_OK;
  853. }
  855. /*
  856.                 if(strcmp(argv[1], "dump") == 0) {
  857.                         int i, j;
  859.                         for(i = 1; i < num_nodes; i++) {
  860.                                 fprintf(stdout, "%2d) ", i);
  861.                                 for(j = 1; j < num_nodes; j++)
  862.                                         fprintf(stdout, "%2d ",
  863.                                                 min_hops[i * num_nodes + j]);
  864.                                 fprintf(stdout, "n");
  865.                         }
  866.                         return TCL_OK;
  867.                 }
  868. */
  870. if(strcmp(argv[1], "num_nodes") == 0) {
  871. tcl.resultf("%d", nodes());
  872. return TCL_OK;
  873. }
  874.         }
  875.         else if(argc == 3) {
  877.         if (strcasecmp(argv[1], "is_source") == 0) {
  878.   int node_id = atoi(argv[2]);
  880.   if (node_status[node_id].is_source_ == true) {
  881.     tcl.result("1");
  882.   } else {
  883.     tcl.result("0");
  884.   }
  885.   return TCL_OK;
  886.         }
  888.         if (strcasecmp(argv[1], "is_sink") == 0) {
  889.   int node_id = atoi(argv[2]);
  891.   if (node_status[node_id].is_sink_ == true) {
  892.     tcl.result("1");
  893.   } else {
  894.     tcl.result("0");
  895.   }
  896.   return TCL_OK;
  897.         }
  899.         if (strcasecmp(argv[1], "is_on_trees") == 0) {
  900.   int node_id = atoi(argv[2]);
  902.   if (node_status[node_id].is_on_trees_ == true) {
  903.     tcl.result("1");
  904.   } else {
  905.     tcl.result("0");
  906.   }
  907.   return TCL_OK;
  908.         }
  910.                 if (strcasecmp(argv[1], "num_nodes") == 0) {
  911.                         assert(num_nodes == 0);
  913.                         // index always starts from 0
  914.                         num_nodes = atoi(argv[2]);
  916. assert(num_nodes > 0);
  918. printf("num_nodes is set %dn", num_nodes);
  920.                         min_hops = new int[num_nodes * num_nodes];
  921. mb_node = new MobileNode*[num_nodes];
  922. node_status = new NodeStatus[num_nodes];
  923. next_hop = new int[num_nodes * num_nodes];
  925.                         bzero((char*) min_hops,
  926.                               sizeof(int) * num_nodes * num_nodes);
  927. bzero((char*) mb_node,
  928.       sizeof(MobileNode*) * num_nodes);
  929. bzero((char*) next_hop,
  930.       sizeof(int) * num_nodes * num_nodes);
  932.                         instance_ = this;
  934.                         return TCL_OK;
  935.                 }
  937. if (strcasecmp(argv[1], "num_data_types") == 0) {
  938.   assert(num_data_types == 0);
  940.                   num_data_types = atoi(argv[2]);
  942.   assert(num_nodes > 0);
  943.   assert(num_data_types > 0);
  945.                   source_table = new int*[num_data_types * num_nodes];
  946.   sink_table = new int[num_data_types * num_nodes];
  947.   num_send = new int[num_data_types];
  949.                   bzero((char*) source_table,
  950.                               sizeof(int *) * num_data_types * num_nodes);
  951.                   bzero((char*) sink_table,
  952.                               sizeof(int) * num_data_types * num_nodes);
  953.   bzero((char*) num_send, sizeof(int) * num_data_types);
  955.   return TCL_OK;
  956. }
  958. if (strcasecmp(argv[1], "new_node") == 0) {
  959.   assert(num_nodes > 0);
  960.   MobileNode *obj = (MobileNode *)TclObject::lookup(argv[2]);
  961.   assert(obj != 0);
  962.   assert(obj->address() < num_nodes);
  964.   mb_node[obj->address()] = obj; 
  965.   return TCL_OK;
  966. }
  968. /*
  969.                 if (strcasecmp(argv[1], "num_nodes") == 0) {
  970.                         assert(num_nodes == 0);
  972.                         // allow for 0 based to 1 based conversion
  973.                         num_nodes = atoi(argv[2]) + 1;
  975.                         min_hops = new int[num_nodes * num_nodes];
  976.                         bzero((char*) min_hops,
  977.                               sizeof(int) * num_nodes * num_nodes);
  979.                         instance_ = this;
  981.                         return TCL_OK;
  982.                 }
  983. */
  985.         }
  986. else if (argc == 4) {
  988.   if (strcasecmp(argv[1], "is_reachable") == 0) {
  989.     int n1 = atoi(argv[2]);
  990.     int n2 = atoi(argv[3]);
  992.     if (IsReachable(n1,n2) == true) {
  993.       tcl.result("1");
  994.     } else {
  995.       tcl.result("0");
  996.     }
  998.     return TCL_OK;
  999.   }
  1002.   // We can add source from tcl script or call AddSource directly.
  1004.   if (strcasecmp(argv[1], "add_source") == 0) {
  1005.     int dt = atoi(argv[2]);
  1006.     int srcid = atoi(argv[3]);
  1007.     
  1008.     AddSource(dt, srcid);
  1009.     return TCL_OK;
  1010.   }
  1012.   // We can add sink from tcl script or call AddSink directly.
  1014.   if (strcasecmp(argv[1], "add_sink") == 0) {
  1015.     int dt = atoi(argv[2]);
  1016.     int skid = atoi(argv[3]);
  1017.     
  1018.     AddSink(dt, skid);
  1019.     return TCL_OK;
  1020.   }
  1022. }
  1023.         else if(argc == 5) {
  1025. /* load for grid-based adaptive fidelity */
  1026. if (strcmp(argv[1], "load_grid") == 0) {
  1027. if(load_grid(atoi(argv[2]), atoi(argv[3]), atoi(argv[4])))
  1028. return TCL_ERROR;
  1029. return TCL_OK;
  1030. }
  1032.                 if (strcasecmp(argv[1], "set-dist") == 0) {
  1033.                         int i = atoi(argv[2]);
  1034.                         int j = atoi(argv[3]);
  1035.                         int d = atoi(argv[4]);
  1037.                         assert(i >= 0 && i < num_nodes);
  1038.                         assert(j >= 0 && j < num_nodes);
  1040. if (active == true) {
  1041.   if (NOW > prev_time) {
  1042.     ComputeRoute();
  1043.   }
  1044. }
  1045. else {
  1046.   min_hops[i*num_nodes+j] = d;
  1047.   min_hops[j*num_nodes+i] = d;
  1048. }
  1050. // The scenario file should set the node positions
  1051. // before calling set-dist !!
  1053. assert(min_hops[i * num_nodes + j] == d);
  1054.                         assert(min_hops[j * num_nodes + i] == d);
  1055.                         return TCL_OK;
  1056.                 }
  1058. /*
  1059.                 if (strcasecmp(argv[1], "set-dist") == 0) {
  1060.                         int i = atoi(argv[2]);
  1061.                         int j = atoi(argv[3]);
  1062.                         int d = atoi(argv[4]);
  1064.                         assert(i >= 0 && i < num_nodes);
  1065.                         assert(j >= 0 && j < num_nodes);
  1067.                         min_hops[i * num_nodes + j] = d;
  1068.                         min_hops[j * num_nodes + i] = d;
  1069.                         return TCL_OK;
  1070.                 }
  1071. */
  1073.         } 
  1074.         return BiConnector::command(argc, argv);
  1075. }