1 files changed, 175 insertions, 175 deletions
diff --git a/src/set/gnunet-set-ibf-profiler.c b/src/set/gnunet-set-ibf-profiler.c
index c54557fb0..944b63d30 100644
--- a/src/set/gnunet-set-ibf-profiler.c
+++ b/src/set/gnunet-set-ibf-profiler.c
@@ -50,62 +50,62 @@ static struct InvertibleBloomFilter *ibf_b;
 static void
-register_hashcode(struct GNUNET_HashCode *hash)
+register_hashcode (struct GNUNET_HashCode *hash)
 {
  struct GNUNET_HashCode replicated;
  struct IBF_Key key;
-  key = ibf_key_from_hashcode(hash);
+  key = ibf_key_from_hashcode (hash);
-  ibf_hashcode_from_key(key, &replicated);
+  ibf_hashcode_from_key (key, &replicated);
-  (void)GNUNET_CONTAINER_multihashmap_put(
+  (void) GNUNET_CONTAINER_multihashmap_put (
    key_to_hashcode,
    &replicated,
-    GNUNET_memdup(hash, sizeof *hash),
+    GNUNET_memdup (hash, sizeof *hash),
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 }
 static void
-iter_hashcodes(struct IBF_Key key,
+iter_hashcodes (struct IBF_Key key,
-               GNUNET_CONTAINER_MulitHashMapIteratorCallback iter,
+                GNUNET_CONTAINER_MulitHashMapIteratorCallback iter,
-               void *cls)
+                void *cls)
 {
  struct GNUNET_HashCode replicated;
-  ibf_hashcode_from_key(key, &replicated);
+  ibf_hashcode_from_key (key, &replicated);
-  GNUNET_CONTAINER_multihashmap_get_multiple(key_to_hashcode,
+  GNUNET_CONTAINER_multihashmap_get_multiple (key_to_hashcode,
-                                             &replicated,
+                                              &replicated,
-                                             iter,
+                                              iter,
-                                             cls);
+                                              cls);
 }
 static int
-insert_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
+insert_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
  struct InvertibleBloomFilter *ibf = cls;
-  ibf_insert(ibf, ibf_key_from_hashcode(key));
+  ibf_insert (ibf, ibf_key_from_hashcode (key));
  return GNUNET_YES;
 }
 static int
-remove_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
+remove_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
  struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls;
  /* if remove fails, there just was a collision with another key */
-  (void)GNUNET_CONTAINER_multihashmap_remove(hashmap, value, NULL);
+  (void) GNUNET_CONTAINER_multihashmap_remove (hashmap, value, NULL);
  return GNUNET_YES;
 }
 static void
-run(void *cls,
+run (void *cls,
-    char *const *args,
+     char *const *args,
-    const char *cfgfile,
+     const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
  struct GNUNET_HashCode id;
  struct IBF_Key ibf_key;
@@ -116,193 +116,193 @@ run(void *cls,
  struct GNUNET_TIME_Relative delta_time;
  set_a =
-    GNUNET_CONTAINER_multihashmap_create(((asize == 0) ? 1 : (asize + csize)),
+    GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)),
-                                         GNUNET_NO);
+                                          GNUNET_NO);
  set_b =
-    GNUNET_CONTAINER_multihashmap_create(((bsize == 0) ? 1 : (bsize + csize)),
+    GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)),
-                                         GNUNET_NO);
+                                          GNUNET_NO);
-  set_c = GNUNET_CONTAINER_multihashmap_create(((csize == 0) ? 1 : csize),
+  set_c = GNUNET_CONTAINER_multihashmap_create (((csize == 0) ? 1 : csize),
-                                               GNUNET_NO);
+                                                GNUNET_NO);
  key_to_hashcode =
-    GNUNET_CONTAINER_multihashmap_create(((asize + bsize + csize == 0)
+    GNUNET_CONTAINER_multihashmap_create (((asize + bsize + csize == 0)
-                                          ? 1
+                                           ? 1
-                                          : (asize + bsize + csize)),
+                                           : (asize + bsize + csize)),
-                                         GNUNET_NO);
+                                          GNUNET_NO);
-  printf("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n",
+  printf ("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n",
-         hash_num,
+          hash_num,
-         ibf_size,
+          ibf_size,
-         asize,
+          asize,
-         bsize,
+          bsize,
-         csize);
+          csize);
  i = 0;
  while (i < asize)
