GNUnet  0.10.x
Data Structures | Macros | Enumerations | Functions | Variables
gnunet-gns-benchmark.c File Reference

issue many queries to GNS and compute performance statistics More...

#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   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 1)
 How long do we wait at least between requests by default? More...
 
#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? More...
 

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. More...
 
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. More...
 
static void process_queue (void *cls)
 Process request from the queue. More...
 
static int compare_req (const void *c1, const void *c2)
 Compare two requests by latency for qsort(). More...
 
static void do_shutdown (void *cls)
 Output statistics, then clean up and terminate the process. More...
 
static void queue (const char *hostname, enum RequestCategory cat)
 Add hostname to the list of requests to be made. More...
 
static void process_stdin (void *cls)
 Begin processing hostnames from stdin. More...
 
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. More...
 
int main (int argc, char *const *argv)
 Call with list of names with numeric category to query. More...
 

Variables

static struct GNUNET_GNS_Handlegns
 GNS handle. More...
 
static unsigned int lookups [RC_MAX]
 Number of lookups we performed overall per category. More...
 
static unsigned int replies [RC_MAX]
 Number of replies we got per category. More...
 
static unsigned int failures [RC_MAX]
 Number of replies we got per category. More...
 
static struct GNUNET_TIME_Relative latency_sum [RC_MAX]
 Sum of the observed latencies of successful queries, per category. More...
 
static struct Requestact_head
 Active requests are kept in a DLL. More...
 
static struct Requestact_tail
 Active requests are kept in a DLL. More...
 
static struct Requestsucc_head
 Completed successful requests are kept in a DLL. More...
 
static struct Requestsucc_tail
 Completed successful requests are kept in a DLL. More...
 
static struct Requesttodo_head
 Yet to be started requests are kept in a DLL. More...
 
static struct Requesttodo_tail
 Yet to be started requests are kept in a DLL. More...
 
static struct GNUNET_SCHEDULER_Taskt
 Main task. More...
 
static struct GNUNET_TIME_Relative request_delay
 Delay between requests. More...
 
static struct GNUNET_TIME_Relative timeout
 Timeout for requests. More...
 
static unsigned int active_cnt
 Number of requests we have concurrently active. More...
 
static int g2d
 Look for GNS2DNS records specifically? More...
 

Detailed Description

issue many queries to GNS and compute performance statistics

Author
Christian Grothoff

Definition in file gnunet-gns-benchmark.c.

Macro Definition Documentation

◆ DEF_REQUEST_DELAY

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

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

Referenced by main().

◆ DEF_TIMEOUT

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

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

Referenced by main().

Enumeration Type Documentation

◆ 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 48 of file gnunet-gns-benchmark.c.

48  {
49  RC_SHARED = 0,
50  RC_PRIVATE = 1,
54  RC_MAX = 2
55 };
Must be last and match number of categories.

Function Documentation

◆ free_request()

static void free_request ( struct Request req)
static

Free req and data structures reachable from it.

Parameters
reqrequest to free

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

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

Referenced by do_shutdown(), and process_queue().

192 {
193  if (NULL != req->lr)
195  GNUNET_free(req);
196 }
void * GNUNET_GNS_lookup_with_tld_cancel(struct GNUNET_GNS_LookupWithTldRequest *ltr)
Cancel pending lookup request.
Definition: gns_tld_api.c:328
struct GNUNET_GNS_LookupWithTldRequest * lr
Socket used to make the request, NULL if not active.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclosure with the struct Request
gns_tldGNUNET_YES if GNS lookup was attempted
rd_countnumber of records in rd
rdthe records in reply

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

References 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, and replies.

Referenced by process_queue().

