gnunet-cadet-profiler.c File Reference

Profiler for cadet experiments. More...

#include "platform.h"
#include <stdio.h>
#include "cadet_test_lib.h"
#include "gnunet_cadet_service.h"
#include "gnunet_statistics_service.h"

Include dependency graph for gnunet-cadet-profiler.c:

Go to the source code of this file.

Data Structures
struct	CadetPingMessage
	Message type for pings. More...
struct	CadetPeer
	Peer description. More...

Macros
#define	PING   1
#define	PONG   2
#define	PING_PERIOD   500
	Paximum ping period in milliseconds. More...
#define	TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
	How long until we give up on connecting the peers? More...
#define	SHORT_TIME   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
	Time to wait for stuff that should be rather fast. More...
#define	number_rounds   sizeof(rounds) / sizeof(rounds[0])
	Total number of rounds. More...

Functions
static void	start_test (void *cls)
	START THE TEST ITSELF, AS WE ARE CONNECTED TO THE CADET SERVICES. More...
static struct GNUNET_TIME_Relative	delay_ms_rnd (unsigned int max)
	Calculate a random delay. More...
static unsigned int	get_index (struct CadetPeer *peer)
	Get the index of a peer in the peers array. More...
static void	show_end_data (void)
	Show the results of the test (banwidth achieved) and log them to GAUGER. More...
static void	disconnect_cadet_peers (void *cls)
	Disconnect from cadet services af all peers, call shutdown. More...
static void	shutdown_task (void *cls)
	Shut down peergroup, clean up. More...
static void	abort_test (long line)
	Finish test normally: schedule disconnect and shutdown. More...
static void	stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
	Stats callback. More...
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. More...
static void	collect_stats (void *cls)
	Task check that keepalives were sent and received. More...
static void	finish_profiler (void *cls)
	Finish profiler normally. More...
static void	adjust_running_peers (unsigned int target)
	Set the total number of running peers. More...
static void	next_rnd (void *cls)
	Move to next round. More...
static size_t	tmt_rdy_ping (void *cls, size_t size, void *buf)
	Transmit ping callback. More...
static size_t	tmt_rdy_pong (void *cls, size_t size, void *buf)
	Transmit pong callback. More...
static void	ping (void *cls)
	Send a ping to destination. More...
static void	pong (struct GNUNET_CADET_Channel *channel, const struct CadetPingMessage *ping)
	Reply with a pong to origin. More...
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. More...
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. More...
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. More...
static void	channel_cleaner (void *cls, const struct GNUNET_CADET_Channel *channel, void *channel_ctx)
	Function called whenever an inbound channel is destroyed. More...
static struct CadetPeer *	select_random_peer (struct CadetPeer *peer)
	Select a random peer that has no incoming channel. More...
static void	warmup (void)
	Do warmup: create some channels to spread information about the topology. More...
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. More...
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 More...
int	main (int argc, char *argv[])
	Main: start profiler. More...

Variables
static float	rounds [] = { 0.8, 0.6, 0.8, 0.5, 0.3, 0.8, 0.0 }
	Ratio of peers active. More...
static struct GNUNET_TIME_Relative	round_time
	Duration of each round. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	ids
	GNUNET_PeerIdentity -> CadetPeer. More...
static struct GNUNET_TESTBED_Peer **	testbed_handles
	Testbed peer handles. More...
static struct GNUNET_TESTBED_Operation *	stats_op
	Testbed Operation (to get stats). More...
static struct CadetPeer *	peers
	Operation to get peer ids. More...
static unsigned int	p_ids
	Peer ids counter. More...
static unsigned long long	peers_total
	Total number of peers. More...
static unsigned long long	peers_running
	Number of currently running peers. More...
static unsigned long long	peers_pinging
	Number of peers doing pings. More...
static struct GNUNET_CADET_TEST_Context *	test_ctx
	Test context (to shut down). More...
static struct GNUNET_SCHEDULER_Task *	disconnect_task
	Task called to disconnect peers, before shutdown. More...
static struct GNUNET_SCHEDULER_Task *	test_task
	Task to perform tests. More...
static unsigned int	current_round
	Round number. More...
static int	do_warmup
	Do preconnect? (Each peer creates a tunnel to one other peer). More...
static unsigned int	peers_warmup
	Warmup progress. More...
static int	test_finished
	Flag to notify callbacks not to generate any new traffic anymore. More...
static struct GNUNET_SCHEDULER_Task *	round_task
	Task running each round of the benchmark. More...
static struct GNUNET_CADET_MessageHandler	handlers []
	Handlers, for diverse services. More...

Detailed Description

Profiler for cadet experiments.

Definition in file gnunet-cadet-profiler.c.

Macro Definition Documentation

PING

#define PING   1

Definition at line 32 of file gnunet-cadet-profiler.c.

PONG

#define PONG   2

Definition at line 33 of file gnunet-cadet-profiler.c.

PING_PERIOD

#define PING_PERIOD   500

Paximum ping period in milliseconds.

Real period = rand (0, PING_PERIOD)

Definition at line 39 of file gnunet-cadet-profiler.c.

TIMEOUT

#define TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)

How long until we give up on connecting the peers?

Definition at line 44 of file gnunet-cadet-profiler.c.

SHORT_TIME