-    {
+  {
-      GNUNET_CRYPTO_hash_create_random(random_quality, &id);
+    GNUNET_CRYPTO_hash_create_random (random_quality, &id);
-      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id))
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
-        continue;
+      continue;
-      GNUNET_break(GNUNET_OK ==
+    GNUNET_break (GNUNET_OK ==
-                   GNUNET_CONTAINER_multihashmap_put(
+                  GNUNET_CONTAINER_multihashmap_put (
-                     set_a,
+                    set_a,
-                     &id,
+                    &id,
-                     NULL,
+                    NULL,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      register_hashcode(&id);
+    register_hashcode (&id);
-      i++;
+    i++;
-    }
+  }
  i = 0;
  while (i < bsize)
-    {
+  {
-      GNUNET_CRYPTO_hash_create_random(random_quality, &id);
+    GNUNET_CRYPTO_hash_create_random (random_quality, &id);
-      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id))
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
-        continue;
+      continue;
-      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_b, &id))
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
-        continue;
+      continue;
-      GNUNET_break(GNUNET_OK ==
+    GNUNET_break (GNUNET_OK ==
-                   GNUNET_CONTAINER_multihashmap_put(
+                  GNUNET_CONTAINER_multihashmap_put (
-                     set_b,
+                    set_b,
-                     &id,
+                    &id,
-                     NULL,
+                    NULL,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      register_hashcode(&id);
+    register_hashcode (&id);
-      i++;
+    i++;
-    }
+  }
  i = 0;
  while (i < csize)
-    {
+  {
-      GNUNET_CRYPTO_hash_create_random(random_quality, &id);
+    GNUNET_CRYPTO_hash_create_random (random_quality, &id);
-      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id))
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
-        continue;
+      continue;
-      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_b, &id))
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
-        continue;
+      continue;
-      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_c, &id))
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_c, &id))
-        continue;
+      continue;
-      GNUNET_break(GNUNET_OK ==
+    GNUNET_break (GNUNET_OK ==
-                   GNUNET_CONTAINER_multihashmap_put(
+                  GNUNET_CONTAINER_multihashmap_put (
-                     set_c,
+                    set_c,
-                     &id,
+                    &id,
-                     NULL,
+                    NULL,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      register_hashcode(&id);
+    register_hashcode (&id);
-      i++;
+    i++;
-    }
+  }
-  ibf_a = ibf_create(ibf_size, hash_num);
+  ibf_a = ibf_create (ibf_size, hash_num);
-  ibf_b = ibf_create(ibf_size, hash_num);
+  ibf_b = ibf_create (ibf_size, hash_num);
  if ((NULL == ibf_a) || (NULL == ibf_b))
-    {
+  {
-      /* insufficient memory */
+    /* insufficient memory */
-      GNUNET_break(0);
+    GNUNET_break (0);
-      GNUNET_SCHEDULER_shutdown();
+    GNUNET_SCHEDULER_shutdown ();
-      return;
+    return;
-    }
+  }
-  printf("generated sets\n");
+  printf ("generated sets\n");
-  start_time = GNUNET_TIME_absolute_get();
+  start_time = GNUNET_TIME_absolute_get ();
-  GNUNET_CONTAINER_multihashmap_iterate(set_a, &insert_iterator, ibf_a);
+  GNUNET_CONTAINER_multihashmap_iterate (set_a, &insert_iterator, ibf_a);
-  GNUNET_CONTAINER_multihashmap_iterate(set_b, &insert_iterator, ibf_b);
+  GNUNET_CONTAINER_multihashmap_iterate (set_b, &insert_iterator, ibf_b);
-  GNUNET_CONTAINER_multihashmap_iterate(set_c, &insert_iterator, ibf_a);
+  GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_a);
-  GNUNET_CONTAINER_multihashmap_iterate(set_c, &insert_iterator, ibf_b);
+  GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_b);
-  delta_time = GNUNET_TIME_absolute_get_duration(start_time);
+  delta_time = GNUNET_TIME_absolute_get_duration (start_time);
-  printf("encoded in: %s\n",
+  printf ("encoded in: %s\n",
-         GNUNET_STRINGS_relative_time_to_string(delta_time, GNUNET_NO));
+          GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO));
-  ibf_subtract(ibf_a, ibf_b);
+  ibf_subtract (ibf_a, ibf_b);
-  start_time = GNUNET_TIME_absolute_get();
+  start_time = GNUNET_TIME_absolute_get ();
  for (i = 0; i <= asize + bsize; i++)
