gnunet_dht_profiler.c File Reference

Profiler for GNUnet DHT. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_constants.h"

Include dependency graph for gnunet_dht_profiler.c:

Go to the source code of this file.

Data Structures
struct	Context
	Context to hold data of peer. More...
struct	ActiveContext
	Context for a peer which actively does DHT PUT/GET. More...

Macros
#define	MESSAGE(...)    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, __VA_ARGS__)
#define	DEBUG(...)    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Enumerations
enum	{ MODE_PUT = 0 , MODE_GET = 1 }
	Should we do a PUT (mode = 0) or GET (mode = 1);. More...

Functions
static void	start_profiling (void)
	Connect to DHT services of active peers.
static void	do_shutdown (void *cls)
	Shutdown task.
static void	bandwidth_stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
	Stats callback.
static int	bandwidth_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 void	summarize ()
static void	cancel_get (void *cls)
	Task to cancel DHT GET.
static void	get_iter (void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
	Iterator called on each result obtained for a DHT operation that expects a reply.
static void	delayed_get (void *cls)
	Task to do DHT GETs.
static void	delayed_put (void *cls)
	Task to do DHT PUTs.
static void	put_cont (void *cls)
	Conclude individual PUT operation, schedule the next one.
static void	dht_connected (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
	Connection to DHT has been established.
static void *	dht_connect (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to DHT service and return the DHT client handler.
static void	dht_disconnect (void *cls, void *op_result)
	Adapter function called to destroy a connection to a service.
static void	service_started (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
	Callback called when DHT service on the peer is started.
static void	test_run (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded, unsigned int links_failed)
	Signature of a main function for a testcase.
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *config)
	Main function that will be run by the scheduler.
int	main (int argc, char *const *argv)
	Main function.

Variables
static unsigned int	put_probability = 100
	Number of peers which should perform a PUT out of 100 peers.
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration.
static char *	hosts_file
	Name of the file with the hosts to run the test over.
static struct Context *	a_ctx
	An array of contexts.
static struct ActiveContext *	a_ac
	Array of active peers.
static struct GNUNET_TIME_Relative	delay_stats
	The delay between rounds for collecting statistics.
static struct GNUNET_TIME_Relative	delay_put
	The delay to start puts.
static struct GNUNET_TIME_Relative	delay_get
	The delay to start puts.
static struct GNUNET_TIME_Relative	timeout
	The timeout for GET and PUT.
static unsigned int	num_peers
	Number of peers.
static unsigned int	n_active
	Number of active peers.
static unsigned int	n_dht
	Number of DHT service connections we currently have.
static unsigned long long	n_puts
	Number of DHT PUTs made.
static unsigned int	num_puts_per_peer = 1
	Number of DHT PUTs to be made per peer.
static unsigned long long	n_puts_ok
	Number of DHT PUTs succeeded.
static unsigned int	n_gets
	Number of DHT GETs made.
static unsigned int	n_gets_ok
	Number of DHT GETs succeeded.
static unsigned int	n_gets_fail
	Number of DHT GETs succeeded.
static unsigned int	replication
	Replication degree.
static struct GNUNET_TESTBED_Operation *	bandwidth_stats_op
	Testbed Operation (to get stats).
static struct GNUNET_TESTBED_Peer **	testbed_handles
	Testbed peer handles.
static uint64_t	outgoing_bandwidth
	Total number of messages sent by peer.
static uint64_t	incoming_bandwidth
	Total number of messages received by peer.
static double	average_put_path_length
	Average number of hops taken to do put.
static double	average_get_path_length
	Average number of hops taken to do get.
static unsigned int	total_put_path_length
	Total put path length across all peers.
static unsigned int	total_get_path_length
	Total get path length across all peers.
static int	peers_started = 0
	Counter to keep track of peers added to peer_context lists.
static enum { ... }	mode
	Should we do a PUT (mode = 0) or GET (mode = 1);.
static int	in_shutdown = 0
	Are we shutting down.

Detailed Description

Profiler for GNUnet DHT.

Author

Sree Harsha Totakura sreeh.nosp@m.arsh.nosp@m.a@tot.nosp@m.akur.nosp@m.a.in

Definition in file gnunet_dht_profiler.c.

Macro Definition Documentation

MESSAGE

#define MESSAGE

(

...

)

GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, __VA_ARGS__)

Definition at line 34 of file gnunet_dht_profiler.c.

{
  struct GNUNET_TESTBED_Peer *peer;
 
  struct GNUNET_TESTBED_Operation *op;
 
  struct ActiveContext *ac;
};
 
 
struct ActiveContext
{
  struct Context *ctx;
 
  struct GNUNET_DHT_Handle *dht;
 
  struct ActiveContext *get_ac;
 
  struct GNUNET_DHT_PutHandle *dht_put;
 
  struct GNUNET_DHT_GetHandle *dht_get;
 
  struct GNUNET_HashCode *hash;
 
  struct GNUNET_SCHEDULER_Task *delay_task;
 
  unsigned int put_count;
 
  uint16_t nrefs;
};
 
 
static struct Context *a_ctx;
 
static struct ActiveContext *a_ac;
 
static struct GNUNET_TIME_Relative delay_stats;
 
static struct GNUNET_TIME_Relative delay_put;
 
static struct GNUNET_TIME_Relative delay_get;
 
static struct GNUNET_TIME_Relative timeout;
 
static unsigned int num_peers;
 
static unsigned int n_active;
 
static unsigned int n_dht;
 
static unsigned long long n_puts;
 
static unsigned int num_puts_per_peer = 1;
 
static unsigned long long n_puts_ok;
 
static unsigned int n_gets;
 
static unsigned int n_gets_ok;
 
static unsigned int n_gets_fail;
 
static unsigned int replication;
 
static struct GNUNET_TESTBED_Operation *bandwidth_stats_op;
 
static struct GNUNET_TESTBED_Peer **testbed_handles;
 
static uint64_t outgoing_bandwidth;
 
static uint64_t incoming_bandwidth;
 
static double average_put_path_length;
 
static double average_get_path_length;
 
static unsigned int total_put_path_length;
 
static unsigned int total_get_path_length;
 
static int peers_started = 0;
 
static enum
{
  MODE_PUT = 0,
 
  MODE_GET = 1
} mode;
 
 
static int in_shutdown = 0;
 
 
static void
start_profiling (void);
 
 
static void
do_shutdown (void *cls)
{
  struct ActiveContext *ac;
 
  in_shutdown = GNUNET_YES;
  if (NULL != a_ctx)
  {
    for (unsigned int cnt = 0; cnt < num_peers; cnt++)
    {
      /* Cleanup active context if this peer is an active peer */
      ac = a_ctx[cnt].ac;
      if (NULL != ac)
      {
        if (NULL != ac->delay_task)
          GNUNET_SCHEDULER_cancel (ac->delay_task);
        if (NULL != ac->hash)
          free (ac->hash);
        if (NULL != ac->dht_put)
          GNUNET_DHT_put_cancel (ac->dht_put);
        if (NULL != ac->dht_get)
          GNUNET_DHT_get_stop (ac->dht_get);
      }
      /* Cleanup testbed operation handle at the last as this operation may
         contain service connection to DHT */
      if (NULL != a_ctx[cnt].op)
        GNUNET_TESTBED_operation_done (a_ctx[cnt].op);
    }
    GNUNET_free (a_ctx);
    a_ctx = NULL;
  }
  // FIXME: Should we collect stats only for put/get not for other messages.
  if (NULL != bandwidth_stats_op)
  {
    GNUNET_TESTBED_operation_done (bandwidth_stats_op);
    bandwidth_stats_op = NULL;
  }
  GNUNET_free (a_ac);
}
 
 
static void
bandwidth_stats_cont (void *cls,
                      struct GNUNET_TESTBED_Operation *op,
                      const char *emsg)
{
  MESSAGE ("# Outgoing (core) bandwidth: %llu bytes\n",
           (unsigned long long) outgoing_bandwidth);
  MESSAGE ("# Incoming (core) bandwidth: %llu bytes\n",
           (unsigned long long) incoming_bandwidth);
  fprintf (stderr,
           "Benchmark done. Collect data via gnunet-statistics, then press ENTER to exit.\n");
  (void) getchar ();
  GNUNET_SCHEDULER_shutdown ();
}
 
 
static int
bandwidth_stats_iterator (void *cls,
                          const struct GNUNET_TESTBED_Peer *peer,
                          const char *subsystem,
                          const char *name,
                          uint64_t value,
                          int is_persistent)
{
  static const char *s_sent = "# bytes encrypted";
  static const char *s_recv = "# bytes decrypted";
 
  if (0 == strncmp (s_sent, name, strlen (s_sent)))
    outgoing_bandwidth = outgoing_bandwidth + value;
  else if (0 == strncmp (s_recv, name, strlen (s_recv)))
    incoming_bandwidth = incoming_bandwidth + value;
  return GNUNET_OK;
}
 
 
static void
summarize ()
{
  MESSAGE ("# PUTS started: %llu\n",
           n_puts);
  MESSAGE ("# PUTS succeeded: %llu\n",
           n_puts_ok);
  MESSAGE ("# GETS made: %u\n",
           n_gets);
  MESSAGE ("# GETS succeeded: %u\n",
           n_gets_ok);
  MESSAGE ("# GETS failed: %u\n",
           n_gets_fail);
  MESSAGE ("# average_put_path_length: %f\n",
           average_put_path_length);
  MESSAGE ("# average_get_path_length: %f\n",
           average_get_path_length);
 
  if (NULL == testbed_handles)
  {
    MESSAGE ("No peers found\n");
    return;
  }
  /* Collect Stats*/
  bandwidth_stats_op = GNUNET_TESTBED_get_statistics (n_active,
                                                      testbed_handles,
                                                      "core",
                                                      NULL,
                                                      &bandwidth_stats_iterator,
                                                      &bandwidth_stats_cont,
                                                      NULL);
}
 
 
static void
cancel_get (void *cls)
{
  struct ActiveContext *ac = cls;
  struct Context *ctx = ac->ctx;
 
  ac->delay_task = NULL;
  GNUNET_assert (NULL != ac->dht_get);
  GNUNET_DHT_get_stop (ac->dht_get);
  ac->dht_get = NULL;
  n_gets_fail++;
  GNUNET_assert (NULL != ctx->op);
  GNUNET_TESTBED_operation_done (ctx->op);
  ctx->op = NULL;
 
  /* If profiling is complete, summarize */
  if (n_active == n_gets_fail + n_gets_ok)
  {
    average_put_path_length = (double) total_put_path_length
                              / (double) n_active;
    average_get_path_length = (double) total_get_path_length
                              / (double ) n_gets_ok;
    summarize ();
  }
}
 
 
static void
get_iter (void *cls,
          struct GNUNET_TIME_Absolute exp,
          const struct GNUNET_HashCode *key,
          const struct GNUNET_PeerIdentity *trunc_peer,
          const struct GNUNET_DHT_PathElement *get_path,
          unsigned int get_path_length,
          const struct GNUNET_DHT_PathElement *put_path,
          unsigned int put_path_length,
          enum GNUNET_BLOCK_Type type,
          size_t size,
          const void *data)
{
  struct ActiveContext *ac = cls;
  struct ActiveContext *get_ac = ac->get_ac;
  struct Context *ctx = ac->ctx;
 
  /* we found the data we are looking for */
  DEBUG ("We found a GET request; %u remaining\n",
         n_gets - (n_gets_fail + n_gets_ok)); // FIXME: It always prints 1.
  n_gets_ok++;
  get_ac->nrefs--;
  GNUNET_DHT_get_stop (ac->dht_get);
  ac->dht_get = NULL;
  if (ac->delay_task != NULL)
    GNUNET_SCHEDULER_cancel (ac->delay_task);
  ac->delay_task = NULL;
  GNUNET_assert (NULL != ctx->op);
  GNUNET_TESTBED_operation_done (ctx->op);
  ctx->op = NULL;
 
  total_put_path_length = total_put_path_length + (double) put_path_length;
  total_get_path_length = total_get_path_length + (double) get_path_length;
  DEBUG ("total_put_path_length = %u,put_path \n",
         total_put_path_length);
  /* Summarize if profiling is complete */
  if (n_active == n_gets_fail + n_gets_ok)
  {
    average_put_path_length = (double) total_put_path_length
                              / (double) n_active;
    average_get_path_length = (double) total_get_path_length
                              / (double ) n_gets_ok;
    summarize ();
  }
}
 
 
static void
delayed_get (void *cls)
{
  struct ActiveContext *ac = cls;
  struct ActiveContext *get_ac;
  unsigned int r;
 
  ac->delay_task = NULL;
  get_ac = NULL;
  while (1)
  {
    r = GNUNET_CRYPTO_random_u32 (n_active);
    get_ac = &a_ac[r];
    if (NULL != get_ac->hash)
      break;
  }
  get_ac->nrefs++;
  ac->get_ac = get_ac;
  r = GNUNET_CRYPTO_random_u32 (num_puts_per_peer);
  DEBUG ("GET_REQUEST_START key %s \n",
         GNUNET_h2s (&get_ac->hash[r]));
  ac->dht_get = GNUNET_DHT_get_start (ac->dht,
                                      GNUNET_BLOCK_TYPE_TEST,
                                      &get_ac->hash[r],
                                      1, /* replication level */
                                      GNUNET_DHT_RO_NONE,
                                      NULL,
                                      0, /* extended query and size */
                                      &get_iter,
                                      ac); /* GET iterator and closure */
  n_gets++;
 
  /* schedule the timeout task for GET */
  ac->delay_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                                 &cancel_get,
                                                 ac);
}
 
 
static void
delayed_put (void *cls);
 
 
static void
put_cont (void *cls)
{
  struct ActiveContext *ac = cls;
 
  ac->dht_put = NULL;
  n_puts_ok++;
  ac->delay_task = GNUNET_SCHEDULER_add_now (&delayed_put,
                                             ac);
}
 
 
static void
delayed_put (void *cls)
{
  struct ActiveContext *ac = cls;
  char block[65536];
  size_t block_size;
 
  ac->delay_task = NULL;
  if (0 == ac->put_count)
  {
    struct Context *ctx = ac->ctx;
    struct GNUNET_TESTBED_Operation *op;
 
    GNUNET_assert (NULL != ctx);
    op = ctx->op;
    ctx->op = NULL;
    GNUNET_TESTBED_operation_done (op);
    return;
  }
 
 
  /* Generate and DHT PUT some random data */
  block_size = 16; /* minimum */
  /* make random payload, reserve 512 - 16 bytes for DHT headers */
  block_size += GNUNET_CRYPTO_random_u32 (
    GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE
    - 512);
  GNUNET_CRYPTO_random_block (block,
                              block_size);
  ac->put_count--;
  GNUNET_CRYPTO_hash (block,
                      block_size,
                      &ac->hash[ac->put_count]);
  DEBUG ("PUT_REQUEST_START key %s\n",
         GNUNET_h2s (&ac->hash[ac->put_count]));
  ac->dht_put = GNUNET_DHT_put (ac->dht,
                                &ac->hash[ac->put_count],
                                replication,
                                GNUNET_DHT_RO_RECORD_ROUTE,
                                GNUNET_BLOCK_TYPE_TEST,
                                block_size,
                                block,
                                GNUNET_TIME_UNIT_FOREVER_ABS, /* expiration time */
                                &put_cont,
                                ac);                /* continuation and its closure */
  n_puts++;
}
 
 
static void
dht_connected (void *cls,
               struct GNUNET_TESTBED_Operation *op,
               void *ca_result,
               const char *emsg)
{
  struct ActiveContext *ac = cls;
  struct Context *ctx = ac->ctx;
 
  GNUNET_assert (NULL != ctx);  // FIXME: Fails
  GNUNET_assert (NULL != ctx->op);
  GNUNET_assert (ctx->op == op);
  ac->dht = (struct GNUNET_DHT_Handle *) ca_result;
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Connection to DHT service failed: %s\n",
                emsg);
    GNUNET_TESTBED_operation_done (ctx->op);  /* Calls dht_disconnect() */
    ctx->op = NULL;
    return;
  }
  switch (mode)
  {
  case MODE_PUT:
    {
      struct GNUNET_TIME_Relative peer_delay_put;
 
      peer_delay_put.rel_value_us =
        GNUNET_CRYPTO_random_u64 (delay_put.rel_value_us);
      ac->put_count = num_puts_per_peer;
      ac->hash = calloc (ac->put_count,
                         sizeof(struct GNUNET_HashCode));
      if (NULL == ac->hash)
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                             "calloc");
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_put,
                                                     &delayed_put,
                                                     ac);
      break;
    }
 
  case MODE_GET:
    {
      struct GNUNET_TIME_Relative peer_delay_get;
 
      peer_delay_get.rel_value_us =
        delay_get.rel_value_us
        + GNUNET_CRYPTO_random_u64 (delay_get.rel_value_us);
      ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_get,
                                                     &delayed_get,
                                                     ac);
      break;
    }
  }
}
 
 
static void *
dht_connect (void *cls,
             const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  n_dht++;
  return GNUNET_DHT_connect (cfg,
                             10);
}
 
 
static void
dht_disconnect (void *cls,
                void *op_result)
{
  struct ActiveContext *ac = cls;
 
  GNUNET_assert (NULL != ac->dht);
  GNUNET_assert (ac->dht == op_result);
  GNUNET_DHT_disconnect (ac->dht);
  ac->dht = NULL;
  n_dht--;
  if (0 != n_dht)
    return;
  if (GNUNET_YES == in_shutdown)
    return;
  switch (mode)
  {
  case MODE_PUT:
    if (n_puts_ok != ((unsigned long long) n_active) * num_puts_per_peer)
      return;
    /* Start GETs if all PUTs have been made */
    mode = MODE_GET;
    start_profiling ();
    return;
 
  case MODE_GET:
    if ((n_gets_ok + n_gets_fail) != n_active)
      return;
    break;
  }
}
 
 
static void
start_profiling ()
{
  struct Context *ctx;
 
  DEBUG ("GNUNET_TESTBED_service_connect\n");
  GNUNET_break (GNUNET_YES != in_shutdown);
  for (unsigned int i = 0; i < n_active; i++)
  {
    struct ActiveContext *ac = &a_ac[i];
    GNUNET_assert (NULL != (ctx = ac->ctx));
    GNUNET_assert (NULL == ctx->op);
    ctx->op = GNUNET_TESTBED_service_connect (ctx,
                                              ctx->peer,
                                              "dht",
                                              &dht_connected, ac,
                                              &dht_connect,
                                              &dht_disconnect,
                                              ac);
  }
}
 
 
static void
service_started (void *cls,
                 struct GNUNET_TESTBED_Operation *op,
                 const char *emsg)
{
  struct Context *ctx = cls;
 
  GNUNET_assert (NULL != ctx);
  GNUNET_assert (NULL != ctx->op);
  GNUNET_TESTBED_operation_done (ctx->op);
  ctx->op = NULL;
  peers_started++;
  DEBUG ("Peers Started = %d; num_peers = %d \n",
         peers_started,
         num_peers);
  if (peers_started == num_peers)
    start_profiling ();
}
 
 
static void
test_run (void *cls,
          struct GNUNET_TESTBED_RunHandle *h,
          unsigned int num_peers,
          struct GNUNET_TESTBED_Peer **peers,
          unsigned int links_succeeded,
          unsigned int links_failed)
{
  unsigned int ac_cnt;
 
  testbed_handles = peers;
  if (NULL == peers)
  {
    /* exit */
    GNUNET_assert (0);
  }
  MESSAGE ("%u peers started, %u/%u links up\n",
           num_peers,
           links_succeeded,
           links_succeeded + links_failed);
  a_ctx = GNUNET_new_array (num_peers,
                            struct Context);
  /* select the peers which actively participate in profiling */
  n_active = num_peers * put_probability / 100;
  if (0 == n_active)
  {
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (a_ctx);
    a_ctx = NULL;
    return;
  }
 
  a_ac = GNUNET_new_array (n_active,
                           struct ActiveContext);
  ac_cnt = 0;
  for (unsigned int cnt = 0; cnt < num_peers && ac_cnt < n_active; cnt++)
  {
    if (GNUNET_CRYPTO_random_u32 (100) >= put_probability)
      continue;
 
    a_ctx[cnt].ac = &a_ac[ac_cnt];
    a_ac[ac_cnt].ctx = &a_ctx[cnt];
    ac_cnt++;
  }
  n_active = ac_cnt;
 
  /* start DHT service on all peers */
  for (unsigned int cnt = 0; cnt < num_peers; cnt++)
  {
    a_ctx[cnt].peer = peers[cnt];
    a_ctx[cnt].op = GNUNET_TESTBED_peer_manage_service (&a_ctx[cnt],
                                                        peers[cnt],
                                                        "dht",
                                                        &service_started,
                                                        &a_ctx[cnt],
                                                        1);
  }
}
 
 
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *config)
{
  uint64_t event_mask;
 
  if (0 == num_peers)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Exiting as the number of peers is %u\n"),
                num_peers);
    return;
  }
  cfg = config;
  event_mask = 0;
  GNUNET_TESTBED_run (hosts_file,
                      cfg,
                      num_peers,
                      event_mask,
                      NULL,
                      NULL,
                      &test_run,
                      NULL);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                 NULL);
}
 
 
int
main (int argc,
      char *const *argv)
{
  int rc;
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_uint ('n',
                               "peers",
                               "COUNT",
                               gettext_noop ("number of peers to start"),
                               &num_peers),
    GNUNET_GETOPT_option_uint ('p',
                               "peer-put-count",
                               "COUNT",
                               gettext_noop (
                                 "number of PUTs to perform per peer"),
                               &num_puts_per_peer),
    GNUNET_GETOPT_option_string ('H',
                                 "hosts",
                                 "FILENAME",
                                 gettext_noop (
                                   "name of the file with the login information for the testbed"),
                                 &hosts_file),
    GNUNET_GETOPT_option_relative_time ('D',
                                        "delay",
                                        "DELAY",
                                        gettext_noop (
                                          "delay between rounds for collecting statistics (default: 30 sec)"),
                                        &delay_stats),
    GNUNET_GETOPT_option_relative_time ('P',
                                        "PUT-delay",
                                        "DELAY",
                                        gettext_noop (
                                          "delay to start doing PUTs (default: 1 sec)"),
                                        &delay_put),
    GNUNET_GETOPT_option_relative_time ('G',
                                        "GET-delay",
                                        "DELAY",
                                        gettext_noop (
                                          "delay to start doing GETs (default: 5 min)"),
                                        &delay_get),
    GNUNET_GETOPT_option_uint ('r',
                               "replication",
                               "DEGREE",
                               gettext_noop ("replication degree for DHT PUTs"),
                               &replication),
    GNUNET_GETOPT_option_uint ('R',
                               "random-chance",
                               "PROBABILITY",
                               gettext_noop (
                                 "chance that a peer is selected at random for PUTs"),
                               &put_probability),
    GNUNET_GETOPT_option_relative_time ('t',
                                        "timeout",
                                        "TIMEOUT",
                                        gettext_noop (
                                          "timeout for DHT PUT and GET requests (default: 1 min)"),
                                        &timeout),
    GNUNET_GETOPT_OPTION_END
  };
 
  /* set default delays */
  delay_stats = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  delay_put = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  delay_get = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  replication = 1;      /* default replication */
  rc = 0;
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run (argc,
                          argv,
                          "gnunet-dht-profiler",
                          gettext_noop (
                            "Measure quality and performance of the DHT service."),
                          options,
                          &run,
                          NULL))
    rc = 1;
  return rc;
}