#define SHORT_TIME   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)

Time to wait for stuff that should be rather fast.

Definition at line 49 of file gnunet-cadet-profiler.c.

number_rounds

#define number_rounds   sizeof(rounds) / sizeof(rounds[0])

Total number of rounds.

Definition at line 54 of file gnunet-cadet-profiler.c.

Function Documentation

start_test()

static void start_test ( void *  cls )

static

START THE TEST ITSELF, AS WE ARE CONNECTED TO THE CADET SERVICES.

Testcase continues when the root receives confirmation of connected peers, on callback function ch.

Parameters

cls	Closure (unused).

Definition at line 917 of file gnunet-cadet-profiler.c.

{
  unsigned long i;
 
  test_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Start profiler\n");
 
 
  for (i = 0; i < peers_pinging; i++)
  {
    peers[i].dest = select_random_peer (&peers[i]);
    peers[i].ch = GNUNET_CADET_channel_create (peers[i].cadet, NULL,
                                               &peers[i].dest->id,
                                               GC_u2h (1));
    if (NULL == peers[i].ch)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Channel %lu failed\n", i);
      GNUNET_CADET_TEST_cleanup (test_ctx);
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "%lu => %u %p\n",
                i,
                get_index (peers[i].dest),
                peers[i].ch);
    peers[i].ping_task = GNUNET_SCHEDULER_add_delayed (delay_ms_rnd (2000),
                                                       &ping, &peers[i]);
  }
  peers_running = peers_total;
  if (NULL != disconnect_task)
    GNUNET_SCHEDULER_cancel (disconnect_task);
  disconnect_task =
    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (round_time,
                                                                 number_rounds
                                                                 + 1),
                                  &disconnect_cadet_peers,
                                  (void *) __LINE__);
  round_task = GNUNET_SCHEDULER_add_delayed (round_time,
                                             &next_rnd,
                                             NULL);
}

References cadet, CadetPeer::ch, ch, delay_ms_rnd(), warningfilter::dest, CadetPeer::dest, disconnect_cadet_peers(), disconnect_task, GC_u2h(), get_index(), GNUNET_CADET_channel_create(), GNUNET_CADET_TEST_cleanup(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_multiply(), next_rnd(), number_rounds, peers, peers_pinging, peers_running, peers_total, ping(), CadetPeer::ping_task, round_task, round_time, select_random_peer(), test_ctx, and test_task.

Referenced by incoming_channel(), and peer_id_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

delay_ms_rnd()

static struct GNUNET_TIME_Relative delay_ms_rnd ( unsigned int  max )

static

Calculate a random delay.

Parameters

max	Exclusive maximum, in ms.

Returns

A time between 0 a max-1 ms.

Definition at line 258 of file gnunet-cadet-profiler.c.

{
  unsigned int rnd;
 
  rnd = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max);
  return GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, rnd);
}

Referenced by start_test(), and tmt_rdy_ping().

Here is the caller graph for this function:

get_index()

static unsigned int get_index ( struct CadetPeer *  peer )

static

Get the index of a peer in the peers array.

Parameters

peer	Peer whose index to get.

Returns

Index of peer in peers.

Definition at line 286 of file gnunet-cadet-profiler.c.

{
  return peer - peers;
}

References peer, and peers.

Referenced by incoming_channel(), ping(), start_test(), and warmup().

Here is the caller graph for this function:

show_end_data()

static void show_end_data ( void  )

static

Show the results of the test (banwidth achieved) and log them to GAUGER.

Definition at line 296 of file gnunet-cadet-profiler.c.

{
  struct CadetPeer *peer;
  unsigned int i;
  unsigned int j;
 
  for (i = 0; i < number_rounds; i++)
  {
    for (j = 0; j < peers_pinging; j++)
    {
      peer = &peers[j];
      fprintf (stdout,
               "ROUND %3u PEER %3u: %10.2f / %10.2f, PINGS: %3u, PONGS: %3u\n",
               i, j, peer->mean[i], sqrt (peer->var[i] / (peer->pongs[i] - 1)),
               peer->pings[i], peer->pongs[i]);
    }
  }
}

References number_rounds, peer, peers, and peers_pinging.

Referenced by finish_profiler().

Here is the caller graph for this function:

disconnect_cadet_peers()

static void disconnect_cadet_peers ( void *  cls )

static

Disconnect from cadet services af all peers, call shutdown.

Parameters

cls	Closure (unused).

Definition at line 322 of file gnunet-cadet-profiler.c.

{
  long line = (long) cls;
  unsigned int i;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "disconnecting cadet service, called from line %ld\n",
              line);
  disconnect_task = NULL;
  for (i = 0; i < peers_total; i++)
  {
    if (NULL != peers[i].op)
      GNUNET_TESTBED_operation_done (peers[i].op);
 
    if (peers[i].up != GNUNET_YES)
      continue;
 
    if (NULL != peers[i].ch)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "%u: channel %p\n", i, peers[i].ch);
      GNUNET_CADET_channel_destroy (peers[i].ch);
    }
    if (NULL != peers[i].warmup_ch)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "%u: warmup channel %p\n",
                  i, peers[i].warmup_ch);
      GNUNET_CADET_channel_destroy (peers[i].warmup_ch);
    }
    if (NULL != peers[i].incoming_ch)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "%u: incoming channel %p\n",
                  i, peers[i].incoming_ch);
      GNUNET_CADET_channel_destroy (peers[i].incoming_ch);
    }
  }
  GNUNET_CADET_TEST_cleanup (test_ctx);
  GNUNET_SCHEDULER_shutdown ();
}

