diff options
author | Florian Dold <florian.dold@gmail.com> | 2013-06-19 10:48:54 +0000 |
---|---|---|
committer | Florian Dold <florian.dold@gmail.com> | 2013-06-19 10:48:54 +0000 |
commit | a900b29ddaa9ea46c731b054b5e3ef3e725b95a8 (patch) | |
tree | 52e1a9697b0abf4618cd5684359ec5f0a040898a /src/set/gnunet-set-profiler.c | |
parent | 17353bc0a47c89bda205f23e7995377c9bfe7769 (diff) | |
download | gnunet-a900b29ddaa9ea46c731b054b5e3ef3e725b95a8.tar.gz gnunet-a900b29ddaa9ea46c731b054b5e3ef3e725b95a8.zip |
- opaque mq structs
- mq for mesh
- faster hashing for IBFs
- mesh replaces stream in set
- new set profiler (work in progress)
Diffstat (limited to 'src/set/gnunet-set-profiler.c')
-rw-r--r-- | src/set/gnunet-set-profiler.c | 320 |
1 files changed, 320 insertions, 0 deletions
diff --git a/src/set/gnunet-set-profiler.c b/src/set/gnunet-set-profiler.c new file mode 100644 index 000000000..bbaef7c43 --- /dev/null +++ b/src/set/gnunet-set-profiler.c | |||
@@ -0,0 +1,320 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | (C) 2013 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 | /** | ||
22 | * @file set/gnunet-set-profiler.c | ||
23 | * @brief profiling tool for set | ||
24 | * @author Florian Dold | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_common.h" | ||
28 | #include "gnunet_util_lib.h" | ||
29 | #include "gnunet_set_service.h" | ||
30 | #include "gnunet_testbed_service.h" | ||
31 | |||
32 | |||
33 | static int ret; | ||
34 | |||
35 | static unsigned int num_a = 5; | ||
36 | static unsigned int num_b = 5; | ||
37 | static unsigned int num_c = 20; | ||
38 | |||
39 | static unsigned int salt = 42; | ||
40 | |||
41 | static char* op_str = "union"; | ||
42 | |||
43 | const static struct GNUNET_CONFIGURATION_Handle *config; | ||
44 | |||
45 | struct GNUNET_CONTAINER_MultiHashMap *map_a; | ||
46 | struct GNUNET_CONTAINER_MultiHashMap *map_b; | ||
47 | struct GNUNET_CONTAINER_MultiHashMap *map_c; | ||
48 | |||
49 | |||
50 | /** | ||
51 | * Elements that set a received, should match map_c | ||
52 | * in the end. | ||
53 | */ | ||
54 | struct GNUNET_CONTAINER_MultiHashMap *map_a_received; | ||
55 | |||
56 | /** | ||
57 | * Elements that set b received, should match map_c | ||
58 | * in the end. | ||
59 | */ | ||
60 | struct GNUNET_CONTAINER_MultiHashMap *map_b_received; | ||
61 | |||
62 | struct GNUNET_SET_Handle *set_a; | ||
63 | struct GNUNET_SET_Handle *set_b; | ||
64 | |||
65 | struct GNUNET_HashCode app_id; | ||
66 | |||
67 | struct GNUNET_PeerIdentity local_peer; | ||
68 | |||
69 | struct GNUNET_SET_ListenHandle *set_listener; | ||
70 | |||
71 | struct GNUNET_SET_OperationHandle *set_oh1; | ||
72 | struct GNUNET_SET_OperationHandle *set_oh2; | ||
73 | |||
74 | |||
75 | int a_done; | ||
76 | int b_done; | ||
77 | |||
78 | |||
79 | |||
80 | static int | ||
81 | map_remove_iterator (void *cls, | ||
82 | const struct GNUNET_HashCode *key, | ||
83 | void *value) | ||
84 | { | ||
85 | struct GNUNET_CONTAINER_MultiHashMap *m = cls; | ||
86 | int ret; | ||
87 | |||
88 | ret = GNUNET_CONTAINER_multihashmap_remove (m, key, NULL); | ||
89 | GNUNET_assert (GNUNET_OK == ret); | ||
90 | return GNUNET_YES; | ||
91 | |||
92 | } | ||
93 | |||
94 | |||
95 | static void | ||
96 | set_result_cb_1 (void *cls, | ||
97 | const struct GNUNET_SET_Element *element, | ||
98 | enum GNUNET_SET_Status status) | ||
99 | { | ||
100 | GNUNET_assert (GNUNET_NO == a_done); | ||
101 | GNUNET_assert (element->size == sizeof (struct GNUNET_HashCode)); | ||
102 | switch (status) | ||
103 | { | ||
104 | case GNUNET_SET_STATUS_DONE: | ||
105 | case GNUNET_SET_STATUS_HALF_DONE: | ||
106 | a_done = GNUNET_YES; | ||
107 | GNUNET_CONTAINER_multihashmap_iterate (map_c, map_remove_iterator, map_a_received); | ||
108 | GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (map_a_received)); | ||
109 | return; | ||
110 | case GNUNET_SET_STATUS_FAILURE: | ||
111 | GNUNET_assert (0); | ||
112 | return; | ||
113 | case GNUNET_SET_STATUS_OK: | ||
114 | break; | ||
115 | default: | ||
116 | GNUNET_assert (0); | ||
117 | } | ||
118 | GNUNET_CONTAINER_multihashmap_put (map_a_received, | ||
119 | element->data, NULL, | ||
120 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | ||
121 | } | ||
122 | |||
123 | |||
124 | static void | ||
125 | set_result_cb_2 (void *cls, | ||
126 | const struct GNUNET_SET_Element *element, | ||
127 | enum GNUNET_SET_Status status) | ||
128 | { | ||
129 | GNUNET_assert (GNUNET_NO == b_done); | ||
130 | GNUNET_assert (element->size == sizeof (struct GNUNET_HashCode)); | ||
131 | switch (status) | ||
132 | { | ||
133 | case GNUNET_SET_STATUS_DONE: | ||
134 | case GNUNET_SET_STATUS_HALF_DONE: | ||
135 | b_done = GNUNET_YES; | ||
136 | GNUNET_CONTAINER_multihashmap_iterate (map_c, map_remove_iterator, map_b_received); | ||
137 | GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (map_b_received)); | ||
138 | return; | ||
139 | case GNUNET_SET_STATUS_FAILURE: | ||
140 | GNUNET_assert (0); | ||
141 | return; | ||
142 | case GNUNET_SET_STATUS_OK: | ||
143 | break; | ||
144 | default: | ||
145 | GNUNET_assert (0); | ||
146 | } | ||
147 | GNUNET_CONTAINER_multihashmap_put (map_b_received, | ||
148 | element->data, NULL, | ||
149 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | ||
150 | } | ||
151 | |||
152 | |||
153 | static void | ||
154 | set_listen_cb (void *cls, | ||
155 | const struct GNUNET_PeerIdentity *other_peer, | ||
156 | const struct GNUNET_MessageHeader *context_msg, | ||
157 | struct GNUNET_SET_Request *request) | ||
158 | { | ||
159 | GNUNET_assert (NULL == set_oh2); | ||
160 | set_oh2 = GNUNET_SET_accept (request, GNUNET_SET_RESULT_ADDED, | ||
161 | set_result_cb_2, NULL); | ||
162 | GNUNET_SET_commit (set_oh2, set_b); | ||
163 | } | ||
164 | |||
165 | |||
166 | |||
167 | static int | ||
168 | set_insert_iterator (void *cls, | ||
169 | const struct GNUNET_HashCode *key, | ||
170 | void *value) | ||
171 | { | ||
172 | struct GNUNET_SET_Handle *set = cls; | ||
173 | struct GNUNET_SET_Element *el; | ||
174 | |||
175 | el = GNUNET_malloc (sizeof *el + sizeof *key); | ||
176 | el->type = 0; | ||
177 | memcpy (&el[1], key, sizeof *key); | ||
178 | el->data = &el[1]; | ||
179 | el->size = sizeof *key; | ||
180 | GNUNET_SET_add_element (set, el, NULL, NULL); | ||
181 | GNUNET_free (el); | ||
182 | return GNUNET_YES; | ||
183 | } | ||
184 | |||
185 | |||
186 | /** | ||
187 | * Signature of the 'main' function for a (single-peer) testcase that | ||
188 | * is run using 'GNUNET_TESTING_peer_run'. | ||
189 | * | ||
190 | * @param cls closure | ||
191 | * @param cfg configuration of the peer that was started | ||
192 | * @param peer identity of the peer that was created | ||
193 | */ | ||
194 | static void | ||
195 | test_main (void *cls, | ||
196 | const struct GNUNET_CONFIGURATION_Handle *cfg, | ||
197 | struct GNUNET_TESTING_Peer *peer) | ||
198 | { | ||
199 | unsigned int i; | ||
200 | struct GNUNET_HashCode hash; | ||
201 | |||
202 | config = cfg; | ||
203 | |||
204 | if (GNUNET_OK != GNUNET_CRYPTO_get_host_identity (cfg, &local_peer)) | ||
205 | { | ||
206 | GNUNET_assert (0); | ||
207 | return; | ||
208 | } | ||
209 | |||
210 | map_a = GNUNET_CONTAINER_multihashmap_create (num_a, GNUNET_NO); | ||
211 | map_b = GNUNET_CONTAINER_multihashmap_create (num_b, GNUNET_NO); | ||
212 | map_c = GNUNET_CONTAINER_multihashmap_create (num_c, GNUNET_NO); | ||
213 | |||
214 | for (i = 0; i < num_a; i++) | ||
215 | { | ||
216 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash); | ||
217 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash)) | ||
218 | { | ||
219 | i--; | ||
220 | continue; | ||
221 | } | ||
222 | GNUNET_CONTAINER_multihashmap_put (map_a, &hash, &hash, | ||
223 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | ||
224 | } | ||
225 | |||
226 | for (i = 0; i < num_b; i++) | ||
227 | { | ||
228 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash); | ||
229 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash)) | ||
230 | { | ||
231 | i--; | ||
232 | continue; | ||
233 | } | ||
234 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_b, &hash)) | ||
235 | { | ||
236 | i--; | ||
237 | continue; | ||
238 | } | ||
239 | GNUNET_CONTAINER_multihashmap_put (map_b, &hash, NULL, | ||
240 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | ||
241 | } | ||
242 | |||
243 | for (i = 0; i < num_c; i++) | ||
244 | { | ||
245 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash); | ||
246 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash)) | ||
247 | { | ||
248 | i--; | ||
249 | continue; | ||
250 | } | ||
251 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_b, &hash)) | ||
252 | { | ||
253 | i--; | ||
254 | continue; | ||
255 | } | ||
256 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_c, &hash)) | ||
257 | { | ||
258 | i--; | ||
259 | continue; | ||
260 | } | ||
261 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash); | ||
262 | GNUNET_CONTAINER_multihashmap_put (map_c, &hash, NULL, | ||
263 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | ||
264 | } | ||
265 | |||
266 | /* use last hash for app id */ | ||
267 | app_id = hash; | ||
268 | |||
269 | /* FIXME: also implement intersection etc. */ | ||
270 | set_a = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); | ||
271 | set_b = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); | ||
272 | |||
273 | GNUNET_CONTAINER_multihashmap_iterate (map_a, set_insert_iterator, set_a); | ||
274 | GNUNET_CONTAINER_multihashmap_iterate (map_b, set_insert_iterator, set_b); | ||
275 | GNUNET_CONTAINER_multihashmap_iterate (map_c, set_insert_iterator, set_a); | ||
276 | GNUNET_CONTAINER_multihashmap_iterate (map_c, set_insert_iterator, set_b); | ||
277 | |||
278 | set_listener = GNUNET_SET_listen (config, GNUNET_SET_OPERATION_UNION, | ||
279 | &app_id, set_listen_cb, NULL); | ||
280 | |||
281 | set_oh1 = GNUNET_SET_prepare (&local_peer, &app_id, NULL, salt, GNUNET_SET_RESULT_ADDED, | ||
282 | set_result_cb_1, NULL); | ||
283 | GNUNET_SET_commit (set_oh1, set_a); | ||
284 | } | ||
285 | |||
286 | static void | ||
287 | run (void *cls, char *const *args, const char *cfgfile, | ||
288 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
289 | { | ||
290 | |||
291 | ret = GNUNET_TESTING_peer_run ("test_set_api", | ||
292 | "test_set.conf", | ||
293 | &test_main, NULL); | ||
294 | } | ||
295 | |||
296 | |||
297 | int | ||
298 | main (int argc, char **argv) | ||
299 | { | ||
300 | static const struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
301 | { 'A', "num-first", NULL, | ||
302 | gettext_noop ("number of values"), | ||
303 | GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_a }, | ||
304 | { 'B', "num-second", NULL, | ||
305 | gettext_noop ("number of values"), | ||
306 | GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_b }, | ||
307 | { 'B', "num-common", NULL, | ||
308 | gettext_noop ("number of values"), | ||
309 | GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_c }, | ||
310 | { 'x', "operation", NULL, | ||
311 | gettext_noop ("oeration to execute"), | ||
312 | GNUNET_YES, &GNUNET_GETOPT_set_string, &op_str }, | ||
313 | GNUNET_GETOPT_OPTION_END | ||
314 | }; | ||
315 | GNUNET_PROGRAM_run2 (argc, argv, "gnunet-consensus", | ||
316 | "help", | ||
317 | options, &run, NULL, GNUNET_YES); | ||
318 | return ret; | ||
319 | } | ||
320 | |||