gnunet-gns-benchmark.c File Reference

#include "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_gnsrecord_lib.h>
#include <gnunet_gns_service.h>

Include dependency graph for gnunet-gns-benchmark.c:

Go to the source code of this file.

Data Structures
struct	Request
	Request we should make. More...

Macros
#define	DEF_REQUEST_DELAY
	How long do we wait at least between requests by default?
#define	DEF_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
	How long do we wait until we consider a request failed by default?

Enumerations
enum	RequestCategory { RC_SHARED = 0 , RC_PRIVATE = 1 , RC_MAX = 2 }
	We distinguish between different categories of requests, for which we track statistics separately. More...

Functions
static void	free_request (struct Request *req)
	Free req and data structures reachable from it.
static void	process_result (void *cls, int gns_tld, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Function called with the result of a GNS resolution.
static void	process_queue (void *cls)
	Process request from the queue.
static int	compare_req (const void *c1, const void *c2)
	Compare two requests by latency for qsort().
static void	do_shutdown (void *cls)
	Output statistics, then clean up and terminate the process.
static void	queue (const char *hostname, enum RequestCategory cat)
	Add hostname to the list of requests to be made.
static void	process_stdin (void *cls)
	Begin processing hostnames from stdin.
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Process requests from the queue, then if the queue is not empty, try again.
int	main (int argc, char *const *argv)
	Call with list of names with numeric category to query.

Variables
static struct GNUNET_GNS_Handle *	gns
	GNS handle.
static unsigned int	lookups [RC_MAX]
	Number of lookups we performed overall per category.
static unsigned int	replies [RC_MAX]
	Number of replies we got per category.
static unsigned int	failures [RC_MAX]
	Number of replies we got per category.
static struct GNUNET_TIME_Relative	latency_sum [RC_MAX]
	Sum of the observed latencies of successful queries, per category.
static struct Request *	act_head
	Active requests are kept in a DLL.
static struct Request *	act_tail
	Active requests are kept in a DLL.
static struct Request *	succ_head
	Completed successful requests are kept in a DLL.
static struct Request *	succ_tail
	Completed successful requests are kept in a DLL.
static struct Request *	todo_head
	Yet to be started requests are kept in a DLL.
static struct Request *	todo_tail
	Yet to be started requests are kept in a DLL.
static struct GNUNET_SCHEDULER_Task *	t
	Main task.
static struct GNUNET_TIME_Relative	request_delay
	Delay between requests.
static struct GNUNET_TIME_Relative	timeout
	Timeout for requests.
static unsigned int	active_cnt
	Number of requests we have concurrently active.
static int	g2d
	Look for GNS2DNS records specifically?

Macro Definition Documentation

DEF_REQUEST_DELAY

#define DEF_REQUEST_DELAY

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MILLISECONDS, 1)

How long do we wait at least between requests by default?

Definition at line 34 of file gnunet-gns-benchmark.c.

{
  RC_SHARED = 0,
  RC_PRIVATE = 1,
  RC_MAX = 2
};
 
 
struct Request
{
  struct Request *next;
 
  struct Request *prev;
 
  struct GNUNET_GNS_LookupWithTldRequest *lr;
 
  const char *hostname;
 
  struct GNUNET_TIME_Absolute op_start_time;
 
  struct GNUNET_TIME_Relative latency;
 
  enum RequestCategory cat;
};
 
 
static struct GNUNET_GNS_Handle *gns;
 
static unsigned int lookups[RC_MAX];
 
static unsigned int replies[RC_MAX];
 
static unsigned int failures[RC_MAX];
 
static struct GNUNET_TIME_Relative latency_sum[RC_MAX];
 
static struct Request *act_head;
 
static struct Request *act_tail;
 
static struct Request *succ_head;
 
static struct Request *succ_tail;
 
static struct Request *todo_head;
 
static struct Request *todo_tail;
 
static struct GNUNET_SCHEDULER_Task *t;
 
static struct GNUNET_TIME_Relative request_delay;
 
static struct GNUNET_TIME_Relative timeout;
 
static unsigned int active_cnt;
 
static int g2d;
 