References ch, disconnect_task, GNUNET_CADET_channel_destroy(), GNUNET_CADET_TEST_cleanup(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_YES, CadetPeer::incoming_ch, line, op, peers, peers_total, test_ctx, CadetPeer::up, and CadetPeer::warmup_ch.

Referenced by abort_test(), shutdown_task(), start_test(), stats_cont(), and tmain().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Shut down peergroup, clean up.

Parameters

cls	Closure (unused).

Definition at line 371 of file gnunet-cadet-profiler.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Ending test.\n");
  if (NULL != disconnect_task)
  {
    GNUNET_SCHEDULER_cancel (disconnect_task);
    disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
                                                (void *) __LINE__);
  }
  if (NULL != round_task)
  {
    GNUNET_SCHEDULER_cancel (round_task);
    round_task = NULL;
  }
  if (NULL != test_task)
  {
    GNUNET_SCHEDULER_cancel (test_task);
    test_task = NULL;
  }
}

References disconnect_cadet_peers(), disconnect_task, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), round_task, and test_task.

Referenced by tmain().

Here is the call graph for this function:

Here is the caller graph for this function:

abort_test()

static void abort_test ( long  line )

static

Finish test normally: schedule disconnect and shutdown.

Parameters

line	Line in the code the abort is requested from (LINE).

Definition at line 400 of file gnunet-cadet-profiler.c.

{
  if (disconnect_task != NULL)
  {
    GNUNET_SCHEDULER_cancel (disconnect_task);
    disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
                                                (void *) line);
  }
}

References disconnect_cadet_peers(), disconnect_task, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), and line.

Referenced by peer_id_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

stats_cont()

static void stats_cont ( void *  cls, struct GNUNET_TESTBED_Operation *  op, const char *  emsg  )

static

Stats callback.

Finish the stats testbed operation and when all stats have been iterated, shutdown the test.

Parameters

cls	closure
op	the operation that has been finished
emsg	error message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 421 of file gnunet-cadet-profiler.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "... collecting statistics done.\n");
  GNUNET_TESTBED_operation_done (stats_op);
 
  if (NULL != disconnect_task)
    GNUNET_SCHEDULER_cancel (disconnect_task);
  disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
                                              (void *) __LINE__);
}

References disconnect_cadet_peers(), disconnect_task, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_operation_done(), and stats_op.

Referenced by collect_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

stats_iterator()

static int stats_iterator ( void *  cls, const struct GNUNET_TESTBED_Peer *  peer, const char *  subsystem, const char *  name, uint64_t  value, int  is_persistent  )

static

Process statistic values.

Parameters

cls	closure
peer	the peer the statistic belong to
subsystem	name of subsystem that created the statistic
name	the name of the datum
value	the current value
is_persistent	GNUNET_YES if the value is persistent, GNUNET_NO if not

Returns

GNUNET_OK to continue, GNUNET_SYSERR to abort iteration

Definition at line 445 of file gnunet-cadet-profiler.c.

{
  uint32_t i;
 
  i = GNUNET_TESTBED_get_index (peer);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              " STATS %u - %s [%s]: %llu\n",
              i, subsystem, name,
              (unsigned long long) value);
 
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_TESTBED_get_index(), name, peer, subsystem, and value.

Referenced by collect_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_stats()

static void collect_stats ( void *  cls )

static

Task check that keepalives were sent and received.

Parameters

cls	Closure (NULL).

Definition at line 470 of file gnunet-cadet-profiler.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Start collecting statistics...\n");
  stats_op = GNUNET_TESTBED_get_statistics (peers_total,
                                            testbed_handles,
                                            NULL, NULL,
                                            &stats_iterator,
                                            &stats_cont, NULL);
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_TESTBED_get_statistics(), peers_total, stats_cont(), stats_iterator(), stats_op, and testbed_handles.

Referenced by finish_profiler().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_profiler()

static void finish_profiler ( void *  cls )

static

Finish profiler normally.

Signal finish and start collecting stats.

Parameters

cls	Closure (unused).

Definition at line 488 of file gnunet-cadet-profiler.c.

{
  test_finished = GNUNET_YES;
  show_end_data ();
  GNUNET_SCHEDULER_add_now (&collect_stats, NULL);
}

References collect_stats(), GNUNET_SCHEDULER_add_now(), GNUNET_YES, show_end_data(), and test_finished.

Referenced by next_rnd().

Here is the call graph for this function:

Here is the caller graph for this function:

adjust_running_peers()

static void adjust_running_peers ( unsigned int  target )

static

Set the total number of running peers.

Parameters

target

Desired number of running peers.

Definition at line 502 of file gnunet-cadet-profiler.c.

