Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
da12ba5a04a51af485ac279f65513d3a4149fc5e
[simgrid.git] / src / bindings / lua / lua_console.c
1 /* SimGrid Lua Console                                                    */
2
3 /* Copyright (c) 2010. The SimGrid Team.
4  * All rights reserved.                                                     */
5
6 /* This program is free software; you can redistribute it and/or modify it
7  * under the terms of the license (GNU LGPL) which comes with this package. */
8
9 #include "simgrid_lua.h"
10 #include <string.h>
11 #include <ctype.h>
12
13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua_console, bindings, "Lua Bindings");
14
15 static p_AS_attr AS;
16 //using xbt_dynar_t :
17 static xbt_dynar_t host_list_d;
18 static xbt_dynar_t link_list_d;
19 static xbt_dynar_t route_list_d;
20
21 /*
22  * Initialize platform model routing
23  */
24
25 static void create_AS(const char *id, const char *mode)
26 {
27   surf_AS_new(id, mode);
28 }
29
30 /**
31  * create host resource via CPU model [for MSG]
32  */
33
34 static void create_host(const char *id, double power_peak, double power_sc,
35                         const char *power_tr,int core,int state_init,
36                         const char *state_tr)
37 {
38
39   double power_scale = 1.0;
40   int core_nb = 1; //default value
41   tmgr_trace_t power_trace = NULL;
42   e_surf_resource_state_t state_initial;
43   tmgr_trace_t state_trace;
44   if (power_sc)                 // !=0
45     power_scale = power_sc;
46   if (core)
47           core_nb = core; //default value
48   else
49   if (state_init == -1)
50     state_initial = SURF_RESOURCE_OFF;
51   else
52     state_initial = SURF_RESOURCE_ON;
53   if (power_tr)
54     power_trace = tmgr_trace_new(power_tr);
55   else
56     power_trace = tmgr_trace_new("");
57   if (state_tr)
58     state_trace = tmgr_trace_new(state_tr);
59   else
60     state_trace = tmgr_trace_new("");
61   current_property_set = xbt_dict_new();
62   surf_host_create_resource(xbt_strdup(id), power_peak, power_scale,
63                             power_trace, core_nb, state_initial, state_trace,
64                             current_property_set);
65
66 }
67
68 /**
69  * create link resource via network model
70  */
71 static void create_link(const char *name,
72                         double bw_initial, const char *trace,
73                         double lat_initial, const char *latency_trace,
74                         int state_init, const char *state_trace,
75                         int policy)
76 {
77   tmgr_trace_t bw_trace;
78   tmgr_trace_t lat_trace;
79   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
80   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
81   tmgr_trace_t st_trace;
82   if (trace)
83     bw_trace = tmgr_trace_new(trace);
84   else
85     bw_trace = tmgr_trace_new("");
86
87   if (latency_trace)
88     lat_trace = tmgr_trace_new(latency_trace);
89   else
90     lat_trace = tmgr_trace_new("");
91
92   if (state_trace)
93     st_trace = tmgr_trace_new(state_trace);
94   else
95     st_trace = tmgr_trace_new("");
96
97   if (state_init == -1)
98     state_initial_link = SURF_RESOURCE_OFF;
99   if (policy == -1)
100     policy_initial_link = SURF_LINK_FATPIPE;
101
102   surf_link_create_resource(xbt_strdup(name), bw_initial, bw_trace,
103                             lat_initial, lat_trace, state_initial_link,
104                             st_trace, policy_initial_link, xbt_dict_new());
105 }
106
107
108 /*
109  *create host resource via workstation_ptask_L07 model [for SimDag]
110  */
111 static void create_host_wsL07(const char *id, double power_peak,
112                               double power_sc, const char *power_tr,
113                               int state_init, const char *state_tr)
114 {
115   double power_scale = 1.0;
116   tmgr_trace_t power_trace = NULL;
117   e_surf_resource_state_t state_initial;
118   tmgr_trace_t state_trace;
119   if (power_sc)                 // !=0
120     power_scale = power_sc;
121   if (state_init == -1)
122     state_initial = SURF_RESOURCE_OFF;
123   else
124     state_initial = SURF_RESOURCE_ON;
125   if (power_tr)
126     power_trace = tmgr_trace_new(power_tr);
127   else
128     power_trace = tmgr_trace_new("");
129   if (state_tr)
130     state_trace = tmgr_trace_new(state_tr);
131   else
132     state_trace = tmgr_trace_new("");
133   current_property_set = xbt_dict_new();
134   surf_wsL07_host_create_resource(xbt_strdup(id), power_peak, power_scale,
135                                   power_trace, state_initial, state_trace,
136                                   current_property_set);
137
138 }
139
140 /**
141  * create link resource via workstation_ptask_L07 model [for SimDag]
142  */
143
144 static void create_link_wsL07(const char *name,
145                               double bw_initial, const char *trace,
146                               double lat_initial,
147                               const char *latency_trace, int state_init,
148                               const char *state_trace, int policy)
149 {
150   tmgr_trace_t bw_trace;
151   tmgr_trace_t lat_trace;
152   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
153   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
154   tmgr_trace_t st_trace;
155   if (trace)
156     bw_trace = tmgr_trace_new(trace);
157   else
158     bw_trace = tmgr_trace_new("");
159
160   if (latency_trace)
161     lat_trace = tmgr_trace_new(latency_trace);
162   else
163     lat_trace = tmgr_trace_new("");
164
165   if (state_trace)
166     st_trace = tmgr_trace_new(state_trace);
167   else
168     st_trace = tmgr_trace_new("");
169
170   if (state_init == -1)
171     state_initial_link = SURF_RESOURCE_OFF;
172   if (policy == -1)
173     policy_initial_link = SURF_LINK_FATPIPE;
174
175   surf_wsL07_link_create_resource(xbt_strdup(name), bw_initial, bw_trace,
176                                   lat_initial, lat_trace,
177                                   state_initial_link, st_trace,
178                                   policy_initial_link, xbt_dict_new());
179 }
180
181
182 /*
183  * init AS
184  */
185
186 static int AS_new(lua_State * L)
187 {
188   const char *id;
189   const char *mode;
190   if (lua_istable(L, 1)) {
191     lua_pushstring(L, "id");
192     lua_gettable(L, -2);
193     id = lua_tostring(L, -1);
194     lua_pop(L, 1);
195
196     lua_pushstring(L, "mode");
197     lua_gettable(L, -2);
198     mode = lua_tostring(L, -1);
199     lua_pop(L, 1);
200   } else {
201     XBT_ERROR
202         ("Bad Arguments to AS.new, Should be a table with named arguments");
203     return -1;
204   }
205   AS = malloc(sizeof(AS_attr));
206   AS->id = id;
207   AS->mode = mode;
208
209   return 0;
210 }
211
212 /*
213  * add new host to platform hosts list
214  */
215 static int Host_new(lua_State * L)
216 {
217
218   if (xbt_dynar_is_empty(host_list_d))
219     host_list_d = xbt_dynar_new(sizeof(p_host_attr), &xbt_free_ref);
220
221   p_host_attr host;
222   const char *id;
223   const char *power_trace;
224   const char *state_trace;
225   double power, power_scale;
226   int state_initial,core;
227   //get values from the table passed as argument
228   if (lua_istable(L, -1)) {
229
230     // get Id Value
231     lua_pushstring(L, "id");
232     lua_gettable(L, -2);
233     id = lua_tostring(L, -1);
234     lua_pop(L, 1);
235
236     // get power value
237     lua_pushstring(L, "power");
238     lua_gettable(L, -2);
239     power = lua_tonumber(L, -1);
240     lua_pop(L, 1);
241
242     //get power_scale
243     lua_pushstring(L, "power_scale");
244     lua_gettable(L, -2);
245     power_scale = lua_tonumber(L, -1);
246     lua_pop(L, 1);
247
248     //get power_trace
249     lua_pushstring(L, "power_trace");
250     lua_gettable(L, -2);
251     power_trace = lua_tostring(L, -1);
252     lua_pop(L, 1);
253
254     lua_pushstring(L, "core");
255     lua_gettable(L, -2);
256     core = lua_tonumber(L, -1);
257     lua_pop(L, 1);
258
259     //get state initial
260     lua_pushstring(L, "state_initial");
261     lua_gettable(L, -2);
262     state_initial = lua_tonumber(L, -1);
263     lua_pop(L, 1);
264
265     //get trace state
266     lua_pushstring(L, "state_trace");
267     lua_gettable(L, -2);
268     state_trace = lua_tostring(L, -1);
269     lua_pop(L, 1);
270
271   } else {
272     XBT_ERROR
273         ("Bad Arguments to create host, Should be a table with named arguments");
274     return -1;
275   }
276
277   host = malloc(sizeof(host_attr));
278   host->id = id;
279   host->power_peak = power;
280   host->power_scale = power_scale;
281   host->power_trace = power_trace;
282   host->core = core;
283   host->state_initial = state_initial;
284   host->state_trace = state_trace;
285   host->function = NULL;
286   xbt_dynar_push(host_list_d, &host);
287
288   return 0;
289 }
290
291 /**
292  * add link to platform links list
293  */
294 static int Link_new(lua_State * L)      // (id,bandwidth,latency)
295 {
296
297   if (xbt_dynar_is_empty(link_list_d))
298     link_list_d = xbt_dynar_new(sizeof(p_link_attr), &xbt_free_ref);
299
300
301   const char* id;
302   double bandwidth, latency;
303   const char *bandwidth_trace;
304   const char *latency_trace;
305   const char *state_trace;
306   int state_initial, policy;
307
308   //get values from the table passed as argument
309   if (lua_istable(L, -1)) {
310     // get Id Value
311     lua_pushstring(L, "id");
312     lua_gettable(L, -2);
313     id = lua_tostring(L, -1);
314     lua_pop(L, 1);
315
316     // get bandwidth value
317     lua_pushstring(L, "bandwidth");
318     lua_gettable(L, -2);
319     bandwidth = lua_tonumber(L, -1);
320     lua_pop(L, 1);
321
322     //get latency value
323     lua_pushstring(L, "latency");
324     lua_gettable(L, -2);
325     latency = lua_tonumber(L, -1);
326     lua_pop(L, 1);
327
328     /*Optional Arguments  */
329
330     //get bandwidth_trace value
331     lua_pushstring(L, "bandwidth_trace");
332     lua_gettable(L, -2);
333     bandwidth_trace = lua_tostring(L, -1);
334     lua_pop(L, 1);
335
336     //get latency_trace value
337     lua_pushstring(L, "latency_trace");
338     lua_gettable(L, -2);
339     latency_trace = lua_tostring(L, -1);
340     lua_pop(L, 1);
341
342     //get state_trace value
343     lua_pushstring(L, "state_trace");
344     lua_gettable(L, -2);
345     state_trace = lua_tostring(L, -1);
346     lua_pop(L, 1);
347
348     //get state_initial value
349     lua_pushstring(L, "state_initial");
350     lua_gettable(L, -2);
351     state_initial = lua_tonumber(L, -1);
352     lua_pop(L, 1);
353
354     //get policy value
355     lua_pushstring(L, "policy");
356     lua_gettable(L, -2);
357     policy = lua_tonumber(L, -1);
358     lua_pop(L, 1);
359
360   } else {
361     XBT_ERROR
362         ("Bad Arguments to create link, Should be a table with named arguments");
363     return -1;
364   }
365
366   p_link_attr link = malloc(sizeof(link_attr));
367   link->id = id;
368   link->bandwidth = bandwidth;
369   link->latency = latency;
370   link->bandwidth_trace = bandwidth_trace;
371   link->latency_trace = latency_trace;
372   link->state_trace = state_trace;
373   link->state_initial = state_initial;
374   link->policy = policy;
375   xbt_dynar_push(link_list_d, &link);
376
377   return 0;
378 }
379
380 /**
381  * add route to platform routes list
382  */
383 static int Route_new(lua_State * L)     // (src_id,dest_id,links_number,link_table)
384 {
385  if (xbt_dynar_is_empty(route_list_d))
386             route_list_d = xbt_dynar_new(sizeof(p_route_attr), &xbt_free_ref);
387
388          const char *links;
389          const char* link_id;
390          p_route_attr route = malloc(sizeof(route_attr));
391
392
393   if (!lua_istable(L, 3)) { // if Route.new is declared as an indexed table (FIXME : we check the third arg if it's not a table)
394      // get Source Value
395      lua_pushstring(L, "src");
396      lua_gettable(L, -2);
397      route->src_id = lua_tostring(L, -1);
398      lua_pop(L, 1);
399
400      // get Destination Value
401      lua_pushstring(L, "dest");
402      lua_gettable(L, -2);
403      route->dest_id = lua_tostring(L, -1);
404      lua_pop(L, 1);
405
406      // get Links Table (char* to be splited later)
407      lua_pushstring(L, "links");
408      lua_gettable(L, -2);
409      links = lua_tostring(L, -1);
410      lua_pop(L,1);
411
412      route->links_id = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
413
414      char *tmp_links = xbt_strdup(links);
415      link_id = strtok(tmp_links,",");   //tmp_link = strtok((char*)links,",");
416      while(link_id != NULL)
417        {
418           xbt_dynar_push(route->links_id, &link_id);
419           link_id = strtok(NULL,","); //Alternativelly, a null pointer may be specified, in which case the function continues scanning where a previous successful call to the function ended.
420         }
421      xbt_dynar_push(route_list_d, &route);
422      return 0;
423
424       }
425   else { // Route.new is declared as a function
426      //const char* link_id;
427      route->src_id = luaL_checkstring(L, 1);
428      route->dest_id = luaL_checkstring(L, 2);
429      route->links_id = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
430      lua_pushnil(L);
431      while (lua_next(L, 3) != 0)
432                 {
433          link_id = lua_tostring(L, -1);
434          xbt_dynar_push(route->links_id, &link_id);
435          XBT_DEBUG("index = %f , Link_id = %s \n", lua_tonumber(L, -2),
436          lua_tostring(L, -1));
437          lua_pop(L, 1);
438         }
439          lua_pop(L, 1);
440           //add route to platform's route list
441           xbt_dynar_push(route_list_d, &route);
442           return 0;
443     }
444
445   return -1;
446 }
447 /**
448  * set function to process
449  */
450 static int Host_set_function(lua_State * L)     //(host,function,nb_args,list_args)
451 {
452         p_host_attr p_host;
453         const char *host;
454         const char *function;
455         const char *args;
456         char * tmp_arg;
457         unsigned int i;
458
459    if (lua_istable(L, -1)) {
460          // get Host id
461          lua_pushstring(L, "host");
462          lua_gettable(L, -2);
463          host = lua_tostring(L, -1);
464          lua_pop(L, 1);
465          // get Function Name
466          lua_pushstring(L, "fct");
467          lua_gettable(L, -2);
468      function = lua_tostring(L, -1);
469      lua_pop(L, 1);
470      //get args
471      lua_pushstring(L,"args");
472      lua_gettable(L, -2);
473      args = lua_tostring(L,-1);
474      lua_pop(L, 1);
475    }
476    else {
477            XBT_ERROR("Bad Arguments to create link, Should be a table with named arguments");
478            return -1;
479    }
480
481   // look for the index of host in host_list
482   xbt_dynar_foreach(host_list_d, i, p_host) {
483           if (p_host->id == host) {
484       p_host->function = function;
485       p_host->args_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
486       // split & fill the args list
487       tmp_arg = strtok((char*)args,",");
488       while (tmp_arg != NULL) {
489           xbt_dynar_push(p_host->args_list, &tmp_arg);
490           tmp_arg = strtok(NULL,",");
491         }
492       return 0;
493            }
494       }
495           XBT_ERROR("Host : %s Not Found !!", host);
496           return 1;
497
498 }
499 /*
500  * surf parse bypass platform
501  * through CPU/network Models
502  */
503
504 static int surf_parse_bypass_platform()
505 {
506   unsigned int i;
507   p_host_attr p_host;
508   p_link_attr p_link;
509   p_route_attr p_route;
510
511   // Init routing mode
512   create_AS(AS->id, AS->mode);
513
514   // Add Hosts
515   xbt_dynar_foreach(host_list_d, i, p_host) {
516     create_host(p_host->id, p_host->power_peak, p_host->power_scale,
517                 p_host->power_trace, p_host->core, p_host->state_initial,
518                 p_host->state_trace);
519     //add to routing model host list
520     surf_route_add_host((char *) p_host->id);
521
522   }
523
524   //add Links
525   xbt_dynar_foreach(link_list_d, i, p_link) {
526     create_link(p_link->id, p_link->bandwidth, p_link->bandwidth_trace,
527                 p_link->latency, p_link->latency_trace,
528                 p_link->state_initial, p_link->state_trace,
529                 p_link->policy);
530   }
531   // add route
532   xbt_dynar_foreach(route_list_d, i, p_route) {
533     surf_routing_add_route((char *) p_route->src_id,
534                            (char *) p_route->dest_id, p_route->links_id);
535   }
536   /* </platform> */
537
538   // Finalize AS
539   surf_AS_finalize(AS->id);
540
541   // add traces
542   surf_add_host_traces();
543   surf_add_link_traces();
544
545   return 0;                     // must return 0 ?!!
546
547 }
548
549 /**
550  *
551  * surf parse bypass platform
552  * through workstation_ptask_L07 Model
553  */
554
555 static int surf_wsL07_parse_bypass_platform()
556 {
557
558   unsigned int i;
559   p_host_attr p_host;
560   p_link_attr p_link;
561   p_route_attr p_route;
562
563   // Init routing mode
564   create_AS(AS->id, AS->mode);
565
566   // Add Hosts
567   xbt_dynar_foreach(host_list_d, i, p_host) {
568     create_host_wsL07(p_host->id, p_host->power_peak, p_host->power_scale,
569                       p_host->power_trace, p_host->state_initial,
570                       p_host->state_trace);
571     //add to routing model host list
572     surf_route_add_host((char *) p_host->id);
573   }
574
575   //add Links
576   xbt_dynar_foreach(link_list_d, i, p_link) {
577     create_link_wsL07(p_link->id, p_link->bandwidth,
578                       p_link->bandwidth_trace, p_link->latency,
579                       p_link->latency_trace, p_link->state_initial,
580                       p_link->state_trace, p_link->policy);
581   }
582   // add route
583   xbt_dynar_foreach(route_list_d, i, p_route) {
584     surf_routing_add_route((char *) p_route->src_id,
585                            (char *) p_route->dest_id, p_route->links_id);
586   }
587   /* </platform> */
588
589   // Finalize AS
590   surf_AS_finalize(AS->id);
591   // add traces
592   surf_wsL07_add_traces();
593
594   return 0;
595 }
596
597 /*
598  * surf parse bypass application for MSG Module
599  */
600 static int surf_parse_bypass_application()
601 {
602   unsigned int i;
603   p_host_attr p_host;
604   xbt_dynar_foreach(host_list_d, i, p_host) {
605     if (p_host->function)
606       MSG_set_function(p_host->id, p_host->function, p_host->args_list);
607   }
608   return 0;
609 }
610
611 /*
612  * Public Methods
613  */
614
615 int console_add_host(lua_State *L)
616 {
617         return Host_new(L);
618 }
619
620 int  console_add_link(lua_State *L)
621 {
622         return Link_new(L);
623 }
624
625 int console_add_route(lua_State *L)
626 {
627         return Route_new(L);
628 }
629
630 int console_add_AS(lua_State *L)
631 {
632         return AS_new(L);
633 }
634
635 int console_set_function(lua_State *L)
636 {
637         return Host_set_function(L);
638 }
639
640 int console_parse_platform()
641 {
642         return surf_parse_bypass_platform();
643 }
644
645 int  console_parse_application()
646 {
647         return surf_parse_bypass_application();
648 }
649
650 int console_parse_platform_wsL07()
651 {
652         return surf_wsL07_parse_bypass_platform();
653 }