aboutsummaryrefslogtreecommitdiff
path: root/src/namestore/perf_namestore_api_zone_iteration.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/namestore/perf_namestore_api_zone_iteration.c')
-rw-r--r--src/namestore/perf_namestore_api_zone_iteration.c379
1 files changed, 0 insertions, 379 deletions
diff --git a/src/namestore/perf_namestore_api_zone_iteration.c b/src/namestore/perf_namestore_api_zone_iteration.c
deleted file mode 100644
index ce1cddf87..000000000
--- a/src/namestore/perf_namestore_api_zone_iteration.c
+++ /dev/null
@@ -1,379 +0,0 @@
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2013, 2018 GNUnet e.V.
4
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.
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 Affero General Public License for more details.
14
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/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
20/**
21 * @file namestore/perf_namestore_api_zone_iteration.c
22 * @brief testcase for zone iteration functionality: iterate all zones
23 * @author Christian Grothoff
24 */
25#include "platform.h"
26#include "gnunet_namestore_service.h"
27#include "gnunet_testing_lib.h"
28#include "namestore.h"
29#include "gnunet_dnsparser_lib.h"
30
31#define TEST_RECORD_TYPE GNUNET_DNSPARSER_TYPE_TXT
32
33/**
34 * A #BENCHMARK_SIZE of 1000 takes less than a minute on a reasonably
35 * modern system, so 30 minutes should be OK even for very, very
36 * slow systems.
37 */
38#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
39
40/**
41 * The runtime of the benchmark is expected to be linear
42 * for the iteration phase with a *good* database. The FLAT
43 * database uses a quadratic retrieval algorithm,
44 * hence it should be quadratic in the size.
45 */
46#define BENCHMARK_SIZE 1000
47
48/**
49 * Maximum record size
50 */
51#define MAX_REC_SIZE 500
52
53/**
54 * How big are the blocks we fetch? Note that the first block is
55 * always just 1 record set per current API. Smaller block
56 * sizes will make quadratic iteration-by-offset penalties
57 * more pronounced.
58 */
59#define BLOCK_SIZE 100
60
61static struct GNUNET_NAMESTORE_Handle *nsh;
62
63static struct GNUNET_SCHEDULER_Task *timeout_task;
64
65static struct GNUNET_SCHEDULER_Task *t;
66
67static struct GNUNET_IDENTITY_PrivateKey privkey;
68
69static struct GNUNET_NAMESTORE_ZoneIterator *zi;
70
71static struct GNUNET_NAMESTORE_QueueEntry *qe;
72
73static int res;
74
75static unsigned int off;
76
77static unsigned int left_until_next;
78
79static uint8_t seen[1 + BENCHMARK_SIZE / 8];
80
81static struct GNUNET_TIME_Absolute start;
82
83
84/**
85 * Terminate everything
86 *
87 * @param cls NULL
88 */
89static void
90end (void *cls)
91{
92 (void) cls;
93 if (NULL != qe)
94 {
95 GNUNET_NAMESTORE_cancel (qe);
96 qe = NULL;
97 }
98 if (NULL != zi)
99 {
100 GNUNET_NAMESTORE_zone_iteration_stop (zi);
101 zi = NULL;
102 }
103 if (NULL != nsh)
104 {
105 GNUNET_NAMESTORE_disconnect (nsh);
106 nsh = NULL;
107 }
108 if (NULL != t)
109 {
110 GNUNET_SCHEDULER_cancel (t);
111 t = NULL;
112 }
113 if (NULL != timeout_task)
114 {
115 GNUNET_SCHEDULER_cancel (timeout_task);
116 timeout_task = NULL;
117 }
118}
119
120
121/**
122 * End with timeout. As this is a benchmark, we do not
123 * fail hard but return "skipped".
124 */
125static void
126timeout (void *cls)
127{
128 (void) cls;
129 timeout_task = NULL;
130 GNUNET_SCHEDULER_shutdown ();
131 res = 77;
132}
133
134
135static struct GNUNET_GNSRECORD_Data *
136create_record (unsigned int count)
137{
138 struct GNUNET_GNSRECORD_Data *rd;
139
140 rd = GNUNET_malloc (count + sizeof(struct GNUNET_GNSRECORD_Data));
141 rd->expiration_time = GNUNET_TIME_relative_to_absolute (
142 GNUNET_TIME_UNIT_HOURS).abs_value_us;
143 rd->record_type = TEST_RECORD_TYPE;
144 rd->data_size = count;
145 rd->data = (void *) &rd[1];
146 rd->flags = 0;
147 memset (&rd[1],
148 'a',
149 count);
150 return rd;
151}
152
153
154static void
155zone_end (void *cls)
156{
157 struct GNUNET_TIME_Relative delay;
158
159 zi = NULL;
160 delay = GNUNET_TIME_absolute_get_duration (start);
161 fprintf (stdout,
162 "Iterating over %u records took %s\n",
163 off,
164 GNUNET_STRINGS_relative_time_to_string (delay,
165 GNUNET_YES));
166 if (BENCHMARK_SIZE == off)
167 {
168 res = 0;
169 }
170 else
171 {
172 GNUNET_break (0);
173 res = 1;
174 }
175 GNUNET_SCHEDULER_shutdown ();
176}
177
178
179static void
180fail_cb (void *cls)
181{
182 zi = NULL;
183 res = 2;
184 GNUNET_break (0);
185 GNUNET_SCHEDULER_shutdown ();
186}
187
188
189static void
190zone_proc (void *cls,
191 const struct GNUNET_IDENTITY_PrivateKey *zone,
192 const char *label,
193 unsigned int rd_count,
194 const struct GNUNET_GNSRECORD_Data *rd)
195{
196 struct GNUNET_GNSRECORD_Data *wrd;
197 unsigned int xoff;
198
199 GNUNET_assert (NULL != zone);
200 if (1 != sscanf (label,
201 "l%u",
202 &xoff))
203 {
204 res = 3;
205 GNUNET_break (0);
206 GNUNET_SCHEDULER_shutdown ();
207 return;
208 }
209 if ((xoff > BENCHMARK_SIZE) ||
210 (0 != (seen[xoff / 8] & (1U << (xoff % 8)))))
211 {
212 res = 3;
213 GNUNET_break (0);
214 GNUNET_SCHEDULER_shutdown ();
215 return;
216 }
217 seen[xoff / 8] |= (1U << (xoff % 8));
218 wrd = create_record (xoff % MAX_REC_SIZE);
219 if ((rd->record_type != wrd->record_type) ||
220 (rd->data_size != wrd->data_size) ||
221 (rd->flags != wrd->flags))
222 {
223 res = 4;
224 GNUNET_break (0);
225 GNUNET_SCHEDULER_shutdown ();
226 GNUNET_free (wrd);
227 return;
228 }
229 if (0 != memcmp (rd->data,
230 wrd->data,
231 wrd->data_size))
232 {
233 res = 4;
234 GNUNET_break (0);
235 GNUNET_SCHEDULER_shutdown ();
236 GNUNET_free (wrd);
237 return;
238 }
239 GNUNET_free (wrd);
240 if (0 != GNUNET_memcmp (zone,
241 &privkey))
242 {
243 res = 5;
244 GNUNET_break (0);
245 GNUNET_SCHEDULER_shutdown ();
246 return;
247 }
248 off++;
249 left_until_next--;
250 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
251 "Obtained record %u, expecting %u more until asking for more explicitly\n",
252 off,
253 left_until_next);
254 if (0 == left_until_next)
255 {
256 left_until_next = BLOCK_SIZE;
257 GNUNET_NAMESTORE_zone_iterator_next (zi,
258 left_until_next);
259 }
260}
261
262
263static void
264publish_record (void *cls);
265
266
267static void
268put_cont (void *cls,
269 int32_t success,
270 const char *emsg)
271{
272 (void) cls;
273 qe = NULL;
274 if (GNUNET_OK != success)
275 {
276 GNUNET_break (0);
277 GNUNET_SCHEDULER_shutdown ();
278 return;
279 }
280 t = GNUNET_SCHEDULER_add_now (&publish_record,
281 NULL);
282}
283
284
285static void
286publish_record (void *cls)
287{
288 struct GNUNET_GNSRECORD_Data *rd;
289 char *label;
290
291 (void) cls;
292 t = NULL;
293 if (BENCHMARK_SIZE == off)
294 {
295 struct GNUNET_TIME_Relative delay;
296
297 delay = GNUNET_TIME_absolute_get_duration (start);
298 fprintf (stdout,
299 "Inserting %u records took %s\n",
300 off,
301 GNUNET_STRINGS_relative_time_to_string (delay,
302 GNUNET_YES));
303 start = GNUNET_TIME_absolute_get ();
304 off = 0;
305 left_until_next = 1;
306 zi = GNUNET_NAMESTORE_zone_iteration_start (nsh,
307 NULL,
308 &fail_cb,
309 NULL,
310 &zone_proc,
311 NULL,
312 &zone_end,
313 NULL);
314 GNUNET_assert (NULL != zi);
315 return;
316 }
317 rd = create_record ((++off) % MAX_REC_SIZE);
318 GNUNET_asprintf (&label,
319 "l%u",
320 off);
321 qe = GNUNET_NAMESTORE_records_store (nsh,
322 &privkey,
323 label,
324 1, rd,
325 &put_cont,
326 NULL);
327 GNUNET_free (label);
328 GNUNET_free (rd);
329}
330
331
332static void
333run (void *cls,
334 const struct GNUNET_CONFIGURATION_Handle *cfg,
335 struct GNUNET_TESTING_Peer *peer)
336{
337 GNUNET_SCHEDULER_add_shutdown (&end,
338 NULL);
339 timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
340 &timeout,
341 NULL);
342 nsh = GNUNET_NAMESTORE_connect (cfg);
343 GNUNET_assert (NULL != nsh);
344 privkey.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY);
345 GNUNET_CRYPTO_ecdsa_key_create (&privkey.ecdsa_key);
346 start = GNUNET_TIME_absolute_get ();
347 t = GNUNET_SCHEDULER_add_now (&publish_record,
348 NULL);
349}
350
351
352#include "test_common.c"
353
354
355int
356main (int argc,
357 char *argv[])
358{
359 const char *plugin_name;
360 char *cfg_name;
361
362 SETUP_CFG (plugin_name, cfg_name);
363 res = 1;
364 if (0 !=
365 GNUNET_TESTING_peer_run ("perf-namestore-api-zone-iteration",
366 cfg_name,
367 &run,
368 NULL))
369 {
370 res = 1;
371 }
372 GNUNET_DISK_purge_cfg_dir (cfg_name,
373 "GNUNET_TEST_HOME");
374 GNUNET_free (cfg_name);
375 return res;
376}
377
378
379/* end of perf_namestore_api_zone_iteration.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-19 22:27:34 +0000