static void
free_request (struct Request *req)
{
  if (NULL != req->lr)
    GNUNET_GNS_lookup_with_tld_cancel (req->lr);
  GNUNET_free (req);
}
 
 
static void
process_result (void *cls,
                int gns_tld,
                uint32_t rd_count,
                const struct GNUNET_GNSRECORD_Data *rd)
{
  struct Request *req = cls;
 
  (void) gns_tld;
  (void) rd_count;
  (void) rd;
  active_cnt--;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got response for request `%s'\n",
              req->hostname);
  req->lr = NULL;
  req->latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
  GNUNET_CONTAINER_DLL_remove (act_head,
                               act_tail,
                               req);
  GNUNET_CONTAINER_DLL_insert (succ_head,
                               succ_tail,
                               req);
  replies[req->cat]++;
  latency_sum[req->cat]
    = GNUNET_TIME_relative_add (latency_sum[req->cat],
                                req->latency);
}
 
 
static void
process_queue (void *cls)
{
  struct Request *req;
  struct GNUNET_TIME_Relative duration;
 
  (void) cls;
  t = NULL;
  /* check for expired requests */
  while (NULL != (req = act_head))
  {
    duration = GNUNET_TIME_absolute_get_duration (req->op_start_time);
    if (duration.rel_value_us < timeout.rel_value_us)
      break;
    GNUNET_CONTAINER_DLL_remove (act_head,
                                 act_tail,
                                 req);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Failing request `%s' due to timeout\n",
                req->hostname);
    failures[req->cat]++;
    active_cnt--;
    free_request (req);
  }
  if (NULL == (req = todo_head))
  {
    struct GNUNET_TIME_Absolute at;
 
    if (NULL == (req = act_head))
    {
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    at = GNUNET_TIME_absolute_add (req->op_start_time,
                                   timeout);
    t = GNUNET_SCHEDULER_add_at (at,
                                 &process_queue,
                                 NULL);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (todo_head,
                               todo_tail,
                               req);
  GNUNET_CONTAINER_DLL_insert_tail (act_head,
                                    act_tail,
                                    req);
  lookups[req->cat]++;
  active_cnt++;
  req->op_start_time = GNUNET_TIME_absolute_get ();
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting request `%s' (%u in parallel)\n",
              req->hostname,
              active_cnt);
  req->lr = GNUNET_GNS_lookup_with_tld (gns,
                                        req->hostname,
                                        g2d
                                        ? GNUNET_GNSRECORD_TYPE_GNS2DNS
                                        : GNUNET_GNSRECORD_TYPE_ANY,
                                        GNUNET_GNS_LO_DEFAULT,
                                        &process_result,
                                        req);
  t = GNUNET_SCHEDULER_add_delayed (request_delay,
                                    &process_queue,
                                    NULL);
}
 
 
static int
compare_req (const void *c1,
             const void *c2)
{
  const struct Request *r1 = *(void **) c1;
  const struct Request *r2 = *(void **) c2;
 
  if (r1->latency.rel_value_us < r2->latency.rel_value_us)
    return -1;
  if (r1->latency.rel_value_us > r2->latency.rel_value_us)
    return 1;
  return 0;
}
 
 
static void
do_shutdown (void *cls)
{
  struct Request *req;
  struct Request **ra[RC_MAX];
  unsigned int rp[RC_MAX];
 
  (void) cls;
  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
  {
    ra[rc] = GNUNET_new_array (replies[rc],
                               struct Request *);
    rp[rc] = 0;
  }
  for (req = succ_head; NULL != req; req = req->next)
  {
    GNUNET_assert (rp[req->cat] < replies[req->cat]);
    ra[req->cat][rp[req->cat]++] = req;
  }
  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
  {
    unsigned int off;
 
    fprintf (stdout,
             "Category %u\n",
             rc);
    fprintf (stdout,
             "\tlookups: %u replies: %u failures: %u\n",
             lookups[rc],
             replies[rc],
             failures[rc]);
    if (0 == rp[rc])
      continue;
    qsort (ra[rc],
           rp[rc],
           sizeof(struct Request *),
           &compare_req);
    latency_sum[rc] = GNUNET_TIME_relative_divide (latency_sum[rc],
                                                   replies[rc]);
    fprintf (stdout,
             "\taverage: %s\n",
             GNUNET_STRINGS_relative_time_to_string (latency_sum[rc],
                                                     GNUNET_YES));
    off = rp[rc] * 50 / 100;
    fprintf (stdout,
             "\tmedian(50): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    off = rp[rc] * 75 / 100;
    fprintf (stdout,
             "\tquantile(75): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    off = rp[rc] * 90 / 100;
    fprintf (stdout,
             "\tquantile(90): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    off = rp[rc] * 99 / 100;
    fprintf (stdout,
             "\tquantile(99): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    GNUNET_free (ra[rc]);
  }
  if (NULL != t)
  {
    GNUNET_SCHEDULER_cancel (t);
    t = NULL;
  }
  while (NULL != (req = act_head))
  {
    GNUNET_CONTAINER_DLL_remove (act_head,
                                 act_tail,
                                 req);
    free_request (req);
  }
  while (NULL != (req = succ_head))
  {
    GNUNET_CONTAINER_DLL_remove (succ_head,
                                 succ_tail,
                                 req);
    free_request (req);
  }
  while (NULL != (req = todo_head))
  {
    GNUNET_CONTAINER_DLL_remove (todo_head,
                                 todo_tail,
                                 req);
    free_request (req);
  }
  if (NULL != gns)
  {
    GNUNET_GNS_disconnect (gns);
    gns = NULL;
  }
}
 
 
static void
queue (const char *hostname,
       enum RequestCategory cat)
{
  struct Request *req;
  const char *dot;
  size_t hlen;
 
  dot = strchr (hostname,
                (unsigned char) '.');
  if (NULL == dot)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Refusing invalid hostname `%s' (lacks '.')\n",
                hostname);
    return;
  }
  hlen = strlen (hostname) + 1;
  req = GNUNET_malloc (sizeof(struct Request) + hlen);
  req->cat = cat;
  req->hostname = (char *) &req[1];
  GNUNET_memcpy (&req[1],
                 hostname,
                 hlen);
  GNUNET_CONTAINER_DLL_insert (todo_head,
                               todo_tail,
                               req);
}
 
 
static void
process_stdin (void *cls)
{
  static struct GNUNET_TIME_Absolute last;
  static uint64_t idot;
  unsigned int cat;
  char hn[256];
  char in[270];
 
  (void) cls;
  t = NULL;
  while (NULL !=
         fgets (in,
                sizeof(in),
                stdin))
  {
    if (strlen (in) > 0)
      hn[strlen (in) - 1] = '\0';  /* eat newline */
    if ((2 != sscanf (in,
                      "%u %255s",
                      &cat,
                      hn)) ||
        (cat >= RC_MAX))
    {
      fprintf (stderr,
               "Malformed input line `%s', skipping\n",
               in);
      continue;
    }
    if (0 == idot)
      last = GNUNET_TIME_absolute_get ();
    idot++;
    if (0 == idot % 100000)
    {
      struct GNUNET_TIME_Relative delta;
 
      delta = GNUNET_TIME_absolute_get_duration (last);
      last = GNUNET_TIME_absolute_get ();
      fprintf (stderr,
               "Read 100000 domain names in %s\n",
               GNUNET_STRINGS_relative_time_to_string (delta,
                                                       GNUNET_YES));
    }
    queue (hn,
           (enum RequestCategory) cat);
  }
  fprintf (stderr,
           "Done reading %llu domain names\n",
           (unsigned long long) idot);
  t = GNUNET_SCHEDULER_add_now (&process_queue,
                                NULL);
}
 
 
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  (void) cls;
  (void) args;
  (void) cfgfile;
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                 NULL);
  gns = GNUNET_GNS_connect (cfg);
  if (NULL == gns)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  t = GNUNET_SCHEDULER_add_now (&process_stdin,
                                NULL);
}
 
 
int
main (int argc,
      char *const*argv)
{
  int ret = 0;
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_relative_time ('d',
                                        "delay",
                                        "RELATIVETIME",
                                        gettext_noop (
                                          "how long to wait between queries"),
                                        &request_delay),
    GNUNET_GETOPT_option_relative_time ('t',
                                        "timeout",
                                        "RELATIVETIME",
                                        gettext_noop (
                                          "how long to wait for an answer"),
                                        &timeout),
    GNUNET_GETOPT_option_flag ('2',
                               "g2d",
                               gettext_noop (
                                 "look for GNS2DNS records instead of ANY"),
                               &g2d),
    GNUNET_GETOPT_OPTION_END
  };
 
  timeout = DEF_TIMEOUT;
  request_delay = DEF_REQUEST_DELAY;
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                          argc,
                          argv,
                          "gnunet-gns-benchmark",
                          "resolve GNS names and measure performance",
                          options,
                          &run,
                          NULL))
    ret = 1;
  return ret;
}
 
 
/* end of gnunet-gns-benchmark.c */

