diff options
Diffstat (limited to 'src/ats-tests/gnunet-solver-eval.c')
-rw-r--r-- | src/ats-tests/gnunet-solver-eval.c | 1025 |
1 files changed, 0 insertions, 1025 deletions
diff --git a/src/ats-tests/gnunet-solver-eval.c b/src/ats-tests/gnunet-solver-eval.c deleted file mode 100644 index 7a3461bf7..000000000 --- a/src/ats-tests/gnunet-solver-eval.c +++ /dev/null | |||
@@ -1,1025 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | Copyright (C) 2010-2013 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | /** | ||
21 | * @file ats-tests/ats-testing-experiment.c | ||
22 | * @brief ats benchmark: controlled experiment execution | ||
23 | * @author Christian Grothoff | ||
24 | * @author Matthias Wachs | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_util_lib.h" | ||
28 | #include "gnunet_ats_plugin.h" | ||
29 | #include "gnunet_ats_service.h" | ||
30 | #include "ats-testing.h" | ||
31 | |||
32 | |||
33 | /** | ||
34 | * Experiments | ||
35 | */ | ||
36 | const char * | ||
37 | print_op (enum OperationType op) | ||
38 | { | ||
39 | switch (op) | ||
40 | { | ||
41 | case START_SEND: | ||
42 | return "START_SEND"; | ||
43 | |||
44 | case STOP_SEND: | ||
45 | return "STOP_SEND"; | ||
46 | |||
47 | case START_PREFERENCE: | ||
48 | return "START_PREFERENCE"; | ||
49 | |||
50 | case STOP_PREFERENCE: | ||
51 | return "STOP_PREFERENCE"; | ||
52 | |||
53 | default: | ||
54 | break; | ||
55 | } | ||
56 | return ""; | ||
57 | } | ||
58 | |||
59 | |||
60 | static struct Experiment * | ||
61 | create_experiment () | ||
62 | { | ||
63 | struct Experiment *e; | ||
64 | |||
65 | e = GNUNET_new (struct Experiment); | ||
66 | e->name = NULL; | ||
67 | e->num_masters = 0; | ||
68 | e->num_slaves = 0; | ||
69 | e->start = NULL; | ||
70 | e->total_duration = GNUNET_TIME_UNIT_ZERO; | ||
71 | return e; | ||
72 | } | ||
73 | |||
74 | |||
75 | static void | ||
76 | free_experiment (struct Experiment *e) | ||
77 | { | ||
78 | struct Episode *cur; | ||
79 | struct Episode *next; | ||
80 | struct GNUNET_ATS_TEST_Operation *cur_o; | ||
81 | struct GNUNET_ATS_TEST_Operation *next_o; | ||
82 | |||
83 | next = e->start; | ||
84 | for (cur = next; NULL != cur; cur = next) | ||
85 | { | ||
86 | next = cur->next; | ||
87 | |||
88 | next_o = cur->head; | ||
89 | for (cur_o = next_o; NULL != cur_o; cur_o = next_o) | ||
90 | { | ||
91 | next_o = cur_o->next; | ||
92 | GNUNET_free (cur_o); | ||
93 | } | ||
94 | GNUNET_free (cur); | ||
95 | } | ||
96 | |||
97 | GNUNET_free (e->name); | ||
98 | GNUNET_free (e->cfg_file); | ||
99 | GNUNET_free (e); | ||
100 | } | ||
101 | |||
102 | |||
103 | static int | ||
104 | load_episode (struct Experiment *e, | ||
105 | struct Episode *cur, | ||
106 | struct GNUNET_CONFIGURATION_Handle *cfg) | ||
107 | { | ||
108 | struct GNUNET_ATS_TEST_Operation *o; | ||
109 | char *sec_name; | ||
110 | char *op_name; | ||
111 | char *op; | ||
112 | char *type; | ||
113 | char *pref; | ||
114 | int op_counter = 0; | ||
115 | |||
116 | fprintf (stderr, "Parsing episode %u\n", cur->id); | ||
117 | GNUNET_asprintf (&sec_name, "episode-%u", cur->id); | ||
118 | |||
119 | while (1) | ||
120 | { | ||
121 | /* Load operation */ | ||
122 | GNUNET_asprintf (&op_name, "op-%u-operation", op_counter); | ||
123 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, | ||
124 | sec_name, | ||
125 | op_name, &op)) | ||
126 | { | ||
127 | GNUNET_free (op_name); | ||
128 | break; | ||
129 | } | ||
130 | o = GNUNET_new (struct GNUNET_ATS_TEST_Operation); | ||
131 | /* operations = set_rate, start_send, stop_send, set_preference */ | ||
132 | if (0 == strcmp (op, "start_send")) | ||
133 | { | ||
134 | o->type = START_SEND; | ||
135 | } | ||
136 | else if (0 == strcmp (op, "stop_send")) | ||
137 | { | ||
138 | o->type = STOP_SEND; | ||
139 | } | ||
140 | else if (0 == strcmp (op, "start_preference")) | ||
141 | { | ||
142 | o->type = START_PREFERENCE; | ||
143 | } | ||
144 | else if (0 == strcmp (op, "stop_preference")) | ||
145 | { | ||
146 | o->type = STOP_PREFERENCE; | ||
147 | } | ||
148 | else | ||
149 | { | ||
150 | fprintf (stderr, "Invalid operation %u `%s' in episode %u\n", | ||
151 | op_counter, op, cur->id); | ||
152 | GNUNET_free (op); | ||
153 | GNUNET_free (op_name); | ||
154 | GNUNET_free (sec_name); | ||
155 | GNUNET_free (o); | ||
156 | return GNUNET_SYSERR; | ||
157 | } | ||
158 | GNUNET_free (op_name); | ||
159 | |||
160 | /* Get source */ | ||
161 | GNUNET_asprintf (&op_name, "op-%u-src", op_counter); | ||
162 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, | ||
163 | sec_name, | ||
164 | op_name, | ||
165 | &o->src_id)) | ||
166 | { | ||
167 | fprintf (stderr, "Missing src in operation %u `%s' in episode %u\n", | ||
168 | op_counter, op, cur->id); | ||
169 | GNUNET_free (op); | ||
170 | GNUNET_free (op_name); | ||
171 | GNUNET_free (sec_name); | ||
172 | GNUNET_free (o); | ||
173 | return GNUNET_SYSERR; | ||
174 | } | ||
175 | if (o->src_id > (e->num_masters - 1)) | ||
176 | { | ||
177 | fprintf (stderr, "Invalid src %llu in operation %u `%s' in episode %u\n", | ||
178 | o->src_id, op_counter, op, cur->id); | ||
179 | GNUNET_free (op); | ||
180 | GNUNET_free (op_name); | ||
181 | GNUNET_free (sec_name); | ||
182 | GNUNET_free (o); | ||
183 | return GNUNET_SYSERR; | ||
184 | } | ||
185 | GNUNET_free (op_name); | ||
186 | |||
187 | /* Get destination */ | ||
188 | GNUNET_asprintf (&op_name, "op-%u-dest", op_counter); | ||
189 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, | ||
190 | sec_name, | ||
191 | op_name, | ||
192 | &o->dest_id)) | ||
193 | { | ||
194 | fprintf (stderr, "Missing src in operation %u `%s' in episode %u\n", | ||
195 | op_counter, op, cur->id); | ||
196 | GNUNET_free (op); | ||
197 | GNUNET_free (op_name); | ||
198 | GNUNET_free (sec_name); | ||
199 | GNUNET_free (o); | ||
200 | return GNUNET_SYSERR; | ||
201 | } | ||
202 | if (o->dest_id > (e->num_slaves - 1)) | ||
203 | { | ||
204 | fprintf (stderr, | ||
205 | "Invalid destination %llu in operation %u `%s' in episode %u\n", | ||
206 | o->dest_id, | ||
207 | op_counter, | ||
208 | op, | ||
209 | cur->id); | ||
210 | GNUNET_free (op); | ||
211 | GNUNET_free (op_name); | ||
212 | GNUNET_free (sec_name); | ||
213 | GNUNET_free (o); | ||
214 | return GNUNET_SYSERR; | ||
215 | } | ||
216 | GNUNET_free (op_name); | ||
217 | |||
218 | GNUNET_asprintf (&op_name, "op-%u-type", op_counter); | ||
219 | if ((GNUNET_SYSERR != | ||
220 | GNUNET_CONFIGURATION_get_value_string (cfg, | ||
221 | sec_name, | ||
222 | op_name, | ||
223 | &type)) && | ||
224 | (STOP_SEND != o->type) && | ||
225 | (STOP_PREFERENCE != o->type)) | ||
226 | { | ||
227 | /* Load arguments for set_rate, start_send, set_preference */ | ||
228 | if (0 == strcmp (type, "constant")) | ||
229 | { | ||
230 | o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT; | ||
231 | } | ||
232 | else if (0 == strcmp (type, "linear")) | ||
233 | { | ||
234 | o->gen_type = GNUNET_ATS_TEST_TG_LINEAR; | ||
235 | } | ||
236 | else if (0 == strcmp (type, "sinus")) | ||
237 | { | ||
238 | o->gen_type = GNUNET_ATS_TEST_TG_SINUS; | ||
239 | } | ||
240 | else if (0 == strcmp (type, "random")) | ||
241 | { | ||
242 | o->gen_type = GNUNET_ATS_TEST_TG_RANDOM; | ||
243 | } | ||
244 | else | ||
245 | { | ||
246 | fprintf (stderr, "Invalid type %u `%s' in episode %u\n", | ||
247 | op_counter, op, cur->id); | ||
248 | GNUNET_free (type); | ||
249 | GNUNET_free (op); | ||
250 | GNUNET_free (op_name); | ||
251 | GNUNET_free (sec_name); | ||
252 | GNUNET_free (o); | ||
253 | return GNUNET_SYSERR; | ||
254 | } | ||
255 | GNUNET_free (op_name); | ||
256 | |||
257 | /* Get base rate */ | ||
258 | GNUNET_asprintf (&op_name, "op-%u-base-rate", op_counter); | ||
259 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, | ||
260 | sec_name, | ||
261 | op_name, | ||
262 | &o->base_rate)) | ||
263 | { | ||
264 | fprintf (stderr, | ||
265 | "Missing base rate in operation %u `%s' in episode %u\n", | ||
266 | op_counter, op, cur->id); | ||
267 | GNUNET_free (type); | ||
268 | GNUNET_free (op); | ||
269 | GNUNET_free (op_name); | ||
270 | GNUNET_free (sec_name); | ||
271 | GNUNET_free (o); | ||
272 | return GNUNET_SYSERR; | ||
273 | } | ||
274 | GNUNET_free (op_name); | ||
275 | |||
276 | /* Get max rate */ | ||
277 | GNUNET_asprintf (&op_name, "op-%u-max-rate", op_counter); | ||
278 | if (GNUNET_SYSERR == | ||
279 | GNUNET_CONFIGURATION_get_value_number (cfg, | ||
280 | sec_name, | ||
281 | op_name, | ||
282 | &o->max_rate)) | ||
283 | { | ||
284 | if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) || | ||
285 | (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) || | ||
286 | (GNUNET_ATS_TEST_TG_SINUS == o->gen_type)) | ||
287 | { | ||
288 | fprintf (stderr, | ||
289 | "Missing max rate in operation %u `%s' in episode %u\n", | ||
290 | op_counter, op, cur->id); | ||
291 | GNUNET_free (type); | ||
292 | GNUNET_free (op_name); | ||
293 | GNUNET_free (op); | ||
294 | GNUNET_free (sec_name); | ||
295 | GNUNET_free (o); | ||
296 | return GNUNET_SYSERR; | ||
297 | } | ||
298 | } | ||
299 | GNUNET_free (op_name); | ||
300 | |||
301 | /* Get period */ | ||
302 | GNUNET_asprintf (&op_name, "op-%u-period", op_counter); | ||
303 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, | ||
304 | sec_name, | ||
305 | op_name, | ||
306 | &o->period)) | ||
307 | { | ||
308 | o->period = cur->duration; | ||
309 | } | ||
310 | GNUNET_free (op_name); | ||
311 | |||
312 | if (START_PREFERENCE == o->type) | ||
313 | { | ||
314 | /* Get frequency */ | ||
315 | GNUNET_asprintf (&op_name, "op-%u-frequency", op_counter); | ||
316 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, | ||
317 | sec_name, | ||
318 | op_name, | ||
319 | &o->frequency)) | ||
320 | { | ||
321 | fprintf (stderr, | ||
322 | "Missing frequency in operation %u `%s' in episode %u\n", | ||
323 | op_counter, op, cur->id); | ||
324 | GNUNET_free (type); | ||
325 | GNUNET_free (op_name); | ||
326 | GNUNET_free (op); | ||
327 | GNUNET_free (sec_name); | ||
328 | GNUNET_free (o); | ||
329 | return GNUNET_SYSERR; | ||
330 | } | ||
331 | GNUNET_free (op_name); | ||
332 | |||
333 | /* Get preference */ | ||
334 | GNUNET_asprintf (&op_name, "op-%u-pref", op_counter); | ||
335 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, | ||
336 | sec_name, | ||
337 | op_name, | ||
338 | &pref)) | ||
339 | { | ||
340 | fprintf (stderr, | ||
341 | "Missing preference in operation %u `%s' in episode %u\n", | ||
342 | op_counter, op, cur->id); | ||
343 | GNUNET_free (type); | ||
344 | GNUNET_free (op_name); | ||
345 | GNUNET_free (op); | ||
346 | GNUNET_free (sec_name); | ||
347 | GNUNET_free (pref); | ||
348 | GNUNET_free (o); | ||
349 | return GNUNET_SYSERR; | ||
350 | } | ||
351 | |||
352 | if (0 == strcmp (pref, "bandwidth")) | ||
353 | o->pref_type = GNUNET_ATS_PREFERENCE_BANDWIDTH; | ||
354 | else if (0 == strcmp (pref, "latency")) | ||
355 | o->pref_type = GNUNET_ATS_PREFERENCE_LATENCY; | ||
356 | else | ||
357 | { | ||
358 | fprintf (stderr, | ||
359 | "Invalid preference in operation %u `%s' in episode %u\n", | ||
360 | op_counter, | ||
361 | op, | ||
362 | cur->id); | ||
363 | GNUNET_free (type); | ||
364 | GNUNET_free (op_name); | ||
365 | GNUNET_free (op); | ||
366 | GNUNET_free (sec_name); | ||
367 | GNUNET_free (pref); | ||
368 | GNUNET_free (o); | ||
369 | return GNUNET_SYSERR; | ||
370 | } | ||
371 | GNUNET_free (pref); | ||
372 | GNUNET_free (op_name); | ||
373 | } | ||
374 | } | ||
375 | |||
376 | /* Safety checks */ | ||
377 | if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) || | ||
378 | (GNUNET_ATS_TEST_TG_SINUS == o->gen_type)) | ||
379 | { | ||
380 | if ((o->max_rate - o->base_rate) > o->base_rate) | ||
381 | { | ||
382 | /* This will cause an underflow */ | ||
383 | GNUNET_break (0); | ||
384 | } | ||
385 | fprintf (stderr, | ||
386 | "Selected max rate and base rate cannot be used for desired traffic form!\n"); | ||
387 | } | ||
388 | |||
389 | if ((START_SEND == o->type) || (START_PREFERENCE == o->type)) | ||
390 | fprintf (stderr, | ||
391 | "Found operation %u in episode %u: %s [%llu]->[%llu] == %s, %llu -> %llu in %s\n", | ||
392 | op_counter, cur->id, print_op (o->type), o->src_id, | ||
393 | o->dest_id, (NULL != type) ? type : "", | ||
394 | o->base_rate, o->max_rate, | ||
395 | GNUNET_STRINGS_relative_time_to_string (o->period, GNUNET_YES)); | ||
396 | else | ||
397 | fprintf (stderr, "Found operation %u in episode %u: %s [%llu]->[%llu]\n", | ||
398 | op_counter, cur->id, print_op (o->type), o->src_id, o->dest_id); | ||
399 | |||
400 | GNUNET_free (type); | ||
401 | GNUNET_free (op); | ||
402 | |||
403 | GNUNET_CONTAINER_DLL_insert (cur->head, cur->tail, o); | ||
404 | op_counter++; | ||
405 | } | ||
406 | GNUNET_free (sec_name); | ||
407 | |||
408 | return GNUNET_OK; | ||
409 | } | ||
410 | |||
411 | |||
412 | static int | ||
413 | load_episodes (struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg) | ||
414 | { | ||
415 | int e_counter = 0; | ||
416 | char *sec_name; | ||
417 | struct GNUNET_TIME_Relative e_duration; | ||
418 | struct Episode *cur; | ||
419 | struct Episode *last; | ||
420 | |||
421 | e_counter = 0; | ||
422 | last = NULL; | ||
423 | while (1) | ||
424 | { | ||
425 | GNUNET_asprintf (&sec_name, "episode-%u", e_counter); | ||
426 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, | ||
427 | sec_name, | ||
428 | "duration", | ||
429 | &e_duration)) | ||
430 | { | ||
431 | GNUNET_free (sec_name); | ||
432 | break; | ||
433 | } | ||
434 | |||
435 | cur = GNUNET_new (struct Episode); | ||
436 | cur->duration = e_duration; | ||
437 | cur->id = e_counter; | ||
438 | |||
439 | if (GNUNET_OK != load_episode (e, cur, cfg)) | ||
440 | { | ||
441 | GNUNET_free (sec_name); | ||
442 | GNUNET_free (cur); | ||
443 | return GNUNET_SYSERR; | ||
444 | } | ||
445 | |||
446 | fprintf (stderr, "Found episode %u with duration %s \n", | ||
447 | e_counter, | ||
448 | GNUNET_STRINGS_relative_time_to_string (cur->duration, | ||
449 | GNUNET_YES)); | ||
450 | |||
451 | /* Update experiment */ | ||
452 | e->num_episodes++; | ||
453 | e->total_duration = GNUNET_TIME_relative_add (e->total_duration, | ||
454 | cur->duration); | ||
455 | /* Put in linked list */ | ||
456 | if (NULL == last) | ||
457 | e->start = cur; | ||
458 | else | ||
459 | last->next = cur; | ||
460 | |||
461 | GNUNET_free (sec_name); | ||
462 | e_counter++; | ||
463 | last = cur; | ||
464 | } | ||
465 | return e_counter; | ||
466 | } | ||
467 | |||
468 | |||
469 | static void | ||
470 | timeout_experiment (void *cls) | ||
471 | { | ||
472 | struct Experiment *e = cls; | ||
473 | |||
474 | e->experiment_timeout_task = NULL; | ||
475 | fprintf (stderr, "Experiment timeout!\n"); | ||
476 | |||
477 | if (NULL != e->episode_timeout_task) | ||
478 | { | ||
479 | GNUNET_SCHEDULER_cancel (e->episode_timeout_task); | ||
480 | e->episode_timeout_task = NULL; | ||
481 | } | ||
482 | |||
483 | e->e_done_cb (e, GNUNET_TIME_absolute_get_duration (e->start_time), | ||
484 | GNUNET_SYSERR); | ||
485 | } | ||
486 | |||
487 | |||
488 | static void | ||
489 | enforce_start_send (struct GNUNET_ATS_TEST_Operation *op) | ||
490 | { | ||
491 | /* | ||
492 | struct BenchmarkPeer *peer; | ||
493 | struct BenchmarkPartner *partner; | ||
494 | |||
495 | peer = GNUNET_ATS_TEST_get_peer (op->src_id); | ||
496 | if (NULL == peer) | ||
497 | { | ||
498 | GNUNET_break (0); | ||
499 | return; | ||
500 | } | ||
501 | |||
502 | partner = GNUNET_ATS_TEST_get_partner (op->src_id, op->dest_id); | ||
503 | if (NULL == partner) | ||
504 | { | ||
505 | GNUNET_break (0); | ||
506 | return; | ||
507 | } | ||
508 | |||
509 | fprintf (stderr, "Found master %llu slave %llu\n",op->src_id, op->dest_id); | ||
510 | |||
511 | if (NULL != partner->tg) | ||
512 | { | ||
513 | fprintf (stderr, "Stopping traffic between master %llu slave %llu\n",op->src_id, op->dest_id); | ||
514 | GNUNET_ATS_TEST_generate_traffic_stop(partner->tg); | ||
515 | partner->tg = NULL; | ||
516 | } | ||
517 | |||
518 | partner->tg = GNUNET_ATS_TEST_generate_traffic_start(peer, partner, | ||
519 | op->tg_type, op->base_rate, op->max_rate, op->period, | ||
520 | GNUNET_TIME_UNIT_FOREVER_REL); | ||
521 | */} | ||
522 | |||
523 | |||
524 | static void | ||
525 | enforce_stop_send (struct GNUNET_ATS_TEST_Operation *op) | ||
526 | { | ||
527 | /* | ||
528 | struct BenchmarkPartner *p; | ||
529 | p = GNUNET_ATS_TEST_get_partner (op->src_id, op->dest_id); | ||
530 | if (NULL == p) | ||
531 | { | ||
532 | GNUNET_break (0); | ||
533 | return; | ||
534 | } | ||
535 | |||
536 | fprintf (stderr, "Found master %llu slave %llu\n",op->src_id, op->dest_id); | ||
537 | |||
538 | if (NULL != p->tg) | ||
539 | { | ||
540 | fprintf (stderr, "Stopping traffic between master %llu slave %llu\n", | ||
541 | op->src_id, op->dest_id); | ||
542 | GNUNET_ATS_TEST_generate_traffic_stop(p->tg); | ||
543 | p->tg = NULL; | ||
544 | } | ||
545 | */} | ||
546 | |||
547 | |||
548 | static void | ||
549 | enforce_start_preference (struct GNUNET_ATS_TEST_Operation *op) | ||
550 | { | ||
551 | /* | ||
552 | struct BenchmarkPeer *peer; | ||
553 | struct BenchmarkPartner *partner; | ||
554 | |||
555 | peer = GNUNET_ATS_TEST_get_peer (op->src_id); | ||
556 | if (NULL == peer) | ||
557 | { | ||
558 | GNUNET_break (0); | ||
559 | return; | ||
560 | } | ||
561 | |||
562 | partner = GNUNET_ATS_TEST_get_partner (op->src_id, op->dest_id); | ||
563 | if (NULL == partner) | ||
564 | { | ||
565 | GNUNET_break (0); | ||
566 | return; | ||
567 | } | ||
568 | |||
569 | fprintf (stderr, "Found master %llu slave %llu\n",op->src_id, op->dest_id); | ||
570 | |||
571 | if (NULL != partner->pg) | ||
572 | { | ||
573 | fprintf (stderr, "Stopping traffic between master %llu slave %llu\n", | ||
574 | op->src_id, op->dest_id); | ||
575 | GNUNET_ATS_TEST_generate_preferences_stop(partner->pg); | ||
576 | partner->pg = NULL; | ||
577 | } | ||
578 | |||
579 | partner->pg = GNUNET_ATS_TEST_generate_preferences_start(peer, partner, | ||
580 | op->tg_type, op->base_rate, op->max_rate, op->period, op->frequency, | ||
581 | op->pref_type); | ||
582 | */} | ||
583 | |||
584 | |||
585 | static void | ||
586 | enforce_stop_preference (struct GNUNET_ATS_TEST_Operation *op) | ||
587 | { | ||
588 | /* | ||
589 | struct BenchmarkPartner *p; | ||
590 | p = GNUNET_ATS_TEST_get_partner (op->src_id, op->dest_id); | ||
591 | if (NULL == p) | ||
592 | { | ||
593 | GNUNET_break (0); | ||
594 | return; | ||
595 | } | ||
596 | |||
597 | fprintf (stderr, "Found master %llu slave %llu\n",op->src_id, op->dest_id); | ||
598 | |||
599 | if (NULL != p->pg) | ||
600 | { | ||
601 | fprintf (stderr, "Stopping preference between master %llu slave %llu\n", | ||
602 | op->src_id, op->dest_id); | ||
603 | GNUNET_ATS_TEST_generate_preferences_stop (p->pg); | ||
604 | p->pg = NULL; | ||
605 | } | ||
606 | */} | ||
607 | |||
608 | |||
609 | static void | ||
610 | enforce_episode (struct Episode *ep) | ||
611 | { | ||
612 | struct GNUNET_ATS_TEST_Operation *cur; | ||
613 | |||
614 | for (cur = ep->head; NULL != cur; cur = cur->next) | ||
615 | { | ||
616 | fprintf (stderr, "Enforcing operation: %s [%llu]->[%llu] == %llu\n", | ||
617 | print_op (cur->type), cur->src_id, cur->dest_id, cur->base_rate); | ||
618 | switch (cur->type) | ||
619 | { | ||
620 | case START_SEND: | ||
621 | enforce_start_send (cur); | ||
622 | break; | ||
623 | |||
624 | case STOP_SEND: | ||
625 | enforce_stop_send (cur); | ||
626 | break; | ||
627 | |||
628 | case START_PREFERENCE: | ||
629 | enforce_start_preference (cur); | ||
630 | break; | ||
631 | |||
632 | case STOP_PREFERENCE: | ||
633 | enforce_stop_preference (cur); | ||
634 | break; | ||
635 | |||
636 | default: | ||
637 | break; | ||
638 | } | ||
639 | } | ||
640 | } | ||
641 | |||
642 | |||
643 | static void | ||
644 | timeout_episode (void *cls) | ||
645 | { | ||
646 | struct Experiment *e = cls; | ||
647 | |||
648 | e->episode_timeout_task = NULL; | ||
649 | if (NULL != e->ep_done_cb) | ||
650 | e->ep_done_cb (e->cur); | ||
651 | |||
652 | /* Scheduling next */ | ||
653 | e->cur = e->cur->next; | ||
654 | if (NULL == e->cur) | ||
655 | { | ||
656 | /* done */ | ||
657 | fprintf (stderr, "Last episode done!\n"); | ||
658 | if (NULL != e->experiment_timeout_task) | ||
659 | { | ||
660 | GNUNET_SCHEDULER_cancel (e->experiment_timeout_task); | ||
661 | e->experiment_timeout_task = NULL; | ||
662 | } | ||
663 | e->e_done_cb (e, GNUNET_TIME_absolute_get_duration (e->start_time), | ||
664 | GNUNET_OK); | ||
665 | return; | ||
666 | } | ||
667 | |||
668 | fprintf (stderr, "Running episode %u with timeout %s\n", | ||
669 | e->cur->id, | ||
670 | GNUNET_STRINGS_relative_time_to_string (e->cur->duration, | ||
671 | GNUNET_YES)); | ||
672 | enforce_episode (e->cur); | ||
673 | |||
674 | e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed (e->cur->duration, | ||
675 | &timeout_episode, e); | ||
676 | } | ||
677 | |||
678 | |||
679 | void | ||
680 | GNUNET_ATS_solvers_experimentation_run (struct Experiment *e, | ||
681 | GNUNET_ATS_TESTING_EpisodeDoneCallback | ||
682 | ep_done_cb, | ||
683 | GNUNET_ATS_TESTING_ExperimentDoneCallback | ||
684 | e_done_cb) | ||
685 | { | ||
686 | fprintf (stderr, "Running experiment `%s' with timeout %s\n", e->name, | ||
687 | GNUNET_STRINGS_relative_time_to_string (e->max_duration, | ||
688 | GNUNET_YES)); | ||
689 | e->e_done_cb = e_done_cb; | ||
690 | e->ep_done_cb = ep_done_cb; | ||
691 | e->start_time = GNUNET_TIME_absolute_get (); | ||
692 | |||
693 | /* Start total time out */ | ||
694 | e->experiment_timeout_task = GNUNET_SCHEDULER_add_delayed (e->max_duration, | ||
695 | &timeout_experiment, | ||
696 | e); | ||
697 | |||
698 | /* Start */ | ||
699 | e->cur = e->start; | ||
700 | fprintf (stderr, "Running episode %u with timeout %s\n", | ||
701 | e->cur->id, | ||
702 | GNUNET_STRINGS_relative_time_to_string (e->cur->duration, | ||
703 | GNUNET_YES)); | ||
704 | enforce_episode (e->cur); | ||
705 | e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed (e->cur->duration, | ||
706 | &timeout_episode, e); | ||
707 | } | ||
708 | |||
709 | |||
710 | struct Experiment * | ||
711 | GNUNET_ATS_solvers_experimentation_load (char *filename) | ||
712 | { | ||
713 | struct Experiment *e; | ||
714 | struct GNUNET_CONFIGURATION_Handle *cfg; | ||
715 | |||
716 | e = NULL; | ||
717 | |||
718 | cfg = GNUNET_CONFIGURATION_create (); | ||
719 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, filename)) | ||
720 | { | ||
721 | fprintf (stderr, "Failed to load `%s'\n", filename); | ||
722 | GNUNET_CONFIGURATION_destroy (cfg); | ||
723 | return NULL; | ||
724 | } | ||
725 | |||
726 | e = create_experiment (); | ||
727 | |||
728 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, "experiment", | ||
729 | "name", &e->name)) | ||
730 | { | ||
731 | fprintf (stderr, "Invalid %s", "name"); | ||
732 | free_experiment (e); | ||
733 | return NULL; | ||
734 | } | ||
735 | else | ||
736 | fprintf (stderr, "Experiment name: `%s'\n", e->name); | ||
737 | |||
738 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename (cfg, | ||
739 | "experiment", | ||
740 | "cfg_file", | ||
741 | &e->cfg_file)) | ||
742 | { | ||
743 | fprintf (stderr, "Invalid %s", "cfg_file"); | ||
744 | free_experiment (e); | ||
745 | return NULL; | ||
746 | } | ||
747 | else | ||
748 | fprintf (stderr, "Experiment name: `%s'\n", e->cfg_file); | ||
749 | |||
750 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, "experiment", | ||
751 | "masters", | ||
752 | &e->num_masters)) | ||
753 | { | ||
754 | fprintf (stderr, "Invalid %s", "masters"); | ||
755 | free_experiment (e); | ||
756 | return NULL; | ||
757 | } | ||
758 | else | ||
759 | fprintf (stderr, "Experiment masters: `%llu'\n", | ||
760 | e->num_masters); | ||
761 | |||
762 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, "experiment", | ||
763 | "slaves", | ||
764 | &e->num_slaves)) | ||
765 | { | ||
766 | fprintf (stderr, "Invalid %s", "slaves"); | ||
767 | free_experiment (e); | ||
768 | return NULL; | ||
769 | } | ||
770 | else | ||
771 | fprintf (stderr, "Experiment slaves: `%llu'\n", | ||
772 | e->num_slaves); | ||
773 | |||
774 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, "experiment", | ||
775 | "log_freq", | ||
776 | &e->log_freq)) | ||
777 | { | ||
778 | fprintf (stderr, "Invalid %s", "log_freq"); | ||
779 | free_experiment (e); | ||
780 | return NULL; | ||
781 | } | ||
782 | else | ||
783 | fprintf (stderr, "Experiment logging frequency: `%s'\n", | ||
784 | GNUNET_STRINGS_relative_time_to_string (e->log_freq, GNUNET_YES)); | ||
785 | |||
786 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (cfg, "experiment", | ||
787 | "max_duration", | ||
788 | &e->max_duration)) | ||
789 | { | ||
790 | fprintf (stderr, "Invalid %s", "max_duration"); | ||
791 | free_experiment (e); | ||
792 | return NULL; | ||
793 | } | ||
794 | else | ||
795 | fprintf (stderr, "Experiment duration: `%s'\n", | ||
796 | GNUNET_STRINGS_relative_time_to_string (e->max_duration, | ||
797 | GNUNET_YES)); | ||
798 | |||
799 | load_episodes (e, cfg); | ||
800 | fprintf (stderr, "Loaded %u episodes with total duration %s\n", | ||
801 | e->num_episodes, | ||
802 | GNUNET_STRINGS_relative_time_to_string (e->total_duration, | ||
803 | GNUNET_YES)); | ||
804 | |||
805 | GNUNET_CONFIGURATION_destroy (cfg); | ||
806 | return e; | ||
807 | } | ||
808 | |||
809 | |||
810 | void | ||
811 | GNUNET_ATS_solvers_experimentation_stop (struct Experiment *e) | ||
812 | { | ||
813 | if (NULL != e->experiment_timeout_task) | ||
814 | { | ||
815 | GNUNET_SCHEDULER_cancel (e->experiment_timeout_task); | ||
816 | e->experiment_timeout_task = NULL; | ||
817 | } | ||
818 | if (NULL != e->episode_timeout_task) | ||
819 | { | ||
820 | GNUNET_SCHEDULER_cancel (e->episode_timeout_task); | ||
821 | e->episode_timeout_task = NULL; | ||
822 | } | ||
823 | free_experiment (e); | ||
824 | } | ||
825 | |||
826 | |||
827 | /** | ||
828 | * Solver | ||
829 | */ | ||
830 | |||
831 | struct GNUNET_ATS_TESTING_SolverHandle | ||
832 | { | ||
833 | char *plugin; | ||
834 | struct GNUNET_ATS_PluginEnvironment env; | ||
835 | void *solver; | ||
836 | }; | ||
837 | |||
838 | enum GNUNET_ATS_Solvers | ||
839 | { | ||
840 | GNUNET_ATS_SOLVER_PROPORTIONAL, | ||
841 | GNUNET_ATS_SOLVER_MLP, | ||
842 | GNUNET_ATS_SOLVER_RIL, | ||
843 | }; | ||
844 | |||
845 | void | ||
846 | GNUNET_ATS_solvers_solver_stop (struct GNUNET_ATS_TESTING_SolverHandle *sh) | ||
847 | { | ||
848 | GNUNET_PLUGIN_unload (sh->plugin, sh->solver); | ||
849 | GNUNET_free (sh->plugin); | ||
850 | GNUNET_free (sh); | ||
851 | } | ||
852 | |||
853 | |||
854 | struct GNUNET_ATS_TESTING_SolverHandle * | ||
855 | GNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type) | ||
856 | { | ||
857 | struct GNUNET_ATS_TESTING_SolverHandle *sh; | ||
858 | char *solver_str; | ||
859 | |||
860 | switch (type) | ||
861 | { | ||
862 | case GNUNET_ATS_SOLVER_PROPORTIONAL: | ||
863 | solver_str = "proportional"; | ||
864 | break; | ||
865 | |||
866 | case GNUNET_ATS_SOLVER_MLP: | ||
867 | solver_str = "mlp"; | ||
868 | break; | ||
869 | |||
870 | case GNUNET_ATS_SOLVER_RIL: | ||
871 | solver_str = "ril"; | ||
872 | break; | ||
873 | |||
874 | default: | ||
875 | GNUNET_break (0); | ||
876 | return NULL; | ||
877 | break; | ||
878 | } | ||
879 | |||
880 | sh = GNUNET_new (struct GNUNET_ATS_TESTING_SolverHandle); | ||
881 | GNUNET_asprintf (&sh->plugin, "libgnunet_plugin_ats_%s", solver_str); | ||
882 | // sh->solver = GNUNET_PLUGIN_load (sh->plugin, &sh->env); | ||
883 | if (NULL == sh->solver) | ||
884 | { | ||
885 | fprintf (stderr, "Failed to load solver `%s'\n", sh->plugin); | ||
886 | exit (1); | ||
887 | } | ||
888 | |||
889 | return sh; | ||
890 | } | ||
891 | |||
892 | |||
893 | static struct Experiment *e; | ||
894 | |||
895 | static struct GNUNET_ATS_TESTING_SolverHandle *sh; | ||
896 | |||
897 | /** | ||
898 | * cmd option -e: experiment file | ||
899 | */ | ||
900 | static char *opt_exp_file; | ||
901 | |||
902 | static char *opt_solver; | ||
903 | |||
904 | /** | ||
905 | * cmd option -l: enable logging | ||
906 | */ | ||
907 | static int opt_log; | ||
908 | |||
909 | /** | ||
910 | * cmd option -p: enable plots | ||
911 | */ | ||
912 | static int opt_plot; | ||
913 | |||
914 | /** | ||
915 | * cmd option -v: verbose logs | ||
916 | */ | ||
917 | static int opt_verbose; | ||
918 | |||
919 | static void | ||
920 | run (void *cls, char *const *args, const char *cfgfile, | ||
921 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
922 | { | ||
923 | enum GNUNET_ATS_Solvers solver; | ||
924 | |||
925 | if (NULL == opt_exp_file) | ||
926 | { | ||
927 | fprintf (stderr, "No experiment given ...\n"); | ||
928 | exit (1); | ||
929 | } | ||
930 | |||
931 | if (NULL == opt_solver) | ||
932 | { | ||
933 | fprintf (stderr, "No solver given ...\n"); | ||
934 | exit (1); | ||
935 | } | ||
936 | |||
937 | if (0 == strcmp (opt_solver, "mlp")) | ||
938 | { | ||
939 | solver = GNUNET_ATS_SOLVER_MLP; | ||
940 | } | ||
941 | else if (0 == strcmp (opt_solver, "proportional")) | ||
942 | { | ||
943 | solver = GNUNET_ATS_SOLVER_PROPORTIONAL; | ||
944 | } | ||
945 | else if (0 == strcmp (opt_solver, "ril")) | ||
946 | { | ||
947 | solver = GNUNET_ATS_SOLVER_RIL; | ||
948 | } | ||
949 | else | ||
950 | { | ||
951 | fprintf (stderr, "No solver given ..."); | ||
952 | return; | ||
953 | } | ||
954 | |||
955 | /* load experiment */ | ||
956 | e = GNUNET_ATS_solvers_experimentation_load (opt_exp_file); | ||
957 | if (NULL == e) | ||
958 | { | ||
959 | fprintf (stderr, "Failed to load experiment ...\n"); | ||
960 | return; | ||
961 | } | ||
962 | |||
963 | /* load solver */ | ||
964 | sh = GNUNET_ATS_solvers_solver_start (solver); | ||
965 | if (NULL == sh) | ||
966 | { | ||
967 | fprintf (stderr, "Failed to start solver ...\n"); | ||
968 | return; | ||
969 | } | ||
970 | |||
971 | /* start logging */ | ||
972 | |||
973 | /* run experiment */ | ||
974 | |||
975 | /* WAIT */ | ||
976 | } | ||
977 | |||
978 | |||
979 | /** | ||
980 | * Main function of the benchmark | ||
981 | * | ||
982 | * @param argc argument count | ||
983 | * @param argv argument values | ||
984 | */ | ||
985 | int | ||
986 | main (int argc, char *argv[]) | ||
987 | { | ||
988 | opt_exp_file = NULL; | ||
989 | opt_solver = NULL; | ||
990 | opt_log = GNUNET_NO; | ||
991 | opt_plot = GNUNET_NO; | ||
992 | |||
993 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
994 | GNUNET_GETOPT_option_string ('s', | ||
995 | "solver", | ||
996 | NULL, | ||
997 | gettext_noop ("solver to use"), | ||
998 | &opt_solver), | ||
999 | |||
1000 | GNUNET_GETOPT_option_string ('e', | ||
1001 | "experiment", | ||
1002 | NULL, | ||
1003 | gettext_noop ("experiment to use"), | ||
1004 | &opt_exp_file), | ||
1005 | |||
1006 | GNUNET_GETOPT_option_flag ('e', | ||
1007 | "experiment", | ||
1008 | gettext_noop ("experiment to use"), | ||
1009 | &opt_verbose), | ||
1010 | GNUNET_GETOPT_OPTION_END | ||
1011 | }; | ||
1012 | |||
1013 | if (GNUNET_OK != | ||
1014 | GNUNET_PROGRAM_run (argc, | ||
1015 | argv, argv[0], | ||
1016 | NULL, | ||
1017 | options, | ||
1018 | &run, argv[0])) | ||
1019 | return 1; | ||
1020 | |||
1021 | return 0; | ||
1022 | } | ||
1023 | |||
1024 | |||
1025 | /* end of file gnunet-solver-eval.c*/ | ||