GNUnet  0.19.2
gnunet-cadet-profiler.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2011 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  */
25 #include "platform.h"
26 #include <stdio.h>
27 #include "cadet_test_lib.h"
28 #include "gnunet_cadet_service.h"
30 
31 
32 #define PING 1
33 #define PONG 2
34 
35 
39 #define PING_PERIOD 500
40 
44 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
45 
49 #define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
50 
54 #define number_rounds sizeof(rounds) / sizeof(rounds[0])
55 
59 static float rounds[] = { 0.8, 0.6, 0.8, 0.5, 0.3, 0.8, 0.0 };
60 
65 {
70 
74  uint32_t counter;
75 
80 
84  uint32_t round_number;
85 };
86 
90 struct CadetPeer
91 {
96 
100  struct GNUNET_PeerIdentity id;
101 
106 
111 
116 
121 
126 
131 
135  int up;
136 
140  struct CadetPeer *dest;
141 
146 
151 
155  struct GNUNET_CADET_TransmitHandle *ping_ntr;
156 
159  unsigned int pongs[number_rounds];
160  unsigned int pings[number_rounds];
161 };
162 
166 static struct GNUNET_TIME_Relative round_time;
167 
172 
177 
182 
186 static struct CadetPeer *peers;
187 
191 static unsigned int p_ids;
192 
196 static unsigned long long peers_total;
197 
201 static unsigned long long peers_running;
202 
206 static unsigned long long peers_pinging;
207 
212 
217 
222 
226 static unsigned int current_round;
227 
231 static int do_warmup;
232 
236 static unsigned int peers_warmup;
237 
241 static int test_finished;
242 
247 
248 
257 static void
258 start_test (void *cls);
259 
260 
268 static struct GNUNET_TIME_Relative
269 delay_ms_rnd (unsigned int max)
270 {
271  unsigned int rnd;
272 
275 }
276 
277 
285 static unsigned int
287 {
288  return peer - peers;
289 }
290 
291 
295 static void
297 {
298  struct CadetPeer *peer;
299  unsigned int i;
300  unsigned int j;
301 
302  for (i = 0; i < number_rounds; i++)
303  {
304  for (j = 0; j < peers_pinging; j++)
305  {
306  peer = &peers[j];
307  fprintf (stdout,
308  "ROUND %3u PEER %3u: %10.2f / %10.2f, PINGS: %3u, PONGS: %3u\n",
309  i, j, peer->mean[i], sqrt (peer->var[i] / (peer->pongs[i] - 1)),
310  peer->pings[i], peer->pongs[i]);
311  }
312  }
313 }
314 
315 
321 static void
323 {
324  long line = (long) cls;
325  unsigned int i;
326 
328  "disconnecting cadet service, called from line %ld\n",
329  line);
330  disconnect_task = NULL;
331  for (i = 0; i < peers_total; i++)
332  {
333  if (NULL != peers[i].op)
335 
336  if (peers[i].up != GNUNET_YES)
337  continue;
338 
339  if (NULL != peers[i].ch)
340  {
342  "%u: channel %p\n", i, peers[i].ch);
344  }
345  if (NULL != peers[i].warmup_ch)
346  {
348  "%u: warmup channel %p\n",
349  i, peers[i].warmup_ch);
351  }
352  if (NULL != peers[i].incoming_ch)
353  {
355  "%u: incoming channel %p\n",
356  i, peers[i].incoming_ch);
358  }
359  }
362 }
363 
364 
370 static void
371 shutdown_task (void *cls)
372 {
374  "Ending test.\n");
375  if (NULL != disconnect_task)
376  {
379  (void *) __LINE__);
380  }
381  if (NULL != round_task)
382  {
384  round_task = NULL;
385  }
386  if (NULL != test_task)
387  {
389  test_task = NULL;
390  }
391 }
392 
393 
399 static void
401 {
402  if (disconnect_task != NULL)
403  {
406  (void *) line);
407  }
408 }
409 
410 
420 static void
421 stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
422 {
423  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "... collecting statistics done.\n");
425 
426  if (NULL != disconnect_task)
429  (void *) __LINE__);
430 }
431 
432 
444 static int
445 stats_iterator (void *cls,
446  const struct GNUNET_TESTBED_Peer *peer,
447  const char *subsystem,
448  const char *name,
449  uint64_t value,
450  int is_persistent)
451 {
452  uint32_t i;
453 
456  " STATS %u - %s [%s]: %llu\n",
457  i, subsystem, name,
458  (unsigned long long) value);
459 
460  return GNUNET_OK;
461 }
462 
463 
469 static void
470 collect_stats (void *cls)
471 {
473  "Start collecting statistics...\n");
476  NULL, NULL,
478  &stats_cont, NULL);
479 }
480 
481 
487 static void
488 finish_profiler (void *cls)
489 {
491  show_end_data ();
493 }
494 
495 
501 static void
502 adjust_running_peers (unsigned int target)
503 {
505  unsigned int delta;
506  unsigned int run;
507  unsigned int i;
508  unsigned int r;
509 
510  GNUNET_assert (target <= peers_total);
511 
512  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "adjust peers to %u\n", target);
513  if (target > peers_running)
514  {
515  delta = target - peers_running;
516  run = GNUNET_YES;
517  }
518  else
519  {
520  delta = peers_running - target;
521  run = GNUNET_NO;
522  }
523 
524  for (i = 0; i < delta; i++)
525  {
526  do
527  {
530  r += peers_pinging;
531  }
532  while (peers[r].up == run || NULL != peers[r].incoming);
533  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "St%s peer %u: %s\n",
534  run ? "arting" : "opping", r, GNUNET_i2s (&peers[r].id));
535 
536  if (NULL != peers[r].ping_task)
537  {
538  GNUNET_SCHEDULER_cancel (peers[r].ping_task);
539  peers[r].ping_task = NULL;
540  }
541  if (NULL != peers[r].ping_ntr)
542  {
543  GNUNET_CADET_notify_transmit_ready_cancel (peers[r].ping_ntr);
544  peers[r].ping_ntr = NULL;
545  }
546  peers[r].up = run;
547 
548  if (NULL != peers[r].ch)
550  peers[r].ch = NULL;
551  if (NULL != peers[r].dest)
552  {
553  if (NULL != peers[r].dest->incoming_ch)
554  GNUNET_CADET_channel_destroy (peers[r].dest->incoming_ch);
555  peers[r].dest->incoming_ch = NULL;
556  }
557 
559  "cadet", NULL, NULL, run);
560  GNUNET_break (NULL != op);
561  peers_running += run ? 1 : -1;
563  }
564 }
565 
566 
572 static void
573 next_rnd (void *cls)
574 {
576  "ROUND %u\n",
577  current_round);
578  if (0.0 == rounds[current_round])
579  {
580  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Finishing\n");
582  return;
583  }
585  current_round++;
586 
588  &next_rnd,
589  NULL);
590 }
591 
592 
602 static size_t
603 tmt_rdy_ping (void *cls, size_t size, void *buf);
604 
605 
613 static size_t
614 tmt_rdy_pong (void *cls, size_t size, void *buf)
615 {
616  struct CadetPingMessage *ping = cls;
617  struct CadetPingMessage *pong;
618 
619  if ((0 == size) || (NULL == buf))
620  {
621  GNUNET_free (ping);
622  return 0;
623  }
624  pong = (struct CadetPingMessage *) buf;
625  GNUNET_memcpy (pong, ping, sizeof(*ping));
626  pong->header.type = htons (PONG);
627 
628  GNUNET_free (ping);
629  return sizeof(*ping);
630 }
631 
632 
638 static void
639 ping (void *cls)
640 {
641  struct CadetPeer *peer = cls;
642 
643  peer->ping_task = NULL;
644  if (GNUNET_YES == test_finished)
645  return;
647  "%u -> %u (%u)\n",
648  get_index (peer),
649  get_index (peer->dest),
650  peer->data_sent);
651  peer->ping_ntr = GNUNET_CADET_notify_transmit_ready (peer->ch, GNUNET_NO,
653  sizeof(struct
655  &tmt_rdy_ping, peer);
656 }
657 
658 
663 static void
664 pong (struct GNUNET_CADET_Channel *channel,
665  const struct CadetPingMessage *ping)
666 {
667  struct CadetPingMessage *copy;
668 
669  copy = GNUNET_new (struct CadetPingMessage);
670  *copy = *ping;
671  GNUNET_CADET_notify_transmit_ready (channel, GNUNET_NO,
673  sizeof(struct CadetPingMessage),
674  &tmt_rdy_pong, copy);
675 }
676 
677 
685 static size_t
686 tmt_rdy_ping (void *cls, size_t size, void *buf)
687 {
688  struct CadetPeer *peer = cls;
689  struct CadetPingMessage *msg = buf;
690 
691  peer->ping_ntr = NULL;
693  "tmt_rdy called, filling buffer\n");
694  if ((size < sizeof(struct CadetPingMessage)) || (NULL == buf))
695  {
698  "size %u, buf %p, data_sent %u, data_received %u\n",
699  (unsigned int) size,
700  buf,
701  peer->data_sent,
702  peer->data_received);
703 
704  return 0;
705  }
707  "Sending: msg %d\n",
708  peer->data_sent);
709  msg->header.size = htons (size);
710  msg->header.type = htons (PING);
711  msg->counter = htonl (peer->data_sent++);
712  msg->round_number = htonl (current_round);
714  peer->pings[current_round]++;
716  &ping, peer);
717 
718  return sizeof(struct CadetPingMessage);
719 }
720 
721 
732 int
733 ping_handler (void *cls, struct GNUNET_CADET_Channel *channel,
734  void **channel_ctx,
735  const struct GNUNET_MessageHeader *message)
736 {
737  long n = (long) cls;
738 
740  "%u got PING\n",
741  (unsigned int) n);
742  GNUNET_CADET_receive_done (channel);
743  if (GNUNET_NO == test_finished)
744  pong (channel, (struct CadetPingMessage *) message);
745 
746  return GNUNET_OK;
747 }
748 
749 
760 int
761 pong_handler (void *cls, struct GNUNET_CADET_Channel *channel,
762  void **channel_ctx,
763  const struct GNUNET_MessageHeader *message)
764 {
765  long n = (long) cls;
766  struct CadetPeer *peer;
767  struct CadetPingMessage *msg;
768  struct GNUNET_TIME_Absolute send_time;
769  struct GNUNET_TIME_Relative latency;
770  unsigned int r /* Ping round */;
771  float delta;
772 
773  GNUNET_CADET_receive_done (channel);
774  peer = &peers[n];
775 
776  msg = (struct CadetPingMessage *) message;
777 
778  send_time = GNUNET_TIME_absolute_ntoh (msg->timestamp);
779  latency = GNUNET_TIME_absolute_get_duration (send_time);
780  r = ntohl (msg->round_number);
781  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%u <- %u (%u) latency: %s\n",
782  get_index (peer),
783  get_index (peer->dest),
784  (uint32_t) ntohl (msg->counter),
786 
787  /* Online variance calculation */
788  peer->pongs[r]++;
789  delta = latency.rel_value_us - peer->mean[r];
790  peer->mean[r] = peer->mean[r] + delta / peer->pongs[r];
791  peer->var[r] += delta * (latency.rel_value_us - peer->mean[r]);
792 
793  return GNUNET_OK;
794 }
795 
796 
800 static struct GNUNET_CADET_MessageHandler handlers[] = {
801  { &ping_handler, PING, sizeof(struct CadetPingMessage) },
802  { &pong_handler, PONG, sizeof(struct CadetPingMessage) },
803  { NULL, 0, 0 }
804 };
805 
806 
819 static void *
820 incoming_channel (void *cls, struct GNUNET_CADET_Channel *channel,
821  const struct GNUNET_PeerIdentity *initiator,
822  const struct GNUNET_HashCode *port,
823  enum GNUNET_CADET_ChannelOption options)
824 {
825  long n = (long) cls;
826  struct CadetPeer *peer;
827 
829  GNUNET_assert (NULL != peer);
830  if (NULL == peers[n].incoming)
831  {
833  "WARMUP %3u: %u <= %u\n",
834  peers_warmup,
835  (unsigned int) n,
836  get_index (peer));
837  peers_warmup++;
839  return NULL;
840  if (NULL != test_task)
841  {
844  &start_test, NULL);
845  }
846  return NULL;
847  }
849  GNUNET_assert (peer->dest == &peers[n]);
851  "%u <= %u %p\n",
852  (unsigned int) n,
853  get_index (peer),
854  channel);
855  peers[n].incoming_ch = channel;
856 
857  return NULL;
858 }
859 
860 
870 static void
871 channel_cleaner (void *cls,
872  const struct GNUNET_CADET_Channel *channel,
873  void *channel_ctx)
874 {
875  long n = (long) cls;
876  struct CadetPeer *peer = &peers[n];
877 
879  "Channel %p disconnected at peer %ld\n", channel, n);
880  if (peer->ch == channel)
881  peer->ch = NULL;
882 }
883 
884 
892 static struct CadetPeer *
894 {
895  unsigned int r;
896 
897  do
898  {
900  }
901  while (NULL != peers[r].incoming);
902  peers[r].incoming = peer;
903 
904  return &peers[r];
905 }
906 
907 
916 static void
917 start_test (void *cls)
918 {
919  unsigned long i;
920 
921  test_task = NULL;
922  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Start profiler\n");
923 
924 
925  for (i = 0; i < peers_pinging; i++)
926  {
927  peers[i].dest = select_random_peer (&peers[i]);
929  &peers[i].dest->id,
930  GC_u2h (1));
931  if (NULL == peers[i].ch)
932  {
933  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Channel %lu failed\n", i);
935  return;
936  }
938  "%lu => %u %p\n",
939  i,
940  get_index (peers[i].dest),
941  peers[i].ch);
943  &ping, &peers[i]);
944  }
946  if (NULL != disconnect_task)
951  + 1),
953  (void *) __LINE__);
955  &next_rnd,
956  NULL);
957 }
958 
959 
963 static void
964 warmup (void)
965 {
966  struct CadetPeer *peer;
967  unsigned int i;
968 
969  for (i = 0; i < peers_total; i++)
970  {
971  peer = select_random_peer (NULL);
972  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "WARMUP %u => %u\n",
973  i, get_index (peer));
974  peers[i].warmup_ch =
976  GC_u2h (1));
977  if (NULL == peers[i].warmup_ch)
978  {
979  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Warmup %u failed\n", i);
981  return;
982  }
983  }
984 }
985 
986 
996 static void
997 peer_id_cb (void *cls,
999  const struct GNUNET_TESTBED_PeerInformation *pinfo,
1000  const char *emsg)
1001 {
1002  long n = (long) cls;
1003 
1004  if ((NULL == pinfo) || (NULL != emsg))
1005  {
1006  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", emsg);
1007  abort_test (__LINE__);
1008  return;
1009  }
1010  peers[n].id = *(pinfo->result.id);
1012  "%ld id: %s\n",
1013  n,
1014  GNUNET_i2s (&peers[n].id));
1018 
1020  peers[n].op = NULL;
1021 
1022  p_ids++;
1023  if (p_ids < peers_total)
1024  return;
1025  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got all IDs, starting profiler\n");
1026  if (do_warmup)
1027  {
1028  struct GNUNET_TIME_Relative delay;
1029 
1030  warmup ();
1032  100 * peers_total);
1034  return; /* start_test from incoming_channel */
1035  }
1036  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting in a second...\n");
1038  &start_test, NULL);
1039 }
1040 
1041 
1051 static void
1052 tmain (void *cls,
1054  unsigned int num_peers,
1056  struct GNUNET_CADET_Handle **cadetes)
1057 {
1058  unsigned long i;
1059 
1061  "test main\n");
1062  test_ctx = ctx;
1068  (void *) __LINE__);
1070  for (i = 0; i < peers_total; i++)
1071  {
1073  "requesting id %ld\n",
1074  i);
1075  peers[i].up = GNUNET_YES;
1076  peers[i].cadet = cadetes[i];
1077  peers[i].op =
1080  &peer_id_cb, (void *) i);
1081  }
1082  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "requested peer ids\n");
1083  /* Continues from pi_cb -> do_test */
1084 }
1085 
1086 
1090 int
1091 main (int argc, char *argv[])
1092 {
1093  static const struct GNUNET_HashCode *ports[2];
1094  const char *config_file;
1095 
1096  config_file = ".profiler.conf";
1097 
1098  if (4 > argc)
1099  {
1100  fprintf (stderr,
1101  "usage: %s ROUND_TIME PEERS PINGS [DO_WARMUP]\n",
1102  argv[0]);
1103  fprintf (stderr,
1104  "example: %s 30s 16 1 Y\n",
1105  argv[0]);
1106  return 1;
1107  }
1108 
1109  if (GNUNET_OK !=
1111  &round_time))
1112  {
1113  fprintf (stderr,
1114  "%s is not a valid time\n",
1115  argv[1]);
1116  return 1;
1117  }
1118 
1119  peers_total = atoll (argv[2]);
1120  if (2 > peers_total)
1121  {
1122  fprintf (stderr,
1123  "%s peers is not valid (> 2)\n",
1124  argv[1]);
1125  return 1;
1126  }
1128  struct CadetPeer);
1129  peers_pinging = atoll (argv[3]);
1130 
1131  if (peers_total < 2 * peers_pinging)
1132  {
1134  "not enough peers, total should be > 2 * peers_pinging\n");
1135  return 1;
1136  }
1137 
1138  do_warmup = (5 > argc || argv[4][0] != 'N');
1139 
1141  GNUNET_YES);
1142  GNUNET_assert (NULL != ids);
1143  p_ids = 0;
1145  ports[0] = GC_u2h (1);
1146  ports[1] = 0;
1147  GNUNET_CADET_TEST_run ("cadet-profiler", config_file, peers_total,
1148  &tmain, NULL, /* tmain cls */
1150  handlers, ports);
1151  GNUNET_free (peers);
1152 
1153  return 0;
1154 }
1155 
1156 
1157 /* end of gnunet-cadet-profiler.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
void GNUNET_CADET_TEST_cleanup(struct GNUNET_CADET_TEST_Context *ctx)
Clean up the testbed.
library for writing CADET tests
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run.
Definition: gnunet-abd.c:757
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
static uint16_t port
Port number.
Definition: gnunet-bcd.c:147
#define number_rounds
Total number of rounds.
static struct GNUNET_TESTBED_Peer ** testbed_handles
Testbed peer handles.
int main(int argc, char *argv[])
Main: start profiler.
static struct GNUNET_TIME_Relative delay_ms_rnd(unsigned int max)
Calculate a random delay.
#define PONG
static unsigned int current_round
Round number.
static float rounds[]
Ratio of peers active.
static unsigned long long peers_total
Total number of peers.
static int do_warmup
Do preconnect? (Each peer creates a tunnel to one other peer).
static void show_end_data(void)
Show the results of the test (banwidth achieved) and log them to GAUGER.
static unsigned int get_index(struct CadetPeer *peer)
Get the index of a peer in the peers array.
static struct GNUNET_TIME_Relative round_time
Duration of each round.
#define PING
static void disconnect_cadet_peers(void *cls)
Disconnect from cadet services af all peers, call shutdown.
static struct GNUNET_CONTAINER_MultiPeerMap * ids
GNUNET_PeerIdentity -> CadetPeer.
static void start_test(void *cls)
START THE TEST ITSELF, AS WE ARE CONNECTED TO THE CADET SERVICES.
static void next_rnd(void *cls)
Move to next round.
int pong_handler(void *cls, struct GNUNET_CADET_Channel *channel, void **channel_ctx, const struct GNUNET_MessageHeader *message)
Function is called whenever a PONG message is received.
static void shutdown_task(void *cls)
Shut down peergroup, clean up.
int ping_handler(void *cls, struct GNUNET_CADET_Channel *channel, void **channel_ctx, const struct GNUNET_MessageHeader *message)
Function is called whenever a PING message is received.
static void * incoming_channel(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator, const struct GNUNET_HashCode *port, enum GNUNET_CADET_ChannelOption options)
Method called whenever another peer has added us to a channel the other peer initiated.
static void tmain(void *cls, struct GNUNET_CADET_TEST_Context *ctx, unsigned int num_peers, struct GNUNET_TESTBED_Peer **testbed_peers, struct GNUNET_CADET_Handle **cadetes)
test main: start test when all peers are connected
static struct GNUNET_TESTBED_Operation * stats_op
Testbed Operation (to get stats).
static void peer_id_cb(void *cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
Callback to be called when the requested peer information is available.
static struct CadetPeer * select_random_peer(struct CadetPeer *peer)
Select a random peer that has no incoming channel.
static struct GNUNET_SCHEDULER_Task * round_task
Task running each round of the benchmark.
static struct CadetPeer * peers
Operation to get peer ids.
static void finish_profiler(void *cls)
Finish profiler normally.
static void channel_cleaner(void *cls, const struct GNUNET_CADET_Channel *channel, void *channel_ctx)
Function called whenever an inbound channel is destroyed.
static void abort_test(long line)
Finish test normally: schedule disconnect and shutdown.
static unsigned long long peers_pinging
Number of peers doing pings.
static size_t tmt_rdy_pong(void *cls, size_t size, void *buf)
Transmit pong callback.
#define SHORT_TIME
Time to wait for stuff that should be rather fast.
static unsigned int p_ids
Peer ids counter.
static void pong(struct GNUNET_CADET_Channel *channel, const struct CadetPingMessage *ping)
Reply with a pong to origin.
static struct GNUNET_CADET_TEST_Context * test_ctx
Test context (to shut down).
static int stats_iterator(void *cls, const struct GNUNET_TESTBED_Peer *peer, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Process statistic values.
static struct GNUNET_SCHEDULER_Task * disconnect_task
Task called to disconnect peers, before shutdown.
static void ping(void *cls)
Send a ping to destination.
static struct GNUNET_SCHEDULER_Task * test_task
Task to perform tests.
static void adjust_running_peers(unsigned int target)
Set the total number of running peers.
static void collect_stats(void *cls)
Task check that keepalives were sent and received.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static unsigned long long peers_running
Number of currently running peers.
static unsigned int peers_warmup
Warmup progress.
static void stats_cont(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
Stats callback.
static void warmup(void)
Do warmup: create some channels to spread information about the topology.
#define PING_PERIOD
Paximum ping period in milliseconds.
static size_t tmt_rdy_ping(void *cls, size_t size, void *buf)
Transmit ping callback.
static int test_finished
Flag to notify callbacks not to generate any new traffic anymore.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static unsigned int num_peers
static char * line
Desired phone line (string to be converted to a hash).
static char * value
Value of the record to add/remove.
static struct GNUNET_TESTBED_Peer ** testbed_peers
Handles to all of the running peers.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
static char buf[2048]
static char * subsystem
Set to subsystem that we're going to get stats for (or NULL for all).
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
CADET service; establish channels to distant peers.
API to create, modify and access statistics.
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1015
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:872
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
const struct GNUNET_HashCode * GC_u2h(uint32_t port)
Transitional function to convert an unsigned int port to a hash value.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:534
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1268
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1303
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:944
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1241
enum GNUNET_GenericReturnValue GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:260
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2021
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_get_information(struct GNUNET_TESTBED_Peer *peer, enum GNUNET_TESTBED_PeerInformationType pit, GNUNET_TESTBED_PeerInfoCallback cb, void *cb_cls)
Request information about a peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_manage_service(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls, unsigned int start)
Start or stop given service at a peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_get_statistics(unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers, const char *subsystem, const char *name, GNUNET_TESTBED_StatisticsIterator proc, GNUNET_TESTBED_OperationCompletionCallback cont, void *cls)
Convenience method that iterates over all (running) peers and retrieves all statistics from each peer...
uint32_t GNUNET_TESTBED_get_index(const struct GNUNET_TESTBED_Peer *peer)
Return the index of the peer inside of the total peer array, aka.
Definition: testbed_api.c:2291
@ GNUNET_TESTBED_PIT_IDENTITY
What is the identity of the peer? Returns a 'const struct GNUNET_PeerIdentity *'.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
#define GNUNET_TIME_UNIT_SECONDS
One second.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:484
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:569
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
#define max(x, y)
static unsigned int size
Size of the "table".
Definition: peer.c:68
long long atoll(const char *nptr)
const char * name
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36
Peer description.
struct GNUNET_SCHEDULER_Task * ping_task
Task to do the next ping.
struct GNUNET_CADET_Channel * ch
Channel handle for the root peer.
struct CadetPeer * dest
Destinaton to ping.
unsigned int pings[sizeof(rounds)/sizeof(rounds[0])]
struct CadetPeer * incoming
Incoming channel for pings.
int data_received
Number of payload packets received.
struct GNUNET_CADET_Channel * warmup_ch
Channel handle for a warmup channel.
struct GNUNET_PeerIdentity id
Peer ID.
int data_sent
Number of payload packes sent.
float mean[sizeof(rounds)/sizeof(rounds[0])]
unsigned int pongs[sizeof(rounds)/sizeof(rounds[0])]
int up
Is peer up?
struct GNUNET_CADET_TransmitHandle * ping_ntr
NTR operation for the next ping.
struct GNUNET_TESTBED_Operation * op
Testbed Operation (to get peer id, etc).
float var[sizeof(rounds)/sizeof(rounds[0])]
struct GNUNET_CADET_Handle * cadet
Cadet handle for the root peer.
struct GNUNET_CADET_Channel * incoming_ch
Channel handle for the dest peer.
Message type for pings.
uint32_t counter
Message number.
struct GNUNET_MessageHeader header
Header.
struct GNUNET_TIME_AbsoluteNBO timestamp
Time the message was sent.
uint32_t round_number
Round number.
Opaque handle to a channel.
Definition: cadet.h:116
Opaque handle to the service.
Definition: cadet_api.c:39
Test context for a CADET Test.
Internal representation of the hash map.
A 512-bit hashcode.
Header for all communications.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Opaque handle to an abstract operation to be executed by the testing framework.
Data returned from GNUNET_TESTBED_peer_get_information.
union GNUNET_TESTBED_PeerInformation::@49 result
The result of the get information operation; Choose according to the pit.
struct GNUNET_PeerIdentity * id
The identity of the peer.
A peer controlled by the testing framework.
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.