bug fix: bloomflex std::bad_alloc for large (2^32?) allocations

when using the fastidious option, swarm crashes when it tries to
allocate the bloomfilter (at least for allocations of 5 GB, could also
be the case for smaller allocations).

Our current tests are not able to trigger this bug.

I've introduced the bug on January 28th while replacing malloc with
new and delete. Sadly, the bug is present in main branch and in the
v3.1.1 release, so I think an urgent v3.1.2 release is necessary.

Other replacements of malloc made in January may have introduced
so-far undetected bugs. I will do my best to test large datasets
before future releases.

src/bloomflex.cc

@@ -35,6 +35,7 @@
 #include <cstring>
 #include "bloomflex.h"
 #include "pseudo_rng.h"
+#include "util.h"
 
 
 auto bloomflex_patterns_generate(struct bloomflex_s * b) -> void
@@ -64,18 +65,18 @@ auto bloomflex_init(uint64_t size, unsigned int k) -> struct bloomflex_s *
   constexpr unsigned int multiplier {16};  // multiply by 65,536
   constexpr unsigned int divider {3};  // divide by 8
 
-  auto * b = new struct bloomflex_s;
+  auto * b = static_cast<struct bloomflex_s *>(xmalloc(sizeof(struct bloomflex_s)));
   b->size = size >> divider;
 
   b->pattern_shift = multiplier;
   b->pattern_count = 1 << b->pattern_shift;
   b->pattern_mask = b->pattern_count - 1;
   b->pattern_k = k;
 
-  b->patterns = new uint64_t[b->pattern_count];
+  b->patterns = static_cast<uint64_t *>(xmalloc(b->pattern_count * sizeof(uint64_t)));
   bloomflex_patterns_generate(b);
 
-  b->bitmap = new uint64_t[size];
+  b->bitmap = static_cast<uint64_t *>(xmalloc(size));
   memset(b->bitmap, UINT8_MAX, size);
 
   return b;
@@ -84,10 +85,7 @@ auto bloomflex_init(uint64_t size, unsigned int k) -> struct bloomflex_s *
 
 auto bloomflex_exit(struct bloomflex_s * b) -> void
 {
-  delete [] b->bitmap;
-  b->bitmap = nullptr;
-  delete [] b->patterns;
-  b->patterns = nullptr;
-  delete b;
-  b = nullptr;
+  xfree(b->bitmap);
+  xfree(b->patterns);
+  xfree(b);
 }

src/util.cc

@@ -28,6 +28,7 @@ static const char * progress_prompt;
 static uint64_t progress_next;
 static uint64_t progress_size;
 static uint64_t progress_chunk;
+constexpr size_t memalignment = 16;
 
 
 auto progress_init(const char * prompt, const uint64_t size) -> void
@@ -70,13 +71,32 @@ auto progress_done() -> void
 }
 
 
+auto xmalloc(size_t size) -> void *
+{
+  if (size == 0) {
+    size = 1;
+  }
+  void * t {nullptr};
+#ifdef _WIN32
+  t = _aligned_malloc(size, memalignment);
+#else
+  if (posix_memalign(& t, memalignment, size) != 0) {
+    t = nullptr;
+  }
+#endif
+  if (t == nullptr) {
+    fatal(error_prefix, "Unable to allocate enough memory.");
+  }
+  return t;
+}
+
+
 auto xrealloc(void *ptr, size_t size) -> void *
 {
   if (size == 0) {
     size = 1;
   }
 #ifdef _WIN32
-  constexpr size_t memalignment = 16;
   void * t = _aligned_realloc(ptr, size, memalignment);
 #else
   void * t = realloc(ptr, size);

src/util.h

@@ -25,6 +25,7 @@
 #include <cstdio>
 
 
+auto xmalloc(size_t size) -> void *;
 auto xrealloc(void * ptr, size_t size) -> void *;
 auto xfree(void * ptr) -> void;
 auto xgetline(char ** linep, size_t * linecapp, FILE * stream) -> ssize_t;