DEBUG

#define DEBUG

(

...

)

GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Definition at line 37 of file gnunet_dht_profiler.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Should we do a PUT (mode = 0) or GET (mode = 1);.

Enumerator
MODE_PUT
MODE_GET

Definition at line 263 of file gnunet_dht_profiler.c.

{
  MODE_PUT = 0,
 
  MODE_GET = 1
} mode;

Function Documentation

start_profiling()

static void start_profiling ( void  )

static

Connect to DHT services of active peers.

Definition at line 779 of file gnunet_dht_profiler.c.

{
  struct Context *ctx;
 
  DEBUG ("GNUNET_TESTBED_service_connect\n");
  GNUNET_break (GNUNET_YES != in_shutdown);
  for (unsigned int i = 0; i < n_active; i++)
  {
    struct ActiveContext *ac = &a_ac[i];
    GNUNET_assert (NULL != (ctx = ac->ctx));
    GNUNET_assert (NULL == ctx->op);
    ctx->op = GNUNET_TESTBED_service_connect (ctx,
                                              ctx->peer,
                                              "dht",
                                              &dht_connected, ac,
                                              &dht_connect,
                                              &dht_disconnect,
                                              ac);
  }
}

References a_ac, ctx, ActiveContext::ctx, DEBUG, dht_connect(), dht_connected(), dht_disconnect(), GNUNET_assert, GNUNET_break, GNUNET_YES, in_shutdown, and n_active.

