iodine 0.2.11 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b66fc52e683d2179b50db49e0c3912b11465cfc
-  data.tar.gz: c52e3bcb4f88dc8134a6fd0cd8c933569a7feccf
+  metadata.gz: f452e7b373f6e571cfde2d15c813a2b56b68b7ec
+  data.tar.gz: ae82d8b0e5a8e89a341e94ad8fa64f4bdcbe2bab
 SHA512:
-  metadata.gz: ce2c2217e792f1cd6b4178e0a12cfc80bf5eb7fef89113ce232799be5fb2797da2c09e399c324c189019434ee566d4083ff68cdf288eacc846c4042e76709cc7
-  data.tar.gz: c7aae4d6787b9d1442a978f66d83610f2391819e1c643099ed2fad2c78ae36d484d66e122295044b90d6d8039ab9a7fb013ef7ef9e95fa037fad3843213c3565
+  metadata.gz: e10f6de46108d5282babbbbde57f24889def07db0807cdc5674257881c6082ec219107d44f7c25c1523bb9365386ae5b188129ef4cf410d49c9ab62dacb255bf
+  data.tar.gz: 5f9dddd11aaad923cedb1151902fc92398e863a281360873642594dd77dd6fbb844f9c1498ff0a6d622cc69de6b857b370b7eab35c2de672f51e6acd47098fc5

data/CHANGELOG.md

@@ -8,7 +8,9 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
-Change log v.0.2.12 (next release)
+Change log v.0.2.12
+
+**Fix** removed `mempool` after it failed some stress and concurrency tests.
 
 ***
 

data/bin/ws-shootout

@@ -32,7 +32,7 @@ class ShootoutApp
     else
       msg = {type: 'broadcast', payload: payload}.to_json
       # Iodine::Websocket.each {|ws| ws.write msg}
-      Iodine::Websocket.multiwrite(msg) # {|ws| true }
+      Iodine::Websocket.each_write(msg) # {|ws| true }
       write({type: "broadcastResult", payload: payload}.to_json)
     end
   end

data/ext/iodine/libasync.c

@@ -445,7 +445,7 @@ void async_join() {
   }
   perform_tasks();
   async_free();
-};
+}
 
 /**
 Waits for existing tasks to complete and releases the thread
@@ -457,7 +457,7 @@ void async_signal() {
     return;
   async->flags.run = 0;
   wake_all_threads();
-};
+}
 
 /******************************************************************************
 Test

data/ext/iodine/libsock.c

@@ -195,7 +195,7 @@ static size_t fd_capacity = 0;
 #define uuid2info(uuid) fd_info[sock_uuid2fd(uuid)]
 #define is_valid(uuid)                                                         \
   (fd_info[sock_uuid2fd(uuid)].fduuid.data.counter ==                          \
-       ((fduuid_u)(uuid)).data.counter &&                                      \
+       ((fduuid_u *)(&uuid))->data.counter &&                                  \
    uuid2info(uuid).open)
 
 static struct {
@@ -254,8 +254,9 @@ static void destroy_lib_data(void) {
 #if USE_MALLOC == 1
     free(fd_info);
 #else
-    munmap(fd_info, (BUFFER_PACKET_REAL_SIZE * BUFFER_PACKET_POOL) +
-                        (sizeof(fd_info_s) * fd_capacity));
+    munmap(fd_info,
+           (BUFFER_PACKET_REAL_SIZE * BUFFER_PACKET_POOL) +
+               (sizeof(fd_info_s) * fd_capacity));
 #endif
   }
   fd_info = NULL;
@@ -300,7 +301,7 @@ static void sock_lib_init(void) {
     spn_unlock(&fd_info[i].lock);
   }
   /* initialize pool */