{
  struct GNUNET_TESTBED_Operation *op;
  unsigned int delta;
  unsigned int run;
  unsigned int i;
  unsigned int r;
 
  GNUNET_assert (target <= peers_total);
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "adjust peers to %u\n", target);
  if (target > peers_running)
  {
    delta = target - peers_running;
    run = GNUNET_YES;
  }
  else
  {
    delta = peers_running - target;
    run = GNUNET_NO;
  }
 
  for (i = 0; i < delta; i++)
  {
    do
    {
      r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                    peers_total - peers_pinging);
      r += peers_pinging;
    }
    while (peers[r].up == run || NULL != peers[r].incoming);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "St%s peer %u: %s\n",
                run ? "arting" : "opping", r, GNUNET_i2s (&peers[r].id));
 
    if (NULL != peers[r].ping_task)
    {
      GNUNET_SCHEDULER_cancel (peers[r].ping_task);
      peers[r].ping_task = NULL;
    }
    if (NULL != peers[r].ping_ntr)
    {
      GNUNET_CADET_notify_transmit_ready_cancel (peers[r].ping_ntr);
      peers[r].ping_ntr = NULL;
    }
    peers[r].up = run;
 
    if (NULL != peers[r].ch)
      GNUNET_CADET_channel_destroy (peers[r].ch);
    peers[r].ch = NULL;
    if (NULL != peers[r].dest)
    {
      if (NULL != peers[r].dest->incoming_ch)
        GNUNET_CADET_channel_destroy (peers[r].dest->incoming_ch);
      peers[r].dest->incoming_ch = NULL;
    }
 
    op = GNUNET_TESTBED_peer_manage_service (&peers[r], testbed_handles[r],
                                             "cadet", NULL, NULL, run);
    GNUNET_break (NULL != op);
    peers_running += run ? 1 : -1;
    GNUNET_assert (peers_running > 0);
  }
}

References CadetPeer::ch, ch, delta, warningfilter::dest, CadetPeer::dest, GNUNET_assert, GNUNET_break, GNUNET_CADET_channel_destroy(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_peer_manage_service(), GNUNET_YES, CadetPeer::incoming_ch, op, peers, peers_pinging, peers_running, peers_total, CadetPeer::ping_ntr, CadetPeer::ping_task, run(), testbed_handles, and CadetPeer::up.

Referenced by next_rnd().

Here is the call graph for this function:

Here is the caller graph for this function:

next_rnd()

static void next_rnd ( void *  cls )

static

Move to next round.

Parameters

cls	Closure (round #).

Definition at line 573 of file gnunet-cadet-profiler.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "ROUND %u\n",
              current_round);
  if (0.0 == rounds[current_round])
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Finishing\n");
    GNUNET_SCHEDULER_add_now (&finish_profiler, NULL);
    return;
  }
  adjust_running_peers (rounds[current_round] * peers_total);
  current_round++;
 
  round_task = GNUNET_SCHEDULER_add_delayed (round_time,
                                             &next_rnd,
                                             NULL);
}

References adjust_running_peers(), current_round, finish_profiler(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), peers_total, round_task, round_time, and rounds.

Referenced by start_test().

Here is the call graph for this function:

Here is the caller graph for this function:

tmt_rdy_ping()

static size_t tmt_rdy_ping ( void *  cls, size_t  size, void *  buf  )

static

Transmit ping callback.

Parameters

cls	Closure (peer for PING, NULL for PONG).
size	Size of the transmit buffer.
buf	Pointer to the beginning of the buffer.

Returns

Number of bytes written to buf.

Parameters

cls	Closure (peer).
size	Size of the buffer we have.
buf	Buffer to copy data to.

Definition at line 686 of file gnunet-cadet-profiler.c.

{
  struct CadetPeer *peer = cls;
  struct CadetPingMessage *msg = buf;
 
  peer->ping_ntr = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "tmt_rdy called, filling buffer\n");
  if ((size < sizeof(struct CadetPingMessage)) || (NULL == buf))
  {
    GNUNET_break (GNUNET_YES == test_finished);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "size %u, buf %p, data_sent %u, data_received %u\n",
                (unsigned int) size,
                buf,
                peer->data_sent,
                peer->data_received);
 
    return 0;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending: msg %d\n",
              peer->data_sent);
  msg->header.size = htons (size);
  msg->header.type = htons (PING);
  msg->counter = htonl (peer->data_sent++);
  msg->round_number = htonl (current_round);
  msg->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
  peer->pings[current_round]++;
  peer->ping_task = GNUNET_SCHEDULER_add_delayed (delay_ms_rnd (PING_PERIOD),
                                                  &ping, peer);
 
  return sizeof(struct CadetPingMessage);
}