Referenced by dht_disconnect(), and service_started().

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Shutdown task.

Cleanup all resources and operations.

Parameters

cls

NULL

Definition at line 290 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac;
 
  in_shutdown = GNUNET_YES;
  if (NULL != a_ctx)
  {
    for (unsigned int cnt = 0; cnt < num_peers; cnt++)
    {
      /* Cleanup active context if this peer is an active peer */
      ac = a_ctx[cnt].ac;
      if (NULL != ac)
      {
        if (NULL != ac->delay_task)
          GNUNET_SCHEDULER_cancel (ac->delay_task);
        if (NULL != ac->hash)
          free (ac->hash);
        if (NULL != ac->dht_put)
          GNUNET_DHT_put_cancel (ac->dht_put);
        if (NULL != ac->dht_get)
          GNUNET_DHT_get_stop (ac->dht_get);
      }
      /* Cleanup testbed operation handle at the last as this operation may
         contain service connection to DHT */
      if (NULL != a_ctx[cnt].op)
        GNUNET_TESTBED_operation_done (a_ctx[cnt].op);
    }
    GNUNET_free (a_ctx);
    a_ctx = NULL;
  }
  // FIXME: Should we collect stats only for put/get not for other messages.
  if (NULL != bandwidth_stats_op)
  {
    GNUNET_TESTBED_operation_done (bandwidth_stats_op);
    bandwidth_stats_op = NULL;
  }
  GNUNET_free (a_ac);
}

