Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
8d5c3ab7fd77907511473ce714be2bb79cd019e8
[simgrid.git] / src / surf / gtnets / gtnets_simulator.cc
1 /*      $Id$     */
2 /* Copyright (c) 2007 Kayo Fujiwara. All rights reserved.                  */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #include "gtnets_simulator.h"
8 #include "gtnets_topology.h"
9 #include <map>
10 #include <vector>
11
12 using namespace std;
13
14 static vector<void*> meta_flows;
15 static int* meta_nflow;
16 static int meta_flg = 0;
17
18
19 void static tcp_sent_callback(void* action, double completion_time);
20
21 // Constructor.
22 // TODO: check the default values.
23 GTSim::GTSim(){
24   int wsize = 20000;
25   is_topology_ = 0;
26   nflow_ = 0;
27   sim_ = new Simulator();
28   topo_ = new GTNETS_Topology();
29
30   sim_->verbose=false;
31   // Set default values.
32   TCP::DefaultAdvWin(wsize);
33   TCP::DefaultSegSize(1000);
34   TCP::DefaultTxBuffer(128000);
35   TCP::DefaultRxBuffer(128000);
36
37   // Manual routing
38   rm_ = new RoutingManual();
39   Routing::SetRouting(rm_);
40 }
41
42 GTSim::~GTSim(){
43
44   map<int, Linkp2p*>::iterator it;
45   for (it = gtnets_links_.begin(); it != gtnets_links_.end(); it++){
46     delete it->second;
47   }
48   while (!gtnets_links_.empty())
49     gtnets_links_.erase(gtnets_links_.begin());
50
51   map<int, Node*>::iterator it3;
52   for (it3 = gtnets_nodes_.begin(); it3 != gtnets_nodes_.end(); it3++){
53     delete it3->second;
54   }
55   while (!gtnets_nodes_.empty())
56     gtnets_nodes_.erase(gtnets_nodes_.begin());
57
58   map<int, TCPServer*>::iterator it4;
59   for (it4 = gtnets_servers_.begin(); it4 != gtnets_servers_.end(); it4++){
60     delete it4->second;
61   }
62   while (!gtnets_servers_.empty())
63     gtnets_servers_.erase(gtnets_servers_.begin());
64
65   map<int, TCPSend*>::iterator it5;
66   for (it5 = gtnets_clients_.begin(); it5 != gtnets_clients_.end(); it5++){
67     delete it5->second;
68   }
69   while (!gtnets_clients_.empty())
70     gtnets_clients_.erase(gtnets_clients_.begin());
71
72   is_topology_ = 0;
73   delete sim_;
74   delete topo_;
75   delete rm_;
76   sim_ = 0;
77   topo_ = 0;
78   rm_ = 0;
79 }
80
81 int GTSim::add_router(int id){
82   if (topo_->add_router(id) < 0){
83     fprintf(stderr, "can't add router %d. already exists.\n", id);
84     return -1;
85   }
86 }
87
88 //bandwidth: in bytes.
89 //latency: in seconds.
90 int GTSim::add_link(int id, double bandwidth, double latency){
91   double bw = bandwidth * 8; //Bandwidth in bits (used in GTNETS).
92   if (topo_->add_link(id) < 0){
93     fprintf(stderr, "can't add link %d. already exists.\n", id);
94     return -1;
95   }
96   gtnets_links_[id] = new Linkp2p(bw, latency);
97   return 0;
98 }
99
100 // if gtnets_nodes_ includes id, return true, otherwise return false.
101 bool GTSim::node_include(int id){
102   if (gtnets_nodes_.find(id) != gtnets_nodes_.end()) return true;
103   else return false;
104 }
105
106 // if gtnets_link_ includes id, return true, otherwise return false.
107 bool GTSim::link_include(int id){
108   if (gtnets_links_.find(id) != gtnets_links_.end()) return true;
109   else return false;
110 }
111
112 int GTSim::add_onehop_route(int src, int dst, int link){
113   if (topo_->add_onehop_route(src, dst, link) < 0){
114     fprintf(stderr, "Cannot add a route, src: %d, dst: %d, link: %d\n",
115             src, dst, link);
116     return -1;
117   }
118   return 0;
119 }
120
121 // Generate the gtnets nodes according to topo_.
122 void GTSim::add_nodes(){
123   static unsigned int address = IPAddr("192.168.0.1");
124   vector<GTNETS_Node*> nodes = topo_->nodes();
125   vector<GTNETS_Node*>::iterator it;
126   int id;
127   for (it = nodes.begin(); it != nodes.end(); it++){
128     id = (*it)->id();
129     gtnets_nodes_[id] = new Node();
130     gtnets_nodes_[id]->SetIPAddr(address++);
131     //    printf("In GTSim, add_node: %d\n", id);
132   }
133 }
134
135 void GTSim::node_connect(){
136
137   map<int, GTNETS_Link*> links = topo_->links();
138   map<int, GTNETS_Link*>::iterator it;
139   int linkid, srcid, dstid;
140   for (it = links.begin(); it != links.end(); it++){
141     linkid = it->second->id();
142     //if link is used in a route, connect the two nodes.
143     if (it->second->src_node() && it->second->dst_node()){
144
145       srcid = it->second->src_node()->id();
146       dstid = it->second->dst_node()->id();
147
148       gtnets_nodes_[srcid]->
149         AddDuplexLink(gtnets_nodes_[dstid], *(gtnets_links_[linkid]));
150     }
151   }
152 }
153
154 // Create nodes and routes from the temporary topology, GTNETS_Topolgy.
155 void GTSim::create_gtnets_topology(){
156   add_nodes();
157   node_connect();
158 }
159
160 // Add a route that includes more than one hop. All one hop
161 // routes must have been added. When this function is called
162 // for the first time, all gtnets nodes are generated.
163 int GTSim::add_route(int src, int dst, int* links, int nlink){
164   if (is_topology_ == 0){
165     create_gtnets_topology();
166     is_topology_ = 1;
167   }  
168
169   IPAddr_t mymask = IPAddr("255.255.255.255");
170
171   int src_node = topo_->nodeid_from_hostid(src);
172   int dst_node = topo_->nodeid_from_hostid(dst);
173
174   if (gtnets_nodes_.find(src_node) == gtnets_nodes_.end()){
175     fprintf(stderr, "node %d not found\n", src_node);
176     return -1;
177   }
178   if (gtnets_nodes_.find(dst_node) == gtnets_nodes_.end()){
179     fprintf(stderr, "node %d not found\n", dst_node);
180     return -1;
181   }
182
183   Node* tmpsrc = gtnets_nodes_[src_node];
184   Node* tmpdst = gtnets_nodes_[dst_node];
185
186   int next_node, cur_node;
187   
188   cur_node = src_node;
189   for (int i = 0; i < nlink; i++){
190     if (gtnets_nodes_.find(cur_node) == gtnets_nodes_.end()){
191       fprintf(stderr, "node %d not found\n", cur_node);
192       return -1;
193     }
194     next_node = topo_->peer_node_id(links[i], cur_node);
195     if (next_node < 0){
196       fprintf(stderr, "peer node not found\n");
197       return -1;
198     }
199     if (gtnets_nodes_.find(next_node) == gtnets_nodes_.end()){
200       fprintf(stderr, "node %d not found\n", next_node);
201       return -1;
202     }
203     
204     //add route
205     Node* tmpcur = gtnets_nodes_[cur_node];
206     Node* tmpnext = gtnets_nodes_[next_node];
207
208     tmpcur->AddRoute(tmpdst->GetIPAddr(),
209                      mymask,
210                      tmpcur->GetIfByNode(tmpnext),
211                      tmpnext->GetIPAddr());
212
213     tmpnext->AddRoute(tmpsrc->GetIPAddr(),
214                       mymask,
215                       tmpnext->GetIfByNode(tmpcur),
216                       tmpcur->GetIPAddr());
217     
218     cur_node = next_node;
219   }
220
221   if (cur_node != dst_node){
222     fprintf(stderr, "Route inconsistency, last: %d, dst: %d\n",
223             cur_node, dst_node);
224     return -1;
225   }
226
227   return 0;
228 }
229
230
231
232 int GTSim::create_flow(int src, int dst, long datasize, void* metadata){
233   //if no route with more than one links, topology has not been generated.
234   //generate it here.
235   if (is_topology_ == 0){
236     create_gtnets_topology();
237     is_topology_ = 1;
238   }
239
240   int src_node = topo_->nodeid_from_hostid(src);
241   if (src_node < 0){
242     fprintf(stderr, "src %d not found\n");
243     return -1;
244   }
245   int dst_node = topo_->nodeid_from_hostid(dst);
246   if (dst_node < 0){
247     fprintf(stderr, "dst %d not found\n");
248     return -1;
249   }
250
251   gtnets_servers_[nflow_] = (TCPServer*) gtnets_nodes_[dst_node]->
252        AddApplication(TCPServer(TCPReno()));
253   gtnets_servers_[nflow_]->BindAndListen(80);
254
255   gtnets_clients_[nflow_] = (TCPSend*)gtnets_nodes_[src_node]->
256     AddApplication(TCPSend(metadata, gtnets_nodes_[dst_node]->GetIPAddr(), 
257                            80, Constant(datasize), TCPReno()));
258   gtnets_clients_[nflow_]->SetSendCallBack(tcp_sent_callback);
259   gtnets_clients_[nflow_]->Start(0);
260
261   gtnets_action_to_flow_[metadata] = nflow_;
262   nflow_++;
263
264   return 0;
265 }
266
267 Time_t GTSim::get_time_to_next_flow_completion(){
268   int status;
269   Time_t t1;
270   int pfds[2];
271   int soon_pid=-1;
272   meta_flg=0;
273
274   //remain needs to be updated in the future
275   Count_t remain;
276   
277   pipe(pfds);
278   
279   t1 = 0;
280
281   if ( (soon_pid=fork()) != 0){
282     read(pfds[0], &t1, sizeof(Time_t));
283     waitpid(soon_pid, &status, 0);      
284   }else{
285     Time_t t;
286     t = sim_->RunUntilNextCompletion();
287     write(pfds[1], (const void*)&t, sizeof(Time_t));
288     exit(0);
289   }
290
291   return t1;
292 }
293
294 double GTSim::gtnets_get_flow_rx(void *metadata){
295   int flow_id = gtnets_action_to_flow_[metadata];
296   return gtnets_servers_[flow_id]->totRx; 
297 }
298
299 int GTSim::run_until_next_flow_completion(void ***metadata, int *number_of_flows){
300
301   meta_flows.clear();
302   meta_nflow = number_of_flows;
303   meta_flg = 1;
304
305   Time_t t1 = sim_->RunUntilNextCompletion();
306
307   *metadata = (meta_flows.empty() ? NULL : &meta_flows[0]);
308   return 0;
309 }
310
311 int GTSim::run(double delta){
312   meta_flg=0;
313   sim_->Run(delta);
314   return 0;
315 }
316
317
318 void static tcp_sent_callback(void* action, double completion_time){
319   // Schedule the flow complete event.
320   SimulatorEvent* e =
321     new SimulatorEvent(SimulatorEvent::FLOW_COMPLETE);
322   Simulator::instance->Schedule(e, 0, Simulator::instance);
323
324   if (meta_flg){
325     meta_flows.push_back(action);
326     (*meta_nflow)++;
327   }
328 }
329
330