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

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

通讯编程

开发平台：

Visual C++

enetmodel.cc：源码内容
  1. /*
  2.  * Copyright (C) 1997-2001 by the University of Southern California
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License,
  6.  * version 2, as published by the Free Software Foundation.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License along
  14.  * with this program; if not, write to the Free Software Foundation, Inc.,
  15.  * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  16.  *
  17.  *
  18.  * The copyright of this module includes the following
  19.  * linking-with-specific-other-licenses addition:
  20.  *
  21.  * In addition, as a special exception, the copyright holders of
  22.  * this module give you permission to combine (via static or
  23.  * dynamic linking) this module with free software programs or
  24.  * libraries that are released under the GNU LGPL and with code
  25.  * included in the standard release of ns-2 under the Apache 2.0
  26.  * license or under otherwise-compatible licenses with advertising
  27.  * requirements (or modified versions of such code, with unchanged
  28.  * license).  You may copy and distribute such a system following the
  29.  * terms of the GNU GPL for this module and the licenses of the
  30.  * other code concerned, provided that you include the source code of
  31.  * that other code when and as the GNU GPL requires distribution of
  32.  * source code.
  33.  *
  34.  * Note that people who make modified versions of this module
  35.  * are not obligated to grant this special exception for their
  36.  * modified versions; it is their choice whether to do so.  The GNU
  37.  * General Public License gives permission to release a modified
  38.  * version without this exception; this exception also makes it
  39.  * possible to release a modified version which carries forward this
  40.  * exception.
  41.  *
  42.  * $Header: /cvsroot/nsnam/nam-1/enetmodel.cc,v 1.46 2007/02/12 07:08:43 tom_henderson Exp $
  43.  */
  45. // Network model with Editor layout
  47. #include <stdlib.h>
  48. #include <math.h>
  49. #include <float.h>
  51. #include "random.h"
  52. #include "view.h"
  53. #include "netview.h"
  54. #include "animation.h"
  55. #include "queue.h"
  56. #include "edge.h"
  57. #include "node.h"
  58. #include "agent.h"
  59. #include "sincos.h"
  60. #include "state.h"
  61. #include "packet.h"
  62. #include "enetmodel.h"
  63. #include "trafficsource.h"
  64. #include "queuehandle.h"
  66. static int agent_number = 0;
  68. class EditorNetworkModelClass : public TclClass {
  69. public:
  70. EditorNetworkModelClass() : TclClass("NetworkModel/Editor") {}
  71. TclObject* create(int argc, const char*const* argv) {
  72. if (argc < 5) 
  73. return 0;
  74. return (new EditorNetModel(argv[4]));
  75. }
  76. } editornetworkmodel_class;
  78. EditorNetModel::EditorNetModel(const char *editor) :
  79. NetModel(editor) {
  81. node_id_count = 0;
  82. traffic_sources_ = NULL;
  83. lossmodels_ = NULL;
  84. queue_handles_ = NULL;
  85. maximum_simulation_time_ = 30.0; // seconds
  86. playback_speed_ = 2000.0;  // default animation speed (in microseconds)
  88. bind("Wpxmin_", &pxmin_);
  89. bind("Wpymin_", &pymin_);
  90. bind("Wpxmax_", &pxmax_);
  91. bind("Wpymax_", &pymax_);
  92. bind("maximum_simulation_time_", &maximum_simulation_time_);
  93. }
  95. EditorNetModel::~EditorNetModel()
  96. {
  97. }
  99. void EditorNetModel::BoundingBox(BBox& bb)
  100. { 
  101. // by default, 800X1000 internal drawing area
  102. bb.xmin = pxmin_;
  103. bb.ymin = pymin_;
  104. bb.xmax = pxmax_;
  105. bb.ymax = pymax_;
  107. for (Animation* a = drawables_; a != 0; a = a->next()) {
  108. a->merge(bb);
  109. }
  111. pxmin_ = bb.xmin;
  112. pymin_ = bb.ymin;
  113. pxmax_ = bb.xmax;
  114. pymax_ = bb.ymax;
  115. }
  117. //----------------------------------------------------------------------
  118. // Node * 
  119. // EditorNetModel::addNode(Node * node)
  120. //----------------------------------------------------------------------
  121. Node * 
  122. EditorNetModel::addNode(Node * node) {
  123. if (!lookupNode(node->num())) {
  124. node->next_ = nodes_;
  125. nodes_ = node;
  126. node->Animation::insert(&drawables_);
  127. return node;
  128. }
  129. return NULL;
  130. }
  132. //----------------------------------------------------------------------
  133. // int
  134. // EditorNetModel::addNode(int node_id)
  135. //----------------------------------------------------------------------
  136. Node *
  137. EditorNetModel::addNode(int node_id) {
  138. Node * node = NULL;
  139. static char name[TRACE_LINE_MAXLEN];
  140. double size = 10.0; // This is the default node size taken from
  141. // parser.cc under the 'n' animation event
  143. sprintf(name, "%d", node_id);
  144. node = new CircleNode(name, size);  
  145. node->init_color("black");
  147. if (node_id_count <= node_id) {
  148. node_id_count = node_id + 1;
  149. }
  151. if (!addNode(node)) {
  152. delete node;
  153. node = NULL; 
  154. }
  156. return node;
  157. }
  158.  
  160. //----------------------------------------------------------------------
  161. // int 
  162. // EditorNetModel::addNode(float cx, float cy)
  163. // - Create a node using the specified name
  164. // and the default size and insert it into this
  165. // NetModel's list of drawables.
  166. //----------------------------------------------------------------------
  167. int 
  168. EditorNetModel::addNode(float cx, float cy) {
  169. Node * node;
  171. // Find the next node id number
  172. if (node_id_count == 0 ) {
  173. for (node = nodes_; node != 0; node = node->next_) {
  174. if (node->num() > node_id_count) {
  175. node_id_count = node->num(); 
  176. }
  177. }
  178. node_id_count++;
  179. }
  180.  
  181. node = addNode(node_id_count);
  182. if (node) {
  183. node->place(cx,cy);
  184. }
  186. return (TCL_OK);
  187. }
  189. //----------------------------------------------------------------------
  190. //----------------------------------------------------------------------
  191. Edge *
  192. EditorNetModel::addEdge(Edge * edge) {
  193. enterEdge(edge); // adds edge to a hash table
  195. edge->Animation::insert(&drawables_); // adds to list of drawable objects
  197. placeEdge(edge, edge->getSourceNode());
  199. return edge;
  200. }
  202. //----------------------------------------------------------------------
  203. // int
  204. // EditorNetModel::addLink(Node * src, Node * dst)
  205. //  - All links are duplex links by default
  206. //----------------------------------------------------------------------
  207. int
  208. EditorNetModel::addLink(Node * src, Node * dst) {
  209. double bw = 1.0;  // Mb/s
  210. double delay = 20;  // ms
  211. double length = 0.0;
  212. double angle = 1.0;
  213. Edge * edge;
  215. if (!src->find_edge(dst->number()) && 
  216.     !dst->find_edge(src->number())) {
  218. // Create the forward edge
  219. edge = new Edge(src, dst, 25, bw, delay, length, angle);
  220. edge->init_color("black");
  222. enterEdge(edge);
  223. edge->Animation::insert(&drawables_);
  224. src->add_link(edge);
  226. placeEdge(edge, src);
  228. // Add queue handle for editing the forward edge's queue properties
  229. addQueueHandle(edge);
  231.  
  232. // Create the reverse edge
  233. edge = new Edge(dst, src, 25, bw, delay, length, angle);
  235. edge->init_color("black");
  236. enterEdge(edge);
  237. edge->Animation::insert(&drawables_);
  238. dst->add_link(edge);
  240. placeEdge(edge, dst);
  242. // Add queue handle for editing the reverse edge's queue properties
  243. addQueueHandle(edge);
  244. }
  246. return (TCL_OK);
  247. }
  249. //----------------------------------------------------------------------
  250. // int EditorNetModel::addLink(int source_id, int destination_id)
  251. //----------------------------------------------------------------------
  252. int 
  253. EditorNetModel::addLink(int source_id, int destination_id) {
  254. Node * source_node, * destination_node;
  256. source_node = lookupNode(source_id);
  257. destination_node = lookupNode(destination_id);
  259. if (source_node && destination_node) {
  260. return addLink(source_node, destination_node);
  261. }
  263. return TCL_ERROR;
  264. }
  267. //----------------------------------------------------------------------
  268. // agent_type
  269. // EditorNetModel::classifyAgent(const char * agent)
  270. //----------------------------------------------------------------------
  272. agent_type
  273. EditorNetModel::classifyAgent(const char * agent) {
  275. if (strcmp(agent, "UDP") == 0) return UDP_SOURCE_AGENT;
  276. if (strcmp(agent, "Null") == 0) return UDP_SINK_AGENT;
  277. if ((strcmp(agent, "TCP") == 0) || (strncmp(agent, "TCP/", 4) == 0))
  278. return TCP_SOURCE_AGENT;
  279. if (strcmp(agent, "TCPSink") >= 0) return TCP_SINK_AGENT;
  280. return UNKNOWN_AGENT;
  281. }
  283. //----------------------------------------------------------------------
  284. // bool
  285. // EditorNetModel::checkAgentCompatibility(agent_type source, agent_type dest)
  286. //----------------------------------------------------------------------
  287. bool
  288. EditorNetModel::checkAgentCompatibility(agent_type source, agent_type dest) {
  290. return (source == UDP_SOURCE_AGENT && dest == UDP_SINK_AGENT)
  291. || (source == UDP_SINK_AGENT && dest == UDP_SOURCE_AGENT)
  292. || (source == TCP_SOURCE_AGENT && dest == TCP_SINK_AGENT)
  293. || (source == TCP_SINK_AGENT && dest == TCP_SOURCE_AGENT)
  294. || (source == FULLTCP_AGENT && dest == FULLTCP_AGENT);
  295. }
  297. //----------------------------------------------------------------------
  298. // bool
  299. // EditorNetModel::checkAgentCompatibility(const char * source, const char * dest)
  300. //----------------------------------------------------------------------
  301. bool
  302. EditorNetModel::checkAgentCompatibility(const char * source, const char * dest) {
  304. return checkAgentCompatibility(classifyAgent(source), classifyAgent(dest));
  305. }
  312. //----------------------------------------------------------------------
  313. // int
  314. // EditorNetModel::addAgent(Agent * agent, Node * node)
  315. //----------------------------------------------------------------------
  316. int
  317. EditorNetModel::addAgent(Agent * agent, Node * node) {
  318. placeAgent(agent, node);
  320. // Add to animations list so that it will be redrawn on all updates
  321. agent->Animation::insert(&animations_);
  322. agent->node_ = node;
  323. node->add_agent(agent);
  325. return (TCL_OK);
  326. }
  328. //----------------------------------------------------------------------
  329. // int
  330. // EditorNetModel::addAgent(Node *src, char * agent_type, float cx, float cy)
  331. //----------------------------------------------------------------------
  332. int
  333. EditorNetModel::addAgent(Node * src, const char * agent_type, float cx, float cy) {
  334. Agent *a;
  335. Node *n = lookupNode(src->num());
  337. if (n == 0) {
  338. return 0;
  339. } else {
  340. a = new BoxAgent(agent_type, n->size());
  341. placeAgent(a, src);
  343. // Add to animations list so that it will be redrawn on all updates
  344. a->Animation::insert(&animations_);
  345. a->node_ = n;
  346. //a->number_ = agent_number++;
  347. agent_number++;
  348. n->add_agent(a);
  349. }
  350. return (TCL_OK);
  351. }
  353. //----------------------------------------------------------------------
  354. // int
  355. // EditorNetModel::addAgentLink(Agent *src_agent, Agent *dst_agent)
  356. //  - Need to add more constraints on which agents can connect to 
  357. //  each other
  358. // 
  359. //----------------------------------------------------------------------
  360. int EditorNetModel::addAgentLink(Agent *src_agent, Agent *dst_agent) {
  362. if (!src_agent->AgentPartner_ && !dst_agent->AgentPartner_
  363. && checkAgentCompatibility(src_agent->name(), dst_agent->name())) {
  364. // Only connect agents that don't have a partner yet
  365. // and are compatible with each other
  366.  
  367. agent_type src_type = classifyAgent(src_agent->name());
  369. if (   src_type == UDP_SOURCE_AGENT
  370.     || src_type == TCP_SOURCE_AGENT
  371.     || src_type == FULLTCP_AGENT) {
  373. src_agent->AgentRole_ = SOURCE;
  374. dst_agent->AgentRole_ = DESTINATION;
  375. } else {
  376. src_agent->AgentRole_ = DESTINATION;
  377. src_agent->AgentRole_ = SOURCE;
  378. }
  380. src_agent->AgentPartner_ = dst_agent;
  381. dst_agent->AgentPartner_ = src_agent;
  382. return TCL_OK;
  383. }
  385. return TCL_ERROR;
  386. }
  388. //----------------------------------------------------------------------
  389. // int
  390. // EditorNetModel::addAgentLink(int source_id, int destination_id) {
  391. //----------------------------------------------------------------------
  392. int
  393. EditorNetModel::addAgentLink(int source_id, int destination_id) {
  394. Agent * source, * destination;
  396. source = lookupAgent(source_id);
  397. destination = lookupAgent(destination_id);
  399. if (source && destination) {
  400.  return addAgentLink(source, destination);
  401. }
  403. return TCL_ERROR;
  404. }
  406. //----------------------------------------------------------------------
  407. // trafgen_type
  408. // EditorNetModel::classifyTrafficSource(const char * source)
  409. //----------------------------------------------------------------------
  410. trafgen_type
  411. EditorNetModel::classifyTrafficSource(const char * source) {
  412. if ( strcmp(source, "FTP") == 0
  413.   || strcmp(source, "Telnet") == 0) return TCP_APP;
  414. if ( strcmp(source, "CBR") == 0
  415.   || strcmp(source, "Pareto") == 0
  416.   || strcmp(source, "Exponential") == 0) return UDP_APP;
  417. return UNKNOWN_APP;
  418. }
  420. //----------------------------------------------------------------------
  421. // trafgen_type
  422. // EditorNetModel::checkAgentTrafficSourceCompatibility(agent_type agent, trafgen_type source)
  423. //----------------------------------------------------------------------
  424. bool
  425. EditorNetModel::checkAgentTrafficSourceCompatibility(agent_type agent, trafgen_type source) {
  426. return (source == UDP_APP && agent == UDP_SOURCE_AGENT)
  427.     || (source == TCP_APP && agent == TCP_SOURCE_AGENT)
  428.     || (source == TCP_APP && agent == FULLTCP_AGENT)
  429.     || (source == FULLTCP_APP && agent == FULLTCP_AGENT);
  431. }
  433. //----------------------------------------------------------------------
  434. // trafgen_type
  435. // EditorNetModel::checkAgentTrafficSourceCompatibility(const char * agent, const char * source)
  436. //----------------------------------------------------------------------
  437. bool
  438. EditorNetModel::checkAgentTrafficSourceCompatibility(const char * agent, const char * source) {
  440. return checkAgentTrafficSourceCompatibility(classifyAgent(agent),
  441. classifyTrafficSource(source));
  442. }
  447. //----------------------------------------------------------------------
  448. // int
  449. // EditorNetModel::addTrafficSource(TrafficSource * traffic_source,
  450. // Agent * agent)
  451. //----------------------------------------------------------------------
  452. int
  453. EditorNetModel::addTrafficSource(TrafficSource * traffic_source,
  454.                                  Agent * agent) {
  456. if (traffic_source && agent
  457.     && checkAgentTrafficSourceCompatibility(agent->name(), traffic_source->name())) {
  459. traffic_source->attachTo(agent);
  461. // Add to animations list so that it will be redrawn on all updates
  462. traffic_source->Animation::insert(&animations_);
  464. // Add to master list of all trafficsources_ which is used to 
  465. // look up a traffic source for editing purposes
  466. traffic_source->editornetmodel_next_ = traffic_sources_;
  467. traffic_sources_ = traffic_source;
  468. return TCL_OK;
  469. }
  470. return TCL_ERROR;
  471. }
  474. //----------------------------------------------------------------------
  475. // int
  476. // EditorNetModel::addTrafficSource(Agent * agent, char * type,
  477. // float cx, float cy)
  478. //----------------------------------------------------------------------
  479. int
  480. EditorNetModel::addTrafficSource(Agent * agent, const char * type,
  481.                                  float cx, float cy) {
  482. TrafficSource * traffic_source;
  483. if (agent) {
  484. traffic_source = new TrafficSource(type, agent->size());
  485. return addTrafficSource(traffic_source, agent);
  486. }
  487. return (TCL_ERROR);
  488. }
  490. //----------------------------------------------------------------------
  491. // TrafficSource *
  492. // EditorNetModel::lookupTrafficSource(int id)
  493. //----------------------------------------------------------------------
  494. TrafficSource *
  495. EditorNetModel::lookupTrafficSource(int id) {
  496. TrafficSource * ts;
  498. for (ts = traffic_sources_; ts; ts = ts->editornetmodel_next_) {
  499. if (ts->number() == id) {
  500. break;
  501. }
  502. }
  504. return ts;
  505. }
  508. //----------------------------------------------------------------------
  509. //----------------------------------------------------------------------
  510. int
  511. EditorNetModel::addLossModel(LossModel * loss_model, Edge * edge) {
  512. if (loss_model && edge) {
  513. edge->addLossModel(loss_model);
  514. loss_model->place();
  516. // Add to animations list so that it will be redrawn on all updates
  517. loss_model->Animation::insert(&animations_);
  519. // Add to master list of all lossmodels_ which is used to 
  520. // look up a lossmodel for editing purposes
  521. loss_model->next_lossmodel_ = lossmodels_;
  522. lossmodels_ = loss_model;
  523. }
  525. return TCL_OK;
  526. }
  529. //----------------------------------------------------------------------
  530. //----------------------------------------------------------------------
  531. int
  532. EditorNetModel::addLossModel(Edge * edge, const char * type,
  533.                              double cx, double cy) {
  534. LossModel * loss_model;
  535. if (edge && !edge->getLossModel()) {
  536. loss_model = new LossModel(type, edge->getSourceNode()->size());
  537. edge->addLossModel(loss_model);
  539. // Add to animations list so that it will be redrawn on all updates
  540. loss_model->Animation::insert(&animations_);
  542. // Add to master list of all lossmodels_ which is used to 
  543. // look up a lossmodel for editing purposes
  544. loss_model->next_lossmodel_ = lossmodels_;
  545. lossmodels_ = loss_model;
  546. }
  548. return (TCL_OK);
  549. }
  551. //----------------------------------------------------------------------
  552. // TrafficSource *
  553. // EditorNetModel::lookupLossModel(int id)
  554. //----------------------------------------------------------------------
  555. LossModel *
  556. EditorNetModel::lookupLossModel(int id) {
  557. LossModel * loss_model;
  559. for (loss_model = lossmodels_; 
  560.              loss_model;
  561.              loss_model = loss_model->next_lossmodel_) {
  562. if (loss_model->number() == id) {
  563. break;
  564. }
  565. }
  567. return loss_model;
  568. }
  570. //----------------------------------------------------------------------
  571. //----------------------------------------------------------------------
  572. QueueHandle * 
  573. EditorNetModel::addQueueHandle(Edge * edge) {
  574. QueueHandle * queue_handle;
  576. // Add queue handle for editing the edge's queue properties
  577. queue_handle = new QueueHandle(edge);
  578. edge->addQueueHandle(queue_handle);
  579. queue_handle->Animation::insert(&drawables_);
  581. queue_handle->next_queue_handle_ = queue_handles_;
  582. queue_handles_ = queue_handle;
  584. return queue_handle;
  585. }
  587. //----------------------------------------------------------------------
  588. //----------------------------------------------------------------------
  589. QueueHandle *
  590. EditorNetModel::addQueueHandle(Edge * edge, const char * type) {
  591. QueueHandle * queue_handle;
  593. queue_handle = addQueueHandle(edge);
  594. queue_handle->setType(type);
  596. return queue_handle;
  597. }
  600. //----------------------------------------------------------------------
  601. //
  602. //----------------------------------------------------------------------
  603. void EditorNetModel::setNodeProperty(int id, const char * value, const char * variable) {
  604. Node * node = lookupNode(id);
  606. if (node) {
  607. if (!strcmp(variable, "size_")) {
  608. node->size(strtod(value,NULL));
  609. } else if (!strcmp(variable, "color")) {
  610. node->init_color(value);
  611. } else if (!strcmp(variable, "dlabel_")) {
  612. node->dlabel(value);
  613. } else if (!strcmp(variable, "X_")) {
  614. node->place(strtod(value, NULL),node->y());
  615. } else if (!strcmp(variable, "Y_")) {
  616. node->place(node->x(), strtod(value, NULL));
  617. } else if (!strcmp(variable, "Z_")) {
  618. // 
  619. } else {
  620. fprintf(stderr, "EditorNetModel::setNodeProperty - unknown property %sn", variable);
  621. }
  622. } else {
  623. fprintf(stderr, "Node %d does not exist.n", id);
  624.      }
  625. }
  627. //----------------------------------------------------------------------
  628. //
  629. //----------------------------------------------------------------------
  630. void EditorNetModel::setAgentProperty(int id, const char * value, const char * variable) {
  631. Agent * agent = lookupAgent(id);
  632. if (agent) {
  633. if (!strcmp(variable, "windowInit_")) {
  634. // initial window size
  635. agent->windowInit(atoi(value));
  636. } else if (!strcmp(variable, "window_")) {
  637. // window size
  638. agent->window(atoi(value));
  639. } else if (!strcmp(variable, "maxcwnd_")) {
  640. // maximum cwnd_
  641. agent->maxcwnd(atoi(value));
  642. } else if (!strcmp(variable, "flowcolor_")) {
  643. // Flow ID + Color
  644. if ((strcmp(value, "(null)") == 0) || (strcmp(value, "") == 0)) {
  645. agent->flowcolor("black");
  646. } else {
  647. agent->flowcolor(value);
  648. } 
  649. } else if (!strcmp(variable, "packetSize_")) {
  650. agent->packetSize(atoi(value));
  651. } else {
  652. // fprintf(stderr, "EditorNetModel::setAgentProperty - unknown property %sn", variable);
  653. }
  654. } else {
  655. fprintf(stderr, "EditorNetModel::setAgentProperty - Nonexisting agent %d.n", id);
  656. }
  657. }
  659. //----------------------------------------------------------------------
  660. // void
  661. // EditorNetModel::setLinkProperty(int source_id, int destination_id, 
  662. //                                 char * value, char * variable)
  663. //----------------------------------------------------------------------
  664. void
  665. EditorNetModel::setLinkProperty(int source_id, int destination_id, 
  666.                                 const char * value, const char * variable) {
  667. Edge * edge = lookupEdge(source_id, destination_id);
  669. if (edge) {
  670. if (!strcmp(variable, "bandwidth_")) {
  671. edge->setBW(strtod(value,NULL));
  672. } else if (!strcmp(variable, "color_")) {
  673. edge->init_color(value);
  674. } else if (!strcmp(variable, "delay_")) {
  675. edge->setDelay(strtod(value,NULL));
  676. } else if (!strcmp(variable, "dlabel_")) {
  677. if (strcmp(value, "")) {
  678. edge->dlabel(value);
  679. }
  680. } else if (!strcmp(variable, "length_")) {
  681. edge->setLength(strtod(value,NULL));
  682. }
  683. }
  684. }
  686. //----------------------------------------------------------------------
  687. //----------------------------------------------------------------------
  688. void
  689. EditorNetModel::setQueueHandleProperty(int source_id, int destination_id,
  690.                                        const char * value, const char * variable) {
  691. Edge * edge;
  692. QueueHandle * queue;
  694. edge = lookupEdge(source_id, destination_id);
  695. if (edge) {
  696. queue = edge->getQueueHandle();
  697.   if (queue) {
  698. if (strcmp(variable, "type_") == 0) {
  699. queue->setType(value);
  700. } else if (strcmp(variable, "limit_") == 0) {
  701. queue->setLimit(atoi(value)); 
  702. } else if (strcmp(variable, "secsPerByte__") == 0) {
  703. queue->setSecondsPerByte(strtod(value,NULL));
  704. } else if (strcmp(variable, "maxqueue_") == 0) {
  705. queue->setMaxQueue(atoi(value));
  706. } else if (strcmp(variable, "buckets_") == 0) {
  707. queue->setBuckets(atoi(value));
  709. } else if (strcmp(variable, "blimit_") == 0) {
  710. queue->setSharedBufferSize(atoi(value));
  712. } else if (strcmp(variable, "quantum_") == 0) {
  713. queue->setQuantum(atoi(value));
  715. } else if (strcmp(variable, "mask_") == 0) {
  716. if (atoi(value) == 0) {
  717. queue->setMask(false);
  718. } else {
  719. queue->setMask(true);
  720. }
  721. } else if (strcmp(variable, "bytes_") == 0) {
  722. if (atoi(value) == 0) {
  723. queue->setBytes(false);
  724. } else {
  725. queue->setBytes(true);
  726. }
  727. } else if (strcmp(variable, "queue_in_bytes_") == 0) {
  728. if (atoi(value) == 0) {
  729. queue->setQueueInBytes(false);
  730. } else {
  731. queue->setQueueInBytes(true);
  732. }
  733. } else if (strcmp(variable, "thresh_") == 0) {
  734. queue->setThreshold(strtod(value,NULL));
  736. } else if (strcmp(variable, "max_thresh__") == 0) {
  737. queue->setMaximumThreshold(strtod(value,NULL));
  739. } else if (strcmp(variable, "mean_pktsize_") == 0) {
  740. queue->setMeanPacketSize(atoi(value));
  742. } else if (strcmp(variable, "q_weight_") == 0) {
  743. queue->setQueueWeight(strtod(value,NULL));
  745. } else if (strcmp(variable, "wait_") == 0) {
  746. if (atoi(value) == 0) {
  747. queue->setWaitInterval(false);
  748. } else {
  749. queue->setWaitInterval(true);
  750. }
  752. } else if (strcmp(variable, "linterm_") == 0) {
  753. queue->setLinterm(strtod(value,NULL));
  755. } else if (strcmp(variable, "setbit_") == 0) {
  756. if (atoi(value) == 0) {
  757. queue->setBitMarking(false);
  758. } else {
  759. queue->setBitMarking(true);
  760. }
  761. } else if (strcmp(variable, "drop_tail_") == 0) {
  762. if (atoi(value) == 0) {
  763. queue->setREDDropTail(false);
  764. } else {
  765. queue->setREDDropTail(true);
  766. }
  767. }
  768. } else {
  769. fprintf(stderr, "EditorNetModel::setQueueHandleProperty() - no queuehandle on edge.n");
  770. }
  771. }
  772. }
  774. //----------------------------------------------------------------------
  775. //----------------------------------------------------------------------
  776. void
  777. EditorNetModel::setTrafficSourceProperty(int id, const char * value,
  778.                                          const char * variable) {
  779. TrafficSource * trafficsource;
  781. trafficsource = lookupTrafficSource(id);
  782. if (trafficsource) {
  783. if (strcmp(variable, "start_") == 0) {
  784. //trafficsource->startAt(atof(value));
  785. trafficsource->timelist.add(strtod(value, NULL));
  787. } else if (strcmp(variable, "stop_") == 0) {
  788. //trafficsource->stopAt(atof(value));
  789. trafficsource->timelist.add(strtod(value, NULL));
  791. } else if (strcmp(variable, "interval_") == 0) {
  792. trafficsource->setInterval(atof(value));
  794. } else if (strcmp(variable, "maxpkts_") == 0) {
  795. trafficsource->setMaxpkts(atoi(value));
  797. } else if (strcmp(variable, "addtime") == 0) {
  798. trafficsource->timelist.add(atof(value));
  800. } else if (strcmp(variable, "removetime") == 0) {
  801. trafficsource->timelist.remove(atof(value));
  803. } else if (strcmp(variable, "timelist") == 0) {
  804. trafficsource->timelist.setList(value);
  806. // --- Exponential Properties
  807. } else if (strcmp(variable, "burst_time_") == 0) {
  808. trafficsource->setBurstTime(atoi(value));
  810. } else if (strcmp(variable, "idle_time_") == 0) {
  811. trafficsource->setIdleTime(atoi(value));
  813. } else if (strcmp(variable, "rate_") == 0) {
  814. trafficsource->setRate(atoi(value));
  816. // --- Pareto
  817. } else if (strcmp(variable, "shape_") == 0) {
  818. trafficsource->setShape(strtod(value, NULL));
  820. } else if (strcmp(variable, "title") == 0) {
  821. } else if (strcmp(variable, "agent_name") == 0) {
  822. } else {
  823. fprintf(stderr, " Unknown traffic source property %sn", variable);
  824. }
  826. } else {
  827. fprintf(stderr, " Unable to find traffic source with id %dn", id);
  828. }
  829. }
  831. //----------------------------------------------------------------------
  832. //----------------------------------------------------------------------
  833. void
  834. EditorNetModel::setLossModelProperty(int id, const char * value,
  835.                                      const char * variable) {
  836. LossModel * lossmodel;
  837.  
  838. lossmodel = lookupLossModel(id);
  839. if (lossmodel) {
  840. if (strcmp(variable, "period_") == 0) {
  841. lossmodel->setPeriod(strtod(value, NULL));
  842.  
  843. } else if (strcmp(variable, "offset_") == 0) {
  844. lossmodel->setOffset(strtod(value, NULL));
  846. } else if (strcmp(variable, "burstlen_") == 0) {
  847. lossmodel->setBurstLength(strtod(value, NULL));
  849. } else if (strcmp(variable, "rate_") == 0) {
  850. lossmodel->setRate(strtod(value, NULL));
  852. } else if (strcmp(variable, "loss_unit_") == 0) {
  853. lossmodel->setLossUnit(value);
  854. }
  856. } else {
  857. fprintf(stderr, " Unable to find loss model with id %dn", id);
  858. }
  859. }
  862. //----------------------------------------------------------------------
  863. //
  864. //----------------------------------------------------------------------
  865. int EditorNetModel::command(int argc, const char *const *argv) {
  866. FILE * file;
  867. Node * node;
  868. double time;
  870. if (argc == 2) {
  871. if (strcmp(argv[1], "layout") == 0) {
  872. layout();
  873. return (TCL_OK);
  874. }
  876. } else if (argc == 4) {
  877. // Write out ns script information
  878. if (strcmp(argv[1], "saveasns") == 0) {
  879. // argv syntax is as follows:
  880. // <net> saveasns filename filename_root
  881. file = fopen(argv[2], "w");
  882. if (file) {
  883. // fprintf(stderr, "Writing ns script to %s...",argv[2]);
  884. writeNsScript(file, argv[2], argv[3]);
  885. fclose(file);
  886. // fprintf(stderr, "done.n");
  887. } else {
  888. fprintf(stderr, "nam: Unable to open file: %sn", argv[2]);
  889. }
  890. return (TCL_OK);
  892. } else if (strcmp(argv[1], "removeNodeMovement") == 0) {
  893. node = lookupNode(atoi(argv[2]));
  894.                time = strtod(argv[3], NULL);
  895. node->removeMovementDestination(time);
  896. return TCL_OK;
  897. } 
  898. }
  899. return (NetModel::command(argc, argv));
  900. }
  902. //----------------------------------------------------------------------
  903. //----------------------------------------------------------------------
  904. void EditorNetModel::layout() {
  905. Node *n;
  906. for (n = nodes_; n != 0; n = n->next_)
  907. for (Edge* e = n->links(); e != 0; e = e->next_)
  908. placeEdge(e, n);
  909. }
  911. //----------------------------------------------------------------------
  912. // int 
  913. // EditorNetModel::saveAsNs(FILE * file)
  914. //----------------------------------------------------------------------
  915. int 
  916. EditorNetModel::writeNsScript(FILE * file, const char * filename, const char * filename_root) {
  917. Node * node;
  918. Edge * edge;
  919. LossModel * loss_model;
  920. Agent * agent;
  921. int number_of_wireless_nodes = 0;
  922. int number_of_wired_nodes = 0;
  923. double maximum_x, maximum_y;
  924. double node_x, node_y;
  926. maximum_x = 500;
  927. maximum_y = 500;
  929. // Add a disclaimer
  931. fprintf(file, "#------------------------------------------------------- n");
  932. fprintf(file, "# This ns script has been created by the nam editor.n");
  933. fprintf(file, "# If you edit it manually, the nam editor might notn");
  934. fprintf(file, "# be able to open it properly in the future.n");
  935. fprintf(file, "#n");
  936. fprintf(file, "# EDITING BY HAND IS AT YOUR OWN RISK!n");
  937. fprintf(file, "#------------------------------------------------------- n");
  939. fprintf(file, "# Create a new simulator object.n");
  940. fprintf(file, "set ns [new Simulator]n");
  941. fprintf(file, "# Create a nam trace datafile.n");
  942. fprintf(file, "set namfile [open %s.nam w]n", filename_root);
  943. fprintf(file, "$ns namtrace-all $namfilen");
  945. // write out node creation infomation
  946. fprintf(file, "n# Create wired nodes.n");
  947. for (node = nodes_; node; node = node->next_) {
  948. if (node->links()) {
  949. // Only write out wired links here
  950. node->writeNsScript(file);
  951. fprintf(file, "n");
  952. number_of_wired_nodes++;
  953. } else {
  954. // If a node has no links it must be a wireless node
  955. number_of_wireless_nodes++;
  956. }
  958. // Find maximum node mobility and placement range
  959. node_x = node->getMaximumX();
  960. node_y = node->getMaximumY();
  962. if (node_x > maximum_x) {
  963. // Add some extra space to be sure node is within
  964. // wireless boundary
  965. maximum_x = node_x + 2.0*node->size();
  966. }
  968. if (node_y > maximum_y) {
  969. // Add some extra space to be sure node is within
  970. // wireless boundary
  971. maximum_y = node_y + 2.0*node->size();
  972. }
  973. }
  975. if (number_of_wireless_nodes > 0) {
  976. fprintf(file, "n# ----- Setup wireless environment. ----n");
  977. fprintf(file, "set wireless_tracefile [open %s.trace w]n", filename_root);
  979. fprintf(file, "set topography [new Topography]n");
  981. fprintf(file, "$ns trace-all $wireless_tracefilen");
  982. fprintf(file, "$ns namtrace-all-wireless $namfile %f %fn", maximum_x, maximum_y);
  984. fprintf(file, "$topography load_flatgrid %f %fn", maximum_x, maximum_y);
  986. fprintf(file, "#n");
  987. fprintf(file, "# Create Godn");
  988. fprintf(file, "#n");
  989. fprintf(file, "set god_ [create-god %d]n", number_of_wireless_nodes);
  992. fprintf(file, "#global node settingn");
  994. fprintf(file, "$ns node-config -adhocRouting DSR \n");
  995. fprintf(file, "                 -llType LL \n");
  996. fprintf(file, "                 -macType Mac/802_11 \n");
  997. fprintf(file, "                 -ifqType Queue/DropTail/PriQueue \n");
  998. fprintf(file, "                 -ifqLen 50 \n");
  999. fprintf(file, "                 -antType Antenna/OmniAntenna \n");
  1000. fprintf(file, "                 -propType Propagation/TwoRayGround \n");
  1001. fprintf(file, "                 -phyType Phy/WirelessPhy \n");
  1002. fprintf(file, "                 -channel [new Channel/WirelessChannel] \n");
  1003. fprintf(file, "                 -topoInstance $topography \n");
  1004. fprintf(file, "                 -agentTrace ON \n");
  1005. fprintf(file, "                 -routerTrace OFF \n");
  1006. fprintf(file, "                 -macTrace ONn");
  1009. fprintf(file, "n# Create wireless nodes.n");
  1011. for (node = nodes_; node; node = node->next_) {
  1012. if (!node->links()) {
  1013. node->writeNsScript(file);
  1014. node->writeNsMovement(file);
  1015. }
  1016. }
  1017. }
  1019. // write out link information
  1020. fprintf(file, "n# Create links between nodes.n");
  1021. for (node = nodes_; node ; node = node->next_) {
  1022. for (edge = node->links(); edge; edge = edge->next_) {
  1023. edge->writeNsScript(file);
  1024. }
  1025. }
  1027. // Write out lossmodel information
  1028. fprintf(file, "# Add Link Loss Modelsn");
  1029. for (loss_model = lossmodels_;
  1030. loss_model;
  1031. loss_model = loss_model->next_lossmodel_) {
  1032. loss_model->writeNsDefinitionScript(file);
  1033. }
  1036. // write out agents and it's traffic sources
  1037. fprintf(file, "n# Create agents.n");
  1038. for (node = nodes_; node; node = node->next_) {
  1039. for (agent = node->agents(); agent; agent = agent->next_) {
  1040. agent->writeNsDefinitionScript(file);
  1041. }
  1042. }
  1044. // Write out agent connections
  1045. // An agent can connect to only one other agent
  1046. fprintf(file, "n# Connect agents.n");
  1047. for (node = nodes_; node; node = node->next_) {
  1048. for (agent = node->agents(); agent; agent = agent->next_) {
  1049. agent->writeNsConnectionScript(file);
  1050. }
  1051. }
  1053. // Find time at which to stop the simulation
  1054. // for (ts = traffic_sources_; ts; ts = ts->editornetmodel_next_) {
  1055. // if (finish_time < ts->stopAt()) {
  1056. // finish_time = ts->stopAt();
  1057. // }
  1058. // }
  1061. fprintf(file, "# Run the simulationn");
  1062. fprintf(file, "proc finish {} {n global ns namfilen $ns flush-tracen");
  1063. fprintf(file, " close $namfilen exec nam -r %fus %s.nam & n exit 0n }n", playback_speed_, filename_root);
  1064. //fprintf(file, "$ns at %f "finish"n", finish_time);
  1065. fprintf(file, "$ns at %f "finish"n", maximum_simulation_time_);
  1066. fprintf(file, "$ns runn");
  1067. return 0;
  1068. }
  1070. //----------------------------------------------------------------------
  1071. // void
  1072. // EditorNetModel::removeNode(Node *n)
  1073. //  - remove node n from the nodes_ list and delete it
  1074. //----------------------------------------------------------------------
  1075. void EditorNetModel::removeNode(Node *n) {
  1076. Node * previous, * run;
  1077. Edge * edge;
  1078. Agent * agent;
  1079. previous = nodes_;  
  1081. for (run = nodes_; run; run = run->next_) {
  1082. if (n->num() == run->num()) {
  1083. // when deleting the last node
  1084. if (run->num() == nodes_->num()) {
  1085. nodes_ = nodes_->next_;
  1086. break;
  1087. } else {
  1088. previous->next_ = run->next_; 
  1089. break;
  1090. }
  1091. }
  1092. previous = run;
  1093. }
  1094. run->next_ = NULL;
  1096. // Remove it from list of drawables
  1097. run->detach();
  1099. // delete edges of the nodes_
  1100. for (edge = run->links(); edge != 0; edge = edge->next_) {
  1101. removeLink(edge);
  1102. }
  1104. // delete agents on the nodes_
  1105. for (agent = run->agents(); agent != 0; agent = agent->next_) {
  1106. removeAgent(agent);
  1107. }
  1109. delete run;
  1110. }
  1112. //----------------------------------------------------------------------
  1113. // void
  1114. // EditorNetModel::removeLink(Edge *e)
  1115. // 
  1116. //----------------------------------------------------------------------
  1117. void
  1118. EditorNetModel::removeLink(Edge *e) {
  1119. EdgeHashNode * h, * g;
  1120. Edge * e1, * e2;
  1121.      LossModel * lossmodel;
  1122. int src = e->src();
  1123. int dst = e->dst();
  1125. h = lookupEdgeHashNode(src, dst);
  1126. g = lookupEdgeHashNode(dst, src);
  1128. if (h == 0 || g == 0) {
  1129. // h,g = 0 or h,g !=0
  1130. return;
  1131. } 
  1133. e1 = h->edge;
  1134. e2 = g->edge;
  1136.      lossmodel = e1->getLossModel();
  1137.      if (lossmodel) {
  1138.        removeLossModel(lossmodel);
  1139.      }
  1140.  
  1141.      lossmodel = e2->getLossModel();
  1142.      if (lossmodel) {
  1143.        removeLossModel(lossmodel);
  1144.      }
  1145.      
  1146. // defined in netmodel.cc
  1147. removeEdge(e1);
  1148. removeEdge(e2);
  1149.  
  1150. e1->detach();
  1151. e2->detach();
  1152.  
  1153. Node* srcnode = e1->start();
  1154. Node* dstnode = e2->start();
  1156. // it is a duplex by default
  1157. srcnode->delete_link(e1);
  1158. dstnode->delete_link(e2); 
  1160. delete e1;
  1161. delete e2;
  1162. }
  1164. //----------------------------------------------------------------------
  1165. // void 
  1166. // EditorNetModel::removeAgent(Agent *a)
  1167. //  - removes and deletes an Agent and all of its Traffic Sources
  1168. //----------------------------------------------------------------------
  1169. void 
  1170. EditorNetModel::removeAgent(Agent *a) {
  1171. Node * n;
  1172. TrafficSource * ts, * next_ts;
  1173. n = a->node_;
  1175. if (a->AgentPartner_ != NULL) {
  1176. a->AgentPartner_->AgentPartner_ = NULL;
  1177. a->AgentPartner_->AgentRole_ = 0;
  1178. }
  1179. n->delete_agent(a);
  1180. a->detach();
  1182. for (ts = a->traffic_sources_; ts; ts = next_ts) {
  1183. // Save next traffic source in list since this
  1184. // traffic source will be deleted in removeTrafficSource
  1185. next_ts = ts->next_;
  1186. removeTrafficSource(ts);
  1187. }
  1189. delete a;
  1190. }
  1193. //----------------------------------------------------------------------
  1194. // void 
  1195. // EditorNetModel::removeTrafficSource(TrafficSource * ts) {
  1196. //----------------------------------------------------------------------
  1197. void 
  1198. EditorNetModel::removeTrafficSource(TrafficSource * ts) {
  1199. TrafficSource * run, * previous;
  1201. // Run down the list of traffic sources
  1202. previous = NULL;
  1203. for (run = traffic_sources_; run; run = run->editornetmodel_next_) {
  1204. if (run == ts) {
  1205. break;
  1206. }
  1207. previous = run;
  1208. }
  1210. if (previous) {
  1211. previous->editornetmodel_next_ = ts->editornetmodel_next_;
  1212. } else {
  1213. if (run == traffic_sources_) {
  1214. // ts is at the front of the list
  1215. traffic_sources_ = ts->editornetmodel_next_;
  1216. }
  1217. }
  1218. ts->editornetmodel_next_ = NULL;
  1220. ts->removeFromAgent();
  1222. delete ts; 
  1223. }
  1225. //----------------------------------------------------------------------
  1226. //----------------------------------------------------------------------
  1227. void 
  1228. EditorNetModel::removeLossModel(LossModel * lossmodel) {
  1229. LossModel * run, * previous;
  1231. // Run down the list of lossmodels
  1232. previous = NULL;
  1233. for (run = lossmodels_; run; run = run->next_lossmodel_) {
  1234. if (run == lossmodel) {
  1235. break;
  1236. }
  1237. previous = run;
  1238. }
  1240. if (previous) {
  1241. previous->next_lossmodel_ = lossmodel->next_lossmodel_;
  1242. } else {
  1243. if (run == lossmodels_) {
  1244. // ts is at the front of the list
  1245. lossmodels_ = lossmodel->next_lossmodel_;
  1246. }
  1247. }
  1248. lossmodel->next_lossmodel_ = NULL;
  1250. lossmodel->clearEdge();
  1252. delete lossmodel;
  1253. }