References a_ac, a_ctx, Context::ac, bandwidth_stats_op, ActiveContext::delay_task, ActiveContext::dht_get, ActiveContext::dht_put, GNUNET_DHT_get_stop(), GNUNET_DHT_put_cancel(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_YES, ActiveContext::hash, in_shutdown, num_peers, and op.

Here is the call graph for this function:

bandwidth_stats_cont()

static void bandwidth_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 340 of file gnunet_dht_profiler.c.

{
  MESSAGE ("# Outgoing (core) bandwidth: %llu bytes\n",
           (unsigned long long) outgoing_bandwidth);
  MESSAGE ("# Incoming (core) bandwidth: %llu bytes\n",
           (unsigned long long) incoming_bandwidth);
  fprintf (stderr,
           "Benchmark done. Collect data via gnunet-statistics, then press ENTER to exit.\n");
  (void) getchar ();
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_SCHEDULER_shutdown(), incoming_bandwidth, MESSAGE, and outgoing_bandwidth.

Referenced by summarize().

Here is the call graph for this function:

Here is the caller graph for this function:

bandwidth_stats_iterator()

static int bandwidth_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 367 of file gnunet_dht_profiler.c.

{
  static const char *s_sent = "# bytes encrypted";
  static const char *s_recv = "# bytes decrypted";
 
  if (0 == strncmp (s_sent, name, strlen (s_sent)))
    outgoing_bandwidth = outgoing_bandwidth + value;
  else if (0 == strncmp (s_recv, name, strlen (s_recv)))
    incoming_bandwidth = incoming_bandwidth + value;
  return GNUNET_OK;
}

References GNUNET_OK, incoming_bandwidth, name, outgoing_bandwidth, and value.

Referenced by summarize().

Here is the caller graph for this function:

summarize()

static void summarize ( )

static

Definition at line 386 of file gnunet_dht_profiler.c.

{
  MESSAGE ("# PUTS started: %llu\n",
           n_puts);
  MESSAGE ("# PUTS succeeded: %llu\n",
           n_puts_ok);
  MESSAGE ("# GETS made: %u\n",
           n_gets);
  MESSAGE ("# GETS succeeded: %u\n",
           n_gets_ok);
  MESSAGE ("# GETS failed: %u\n",
           n_gets_fail);
  MESSAGE ("# average_put_path_length: %f\n",
           average_put_path_length);
  MESSAGE ("# average_get_path_length: %f\n",
           average_get_path_length);
 
  if (NULL == testbed_handles)
  {
    MESSAGE ("No peers found\n");
    return;
  }
  /* Collect Stats*/
  bandwidth_stats_op = GNUNET_TESTBED_get_statistics (n_active,
                                                      testbed_handles,
                                                      "core",
                                                      NULL,
                                                      &bandwidth_stats_iterator,
                                                      &bandwidth_stats_cont,
                                                      NULL);
}

References average_get_path_length, average_put_path_length, bandwidth_stats_cont(), bandwidth_stats_iterator(), bandwidth_stats_op, MESSAGE, n_active, n_gets, n_gets_fail, n_gets_ok, n_puts, n_puts_ok, and testbed_handles.

Referenced by cancel_get(), and get_iter().

Here is the call graph for this function:

Here is the caller graph for this function:

cancel_get()

static void cancel_get ( void *  cls )

static

Task to cancel DHT GET.

Parameters

cls

NULL

Definition at line 425 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac = cls;
  struct Context *ctx = ac->ctx;
 
  ac->delay_task = NULL;
  GNUNET_assert (NULL != ac->dht_get);
  GNUNET_DHT_get_stop (ac->dht_get);
  ac->dht_get = NULL;
  n_gets_fail++;
  GNUNET_assert (NULL != ctx->op);
  GNUNET_TESTBED_operation_done (ctx->op);
  ctx->op = NULL;
 
  /* If profiling is complete, summarize */
  if (n_active == n_gets_fail + n_gets_ok)
  {
    average_put_path_length = (double) total_put_path_length
                              / (double) n_active;
    average_get_path_length = (double) total_get_path_length
                              / (double ) n_gets_ok;
    summarize ();
  }
}

References Context::ac, average_get_path_length, average_put_path_length, ctx, ActiveContext::ctx, ActiveContext::delay_task, ActiveContext::dht_get, GNUNET_assert, GNUNET_DHT_get_stop(), n_active, n_gets_fail, n_gets_ok, summarize(), total_get_path_length, and total_put_path_length.

Referenced by delayed_get().

Here is the call graph for this function:

Here is the caller graph for this function:

get_iter()

static void get_iter ( void *  cls, struct GNUNET_TIME_Absolute  exp, const struct GNUNET_HashCode *  key, const struct GNUNET_PeerIdentity *  trunc_peer, const struct GNUNET_DHT_PathElement *  get_path, unsigned int  get_path_length, const struct GNUNET_DHT_PathElement *  put_path, unsigned int  put_path_length, enum GNUNET_BLOCK_Type  type, size_t  size, const void *  data  )

static

Iterator called on each result obtained for a DHT operation that expects a reply.

Parameters

cls	closure
exp	when will this value expire
key	key of the result
trunc_peer	peer the path was truncated at, or NULL
get_path	peers on reply path (or NULL if not recorded) [0] = datastore's first neighbor, [length - 1] = local peer
get_path_length	number of entries in get_path
put_path	peers on the PUT path (or NULL if not recorded) [0] = origin, [length - 1] = datastore
put_path_length	number of entries in put_path
type	type of the result
size	number of bytes in data
data	pointer to the result data

Definition at line 470 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac = cls;
  struct ActiveContext *get_ac = ac->get_ac;
  struct Context *ctx = ac->ctx;
 
  /* we found the data we are looking for */
  DEBUG ("We found a GET request; %u remaining\n",
         n_gets - (n_gets_fail + n_gets_ok)); // FIXME: It always prints 1.
  n_gets_ok++;
  get_ac->nrefs--;
  GNUNET_DHT_get_stop (ac->dht_get);
  ac->dht_get = NULL;
  if (ac->delay_task != NULL)
    GNUNET_SCHEDULER_cancel (ac->delay_task);
  ac->delay_task = NULL;
  GNUNET_assert (NULL != ctx->op);
  GNUNET_TESTBED_operation_done (ctx->op);
  ctx->op = NULL;
 
  total_put_path_length = total_put_path_length + (double) put_path_length;
  total_get_path_length = total_get_path_length + (double) get_path_length;
  DEBUG ("total_put_path_length = %u,put_path \n",
         total_put_path_length);
  /* Summarize if profiling is complete */
  if (n_active == n_gets_fail + n_gets_ok)
  {
    average_put_path_length = (double) total_put_path_length
                              / (double) n_active;
    average_get_path_length = (double) total_get_path_length
                              / (double ) n_gets_ok;
    summarize ();
  }
}