References buf, current_round, delay_ms_rnd(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_YES, msg, peer, PING, ping(), PING_PERIOD, GNUNET_MessageHeader::size, size, test_finished, and GNUNET_MessageHeader::type.

Referenced by ping().

Here is the call graph for this function:

Here is the caller graph for this function:

tmt_rdy_pong()

static size_t tmt_rdy_pong ( void *  cls, size_t  size, void *  buf  )

static

Transmit pong callback.

Parameters

cls	Closure (copy of PING message, to be freed).
size	Size of the buffer we have.
buf	Buffer to copy data to.

Definition at line 614 of file gnunet-cadet-profiler.c.

{
  struct CadetPingMessage *ping = cls;
  struct CadetPingMessage *pong;
 
  if ((0 == size) || (NULL == buf))
  {
    GNUNET_free (ping);
    return 0;
  }
  pong = (struct CadetPingMessage *) buf;
  GNUNET_memcpy (pong, ping, sizeof(*ping));
  pong->header.type = htons (PONG);
 
  GNUNET_free (ping);
  return sizeof(*ping);
}

References buf, GNUNET_free, GNUNET_memcpy, ping(), PONG, pong(), and size.

Referenced by pong().

Here is the call graph for this function:

Here is the caller graph for this function:

ping()

static void ping ( void *  cls )

static

Send a ping to destination.

Parameters

cls	Closure (peer).

Definition at line 639 of file gnunet-cadet-profiler.c.

{
  struct CadetPeer *peer = cls;
 
  peer->ping_task = NULL;
  if (GNUNET_YES == test_finished)
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "%u -> %u (%u)\n",
              get_index (peer),
              get_index (peer->dest),
              peer->data_sent);
  peer->ping_ntr = GNUNET_CADET_notify_transmit_ready (peer->ch, GNUNET_NO,
                                                       GNUNET_TIME_UNIT_FOREVER_REL,
                                                       sizeof(struct
                                                              CadetPingMessage),
                                                       &tmt_rdy_ping, peer);
}

References get_index(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, peer, test_finished, and tmt_rdy_ping().

Referenced by GSC_KX_init(), GST_validation_handle_ping(), pong(), start_test(), tmt_rdy_ping(), tmt_rdy_pong(), and transmit_ping_if_allowed().

Here is the call graph for this function:

Here is the caller graph for this function:

pong()

static void pong ( struct GNUNET_CADET_Channel *  channel, const struct CadetPingMessage *  ping  )

static

Reply with a pong to origin.

Definition at line 664 of file gnunet-cadet-profiler.c.

{
  struct CadetPingMessage *copy;
 
  copy = GNUNET_new (struct CadetPingMessage);
  *copy = *ping;
  GNUNET_CADET_notify_transmit_ready (channel, GNUNET_NO,
                                      GNUNET_TIME_UNIT_FOREVER_REL,
                                      sizeof(struct CadetPingMessage),
                                      &tmt_rdy_pong, copy);
}

References GNUNET_new, GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_REL, ping(), and tmt_rdy_pong().

Referenced by GSC_KX_init(), GST_validation_handle_ping(), GST_validation_handle_pong(), multicast_pong(), ping_handler(), and tmt_rdy_pong().

Here is the call graph for this function:

Here is the caller graph for this function:

ping_handler()

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.

Parameters

cls	closure (peer #, set from GNUNET_CADET_connect)
channel	connection to the other end
channel_ctx	place to store local state associated with the channel
message	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 733 of file gnunet-cadet-profiler.c.

{
  long n = (long) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%u got PING\n",
              (unsigned int) n);
  GNUNET_CADET_receive_done (channel);
  if (GNUNET_NO == test_finished)
    pong (channel, (struct CadetPingMessage *) message);
 
  return GNUNET_OK;
}

References GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, pong(), and test_finished.

Here is the call graph for this function:

pong_handler()

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.

Parameters

cls	closure (peer #, set from GNUNET_CADET_connect)
channel	connection to the other end
channel_ctx	place to store local state associated with the channel
message	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 761 of file gnunet-cadet-profiler.c.

{
  long n = (long) cls;
  struct CadetPeer *peer;
  struct CadetPingMessage *msg;
  struct GNUNET_TIME_Absolute send_time;
  struct GNUNET_TIME_Relative latency;
  unsigned int r /* Ping round */;
  float delta;
 
  GNUNET_CADET_receive_done (channel);
  peer = &peers[n];
 
  msg = (struct CadetPingMessage *) message;
 
  send_time = GNUNET_TIME_absolute_ntoh (msg->timestamp);
  latency = GNUNET_TIME_absolute_get_duration (send_time);
  r = ntohl (msg->round_number);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%u <- %u (%u) latency: %s\n",
              get_index (peer),
              get_index (peer->dest),
              (uint32_t) ntohl (msg->counter),
              GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_NO));
 
  /* Online variance calculation */
  peer->pongs[r]++;
  delta = latency.rel_value_us - peer->mean[r];
  peer->mean[r] = peer->mean[r] + delta / peer->pongs[r];
  peer->var[r] += delta * (latency.rel_value_us - peer->mean[r]);
 
  return GNUNET_OK;
}

incoming_channel()

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  )

static

Method called whenever another peer has added us to a channel the other peer initiated.

Parameters

cls	Closure.
channel	New handle to the channel.
initiator	Peer that started the channel.
port	Port this channel is connected to.
options	channel option flags

Returns

Initial channel context for the channel (can be NULL – that's not an error).

Definition at line 820 of file gnunet-cadet-profiler.c.

{
  long n = (long) cls;
  struct CadetPeer *peer;
 
  peer = GNUNET_CONTAINER_multipeermap_get (ids, initiator);
  GNUNET_assert (NULL != peer);
  if (NULL == peers[n].incoming)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "WARMUP %3u: %u <= %u\n",
                peers_warmup,
                (unsigned int) n,
                get_index (peer));
    peers_warmup++;
    if (peers_warmup < peers_total)
      return NULL;
    if (NULL != test_task)
    {
      GNUNET_SCHEDULER_cancel (test_task);
      test_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                &start_test, NULL);
    }
    return NULL;
  }
  GNUNET_assert (peer == peers[n].incoming);
  GNUNET_assert (peer->dest == &peers[n]);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "%u <= %u %p\n",
              (unsigned int) n,
              get_index (peer),
              channel);
  peers[n].incoming_ch = channel;
 
  return NULL;
}

