Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
one more buf fix to simdag prop
[simgrid.git] / examples / simdag / properties / sd_prop.c
1 /*      $Id$     */
2
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include "simdag/simdag.h"
6 #include "xbt/ex.h"
7 #include "xbt/log.h"
8 #include "xbt/dynar.h"
9 #include "xbt/dict.h"
10
11 XBT_LOG_NEW_DEFAULT_CATEGORY(test,
12                              "Property test");
13
14 int main(int argc, char **argv) {
15   int i;
16
17   /* initialisation of SD */
18   SD_init(&argc, argv);
19
20   /*  xbt_log_control_set("sd.thres=debug"); */
21
22   if (argc < 2) {
23     INFO1("Usage: %s platform_file", argv[0]);
24     INFO1("example: %s sd_platform.xml", argv[0]);
25     exit(1);
26   }
27
28   /* creation of the environment */
29   const char * platform_file = argv[1];
30   SD_create_environment(platform_file);
31
32   /* test the estimation functions */
33   const SD_workstation_t *workstations = SD_workstation_get_list();
34   SD_workstation_t w1 = workstations[0];
35   SD_workstation_t w2 = workstations[1];
36   SD_workstation_set_access_mode(w2, SD_WORKSTATION_SEQUENTIAL_ACCESS);
37   const char *name1 = SD_workstation_get_name(w1);
38   const char *name2 = SD_workstation_get_name(w2);
39
40   /* The host properties can be retrived from all interfaces */
41   xbt_dict_t props;
42   INFO1("Property list for workstation %s", name1);
43   /* Get the property list of the workstation 1 */
44   props = SD_workstation_get_properties(w1);
45   xbt_dict_cursor_t cursor = NULL;
46   char *key,*data;
47
48     /* Trying to set a new property */
49   xbt_dict_set(props, xbt_strdup("NewProp"), strdup("newValue"), free);
50
51   /* Print the properties of the workstation 1 */
52   xbt_dict_foreach(props,cursor,key,data) {
53     INFO2("\tProperty: %s has value: %s",key,data);
54   }
55  
56   /* Try to get a property that does not exist */
57   char noexist[]="NoProp";
58   const char *value = SD_workstation_get_property_value(w1,noexist);
59   if ( value == NULL) 
60     INFO1("\tProperty: %s is undefined", noexist);
61   else
62     INFO2("\tProperty: %s has value: %s", noexist, value);
63
64
65   INFO1("Property list for workstation %s", name2);
66   /* Get the property list of the workstation 2 */
67   props = SD_workstation_get_properties(w2);
68   cursor = NULL;
69
70   /* Print the properties of the workstation 2 */
71   xbt_dict_foreach(props,cursor,key,data) {
72     INFO2("\tProperty: %s on host: %s",key,data);
73   }
74
75   /* Modify an existing property test. First check it exists */\
76   INFO0("Modify an existing property");
77   char exist[]="Hdd";
78   value = SD_workstation_get_property_value(w2,exist);
79   if ( value == NULL) 
80     INFO1("\tProperty: %s is undefined", exist);
81   else {
82     INFO2("\tProperty: %s old value: %s", exist, value);
83     xbt_dict_set(props, exist, strdup("250"), free);  
84   }
85  
86   /* Test if we have changed the value */
87   value = SD_workstation_get_property_value(w2,exist);
88   if ( value == NULL) 
89     INFO1("\tProperty: %s is undefined", exist);
90   else
91     INFO2("\tProperty: %s new value: %s", exist, value);
92     
93   
94
95   const double computation_amount1 = 2000000;
96   const double computation_amount2 = 1000000;
97   const double communication_amount12 = 2000000;
98   const double communication_amount21 = 3000000;
99
100   /* NOTE: The link properties can be retrieved only from the SimDag interface */
101   const SD_link_t *route = SD_route_get_list(w1, w2);
102   int route_size = SD_route_get_size(w1, w2);
103   for (i = 0; i < route_size; i++) {
104      
105     props = SD_link_get_properties(route[i]);
106     xbt_dict_cursor_t cursor = NULL;
107     char *key,*data;
108
109     /* Print the properties of the current link */
110     xbt_dict_foreach(props,cursor,key,data) {
111     INFO3("\tLink %s property: %s has value: %s",SD_link_get_name(route[i]),key,data);
112
113     /* Try to get a property that does not exist */
114     char noexist1[]="Other";
115     value = SD_link_get_property_value(route[i], noexist1);
116     if ( value == NULL) 
117       INFO2("\tProperty: %s for link %s is undefined", noexist, SD_link_get_name(route[i]));
118     else
119       INFO3("\tLink %s property: %s has value: %s",SD_link_get_name(route[i]),noexist,value);
120   }
121
122   }
123   /* creation of the tasks and their dependencies */
124   SD_task_t taskA = SD_task_create("Task A", NULL, 10.0);
125   SD_task_t taskB = SD_task_create("Task B", NULL, 40.0);
126   SD_task_t taskC = SD_task_create("Task C", NULL, 30.0);
127   SD_task_t taskD = SD_task_create("Task D", NULL, 60.0);
128   
129
130   SD_task_dependency_add(NULL, NULL, taskB, taskA);
131   SD_task_dependency_add(NULL, NULL, taskC, taskA);
132   SD_task_dependency_add(NULL, NULL, taskD, taskB);
133   SD_task_dependency_add(NULL, NULL, taskD, taskC);
134
135   /* watch points */
136   SD_task_watch(taskD, SD_DONE);
137   SD_task_watch(taskB, SD_DONE);
138   SD_task_unwatch(taskD, SD_DONE);
139   
140
141   /* scheduling parameters */
142
143   const int workstation_number = 2;
144   const SD_workstation_t workstation_list[] = {w1, w2};
145   double computation_amount[] = {computation_amount1, computation_amount2};
146   double communication_amount[] =
147     {
148       0, communication_amount12,
149       communication_amount21, 0
150     };
151   double rate = -1.0;
152
153   /* estimated time */
154   SD_task_t task = taskD;
155   INFO2("Estimated time for '%s': %f", SD_task_get_name(task),
156         SD_task_get_execution_time(task, workstation_number, workstation_list,
157                                    computation_amount, communication_amount, rate));
158
159   /* let's launch the simulation! */
160
161   SD_task_schedule(taskA, workstation_number, workstation_list,
162                    computation_amount, communication_amount, rate);
163   SD_task_schedule(taskB, workstation_number, workstation_list,
164                    computation_amount, communication_amount, rate);
165   SD_task_schedule(taskC, workstation_number, workstation_list,
166                    computation_amount, communication_amount, rate);
167   SD_task_schedule(taskD, workstation_number, workstation_list,
168                    computation_amount, communication_amount, rate);
169
170   SD_task_t *changed_tasks;
171
172   changed_tasks = SD_simulate(-1.0);
173   for (i = 0; changed_tasks[i] != NULL; i++) {
174     INFO3("Task '%s' start time: %f, finish time: %f",
175           SD_task_get_name(changed_tasks[i]),
176           SD_task_get_start_time(changed_tasks[i]),
177           SD_task_get_finish_time(changed_tasks[i]));
178   }
179   
180   xbt_assert0(changed_tasks[0] == taskD &&
181               changed_tasks[1] == taskB &&
182               changed_tasks[2] == NULL,
183               "Unexpected simulation results");
184
185   xbt_free(changed_tasks);
186
187   DEBUG0("Destroying tasks...");
188
189   SD_task_destroy(taskA);
190   SD_task_destroy(taskB);
191   SD_task_destroy(taskC);
192   SD_task_destroy(taskD);
193
194   DEBUG0("Tasks destroyed. Exiting SimDag...");
195
196   SD_exit();
197   return 0;
198 }
199