212 {
213  struct Request *req = cls;
214 
215  (void)gns_tld;
216  (void)rd_count;
217  (void)rd;
218  active_cnt--;
220  "Got response for request `%s'\n",
221  req->hostname);
222  req->lr = NULL;
225  act_tail,
226  req);
228  succ_tail,
229  req);
230  replies[req->cat]++;
231  latency_sum[req->cat]
233  req->latency);
234 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
char * hostname
Hostname we are resolving.
enum RequestCategory cat
Category of the request.
static unsigned int replies[RC_MAX]
Number of replies we got per category.
static struct Request * succ_head
Completed successful requests are kept in a DLL.
static struct GNUNET_TIME_Relative latency_sum[RC_MAX]
Sum of the observed latencies of successful queries, per category.
Request we should make.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Add relative times together.
Definition: time.c:577
struct GNUNET_GNS_LookupWithTldRequest * lr
Socket used to make the request, NULL if not active.
struct GNUNET_TIME_Absolute op_start_time
While we are fetching the record, the value is set to the starting time of the GNS operation...
static struct Request * act_tail
Active requests are kept in a DLL.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
struct GNUNET_TIME_Relative latency
Observed latency, set once we got a reply.
#define GNUNET_log(kind,...)
static unsigned int active_cnt
Number of requests we have concurrently active.
static struct Request * act_head
Active requests are kept in a DLL.
static struct Request * succ_tail
Completed successful requests are kept in a DLL.
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
clsNULL

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

References active_cnt, Request::cat, failures, free_request(), g2d, 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_result(), GNUNET_TIME_Relative::rel_value_us, request_delay, and timeout.

Referenced by process_stdin().

244 {
245  struct Request *req;
247 
248  (void)cls;
249  t = NULL;
250  /* check for expired requests */
251  while (NULL != (req = act_head))
252  {
255  break;
257  act_tail,
258  req);
260  "Failing request `%s' due to timeout\n",
261  req->hostname);
262  failures[req->cat]++;
263  active_cnt--;
264  free_request(req);
265  }
266  if (NULL == (req = todo_head))
267  {
268  struct GNUNET_TIME_Absolute at;
269 
270  if (NULL == (req = act_head))
271  {
273  return;
274  }
276  timeout);
278  &process_queue,
279  NULL);
280  return;
281  }
283  todo_tail,
284  req);
286  act_tail,
287  req);
288  lookups[req->cat]++;
289  active_cnt++;
292  "Starting request `%s' (%u in parallel)\n",
293  req->hostname,
294  active_cnt);
296  req->hostname,
297  g2d
302  req);
304  &process_queue,
305  NULL);
306 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static void free_request(struct Request *req)
Free req and data structures reachable from it.
static struct Request * todo_head
Yet to be started requests are kept in a DLL.
uint64_t rel_value_us
The actual value.
char * hostname
Hostname we are resolving.
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.
#define GNUNET_GNSRECORD_TYPE_ANY
Record type indicating any record/&#39;*&#39;.
static struct GNUNET_TIME_Relative request_delay
Delay between requests.
static struct Request * todo_tail
Yet to be started requests are kept in a DLL.
struct GNUNET_GNS_LookupWithTldRequest * GNUNET_GNS_lookup_with_tld(struct GNUNET_GNS_Handle *handle, const char *name, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor2 proc, void *proc_cls)
Perform an asynchronous lookup operation on the GNS, determining the zone using the TLD of the given ...
Definition: gns_tld_api.c:240
static unsigned int failures[RC_MAX]
Number of replies we got per category.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:393
enum RequestCategory cat
Category of the request.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
static struct GNUNET_GNS_Handle * gns
GNS handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
#define GNUNET_GNSRECORD_TYPE_GNS2DNS
Record type for delegation to DNS.
static void process_queue(void *cls)
Process request from the queue.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static unsigned int lookups[RC_MAX]
Number of lookups we performed overall per category.
static struct GNUNET_SCHEDULER_Task * t
Main task.
static struct GNUNET_TIME_Relative timeout
Timeout for requests.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
Request we should make.
struct GNUNET_GNS_LookupWithTldRequest * lr
Socket used to make the request, NULL if not active.
struct GNUNET_TIME_Absolute op_start_time
While we are fetching the record, the value is set to the starting time of the GNS operation...
static struct Request * act_tail
Active requests are kept in a DLL.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
#define GNUNET_log(kind,...)
static struct GNUNET_TIME_Relative duration
How long do we run the test?
static int g2d
Look for GNS2DNS records specifically?
Time for absolute times used by GNUnet, in microseconds.
static unsigned int active_cnt
Number of requests we have concurrently active.
Defaults, look in cache, then in DHT.
static struct Request * act_head
Active requests are kept in a DLL.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1214
Time for relative time used by GNUnet, in microseconds.
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
c1pointer to struct Request *
c2pointer to struct Request *
Returns
-1 if c1<c2, 1 if c1>c2, 0 if c1==c2.

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

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