References Context::ac, average_get_path_length, average_put_path_length, ctx, ActiveContext::ctx, DEBUG, ActiveContext::delay_task, ActiveContext::dht_get, ActiveContext::get_ac, GNUNET_assert, GNUNET_DHT_get_stop(), GNUNET_SCHEDULER_cancel(), n_active, n_gets, n_gets_fail, n_gets_ok, ActiveContext::nrefs, summarize(), total_get_path_length, and total_put_path_length.

Referenced by delayed_get().

Here is the call graph for this function:

Here is the caller graph for this function:

delayed_get()

static void delayed_get ( void *  cls )

static

Task to do DHT GETs.

Parameters

cls	the active context

Definition at line 522 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac = cls;
  struct ActiveContext *get_ac;
  unsigned int r;
 
  ac->delay_task = NULL;
  get_ac = NULL;
  while (1)
  {
    r = GNUNET_CRYPTO_random_u32 (n_active);
    get_ac = &a_ac[r];
    if (NULL != get_ac->hash)
      break;
  }
  get_ac->nrefs++;
  ac->get_ac = get_ac;
  r = GNUNET_CRYPTO_random_u32 (num_puts_per_peer);
  DEBUG ("GET_REQUEST_START key %s \n",
         GNUNET_h2s (&get_ac->hash[r]));
  ac->dht_get = GNUNET_DHT_get_start (ac->dht,
                                      GNUNET_BLOCK_TYPE_TEST,
                                      &get_ac->hash[r],
                                      1, /* replication level */
                                      GNUNET_DHT_RO_NONE,
                                      NULL,
                                      0, /* extended query and size */
                                      &get_iter,
                                      ac); /* GET iterator and closure */
  n_gets++;
 
  /* schedule the timeout task for GET */
  ac->delay_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                                 &cancel_get,
                                                 ac);
}