DEF_TIMEOUT

#define DEF_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)

How long do we wait until we consider a request failed by default?

Definition at line 40 of file gnunet-gns-benchmark.c.

Enumeration Type Documentation

RequestCategory

enum RequestCategory

We distinguish between different categories of requests, for which we track statistics separately.

However, this process does not change how it acts based on the category.

Enumerator
RC_SHARED
RC_PRIVATE
RC_MAX	Must be last and match number of categories.

Definition at line 49 of file gnunet-gns-benchmark.c.

{
  RC_SHARED = 0,
  RC_PRIVATE = 1,
  RC_MAX = 2
};

Function Documentation

free_request()

static void free_request ( struct Request *  req )

static

Free req and data structures reachable from it.

Parameters

req	request to free

Definition at line 194 of file gnunet-gns-benchmark.c.

{
  if (NULL != req->lr)
    GNUNET_GNS_lookup_with_tld_cancel (req->lr);
  GNUNET_free (req);
}

References GNUNET_free, GNUNET_GNS_lookup_with_tld_cancel(), and Request::lr.

Referenced by do_shutdown(), and process_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

process_result()

static void process_result ( void *  cls, int  gns_tld, uint32_t  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Function called with the result of a GNS resolution.

Parameters

cls	closure with the struct Request
gns_tld	GNUNET_YES if GNS lookup was attempted
rd_count	number of records in rd
rd	the records in reply

Definition at line 211 of file gnunet-gns-benchmark.c.

{
  struct Request *req = cls;
 
  (void) gns_tld;
  (void) rd_count;
  (void) rd;
  active_cnt--;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got response for request `%s'\n",
              req->hostname);
  req->lr = NULL;
  req->latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
  GNUNET_CONTAINER_DLL_remove (act_head,
                               act_tail,
                               req);
  GNUNET_CONTAINER_DLL_insert (succ_head,
                               succ_tail,
                               req);
  replies[req->cat]++;
  latency_sum[req->cat]
    = GNUNET_TIME_relative_add (latency_sum[req->cat],
                                req->latency);
}

References act_head, act_tail, active_cnt, Request::cat, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_add(), Request::hostname, Request::latency, latency_sum, Request::lr, Request::op_start_time, rd, rd_count, replies, succ_head, and succ_tail.

Referenced by process_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

process_queue()

static void process_queue ( void *  cls )

static

Process request from the queue.

Parameters

cls

NULL

Definition at line 246 of file gnunet-gns-benchmark.c.

{
  struct Request *req;
  struct GNUNET_TIME_Relative duration;
 
  (void) cls;
  t = NULL;
  /* check for expired requests */
  while (NULL != (req = act_head))
  {
    duration = GNUNET_TIME_absolute_get_duration (req->op_start_time);
    if (duration.rel_value_us < timeout.rel_value_us)
      break;
    GNUNET_CONTAINER_DLL_remove (act_head,
                                 act_tail,
                                 req);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Failing request `%s' due to timeout\n",
                req->hostname);
    failures[req->cat]++;
    active_cnt--;
    free_request (req);
  }
  if (NULL == (req = todo_head))
  {
    struct GNUNET_TIME_Absolute at;
 
    if (NULL == (req = act_head))
    {
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    at = GNUNET_TIME_absolute_add (req->op_start_time,
                                   timeout);
    t = GNUNET_SCHEDULER_add_at (at,
                                 &process_queue,
                                 NULL);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (todo_head,
                               todo_tail,
                               req);
  GNUNET_CONTAINER_DLL_insert_tail (act_head,
                                    act_tail,
                                    req);
  lookups[req->cat]++;
  active_cnt++;
  req->op_start_time = GNUNET_TIME_absolute_get ();
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting request `%s' (%u in parallel)\n",
              req->hostname,
              active_cnt);
  req->lr = GNUNET_GNS_lookup_with_tld (gns,
                                        req->hostname,
                                        g2d
                                        ? GNUNET_GNSRECORD_TYPE_GNS2DNS
                                        : GNUNET_GNSRECORD_TYPE_ANY,
                                        GNUNET_GNS_LO_DEFAULT,
                                        &process_result,
                                        req);
  t = GNUNET_SCHEDULER_add_delayed (request_delay,
                                    &process_queue,
                                    NULL);
}

References act_head, act_tail, active_cnt, Request::cat, duration, failures, free_request(), g2d, gns, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNS_LO_DEFAULT, GNUNET_GNS_lookup_with_tld(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_TYPE_GNS2DNS, GNUNET_log, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), Request::hostname, lookups, Request::lr, Request::op_start_time, process_queue(), process_result(), GNUNET_TIME_Relative::rel_value_us, request_delay, t, timeout, todo_head, and todo_tail.

Referenced by process_queue(), and process_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_req()

static int compare_req ( const void *  c1, const void *  c2  )

static

Compare two requests by latency for qsort().

Parameters

c1	pointer to struct Request *
c2	pointer to struct Request *

Returns

-1 if c1<c2, 1 if c1>c2, 0 if c1==c2.

Definition at line 320 of file gnunet-gns-benchmark.c.

{
  const struct Request *r1 = *(void **) c1;
  const struct Request *r2 = *(void **) c2;
 
  if (r1->latency.rel_value_us < r2->latency.rel_value_us)
    return -1;
  if (r1->latency.rel_value_us > r2->latency.rel_value_us)
    return 1;
  return 0;
}

References Request::latency, and GNUNET_TIME_Relative::rel_value_us.

Referenced by do_shutdown().

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Output statistics, then clean up and terminate the process.

Parameters

cls

NULL

Definition at line 340 of file gnunet-gns-benchmark.c.

{
  struct Request *req;
  struct Request **ra[RC_MAX];
  unsigned int rp[RC_MAX];
 
  (void) cls;
  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
  {
    ra[rc] = GNUNET_new_array (replies[rc],
                               struct Request *);
    rp[rc] = 0;
  }
  for (req = succ_head; NULL != req; req = req->next)
  {
    GNUNET_assert (rp[req->cat] < replies[req->cat]);
    ra[req->cat][rp[req->cat]++] = req;
  }
  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
  {
    unsigned int off;
 
    fprintf (stdout,
             "Category %u\n",
             rc);
    fprintf (stdout,
             "\tlookups: %u replies: %u failures: %u\n",
             lookups[rc],
             replies[rc],
             failures[rc]);
    if (0 == rp[rc])
      continue;
    qsort (ra[rc],
           rp[rc],
           sizeof(struct Request *),
           &compare_req);
    latency_sum[rc] = GNUNET_TIME_relative_divide (latency_sum[rc],
                                                   replies[rc]);
    fprintf (stdout,
             "\taverage: %s\n",
             GNUNET_STRINGS_relative_time_to_string (latency_sum[rc],
                                                     GNUNET_YES));
    off = rp[rc] * 50 / 100;
    fprintf (stdout,
             "\tmedian(50): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    off = rp[rc] * 75 / 100;
    fprintf (stdout,
             "\tquantile(75): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    off = rp[rc] * 90 / 100;
    fprintf (stdout,
             "\tquantile(90): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    off = rp[rc] * 99 / 100;
    fprintf (stdout,
             "\tquantile(99): %s\n",
             GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
                                                     GNUNET_YES));
    GNUNET_free (ra[rc]);
  }
  if (NULL != t)
  {
    GNUNET_SCHEDULER_cancel (t);
    t = NULL;
  }
  while (NULL != (req = act_head))
  {
    GNUNET_CONTAINER_DLL_remove (act_head,
                                 act_tail,
                                 req);
    free_request (req);
  }
  while (NULL != (req = succ_head))
  {
    GNUNET_CONTAINER_DLL_remove (succ_head,
                                 succ_tail,
                                 req);
    free_request (req);
  }
  while (NULL != (req = todo_head))
  {
    GNUNET_CONTAINER_DLL_remove (todo_head,
                                 todo_tail,
                                 req);
    free_request (req);
  }
  if (NULL != gns)
  {
    GNUNET_GNS_disconnect (gns);
    gns = NULL;
  }
}

References act_head, act_tail, Request::cat, compare_req(), failures, free_request(), gns, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_GNS_disconnect(), GNUNET_new_array, GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_divide(), GNUNET_YES, Request::latency, latency_sum, lookups, Request::next, RC_MAX, replies, rp, succ_head, succ_tail, t, todo_head, and todo_tail.

Here is the call graph for this function:

queue()

static void queue ( const char *  hostname, enum RequestCategory  cat  )

static

Add hostname to the list of requests to be made.

Parameters

hostname	name to resolve
cat	category of the hostname

Definition at line 445 of file gnunet-gns-benchmark.c.

{
  struct Request *req;
  const char *dot;
  size_t hlen;
 
  dot = strchr (hostname,
                (unsigned char) '.');
  if (NULL == dot)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Refusing invalid hostname `%s' (lacks '.')\n",
                hostname);
    return;
  }
  hlen = strlen (hostname) + 1;
  req = GNUNET_malloc (sizeof(struct Request) + hlen);
  req->cat = cat;
  req->hostname = (char *) &req[1];
  GNUNET_memcpy (&req[1],
                 hostname,
                 hlen);
  GNUNET_CONTAINER_DLL_insert (todo_head,
                               todo_tail,
                               req);
}

