merge benchmark changes
[oweals/gnunet.git] / src / gns / gnunet-gns-benchmark.c
1 /*
2      This file is part of GNUnet
3      Copyright (C) 2018 GNUnet e.V.
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 3, or (at your
8      option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18      Boston, MA 02110-1301, USA.
19 */
20 /**
21  * @file src/gns/gnunet-gns-benchmark.c
22  * @brief issue many queries to GNS and compute performance statistics
23  * @author Christian Grothoff
24  */
25 #include "platform.h"
26 #include <gnunet_util_lib.h>
27 #include <gnunet_gnsrecord_lib.h>
28 #include <gnunet_gns_service.h>
29
30
31 /**
32  * How long do we wait at least between requests by default?
33  */
34 #define DEF_REQUEST_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 1)
35
36 /**
37  * How long do we wait until we consider a request failed by default?
38  */
39 #define DEF_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
40
41
42 /**
43  * We distinguish between different categories of
44  * requests, for which we track statistics separately.
45  * However, this process does not change how it acts
46  * based on the category.
47  */
48 enum RequestCategory
49 {
50   RC_SHARED = 0,
51   RC_PRIVATE = 1,
52   /**
53    * Must be last and match number of categories.
54    */
55   RC_MAX = 2
56 };
57
58
59 /**
60  * Request we should make.  We keep this struct in memory per request,
61  * thus optimizing it is crucial for the overall memory consumption of
62  * the zone importer.
63  */
64 struct Request
65 {
66
67   /**
68    * Active requests are kept in a DLL.
69    */
70   struct Request *next;
71
72   /**
73    * Active requests are kept in a DLL.
74    */
75   struct Request *prev;
76
77   /**
78    * Socket used to make the request, NULL if not active.
79    */
80   struct GNUNET_GNS_LookupWithTldRequest *lr;
81
82   /**
83    * Hostname we are resolving, allocated at the end of
84    * this struct (optimizing memory consumption by reducing
85    * total number of allocations).
86    */
87   const char *hostname;
88
89   /**
90    * While we are fetching the record, the value is set to the
91    * starting time of the GNS operation.
92    */
93   struct GNUNET_TIME_Absolute op_start_time;
94
95   /**
96    * Observed latency, set once we got a reply.
97    */
98   struct GNUNET_TIME_Relative latency;
99
100   /**
101    * Category of the request.
102    */
103   enum RequestCategory cat;
104
105 };
106
107
108 /**
109  * GNS handle.
110  */
111 static struct GNUNET_GNS_Handle *gns;
112
113 /**
114  * Number of lookups we performed overall per category.
115  */
116 static unsigned int lookups[RC_MAX];
117
118 /**
119  * Number of replies we got per category.
120  */
121 static unsigned int replies[RC_MAX];
122
123 /**
124  * Number of replies we got per category.
125  */
126 static unsigned int failures[RC_MAX];
127
128 /**
129  * Sum of the observed latencies of successful queries,
130  * per category.
131  */
132 static struct GNUNET_TIME_Relative latency_sum[RC_MAX];
133
134 /**
135  * Active requests are kept in a DLL.
136  */
137 static struct Request *act_head;
138
139 /**
140  * Active requests are kept in a DLL.
141  */
142 static struct Request *act_tail;
143
144 /**
145  * Completed successful requests are kept in a DLL.
146  */
147 static struct Request *succ_head;
148
149 /**
150  * Completed successful requests are kept in a DLL.
151  */
152 static struct Request *succ_tail;
153
154 /**
155  * Yet to be started requests are kept in a DLL.
156  */
157 static struct Request *todo_head;
158
159 /**
160  * Yet to be started requests are kept in a DLL.
161  */
162 static struct Request *todo_tail;
163
164 /**
165  * Main task.
166  */
167 static struct GNUNET_SCHEDULER_Task *t;
168
169 /**
170  * Delay between requests.
171  */
172 static struct GNUNET_TIME_Relative request_delay;
173
174 /**
175  * Timeout for requests.
176  */
177 static struct GNUNET_TIME_Relative timeout;
178
179 /**
180  * Number of requests we have concurrently active.
181  */
182 static unsigned int active_cnt;
183
184 /**
185  * Look for GNS2DNS records specifically?
186  */
187 static int g2d;
188
189 /**
190  * Free @a req and data structures reachable from it.
191  *
192  * @param req request to free
193  */
194 static void
195 free_request (struct Request *req)
196 {
197   if (NULL != req->lr)
198     GNUNET_GNS_lookup_with_tld_cancel (req->lr);
199   GNUNET_free (req);
200 }
201
202
203 /**
204  * Function called with the result of a GNS resolution.
205  *
206  * @param cls closure with the `struct Request`
207  * @param gns_tld #GNUNET_YES if GNS lookup was attempted
208  * @param rd_count number of records in @a rd
209  * @param rd the records in reply
210  */
211 static void
212 process_result (void *cls,
213                 int gns_tld,
214                 uint32_t rd_count,
215                 const struct GNUNET_GNSRECORD_Data *rd)
216 {
217   struct Request *req = cls;
218
219   (void) gns_tld;
220   (void) rd_count;
221   (void) rd;
222   active_cnt--;
223   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
224               "Got response for request `%s'\n",
225               req->hostname);
226   req->lr = NULL;
227   req->latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
228   GNUNET_CONTAINER_DLL_remove (act_head,
229                                act_tail,
230                                req);
231   GNUNET_CONTAINER_DLL_insert (succ_head,
232                                succ_tail,
233                                req);
234   replies[req->cat]++;
235   latency_sum[req->cat]
236     = GNUNET_TIME_relative_add (latency_sum[req->cat],
237                                 req->latency);
238 }
239
240
241 /**
242  * Process request from the queue.
243  *
244  * @param cls NULL
245  */
246 static void
247 process_queue (void *cls)
248 {
249   struct Request *req;
250   struct GNUNET_TIME_Relative duration;
251
252   (void) cls;
253   t = NULL;
254   /* check for expired requests */
255   while (NULL != (req = act_head))
256   {
257     duration = GNUNET_TIME_absolute_get_duration (req->op_start_time);
258     if (duration.rel_value_us < timeout.rel_value_us)
259       break;
260     GNUNET_CONTAINER_DLL_remove (act_head,
261                                  act_tail,
262                                  req);
263     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
264                 "Failing request `%s' due to timeout\n",
265                 req->hostname);
266     failures[req->cat]++;
267     active_cnt--;
268     free_request (req);
269   }
270   if (NULL == (req = todo_head))
271   {
272     struct GNUNET_TIME_Absolute at;
273
274     if (NULL == (req = act_head))
275     {
276       GNUNET_SCHEDULER_shutdown ();
277       return;
278     }
279     at = GNUNET_TIME_absolute_add (req->op_start_time,
280                                    timeout);
281     t = GNUNET_SCHEDULER_add_at (at,
282                                  &process_queue,
283                                  NULL);
284     return;
285   }
286   GNUNET_CONTAINER_DLL_remove (todo_head,
287                                todo_tail,
288                                req);
289   GNUNET_CONTAINER_DLL_insert_tail (act_head,
290                                     act_tail,
291                                     req);
292   lookups[req->cat]++;
293   active_cnt++;
294   req->op_start_time = GNUNET_TIME_absolute_get ();
295   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
296               "Starting request `%s' (%u in parallel)\n",
297               req->hostname,
298               active_cnt);
299   req->lr = GNUNET_GNS_lookup_with_tld (gns,
300                                         req->hostname,
301                                         g2d
302                                         ? GNUNET_GNSRECORD_TYPE_GNS2DNS
303                                         : GNUNET_GNSRECORD_TYPE_ANY,
304                                         GNUNET_GNS_LO_DEFAULT,
305                                         &process_result,
306                                         req);
307   t = GNUNET_SCHEDULER_add_delayed (request_delay,
308                                     &process_queue,
309                                     NULL);
310 }
311
312
313 /**
314  * Compare two requests by latency for qsort().
315  *
316  * @param c1 pointer to `struct Request *`
317  * @param c2 pointer to `struct Request *`
318  * @return -1 if c1<c2, 1 if c1>c2, 0 if c1==c2.
319  */
320 static int
321 compare_req (const void *c1,
322              const void *c2)
323 {
324   const struct Request *r1 = *(void **) c1;
325   const struct Request *r2 = *(void **) c2;
326
327   if (r1->latency.rel_value_us < r2->latency.rel_value_us)
328     return -1;
329   if (r1->latency.rel_value_us > r2->latency.rel_value_us)
330     return 1;
331   return 0;
332 }
333
334
335 /**
336  * Output statistics, then clean up and terminate the process.
337  *
338  * @param cls NULL
339  */
340 static void
341 do_shutdown (void *cls)
342 {
343   struct Request *req;
344   struct Request **ra[RC_MAX];
345   unsigned int rp[RC_MAX];
346
347   (void) cls;
348   for (enum RequestCategory rc = 0;rc < RC_MAX;rc++)
349   {
350     ra[rc] = GNUNET_new_array (replies[rc],
351                                struct Request *);
352     rp[rc] = 0;
353   }
354   for (req = succ_head;NULL != req; req = req->next)
355   {
356     GNUNET_assert (rp[req->cat] < replies[req->cat]);
357     ra[req->cat][rp[req->cat]++] = req;
358   }
359   for (enum RequestCategory rc = 0;rc < RC_MAX;rc++)
360   {
361     unsigned int off;
362
363     fprintf (stdout,
364              "Category %u\n",
365              rc);
366     fprintf (stdout,
367              "\tlookups: %u replies: %u failures: %u\n",
368              lookups[rc],
369              replies[rc],
370              failures[rc]);
371     if (0 == rp[rc])
372       continue;
373     qsort (ra[rc],
374            rp[rc],
375            sizeof (struct Request *),
376            &compare_req);
377     latency_sum[rc] = GNUNET_TIME_relative_divide (latency_sum[rc],
378                                                    replies[rc]);
379     fprintf (stdout,
380              "\taverage: %s\n",
381              GNUNET_STRINGS_relative_time_to_string (latency_sum[rc],
382                                                      GNUNET_YES));
383     off = rp[rc] * 50 / 100;
384     fprintf (stdout,
385              "\tmedian(50): %s\n",
386              GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
387                                                      GNUNET_YES));
388     off = rp[rc] * 75 / 100;
389     fprintf (stdout,
390              "\tquantile(75): %s\n",
391              GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
392                                                      GNUNET_YES));
393     off = rp[rc] * 90 / 100;
394     fprintf (stdout,
395              "\tquantile(90): %s\n",
396              GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
397                                                      GNUNET_YES));
398     off = rp[rc] * 99 / 100;
399     fprintf (stdout,
400              "\tquantile(99): %s\n",
401              GNUNET_STRINGS_relative_time_to_string (ra[rc][off]->latency,
402                                                      GNUNET_YES));
403     GNUNET_free (ra[rc]);
404   }
405   if (NULL != t)
406   {
407     GNUNET_SCHEDULER_cancel (t);
408     t = NULL;
409   }
410   while (NULL != (req = act_head))
411   {
412     GNUNET_CONTAINER_DLL_remove (act_head,
413                                  act_tail,
414                                  req);
415     free_request (req);
416   }
417   while (NULL != (req = succ_head))
418   {
419     GNUNET_CONTAINER_DLL_remove (succ_head,
420                                  succ_tail,
421                                  req);
422     free_request (req);
423   }
424   while (NULL != (req = todo_head))
425   {
426     GNUNET_CONTAINER_DLL_remove (todo_head,
427                                  todo_tail,
428                                  req);
429     free_request (req);
430   }
431   if (NULL != gns)
432   {
433     GNUNET_GNS_disconnect (gns);
434     gns = NULL;
435   }
436 }
437
438
439 /**
440  * Add @a hostname to the list of requests to be made.
441  *
442  * @param hostname name to resolve
443  * @param cat category of the @a hostname
444  */
445 static void
446 queue (const char *hostname,
447        enum RequestCategory cat)
448 {
449   struct Request *req;
450   const char *dot;
451   size_t hlen;
452
453   dot = strchr (hostname,
454                 (unsigned char) '.');
455   if (NULL == dot)
456   {
457     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
458                 "Refusing invalid hostname `%s' (lacks '.')\n",
459                 hostname);
460     return;
461   }
462   hlen = strlen (hostname) + 1;
463   req = GNUNET_malloc (sizeof (struct Request) + hlen);
464   req->cat = cat;
465   req->hostname = (char *) &req[1];
466   GNUNET_memcpy (&req[1],
467                  hostname,
468                  hlen);
469   GNUNET_CONTAINER_DLL_insert (todo_head,
470                                todo_tail,
471                                req);
472 }
473
474
475 /**
476  * Begin processing hostnames from stdin.
477  *
478  * @param cls NULL
479  */
480 static void
481 process_stdin (void *cls)
482 {
483   static struct GNUNET_TIME_Absolute last;
484   static uint64_t idot;
485   unsigned int cat;
486   char hn[256];
487   char in[270];
488
489   (void) cls;
490   t = NULL;
491   while (NULL !=
492          fgets (in,
493                 sizeof (in),
494                 stdin))
495   {
496     if (strlen(in) > 0)
497       hn[strlen(in)-1] = '\0'; /* eat newline */
498     if ( (2 != sscanf (in,
499                        "%u %255s",
500                        &cat,
501                        hn)) ||
502          (cat >= RC_MAX) )
503     {
504       fprintf (stderr,
505                "Malformed input line `%s', skipping\n",
506                in);
507       continue;
508     }
509     if (0 == idot)
510       last = GNUNET_TIME_absolute_get ();
511     idot++;
512     if (0 == idot % 100000)
513     {
514       struct GNUNET_TIME_Relative delta;
515
516       delta = GNUNET_TIME_absolute_get_duration (last);
517       last = GNUNET_TIME_absolute_get ();
518       fprintf (stderr,
519                "Read 100000 domain names in %s\n",
520                GNUNET_STRINGS_relative_time_to_string (delta,
521                                                        GNUNET_YES));
522     }
523     queue (hn,
524            (enum RequestCategory) cat);
525   }
526   fprintf (stderr,
527            "Done reading %llu domain names\n",
528            (unsigned long long) idot);
529   t = GNUNET_SCHEDULER_add_now (&process_queue,
530                                 NULL);
531 }
532
533
534 /**
535  * Process requests from the queue, then if the queue is
536  * not empty, try again.
537  *
538  * @param cls NULL
539  * @param args remaining command-line arguments
540  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
541  * @param cfg configuration
542  */
543 static void
544 run (void *cls,
545      char *const *args,
546      const char *cfgfile,
547      const struct GNUNET_CONFIGURATION_Handle *cfg)
548 {
549   (void) cls;
550   (void) args;
551   (void) cfgfile;
552   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
553                                  NULL);
554   gns = GNUNET_GNS_connect (cfg);
555   if (NULL == gns)
556   {
557     GNUNET_break (0);
558     GNUNET_SCHEDULER_shutdown ();
559     return;
560   }
561   t = GNUNET_SCHEDULER_add_now (&process_stdin,
562                                 NULL);
563 }
564
565
566 /**
567  * Call with list of names with numeric category to query.
568  *
569  * @param argc unused
570  * @param argv unused
571  * @return 0 on success
572  */
573 int
574 main (int argc,
575       char *const*argv)
576 {
577   int ret = 0;
578   struct GNUNET_GETOPT_CommandLineOption options[] = {
579     GNUNET_GETOPT_option_relative_time ('d',
580                                         "delay",
581                                         "RELATIVETIME",
582                                         gettext_noop ("how long to wait between queries"),
583                                         &request_delay),
584     GNUNET_GETOPT_option_relative_time ('t',
585                                         "timeout",
586                                         "RELATIVETIME",
587                                         gettext_noop ("how long to wait for an answer"),
588                                         &timeout),
589     GNUNET_GETOPT_option_flag ('2',
590                                "g2d",
591                                gettext_noop ("look for GNS2DNS records instead of ANY"),
592                                &g2d),
593     GNUNET_GETOPT_OPTION_END
594   };
595
596   if (GNUNET_OK !=
597       GNUNET_STRINGS_get_utf8_args (argc, argv,
598                                     &argc, &argv))
599     return 2;
600   timeout = DEF_TIMEOUT;
601   request_delay = DEF_REQUEST_DELAY;
602   if (GNUNET_OK !=
603       GNUNET_PROGRAM_run (argc,
604                           argv,
605                           "gnunet-gns-benchmark",
606                           "resolve GNS names and measure performance",
607                           options,
608                           &run,
609                           NULL))
610     ret = 1;
611   GNUNET_free ((void*) argv);
612   return ret;
613 }
614
615 /* end of gnunet-gns-benchmark.c */