References a_ac, cancel_get(), DEBUG, ActiveContext::delay_task, ActiveContext::dht, ActiveContext::dht_get, ActiveContext::get_ac, get_iter(), GNUNET_BLOCK_TYPE_TEST, GNUNET_CRYPTO_random_u32(), GNUNET_DHT_get_start(), GNUNET_DHT_RO_NONE, GNUNET_h2s(), GNUNET_SCHEDULER_add_delayed(), ActiveContext::hash, n_active, n_gets, ActiveContext::nrefs, num_puts_per_peer, and timeout.

Referenced by dht_connected().

Here is the call graph for this function:

Here is the caller graph for this function:

delayed_put()

static void delayed_put ( void *  cls )

static

Task to do DHT PUTs.

If the "put_count" hits zero, we stop the TESTBED operation (connection to DHT) so that others PUTs have a chance.

Parameters

cls	the active context

Definition at line 597 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac = cls;
  char block[65536];
  size_t block_size;
 
  ac->delay_task = NULL;
  if (0 == ac->put_count)
  {
    struct Context *ctx = ac->ctx;
    struct GNUNET_TESTBED_Operation *op;
 
    GNUNET_assert (NULL != ctx);
    op = ctx->op;
    ctx->op = NULL;
    GNUNET_TESTBED_operation_done (op);
    return;
  }
 
 
  /* Generate and DHT PUT some random data */
  block_size = 16; /* minimum */
  /* make random payload, reserve 512 - 16 bytes for DHT headers */
  block_size += GNUNET_CRYPTO_random_u32 (
    GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE
    - 512);
  GNUNET_CRYPTO_random_block (block,
                              block_size);
  ac->put_count--;
  GNUNET_CRYPTO_hash (block,
                      block_size,
                      &ac->hash[ac->put_count]);
  DEBUG ("PUT_REQUEST_START key %s\n",
         GNUNET_h2s (&ac->hash[ac->put_count]));
  ac->dht_put = GNUNET_DHT_put (ac->dht,
                                &ac->hash[ac->put_count],
                                replication,
                                GNUNET_DHT_RO_RECORD_ROUTE,
                                GNUNET_BLOCK_TYPE_TEST,
                                block_size,
                                block,
                                GNUNET_TIME_UNIT_FOREVER_ABS, /* expiration time */
                                &put_cont,
                                ac);                /* continuation and its closure */
  n_puts++;
}

References Context::ac, ctx, ActiveContext::ctx, DEBUG, ActiveContext::delay_task, ActiveContext::dht, ActiveContext::dht_put, GNUNET_assert, GNUNET_BLOCK_TYPE_TEST, GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_random_block(), GNUNET_CRYPTO_random_u32(), GNUNET_DHT_put(), GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_h2s(), GNUNET_TIME_UNIT_FOREVER_ABS, ActiveContext::hash, n_puts, op, put_cont(), ActiveContext::put_count, and replication.

Referenced by dht_connected(), and put_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

put_cont()

static void put_cont ( void *  cls )

static

Conclude individual PUT operation, schedule the next one.

Parameters

cls	the active context

Definition at line 578 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac = cls;
 
  ac->dht_put = NULL;
  n_puts_ok++;
  ac->delay_task = GNUNET_SCHEDULER_add_now (&delayed_put,
                                             ac);
}

References ActiveContext::delay_task, delayed_put(), ActiveContext::dht_put, GNUNET_SCHEDULER_add_now(), and n_puts_ok.

Referenced by delayed_put().

Here is the call graph for this function:

Here is the caller graph for this function:

dht_connected()

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

static

Connection to DHT has been established.

Call the delay task.

Parameters

cls	the active context
op	the operation that has been finished
ca_result	the service handle returned from GNUNET_TESTBED_ConnectAdapter()
emsg	error message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 655 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac = cls;
  struct Context *ctx = ac->ctx;
 
  GNUNET_assert (NULL != ctx);  // FIXME: Fails
  GNUNET_assert (NULL != ctx->op);
  GNUNET_assert (ctx->op == op);
  ac->dht = (struct GNUNET_DHT_Handle *) ca_result;
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Connection to DHT service failed: %s\n",
                emsg);
    GNUNET_TESTBED_operation_done (ctx->op);  /* Calls dht_disconnect() */
    ctx->op = NULL;
    return;
  }
  switch (mode)
  {
  case MODE_PUT:
    {
      struct GNUNET_TIME_Relative peer_delay_put;
 
      peer_delay_put.rel_value_us =
        GNUNET_CRYPTO_random_u64 (delay_put.rel_value_us);
      ac->put_count = num_puts_per_peer;
      ac->hash = calloc (ac->put_count,
                         sizeof(struct GNUNET_HashCode));
      if (NULL == ac->hash)
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                             "calloc");
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_put,
                                                     &delayed_put,
                                                     ac);
      break;
    }
 
  case MODE_GET:
    {
      struct GNUNET_TIME_Relative peer_delay_get;
 
      peer_delay_get.rel_value_us =
        delay_get.rel_value_us
        + GNUNET_CRYPTO_random_u64 (delay_get.rel_value_us);
      ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_get,
                                                     &delayed_get,
                                                     ac);
      break;
    }
  }
}

References Context::ac, ctx, ActiveContext::ctx, delay_get, delay_put, ActiveContext::delay_task, delayed_get(), delayed_put(), ActiveContext::dht, GNUNET_assert, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_strerror, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), ActiveContext::hash, mode, MODE_GET, MODE_PUT, num_puts_per_peer, op, ActiveContext::put_count, and GNUNET_TIME_Relative::rel_value_us.

Referenced by start_profiling().

Here is the call graph for this function:

Here is the caller graph for this function:

dht_connect()

static void * dht_connect ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Connect to DHT service and return the DHT client handler.

Parameters

cls	the active context
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns

service handle to return in 'op_result', NULL on error

Definition at line 726 of file gnunet_dht_profiler.c.

{
  n_dht++;
  return GNUNET_DHT_connect (cfg,
                             10);
}

References cfg, GNUNET_DHT_connect(), and n_dht.

Referenced by start_profiling().

Here is the call graph for this function:

Here is the caller graph for this function:

dht_disconnect()

static void dht_disconnect ( void *  cls, void *  op_result  )

static

Adapter function called to destroy a connection to a service.

Parameters

cls	the active context
op_result	service handle returned from the connect adapter

Definition at line 743 of file gnunet_dht_profiler.c.