References get_index(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_UNIT_SECONDS, ids, CadetPeer::incoming, CadetPeer::incoming_ch, peer, peers, peers_total, peers_warmup, start_test(), and test_task.

Here is the call graph for this function:

channel_cleaner()

static void channel_cleaner ( void *  cls, const struct GNUNET_CADET_Channel *  channel, void *  channel_ctx  )

static

Function called whenever an inbound channel is destroyed.

Should clean up any associated state.

Parameters

cls	closure (set from GNUNET_CADET_connect)
channel	connection to the other end (henceforth invalid)
channel_ctx	place where local state associated with the channel is stored

Definition at line 871 of file gnunet-cadet-profiler.c.

{
  long n = (long) cls;
  struct CadetPeer *peer = &peers[n];
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Channel %p disconnected at peer %ld\n", channel, n);
  if (peer->ch == channel)
    peer->ch = NULL;
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, peer, and peers.

select_random_peer()

static struct CadetPeer* select_random_peer ( struct CadetPeer *  peer )

static

Select a random peer that has no incoming channel.

Parameters

peer	ID of the peer connecting. NULL if irrelevant (warmup).

Returns

Random peer not yet connected to.

Definition at line 893 of file gnunet-cadet-profiler.c.

{
  unsigned int r;
 
  do
  {
    r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, peers_total);
  }
  while (NULL != peers[r].incoming);
  peers[r].incoming = peer;
 
  return &peers[r];
}

References GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), CadetPeer::incoming, peer, peers, and peers_total.

Referenced by start_test(), and warmup().

Here is the call graph for this function:

Here is the caller graph for this function:

warmup()

static void warmup ( void  )

static

Do warmup: create some channels to spread information about the topology.

Definition at line 964 of file gnunet-cadet-profiler.c.

{
  struct CadetPeer *peer;
  unsigned int i;
 
  for (i = 0; i < peers_total; i++)
  {
    peer = select_random_peer (NULL);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "WARMUP %u => %u\n",
                i, get_index (peer));
    peers[i].warmup_ch =
      GNUNET_CADET_channel_create (peers[i].cadet, NULL, &peer->id,
                                   GC_u2h (1));
    if (NULL == peers[i].warmup_ch)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Warmup %u failed\n", i);
      GNUNET_CADET_TEST_cleanup (test_ctx);
      return;
    }
  }
}

References cadet, GC_u2h(), get_index(), GNUNET_CADET_channel_create(), GNUNET_CADET_TEST_cleanup(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, peer, peers, peers_total, select_random_peer(), test_ctx, and CadetPeer::warmup_ch.

Referenced by peer_id_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

peer_id_cb()

static void peer_id_cb ( void *  cls, struct GNUNET_TESTBED_Operation *  op, const struct GNUNET_TESTBED_PeerInformation *  pinfo, const char *  emsg  )

static

Callback to be called when the requested peer information is available.

Parameters

cls	the closure from GNUNET_TESTBED_peer_get_information()
op	the operation this callback corresponds to
pinfo	the result; will be NULL if the operation has failed
emsg	error message if the operation has failed; NULL if the operation is successful

Definition at line 997 of file gnunet-cadet-profiler.c.

{
  long n = (long) cls;
 
  if ((NULL == pinfo) || (NULL != emsg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", emsg);
    abort_test (__LINE__);
    return;
  }
  peers[n].id = *(pinfo->result.id);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "%ld  id: %s\n",
              n,
              GNUNET_i2s (&peers[n].id));
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONTAINER_multipeermap_put (ids, &peers[n].id, &peers[n],
                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
 
  GNUNET_TESTBED_operation_done (peers[n].op);
  peers[n].op = NULL;
 
  p_ids++;
  if (p_ids < peers_total)
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got all IDs, starting profiler\n");
  if (do_warmup)
  {
    struct GNUNET_TIME_Relative delay;
 
    warmup ();
    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
                                           100 * peers_total);
    test_task = GNUNET_SCHEDULER_add_delayed (delay, &start_test, NULL);
    return;   /* start_test from incoming_channel */
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting in a second...\n");
  test_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                            &start_test, NULL);
}

References abort_test(), delay, do_warmup, GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTBED_operation_done(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_TIME_UNIT_SECONDS, CadetPeer::id, GNUNET_TESTBED_PeerInformation::id, ids, op, CadetPeer::op, p_ids, peers, peers_total, GNUNET_TESTBED_PeerInformation::result, start_test(), test_task, and warmup().

Referenced by tmain().

Here is the call graph for this function:

Here is the caller graph for this function:

tmain()

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  )

static

test main: start test when all peers are connected

Parameters

cls	Closure.
ctx	Argument to give to GNUNET_CADET_TEST_cleanup on test end.
num_peers	Number of peers that are running.
testbed_peers	Array of peers.
cadetes	Handle to each of the CADETs of the peers.

Definition at line 1052 of file gnunet-cadet-profiler.c.

{
  unsigned long i;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "test main\n");
  test_ctx = ctx;
  GNUNET_assert (peers_total == num_peers);
  peers_running = num_peers;
  testbed_handles = testbed_peers;
  disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
                                                  &disconnect_cadet_peers,
                                                  (void *) __LINE__);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  for (i = 0; i < peers_total; i++)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "requesting id %ld\n",
                i);
    peers[i].up = GNUNET_YES;
    peers[i].cadet = cadetes[i];
    peers[i].op =
      GNUNET_TESTBED_peer_get_information (testbed_handles[i],
                                           GNUNET_TESTBED_PIT_IDENTITY,
                                           &peer_id_cb, (void *) i);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "requested peer ids\n");
  /* Continues from pi_cb -> do_test */
}

