iodine 0.7.15 → 0.7.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1996d0474dc00ad0614035f36b703154b594415278cd18624cec94c8149150e
-  data.tar.gz: 3060659e07df3fc734594584b407b5bf9156ae77fcdb8709f62a49d0f2f62296
+  metadata.gz: 4813b7d2deb5b0dede2e40d240e295f10cdcef94effb743eeb0293317e84fc3e
+  data.tar.gz: 4fb3632e530571ad598c50f42e3eca989aca0425c00df041d590ca26fdcc2b8e
 SHA512:
-  metadata.gz: 2ab1733a97c6617232022405bd25d4f0c46d4a99c6751b5a8467e48fa17efc0dc815dc47ca329c7ca955d135c56e8a06c69d3fd168ead0b3510712e909711468
-  data.tar.gz: 53be4c7971bca24fd484bfa4dd18d67a99ffba196a5908c76bf1a3001a957ef607c51ec8d90b3d4714d6297609bf4dde8077d24bd85eee081b875bf27faa5d8f
+  metadata.gz: d632268e49abf09a61e7eaa0d8905f9c4bef2f303784d4d3eca0fd9a6bc29952b28eb7c9709ab34d95324b0bdbdc866a98c0520d9df5cc560b3afba83f5e940f
+  data.tar.gz: 28c9fa08377cad5fba31cda50186598839abe336f85c882efea480c4bed467e1e10e0df5c18fe72ef48e97ed2b92c4bdf68264373169cfeeb82a82788ee6b966

data/.travis.yml

@@ -6,6 +6,7 @@ before_install:
   - gem install bundler -v 1.10.6
   - bundle install
 rvm:
+  - 2.6.0
   - 2.5.0
   - 2.4.0
   - 2.3.1

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.16
+
+**Security**: (`fio`) security fixes from the facil.io core library (updated to 0.7.0.beta6).
+
+**Update**: (`iodine`) better Redis support from CLI and environment (by setting the `IODINE_REDIS_URL` environment variable).
+
+**Optimization**: (`Iodine::Mustache`) optimized worst case scenario seeking by seeking Symbols before Strings, which improved seeking times.
+
 #### Change log v.0.7.15
 
 **Fix**: (`fio`) fixed a minor memory leak in cluster mode, caused by the root process not freeing the hash map used for child process subscription monitoring (only effected hot restarts).

data/README.md