{
  struct ActiveContext *ac = cls;
 
  GNUNET_assert (NULL != ac->dht);
  GNUNET_assert (ac->dht == op_result);
  GNUNET_DHT_disconnect (ac->dht);
  ac->dht = NULL;
  n_dht--;
  if (0 != n_dht)
    return;
  if (GNUNET_YES == in_shutdown)
    return;
  switch (mode)
  {
  case MODE_PUT:
    if (n_puts_ok != ((unsigned long long) n_active) * num_puts_per_peer)
      return;
    /* Start GETs if all PUTs have been made */
    mode = MODE_GET;
    start_profiling ();
    return;
 
  case MODE_GET:
    if ((n_gets_ok + n_gets_fail) != n_active)
      return;
    break;
  }
}

References ActiveContext::dht, GNUNET_assert, GNUNET_DHT_disconnect(), GNUNET_YES, in_shutdown, mode, MODE_GET, MODE_PUT, n_active, n_dht, n_gets_fail, n_gets_ok, n_puts_ok, num_puts_per_peer, and start_profiling().

Referenced by start_profiling().

Here is the call graph for this function:

Here is the caller graph for this function:

service_started()

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

static

Callback called when DHT service on the peer is started.

Parameters

cls	the context
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 810 of file gnunet_dht_profiler.c.

{
  struct Context *ctx = cls;
 
  GNUNET_assert (NULL != ctx);
  GNUNET_assert (NULL != ctx->op);
  GNUNET_TESTBED_operation_done (ctx->op);
  ctx->op = NULL;
  peers_started++;
  DEBUG ("Peers Started = %d; num_peers = %d \n",
         peers_started,
         num_peers);
  if (peers_started == num_peers)
    start_profiling ();
}

References ctx, DEBUG, GNUNET_assert, num_peers, peers_started, and start_profiling().

Referenced by test_run().

Here is the call graph for this function:

Here is the caller graph for this function:

test_run()

static void test_run ( void *  cls, struct GNUNET_TESTBED_RunHandle *  h, unsigned int  num_peers, struct GNUNET_TESTBED_Peer **  peers, unsigned int  links_succeeded, unsigned int  links_failed  )

static

Signature of a main function for a testcase.

Parameters

cls	closure
h	the run handle
num_peers	number of peers in 'peers'
peers	handle to peers run in the testbed
links_succeeded	the number of overlay link connection attempts that succeeded
links_failed	the number of overlay link

Definition at line 841 of file gnunet_dht_profiler.c.

{
  unsigned int ac_cnt;
 
  testbed_handles = peers;
  if (NULL == peers)
  {
    /* exit */
    GNUNET_assert (0);
  }
  MESSAGE ("%u peers started, %u/%u links up\n",
           num_peers,
           links_succeeded,
           links_succeeded + links_failed);
  a_ctx = GNUNET_new_array (num_peers,
                            struct Context);
  /* select the peers which actively participate in profiling */
  n_active = num_peers * put_probability / 100;
  if (0 == n_active)
  {
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (a_ctx);
    a_ctx = NULL;
    return;
  }
 
  a_ac = GNUNET_new_array (n_active,
                           struct ActiveContext);
  ac_cnt = 0;
  for (unsigned int cnt = 0; cnt < num_peers && ac_cnt < n_active; cnt++)
  {
    if (GNUNET_CRYPTO_random_u32 (100) >= put_probability)
      continue;
 
    a_ctx[cnt].ac = &a_ac[ac_cnt];
    a_ac[ac_cnt].ctx = &a_ctx[cnt];
    ac_cnt++;
  }
  n_active = ac_cnt;
 
  /* start DHT service on all peers */
  for (unsigned int cnt = 0; cnt < num_peers; cnt++)
  {
    a_ctx[cnt].peer = peers[cnt];
    a_ctx[cnt].op = GNUNET_TESTBED_peer_manage_service (&a_ctx[cnt],
                                                        peers[cnt],
                                                        "dht",
                                                        &service_started,
                                                        &a_ctx[cnt],
                                                        1);
  }
}

References a_ac, a_ctx, Context::ac, ActiveContext::ctx, GNUNET_assert, GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_new_array, GNUNET_SCHEDULER_shutdown(), MESSAGE, n_active, num_peers, Context::op, Context::peer, peers, put_probability, service_started(), and testbed_handles.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  config  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
config	configuration

Definition at line 909 of file gnunet_dht_profiler.c.

{
  uint64_t event_mask;
 
  if (0 == num_peers)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Exiting as the number of peers is %u\n"),
                num_peers);
    return;
  }
  cfg = config;
  event_mask = 0;
  GNUNET_TESTBED_run (hosts_file,
                      cfg,
                      num_peers,
                      event_mask,
                      NULL,
                      NULL,
                      &test_run,
                      NULL);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                 NULL);
}

References _, cfg, config, do_shutdown, event_mask, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), hosts_file, num_peers, and test_run().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

Main function.

Returns

0 on success

Definition at line 944 of file gnunet_dht_profiler.c.

{
  int rc;
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_uint ('n',
                               "peers",
                               "COUNT",
                               gettext_noop ("number of peers to start"),
                               &num_peers),
    GNUNET_GETOPT_option_uint ('p',
                               "peer-put-count",
                               "COUNT",
                               gettext_noop (
                                 "number of PUTs to perform per peer"),
                               &num_puts_per_peer),
    GNUNET_GETOPT_option_string ('H',
                                 "hosts",
                                 "FILENAME",
                                 gettext_noop (
                                   "name of the file with the login information for the testbed"),
                                 &hosts_file),
    GNUNET_GETOPT_option_relative_time ('D',
                                        "delay",
                                        "DELAY",
                                        gettext_noop (
                                          "delay between rounds for collecting statistics (default: 30 sec)"),
                                        &delay_stats),
    GNUNET_GETOPT_option_relative_time ('P',
                                        "PUT-delay",
                                        "DELAY",
                                        gettext_noop (
                                          "delay to start doing PUTs (default: 1 sec)"),
                                        &delay_put),
    GNUNET_GETOPT_option_relative_time ('G',
                                        "GET-delay",
                                        "DELAY",
                                        gettext_noop (
                                          "delay to start doing GETs (default: 5 min)"),
                                        &delay_get),
    GNUNET_GETOPT_option_uint ('r',
                               "replication",
                               "DEGREE",
                               gettext_noop ("replication degree for DHT PUTs"),
                               &replication),
    GNUNET_GETOPT_option_uint ('R',
                               "random-chance",
                               "PROBABILITY",
                               gettext_noop (
                                 "chance that a peer is selected at random for PUTs"),
                               &put_probability),
    GNUNET_GETOPT_option_relative_time ('t',
                                        "timeout",
                                        "TIMEOUT",
                                        gettext_noop (
                                          "timeout for DHT PUT and GET requests (default: 1 min)"),
                                        &timeout),
    GNUNET_GETOPT_OPTION_END
  };
 
  /* set default delays */
  delay_stats = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  delay_put = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  delay_get = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
  replication = 1;      /* default replication */
  rc = 0;
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run (argc,
                          argv,
                          "gnunet-dht-profiler",
                          gettext_noop (
                            "Measure quality and performance of the DHT service."),
                          options,
                          &run,
                          NULL))
    rc = 1;
  return rc;
}