References CadetPeer::cadet, ctx, disconnect_cadet_peers(), disconnect_task, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_PIT_IDENTITY, GNUNET_YES, num_peers, CadetPeer::op, peer_id_cb(), peers, peers_running, peers_total, SHORT_TIME, shutdown_task(), test_ctx, testbed_handles, testbed_peers, and CadetPeer::up.

Referenced by GNUNET_CADET_TEST_ruN(), and GNUNET_DHT_TEST_run().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[]
	)

Main: start profiler.

Definition at line 1091 of file gnunet-cadet-profiler.c.

{
  static const struct GNUNET_HashCode *ports[2];
  const char *config_file;
 
  config_file = ".profiler.conf";
 
  if (4 > argc)
  {
    fprintf (stderr,
             "usage: %s ROUND_TIME PEERS PINGS [DO_WARMUP]\n",
             argv[0]);
    fprintf (stderr,
             "example: %s 30s 16 1 Y\n",
             argv[0]);
    return 1;
  }
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_fancy_time_to_relative (argv[1],
                                             &round_time))
  {
    fprintf (stderr,
             "%s is not a valid time\n",
             argv[1]);
    return 1;
  }
 
  peers_total = atoll (argv[2]);
  if (2 > peers_total)
  {
    fprintf (stderr,
             "%s peers is not valid (> 2)\n",
             argv[1]);
    return 1;
  }
  peers = GNUNET_new_array (peers_total,
                            struct CadetPeer);
  peers_pinging = atoll (argv[3]);
 
  if (peers_total < 2 * peers_pinging)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "not enough peers, total should be > 2 * peers_pinging\n");
    return 1;
  }
 
  do_warmup = (5 > argc || argv[4][0] != 'N');
 
  ids = GNUNET_CONTAINER_multipeermap_create (2 * peers_total,
                                              GNUNET_YES);
  GNUNET_assert (NULL != ids);
  p_ids = 0;
  test_finished = GNUNET_NO;
  ports[0] = GC_u2h (1);
  ports[1] = 0;
  GNUNET_CADET_TEST_run ("cadet-profiler", config_file, peers_total,
                         &tmain, NULL, /* tmain cls */
                         &incoming_channel, &channel_cleaner,
                         handlers, ports);
  GNUNET_free (peers);
 
  return 0;
}

Variable Documentation

rounds

float rounds[] = { 0.8, 0.6, 0.8, 0.5, 0.3, 0.8, 0.0 }

static

Ratio of peers active.

First round always is 1.0.

Definition at line 59 of file gnunet-cadet-profiler.c.

Referenced by next_rnd().

round_time

struct GNUNET_TIME_Relative round_time

static

Duration of each round.

Definition at line 59 of file gnunet-cadet-profiler.c.

Referenced by next_rnd(), and start_test().

ids

struct GNUNET_CONTAINER_MultiPeerMap* ids

static

GNUNET_PeerIdentity -> CadetPeer.

Definition at line 171 of file gnunet-cadet-profiler.c.

Referenced by GNUNET_PEER_decrement_rcs(), GNUNET_RPS_seed_ids(), hist_update(), incoming_channel(), and peer_id_cb().

testbed_handles

struct GNUNET_TESTBED_Peer** testbed_handles

static

Testbed peer handles.

Definition at line 176 of file gnunet-cadet-profiler.c.

Referenced by adjust_running_peers(), collect_stats(), and tmain().

stats_op

struct GNUNET_TESTBED_Operation* stats_op

static

Testbed Operation (to get stats).

Definition at line 181 of file gnunet-cadet-profiler.c.

Referenced by collect_stats(), and stats_cont().

peers

struct CadetPeer* peers

static

Operation to get peer ids.

Definition at line 186 of file gnunet-cadet-profiler.c.

Referenced by adjust_running_peers(), cadet_test_run(), channel_cleaner(), check_n_peers_ready(), clients_notify_stream_peer(), collect_peers_cb(), collect_peers_info_cb(), compute_rand_delay(), destroy_peer(), dht_test_run(), disconnect_cadet_peers(), extend_path(), GCP_destroy_all_peers(), GCP_get(), GCP_iterate_all(), get_index(), GNUNET_CONSENSUS_create(), GNUNET_SECRETSHARING_create_session(), GNUNET_TESTBED_get_statistics(), GNUNET_TESTBED_overlay_configure_topology(), GNUNET_TESTBED_overlay_configure_topology_va(), handle_client_seed(), handle_view_update(), incoming_channel(), peer_id_cb(), peer_info_ready_cb(), peers_ready_cb(), select_random_peer(), send_stream_peers(), show_end_data(), start_test(), test_master(), test_run(), tmain(), view_update_cb(), and warmup().