Referenced by do_shutdown().

319 {
320  const struct Request *r1 = *(void **)c1;
321  const struct Request *r2 = *(void **)c2;
322 
324  return -1;
326  return 1;
327  return 0;
328 }
uint64_t rel_value_us
The actual value.
Request we should make.
struct GNUNET_TIME_Relative latency
Observed latency, set once we got a reply.
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
clsNULL

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

References Request::cat, compare_req(), failures, free_request(), 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, and rp.

Referenced by run().

338 {
339  struct Request *req;
340  struct Request **ra[RC_MAX];
341  unsigned int rp[RC_MAX];
342 
343  (void)cls;
344  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
345  {
346  ra[rc] = GNUNET_new_array(replies[rc],
347  struct Request *);
348  rp[rc] = 0;
349  }
350  for (req = succ_head; NULL != req; req = req->next)
351  {
352  GNUNET_assert(rp[req->cat] < replies[req->cat]);
353  ra[req->cat][rp[req->cat]++] = req;
354  }
355  for (enum RequestCategory rc = 0; rc < RC_MAX; rc++)
356  {
357  unsigned int off;
358 
359  fprintf(stdout,
360  "Category %u\n",
361  rc);
362  fprintf(stdout,
363  "\tlookups: %u replies: %u failures: %u\n",
364  lookups[rc],
365  replies[rc],
366  failures[rc]);
367  if (0 == rp[rc])
368  continue;
369  qsort(ra[rc],
370  rp[rc],
371  sizeof(struct Request *),
372  &compare_req);
374  replies[rc]);
375  fprintf(stdout,
376  "\taverage: %s\n",
378  GNUNET_YES));
379  off = rp[rc] * 50 / 100;
380  fprintf(stdout,
381  "\tmedian(50): %s\n",
383  GNUNET_YES));
384  off = rp[rc] * 75 / 100;
385  fprintf(stdout,
386  "\tquantile(75): %s\n",
388  GNUNET_YES));
389  off = rp[rc] * 90 / 100;
390  fprintf(stdout,
391  "\tquantile(90): %s\n",
393  GNUNET_YES));
394  off = rp[rc] * 99 / 100;
395  fprintf(stdout,
396  "\tquantile(99): %s\n",
398  GNUNET_YES));
399  GNUNET_free(ra[rc]);
400  }
401  if (NULL != t)
402  {
404  t = NULL;
405  }
406  while (NULL != (req = act_head))
407  {
409  act_tail,
410  req);
411  free_request(req);
412  }
413  while (NULL != (req = succ_head))
414  {
416  succ_tail,
417  req);
418  free_request(req);
419  }
420  while (NULL != (req = todo_head))
421  {
423  todo_tail,
424  req);
425  free_request(req);
426  }
427  if (NULL != gns)
428  {
430  gns = NULL;
431  }
432 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static void free_request(struct Request *req)
Free req and data structures reachable from it.
static struct Request * todo_head
Yet to be started requests are kept in a DLL.
static int compare_req(const void *c1, const void *c2)
Compare two requests by latency for qsort().
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct Request * todo_tail
Yet to be started requests are kept in a DLL.
static unsigned int failures[RC_MAX]
Number of replies we got per category.
enum RequestCategory cat
Category of the request.
static struct GNUNET_GNS_Handle * gns
GNS handle.
static unsigned int replies[RC_MAX]
Number of replies we got per category.
void GNUNET_GNS_disconnect(struct GNUNET_GNS_Handle *handle)
Shutdown connection with the GNS service.
Definition: gns_api.c:282
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
static struct Request * succ_head
Completed successful requests are kept in a DLL.
static struct GNUNET_TIME_Relative latency_sum[RC_MAX]
Sum of the observed latencies of successful queries, per category.
static unsigned int lookups[RC_MAX]
Number of lookups we performed overall per category.
static struct GNUNET_SCHEDULER_Task * t
Main task.
Request we should make.
RequestCategory
We distinguish between different categories of requests, for which we track statistics separately...
static struct Request * act_tail
Active requests are kept in a DLL.
struct GNUNET_TIME_Relative latency
Observed latency, set once we got a reply.
struct Request * next
Requests are kept in a DLL.
Must be last and match number of categories.
static char * rp
Relying party.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:525
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct Request * act_head
Active requests are kept in a DLL.
static struct Request * succ_tail
Completed successful requests are kept in a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function:
Here is the caller 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
hostnamename to resolve
catcategory of the hostname

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

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

