2 This file is part of GNUnet.
3 Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011, 2015 GNUnet e.V.
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
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 Affero General Public License for more details.
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
21 * @file datastore/perf_datastore_api.c
22 * @brief performance measurement for the datastore implementation
23 * @author Christian Grothoff
25 * This testcase inserts a bunch of (variable size) data and then
26 * deletes data until the (reported) database size drops below a given
27 * threshold. This is iterated 10 times, with the actual size of the
28 * content stored and the number of operations performed being printed
29 * for each iteration. The code also prints a "I" for every 40 blocks
30 * inserted and a "D" for every 40 blocks deleted. The deletion
31 * strategy uses the "random" iterator. Priorities and expiration
32 * dates are set using a pseudo-random value within a realistic range.
35 #include "gnunet_util_lib.h"
36 #include "gnunet_protocols.h"
37 #include "gnunet_datastore_service.h"
38 #include "gnunet_testing_lib.h"
42 * How long until we give up on transmitting the message?
44 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
47 * Target datastore size (in bytes).
49 #define MAX_SIZE (1024LL * 1024 * 4)
52 * Report progress outside of major reports? Should probably be #GNUNET_YES if
55 #define REPORT_ID GNUNET_YES
58 * Number of put operations equivalent to 1/3rd of #MAX_SIZE
60 #define PUT_10 MAX_SIZE / 32 / 1024 / 3
63 * Total number of iterations (each iteration doing
64 * PUT_10 put operations); we report full status every
65 * 10 iterations. Abort with CTRL-C.
70 * Total number of iterations to do to go beyond the quota.
71 * The quota is set to 10 MB or 2.5 times #MAX_SIZE,
72 * so we got 16 times #MAX_SIZE to be sure to hit it a LOT.
74 #define QUOTA_PUTS (MAX_SIZE / 32 / 1024 * 16LL)
78 * Number of bytes stored in the datastore in total.
80 static unsigned long long stored_bytes;
83 * Number of entries stored in the datastore in total.
85 static unsigned long long stored_entries;
88 * Number of database operations performed. Inserting
89 * counts as one operation, deleting as two (as deletion
90 * requires selecting a value for deletion first).
92 static unsigned long long stored_ops;
95 * Start time of the benchmark.
97 static struct GNUNET_TIME_Absolute start_time;
100 * Database backend we use.
102 static const char *plugin_name;
105 * Handle to the datastore.
107 static struct GNUNET_DATASTORE_Handle *datastore;
110 * Value we return from #main().
115 * Which phase of the process are we in?
120 * We are done (shutting down normally).
125 * We are adding new entries to the datastore.
130 * We are deleting entries from the datastore.
135 * We are putting as much as we can to see how the database performs
136 * when it reaches the quota and has to auto-delete (see #3903).
141 * We are generating a report.
146 * Execution failed with some kind of error.
153 * Closure we give to all of the functions executing the
154 * benchmark. Could right now be global, but this allows
155 * us to theoretically run multiple clients "in parallel".
160 * Execution phase we are in.
165 * Size of the value we are currently storing (during #RP_PUT).
170 * Current iteration counter, we are done with the benchmark
171 * once it hits #ITERATIONS.
176 * Counts the number of items put in the current phase.
177 * Once it hits #PUT_10, we progress to the #RP_CUT phase
178 * or are done if @e i reaches #ITERATIONS.
185 * Main state machine. Executes the next step of the benchmark
186 * depending on the current state.
188 * @param cls the `struct CpsRunContext`
191 run_continuation (void *cls);
195 * Continuation called to notify client about result of the insertion
196 * operation. Checks for errors, updates our iteration counters and
197 * continues execution with #run_continuation().
199 * @param cls the `struct CpsRunContext`
200 * @param success #GNUNET_SYSERR on failure
201 * @param min_expiration minimum expiration time required for content to be stored
202 * by the datacache at this time, zero for unknown
203 * @param msg NULL on success, otherwise an error message
206 check_success (void *cls,
208 struct GNUNET_TIME_Absolute min_expiration,
211 struct CpsRunContext *crc = cls;
214 fprintf (stderr, "%s", (GNUNET_OK == success) ? "I" : "i");
216 if (GNUNET_OK != success)
218 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
219 "Check success failed: `%s'\n",
221 crc->phase = RP_ERROR;
222 GNUNET_SCHEDULER_add_now (&run_continuation,
226 stored_bytes += crc->size;
233 if (crc->j >= PUT_10)
237 if (crc->i == ITERATIONS)
238 crc->phase = RP_PUT_QUOTA;
245 if (crc->j >= QUOTA_PUTS)
248 crc->phase = RP_DONE;
255 GNUNET_SCHEDULER_add_now (&run_continuation,
261 * Continuation called to notify client about result of the
262 * deletion operation. Checks for errors and continues
263 * execution with #run_continuation().
265 * @param cls the `struct CpsRunContext`
266 * @param success #GNUNET_SYSERR on failure
267 * @param min_expiration minimum expiration time required for content to be stored
268 * by the datacache at this time, zero for unknown
269 * @param msg NULL on success, otherwise an error message
272 remove_next (void *cls,
274 struct GNUNET_TIME_Absolute min_expiration,
277 struct CpsRunContext *crc = cls;
279 if (GNUNET_OK != success)
281 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
282 "remove_next failed: `%s'\n",
284 crc->phase = RP_ERROR;
285 GNUNET_SCHEDULER_add_now (&run_continuation,
290 fprintf (stderr, "%s", "D");
292 GNUNET_assert (GNUNET_OK == success);
293 GNUNET_SCHEDULER_add_now (&run_continuation,
299 * We have selected a value for deletion, trigger removal.
301 * @param cls the `struct CpsRunContext`
302 * @param key key for the content
303 * @param size number of bytes in data
304 * @param data content stored
305 * @param type type of the content
306 * @param priority priority of the content
307 * @param anonymity anonymity-level for the content
308 * @param replication replication-level for the content
309 * @param expiration expiration time for the content
310 * @param uid unique identifier for the datum;
311 * maybe 0 if no unique identifier is available
314 delete_value (void *cls,
315 const struct GNUNET_HashCode *key,
318 enum GNUNET_BLOCK_Type type,
321 uint32_t replication,
322 struct GNUNET_TIME_Absolute expiration,
325 struct CpsRunContext *crc = cls;
327 GNUNET_assert (NULL != key);
329 stored_bytes -= size;
332 if (stored_bytes < MAX_SIZE)
334 GNUNET_assert (NULL !=
335 GNUNET_DATASTORE_remove (datastore,
344 * Main state machine. Executes the next step of the benchmark
345 * depending on the current state.
347 * @param cls the `struct CpsRunContext`
350 run_continuation (void *cls)
352 struct CpsRunContext *crc = cls;
354 static struct GNUNET_HashCode key;
355 static char data[65536];
358 ok = (int) crc->phase;
364 sizeof(struct GNUNET_HashCode));
365 /* most content is 32k */
368 GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
369 16)) /* but some of it is less! */
370 size = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
372 crc->size = size = size - (size & 7); /* always multiple of 8 */
373 GNUNET_CRYPTO_hash (&key,
374 sizeof(struct GNUNET_HashCode),
381 (int) (crc->j - 255),
384 GNUNET_assert (NULL !=
385 GNUNET_DATASTORE_put (datastore,
391 GNUNET_CRYPTO_random_u32
392 (GNUNET_CRYPTO_QUALITY_WEAK, 100),
395 GNUNET_TIME_relative_to_absolute
396 (GNUNET_TIME_relative_multiply
397 (GNUNET_TIME_UNIT_SECONDS,
398 GNUNET_CRYPTO_random_u32
399 (GNUNET_CRYPTO_QUALITY_WEAK,
403 &check_success, crc));
407 /* trim down below MAX_SIZE again */
408 GNUNET_assert (NULL !=
409 GNUNET_DATASTORE_get_for_replication (datastore,
420 "Stored %llu kB / %lluk ops / %llu ops/s\n",
421 stored_bytes / 1024, /* used size in k */
422 stored_ops / 1024, /* total operations (in k) */
423 1000LL * 1000LL * stored_ops / (1
424 + GNUNET_TIME_absolute_get_duration
425 (start_time).rel_value_us));
428 GNUNET_SCHEDULER_add_now (&run_continuation,
435 sizeof(struct GNUNET_HashCode));
436 /* most content is 32k */
439 GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
440 16)) /* but some of it is less! */
441 size = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
443 crc->size = size = size - (size & 7); /* always multiple of 8 */
444 GNUNET_CRYPTO_hash (&key,
445 sizeof(struct GNUNET_HashCode),
452 (int) (crc->j - 255),
455 GNUNET_assert (NULL !=
456 GNUNET_DATASTORE_put (datastore,
457 0, /* reservation ID */
461 crc->j + 1, /* type */
462 GNUNET_CRYPTO_random_u32
463 (GNUNET_CRYPTO_QUALITY_WEAK,
465 crc->j, /* anonymity */
467 GNUNET_TIME_relative_to_absolute
468 (GNUNET_TIME_relative_multiply
469 (GNUNET_TIME_UNIT_SECONDS,
470 GNUNET_CRYPTO_random_u32
471 (GNUNET_CRYPTO_QUALITY_WEAK,
475 &check_success, crc));
479 GNUNET_snprintf (gstr,
483 if ((crc->i == ITERATIONS) && (stored_ops > 0))
486 "PUT operation duration",
487 GNUNET_TIME_absolute_get_duration (start_time).rel_value_us
492 "\nPUT performance: %s for %llu operations\n",
493 GNUNET_STRINGS_relative_time_to_string (
494 GNUNET_TIME_absolute_get_duration (start_time),
498 "PUT performance: %llu ms/operation\n",
499 GNUNET_TIME_absolute_get_duration (start_time).rel_value_us
503 GNUNET_DATASTORE_disconnect (datastore,
510 GNUNET_DATASTORE_disconnect (datastore, GNUNET_YES);
522 * Function called with the result of the initial PUT operation. If
523 * the PUT succeeded, we start the actual benchmark loop, otherwise we
524 * bail out with an error.
528 * @param success #GNUNET_SYSERR on failure
529 * @param min_expiration minimum expiration time required for content to be stored
530 * by the datacache at this time, zero for unknown
531 * @param msg NULL on success, otherwise an error message
534 run_tests (void *cls,
536 struct GNUNET_TIME_Absolute min_expiration,
539 struct CpsRunContext *crc = cls;
541 if (success != GNUNET_YES)
544 "Test 'put' operation failed with error `%s' database likely not setup, skipping test.\n",
546 GNUNET_DATASTORE_disconnect (datastore,
551 GNUNET_SCHEDULER_add_now (&run_continuation,
557 * Beginning of the actual execution of the benchmark.
558 * Performs a first test operation (PUT) to verify that
559 * the plugin works at all.
562 * @param cfg configuration to use
563 * @param peer peer handle (unused)
567 const struct GNUNET_CONFIGURATION_Handle *cfg,
568 struct GNUNET_TESTING_Peer *peer)
570 struct CpsRunContext *crc;
571 static struct GNUNET_HashCode zkey;
573 datastore = GNUNET_DATASTORE_connect (cfg);
574 start_time = GNUNET_TIME_absolute_get ();
575 crc = GNUNET_new (struct CpsRunContext);
578 GNUNET_DATASTORE_put (datastore,
582 GNUNET_BLOCK_TYPE_TEST,
584 GNUNET_TIME_relative_to_absolute (
585 GNUNET_TIME_UNIT_SECONDS),
591 "Test 'put' operation failed.\n");
599 * Entry point into the test. Determines which configuration / plugin
600 * we are running with based on the name of the binary and starts
603 * @param argc should be 1
604 * @param argv used to determine plugin / configuration name.
605 * @return 0 on success
611 char cfg_name[PATH_MAX];
613 plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);
614 GNUNET_snprintf (cfg_name,
616 "test_datastore_api_data_%s.conf",
619 GNUNET_TESTING_peer_run ("perf-gnunet-datastore",
624 fprintf (stderr, "%s", "\n");
629 /* end of perf_datastore_api.c */