aboutsummaryrefslogtreecommitdiff
path: root/src/ats-tests/perf_ats_logging.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/ats-tests/perf_ats_logging.c')
-rw-r--r--src/ats-tests/perf_ats_logging.c780
1 files changed, 0 insertions, 780 deletions
diff --git a/src/ats-tests/perf_ats_logging.c b/src/ats-tests/perf_ats_logging.c
deleted file mode 100644
index ac8fa8950..000000000
--- a/src/ats-tests/perf_ats_logging.c
+++ /dev/null
@@ -1,780 +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/perf_ats_logging.c
22 * @brief ats benchmark: logging for performance tests
23 * @author Christian Grothoff
24 * @author Matthias Wachs
25 */
26#include "platform.h"
27#include "gnunet_util_lib.h"
28#include "perf_ats.h"
29
30#define THROUGHPUT_TEMPLATE "#!/usr/bin/gnuplot \n" \
31 "set datafile separator ';' \n" \
32 "set title \"Throughput between Master and Slaves\" \n" \
33 "set xlabel \"Time in ms\" \n" \
34 "set ylabel \"Bytes/s\" \n" \
35 "set grid \n"
36
37#define RTT_TEMPLATE "#!/usr/bin/gnuplot \n" \
38 "set datafile separator ';' \n" \
39 "set title \"Application level roundtrip time between Master and Slaves\" \n" \
40 "set xlabel \"Time in ms\" \n" \
41 "set ylabel \"ms\" \n" \
42 "set grid \n"
43
44#define BW_TEMPLATE "#!/usr/bin/gnuplot \n" \
45 "set datafile separator ';' \n" \
46 "set title \"Bandwidth inbound and outbound between Master and Slaves\" \n" \
47 "set xlabel \"Time in ms\" \n" \
48 "set ylabel \"Bytes / s \" \n" \
49 "set grid \n"
50
51#define LOG_ITEMS_TIME 2
52#define LOG_ITEMS_PER_PEER 17
53
54#define LOG_ITEM_BYTES_SENT 1
55#define LOG_ITEM_MSGS_SENT 2
56#define LOG_ITEM_THROUGHPUT_SENT 3
57#define LOG_ITEM_BYTES_RECV 4
58#define LOG_ITEM_MSGS_RECV 5
59#define LOG_ITEM_THROUGHPUT_RECV 6
60#define LOG_ITEM_APP_RTT 7
61#define LOG_ITEM_ATS_BW_IN 8
62#define LOG_ITEM_ATS_BW_OUT 9
63#define LOG_ITEM_ATS_COSTS_LAN 10
64#define LOG_ITEM_ATS_WAN 11
65#define LOG_ITEM_ATS_WLAN 12
66#define LOG_ITEM_ATS_DELAY 13
67#define LOG_ITEM_ATS_DISTANCE 14
68#define LOG_ITEM_ATS_NETWORKTYPE 15
69#define LOG_ITEM_ATS_UTIL_UP 16
70#define LOG_ITEM_ATS_UTIL_DOWN 17
71
72/**
73 * Logging task
74 */
75static struct GNUNET_SCHEDULER_Task *log_task;
76
77/**
78 * Reference to perf_ats' masters
79 */
80static int num_peers;
81static int running;
82static char *name;
83static struct GNUNET_TIME_Relative frequency;
84
85/**
86 * A single logging time step for a partner
87 */
88struct PartnerLoggingTimestep
89{
90 /**
91 * Peer
92 */
93 struct BenchmarkPeer *slave;
94
95 /**
96 * Total number of messages this peer has sent
97 */
98 unsigned int total_messages_sent;
99
100 /**
101 * Total number of bytes this peer has sent
102 */
103 unsigned int total_bytes_sent;
104
105 /**
106 * Total number of messages this peer has received
107 */
108 unsigned int total_messages_received;
109
110 /**
111 * Total number of bytes this peer has received
112 */
113 unsigned int total_bytes_received;
114
115 /**
116 * Total outbound throughput for master in Bytes / s
117 */
118 unsigned int throughput_sent;
119
120 /**
121 * Total inbound throughput for master in Bytes / s
122 */
123 unsigned int throughput_recv;
124
125 /**
126 * Accumulated RTT for all messages
127 */
128 unsigned int total_app_rtt;
129
130 /**
131 * Current application level delay
132 */
133 unsigned int app_rtt;
134
135 /* Current ATS properties */
136
137 uint32_t ats_distance;
138
139 uint32_t ats_delay;
140
141 uint32_t bandwidth_in;
142
143 uint32_t bandwidth_out;
144
145 uint32_t ats_utilization_up;
146
147 uint32_t ats_utilization_down;
148
149 uint32_t ats_network_type;
150
151 uint32_t ats_cost_wan;
152
153 uint32_t ats_cost_lan;
154
155 uint32_t ats_cost_wlan;
156};
157
158
159/**
160 * A single logging time step for a peer
161 */
162struct PeerLoggingTimestep
163{
164 /**
165 * Next in DLL
166 */
167 struct PeerLoggingTimestep *next;
168
169 /**
170 * Prev in DLL
171 */
172 struct PeerLoggingTimestep *prev;
173
174 /**
175 * Logging timestamp
176 */
177 struct GNUNET_TIME_Absolute timestamp;
178
179 /**
180 * Total number of messages this peer has sent
181 */
182 unsigned int total_messages_sent;
183
184 /**
185 * Total number of bytes this peer has sent
186 */
187 unsigned int total_bytes_sent;
188
189 /**
190 * Total number of messages this peer has received
191 */
192 unsigned int total_messages_received;
193
194 /**
195 * Total number of bytes this peer has received
196 */
197 unsigned int total_bytes_received;
198
199 /**
200 * Total outbound throughput for master in Bytes / s
201 */
202 unsigned int total_throughput_send;
203
204 /**
205 * Total inbound throughput for master in Bytes / s
206 */
207 unsigned int total_throughput_recv;
208
209 /**
210 * Logs for slaves
211 */
212 struct PartnerLoggingTimestep *slaves_log;
213};
214
215/**
216 * Entry for a benchmark peer
217 */
218struct LoggingPeer
219{
220 /**
221 * Peer
222 */
223 struct BenchmarkPeer *peer;
224
225 /**
226 * Start time
227 */
228 struct GNUNET_TIME_Absolute start;
229
230 /**
231 * DLL for logging entries: head
232 */
233 struct PeerLoggingTimestep *head;
234
235 /**
236 * DLL for logging entries: tail
237 */
238 struct PeerLoggingTimestep *tail;
239};
240
241/**
242 * Log structure of length num_peers
243 */
244static struct LoggingPeer *lp;
245
246
247static void
248write_throughput_gnuplot_script (char *fn, struct LoggingPeer *lp)
249{
250 struct GNUNET_DISK_FileHandle *f;
251 char *gfn;
252 char *data;
253 int c_s;
254 int peer_index;
255
256 GNUNET_asprintf (&gfn, "gnuplot_throughput_%s", fn);
257 f = GNUNET_DISK_file_open (gfn,
258 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
259 GNUNET_DISK_PERM_USER_EXEC
260 | GNUNET_DISK_PERM_USER_READ
261 | GNUNET_DISK_PERM_USER_WRITE);
262 if (NULL == f)
263 {
264 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n",
265 gfn);
266 GNUNET_free (gfn);
267 return;
268 }
269
270 /* Write header */
271
272 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, THROUGHPUT_TEMPLATE, strlen (
273 THROUGHPUT_TEMPLATE)))
274 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
275 "Cannot write data to plot file `%s'\n", gfn);
276
277 /* Write master data */
278 peer_index = LOG_ITEMS_TIME;
279 GNUNET_asprintf (&data,
280 "plot '%s' using 2:%u with lines title 'Master %u send total', \\\n" \
281 "'%s' using 2:%u with lines title 'Master %u receive total', \\\n",
282 fn, peer_index + LOG_ITEM_THROUGHPUT_SENT, lp->peer->no,
283 fn, peer_index + LOG_ITEM_THROUGHPUT_RECV, lp->peer->no);
284 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, data, strlen (data)))
285 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
286 "Cannot write data to plot file `%s'\n", gfn);
287 GNUNET_free (data);
288
289 peer_index = LOG_ITEMS_TIME + LOG_ITEMS_PER_PEER;
290 for (c_s = 0; c_s < lp->peer->num_partners; c_s++)
291 {
292 GNUNET_asprintf (&data,
293 "'%s' using 2:%u with lines title 'Master %u - Slave %u send', \\\n" \
294 "'%s' using 2:%u with lines title 'Master %u - Slave %u receive'%s\n",
295 fn, peer_index + LOG_ITEM_THROUGHPUT_SENT, lp->peer->no,
296 lp->peer->partners[c_s].dest->no,
297 fn, peer_index + LOG_ITEM_THROUGHPUT_RECV, lp->peer->no,
298 lp->peer->partners[c_s].dest->no,
299 (c_s < lp->peer->num_partners - 1) ? ", \\" :
300 "\n pause -1");
301 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, data, strlen (data)))
302 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
303 "Cannot write data to plot file `%s'\n", gfn);
304 GNUNET_free (data);
305 peer_index += LOG_ITEMS_PER_PEER;
306 }
307
308 if (GNUNET_SYSERR == GNUNET_DISK_file_close (f))
309 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n",
310 gfn);
311 else
312 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
313 "Data successfully written to plot file `%s'\n", gfn);
314
315 GNUNET_free (gfn);
316}
317
318
319static void
320write_rtt_gnuplot_script (char *fn, struct LoggingPeer *lp)
321{
322 struct GNUNET_DISK_FileHandle *f;
323 char *gfn;
324 char *data;
325 int c_s;
326 int index;
327
328 GNUNET_asprintf (&gfn, "gnuplot_rtt_%s", fn);
329 f = GNUNET_DISK_file_open (gfn,
330 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
331 GNUNET_DISK_PERM_USER_EXEC
332 | GNUNET_DISK_PERM_USER_READ
333 | GNUNET_DISK_PERM_USER_WRITE);
334 if (NULL == f)
335 {
336 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n",
337 gfn);
338 GNUNET_free (gfn);
339 return;
340 }
341
342 /* Write header */
343
344 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, RTT_TEMPLATE, strlen (
345 RTT_TEMPLATE)))
346 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
347 "Cannot write data to plot file `%s'\n", gfn);
348
349 index = LOG_ITEMS_TIME + LOG_ITEMS_PER_PEER;
350 for (c_s = 0; c_s < lp->peer->num_partners; c_s++)
351 {
352 GNUNET_asprintf (&data,
353 "%s'%s' using 2:%u with lines title 'Master %u - Slave %u '%s\n",
354 (0 == c_s) ? "plot " : "",
355 fn, index + LOG_ITEM_APP_RTT, lp->peer->no,
356 lp->peer->partners[c_s].dest->no,
357 (c_s < lp->peer->num_partners - 1) ? ", \\" :
358 "\n pause -1");
359 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, data, strlen (data)))
360 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
361 "Cannot write data to plot file `%s'\n", gfn);
362 GNUNET_free (data);
363 index += LOG_ITEMS_PER_PEER;
364 }
365
366 if (GNUNET_SYSERR == GNUNET_DISK_file_close (f))
367 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n",
368 gfn);
369 else
370 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
371 "Data successfully written to plot file `%s'\n", gfn);
372 GNUNET_free (gfn);
373}
374
375
376static void
377write_bw_gnuplot_script (char *fn, struct LoggingPeer *lp)
378{
379 struct GNUNET_DISK_FileHandle *f;
380 char *gfn;
381 char *data;
382 int c_s;
383 int index;
384
385 GNUNET_asprintf (&gfn, "gnuplot_bw_%s", fn);
386 f = GNUNET_DISK_file_open (gfn,
387 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
388 GNUNET_DISK_PERM_USER_EXEC
389 | GNUNET_DISK_PERM_USER_READ
390 | GNUNET_DISK_PERM_USER_WRITE);
391 if (NULL == f)
392 {
393 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n",
394 gfn);
395 GNUNET_free (gfn);
396 return;
397 }
398
399 /* Write header */
400
401 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, BW_TEMPLATE, strlen (
402 BW_TEMPLATE)))
403 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
404 "Cannot write data to plot file `%s'\n", gfn);
405
406 index = LOG_ITEMS_TIME + LOG_ITEMS_PER_PEER;
407 for (c_s = 0; c_s < lp->peer->num_partners; c_s++)
408 {
409 GNUNET_asprintf (&data, "%s" \
410 "'%s' using 2:%u with lines title 'BW out master %u - Slave %u ', \\\n" \
411 "'%s' using 2:%u with lines title 'BW in master %u - Slave %u '" \
412 "%s\n",
413 (0 == c_s) ? "plot " : "",
414 fn, index + LOG_ITEM_ATS_BW_OUT, lp->peer->no,
415 lp->peer->partners[c_s].dest->no,
416 fn, index + LOG_ITEM_ATS_BW_IN, lp->peer->no,
417 lp->peer->partners[c_s].dest->no,
418 (c_s < lp->peer->num_partners - 1) ? ", \\" :
419 "\n pause -1");
420 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, data, strlen (data)))
421 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
422 "Cannot write data to plot file `%s'\n", gfn);
423 GNUNET_free (data);
424 index += LOG_ITEMS_PER_PEER;
425 }
426
427 if (GNUNET_SYSERR == GNUNET_DISK_file_close (f))
428 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n",
429 gfn);
430 else
431 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
432 "Data successfully written to plot file `%s'\n", gfn);
433 GNUNET_free (gfn);
434}
435
436
437static void
438write_to_file ()
439{
440 struct GNUNET_DISK_FileHandle *f;
441
442 char *filename;
443 char *data;
444 char *slave_string;
445 char *slave_string_tmp;
446 struct PeerLoggingTimestep *cur_lt;
447 struct PartnerLoggingTimestep *plt;
448 int c_m;
449 int c_s;
450
451 for (c_m = 0; c_m < num_peers; c_m++)
452 {
453 GNUNET_asprintf (&filename, "%llu_master_%u_%s_%s.data",
454 GNUNET_TIME_absolute_get ().abs_value_us,
455 lp[c_m].peer->no, GNUNET_i2s (&lp[c_m].peer->id), name);
456
457 f = GNUNET_DISK_file_open (filename,
458 GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
459 GNUNET_DISK_PERM_USER_READ
460 | GNUNET_DISK_PERM_USER_WRITE);
461 if (NULL == f)
462 {
463 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open log file `%s'\n",
464 filename);
465 GNUNET_free (filename);
466 return;
467 }
468
469 for (cur_lt = lp[c_m].head; NULL != cur_lt; cur_lt = cur_lt->next)
470 {
471 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
472 "Master [%u]: timestamp %llu %llu ; %u %u %u ; %u %u %u\n",
473 lp[c_m].peer->no,
474 cur_lt->timestamp, GNUNET_TIME_absolute_get_difference (
475 lp[c_m].start, cur_lt->timestamp).rel_value_us / 1000,
476 cur_lt->total_messages_sent, cur_lt->total_bytes_sent,
477 cur_lt->total_throughput_send,
478 cur_lt->total_messages_received, cur_lt->total_bytes_received,
479 cur_lt->total_throughput_recv);
480
481 slave_string = GNUNET_strdup (";");
482 for (c_s = 0; c_s < lp[c_m].peer->num_partners; c_s++)
483 {
484 plt = &cur_lt->slaves_log[c_s];
485 /* Log partners */
486
487 /* Assembling slave string */
488 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
489 "\t Slave [%u]: %u %u %u ; %u %u %u rtt %u delay %u bw_in %u bw_out %u \n",
490 plt->slave->no,
491 plt->total_messages_sent, plt->total_bytes_sent,
492 plt->throughput_sent,
493 plt->total_messages_received, plt->total_bytes_received,
494 plt->throughput_recv,
495 plt->app_rtt, plt->ats_delay,
496 plt->bandwidth_in, plt->bandwidth_out);
497
498 GNUNET_asprintf (&slave_string_tmp,
499 "%s%u;%u;%u;%u;%u;%u;%.3f;%u;%u;%u;%u;%u;%u;%u;%u;%u;%u;",
500 slave_string,
501 plt->total_messages_sent, plt->total_bytes_sent,
502 plt->throughput_sent,
503 plt->total_messages_received,
504 plt->total_bytes_received, plt->throughput_sent,
505 (double) plt->app_rtt / 1000,
506 plt->bandwidth_in, plt->bandwidth_out,
507 plt->ats_cost_lan, plt->ats_cost_wan,
508 plt->ats_cost_wlan,
509 plt->ats_delay, plt->ats_distance,
510 plt->ats_network_type,
511 plt->ats_utilization_up, plt->ats_utilization_down);
512 GNUNET_free (slave_string);
513 slave_string = slave_string_tmp;
514 }
515 /* Assembling master string */
516
517
518 GNUNET_asprintf (&data, "%llu;%llu;%u;%u;%u;%u;%u;%u;;;;;;;;;;;%s\n",
519 cur_lt->timestamp,
520 GNUNET_TIME_absolute_get_difference (lp[c_m].start,
521 cur_lt->timestamp).
522 rel_value_us / 1000,
523 cur_lt->total_messages_sent, cur_lt->total_bytes_sent,
524 cur_lt->total_throughput_send,
525 cur_lt->total_messages_received,
526 cur_lt->total_bytes_received,
527 cur_lt->total_throughput_recv,
528 slave_string);
529 GNUNET_free (slave_string);
530
531 if (GNUNET_SYSERR == GNUNET_DISK_file_write (f, data, strlen (data)))
532 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
533 "Cannot write data to log file `%s'\n", filename);
534 GNUNET_free (data);
535 }
536 if (GNUNET_SYSERR == GNUNET_DISK_file_close (f))
537 {
538 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close log file `%s'\n",
539 filename);
540 GNUNET_free (filename);
541 return;
542 }
543
544 write_throughput_gnuplot_script (filename, lp);
545 write_rtt_gnuplot_script (filename, lp);
546 write_bw_gnuplot_script (filename, lp);
547
548 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
549 "Data file successfully written to log file `%s'\n", filename);
550 GNUNET_free (filename);
551 }
552}
553
554
555void
556collect_log_now (void)
557{
558 struct LoggingPeer *bp;
559 struct PeerLoggingTimestep *mlt;
560 struct PeerLoggingTimestep *prev_log_mlt;
561 struct PartnerLoggingTimestep *slt;
562 struct PartnerLoggingTimestep *prev_log_slt;
563 struct BenchmarkPartner *p;
564 struct GNUNET_TIME_Relative delta;
565 int c_s;
566 int c_m;
567 unsigned int app_rtt;
568 double mult;
569
570 if (GNUNET_YES != running)
571 return;
572
573 for (c_m = 0; c_m < num_peers; c_m++)
574 {
575 bp = &lp[c_m];
576 mlt = GNUNET_new (struct PeerLoggingTimestep);
577 GNUNET_CONTAINER_DLL_insert_tail (bp->head, bp->tail, mlt);
578 prev_log_mlt = mlt->prev;
579
580 /* Collect data */
581
582 /* Current master state */
583 mlt->timestamp = GNUNET_TIME_absolute_get ();
584 mlt->total_bytes_sent = bp->peer->total_bytes_sent;
585 mlt->total_messages_sent = bp->peer->total_messages_sent;
586 mlt->total_bytes_received = bp->peer->total_bytes_received;
587 mlt->total_messages_received = bp->peer->total_messages_received;
588
589 /* Throughput */
590 if (NULL == prev_log_mlt)
591 {
592 /* Get difference to start */
593 delta = GNUNET_TIME_absolute_get_difference (lp[c_m].start,
594 mlt->timestamp);
595 }
596 else
597 {
598 /* Get difference to last timestep */
599 delta = GNUNET_TIME_absolute_get_difference (mlt->prev->timestamp,
600 mlt->timestamp);
601 }
602
603 /* Multiplication factor for throughput calculation */
604 mult = (1.0 * 1000 * 1000) / (delta.rel_value_us);
605
606 /* Total throughput */
607 if (NULL != prev_log_mlt)
608 {
609 if (mlt->total_bytes_sent - mlt->prev->total_bytes_sent > 0)
610 mlt->total_throughput_send = mult * (mlt->total_bytes_sent
611 - mlt->prev->total_bytes_sent);
612 else
613 mlt->total_throughput_send = prev_log_mlt->total_throughput_send; /* no msgs send */
614
615 if (mlt->total_bytes_received - mlt->prev->total_bytes_received > 0)
616 mlt->total_throughput_recv = mult * (mlt->total_bytes_received
617 - mlt->prev->total_bytes_received);
618 else
619 mlt->total_throughput_recv = prev_log_mlt->total_throughput_recv; /* no msgs received */
620 }
621 else
622 {
623 mlt->total_throughput_send = mult * mlt->total_bytes_sent;
624 mlt->total_throughput_send = mult * mlt->total_bytes_received;
625 }
626
627 mlt->slaves_log = GNUNET_malloc (bp->peer->num_partners
628 * sizeof(struct PartnerLoggingTimestep));
629
630 for (c_s = 0; c_s < bp->peer->num_partners; c_s++)
631 {
632 p = &bp->peer->partners[c_s];
633 slt = &mlt->slaves_log[c_s];
634
635 slt->slave = p->dest;
636 /* Bytes sent from master to this slave */
637 slt->total_bytes_sent = p->bytes_sent;
638 /* Messages sent from master to this slave */
639 slt->total_messages_sent = p->messages_sent;
640 /* Bytes master received from this slave */
641 slt->total_bytes_received = p->bytes_received;
642 /* Messages master received from this slave */
643 slt->total_messages_received = p->messages_received;
644 slt->total_app_rtt = p->total_app_rtt;
645 /* ats performance information */
646 slt->ats_cost_lan = p->ats_cost_lan;
647 slt->ats_cost_wan = p->ats_cost_wan;
648 slt->ats_cost_wlan = p->ats_cost_wlan;
649 slt->ats_delay = p->ats_delay;
650 slt->ats_distance = p->ats_distance;
651 slt->ats_network_type = p->ats_network_type;
652 slt->ats_utilization_down = p->ats_utilization_down;
653 slt->ats_utilization_up = p->ats_utilization_up;
654 slt->bandwidth_in = p->bandwidth_in;
655 slt->bandwidth_out = p->bandwidth_out;
656
657 /* Total application level rtt */
658 if (NULL == prev_log_mlt)
659 {
660 if (0 != slt->total_messages_sent)
661 app_rtt = slt->total_app_rtt / slt->total_messages_sent;
662 else
663 app_rtt = 0;
664 }
665 else
666 {
667 prev_log_slt = &prev_log_mlt->slaves_log[c_s];
668 if ((slt->total_messages_sent - prev_log_slt->total_messages_sent) > 0)
669 app_rtt = (slt->total_app_rtt - prev_log_slt->total_app_rtt)
670 / (slt->total_messages_sent
671 - prev_log_slt->total_messages_sent);
672 else
673 app_rtt = prev_log_slt->app_rtt; /* No messages were */
674 }
675 slt->app_rtt = app_rtt;
676
677 /* Partner throughput */
678 if (NULL != prev_log_mlt)
679 {
680 prev_log_slt = &prev_log_mlt->slaves_log[c_s];
681 if (slt->total_bytes_sent - prev_log_slt->total_bytes_sent > 0)
682 slt->throughput_sent = mult * (slt->total_bytes_sent
683 - prev_log_slt->total_bytes_sent);
684 else
685 slt->throughput_sent = prev_log_slt->throughput_sent; /* no msgs send */
686
687 if (slt->total_bytes_received - prev_log_slt->total_bytes_received > 0)
688 slt->throughput_recv = mult * (slt->total_bytes_received
689 - prev_log_slt->total_bytes_received);
690 else
691 slt->throughput_recv = prev_log_slt->throughput_recv; /* no msgs received */
692 }
693 else
694 {
695 slt->throughput_sent = mult * slt->total_bytes_sent;
696 slt->throughput_sent = mult * slt->total_bytes_received;
697 }
698
699 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
700 "Master [%u]: slave [%u]\n",
701 bp->peer->no, p->dest->no);
702 }
703 }
704}
705
706
707static void
708collect_log_task (void *cls)
709{
710 log_task = NULL;
711 collect_log_now ();
712 log_task = GNUNET_SCHEDULER_add_delayed (frequency,
713 &collect_log_task, NULL);
714}
715
716
717void
718perf_logging_stop ()
719{
720 int c_m;
721 struct PeerLoggingTimestep *cur;
722
723 if (GNUNET_YES != running)
724 return;
725
726 if (NULL != log_task)
727 {
728 GNUNET_SCHEDULER_cancel (log_task);
729 log_task = NULL;
730 }
731 collect_log_task (NULL);
732
733 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
734 _ ("Stop logging\n"));
735
736 write_to_file ();
737
738 for (c_m = 0; c_m < num_peers; c_m++)
739 {
740 while (NULL != (cur = lp[c_m].head))
741 {
742 GNUNET_CONTAINER_DLL_remove (lp[c_m].head, lp[c_m].tail, cur);
743 GNUNET_free (cur->slaves_log);
744 GNUNET_free (cur);
745 }
746 }
747
748 GNUNET_free (lp);
749}
750
751
752void
753perf_logging_start (struct GNUNET_TIME_Relative log_frequency,
754 char *testname, struct BenchmarkPeer *masters, int
755 num_masters)
756{
757 int c_m;
758
759 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
760 _ ("Start logging `%s'\n"), testname);
761
762 num_peers = num_masters;
763 name = testname;
764 frequency = log_frequency;
765
766 lp = GNUNET_malloc (num_masters * sizeof(struct LoggingPeer));
767
768 for (c_m = 0; c_m < num_masters; c_m++)
769 {
770 lp[c_m].peer = &masters[c_m];
771 lp[c_m].start = GNUNET_TIME_absolute_get ();
772 }
773
774 /* Schedule logging task */
775 log_task = GNUNET_SCHEDULER_add_now (&collect_log_task, NULL);
776 running = GNUNET_YES;
777}
778
779
780/* end of file perf_ats_logging.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-18 01:31:19 +0000