References delay_get, delay_put, delay_stats, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_uint(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, hosts_file, num_peers, num_puts_per_peer, options, put_probability, replication, run(), and timeout.

Here is the call graph for this function:

Variable Documentation

put_probability

unsigned int put_probability = 100

static

Number of peers which should perform a PUT out of 100 peers.

Definition at line 43 of file gnunet_dht_profiler.c.

Referenced by main(), and test_run().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration.

Definition at line 48 of file gnunet_dht_profiler.c.

Referenced by dht_connect(), and run().

hosts_file

char* hosts_file

static

Name of the file with the hosts to run the test over.

Definition at line 53 of file gnunet_dht_profiler.c.

Referenced by main(), and run().

a_ctx

struct Context* a_ctx

static

An array of contexts.

The size of this array should be equal to num_peers

Definition at line 138 of file gnunet_dht_profiler.c.

Referenced by do_shutdown(), and test_run().

a_ac

struct ActiveContext* a_ac

static

Array of active peers.

Definition at line 143 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), do_shutdown(), start_profiling(), and test_run().

delay_stats

struct GNUNET_TIME_Relative delay_stats

static

The delay between rounds for collecting statistics.

Definition at line 148 of file gnunet_dht_profiler.c.

Referenced by main().

delay_put

struct GNUNET_TIME_Relative delay_put

static

The delay to start puts.

Definition at line 153 of file gnunet_dht_profiler.c.

Referenced by dht_connected(), and main().

delay_get

struct GNUNET_TIME_Relative delay_get

static

The delay to start puts.

Definition at line 158 of file gnunet_dht_profiler.c.

Referenced by dht_connected(), and main().

timeout

struct GNUNET_TIME_Relative timeout

static

The timeout for GET and PUT.

Definition at line 163 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), and main().

num_peers

unsigned int num_peers

static

Number of peers.

Definition at line 168 of file gnunet_dht_profiler.c.

Referenced by check_client_keygen(), check_client_seed(), check_n_peers_ready(), check_stream_input(), check_view_update(), clients_notify_stream_peer(), clients_notify_view_update(), collect_peers_cb(), collect_peers_info_cb(), do_shutdown(), extend_path(), GNUNET_CONSENSUS_create(), GNUNET_SECRETSHARING_create_session(), GNUNET_TRANSPORT_TESTING_connect_check(), GNUNET_TRANSPORT_TESTING_main_(), handle_client_seed(), handle_stream_input(), hist_update(), keygen_reveal_get_enc_preshare(), keygen_reveal_get_exp_preshare(), main(), peers_ready_cb(), restore_valid_peers(), rfn_commit(), rfn_contest(), rfn_vote(), RPS_sampler_get_n_rand_peers(), RPS_sampler_update_with_nw_size(), run(), run(), send_stream_peers(), service_started(), stream_input_handle(), task_start_eval_echo(), task_start_grade(), and test_run().

n_active

unsigned int n_active

static

Number of active peers.

Definition at line 173 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), delayed_get(), dht_disconnect(), get_iter(), start_profiling(), summarize(), and test_run().

n_dht

unsigned int n_dht

static

Number of DHT service connections we currently have.

Definition at line 178 of file gnunet_dht_profiler.c.

Referenced by dht_connect(), and dht_disconnect().

n_puts

unsigned long long n_puts

static

Number of DHT PUTs made.

Definition at line 183 of file gnunet_dht_profiler.c.

Referenced by delayed_put(), and summarize().

num_puts_per_peer

unsigned int num_puts_per_peer = 1

static

Number of DHT PUTs to be made per peer.

Definition at line 188 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), dht_connected(), dht_disconnect(), and main().

n_puts_ok

unsigned long long n_puts_ok

static

Number of DHT PUTs succeeded.

Definition at line 193 of file gnunet_dht_profiler.c.

Referenced by dht_disconnect(), put_cont(), and summarize().

n_gets

unsigned int n_gets

static

Number of DHT GETs made.

Definition at line 198 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), get_iter(), and summarize().

n_gets_ok

unsigned int n_gets_ok

static

Number of DHT GETs succeeded.

Definition at line 203 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), dht_disconnect(), get_iter(), and summarize().

n_gets_fail

unsigned int n_gets_fail

static

Number of DHT GETs succeeded.

Definition at line 208 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), dht_disconnect(), get_iter(), and summarize().

replication

unsigned int replication

static

Replication degree.

Definition at line 213 of file gnunet_dht_profiler.c.

Referenced by delayed_put(), and main().

bandwidth_stats_op

struct GNUNET_TESTBED_Operation* bandwidth_stats_op

static

Testbed Operation (to get stats).

Definition at line 218 of file gnunet_dht_profiler.c.

Referenced by do_shutdown(), and summarize().

testbed_handles

struct GNUNET_TESTBED_Peer** testbed_handles

static

Testbed peer handles.

Definition at line 223 of file gnunet_dht_profiler.c.

Referenced by summarize(), and test_run().

outgoing_bandwidth

uint64_t outgoing_bandwidth

static

Total number of messages sent by peer.

Definition at line 228 of file gnunet_dht_profiler.c.

Referenced by bandwidth_stats_cont(), and bandwidth_stats_iterator().

incoming_bandwidth

uint64_t incoming_bandwidth

static

Total number of messages received by peer.

Definition at line 233 of file gnunet_dht_profiler.c.

Referenced by bandwidth_stats_cont(), and bandwidth_stats_iterator().

average_put_path_length

double average_put_path_length

static

Average number of hops taken to do put.

Definition at line 238 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), get_iter(), and summarize().

average_get_path_length

double average_get_path_length

static

Average number of hops taken to do get.

Definition at line 243 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), get_iter(), and summarize().

total_put_path_length

unsigned int total_put_path_length

static

Total put path length across all peers.

Definition at line 248 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), and get_iter().

total_get_path_length

unsigned int total_get_path_length

static

Total get path length across all peers.

Definition at line 253 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), and get_iter().

peers_started

int peers_started = 0

static

Counter to keep track of peers added to peer_context lists.

Definition at line 258 of file gnunet_dht_profiler.c.

Referenced by service_started().

[]

enum { ... } mode

Should we do a PUT (mode = 0) or GET (mode = 1);.

Referenced by dht_connected(), dht_disconnect(), GNUNET_CRYPTO_hpke_receiver_setup2(), GNUNET_CRYPTO_hpke_sender_setup2(), GNUNET_DISK_file_open(), GNUNET_DISK_fix_permissions(), GNUNET_DISK_fn_write(), key_schedule(), pack_message(), translate_unix_perms(), and verify_psk_inputs().

in_shutdown

int in_shutdown = 0

static

Are we shutting down.

Definition at line 274 of file gnunet_dht_profiler.c.

Referenced by dht_disconnect(), do_shutdown(), and start_profiling().