References Request::cat, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, Request::hostname, todo_head, and todo_tail.

Referenced by process_stdin().

Here is the caller graph for this function:

process_stdin()

static void process_stdin ( void *  cls )

static

Begin processing hostnames from stdin.

Parameters

cls

NULL

Definition at line 480 of file gnunet-gns-benchmark.c.

{
  static struct GNUNET_TIME_Absolute last;
  static uint64_t idot;
  unsigned int cat;
  char hn[256];
  char in[270];
 
  (void) cls;
  t = NULL;
  while (NULL !=
         fgets (in,
                sizeof(in),
                stdin))
  {
    if (strlen (in) > 0)
      hn[strlen (in) - 1] = '\0';  /* eat newline */
    if ((2 != sscanf (in,
                      "%u %255s",
                      &cat,
                      hn)) ||
        (cat >= RC_MAX))
    {
      fprintf (stderr,
               "Malformed input line `%s', skipping\n",
               in);
      continue;
    }
    if (0 == idot)
      last = GNUNET_TIME_absolute_get ();
    idot++;
    if (0 == idot % 100000)
    {
      struct GNUNET_TIME_Relative delta;
 
      delta = GNUNET_TIME_absolute_get_duration (last);
      last = GNUNET_TIME_absolute_get ();
      fprintf (stderr,
               "Read 100000 domain names in %s\n",
               GNUNET_STRINGS_relative_time_to_string (delta,
                                                       GNUNET_YES));
    }
    queue (hn,
           (enum RequestCategory) cat);
  }
  fprintf (stderr,
           "Done reading %llu domain names\n",
           (unsigned long long) idot);
  t = GNUNET_SCHEDULER_add_now (&process_queue,
                                NULL);
}

