fixing mess with search update serialization and parenting
[oweals/gnunet.git] / src / datastore / perf_plugin_datastore.c
1 /*
2      This file is part of GNUnet.
3      (C) 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
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 2, 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., 59 Temple Place - Suite 330,
18      Boston, MA 02111-1307, USA.
19 */
20 /*
21  * @file perf_plugin_datastore.c
22  * @brief Profile database plugin directly, focusing on iterators.
23  * @author Christian Grothoff
24  */
25
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_protocols.h"
29 #include "plugin_datastore.h"
30
31 #define VERBOSE GNUNET_NO
32
33 /**
34  * Target datastore size (in bytes).  Realistic sizes are
35  * more like 16 GB (not the default of 16 MB); however,
36  * those take too long to run them in the usual "make check"
37  * sequence.  Hence the value used for shipping is tiny.
38  */
39 #define MAX_SIZE 1024LL * 1024 * 128
40
41 #define ITERATIONS 10
42
43 /**
44  * Number of put operations equivalent to 1/10th of MAX_SIZE
45  */
46 #define PUT_10 (MAX_SIZE / 32 / 1024 / ITERATIONS)
47
48 static unsigned long long stored_bytes;
49
50 static unsigned long long stored_entries;
51
52 static unsigned long long stored_ops;
53
54 static int ok;
55
56 enum RunPhase
57   {
58     RP_DONE = 0,
59     RP_PUT,
60     RP_LP_GET,
61     RP_AE_GET,
62     RP_ZA_GET,
63     RP_MO_GET,
64     RP_AN_GET
65   };
66
67
68 struct CpsRunContext
69 {
70   unsigned int i;
71   struct GNUNET_TIME_Absolute start;
72   struct GNUNET_TIME_Absolute end;
73   struct GNUNET_SCHEDULER_Handle *sched;
74   const struct GNUNET_CONFIGURATION_Handle *cfg;
75   struct GNUNET_DATASTORE_PluginFunctions * api;
76   const char *msg;
77   enum RunPhase phase;
78   unsigned int cnt;
79 };
80
81
82              
83 static void
84 putValue (struct GNUNET_DATASTORE_PluginFunctions * api, int i, int k)
85 {
86   char value[65536];
87   size_t size;
88   static GNUNET_HashCode key;
89   static int ic;
90   char *msg;
91   unsigned int prio;
92
93   /* most content is 32k */
94   size = 32 * 1024;
95
96   if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16) == 0)  /* but some of it is less! */
97     size = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 32 * 1024);
98   size = size - (size & 7);     /* always multiple of 8 */
99
100   /* generate random key */
101   key.bits[0] = (unsigned int) GNUNET_TIME_absolute_get ().value;
102   GNUNET_CRYPTO_hash (&key, sizeof (GNUNET_HashCode), &key);
103   memset (value, i, size);
104   if (i > 255)
105     memset (value, i - 255, size / 2);
106   value[0] = k;
107   msg = NULL;
108   prio = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100);
109   if (GNUNET_OK != api->put (api->cls,
110                              &key, 
111                              size,
112                              value,
113                              i,
114                              prio,
115                              i,
116                              GNUNET_TIME_relative_to_absolute 
117                              (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
118                                                              60 * 60 * 60 * 1000 +
119                                                              GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000))),
120                              &msg))
121     {
122       fprintf (stderr, "ERROR: `%s'\n", msg);
123       GNUNET_free_non_null (msg);
124       return;
125     }
126   ic++;
127   stored_bytes += size;
128   stored_ops++;
129   stored_entries++;
130 }
131
132 static void
133 test (void *cls,
134       const struct GNUNET_SCHEDULER_TaskContext *tc);
135
136
137 static int
138 iterateDummy (void *cls,
139               void *next_cls,
140               const GNUNET_HashCode * key,
141               uint32_t size,
142               const void *data,
143               enum GNUNET_BLOCK_Type type,
144               uint32_t priority,
145               uint32_t anonymity,
146               struct GNUNET_TIME_Absolute
147               expiration, 
148               uint64_t uid)
149 {
150   struct CpsRunContext *crc = cls;
151   
152   if (key == NULL)
153     {
154       crc->end = GNUNET_TIME_absolute_get();
155       printf (crc->msg,
156               crc->i,
157               (unsigned long long) (crc->end.value - crc->start.value),
158               crc->cnt);
159       if (crc->phase != RP_AN_GET)
160         {
161           crc->phase++;
162         }
163       else
164         {
165           if (crc->i == ITERATIONS)
166             crc->phase = RP_DONE;
167           else
168             crc->phase = RP_PUT;
169         }
170       GNUNET_SCHEDULER_add_after (crc->sched,
171                                   GNUNET_SCHEDULER_NO_TASK,
172                                   &test, crc);
173       return GNUNET_OK;
174     }
175 #if VERBOSE
176   fprintf (stderr, "Found result type=%u, priority=%u, size=%u, expire=%llu\n",
177            type, priority, size,
178            (unsigned long long) expiration.value);
179 #endif
180   crc->cnt++;
181   crc->api->next_request (next_cls,
182                           GNUNET_NO);
183   return GNUNET_OK;
184 }
185
186
187
188 /**
189  * Function called when the service shuts
190  * down.  Unloads our datastore plugin.
191  *
192  * @param api api to unload
193  * @param cfg configuration to use
194  */
195 static void
196 unload_plugin (struct GNUNET_DATASTORE_PluginFunctions * api,
197                const struct GNUNET_CONFIGURATION_Handle *cfg)
198 {
199   char *name;
200   char *libname;
201
202   if (GNUNET_OK !=
203       GNUNET_CONFIGURATION_get_value_string (cfg,
204                                              "DATASTORE", "DATABASE", &name))
205     {
206       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
207                   _("No `%s' specified for `%s' in configuration!\n"),
208                   "DATABASE",
209                   "DATASTORE");
210       return;
211     }
212   GNUNET_asprintf (&libname, "libgnunet_plugin_datastore_%s", name);
213   GNUNET_break (NULL == GNUNET_PLUGIN_unload (libname, api));
214   GNUNET_free (libname);
215   GNUNET_free (name);
216 }
217
218
219
220 /**
221  * Last task run during shutdown.  Disconnects us from
222  * the transport and core.
223  */
224 static void
225 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
226 {
227   struct CpsRunContext *crc = cls;
228
229   unload_plugin (crc->api, crc->cfg);
230   GNUNET_free (crc);
231 }
232
233
234 static void
235 test (void *cls,
236       const struct GNUNET_SCHEDULER_TaskContext *tc)
237 {  
238   struct CpsRunContext *crc = cls;
239   int j;
240
241   switch (crc->phase)
242     {
243     case RP_PUT:      
244       crc->start = GNUNET_TIME_absolute_get ();
245       for (j=0;j<PUT_10;j++)
246         putValue (crc->api, j, crc->i);
247       crc->end = GNUNET_TIME_absolute_get ();
248       printf ("%3u insertion took                      %20llums for %u\n",
249               crc->i,
250               (unsigned long long) (crc->end.value - crc->start.value),
251               (unsigned int) PUT_10);
252       crc->i++;
253       crc->phase = RP_LP_GET;
254       GNUNET_SCHEDULER_add_after (crc->sched,
255                                   GNUNET_SCHEDULER_NO_TASK,
256                                   &test, crc);
257       break;
258     case RP_LP_GET:
259       crc->cnt = 0;
260       crc->start = GNUNET_TIME_absolute_get ();      
261       crc->msg = "%3u low priority iteration took         %20llums for %u\n";
262       crc->api->iter_low_priority (crc->api->cls, 0, 
263                                    &iterateDummy,
264                                    crc);
265       break;
266     case RP_AE_GET:
267       crc->cnt = 0;
268       crc->start = GNUNET_TIME_absolute_get ();      
269       crc->msg = "%3u ascending expiration iteration took %20llums for %u\n";
270       crc->api->iter_ascending_expiration (crc->api->cls, 0, 
271                                       &iterateDummy,
272                                       crc);
273       break;
274     case RP_ZA_GET:
275       crc->cnt = 0;
276       crc->start = GNUNET_TIME_absolute_get ();      
277       crc->msg = "%3u zero anonymity iteration took       %20llums for %u\n";
278       crc->api->iter_zero_anonymity (crc->api->cls, 0, 
279                                      &iterateDummy,
280                                      crc);
281       break;
282     case RP_MO_GET:
283       crc->cnt = 0;
284       crc->start = GNUNET_TIME_absolute_get ();      
285       crc->msg = "%3u migration order iteration took      %20llums for %u\n";
286       crc->api->iter_migration_order (crc->api->cls, 0, 
287                                       &iterateDummy,
288                                       crc);
289       break;
290     case RP_AN_GET:
291       crc->cnt = 0;
292       crc->start = GNUNET_TIME_absolute_get ();      
293       crc->msg = "%3u all now iteration took              %20llums for %u\n";
294       crc->api->iter_all_now (crc->api->cls, 0,
295                               &iterateDummy,
296                               crc);
297       break;
298     case RP_DONE:
299       crc->api->drop (crc->api->cls);
300       GNUNET_SCHEDULER_add_with_priority (crc->sched,
301                                     GNUNET_SCHEDULER_PRIORITY_IDLE,
302                                     &cleaning_task, crc);
303       break;
304     }
305 }
306
307
308 /**
309  * Load the datastore plugin.
310  */
311 static struct GNUNET_DATASTORE_PluginFunctions *
312 load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg,
313              struct GNUNET_SCHEDULER_Handle *sched)
314 {
315   static struct GNUNET_DATASTORE_PluginEnvironment env;
316   struct GNUNET_DATASTORE_PluginFunctions * ret; 
317   char *name;
318   char *libname;
319
320   if (GNUNET_OK !=
321       GNUNET_CONFIGURATION_get_value_string (cfg,
322                                              "DATASTORE", "DATABASE", &name))
323     {
324       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
325                   _("No `%s' specified for `%s' in configuration!\n"),
326                   "DATABASE",
327                   "DATASTORE");
328       return NULL;
329     }
330   env.cfg = cfg;
331   env.sched = sched;  
332   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
333               _("Loading `%s' datastore plugin\n"), name);
334   GNUNET_asprintf (&libname, "libgnunet_plugin_datastore_%s", name);
335   GNUNET_assert (NULL != (ret = GNUNET_PLUGIN_load (libname, &env)));
336   GNUNET_free (libname);
337   GNUNET_free (name);
338   return ret;
339 }
340
341
342 static void
343 run (void *cls,
344      struct GNUNET_SCHEDULER_Handle *s,
345      char *const *args,
346      const char *cfgfile,
347      const struct GNUNET_CONFIGURATION_Handle *c)
348 {
349   struct GNUNET_DATASTORE_PluginFunctions *api;
350   struct CpsRunContext *crc;
351
352   api = load_plugin (c, s);
353   GNUNET_assert (api != NULL);
354   crc = GNUNET_malloc(sizeof(struct CpsRunContext));
355   crc->api = api;
356   crc->sched = s;
357   crc->cfg = c;
358   crc->phase = RP_PUT;
359   GNUNET_SCHEDULER_add_after (s,
360                               GNUNET_SCHEDULER_NO_TASK,
361                               &test, crc);
362 }
363
364
365 static int
366 check ()
367 {
368   char *const argv[] = { 
369     "perf-plugin-datastore",
370     "-c",
371     "perf_plugin_datastore_data.conf",
372 #if VERBOSE
373     "-L", "DEBUG",
374 #endif
375     NULL
376   };
377   struct GNUNET_GETOPT_CommandLineOption options[] = {
378     GNUNET_GETOPT_OPTION_END
379   };
380   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
381                       argv, "perf-plugin-datastore", "nohelp",
382                       options, &run, NULL);
383   if (ok != 0)
384     fprintf (stderr, "Missed some testcases: %u\n", ok);
385   return ok;
386 }
387
388
389 int
390 main (int argc, char *argv[])
391 {
392   int ret;
393
394   GNUNET_DISK_directory_remove ("/tmp/perf-gnunet-datastore");
395   GNUNET_log_setup ("perf-plugin-datastore",
396 #if VERBOSE
397                     "DEBUG",
398 #else
399                     "WARNING",
400 #endif
401                     NULL);
402   ret = check ();
403   GNUNET_DISK_directory_remove ("/tmp/perf-gnunet-datastore");
404
405   return ret;
406 }
407
408
409 /* end of perf_plugin_datastore.c */
410
411