Referenced by process_stdin().

444 {
445  struct Request *req;
446  const char *dot;
447  size_t hlen;
448 
449  dot = strchr(hostname,
450  (unsigned char)'.');
451  if (NULL == dot)
452  {
454  "Refusing invalid hostname `%s' (lacks '.')\n",
455  hostname);
456  return;
457  }
458  hlen = strlen(hostname) + 1;
459  req = GNUNET_malloc(sizeof(struct Request) + hlen);
460  req->cat = cat;
461  req->hostname = (char *)&req[1];
462  GNUNET_memcpy(&req[1],
463  hostname,
464  hlen);
466  todo_tail,
467  req);
468 }
static struct Request * todo_head
Yet to be started requests are kept in a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
char * hostname
Hostname we are resolving.
static struct Request * todo_tail
Yet to be started requests are kept in a DLL.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
enum RequestCategory cat
Category of the request.
Request we should make.
static char * hostname
Our hostname; we give this to all the peers we start.
#define GNUNET_log(kind,...)
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the caller graph for this function:

◆ process_stdin()

static void process_stdin ( void *  cls)
static

Begin processing hostnames from stdin.

Parameters
clsNULL

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

References Request::cat, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, Request::hn, process_queue(), queue(), and RC_MAX.

Referenced by run().

478 {
479  static struct GNUNET_TIME_Absolute last;
480  static uint64_t idot;
481  unsigned int cat;
482  char hn[256];
483  char in[270];
484 
485  (void)cls;
486  t = NULL;
487  while (NULL !=
488  fgets(in,
489  sizeof(in),
490  stdin))
491  {
492  if (strlen(in) > 0)
493  hn[strlen(in) - 1] = '\0'; /* eat newline */
494  if ((2 != sscanf(in,
495  "%u %255s",
496  &cat,
497  hn)) ||
498  (cat >= RC_MAX))
499  {
500  fprintf(stderr,
501  "Malformed input line `%s', skipping\n",
502  in);
503  continue;
504  }
505  if (0 == idot)
506  last = GNUNET_TIME_absolute_get();
507  idot++;
508  if (0 == idot % 100000)
509  {
511 
513  last = GNUNET_TIME_absolute_get();
514  fprintf(stderr,
515  "Read 100000 domain names in %s\n",
517  GNUNET_YES));
518  }
519  queue(hn,
520  (enum RequestCategory)cat);
521  }
522  fprintf(stderr,
523  "Done reading %llu domain names\n",
524  (unsigned long long)idot);
526  NULL);
527 }
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
static void queue(const char *hostname, enum RequestCategory cat)
Add hostname to the list of requests to be made.
static void process_queue(void *cls)
Process request from the queue.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static struct GNUNET_SCHEDULER_Task * t
Main task.
RequestCategory
We distinguish between different categories of requests, for which we track statistics separately...
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
Must be last and match number of categories.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
Time for relative time used by GNUnet, in microseconds.
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
clsNULL
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

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

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