References delta, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, process_queue(), queue(), RC_MAX, and t.

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 *  cfg  )

static

Process requests from the queue, then if the queue is not empty, try again.

Parameters

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

Definition at line 543 of file gnunet-gns-benchmark.c.

{
  (void) cls;
  (void) args;
  (void) cfgfile;
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                 NULL);
  gns = GNUNET_GNS_connect (cfg);
  if (NULL == gns)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  t = GNUNET_SCHEDULER_add_now (&process_stdin,
                                NULL);
}

References cfg, do_shutdown, gns, GNUNET_break, GNUNET_GNS_connect(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), process_stdin(), and t.

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
	)

Call with list of names with numeric category to query.

Parameters

argc	unused
argv	unused

Returns

0 on success

Definition at line 573 of file gnunet-gns-benchmark.c.

{
  int ret = 0;
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_relative_time ('d',
                                        "delay",
                                        "RELATIVETIME",
                                        gettext_noop (
                                          "how long to wait between queries"),
                                        &request_delay),
    GNUNET_GETOPT_option_relative_time ('t',
                                        "timeout",
                                        "RELATIVETIME",
                                        gettext_noop (
                                          "how long to wait for an answer"),
                                        &timeout),
    GNUNET_GETOPT_option_flag ('2',
                               "g2d",
                               gettext_noop (
                                 "look for GNS2DNS records instead of ANY"),
                               &g2d),
    GNUNET_GETOPT_OPTION_END
  };
 
  timeout = DEF_TIMEOUT;
  request_delay = DEF_REQUEST_DELAY;
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                          argc,
                          argv,
                          "gnunet-gns-benchmark",
                          "resolve GNS names and measure performance",
                          options,
                          &run,
                          NULL))
    ret = 1;
  return ret;
}