+  {
+    res = ibf_decode (ibf_a, &side, &ibf_key);
+    if (GNUNET_SYSERR == res)
    {
-      res = ibf_decode(ibf_a, &side, &ibf_key);
+      printf ("decode failed, %u/%u elements left\n",
-      if (GNUNET_SYSERR == res)
+              GNUNET_CONTAINER_multihashmap_size (set_a)
-        {
+              + GNUNET_CONTAINER_multihashmap_size (set_b),
-          printf("decode failed, %u/%u elements left\n",
+              asize + bsize);
-                 GNUNET_CONTAINER_multihashmap_size(set_a) +
+      return;
-                 GNUNET_CONTAINER_multihashmap_size(set_b),
-                 asize + bsize);
-          return;
-        }
-      if (GNUNET_NO == res)
-        {
-          if ((0 == GNUNET_CONTAINER_multihashmap_size(set_b)) &&
-              (0 == GNUNET_CONTAINER_multihashmap_size(set_a)))
-            {
-              delta_time = GNUNET_TIME_absolute_get_duration(start_time);
-              printf("decoded successfully in: %s\n",
-                     GNUNET_STRINGS_relative_time_to_string(delta_time, GNUNET_NO));
-            }
-          else
-            {
-              printf("decode missed elements (should never happen)\n");
-            }
-          return;
-        }
-      if (side == 1)
-        iter_hashcodes(ibf_key, remove_iterator, set_a);
-      if (side == -1)
-        iter_hashcodes(ibf_key, remove_iterator, set_b);
    }
-  printf("cyclic IBF, %u/%u elements left\n",
+    if (GNUNET_NO == res)
-         GNUNET_CONTAINER_multihashmap_size(set_a) +
+    {
-         GNUNET_CONTAINER_multihashmap_size(set_b),
+      if ((0 == GNUNET_CONTAINER_multihashmap_size (set_b)) &&
-         asize + bsize);
+          (0 == GNUNET_CONTAINER_multihashmap_size (set_a)))
+      {
+        delta_time = GNUNET_TIME_absolute_get_duration (start_time);
+        printf ("decoded successfully in: %s\n",
+                GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO));
+      }
+      else
+      {
+        printf ("decode missed elements (should never happen)\n");
+      }
+      return;
+    }
+    if (side == 1)
+      iter_hashcodes (ibf_key, remove_iterator, set_a);
+    if (side == -1)
+      iter_hashcodes (ibf_key, remove_iterator, set_b);
+  }
+  printf ("cyclic IBF, %u/%u elements left\n",
+          GNUNET_CONTAINER_multihashmap_size (set_a)
+          + GNUNET_CONTAINER_multihashmap_size (set_b),
+          asize + bsize);
 }
 int
-main(int argc, char **argv)
+main (int argc, char **argv)
 {
  struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_uint('A',
+    GNUNET_GETOPT_option_uint ('A',
-                              "asize",
+                               "asize",
-                              NULL,
+                               NULL,
-                              gettext_noop("number of element in set A-B"),
+                               gettext_noop ("number of element in set A-B"),
-                              &asize),
+                               &asize),
-    GNUNET_GETOPT_option_uint('B',
+    GNUNET_GETOPT_option_uint ('B',
-                              "bsize",
+                               "bsize",
-                              NULL,
+                               NULL,
-                              gettext_noop("number of element in set B-A"),
+                               gettext_noop ("number of element in set B-A"),
-                              &bsize),
+                               &bsize),
-    GNUNET_GETOPT_option_uint('C',
+    GNUNET_GETOPT_option_uint ('C',
-                              "csize",
+                               "csize",
-                              NULL,
+                               NULL,
-                              gettext_noop(
+                               gettext_noop (
-                                "number of common elements in A and B"),
+                                 "number of common elements in A and B"),
-                              &csize),
+                               &csize),
-    GNUNET_GETOPT_option_uint('k',
+    GNUNET_GETOPT_option_uint ('k',
-                              "hash-num",
+                               "hash-num",
-                              NULL,
+                               NULL,
-                              gettext_noop("hash num"),
+                               gettext_noop ("hash num"),
-                              &hash_num),
+                               &hash_num),
-    GNUNET_GETOPT_option_uint('s',
+    GNUNET_GETOPT_option_uint ('s',
-                              "ibf-size",
+                               "ibf-size",
-                              NULL,
+                               NULL,
-                              gettext_noop("ibf size"),
+                               gettext_noop ("ibf size"),
-                              &ibf_size),
+                               &ibf_size),
    GNUNET_GETOPT_OPTION_END
  };
