[gnunet] 164/164: completing rebase to master

[gnunet]

This is an automated email from the git hooks/post-receive script.

grothoff pushed a commit to branch master
in repository gnunet.

commit 24bc8b1029d0207c7a4a0eba0516929d527cfb8e
Author: Christian Grothoff <christian@grothoff.org>
AuthorDate: Fri Jul 30 15:25:57 2021 +0200

    completing rebase to master
---
 src/setu/gnunet-service-setu.c                  |  13 +-
 src/setu/gnunet-service-setu_strata_estimator.c | 270 +++++++++++++++++-------
 src/setu/ibf.c                                  |  76 ++++---
 src/setu/perf_setu_api.c                        |  92 ++++----
 4 files changed, 288 insertions(+), 163 deletions(-)

diff --git a/src/setu/gnunet-service-setu.c b/src/setu/gnunet-service-setu.c
index bc181b1c2..a51e92b71 100644
--- a/src/setu/gnunet-service-setu.c
+++ b/src/setu/gnunet-service-setu.c
@@ -941,12 +941,13 @@ calculate_perf_store ()
   float rtt = 1;
   int bytes_transmitted = 0;
 
-    /**
-     *  Calculate RGNUNET_SETU_AcceptMessageRT of Fullsync normally 1 or 1.5 
depending
-     */
-    if (( perf_store.element_full.received != 0 ) ||
-         ( perf_store.element_full.sent != 0)
-        ) rtt += 1;
+  /**
+   *  Calculate RGNUNET_SETU_AcceptMessageRT of Fullsync normaly 1 or 1.5 
depending
+   */
+  if ((perf_store.element_full.received != 0) ||
+      (perf_store.element_full.sent != 0)
+      )
+    rtt += 1;
 
   if ((perf_store.request_full.received != 0) ||
       (perf_store.request_full.sent != 0)
diff --git a/src/setu/gnunet-service-setu_strata_estimator.c 
b/src/setu/gnunet-service-setu_strata_estimator.c
index aace38c56..7981cc847 100644
--- a/src/setu/gnunet-service-setu_strata_estimator.c
+++ b/src/setu/gnunet-service-setu_strata_estimator.c
@@ -30,6 +30,82 @@
 #include "gnunet-service-setu_strata_estimator.h"
 
 
+/**
+ * Should we try compressing the strata estimator? This will
+ * break compatibility with the 0.10.1-network.
+ */
+#define FAIL_10_1_COMPATIBILTIY 1
+
+/**
+ * Number of strata estimators in memory NOT transmitted
+ */
+
+#define MULTI_SE_BASE_COUNT 8
+
+/**
+ * The avg size of 1 se
+ * Based on the bsc thesis of Elias Summermatter (2021)
+ */
+
+#define AVG_BYTE_SIZE_SE 4221
+
+/**
+ * Calculates the optimal number of strata Estimators to send
+ * @param avg_element_size
+ * @param element_count
+ * @return
+ */
+uint8_t
+determine_strata_count (uint64_t avg_element_size, uint64_t element_count)
+{
+  uint64_t base_size = avg_element_size * element_count;
+  /* >67kb total size of elements in set */
+  if (base_size < AVG_BYTE_SIZE_SE * 16)
+    return 1;
+  /* >270kb total size of elements in set  */
+  if (base_size < AVG_BYTE_SIZE_SE * 64)
+    return 2;
+  /* >1mb total size of elements in set */
+  if (base_size < AVG_BYTE_SIZE_SE * 256)
+    return 4;
+  return 8;
+}
+
+
+/**
+ * Modify an IBF key @a k_in based on the @a salt, returning a
+ * salted key in @a k_out.
+ */
+static void
+salt_key (const struct IBF_Key *k_in,
+          uint32_t salt,
+          struct IBF_Key *k_out)
+{
+  int s = (salt * 7) % 64;
+  uint64_t x = k_in->key_val;
+
+  /* rotate ibf key */
+  x = (x >> s) | (x << (64 - s));
+  k_out->key_val = x;
+}
+
+
+/**
+ * Reverse modification done in the salt_key function
+ */
+static void
+unsalt_key (const struct IBF_Key *k_in,
+            uint32_t salt,
+            struct IBF_Key *k_out)
+{
+  int s = (salt * 7) % 64;
+  uint64_t x = k_in->key_val;
+
+  x = (x << s) | (x >> (64 - s));
+  k_out->key_val = x;
+}
+
+
 /**
  * Write the given strata estimator to the buffer.
  *
@@ -44,20 +120,27 @@ strata_estimator_write (struct MultiStrataEstimator *se,
                         void *buf)
 {
   char *sbuf = buf;
+  unsigned int i;
   size_t osize;
   uint64_t sbuf_offset = 0;
   se->size = number_se_send;
 
   GNUNET_assert (NULL != se);
-  for (unsigned int i = 0; i < se->strata_count; i++)
+  for (uint8_t strata_ctr = 0; strata_ctr < number_se_send; strata_ctr++)
   {
-    ibf_write_slice (se->strata[i],
-                     0,
-                     se->ibf_size,
-                     &sbuf[se->ibf_size * IBF_BUCKET_SIZE * i],
-                     8);
+    for (i = 0; i < se->stratas[strata_ctr]->strata_count; i++)
+    {
+      ibf_write_slice (se->stratas[strata_ctr]->strata[i],
+                       0,
+                       se->stratas[strata_ctr]->ibf_size,
+                       &sbuf[sbuf_offset],
+                       8);
+      sbuf_offset += se->stratas[strata_ctr]->ibf_size * IBF_BUCKET_SIZE;
+    }
   }
-  osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count;
+  osize = ((se_ibf_total_size / 8) * number_se_send) * IBF_BUCKET_SIZE
+          * se->stratas[0]->strata_count;
+#if FAIL_10_1_COMPATIBILTIY
   {
     char *cbuf;
     size_t nsize;
@@ -68,13 +151,12 @@ strata_estimator_write (struct MultiStrataEstimator *se,
                                 &cbuf,
                                 &nsize))
     {
-      GNUNET_memcpy (buf,
-                     cbuf,
-                     nsize);
+      GNUNET_memcpy (buf,  cbuf, nsize);
       osize = nsize;
       GNUNET_free (cbuf);
     }
   }
+#endif
   return osize;
 }
 
@@ -97,6 +179,7 @@ strata_estimator_read (const void *buf,
                        uint16_t se_ibf_total_size,
                        struct MultiStrataEstimator *se)
 {
+  unsigned int i;
   size_t osize;
   char *dbuf;
 
@@ -126,10 +209,14 @@ strata_estimator_read (const void *buf,
     return GNUNET_SYSERR;
   }
 
-  for (unsigned int i = 0; i < se->strata_count; i++)
+  for (uint8_t strata_ctr = 0; strata_ctr < number_se_received; strata_ctr++)
   {
-    ibf_read_slice (buf, 0, se->ibf_size, se->strata[i], 8);
-    buf += se->ibf_size * IBF_BUCKET_SIZE;
+    for (i = 0; i < se->stratas[strata_ctr]->strata_count; i++)
+    {
+      ibf_read_slice (buf, 0, se->stratas[strata_ctr]->ibf_size,
+                      se->stratas[strata_ctr]->strata[i], 8);
+      buf += se->stratas[strata_ctr]->ibf_size * IBF_BUCKET_SIZE;
+    }
   }
   se->size = number_se_received;
   GNUNET_free (dbuf);
@@ -215,24 +302,37 @@ strata_estimator_create (unsigned int strata_count,
                          uint32_t ibf_size,
                          uint8_t ibf_hashnum)
 {
-  struct StrataEstimator *se;
-
-  se = GNUNET_new (struct StrataEstimator);
-  se->strata_count = strata_count;
-  se->ibf_size = ibf_size;
-  se->strata = GNUNET_new_array (strata_count,
-                                 struct InvertibleBloomFilter *);
-  for (unsigned int i = 0; i < strata_count; i++)
+  struct MultiStrataEstimator *se;
+  unsigned int i;
+  unsigned int j;
+  se = GNUNET_new (struct MultiStrataEstimator);
+
+  se->size = MULTI_SE_BASE_COUNT;
+  se->stratas = GNUNET_new_array (MULTI_SE_BASE_COUNT,struct StrataEstimator 
*);
+
+  uint8_t ibf_prime_sizes[] = {79,79,79,79,79,79,79,79};
+
+  for (uint8_t strata_ctr = 0; strata_ctr < MULTI_SE_BASE_COUNT; strata_ctr++)
   {
-    se->strata[i] = ibf_create (ibf_size, ibf_hashnum);
-    if (NULL == se->strata[i])
+    se->stratas[strata_ctr] = GNUNET_new (struct StrataEstimator);
+    se->stratas[strata_ctr]->strata_count = strata_count;
+    se->stratas[strata_ctr]->ibf_size = ibf_prime_sizes[strata_ctr];
+    se->stratas[strata_ctr]->strata = GNUNET_new_array (strata_count * 4,
+                                                        struct
+                                                        InvertibleBloomFilter 
*);
+    for (i = 0; i < strata_count; i++)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to allocate memory for strata estimator\n");
-      for (unsigned int j = 0; j < i; j++)
-        ibf_destroy (se->strata[i]);
-      GNUNET_free (se);
-      return NULL;
+      se->stratas[strata_ctr]->strata[i] = ibf_create (
+        ibf_prime_sizes[strata_ctr], ibf_hashnum);
+      if (NULL == se->stratas[strata_ctr]->strata[i])
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Failed to allocate memory for strata estimator\n");
+        for (j = 0; j < i; j++)
+          ibf_destroy (se->stratas[strata_ctr]->strata[i]);
+        GNUNET_free (se);
+        return NULL;
+      }
     }
   }
   return se;
@@ -252,41 +352,55 @@ void
 strata_estimator_difference (const struct MultiStrataEstimator *se1,
                              const struct MultiStrataEstimator *se2)
 {
-  unsigned int count;
+  int avg_local_diff = 0;
+  int avg_remote_diff = 0;
+  uint8_t number_of_estimators = se1->size;
 
-  GNUNET_assert (se1->strata_count == se2->strata_count);
-  count = 0;
-  for (int i = se1->strata_count - 1; i >= 0; i--)
+  for (uint8_t strata_ctr = 0; strata_ctr < number_of_estimators; strata_ctr++)
   {
-    struct InvertibleBloomFilter *diff;
-    /* number of keys decoded from the ibf */
-
-    /* FIXME: implement this without always allocating new IBFs */
-    diff = ibf_dup (se1->strata[i]);
-    ibf_subtract (diff,
-                  se2->strata[i]);
-    for (int ibf_count = 0; GNUNET_YES; ibf_count++)
+    GNUNET_assert (se1->stratas[strata_ctr]->strata_count ==
+                   se2->stratas[strata_ctr]->strata_count);
+
+
+    for (int i = se1->stratas[strata_ctr]->strata_count - 1; i >= 0; i--)
     {
-      int more;
+      struct InvertibleBloomFilter *diff;
+      /* number of keys decoded from the ibf */
 
-      more = ibf_decode (diff,
-                         NULL,
-                         NULL);
-      if (GNUNET_NO == more)
-      {
-        se1->strata[0]->local_decoded_count += diff->local_decoded_count ;
-        se1->strata[0]->remote_decoded_count += diff->remote_decoded_count;
-        count += ibf_count;
-        break;
-      }
-      /* Estimate if decoding fails or would not terminate */
-      if ( (GNUNET_SYSERR == more) ||
-           (ibf_count > diff->size) )
+      /* FIXME: implement this without always allocating new IBFs */
+      diff = ibf_dup (se1->stratas[strata_ctr]->strata[i]);
+      diff->local_decoded_count = 0;
+      diff->remote_decoded_count = 0;
+
+      ibf_subtract (diff, se2->stratas[strata_ctr]->strata[i]);
+
+      for (int ibf_count = 0; GNUNET_YES; ibf_count++)
       {
-        se1->strata[0]->local_decoded_count = 
se1->strata[0]->local_decoded_count * (1 << (i + 1));
-        se1->strata[0]->remote_decoded_count = 
se1->strata[0]->remote_decoded_count * (1 << (i + 1));
-        ibf_destroy (diff);
-        return count * (1 << (i + 1));
+        int more;
+
+        more = ibf_decode (diff, NULL, NULL);
+        if (GNUNET_NO == more)
+        {
+          se1->stratas[strata_ctr]->strata[0]->local_decoded_count +=
+            diff->local_decoded_count;
+          se1->stratas[strata_ctr]->strata[0]->remote_decoded_count +=
+            diff->remote_decoded_count;
+          break;
+        }
+        /* Estimate if decoding fails or would not terminate */
+        if ((GNUNET_SYSERR == more) || (ibf_count > diff->size))
+        {
+          se1->stratas[strata_ctr]->strata[0]->local_decoded_count =
+            se1->stratas[strata_ctr]->strata[0]->local_decoded_count * (1 << (i
+                                                                              +
+                                                                              
1));
+          se1->stratas[strata_ctr]->strata[0]->remote_decoded_count =
+            se1->stratas[strata_ctr]->strata[0]->remote_decoded_count * (1 << 
(i
+                                                                               
+
+                                                                               
1));
+          ibf_destroy (diff);
+          goto break_all_counting_loops;
+        }
       }
       ibf_destroy (diff);
     }
@@ -311,15 +425,25 @@ break_all_counting_loops:;
 struct MultiStrataEstimator *
 strata_estimator_dup (struct MultiStrataEstimator *se)
 {
-  struct StrataEstimator *c;
-
-  c = GNUNET_new (struct StrataEstimator);
-  c->strata_count = se->strata_count;
-  c->ibf_size = se->ibf_size;
-  c->strata = GNUNET_new_array (se->strata_count,
-                                struct InvertibleBloomFilter *);
-  for (unsigned int i = 0; i < se->strata_count; i++)
-    c->strata[i] = ibf_dup (se->strata[i]);
+  struct MultiStrataEstimator *c;
+  unsigned int i;
+
+  c = GNUNET_new (struct MultiStrataEstimator);
+  c->stratas = GNUNET_new_array (MULTI_SE_BASE_COUNT,struct StrataEstimator *);
+  for (uint8_t strata_ctr = 0; strata_ctr < MULTI_SE_BASE_COUNT; strata_ctr++)
+  {
+    c->stratas[strata_ctr] = GNUNET_new (struct StrataEstimator);
+    c->stratas[strata_ctr]->strata_count =
+      se->stratas[strata_ctr]->strata_count;
+    c->stratas[strata_ctr]->ibf_size = se->stratas[strata_ctr]->ibf_size;
+    c->stratas[strata_ctr]->strata = GNUNET_new_array (
+      se->stratas[strata_ctr]->strata_count,
+      struct
+      InvertibleBloomFilter *);
+    for (i = 0; i < se->stratas[strata_ctr]->strata_count; i++)
+      c->stratas[strata_ctr]->strata[i] = ibf_dup (
+        se->stratas[strata_ctr]->strata[i]);
+  }
   return c;
 }
 
@@ -332,8 +456,12 @@ strata_estimator_dup (struct MultiStrataEstimator *se)
 void
 strata_estimator_destroy (struct MultiStrataEstimator *se)
 {
-  for (unsigned int i = 0; i < se->strata_count; i++)
-    ibf_destroy (se->strata[i]);
-  GNUNET_free (se->strata);
+  unsigned int i;
+  for (uint8_t strata_ctr = 0; strata_ctr < MULTI_SE_BASE_COUNT; strata_ctr++)
+  {
+    for (i = 0; i < se->stratas[strata_ctr]->strata_count; i++)
+      ibf_destroy (se->stratas[strata_ctr]->strata[i]);
+    GNUNET_free (se->stratas[strata_ctr]->strata);
+  }
   GNUNET_free (se);
 }
diff --git a/src/setu/ibf.c b/src/setu/ibf.c
index 7d726236d..8f29adb62 100644
--- a/src/setu/ibf.c
+++ b/src/setu/ibf.c
@@ -20,7 +20,7 @@
 
 /**
  * @file set/ibf.c
- * @brief implementation of the invertible Bloom filter
+ * @brief implementation of the invertible bloom filter
  * @author Florian Dold
  * @author Elias Summermatter
  */
@@ -62,11 +62,12 @@ ibf_hashcode_from_key (struct IBF_Key key,
                        struct GNUNET_HashCode *dst)
 {
   struct IBF_Key *p;
+  unsigned int i;
   const unsigned int keys_per_hashcode = sizeof(struct GNUNET_HashCode)
                                          / sizeof(struct IBF_Key);
 
   p = (struct IBF_Key *) dst;
-  for (unsigned int i = 0; i < keys_per_hashcode; i++)
+  for (i = 0; i < keys_per_hashcode; i++)
     *p++ = key;
 }
 
@@ -79,12 +80,12 @@ ibf_hashcode_from_key (struct IBF_Key key,
  * @return the newly created invertible bloom filter, NULL on error
  */
 struct InvertibleBloomFilter *
-ibf_create (uint32_t size,
-            uint8_t hash_num)
+ibf_create (uint32_t size, uint8_t hash_num)
 {
   struct InvertibleBloomFilter *ibf;
 
   GNUNET_assert (0 != size);
+
   ibf = GNUNET_new (struct InvertibleBloomFilter);
   ibf->count = GNUNET_malloc_large (size * sizeof(uint64_t));
   if (NULL == ibf->count)
@@ -109,6 +110,7 @@ ibf_create (uint32_t size,
   }
   ibf->size = size;
   ibf->hash_num = hash_num;
+
   return ibf;
 }
 
@@ -125,8 +127,7 @@ ibf_get_indices (const struct InvertibleBloomFilter *ibf,
   uint32_t i;
   uint32_t bucket;
 
-  bucket = GNUNET_CRYPTO_crc32_n (&key,
-                                  sizeof (key));
+  bucket = GNUNET_CRYPTO_crc32_n (&key, sizeof key);
   for (i = 0, filled = 0; filled < ibf->hash_num; i++)
   {
     uint64_t x;
@@ -137,8 +138,7 @@ ibf_get_indices (const struct InvertibleBloomFilter *ibf,
     dst[filled++] = bucket % ibf->size;
 try_next:
     x = ((uint64_t) bucket << 32) | i;
-    bucket = GNUNET_CRYPTO_crc32_n (&x,
-                                    sizeof (x));
+    bucket = GNUNET_CRYPTO_crc32_n (&x, sizeof x);
   }
 }
 
@@ -174,13 +174,8 @@ ibf_insert (struct InvertibleBloomFilter *ibf,
   int buckets[ibf->hash_num];
 
   GNUNET_assert (ibf->hash_num <= ibf->size);
-  ibf_get_indices (ibf,
-                   key,
-                   buckets);
-  ibf_insert_into (ibf,
-                   key,
-                   buckets,
-                   1);
+  ibf_get_indices (ibf, key, buckets);
+  ibf_insert_into (ibf, key, buckets, 1);
 }
 
 
@@ -197,13 +192,8 @@ ibf_remove (struct InvertibleBloomFilter *ibf,
   int buckets[ibf->hash_num];
 
   GNUNET_assert (ibf->hash_num <= ibf->size);
-  ibf_get_indices (ibf,
-                   key,
-                   buckets);
-  ibf_insert_into (ibf,
-                   key,
-                   buckets,
-                   -1);
+  ibf_get_indices (ibf, key, buckets);
+  ibf_insert_into (ibf, key, buckets, -1);
 }
 
 
@@ -248,6 +238,8 @@ ibf_decode (struct InvertibleBloomFilter *ibf,
 
   for (uint32_t i = 0; i < ibf->size; i++)
   {
+    int hit;
+
     /* we can only decode from pure buckets */
     if ( (1 != ibf->count[i].count_val) &&
          (-1 != ibf->count[i].count_val) )
@@ -261,30 +253,33 @@ ibf_decode (struct InvertibleBloomFilter *ibf,
 
     /* test if key in bucket hits its own location,
      * if not, the key hash was subject to collision */
-    {
-      bool hit = false;
+    hit = GNUNET_NO;
+    ibf_get_indices (ibf, ibf->key_sum[i], buckets);
+    for (int j = 0; j < ibf->hash_num; j++)
+      if (buckets[j] == i)
+        hit = GNUNET_YES;
 
-      ibf_get_indices (ibf,
-                       ibf->key_sum[i],
-                       buckets);
-      for (int j = 0; j < ibf->hash_num; j++)
-        if (buckets[j] == i)
-        {
-          hit = true;
-          break;
-        }
-      if (! hit)
-        continue;
+    if (GNUNET_NO == hit)
+      continue;
+
+    if (1 == ibf->count[i].count_val)
+    {
+      ibf->remote_decoded_count++;
+    }
+    else
+    {
+      ibf->local_decoded_count++;
     }
+
+
     if (NULL != ret_side)
       *ret_side = ibf->count[i].count_val;
     if (NULL != ret_id)
       *ret_id = ibf->key_sum[i];
 
     /* insert on the opposite side, effectively removing the element */
-    ibf_insert_into (ibf,
-                     ibf->key_sum[i], buckets,
-                     -ibf->count[i].count_val);
+    ibf_insert_into (ibf, ibf->key_sum[i], buckets, -ibf->count[i].count_val);
+
     return GNUNET_YES;
   }
 
@@ -327,8 +322,9 @@ ibf_get_max_counter (struct InvertibleBloomFilter *ibf)
 void
 ibf_write_slice (const struct InvertibleBloomFilter *ibf,
                  uint32_t start,
-                 uint32_t count,
-                 void *buf)
+                 uint64_t count,
+                 void *buf,
+                 uint8_t counter_max_length)
 {
   struct IBF_Key *key_dst;
   struct IBF_KeyHash *key_hash_dst;
diff --git a/src/setu/perf_setu_api.c b/src/setu/perf_setu_api.c
index 887dc54a3..af84994f8 100644
--- a/src/setu/perf_setu_api.c
+++ b/src/setu/perf_setu_api.c
@@ -326,52 +326,52 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *cfg,
      struct GNUNET_TESTING_Peer *peer)
 {
-    struct GNUNET_SETU_OperationHandle *my_oh;
-
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Running preparatory tests\n");
-    tt = GNUNET_SCHEDULER_add_delayed (
-            GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
-            &timeout_fail,
-            NULL);
-    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
-
-    config = cfg;
-    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg,
-                                                                 &local_id));
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "my id (from CRYPTO): %s\n",
-                GNUNET_i2s (&local_id));
-    GNUNET_TESTING_peer_get_identity (peer,
-                                      &local_id);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "my id (from TESTING): %s\n",
-                GNUNET_i2s (&local_id));
-    set1 = GNUNET_SETU_create (cfg);
-    set2 = GNUNET_SETU_create (cfg);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Created sets %p and %p for union operation\n",
-                set1,
-                set2);
-    GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id);
-
-    /* test if canceling an uncommitted request works! */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Launching and instantly stopping set operation\n");
-    my_oh = GNUNET_SETU_prepare (&local_id,
-                                 &app_id,
-                                 NULL,
-                                 (struct GNUNET_SETU_Option[]){ 0 },
-                                 NULL,
-                                 NULL);
-    GNUNET_SETU_operation_cancel (my_oh);
-
-    /* test the real set reconciliation */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Running real set-reconciliation\n");
-    //init_set1 ();
-    // limit ~23800 element total
-    initRandomSets(470, 500,500,32);
+  struct GNUNET_SETU_OperationHandle *my_oh;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Running preparatory tests\n");
+  tt = GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
+    &timeout_fail,
+    NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+
+  config = cfg;
+  GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg,
+                                                               &local_id));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "my id (from CRYPTO): %s\n",
+              GNUNET_i2s (&local_id));
+  GNUNET_TESTING_peer_get_identity (peer,
+                                    &local_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "my id (from TESTING): %s\n",
+              GNUNET_i2s (&local_id));
+  set1 = GNUNET_SETU_create (cfg);
+  set2 = GNUNET_SETU_create (cfg);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Created sets %p and %p for union operation\n",
+              set1,
+              set2);
+  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id);
+
+  /* test if canceling an uncommited request works! */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Launching and instantly stopping set operation\n");
+  my_oh = GNUNET_SETU_prepare (&local_id,
+                               &app_id,
+                               NULL,
+                               (struct GNUNET_SETU_Option[]){ 0 },
+                               NULL,
+                               NULL);
+  GNUNET_SETU_operation_cancel (my_oh);
+
+  /* test the real set reconciliation */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Running real set-reconciliation\n");
+  // init_set1 ();
+  // limit ~23800 element total
+  initRandomSets (490, 500,500,32);
 }
 
 

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.