References DEF_REQUEST_DELAY, DEF_TIMEOUT, g2d, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_relative_time(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), options, request_delay, ret, run(), and timeout.

Here is the call graph for this function:

Variable Documentation

gns

struct GNUNET_GNS_Handle* gns

static

GNS handle.

Definition at line 110 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), process_queue(), and run().

lookups

unsigned int lookups[RC_MAX]

static

Number of lookups we performed overall per category.

Definition at line 115 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), and process_queue().

replies

unsigned int replies[RC_MAX]

static

Number of replies we got per category.

Definition at line 120 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), and process_result().

failures

unsigned int failures[RC_MAX]

static

Number of replies we got per category.

Definition at line 125 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), and process_queue().

latency_sum

struct GNUNET_TIME_Relative latency_sum[RC_MAX]

static

Sum of the observed latencies of successful queries, per category.

Definition at line 131 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), and process_result().

act_head

struct Request* act_head

static

Active requests are kept in a DLL.

Definition at line 136 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), process_queue(), and process_result().

act_tail

struct Request* act_tail

static

Active requests are kept in a DLL.

Definition at line 141 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), process_queue(), and process_result().

succ_head

struct Request* succ_head

static

Completed successful requests are kept in a DLL.

Definition at line 146 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), and process_result().

succ_tail