@@ -7,9 +7,13 @@
 
 [![Logo](https://github.com/boazsegev/iodine/raw/master/logo.png)](https://github.com/boazsegev/iodine)
 
-Iodine is a fast concurrent web server for real-time Ruby applications, with native support for:
+I believe that network concerns should be separated from application concerns - application developers really shouldn't need to worry about the transport layer.
 
-* Websockets and EventSource (SSE);
+And I know that these network concerns are more than just about the web server. Which is why iodine is more than just an HTTP server.
+
+Iodine is a fast concurrent web server for real-time Ruby applications, but it's also so much more. Iodine includes native support for:
+
+* WebSockets and EventSource (SSE);
 * Pub/Sub (with optional Redis Pub/Sub scaling);
 * Static file service (with automatic `gzip` support for pre-compressed versions);
 * HTTP/1.1 keep-alive and pipelining;
@@ -25,9 +29,9 @@ Iodine is an **evented** framework with a simple API that ports much of the [C f
 
 * Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections on Linux)!
 
-* Iodine is ideal for **Linux/Unix** based systems (i.e. macOS, Ubuntu, FreeBSD etc'), which are ideal for evented IO (while Windows and Solaris are better at IO *completion* events, which are totally different).
+* Iodine is ideal for **Linux/Unix** based systems (i.e. macOS, Ubuntu, FreeBSD etc'), which are ideal for evented IO (while Windows and Solaris are better at IO *completion* events, which are very different).
 
-Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but Rack requires Ruby 2.2.2, and so iodine matches this requirement.
+Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but CI tests start at Ruby 2.2.2.
 
 ## Iodine - a fast & powerful HTTP + Websockets server with native Pub/Sub
 
@@ -63,13 +67,11 @@ bundler exec iodine -p $PORT -t 16 -w 1
 
 ### Heap Fragmentation Protection
 
-Iodine includes a network oriented custom memory allocator, with very high performance.
-
-This allows the heap to be divided, naturally, into long-living objects (allocated normally) and short living objects (allocated using the iodine allocator).
+Iodine includes a fast, network oriented, custom memory allocator, optimizing away some of the work usually placed on the Ruby Garbage Collector (GC).
 
-This approach helps to minimize heap fragmentation for long running processes.
+This approach helps to minimize heap fragmentation for long running processes, by grouping many short-lived objects into a common memory space.
 
-It's still recommended to consider [jemalloc](http://jemalloc.net) or other allocators to mitigate the heap fragmentation that would be caused by Ruby's internal memory management.
+It's still recommended to consider [jemalloc](http://jemalloc.net) or other allocators that also help mitigate heap fragmentation issues.
 
 ### Static file serving support
 
@@ -301,9 +303,9 @@ bundler exec iodine -p $PORT -v  2>&1
 
 ### Built-in support for Sequel and ActiveRecord
 
-It's a well known fact that Database connections require special attention when using `fork`-ing servers (multi-process servers) such as Puma, Passenger and iodine.
+It's a well known fact that [Database connections require special attention when using `fork`-ing servers (multi-process servers)](https://devcenter.heroku.com/articles/concurrency-and-database-connections#multi-process-servers) such as Puma, Passenger (Pro) and iodine.
 
-However, it's also true that these issues go unnoticed by many developers, since application developers are (rightfully) focused on the application rather than the infrastructure.
+However, it's also true that [these issues go unnoticed by many developers](https://stackoverflow.com/a/45570999/4025095), since application developers are (rightfully) focused on the application rather than the infrastructure.
 
 With iodine, there's no need to worry.
 

data/examples/redis.ru

@@ -1,14 +1,19 @@
 # This example implements a Redis pub/sub engine according to the Iodine::PubSub::Engine specifications.
 #
-# Run this applications on two ports, in two terminals to see the synchronization is action
+# Run this applications on two ports, in two terminals to see the synchronization is action:
 #
-#      REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3000 redis.ru
-#      REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3030 redis.ru
+#      IODINE_REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3000 redis.ru
+#      IODINE_REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3030 redis.ru
+#
+# Or:
+#
+#      iodine -t 1 -p 3000 redis.ru -redis redis://localhost:6379/0
+#      iodine -t 1 -p 3030 redis.ru -redis redis://localhost:6379/0
 #
 require 'iodine'
 # initialize the Redis engine for each Iodine process.
-if ENV["REDIS_URL"]
-  Iodine::PubSub.default = Iodine::PubSub::Redis.new(ENV["REDIS_URL"], ping: 10)
+if Iodine::DEFAULT_HTTP_ARGS[:redis_]
+  puts "* Redis support automatically detected."
 else
   puts "* No Redis, it's okay, pub/sub will support the process cluster."
 end
@@ -47,7 +52,7 @@ class WS_RedisPubSub
     client.publish "chat", "#{@name} entered the chat."
   end
   # send a message, letting the client know the server is suggunt down.
-  def on_shutdown client 
+  def on_shutdown client
     client.write "Server shutting down. Goodbye."
   end
   # perform the echo

data/exe/iodine

@@ -1,5 +1,10 @@
 #!/usr/bin/env ruby
-require 'rack'
+begin
+  require 'rack'
+rescue LoadError
+  puts "ERROR: the iodine command-line utility requires the gem: rack."
+  exit(0)
+end
 require 'iodine'
 
 module Iodine

data/ext/iodine/fio.c

@@ -5,9 +5,13 @@ License: MIT
 Feel free to copy, use and enjoy according to the license provided.
 ***************************************************************************** */
 
+#include <fio.h>
+
 #define FIO_INCLUDE_STR
-#define FIO_INCLUDE_LINKED_LIST
+#include <fio.h>
 
+#define FIO_FORCE_MALLOC_TMP 1
+#define FIO_INCLUDE_LINKED_LIST
 #include <fio.h>
 
 #include <ctype.h>
@@ -2109,9 +2113,11 @@ static void deferred_on_ready(void *arg, void *arg2) {
 }
 
 static void deferred_on_data(void *uuid, void *arg2) {
-  if (!uuid_data(uuid).protocol || fio_is_closed((intptr_t)uuid)) {
+  if (fio_is_closed((intptr_t)uuid)) {
     return;
   }
+  if (!uuid_data(uuid).protocol)
+    goto no_protocol;
   fio_protocol_s *pr = protocol_try_lock(fio_uuid2fd(uuid), FIO_PR_LOCK_TASK);
   if (!pr) {
     if (errno == EBADF) {
@@ -2126,6 +2132,7 @@ static void deferred_on_data(void *uuid, void *arg2) {
     fio_poll_add_read(fio_uuid2fd((intptr_t)uuid));
   }
   return;
+
 postpone:
   if (arg2) {
     /* the event is being forced, so force rescheduling */
@@ -2135,6 +2142,11 @@ postpone:
     fio_poll_add_read(fio_uuid2fd((intptr_t)uuid));
   }
   return;
+
+no_protocol:
+  /* a missing protocol might still want to invoke the RW hook flush */
+  deferred_on_ready(uuid, arg2);
+  return;
 }
 
 static void deferred_ping(void *arg, void *arg2) {
@@ -2537,8 +2549,9 @@ static int fio_sock_write_buffer(int fd, fio_packet_s *packet) {
   if (written > 0) {
     packet->length -= written;
     packet->offset += written;
-    if (!packet->length)
+    if (!packet->length) {
       fio_sock_packet_rotate_unsafe(fd);
+    }
   }
   return written;
 }
@@ -2552,10 +2565,11 @@ static int fio_sock_write_from_fd(int fd, fio_packet_s *packet) {
     packet->offset += sent;
     packet->length -= sent;
   retry:
-    asked = (packet->length < BUFFER_FILE_READ_SIZE)
-                ? pread(packet->data.fd, buff, packet->length, packet->offset)
-                : pread(packet->data.fd, buff, BUFFER_FILE_READ_SIZE,
-                        packet->offset);
+    asked = pread(packet->data.fd, buff,
+                  ((packet->length < BUFFER_FILE_READ_SIZE)
+                       ? packet->length
+                       : BUFFER_FILE_READ_SIZE),
+                  packet->offset);
     if (asked <= 0)
       goto read_error;
     sent = fd_data(fd).rw_hooks->write(fd2uuid(fd), fd_data(fd).rw_udata, buff,
@@ -2784,7 +2798,7 @@ void fio_close(intptr_t uuid) {
     errno = EBADF;
     return;
   }
-  if (uuid_data(uuid).packet) {
+  if (uuid_data(uuid).packet || uuid_data(uuid).sock_lock) {
     uuid_data(uuid).close = 1;
     fio_poll_add_write(fio_uuid2fd(uuid));
     return;
@@ -2914,7 +2928,7 @@ size_t fio_flush_all(void) {
   if (!fio_data)
     return 0;
   size_t count = 0;
-  for (uintptr_t i = 0; i < fio_data->max_protocol_fd; ++i) {
+  for (uintptr_t i = 0; i <= fio_data->max_protocol_fd; ++i) {
     if ((fd_data(i).open || fd_data(i).packet) && fio_flush(fd2uuid(i)) > 0)
       ++count;
   }
@@ -2958,6 +2972,41 @@ const fio_rw_hook_s FIO_DEFAULT_RW_HOOKS = {
     .cleanup = fio_hooks_default_cleanup,
 };
 
+/**
+ * Replaces an existing read/write hook with another from within a read/write
+ * hook callback.
+ *
+ * Does NOT call any cleanup callbacks.
+ *
+ * Returns -1 on error, 0 on success.
+ */
+int fio_rw_hook_replace_unsafe(intptr_t uuid, fio_rw_hook_s *rw_hooks,
+                               void *udata) {
+  int replaced = -1;
+  uint8_t was_locked;
+  intptr_t fd = fio_uuid2fd(uuid);
+  if (!rw_hooks->read)
+    rw_hooks->read = fio_hooks_default_read;
+  if (!rw_hooks->write)
+    rw_hooks->write = fio_hooks_default_write;
+  if (!rw_hooks->flush)
+    rw_hooks->flush = fio_hooks_default_flush;
+  if (!rw_hooks->before_close)
+    rw_hooks->before_close = fio_hooks_default_before_close;
+  if (!rw_hooks->cleanup)
+    rw_hooks->cleanup = fio_hooks_default_cleanup;
+  /* protect against some fulishness... but not all of it. */
+  was_locked = fio_trylock(&fd_data(fd).sock_lock);
+  if (fd2uuid(fd) == uuid) {
+    fd_data(fd).rw_hooks = rw_hooks;
+    fd_data(fd).rw_udata = udata;
+    replaced = 0;
+  }
+  if (!was_locked)
+    fio_unlock(&fd_data(fd).sock_lock);
+  return replaced;
+}
+
 /** Sets a socket hook state (a pointer to the struct). */
 int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
   if (fio_is_closed(uuid))
@@ -3060,10 +3109,18 @@ static int fio_attach__internal(void *uuid_, void *protocol_) {
   touchfd(fio_uuid2fd(uuid));
   fio_unlock(&uuid_data(uuid).protocol_lock);
   if (old_pr) {
+    /* protocol replacement */
     fio_defer_push_task(deferred_on_close, (void *)uuid, old_pr);
+    if (!protocol) {
+      /* hijacking */
+      fio_poll_remove_fd(fio_uuid2fd(uuid));
+      fio_poll_add_write(fio_uuid2fd(uuid));
+    }
   } else if (protocol) {
+    /* adding a new uuid to the reactor */
     fio_poll_add(fio_uuid2fd(uuid));
   }
+  fio_max_fd_min(fio_uuid2fd(uuid));
   return 0;
 
 invalid_uuid:
@@ -3313,23 +3370,6 @@ Initialize the library
 
 static void fio_pubsub_on_fork(void);
 
-static void fio_mem_destroy(void);
-static void __attribute__((destructor)) fio_lib_destroy(void) {
-  uint8_t add_eol = fio_is_master();
-  fio_data->active = 0;
-  fio_state_callback_force(FIO_CALL_AT_EXIT);
-  fio_state_callback_clear_all();
-  fio_defer_perform();
-  fio_poll_close();
-  fio_timer_clear_all();
-  fio_free(fio_data);
-  /* memory library destruction must be last */
-  fio_mem_destroy();
-  FIO_LOG_DEBUG("(%d) facil.io resources released, exit complete.", getpid());
-  if (add_eol)
-    fprintf(stderr, "\n"); /* add EOL to logs (logging adds EOL before text */
-}
-
 /* Called within a child process after it starts. */
 static void fio_on_fork(void) {
   fio_data->lock = FIO_LOCK_INIT;
@@ -3356,6 +3396,25 @@ static void fio_on_fork(void) {
   fio_data->is_worker = 1;
 }
 
+static void fio_mem_destroy(void);
+static void __attribute__((destructor)) fio_lib_destroy(void) {
+  uint8_t add_eol = fio_is_master();
+  fio_data->active = 0;
+  fio_on_fork();
+  fio_defer_perform();
+  fio_state_callback_force(FIO_CALL_AT_EXIT);
+  fio_state_callback_clear_all();
+  fio_defer_perform();
+  fio_poll_close();
+  fio_timer_clear_all();
+  fio_free(fio_data);
+  /* memory library destruction must be last */
+  fio_mem_destroy();
+  FIO_LOG_DEBUG("(%d) facil.io resources released, exit complete.", getpid());
+  if (add_eol)
+    fprintf(stderr, "\n"); /* add EOL to logs (logging adds EOL before text */
+}
+
 static void fio_mem_init(void);
 static void fio_cluster_init(void);
 static void fio_pubsub_initialize(void);
@@ -4548,11 +4607,7 @@ static int fio_channel_cmp(channel_s *ch1, channel_s *ch2) {
          !memcmp(ch1->name, ch2->name, ch1->name_len);
 }
 /* pub/sub channels and core data sets have a long life, so avoid fio_malloc */
-#if !FIO_FORCE_MALLOC
-#define FIO_FORCE_MALLOC 1
-#define FIO_FORCE_MALLOC_IS_TMP 1
-#endif
-
+#define FIO_FORCE_MALLOC_TMP 1
 #define FIO_SET_NAME fio_ch_set
 #define FIO_SET_OBJ_TYPE channel_s *
 #define FIO_SET_OBJ_COMPARE(o1, o2) fio_channel_cmp((o1), (o2))
@@ -4560,19 +4615,17 @@ static int fio_channel_cmp(channel_s *ch1, channel_s *ch2) {
 #define FIO_SET_OBJ_COPY(dest, src) ((dest) = fio_channel_copy((src)))
 #include <fio.h>
 
+#define FIO_FORCE_MALLOC_TMP 1
 #define FIO_ARY_NAME fio_meta_ary
 #define FIO_ARY_TYPE fio_msg_metadata_fn
 #include <fio.h>
 
+#define FIO_FORCE_MALLOC_TMP 1
 #define FIO_SET_NAME fio_engine_set
 #define FIO_SET_OBJ_TYPE fio_pubsub_engine_s *
 #define FIO_SET_OBJ_COMPARE(k1, k2) ((k1) == (k2))
 #include <fio.h>
 
-#if FIO_FORCE_MALLOC_IS_TMP
-#undef FIO_FORCE_MALLOC
-#endif
-
 struct fio_collection_s {
   fio_ch_set_s channels;
   fio_lock_i lock;
@@ -6823,9 +6876,8 @@ void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length) {
     return NULL;
   new_size = ((new_size >> 4) + (!!(new_size & 15)));
   copy_length = ((copy_length >> 4) + (!!(copy_length & 15)));
-  // memcpy(new_mem, ptr, (copy_length > new_size ? new_size : copy_length) <<
-  // 4);
-  fio_memcpy(new_mem, ptr, (copy_length > new_size ? new_size : copy_length));
+  fio_memcpy(new_mem, ptr, copy_length > new_size ? new_size : copy_length);
+
   block_slice_free(ptr);
   return new_mem;
 zero_size:

data/ext/iodine/fio.h

@@ -36,6 +36,7 @@ Feel free to copy, use and enjoy according to the license provided.
  * Cluster / Pub/Sub Middleware and Extensions ("Engines")
  *
  * Atomic Operations and Spin Locking Helper Functions
+ * Simple Constant Time Operations
  * Byte Swapping and Network Order
  *
  * Converting Numbers to Strings (and back)
@@ -109,7 +110,7 @@ Version and helper macros
 #define FIO_VERSION_MAJOR 0
 #define FIO_VERSION_MINOR 7
 #define FIO_VERSION_PATCH 0
-#define FIO_VERSION_BETA 4
+#define FIO_VERSION_BETA 6
 
 /* Automatically convert version data to a string constant - ignore these two */
 #define FIO_MACRO2STR_STEP2(macro) #macro
@@ -323,16 +324,16 @@ Memory pool / custom allocator for short lived objects
  * Allocates memory using a per-CPU core block memory pool.
  * Memory is zeroed out.
  *
- * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (12,288 bytes when using 32Kb
- * blocks) will be redirected to `mmap`, as if `fio_mmap` was called.
+ * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (16Kb when using 32Kb blocks)
+ * will be redirected to `mmap`, as if `fio_mmap` was called.
  */
 void *FIO_ALIGN_NEW fio_malloc(size_t size);
 
 /**
  * same as calling `fio_malloc(size_per_unit * unit_count)`;
  *
- * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (12,288 bytes when using 32Kb
- * blocks) will be redirected to `mmap`, as if `fio_mmap` was called.
+ * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (16Kb when using 32Kb blocks)
+ * will be redirected to `mmap`, as if `fio_mmap` was called.
  */
 void *FIO_ALIGN_NEW fio_calloc(size_t size_per_unit, size_t unit_count);
 
@@ -372,22 +373,6 @@ void fio_malloc_after_fork(void);
 
 #undef FIO_ALIGN
 
-#if FIO_FORCE_MALLOC
-#define FIO_MALLOC(size) calloc((size), 1)
-#define FIO_CALLOC(size, units) calloc((size), (units))
-#define FIO_REALLOC(ptr, new_length, existing_data_length)                     \
-  realloc((ptr), (new_length))
-#define FIO_FREE free
-
-#else
-#define FIO_MALLOC(size) fio_malloc((size))
-#define FIO_CALLOC(size, units) fio_calloc((size), (units))
-#define FIO_REALLOC(ptr, new_length, existing_data_length)                     \
-  fio_realloc2((ptr), (new_length), (existing_data_length))
-#define FIO_FREE fio_free
-
-#endif
-
 /* *****************************************************************************
 
 
@@ -1128,12 +1113,12 @@ inline FIO_FUNC ssize_t fio_write(const intptr_t uuid, const void *buffer,
                                   const size_t length) {
   if (!length || !buffer)
     return 0;
-  void *cpy = FIO_MALLOC(length);
+  void *cpy = fio_malloc(length);
   if (!cpy)
     return -1;
   memcpy(cpy, buffer, length);
   return fio_write2(uuid, .data.buffer = cpy, .length = length,
-                    .after.dealloc = FIO_FREE);
+                    .after.dealloc = fio_free);
 }
 
 /**
@@ -1322,6 +1307,23 @@ typedef struct fio_rw_hook_s {
 /** Sets a socket hook state (a pointer to the struct). */
 int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata);
 
+/**
+ * Replaces an existing read/write hook with another from within a read/write
+ * hook callback.
+ *
+ * Does NOT call any cleanup callbacks.
+ *
+ * Replaces existing udata. Call with the existing udata to keep it.
+ *
+ * Returns -1 on error, 0 on success.
+ *
+ * Note: this function is marked as unsafe, since it should only be called from
+ *       within an existing read/write hook callback. Otherwise, data corruption
+ *       might occur.
+ */
+int fio_rw_hook_replace_unsafe(intptr_t uuid, fio_rw_hook_s *rw_hooks,
+                               void *udata);
+
 /** The default Read/Write hooks used for system Read/Write (udata == NULL). */
 extern const fio_rw_hook_s FIO_DEFAULT_RW_HOOKS;
 
@@ -1983,6 +1985,56 @@ FIO_FUNC inline void fio_throttle_thread(size_t nano_sec);
 
 
 
+                         Simple Constant Time Operations
+                         ( boolean true / false and if )
+
+
+
+
+
+
+
+
+
+
+
+***************************************************************************** */
+
+/** Returns 1 if the expression is true (input isn't zero). */
+FIO_FUNC inline uintptr_t fio_ct_true(uintptr_t cond) {
+  // promise that the highest bit is set if any bits are set, than shift.
+  return ((cond | (0 - cond)) >> ((sizeof(cond) << 3) - 1));
+}
+
+/** Returns 1 if the expression is false (input is zero). */
+FIO_FUNC inline uintptr_t fio_ct_false(uintptr_t cond) {
+  // fio_ct_true returns only one bit, XOR will inverse that bit.
+  return fio_ct_true(cond) ^ 1;
+}
+
+/** Returns `a` if `cond` is boolean and true, returns b otherwise. */
+FIO_FUNC inline uintptr_t fio_ct_if(uint8_t cond, uintptr_t a, uintptr_t b) {
+  // b^(a^b) cancels b out. 0-1 => sets all bits.
+  return (b ^ ((0 - (cond & 1)) & (a ^ b)));
+}
+
+/** Returns `a` if `cond` isn't zero (uses fio_ct_true), returns b otherwise. */
+FIO_FUNC inline uintptr_t fio_ct_if2(uintptr_t cond, uintptr_t a, uintptr_t b) {
+  // b^(a^b) cancels b out. 0-1 => sets all bits.
+  return fio_ct_if(fio_ct_true(cond), a, b);
+}
+
+/* *****************************************************************************
+
+
+
+
+
+
+
+
+
+
                          Byte Swapping and Network Order
                        (Big Endian v.s Little Endian etc')
 
@@ -2768,6 +2820,42 @@ FIO_FUNC inline int fio_trylock_dbg(fio_lock_i *lock, const char *file,
 
 
 
+                    Memory allocation macros for helper types
+
+
+
+
+
+
+***************************************************************************** */
+
+#undef FIO_MALLOC
+#undef FIO_CALLOC
+#undef FIO_REALLOC
+#undef FIO_FREE
+
+#if FIO_FORCE_MALLOC || FIO_FORCE_MALLOC_TMP
+#define FIO_MALLOC(size) calloc((size), 1)
+#define FIO_CALLOC(size, units) calloc((size), (units))
+#define FIO_REALLOC(ptr, new_length, existing_data_length)                     \
+  realloc((ptr), (new_length))
+#define FIO_FREE free
+
+#else
+#define FIO_MALLOC(size) fio_malloc((size))
+#define FIO_CALLOC(size, units) fio_calloc((size), (units))
+#define FIO_REALLOC(ptr, new_length, existing_data_length)                     \
+  fio_realloc2((ptr), (new_length), (existing_data_length))
+#define FIO_FREE fio_free
+#endif /* FIO_FORCE_MALLOC || FIO_FORCE_MALLOC_TMP */
+
+/* *****************************************************************************
+
+
+
+
+
+
                            Linked List Helpers
 
         exposes internally used inline helpers for linked lists
@@ -2960,7 +3048,7 @@ FIO_FUNC inline void *fio_ls_remove(fio_ls_s *node) {
   const void *ret = node->obj;
   node->next->prev = node->prev;
   node->prev->next = node->next;
-  free(node);
+  FIO_FREE(node);
   return (void *)ret;
 }
 
@@ -2969,11 +3057,8 @@ FIO_FUNC inline fio_ls_s *fio_ls_push(fio_ls_s *pos, const void *obj) {
   if (!pos)
     return NULL;
   /* prepare item */
-  fio_ls_s *item = (fio_ls_s *)malloc(sizeof(*item));
-  if (!item) {
-    perror("ERROR: simple list couldn't allocate memory");
-    exit(errno);
-  }
+  fio_ls_s *item = (fio_ls_s *)FIO_MALLOC(sizeof(*item));
+  FIO_ASSERT_ALLOC(item);
   *item = (fio_ls_s){.prev = pos->prev, .next = pos, .obj = obj};
   /* inject item */
   pos->prev->next = item;
@@ -3105,15 +3190,20 @@ typedef struct {
                .dealloc = FIO_FREE})
 
 /**
- * This macro allows the container to be initialized with existing data, as long
- * as it's memory was allocated using `fio_malloc`.
- *
- * The `capacity` value should exclude the NUL character (if exists).
+ * This macro allows the container to be initialized with existing static data,
+ * that shouldn't be freed.
  */
 #define FIO_STR_INIT_STATIC(buffer)                                            \
   ((fio_str_s){                                                                \
       .data = (char *)(buffer), .len = strlen((buffer)), .dealloc = NULL})
 
+/**
+ * This macro allows the container to be initialized with existing static data,
+ * that shouldn't be freed.
+ */
+#define FIO_STR_INIT_STATIC2(buffer, length)                                   \
+  ((fio_str_s){.data = (char *)(buffer), .len = (length), .dealloc = NULL})
+
 /**
  * Allocates a new fio_str_s object on the heap and initializes it.
  *
@@ -3629,10 +3719,6 @@ String Implementation - Memory management
  * directly to `mmap` (due to their size, usually over 12KB).
  */
 #define ROUND_UP_CAPA2WORDS(num) (((num) + 1) | (sizeof(long double) - 1))
-// Smaller might be:
-//   ((((num) + 1) & (sizeof(long double) - 1))
-//        ? (((num) + 1) | (sizeof(long double) - 1))
-//        : (num))
 
 /**
  * Requires the String to have at least `needed` capacity. Returns the current
@@ -5908,5 +5994,6 @@ restart:
 #undef FIO_NAME_FROM_MACRO_STEP3
 #undef FIO_NAME_FREE
 #undef FIO_SET_NAME
+#undef FIO_FORCE_MALLOC_TMP
 
 #endif