p_ids

unsigned int p_ids

static

Peer ids counter.

Definition at line 191 of file gnunet-cadet-profiler.c.

Referenced by peer_id_cb().

peers_total

unsigned long long peers_total

static

Total number of peers.

Definition at line 196 of file gnunet-cadet-profiler.c.

Referenced by adjust_running_peers(), collect_stats(), disconnect_cadet_peers(), incoming_channel(), next_rnd(), peer_id_cb(), select_random_peer(), start_test(), tmain(), and warmup().

peers_running

unsigned long long peers_running

static

Number of currently running peers.

Definition at line 201 of file gnunet-cadet-profiler.c.

Referenced by adjust_running_peers(), start_test(), and tmain().

peers_pinging

unsigned long long peers_pinging

static

Number of peers doing pings.

Definition at line 206 of file gnunet-cadet-profiler.c.

Referenced by adjust_running_peers(), show_end_data(), and start_test().

test_ctx

struct GNUNET_CADET_TEST_Context* test_ctx

static

Test context (to shut down).

Definition at line 211 of file gnunet-cadet-profiler.c.

Referenced by disconnect_cadet_peers(), start_test(), tmain(), and warmup().

disconnect_task

struct GNUNET_SCHEDULER_Task* disconnect_task

static

Task called to disconnect peers, before shutdown.

Definition at line 216 of file gnunet-cadet-profiler.c.

Referenced by abort_test(), disconnect_cadet_peers(), shutdown_task(), start_test(), stats_cont(), and tmain().

test_task

struct GNUNET_SCHEDULER_Task* test_task

static

Task to perform tests.

Definition at line 221 of file gnunet-cadet-profiler.c.

Referenced by incoming_channel(), peer_id_cb(), shutdown_task(), and start_test().

current_round

unsigned int current_round

static

Round number.

Definition at line 226 of file gnunet-cadet-profiler.c.

Referenced by next_rnd(), and tmt_rdy_ping().

do_warmup

int do_warmup

static

Do preconnect? (Each peer creates a tunnel to one other peer).

Definition at line 231 of file gnunet-cadet-profiler.c.

Referenced by peer_id_cb().

peers_warmup

unsigned int peers_warmup

static

Warmup progress.

Definition at line 236 of file gnunet-cadet-profiler.c.

Referenced by incoming_channel().

test_finished

int test_finished ( void  )

static

Flag to notify callbacks not to generate any new traffic anymore.

Definition at line 241 of file gnunet-cadet-profiler.c.

Referenced by finish_profiler(), ping(), ping_handler(), and tmt_rdy_ping().

round_task

struct GNUNET_SCHEDULER_Task* round_task

static

Task running each round of the benchmark.

Definition at line 246 of file gnunet-cadet-profiler.c.

Referenced by next_rnd(), shutdown_task(), and start_test().

handlers

struct GNUNET_CADET_MessageHandler handlers[]

static

Initial value:

= {
  { &ping_handler,  1 , sizeof(struct CadetPingMessage) },
  { &pong_handler,  2 , sizeof(struct CadetPingMessage) },
  { NULL, 0, 0 }
}

Handlers, for diverse services.

Definition at line 761 of file gnunet-cadet-profiler.c.

Referenced by advertise_dns_exit(), connect_check_run(), connect_task(), connect_tunnel(), create_loc_uri(), demultiplex_with_cmc(), do_connect(), do_peer_connect(), do_plugin_connect(), do_reconnect(), GCO_init(), GCT_create_tunnel(), get_cadet(), GNUNET_CADET_channel_create(), GNUNET_CADET_open_port(), GNUNET_CADET_TEST_ruN(), GNUNET_CLIENT_connect(), GNUNET_CONVERSATION_call_start(), GNUNET_CORE_connect(), GNUNET_FS_get_indexed_files(), GNUNET_IDENTITY_ego_lookup(), GNUNET_IDENTITY_ego_lookup_by_suffix(), GNUNET_MQ_copy_handlers(), GNUNET_MQ_copy_handlers2(), GNUNET_MQ_count_handlers(), GNUNET_MQ_queue_for_callbacks(), GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_REST_handle_request(), GNUNET_REVOCATION_query(), GNUNET_REVOCATION_revoke(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SERVER_add_handlers(), GNUNET_SERVICE_run_(), GNUNET_SERVICE_start(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_controller_connect(), GNUNET_TRANSPORT_address_to_string(), GNUNET_TRANSPORT_core_connect(), GNUNET_TRANSPORT_TESTING_start_peer(), GSC_KX_init(), GSF_cadet_start_server(), hash_for_index_cb(), libgnunet_plugin_dhtu_gnunet_init(), main(), open_srv_room(), reconnect(), reconnect_arm(), reconnect_arm_monitor(), reconnect_phone(), reconnect_task(), reset_cadet(), run(), search_reconnect(), store_service(), try_connect(), try_reconnect(), and unindex_finish().