struct Request* succ_tail

static

Completed successful requests are kept in a DLL.

Definition at line 151 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), and process_result().

todo_head

struct Request* todo_head

static

Yet to be started requests are kept in a DLL.

Definition at line 156 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), process_queue(), and queue().

todo_tail

struct Request* todo_tail

static

Yet to be started requests are kept in a DLL.

Definition at line 161 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), process_queue(), and queue().

t

struct GNUNET_SCHEDULER_Task* t

static

Main task.

Definition at line 166 of file gnunet-gns-benchmark.c.

Referenced by do_shutdown(), process_queue(), process_stdin(), and run().

request_delay

struct GNUNET_TIME_Relative request_delay

static

Delay between requests.

Definition at line 171 of file gnunet-gns-benchmark.c.

Referenced by main(), and process_queue().

timeout

struct GNUNET_TIME_Relative timeout

static

Timeout for requests.

Definition at line 176 of file gnunet-gns-benchmark.c.

Referenced by main(), and process_queue().

active_cnt

unsigned int active_cnt

static

Number of requests we have concurrently active.

Definition at line 181 of file gnunet-gns-benchmark.c.

Referenced by process_queue(), and process_result().

g2d

int g2d

static

Look for GNS2DNS records specifically?

Definition at line 186 of file gnunet-gns-benchmark.c.

Referenced by main(), and process_queue().