Referenced by main().

544 {
545  (void)cls;
546  (void)args;
547  (void)cfgfile;
549  NULL);
550  gns = GNUNET_GNS_connect(cfg);
551  if (NULL == gns)
552  {
553  GNUNET_break(0);
555  return;
556  }
558  NULL);
559 }
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1284
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_GNS_Handle * gns
GNS handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static void process_stdin(void *cls)
Begin processing hostnames from stdin.
static void do_shutdown(void *cls)
Output statistics, then clean up and terminate the process.
struct GNUNET_GNS_Handle * GNUNET_GNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the GNS service.
Definition: gns_api.c:260
static struct GNUNET_SCHEDULER_Task * t
Main task.
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
argcunused
argvunused
Returns
0 on success

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

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

572 {
573  int ret = 0;
576  "delay",
577  "RELATIVETIME",
578  gettext_noop("how long to wait between queries"),
579  &request_delay),
581  "timeout",
582  "RELATIVETIME",
583  gettext_noop("how long to wait for an answer"),
584  &timeout),
586  "g2d",
587  gettext_noop("look for GNS2DNS records instead of ANY"),
588  &g2d),
590  };
591 
592  if (GNUNET_OK !=
593  GNUNET_STRINGS_get_utf8_args(argc, argv,
594  &argc, &argv))
595  return 2;
598  if (GNUNET_OK !=
599  GNUNET_PROGRAM_run(argc,
600  argv,
601  "gnunet-gns-benchmark",
602  "resolve GNS names and measure performance",
603  options,
604  &run,
605  NULL))
606  ret = 1;
607  GNUNET_free((void*)argv);
608  return ret;
609 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_relative_time(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_TIME_Relative *val)
Allow user to specify a struct GNUNET_TIME_Relative (using human-readable "fancy" time)...
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.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1439
static struct GNUNET_TIME_Relative request_delay
Delay between requests.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Definition of a command line option.
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
#define DEF_REQUEST_DELAY
How long do we wait at least between requests by default?
static struct GNUNET_TIME_Relative timeout
Timeout for requests.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
#define DEF_TIMEOUT
How long do we wait until we consider a request failed by default?
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
static int g2d
Look for GNS2DNS records specifically?
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:

Variable Documentation

◆ gns

struct GNUNET_GNS_Handle* gns
static

GNS handle.

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

◆ lookups

unsigned int lookups[RC_MAX]
static

Number of lookups we performed overall per category.

Definition at line 112 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 117 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 122 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 128 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 133 of file gnunet-gns-benchmark.c.

◆ act_tail

struct Request* act_tail
static

Active requests are kept in a DLL.

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

◆ succ_head

struct Request* succ_head
static

Completed successful requests are kept in a DLL.

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

◆ succ_tail

struct Request* succ_tail
static

Completed successful requests are kept in a DLL.

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

◆ todo_head

struct Request* todo_head
static

Yet to be started requests are kept in a DLL.

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

◆ todo_tail

struct Request* todo_tail
static

Yet to be started requests are kept in a DLL.

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

◆ t

struct GNUNET_SCHEDULER_Task* t
static

Main task.

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

◆ request_delay

struct GNUNET_TIME_Relative request_delay
static

Delay between requests.

Definition at line 168 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 173 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 178 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 183 of file gnunet-gns-benchmark.c.

Referenced by main(), and process_queue().