-  buffer_pool.allocated = buff_mem + fd_map_mem_size;
+  buffer_pool.allocated = (void *)((uintptr_t)buff_mem + fd_map_mem_size);
   buffer_pool.pool = buffer_pool.allocated;
   sock_packet_s *pos = buffer_pool.pool;
   for (size_t i = 0; i < BUFFER_PACKET_POOL - 1; i++) {
@@ -436,10 +437,11 @@ static inline int sock_flush_fd(int fd) {
   // send the data
   if (fd_info[fd].rw_hooks && fd_info[fd].rw_hooks->write)
     sent = fd_info[fd].rw_hooks->write(
-        fd_info[fd].fduuid.uuid, (((void *)(packet + 1)) + fd_info[fd].sent),
+        fd_info[fd].fduuid.uuid,
+        (void *)(((uintptr_t)(packet + 1)) + fd_info[fd].sent),
         i_exp - fd_info[fd].sent);
   else
-    sent = write(fd, (((void *)(packet + 1)) + fd_info[fd].sent),
+    sent = write(fd, (void *)(((uintptr_t)(packet + 1)) + fd_info[fd].sent),
                  i_exp - fd_info[fd].sent);
   // review result and update packet data
   if (sent < 0) {
@@ -463,11 +465,13 @@ static inline int sock_flush_data(int fd) {
   ssize_t sent;
   if (fd_info[fd].rw_hooks && fd_info[fd].rw_hooks->write)
     sent = fd_info[fd].rw_hooks->write(
-        fd_info[fd].fduuid.uuid, fd_info[fd].packet->buffer + fd_info[fd].sent,
+        fd_info[fd].fduuid.uuid,
+        (void *)((uintptr_t)fd_info[fd].packet->buffer + fd_info[fd].sent),
         fd_info[fd].packet->length - fd_info[fd].sent);
   else
-    sent = write(fd, fd_info[fd].packet->buffer + fd_info[fd].sent,
-                 fd_info[fd].packet->length - fd_info[fd].sent);
+    sent = write(
+        fd, (void *)((uintptr_t)fd_info[fd].packet->buffer + fd_info[fd].sent),
+        fd_info[fd].packet->length - fd_info[fd].sent);
   if (sent < 0) {
     if (ERR_OK)
       return -1;
@@ -502,7 +506,7 @@ static void sock_flush_unsafe(int fd) {
 #if SOCK_DELAY_WRITE == 1
 
 static inline void sock_flush_schd(intptr_t uuid) {
-  if (async_run((void *)sock_flush, (void *)uuid) == -1)
+  if (async_run((void (*)(void *))sock_flush, (void *)uuid) == -1)
     goto fallback;
   return;
 fallback:
@@ -744,7 +748,9 @@ sock_packet_s *sock_checkout_packet(void) {
     if (packet) {
       buffer_pool.pool = packet->metadata.next;
       spn_unlock(&buffer_pool.lock);
-      *packet = (sock_packet_s){.buffer = packet + 1, .metadata.next = NULL};
+      *packet = (sock_packet_s){
+          .buffer = packet + 1, .metadata.next = NULL, .metadata.dealloc = free,
+      };
       return packet;
     }
     spn_unlock(&buffer_pool.lock);
@@ -789,7 +795,7 @@ void sock_free_packet(sock_packet_s *packet) {
       if (next->metadata.keep_open == 0)
         close((int)((ssize_t)next->buffer));
     } else if (next->metadata.external)
-      free(next->buffer);
+      next->metadata.dealloc(next->buffer);
     if (next->metadata.next == NULL)
       break; /* next will hold the last packet in the chain. */
     next = next->metadata.next;
@@ -920,7 +926,7 @@ ssize_t sock_write2_fn(sock_write_info_s options) {
           memcpy(packet->buffer, options.buffer, to_cpy);
           packet->length = to_cpy;
           options.length -= to_cpy;
-          options.buffer += to_cpy;
+          options.buffer = (void *)((uintptr_t)options.buffer + to_cpy);
           sock_send_packet_unsafe(sock_uuid2fd(options.fduuid), packet);
           if (!is_valid(options.fduuid) || uuid2info(options.fduuid).err == 1 ||
               options.length == 0)

data/ext/iodine/libsock.h

@@ -69,7 +69,7 @@ typedef union {
 } fduuid_u;
 
 #define FDUUID_FAIL(uuid) (uuid == -1)
-#define sock_uuid2fd(uuid) ((fduuid_u)(uuid)).data.fd
+#define sock_uuid2fd(uuid) ((fduuid_u *)(&uuid))->data.fd
 #endif
 
 /* *****************************************************************************
@@ -362,6 +362,14 @@ typedef struct sock_packet_s {
     /** Starting point offset, when the buffer is a file (see
      * `sock_packet_s.metadata.is_fd`). */
     off_t offset;
+    /** This deallocation callback will be called when the packet is finished
+     * with the buffer.
+     * The deallocation callback will only be called for buffers marked as
+     * `external`.
+     * If no deallocation callback is specified,`free` will be called as a
+     * default deallocation method.
+     */
+    void (*dealloc)(void *buffer);
     /** sets whether a packet can be inserted before this packet without
      * interrupting the communication flow. */
     unsigned can_interrupt : 1;

data/ext/iodine/rb-libasync.h

@@ -32,7 +32,10 @@ Portability - used to help port this to different frameworks (i.e. Ruby).
 void async_signal();
 
 /* used here but declared elsewhere */
-void call_async_signal(void *_) { async_signal(); }
+void call_async_signal(void *_) {
+  (void)(_);
+  async_signal();
+}
 
 /* protect the call to join from any exceptions */
 static void *_inner_join_with_rbthread(void *rbt) {
@@ -69,7 +72,7 @@ static void *create_ruby_thread_gvl(void *_args) {
 
 /* create a ruby thread */
 UNUSED_FUNC static int create_thread(THREAD_TYPE *thr,
-                                  void *(*thread_func)(void *), void *arg) {
+                                     void *(*thread_func)(void *), void *arg) {
   struct CreateThreadArgs *data = malloc(sizeof(*data));
   if (!data)
     return -1;

data/ext/iodine/websockets.c

@@ -7,7 +7,6 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "websockets.h"
 #include "bscrypt.h"
 #include "libserver.h"
-#include "mempool.h"
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -57,13 +56,13 @@ struct buffer_s create_ws_buffer(ws_s *owner) {
   (void)(owner);
   struct buffer_s buff;
   buff.size = round_up_buffer_size(WS_INITIAL_BUFFER_SIZE);
-  buff.data = mempool_malloc(buff.size);
+  buff.data = malloc(buff.size);
   return buff;
 }
 
 struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s buff) {
   buff.size = round_up_buffer_size(buff.size);
-  void *tmp = mempool_realloc(buff.data, buff.size);
+  void *tmp = realloc(buff.data, buff.size);
   if (!tmp) {
     free_ws_buffer(owner, buff);
     buff.size = 0;
@@ -74,7 +73,7 @@ struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s buff) {
 void free_ws_buffer(ws_s *owner, struct buffer_s buff) {
   (void)(owner);
   if (buff.data)
-    mempool_free(buff.data);
+    free(buff.data);
 }
 
 #undef round_up_buffer_size
@@ -425,7 +424,7 @@ Create/Destroy the websocket object
 
 static ws_s *new_websocket() {
   // allocate the protocol object
-  ws_s *ws = mempool_malloc(sizeof(*ws));
+  ws_s *ws = malloc(sizeof(*ws));
   memset(ws, 0, sizeof(*ws));
 
   // setup the protocol & protocol callbacks
@@ -442,7 +441,7 @@ static void destroy_ws(ws_s *ws) {
   if (ws->on_close)
     ws->on_close(ws);
   free_ws_buffer(ws, ws->buffer);
-  mempool_free(ws);
+  free(ws);
 }
 
 /*******************************************************************************
@@ -807,25 +806,54 @@ Multi-Write (direct broadcast) Implementation
 struct websocket_multi_write {
   uint8_t (*if_callback)(ws_s *ws_to, void *arg);
   void *arg;
+  spn_lock_i lock;
+  size_t count;
   size_t length;
   uint8_t buffer[];
 };
 
+static void ws_reduce_or_free_multi_write(void *buff) {
+  struct websocket_multi_write *mw =
+      (void *)((uintptr_t)buff - sizeof(struct websocket_multi_write));
+  spn_lock(&mw->lock);
+  mw->count -= 1;
+  spn_unlock(&mw->lock);
+  if (!mw->count) {
+    free(mw);
+  }
+}
+
 static void ws_finish_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
+  struct websocket_multi_write *multi = arg;
   (void)(fd);
   (void)(_ws);
-  mempool_free(arg);
-}
-static void ws_check_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
-  struct websocket_multi_write *multi = arg;
-  if (multi->if_callback((void *)_ws, multi->arg))
-    sock_write(fd, multi->buffer, multi->length);
+  ws_reduce_or_free_multi_write(multi->buffer);
 }
 
 static void ws_direct_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
   struct websocket_multi_write *multi = arg;
   (void)(_ws);
-  sock_write(fd, multi->buffer, multi->length);
+
+  sock_packet_s *packet = sock_checkout_packet();
+  *packet = (sock_packet_s){
+      .buffer = multi->buffer,
+      .length = multi->length,
+      .metadata.can_interrupt = 1,
+      .metadata.dealloc = ws_reduce_or_free_multi_write,
+      .metadata.external = 1,
+  };
+
+  spn_lock(&multi->lock);
+  multi->count += 1;
+  spn_unlock(&multi->lock);
+
+  sock_send_packet(fd, packet);
+}
+
+static void ws_check_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
+  struct websocket_multi_write *multi = arg;
+  if (multi->if_callback((void *)_ws, multi->arg))
+    ws_direct_multi_write(fd, _ws, arg);
 }
 
 void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
@@ -833,11 +861,13 @@ void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
                           uint8_t (*if_callback)(ws_s *ws_to, void *arg),
                           void *arg) {
   struct websocket_multi_write *multi =
-      mempool_malloc(len + 14 /* max head size */ + sizeof(*multi));
+      malloc(len + 14 /* max head size */ + sizeof(*multi));
   multi->length =
       websocket_encode(multi->buffer, data, len, is_text, 1, 1, as_client);
   multi->if_callback = if_callback;
   multi->arg = arg;
+  multi->lock = SPN_LOCK_INIT;
+  multi->count = 1;
   server_each((ws_originator ? ws_originator->fd : -1), WEBSOCKET_ID_STR,
               (if_callback ? ws_check_multi_write : ws_direct_multi_write),
               multi, ws_finish_multi_write);

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.11'.freeze
+  VERSION = '0.2.12'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.12
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-20 00:00:00.000000000 Z
+date: 2017-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -147,7 +147,6 @@ files:
 - ext/iodine/libserver.h
 - ext/iodine/libsock.c
 - ext/iodine/libsock.h
-- ext/iodine/mempool.h
 - ext/iodine/misc.c
 - ext/iodine/misc.h
 - ext/iodine/random.c

data/ext/iodine/mempool.h

@@ -1,836 +0,0 @@
-/*
-Copyright: Boaz Segev, 2016-2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#ifndef MEMPOOL_H
-
-/* *****************************************************************************
-A simple `mmap` based localized memory pool (localized `malloc` alternative).
-
-The memory pool is localized to the same object file (C file). See NOTICE.
-
-The issue: objects that have a long life, such as Websocket / HTTP2 protocol
-objects or server wide strings with reference counts, cause memory fragmentation
-when allocated on the heap alongside objects that have a short life.
-
-This is a common issue when using `malloc` in long running processes for all
-allocations.
-
-This issue effects long running processes (such as servers) while it's effect on
-short lived proccesses are less accute and could often be ignored.
-
-To circumvent this issue, a seperate memory allocation method is used for
-long-lived objects.
-
-This memory pool allocates large blocks of memory (~2Mb at a time), minimizing
-small memory fragmentation by both reserving large memory blocks and seperating
-memory locality between long lived objects and short lived objects.
-
-The memory pool isn't expected to be faster than the system's `malloc`
-(although, sometimes it might perform better). However, selective use of this
-memory pool could improve concurrency (each pool has a seperate lock, unlike
-`malloc`'s system lock') as well as help with memory fragmentation.
-
-================================================================================
-NOTICE:
-
-The memory pool is attached to the specific file. in which `mempool.h` is
-included.
-
-The memory shoule NEVER be freed from a different file.
-
-However, it's easy to work around this limitation by wrapping the `mempool_`
-functions using proper `create` / `destroy` functions for any objects.
-
-================================================================================
-
-This file requires the "spnlock.h" library file as well. Together these files
-can be used also seperately from the `facil.io` library.
-
-*/
-#define MEMPOOL_H
-MEMPOOL_H
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include <errno.h>
-#include <signal.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef UNUSED_FUNC
-#define UNUSED_FUNC __attribute__((unused))
-#endif
-
-/* *****************************************************************************
-********************************************************************************
-API Declerations
-********************************************************************************
-***************************************************************************** */
-
-/** Allocates memory from the pool. */
-static UNUSED_FUNC void *mempool_malloc(size_t size);
-/**
- * Frees the memory, releasing it back to the pool (or, sometimes, the system).
- */
-static UNUSED_FUNC void mempool_free(void *ptr);
-/**
- * Behaves the same a the systems `realloc`, attempting to resize the memory
- * when possible.
- *
- * On error returns NULL (the old pointer data remains allocated and valid)
- * otherwise returns a new pointer (either equal to the old or after
- * deallocating the old one).
- */
-static UNUSED_FUNC void *mempool_realloc(void *ptr, size_t new_size);
-
-#if defined(DEBUG) && DEBUG == 1
-/** Tests the memory pool, both testing against issues / corruption and testing
- * it's performance against the system's `malloc`.
- */
-static UNUSED_FUNC void mempool_test(void);
-#endif
-
-/* *****************************************************************************
-********************************************************************************
-Implementation
-********************************************************************************
-***************************************************************************** */
-
-/* *****************************************************************************
-Memory block allocation
-*/
-
-#define MEMPOOL_BLOCK_SIZE (1UL << 21)
-#define MEMPOOL_ORDERING_LIMIT 32
-#define MEMPOOL_RETURN_MEM_TO_SYSTEM 1
-
-/* Will we use mmap or malloc? */
-// clang-format off
-#ifdef __has_include
-/* check for unix support */
-# if __has_include(<unistd.h>) && __has_include(<sys/mman.h>)
-#  define HAS_UNIX_FEATURES
-#  include <unistd.h>
-# endif
-#endif
-// clang-format on
-
-/* *****************************************************************************
-spnlock.h (can also be embeded instead of included)
-*/
-#include "spnlock.h"
-
-/* *****************************************************************************
-Memory slices, tree and helpers
-*/
-
-struct mempool_reserved_slice_s_offset { /** offset from this slice */
-  uint32_t reserved1; /* used to make the offset 16 bytes long */
-  uint32_t ahead;
-  uint32_t behind;
-  uint32_t reserved2; /* used to make the offset 16 bytes long */
-};
-
-typedef struct mempool_reserved_slice_s {
-  /** offset from this slice */
-  struct mempool_reserved_slice_s_offset offset;
-  /** Used for the free slices linked list. */
-  struct mempool_reserved_slice_s *next;
-  struct mempool_reserved_slice_s *prev;
-} mempool_reserved_slice_s;
-
-static struct {
-  mempool_reserved_slice_s *available;
-  spn_lock_i lock;
-} mempool_reserved_pool = {.available = NULL, .lock = SPN_LOCK_INIT};
-
-#define MEMPOOL_LOCK() spn_lock(&mempool_reserved_pool.lock)
-#define MEMPOOL_UNLOCK() spn_unlock(&mempool_reserved_pool.lock)
-
-#define MEMPOOL_USED_MARKER ((uint32_t)(~0UL << 21))
-#define MEMPOOL_INDI_MARKER ((uint32_t)0xF7F7F7F7UL)
-#define MEMPOOL_SIZE_MASK (MEMPOOL_BLOCK_SIZE - 1)
-
-#define MEMPOOL_SLICE2PTR(slice)                                               \
-  ((void *)(((uintptr_t)(slice)) +                                             \
-            (sizeof(struct mempool_reserved_slice_s_offset))))
-#define MEMPOOL_PTR2SLICE(ptr)                                                 \
-  ((mempool_reserved_slice_s *)(((uintptr_t)(ptr)) -                           \
-                                (sizeof(                                       \
-                                    struct mempool_reserved_slice_s_offset))))
-
-/* *****************************************************************************
-Memory Block Allocation / Deallocation
-*/
-#ifdef HAS_UNIX_FEATURES
-#include <sys/mman.h>
-
-#define MEMPOOL_ALLOC_SPECIAL(target, size)                                    \
-  do {                                                                         \
-    target = mmap(NULL, size, PROT_READ | PROT_WRITE | PROT_EXEC,              \
-                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);                         \
-    if (target == MAP_FAILED)                                                  \
-      target = NULL;                                                           \
-  } while (0);
-
-#define MEMPOOL_DEALLOC_SPECIAL(target, size) munmap((target), (size))
-
-#else
-
-#define MEMPOOL_ALLOC_SPECIAL(target, size)                                    \
-  do {                                                                         \
-    target = malloc(size);                                                     \
-  } while (0);
-
-#define MEMPOOL_DEALLOC_SPECIAL(target, size) free((target));
-
-#endif
-
-/* *****************************************************************************
-Helpers: Memory block slicing and memory pool list maintanence.
-*/
-
-/* *****************************************************************************
-API implementation
-*/
-
-static UNUSED_FUNC void *mempool_malloc(size_t size) {
-  if (!size)
-    return NULL;
-  if (size & 15) {
-    size = (size & (~15)) + 16;
-  }
-
-  size += sizeof(struct mempool_reserved_slice_s_offset);
-
-  mempool_reserved_slice_s *slice = NULL;
-
-  if (size > (MEMPOOL_BLOCK_SIZE - (sizeof(mempool_reserved_slice_s) << 1)))
-    goto alloc_indi;
-
-  MEMPOOL_LOCK();
-  slice = mempool_reserved_pool.available;
-  while (slice && slice->offset.ahead < size)
-    slice = slice->next;
-  if (slice) {
-    /* remove slice from available memory list */
-    if (slice->next)
-      slice->next->prev = slice->prev;
-    if (slice->prev)
-      slice->prev->next = slice->next;
-    else
-      mempool_reserved_pool.available = slice->next;
-    slice->next = NULL;
-    slice->prev = NULL;
-  } else {
-    MEMPOOL_ALLOC_SPECIAL(slice, MEMPOOL_BLOCK_SIZE);
-    // fprintf(stderr, "Allocated Block at %p\n", slice);
-    slice->offset.behind = 0;
-    slice->offset.ahead =
-        MEMPOOL_BLOCK_SIZE - (sizeof(struct mempool_reserved_slice_s_offset));
-
-    mempool_reserved_slice_s *tmp =
-        (mempool_reserved_slice_s
-             *)(((uintptr_t)(slice)) + MEMPOOL_BLOCK_SIZE -
-                (sizeof(struct mempool_reserved_slice_s_offset)));
-    tmp->offset.ahead = 0;
-    tmp->offset.behind = slice->offset.ahead;
-  }
-
-  if (!slice) {
-    MEMPOOL_UNLOCK();
-    fprintf(stderr, "mempool: no memory\n");
-    return NULL;
-  }
-
-  if (slice->offset.ahead > (size + sizeof(mempool_reserved_slice_s))) {
-    if (slice->offset.ahead & MEMPOOL_USED_MARKER) {
-      fprintf(stderr, "mempool ERROR: allocating an allocated slice!\n");
-    }
-    /* cut the slice in two */
-    mempool_reserved_slice_s *tmp =
-        (mempool_reserved_slice_s *)(((uintptr_t)slice) + size);
-    tmp->offset.behind = size;
-    tmp->offset.ahead = slice->offset.ahead - size;
-    slice->offset.ahead = size;
-    /* inform higher neighbor about any updates */
-    ((mempool_reserved_slice_s *)(((uintptr_t)tmp) + tmp->offset.ahead))
-        ->offset.behind = tmp->offset.ahead;
-    /* place the new slice in the available memory list */
-    uint16_t limit = MEMPOOL_ORDERING_LIMIT;
-    tmp->next = NULL;
-    tmp->prev = NULL;
-    mempool_reserved_slice_s **pos = &mempool_reserved_pool.available;
-    while (limit && *pos && ((*pos)->offset.ahead < tmp->offset.ahead)) {
-      tmp->prev = *pos;
-      pos = &(*pos)->next;
-      --limit;
-    }
-    if (*pos) {
-      tmp->next = *pos;
-      tmp->next->prev = tmp;
-      *pos = tmp;
-    } else {
-      *pos = tmp;
-    }
-  }
-
-  slice->offset.ahead |= MEMPOOL_USED_MARKER;
-  MEMPOOL_UNLOCK();
-  slice->next = NULL;
-  slice->prev = NULL;
-  // mempool_reserved_slice_s *tmp =
-  //     (void *)((uintptr_t)slice + (slice->offset.ahead &
-  //     MEMPOOL_SIZE_MASK));
-  // fprintf(stderr, "Allocated %lu bytes at: %u <- %p -> %u."
-  //                 "next: %u <- %p -> %u\n ",
-  //         size, slice->offset.behind, slice,
-  //         (uint32_t)(slice->offset.ahead & MEMPOOL_SIZE_MASK),
-  //         tmp->offset.behind, tmp,
-  //         (uint32_t)(tmp->offset.ahead & MEMPOOL_SIZE_MASK));
-  return MEMPOOL_SLICE2PTR(slice);
-alloc_indi:
-  MEMPOOL_ALLOC_SPECIAL(slice, size);
-  if (slice) {
-    slice->offset.ahead = size;
-    slice->offset.behind = MEMPOOL_INDI_MARKER;
-  }
-  return MEMPOOL_SLICE2PTR(slice);
-}
-
-/**
- * Frees the memory, releasing it back to the pool (or, sometimes, the
- * system).
- */
-static UNUSED_FUNC void mempool_free(void *ptr) {
-  if (!ptr)
-    return;
-  mempool_reserved_slice_s **pos, *slice = MEMPOOL_PTR2SLICE(ptr), *tmp;
-
-  if (slice->offset.behind == MEMPOOL_INDI_MARKER)
-    goto alloc_indi;
-  if ((slice->offset.ahead & MEMPOOL_USED_MARKER) != MEMPOOL_USED_MARKER)
-    goto error;
-
-  MEMPOOL_LOCK();
-  slice->offset.ahead &= MEMPOOL_SIZE_MASK;
-  /* merge slice with upper boundry */
-  while ((tmp = (mempool_reserved_slice_s *)(((uintptr_t)slice) +
-                                             slice->offset.ahead))
-             ->offset.ahead &&
-         (tmp->offset.ahead & MEMPOOL_USED_MARKER) == 0) {
-    /* extract merged slice from list */
-    if (tmp->next)
-      tmp->next->prev = tmp->prev;
-    if (tmp->prev)
-      tmp->prev->next = tmp->next;
-    else
-      mempool_reserved_pool.available = tmp->next;
-
-    tmp->next = NULL;
-    tmp->prev = NULL;
-    slice->offset.ahead += tmp->offset.ahead;
-  }
-  /* merge slice with lower boundry */
-  while (slice->offset.behind &&
-         ((tmp = (mempool_reserved_slice_s *)(((uintptr_t)slice) -
-                                              slice->offset.behind))
-              ->offset.ahead &
-          MEMPOOL_USED_MARKER) == 0) {
-    /* extract merged slice from list */
-    if (tmp->next)
-      tmp->next->prev = tmp->prev;
-    if (tmp->prev)
-      tmp->prev->next = tmp->next;
-    else
-      mempool_reserved_pool.available = tmp->next;
-
-    tmp->next = NULL;
-    tmp->prev = NULL;
-    tmp->offset.ahead += slice->offset.ahead;
-
-    slice = tmp;
-  }
-
-  /* return memory to system, if the block is no longer required. */
-  if (MEMPOOL_RETURN_MEM_TO_SYSTEM && mempool_reserved_pool.available &&
-      slice->offset.behind == 0 &&
-      ((mempool_reserved_slice_s *)(((uintptr_t)slice) + slice->offset.ahead))
-              ->offset.ahead == 0) {
-    MEMPOOL_UNLOCK();
-    // fprintf(
-    //     stderr, "DEALLOCATED BLOCK %p, size review %u == %lu %s\n", slice,
-    //     slice->offset.ahead,
-    //     MEMPOOL_BLOCK_SIZE - sizeof(struct mempool_reserved_slice_s_offset),
-    //     (slice->offset.ahead ==
-    //      MEMPOOL_BLOCK_SIZE - sizeof(struct mempool_reserved_slice_s_offset))
-    //         ? "passed."
-    //         : "FAILED.");
-    MEMPOOL_DEALLOC_SPECIAL(slice, MEMPOOL_BLOCK_SIZE);
-    return;
-  }
-
-  /* inform higher neighbor about any updates */
-  // fprintf(stderr, "slice: %p -> %u\n", slice, slice->offset.ahead);
-  ((mempool_reserved_slice_s *)(((uintptr_t)slice) + slice->offset.ahead))
-      ->offset.behind = slice->offset.ahead;
-
-  /* place slice in list */
-  uint8_t limit = MEMPOOL_ORDERING_LIMIT;
-  slice->next = NULL;
-  slice->prev = NULL;
-  pos = &mempool_reserved_pool.available;
-  while (limit && *pos && ((*pos)->offset.ahead < slice->offset.ahead)) {
-    slice->prev = *pos;
-    pos = &(*pos)->next;
-    --limit;
-  }
-  if (*pos) {
-    slice->next = *pos;
-    slice->next->prev = slice;
-    *pos = slice;
-  } else {
-    *pos = slice;
-  }
-
-  MEMPOOL_UNLOCK();
-  return;
-alloc_indi:
-  MEMPOOL_DEALLOC_SPECIAL(slice, slice->offset.ahead);
-  return;
-error:
-  MEMPOOL_UNLOCK();
-  if ((slice->offset.ahead & MEMPOOL_USED_MARKER) == 0)
-    fprintf(stderr, "mempool: memory being freed is already free.\n");
-  else
-    fprintf(stderr, "mempool: memory allocation data corrupted. possible "
-                    "buffer overflow?\n");
-  errno = EFAULT;
-  raise(SIGSEGV); /* support longjmp rescue */
-  exit(EFAULT);
-}
-/**
- * Behaves the same a the systems `realloc`, attempting to resize the memory
- * when possible. On error returns NULL (the old pointer data remains allocated
- * and valid) otherwise returns a new pointer (either equal to the old or after
- * deallocating the old one).
- */
-static UNUSED_FUNC void *mempool_realloc(void *ptr, size_t size) {
-  if (!size)
-    return NULL;
-  if (size & 15) {
-    size = (size & (~16)) + 16;
-  }
-  size += sizeof(struct mempool_reserved_slice_s_offset);
-
-  mempool_reserved_slice_s *tmp = NULL, *slice = MEMPOOL_PTR2SLICE(ptr);
-
-  if (slice->offset.behind == MEMPOOL_INDI_MARKER)
-    goto realloc_indi;
-  if ((slice->offset.ahead & MEMPOOL_USED_MARKER) != MEMPOOL_USED_MARKER)
-    goto error;
-
-  MEMPOOL_LOCK();
-
-  slice->offset.ahead &= MEMPOOL_SIZE_MASK;
-  /* merge slice with upper boundry */
-  while ((tmp = (mempool_reserved_slice_s *)(((uintptr_t)slice) +
-                                             slice->offset.ahead))
-             ->offset.ahead &&
-         (tmp->offset.ahead & MEMPOOL_USED_MARKER) == 0) {
-    /* extract merged slice from list */
-    if (tmp->next)
-      tmp->next->prev = tmp->prev;
-    if (tmp->prev)
-      tmp->prev->next = tmp->next;
-    else
-      mempool_reserved_pool.available = tmp->next;
-
-    tmp->next = NULL;
-    tmp->prev = NULL;
-    slice->offset.ahead += tmp->offset.ahead;
-  }
-
-  /* inform higher neighbor about any updates */
-  ((mempool_reserved_slice_s *)(((uintptr_t)slice) + slice->offset.ahead))
-      ->offset.behind = slice->offset.ahead;
-
-  if ((slice->offset.ahead) > size + sizeof(mempool_reserved_slice_s)) {
-    /* cut the slice in two */
-    tmp = (mempool_reserved_slice_s *)(((uintptr_t)slice) + size);
-    tmp->offset.behind = size;
-    tmp->offset.ahead = slice->offset.ahead - size;
-    slice->offset.ahead = size;
-    /* inform higher neighbor about any updates */
-    ((mempool_reserved_slice_s *)(((uintptr_t)tmp) + tmp->offset.ahead))
-        ->offset.behind = tmp->offset.ahead;
-    /* place the new slice in the available memory list */
-    tmp->next = NULL;
-    tmp->prev = NULL;
-    mempool_reserved_slice_s **pos = &mempool_reserved_pool.available;
-    uint8_t limit = MEMPOOL_ORDERING_LIMIT;
-    while (limit && *pos && ((*pos)->offset.ahead < tmp->offset.ahead)) {
-      tmp->prev = *pos;
-      pos = &(*pos)->next;
-      --limit;
-    }
-    if (*pos) {
-      tmp->next = *pos;
-      tmp->next->prev = tmp;
-      *pos = tmp;
-    } else {
-      *pos = tmp;
-    }
-
-    slice->offset.ahead |= MEMPOOL_USED_MARKER;
-    MEMPOOL_UNLOCK();
-    return ptr;
-  }
-  slice->offset.ahead |= MEMPOOL_USED_MARKER;
-  MEMPOOL_UNLOCK();
-
-  if ((slice->offset.ahead & MEMPOOL_SIZE_MASK) < size) {
-    void *new_mem =
-        mempool_malloc(size - sizeof(struct mempool_reserved_slice_s_offset));
-    if (!new_mem)
-      return NULL;
-    memcpy(new_mem, ptr, slice->offset.ahead & MEMPOOL_SIZE_MASK);
-    mempool_free(ptr);
-    ptr = new_mem;
-  }
-  return ptr;
-
-realloc_indi:
-  /* indi doesn't shrink */
-  if (slice->offset.ahead > size)
-    return ptr;
-  /* reallocate indi */
-  void *new_mem =
-      mempool_malloc(size - sizeof(struct mempool_reserved_slice_s_offset));
-  if (!new_mem)
-    return NULL;
-  memcpy(new_mem, ptr, slice->offset.ahead & MEMPOOL_SIZE_MASK);
-  mempool_free(ptr);
-  return new_mem;
-error:
-  errno = EFAULT;
-  raise(SIGSEGV); /* support longjmp rescue */
-  exit(EFAULT);
-}
-
-/* *****************************************************************************
-********************************************************************************
-TESTING
-********************************************************************************
-***************************************************************************** */
-
-#if defined(DEBUG) && DEBUG == 1
-
-#define MEMTEST_SLICE 32
-
-#include <time.h>
-#include <inttypes.h>
-static void mempool_stats(void) {
-  fprintf(stderr, "* Pool object: %lu bytes\n"
-                  "* Alignment: %lu \n"
-                  "* Minimal Allocation Size (including header): %lu\n"
-                  "* Minimal Allocation Space (no header): %lu\n"
-                  "* Header size: %lu\n",
-          sizeof(mempool_reserved_pool),
-          sizeof(struct mempool_reserved_slice_s_offset),
-          sizeof(mempool_reserved_slice_s),
-          sizeof(mempool_reserved_slice_s) -
-              sizeof(struct mempool_reserved_slice_s_offset),
-          sizeof(struct mempool_reserved_slice_s_offset));
-}
-
-static void mempool_speedtest(size_t memtest_repeats, void *(*mlk)(size_t),
-                              void (*fr)(void *),
-                              void *(*ralc)(void *, size_t)) {
-  void **pntrs = mlk(memtest_repeats * sizeof(*pntrs));
-  clock_t start, end, mlk_time, fr_time, zr_time;
-  mlk_time = 0;
-  fr_time = 0;
-  zr_time = 0;
-  struct timespec start_test, end_test;
-  clock_gettime(CLOCK_MONOTONIC, &start_test);
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i++) {
-    __asm__ volatile("" ::: "memory");
-  }
-  end = clock();
-  mlk_time = end - start;
-  fprintf(stderr, "* Doing nothing: %lu CPU cycles.\n", mlk_time);
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i++) {
-    // fprintf(stderr, "malloc %lu\n", i);
-    pntrs[i] = mlk(MEMTEST_SLICE);
-    *((uint8_t *)pntrs[i]) = 1;
-  }
-  end = clock();
-  mlk_time = end - start;
-  fprintf(stderr,
-          "* Allocating %lu consecutive blocks %d each: %lu CPU cycles.\n",
-          memtest_repeats, MEMTEST_SLICE, mlk_time);
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i += 2) {
-    fr(pntrs[i]);
-  }
-  end = clock();
-  fr_time = end - start;
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i += 2) {
-    pntrs[i] = mlk(MEMTEST_SLICE);
-  }
-  end = clock();
-  mlk_time = end - start;
-
-  fprintf(stderr,
-          "* Freeing %lu Fragmented (single space) blocks %d each: %lu CPU "
-          "cycles.\n",
-          memtest_repeats / 2, MEMTEST_SLICE, fr_time);
-
-  fprintf(stderr, "* Allocating %lu Fragmented (single space) blocks %d "
-                  "bytes each: %lu CPU "
-                  "cycles.\n",
-          memtest_repeats / 2, MEMTEST_SLICE, mlk_time);
-
-  mlk_time = 0;
-  fr_time = 0;
-
-  for (size_t xtimes = 0; xtimes < 100; xtimes++) {
-    start = clock();
-    for (size_t i = 0; i < memtest_repeats; i += 7) {
-      fr(pntrs[i]);
-    }
-    end = clock();
-    fr_time += end - start;
-
-    start = clock();
-    for (size_t i = 0; i < memtest_repeats; i += 7) {
-      pntrs[i] = mlk(MEMTEST_SLICE);
-    }
-    end = clock();
-    mlk_time += end - start;
-  }
-
-  fprintf(stderr,
-          "* 100X Freeing %lu Fragmented (7 spaces) blocks %d each: %lu CPU "
-          "cycles.\n",
-          memtest_repeats / 7, MEMTEST_SLICE, fr_time);
-
-  fprintf(stderr, "* 100X Allocating %lu Fragmented (7 spaces) blocks %d "
-                  "bytes each: %lu CPU "
-                  "cycles.\n",
-          memtest_repeats / 7, MEMTEST_SLICE, mlk_time);
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i++) {
-    memset(pntrs[i], 170, MEMTEST_SLICE);
-  }
-  end = clock();
-  zr_time = end - start;
-  fprintf(stderr, "* Set bits (0b10) for %lu consecutive blocks %dB "
-                  "each: %lu CPU cycles.\n",
-          memtest_repeats, MEMTEST_SLICE, zr_time);
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i++) {
-    fr(pntrs[i]);
-  }
-  end = clock();
-  fr_time = end - start;
-  fprintf(stderr, "* Freeing %lu consecutive blocks %d each: %lu CPU cycles.\n",
-          memtest_repeats, MEMTEST_SLICE, fr_time);
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i++) {
-    pntrs[i] = mlk(MEMTEST_SLICE);
-  }
-  end = clock();
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i += 2) {
-    fr(pntrs[i]);
-  }
-  end = clock();
-  mlk_time = end - start;
-  fprintf(stderr,
-          "* Freeing every other block %dB X %lu blocks: %lu CPU cycles.\n",
-          MEMTEST_SLICE, memtest_repeats >> 1, mlk_time);
-
-  start = clock();
-  for (size_t i = 1; i < memtest_repeats; i += 2) {
-    pntrs[i] = ralc(pntrs[i], MEMTEST_SLICE << 1);
-    if (pntrs[i] == NULL)
-      fprintf(stderr, "REALLOC RETURNED NULL - Memory leaked during test\n");
-  }
-  end = clock();
-  mlk_time = end - start;
-  fprintf(
-      stderr,
-      "* Reallocating every other block %dB X %lu blocks: %lu CPU cycles.\n",
-      MEMTEST_SLICE, memtest_repeats >> 1, mlk_time);
-
-  start = clock();
-  for (size_t i = 1; i < memtest_repeats; i += 2) {
-    fr(pntrs[i]);
-  }
-  end = clock();
-  mlk_time = end - start;
-  fprintf(stderr,
-          "* Freeing every other block %dB X %lu blocks: %lu CPU cycles.\n",
-          MEMTEST_SLICE, memtest_repeats >> 1, mlk_time);
-
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i++) {
-    pntrs[i] = mlk(MEMTEST_SLICE);
-  }
-  end = clock();
-  mlk_time = end - start;
-  fprintf(stderr,
-          "* Allocating %lu consecutive blocks %d each: %lu CPU cycles.\n",
-          memtest_repeats, MEMTEST_SLICE, mlk_time);
-  start = clock();
-  for (size_t i = 0; i < memtest_repeats; i++) {
-    fr(pntrs[i]);
-  }
-  end = clock();
-  fr_time = end - start;
-  fprintf(stderr, "* Freeing %lu consecutive blocks %d each: %lu CPU cycles.\n",
-          memtest_repeats, MEMTEST_SLICE, fr_time);
-  fprintf(stderr, "* Freeing pointer array %p.\n", (void *)pntrs);
-  fr(pntrs);
-
-  clock_gettime(CLOCK_MONOTONIC, &end_test);
-  uint64_t msec_for_test =
-      (end_test.tv_nsec < start_test.tv_nsec)
-          ? ((end_test.tv_sec -= 1), (start_test.tv_nsec - end_test.tv_nsec))
-          : (end_test.tv_nsec - start_test.tv_nsec);
-  uint64_t sec_for_test = end_test.tv_sec - start_test.tv_sec;
-
-  fprintf(stderr,
-          "Finished test in %" PRIu64 "m, %" PRIu64 "s %" PRIu64 " mili.sec.\n",
-          sec_for_test / 60, sec_for_test - (((sec_for_test) / 60) * 60),
-          msec_for_test / 1000000);
-}
-
-static UNUSED_FUNC void mempool_test(void) {
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, "mempool implementation details:\n");
-  mempool_stats();
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, "System memory test for ~2Mb\n");
-  mempool_speedtest((2 << 20) / MEMTEST_SLICE, malloc, free, realloc);
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, " mempool memory test for ~2Mb\n");
-  mempool_speedtest((2 << 20) / MEMTEST_SLICE, mempool_malloc, mempool_free,
-                    mempool_realloc);
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, "System memory test for ~4Mb\n");
-  mempool_speedtest((2 << 21) / MEMTEST_SLICE, malloc, free, realloc);
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, " mempool memory test for ~4Mb\n");
-  mempool_speedtest((2 << 21) / MEMTEST_SLICE, mempool_malloc, mempool_free,
-                    mempool_realloc);
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, "System memory test for ~8Mb\n");
-  mempool_speedtest((2 << 22) / MEMTEST_SLICE, malloc, free, realloc);
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, " mempool memory test for ~8Mb\n");
-  mempool_speedtest((2 << 22) / MEMTEST_SLICE, mempool_malloc, mempool_free,
-                    mempool_realloc);
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, "System memory test for ~16Mb\n");
-  mempool_speedtest((2 << 23) / MEMTEST_SLICE, malloc, free, realloc);
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, " mempool memory test for ~16Mb\n");
-  mempool_speedtest((2 << 23) / MEMTEST_SLICE, mempool_malloc, mempool_free,
-                    mempool_realloc);
-  fprintf(stderr, "*****************************\n");
-
-  fprintf(stderr, "*****************************\n");
-  fprintf(stderr, "Stressing the system\n");
-  fprintf(stderr, "*****************************\n");
-  size_t repeat = 1024 * 1024 * 16;
-  size_t unit = 16;
-  struct timespec start_test, end_test;
-  clock_t start, end;
-  fprintf(stderr, "Stress allocation/deallocation using "
-                  "1:5 fragmentation of ~134Mb:\n");
-  while (repeat >= 1024) {
-    fprintf(stderr, " * %lu X %lu bytes", repeat, unit);
-    clock_gettime(CLOCK_MONOTONIC, &start_test);
-    start = clock();
-    void **ptrs = mempool_malloc(repeat * sizeof(void *));
-    for (size_t i = 0; i < repeat; i++) {
-      ptrs[i] = mempool_malloc(unit);
-    }
-    for (size_t i = 0; i < repeat; i += 5) {
-      mempool_free(ptrs[i]);
-    }
-    for (size_t i = 1; i < repeat; i += 5) {
-      mempool_free(ptrs[i]);
-    }
-    for (size_t i = 2; i < repeat; i += 5) {
-      mempool_free(ptrs[i]);
-    }
-    for (size_t i = 3; i < repeat; i += 5) {
-      mempool_free(ptrs[i]);
-    }
-    for (size_t i = 4; i < repeat; i += 5) {
-      mempool_free(ptrs[i]);
-    }
-    for (size_t i = 0; i < repeat; i++) {
-      ptrs[i] = mempool_malloc(unit);
-    }
-    for (size_t i = 0; i < repeat; i++) {
-      mempool_free(ptrs[i]);
-    }
-    mempool_free(ptrs);
-    end = clock();
-    clock_gettime(CLOCK_MONOTONIC, &end_test);
-    uint64_t msec_for_test =
-        (end_test.tv_nsec < start_test.tv_nsec)
-            ? ((end_test.tv_sec -= 1), (start_test.tv_nsec - end_test.tv_nsec))
-            : (end_test.tv_nsec - start_test.tv_nsec);
-    uint64_t sec_for_test = end_test.tv_sec - start_test.tv_sec;
-
-    fprintf(stderr,
-            " %" PRIu64 "m, %" PRIu64 "s %" PRIu64 " mili.sec. ( %lu CPU)\n",
-            sec_for_test / 60, sec_for_test - (((sec_for_test) / 60) * 60),
-            msec_for_test / 1000000, end - start);
-
-    unit <<= 1;
-    repeat >>= 1;
-  }
-}
-
-#undef MEMTEST_SLICE
-
-#endif
-
-/* *****************************************************************************
-Cleanup
-*/
-#undef MEMPOOL_BLOCK_SIZE
-#undef MEMPOOL_ALLOC_SPECIAL
-#undef MEMPOOL_DEALLOC_SPECIAL
-#undef MEMPOOL_SIZE_MASK
-#undef MEMPOOL_USED_MARKER
-#undef MEMPOOL_INDI_MARKER
-#undef MEMPOOL_SLICE2PTR
-#undef MEMPOOL_PTR2SLICE
-#undef MEMPOOL_LOCK
-#undef MEMPOOL_UNLOCK
-#undef MEMPOOL_ORDERING_LIMIT
-#endif