-  GNUNET_PROGRAM_run2(argc,
+  GNUNET_PROGRAM_run2 (argc,
-                      argv,
+                       argv,
-                      "gnunet-consensus-ibf",
+                       "gnunet-consensus-ibf",
-                      "help",
+                       "help",
-                      options,
+                       options,
-                      &run,
+                       &run,
-                      NULL,
+                       NULL,
-                      GNUNET_YES);
+                       GNUNET_YES);
  return 0;
 }

diff --git a/src/set/gnunet-set-ibf-profiler.c b/src/set/gnunet-set-ibf-profiler.c index c54557fb0..944b63d30 100644 --- a/src/set/gnunet-set-ibf-profiler.c +++ b/src/set/gnunet-set-ibf-profiler.c
@@ -50,62 +50,62 @@ static struct InvertibleBloomFilter *ibf_b;
50		50
51		51
52	static void	52	static void
53	register_hashcode(struct GNUNET_HashCode *hash)	53	register_hashcode (struct GNUNET_HashCode *hash)
54	{	54	{
55	struct GNUNET_HashCode replicated;	55	struct GNUNET_HashCode replicated;
56	struct IBF_Key key;	56	struct IBF_Key key;
57		57
58	key = ibf_key_from_hashcode(hash);	58	key = ibf_key_from_hashcode (hash);
59	ibf_hashcode_from_key(key, &replicated);	59	ibf_hashcode_from_key (key, &replicated);
60	(void)GNUNET_CONTAINER_multihashmap_put(	60	(void) GNUNET_CONTAINER_multihashmap_put (
61	key_to_hashcode,	61	key_to_hashcode,
62	&replicated,	62	&replicated,
63	GNUNET_memdup(hash, sizeof *hash),	63	GNUNET_memdup (hash, sizeof *hash),
64	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);	64	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
65	}	65	}
66		66
67		67
68	static void	68	static void
69	iter_hashcodes(struct IBF_Key key,	69	iter_hashcodes (struct IBF_Key key,
70	GNUNET_CONTAINER_MulitHashMapIteratorCallback iter,	70	GNUNET_CONTAINER_MulitHashMapIteratorCallback iter,
71	void *cls)	71	void *cls)
72	{	72	{
73	struct GNUNET_HashCode replicated;	73	struct GNUNET_HashCode replicated;
74		74
75	ibf_hashcode_from_key(key, &replicated);	75	ibf_hashcode_from_key (key, &replicated);
76	GNUNET_CONTAINER_multihashmap_get_multiple(key_to_hashcode,	76	GNUNET_CONTAINER_multihashmap_get_multiple (key_to_hashcode,
77	&replicated,	77	&replicated,
78	iter,	78	iter,
79	cls);	79	cls);
80	}	80	}
81		81
82		82
83	static int	83	static int
84	insert_iterator(void cls, const struct GNUNET_HashCode key, void *value)	84	insert_iterator (void cls, const struct GNUNET_HashCode key, void *value)
85	{	85	{
86	struct InvertibleBloomFilter *ibf = cls;	86	struct InvertibleBloomFilter *ibf = cls;
87		87
88	ibf_insert(ibf, ibf_key_from_hashcode(key));	88	ibf_insert (ibf, ibf_key_from_hashcode (key));
89	return GNUNET_YES;	89	return GNUNET_YES;
90	}	90	}
91		91
92		92
93	static int	93	static int
94	remove_iterator(void cls, const struct GNUNET_HashCode key, void *value)	94	remove_iterator (void cls, const struct GNUNET_HashCode key, void *value)
95	{	95	{
96	struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls;	96	struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls;
97		97
98	/* if remove fails, there just was a collision with another key */	98	/* if remove fails, there just was a collision with another key */
99	(void)GNUNET_CONTAINER_multihashmap_remove(hashmap, value, NULL);	99	(void) GNUNET_CONTAINER_multihashmap_remove (hashmap, value, NULL);
100	return GNUNET_YES;	100	return GNUNET_YES;
101	}	101	}
102		102
103		103
104	static void	104	static void
105	run(void *cls,	105	run (void *cls,
106	char const args,	106	char const args,
107	const char *cfgfile,	107	const char *cfgfile,
108	const struct GNUNET_CONFIGURATION_Handle *cfg)	108	const struct GNUNET_CONFIGURATION_Handle *cfg)
109	{	109	{
110	struct GNUNET_HashCode id;	110	struct GNUNET_HashCode id;
111	struct IBF_Key ibf_key;	111	struct IBF_Key ibf_key;
@@ -116,193 +116,193 @@ run(void *cls,
116	struct GNUNET_TIME_Relative delta_time;	116	struct GNUNET_TIME_Relative delta_time;
117		117
118	set_a =	118	set_a =
119	GNUNET_CONTAINER_multihashmap_create(((asize == 0) ? 1 : (asize + csize)),	119	GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)),
120	GNUNET_NO);	120	GNUNET_NO);
121	set_b =	121	set_b =
122	GNUNET_CONTAINER_multihashmap_create(((bsize == 0) ? 1 : (bsize + csize)),	122	GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)),
123	GNUNET_NO);	123	GNUNET_NO);
124	set_c = GNUNET_CONTAINER_multihashmap_create(((csize == 0) ? 1 : csize),	124	set_c = GNUNET_CONTAINER_multihashmap_create (((csize == 0) ? 1 : csize),
125	GNUNET_NO);	125	GNUNET_NO);
126		126
127	key_to_hashcode =	127	key_to_hashcode =
128	GNUNET_CONTAINER_multihashmap_create(((asize + bsize + csize == 0)	128	GNUNET_CONTAINER_multihashmap_create (((asize + bsize + csize == 0)
129	? 1	129	? 1
130	: (asize + bsize + csize)),	130	: (asize + bsize + csize)),
131	GNUNET_NO);	131	GNUNET_NO);
132		132
133	printf("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n",	133	printf ("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n",
134	hash_num,	134	hash_num,
135	ibf_size,	135	ibf_size,
136	asize,	136	asize,
137	bsize,	137	bsize,
138	csize);	138	csize);
139		139
140	i = 0;	140	i = 0;
141	while (i < asize)	141	while (i < asize)
142	{	142	{
143	GNUNET_CRYPTO_hash_create_random(random_quality, &id);	143	GNUNET_CRYPTO_hash_create_random (random_quality, &id);
144	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id))	144	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
145	continue;	145	continue;
146	GNUNET_break(GNUNET_OK ==	146	GNUNET_break (GNUNET_OK ==
147	GNUNET_CONTAINER_multihashmap_put(	147	GNUNET_CONTAINER_multihashmap_put (
148	set_a,	148	set_a,
149	&id,	149	&id,
150	NULL,	150	NULL,
151	GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));	151	GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
152	register_hashcode(&id);	152	register_hashcode (&id);
153	i++;	153	i++;
154	}	154	}
155	i = 0;	155	i = 0;
156	while (i < bsize)	156	while (i < bsize)
157	{	157	{
158	GNUNET_CRYPTO_hash_create_random(random_quality, &id);	158	GNUNET_CRYPTO_hash_create_random (random_quality, &id);
159	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id))	159	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
160	continue;	160	continue;
161	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_b, &id))	161	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
162	continue;	162	continue;
163	GNUNET_break(GNUNET_OK ==	163	GNUNET_break (GNUNET_OK ==
164	GNUNET_CONTAINER_multihashmap_put(	164	GNUNET_CONTAINER_multihashmap_put (
165	set_b,	165	set_b,
166	&id,	166	&id,
167	NULL,	167	NULL,
168	GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));	168	GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
169	register_hashcode(&id);	169	register_hashcode (&id);
170	i++;	170	i++;
171	}	171	}
172	i = 0;	172	i = 0;
173	while (i < csize)	173	while (i < csize)
174	{	174	{
175	GNUNET_CRYPTO_hash_create_random(random_quality, &id);	175	GNUNET_CRYPTO_hash_create_random (random_quality, &id);
176	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id))	176	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
177	continue;	177	continue;
178	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_b, &id))	178	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
179	continue;	179	continue;
180	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_c, &id))	180	if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_c, &id))
181	continue;	181	continue;
182	GNUNET_break(GNUNET_OK ==	182	GNUNET_break (GNUNET_OK ==
183	GNUNET_CONTAINER_multihashmap_put(	183	GNUNET_CONTAINER_multihashmap_put (
184	set_c,	184	set_c,
185	&id,	185	&id,
186	NULL,	186	NULL,
187	GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));	187	GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
188	register_hashcode(&id);	188	register_hashcode (&id);
189	i++;	189	i++;
190	}	190	}
191		191
192	ibf_a = ibf_create(ibf_size, hash_num);	192	ibf_a = ibf_create (ibf_size, hash_num);
193	ibf_b = ibf_create(ibf_size, hash_num);	193	ibf_b = ibf_create (ibf_size, hash_num);
194	if ((NULL == ibf_a) \|\| (NULL == ibf_b))	194	if ((NULL == ibf_a) \|\| (NULL == ibf_b))
195	{	195	{
196	/* insufficient memory */	196	/* insufficient memory */
197	GNUNET_break(0);	197	GNUNET_break (0);
198	GNUNET_SCHEDULER_shutdown();	198	GNUNET_SCHEDULER_shutdown ();
199	return;	199	return;
200	}	200	}
201		201
202		202
203	printf("generated sets\n");	203	printf ("generated sets\n");
204		204
205	start_time = GNUNET_TIME_absolute_get();	205	start_time = GNUNET_TIME_absolute_get ();
206		206
207	GNUNET_CONTAINER_multihashmap_iterate(set_a, &insert_iterator, ibf_a);	207	GNUNET_CONTAINER_multihashmap_iterate (set_a, &insert_iterator, ibf_a);
208	GNUNET_CONTAINER_multihashmap_iterate(set_b, &insert_iterator, ibf_b);	208	GNUNET_CONTAINER_multihashmap_iterate (set_b, &insert_iterator, ibf_b);
209	GNUNET_CONTAINER_multihashmap_iterate(set_c, &insert_iterator, ibf_a);	209	GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_a);
210	GNUNET_CONTAINER_multihashmap_iterate(set_c, &insert_iterator, ibf_b);	210	GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_b);
211		211
212	delta_time = GNUNET_TIME_absolute_get_duration(start_time);	212	delta_time = GNUNET_TIME_absolute_get_duration (start_time);
213		213
214	printf("encoded in: %s\n",	214	printf ("encoded in: %s\n",
215	GNUNET_STRINGS_relative_time_to_string(delta_time, GNUNET_NO));	215	GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO));
216		216
217	ibf_subtract(ibf_a, ibf_b);	217	ibf_subtract (ibf_a, ibf_b);
218		218
219		219
220	start_time = GNUNET_TIME_absolute_get();	220	start_time = GNUNET_TIME_absolute_get ();
221		221
222	for (i = 0; i <= asize + bsize; i++)	222	for (i = 0; i <= asize + bsize; i++)
		223	{
		224	res = ibf_decode (ibf_a, &side, &ibf_key);
		225	if (GNUNET_SYSERR == res)
223	{	226	{
224	res = ibf_decode(ibf_a, &side, &ibf_key);	227	printf ("decode failed, %u/%u elements left\n",
225	if (GNUNET_SYSERR == res)	228	GNUNET_CONTAINER_multihashmap_size (set_a)
226	{	229	+ GNUNET_CONTAINER_multihashmap_size (set_b),
227	printf("decode failed, %u/%u elements left\n",	230	asize + bsize);
228	GNUNET_CONTAINER_multihashmap_size(set_a) +	231	return;
229	GNUNET_CONTAINER_multihashmap_size(set_b),
230	asize + bsize);
231	return;
232	}
233	if (GNUNET_NO == res)
234	{
235	if ((0 == GNUNET_CONTAINER_multihashmap_size(set_b)) &&
236	(0 == GNUNET_CONTAINER_multihashmap_size(set_a)))
237	{
238	delta_time = GNUNET_TIME_absolute_get_duration(start_time);
239	printf("decoded successfully in: %s\n",
240	GNUNET_STRINGS_relative_time_to_string(delta_time, GNUNET_NO));
241	}
242	else
243	{
244	printf("decode missed elements (should never happen)\n");
245	}
246	return;
247	}
248
249	if (side == 1)
250	iter_hashcodes(ibf_key, remove_iterator, set_a);
251	if (side == -1)
252	iter_hashcodes(ibf_key, remove_iterator, set_b);
253	}	232	}
254	printf("cyclic IBF, %u/%u elements left\n",	233	if (GNUNET_NO == res)
255	GNUNET_CONTAINER_multihashmap_size(set_a) +	234	{
256	GNUNET_CONTAINER_multihashmap_size(set_b),	235	if ((0 == GNUNET_CONTAINER_multihashmap_size (set_b)) &&
257	asize + bsize);	236	(0 == GNUNET_CONTAINER_multihashmap_size (set_a)))
		237	{
		238	delta_time = GNUNET_TIME_absolute_get_duration (start_time);
		239	printf ("decoded successfully in: %s\n",
		240	GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO));
		241	}
		242	else
		243	{
		244	printf ("decode missed elements (should never happen)\n");
		245	}
		246	return;
		247	}
		248
		249	if (side == 1)
		250	iter_hashcodes (ibf_key, remove_iterator, set_a);
		251	if (side == -1)
		252	iter_hashcodes (ibf_key, remove_iterator, set_b);
		253	}
		254	printf ("cyclic IBF, %u/%u elements left\n",
		255	GNUNET_CONTAINER_multihashmap_size (set_a)
		256	+ GNUNET_CONTAINER_multihashmap_size (set_b),
		257	asize + bsize);
258	}	258	}
259		259
260		260
261	int	261	int
262	main(int argc, char **argv)	262	main (int argc, char **argv)
263	{	263	{
264	struct GNUNET_GETOPT_CommandLineOption options[] = {	264	struct GNUNET_GETOPT_CommandLineOption options[] = {
265	GNUNET_GETOPT_option_uint('A',	265	GNUNET_GETOPT_option_uint ('A',
266	"asize",	266	"asize",
267	NULL,	267	NULL,
268	gettext_noop("number of element in set A-B"),	268	gettext_noop ("number of element in set A-B"),
269	&asize),	269	&asize),
270		270
271	GNUNET_GETOPT_option_uint('B',	271	GNUNET_GETOPT_option_uint ('B',
272	"bsize",	272	"bsize",
273	NULL,	273	NULL,
274	gettext_noop("number of element in set B-A"),	274	gettext_noop ("number of element in set B-A"),
275	&bsize),	275	&bsize),
276		276
277	GNUNET_GETOPT_option_uint('C',	277	GNUNET_GETOPT_option_uint ('C',
278	"csize",	278	"csize",
279	NULL,	279	NULL,
280	gettext_noop(	280	gettext_noop (
281	"number of common elements in A and B"),	281	"number of common elements in A and B"),
282	&csize),	282	&csize),
283		283
284	GNUNET_GETOPT_option_uint('k',	284	GNUNET_GETOPT_option_uint ('k',
285	"hash-num",	285	"hash-num",
286	NULL,	286	NULL,
287	gettext_noop("hash num"),	287	gettext_noop ("hash num"),
288	&hash_num),	288	&hash_num),
289		289
290	GNUNET_GETOPT_option_uint('s',	290	GNUNET_GETOPT_option_uint ('s',
291	"ibf-size",	291	"ibf-size",
292	NULL,	292	NULL,
293	gettext_noop("ibf size"),	293	gettext_noop ("ibf size"),
294	&ibf_size),	294	&ibf_size),
295		295
296	GNUNET_GETOPT_OPTION_END	296	GNUNET_GETOPT_OPTION_END
297	};	297	};
298		298
299	GNUNET_PROGRAM_run2(argc,	299	GNUNET_PROGRAM_run2 (argc,
300	argv,	300	argv,
301	"gnunet-consensus-ibf",	301	"gnunet-consensus-ibf",
302	"help",	302	"help",
303	options,	303	options,
304	&run,	304	&run,
305	NULL,	305	NULL,
306	GNUNET_YES);	306	GNUNET_YES);
307	return 0;	307	return 0;
308	}	308	}