iodine 0.7.10 → 0.7.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd4ea42a7f008886bcadee4c829499686a1fbceeb2738daf56e4155063d9054c
-  data.tar.gz: aeb66d448ad9cd09e55f7f15c79bcb1b3e8f0a41f3e2adfc9e2c894c20d7c80f
+  metadata.gz: d1140536cb23442b4b484d0c193cfd8cd207775e557dda8e132dbe52607a82f3
+  data.tar.gz: 3a7d54ecdb80550a348984f52c553afb8e98c514a027bd61d26736332a4e9fce
 SHA512:
-  metadata.gz: ecdde8977f2b48089f370356f3bbd272054df193f9be220ac28ad8491c59f749a1c21e1506bb45c9f2532e9bf072b9e7bf365c92ccb4b3a651b52bacbdfb21ad
-  data.tar.gz: 5268a0318e3484a0a703fa68e52f057c6cab513066243ff37e052c58669d8babe5c53650082349bb9b2610f80afd0f5e551f530a3e6d662ad49dfa4609f3d6b1
+  metadata.gz: ef3f67bfb2bd6c3ceed9772b54644861718bcb8a1af7d1660c747020dfb3ced1cf7121ea03bc980d531f691904e8619f9bb1f790b0065d905760f27dfc800bd1
+  data.tar.gz: 31325c6c16d8d9fe19043fb223d66ade09774a49a466dfe2f80b64f00fbc068169bffb39f37a3f336415dcf8acb5de222a97e46d2f53064b24c373ba8504ed1d

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.11
+
+**Fix**: (`fio`) Deletes Unix sockets once done listening. Fixes an issue where the files would remain intact.
+
+**Optimization**: (`fio`) significant memory allocation optimizations. The facil.io allocator (included with iodine) helps to protect against heap fragmentation and improves speed for concurrent memory allocations when forking / multi-threading.
+
 #### Change log v.0.7.10
 
 **Fix**: (pub/sub) fixed connection lock for pub/sub tasks. Now pub/sub Ruby tasks will lock the connection, protecting the user's code against concurrent access to the connection's data.

data/README.md

@@ -18,6 +18,7 @@ Iodine is a fast concurrent web server for real-time Ruby applications, with nat
 * Client connectivity (attach client sockets to make them evented);
 * Custom protocol authoring;
 * Optimized Logging to `stderr`.
+* [Sequel](https://github.com/jeremyevans/sequel) and ActiveRecord forking protection.
 * and more!
 
 Iodine is an **evented** framework with a simple API that ports much of the [C facil.io framework](https://github.com/boazsegev/facil.io) to Ruby. This means that:
@@ -265,7 +266,7 @@ To hot-restart iodine, send the `SIGUSR1` signal to the root process.
 The following code will hot-restart iodine every 4 hours when iodine is running in cluster mode:
 
 ```ruby
-Iodine.run_every(2 * 60 * 60 * 1000) do
+Iodine.run_every(4 * 60 * 60 * 1000) do
   Process.kill("SIGUSR1", Process.pid) unless Iodine.worker?
 end
 ```
@@ -306,7 +307,7 @@ However, it's also true that these issues go unnoticed by many developers, since
 
 With iodine, there's no need to worry.
 
-Iodine provides built-in `fork` handling for both ActiveRecord and Sequel, in order to protect against these possible errors.
+Iodine provides built-in `fork` handling for both ActiveRecord and [Sequel](https://github.com/jeremyevans/sequel), in order to protect against these possible errors.
 
 ### TCP/IP (raw) sockets
 

data/ext/iodine/fio.c

@@ -77,27 +77,6 @@ Feel free to copy, use and enjoy according to the license provided.
 #define __thread _Thread_value
 #endif
 
-/* *****************************************************************************
-Patch for OSX version < 10.12 from https://stackoverflow.com/a/9781275/4025095
-***************************************************************************** */
-#if defined(__MACH__) && !defined(CLOCK_REALTIME)
-#include <sys/time.h>
-#define CLOCK_REALTIME 0
-#define clock_gettime patch_clock_gettime
-// clock_gettime is not implemented on older versions of OS X (< 10.12).
-// If implemented, CLOCK_REALTIME will have already been defined.
-static inline int patch_clock_gettime(int clk_id, struct timespec *t) {
-  struct timeval now;
-  int rv = gettimeofday(&now, NULL);
-  if (rv)
-    return rv;
-  t->tv_sec = now.tv_sec;
-  t->tv_nsec = now.tv_usec * 1000;
-  return 0;
-  (void)clk_id;
-}
-#endif
-
 /* *****************************************************************************
 Event deferring (declarations)
 ***************************************************************************** */
@@ -4027,6 +4006,13 @@ static void fio_listen_cleanup_task(void *pr_) {
     pr->on_finish(pr->uuid, pr->udata);
   }
   fio_force_close(pr->uuid);
+  if (pr->addr &&
+      (!pr->port || *pr->port == 0 ||
+       (pr->port[0] == '0' && pr->port[1] == 0)) &&
+      fio_is_master()) {
+    /* delete Unix sockets */
+    unlink(pr->addr);
+  }
   free(pr_);
 }
 
@@ -5981,6 +5967,39 @@ Section Start Marker
 
 
 
+***************************************************************************** */
+
+/* *****************************************************************************
+Allocator default settings
+***************************************************************************** */
+
+/* doun't change these */
+#undef FIO_MEMORY_BLOCK_SLICES
+#undef FIO_MEMORY_BLOCK_HEADER_SIZE
+#undef FIO_MEMORY_BLOCK_START_POS
+#undef FIO_MEMORY_MAX_SLICES_PER_BLOCK
+#undef FIO_MEMORY_BLOCK_MASK
+
+/* The number of blocks pre-allocated each system call, 256 ==8Mb */
+#ifndef FIO_MEMORY_BLOCKS_PER_ALLOCATION
+#define FIO_MEMORY_BLOCKS_PER_ALLOCATION 256
+#endif
+
+#define FIO_MEMORY_BLOCK_MASK (FIO_MEMORY_BLOCK_SIZE - 1) /* 0b0...1... */
+
+#define FIO_MEMORY_BLOCK_SLICES (FIO_MEMORY_BLOCK_SIZE >> 4) /* 16B slices */
+
+/* must be divisable by 16 bytes, bigger than min(sizeof(block_s), 16) */
+#define FIO_MEMORY_BLOCK_HEADER_SIZE 32
+
+/* allocation counter position (start) */
+#define FIO_MEMORY_BLOCK_START_POS (FIO_MEMORY_BLOCK_HEADER_SIZE >> 4)
+
+#define FIO_MEMORY_MAX_SLICES_PER_BLOCK                                        \
+  (FIO_MEMORY_BLOCK_SLICES - FIO_MEMORY_BLOCK_START_POS)
+
+/* *****************************************************************************
+FIO_FORCE_MALLOC handler
 ***************************************************************************** */
 
 #if FIO_FORCE_MALLOC
@@ -6129,9 +6148,13 @@ static inline void *sys_alloc(size_t len, uint8_t is_indi) {
     }
     munmap((void *)((uintptr_t)result + len), FIO_MEMORY_BLOCK_SIZE - offset);
   }
-  next_alloc =
-      (void *)((uintptr_t)result + FIO_MEMORY_BLOCK_SIZE +
-               (is_indi * ((uintptr_t)1 << 30))); /* add 1TB for realloc */
+  if (is_indi ==
+      0) /* advance by a block's allocation size for next allocation */
+    next_alloc =
+        (void *)((uintptr_t)result +
+                 (FIO_MEMORY_BLOCK_SIZE * (FIO_MEMORY_BLOCKS_PER_ALLOCATION)));
+  else /* add 1TB for realloc */
+    next_alloc = (void *)((uintptr_t)result + (is_indi * ((uintptr_t)1 << 30)));
   return result;
 }
 
@@ -6140,14 +6163,14 @@ static inline void sys_free(void *mem, size_t len) { munmap(mem, len); }
 
 static void *sys_realloc(void *mem, size_t prev_len, size_t new_len) {
   if (new_len > prev_len) {
-#if defined(__linux__) && defined(MREMAP_MAYMOVE)
-    void *result = mremap(mem, prev_len, new_len, MREMAP_MAYMOVE);
-    if (result == MAP_FAILED)
-      return NULL;
-#else
-    void *result =
-        mmap((void *)((uintptr_t)mem + prev_len), new_len - prev_len,
-             PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    void *result;
+#if defined(__linux__)
+    result = mremap(mem, prev_len, new_len, 0);
+    if (result != MAP_FAILED)
+      return result;
+#endif
+    result = mmap((void *)((uintptr_t)mem + prev_len), new_len - prev_len,
+                  PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (result == (void *)((uintptr_t)mem + prev_len)) {
       result = mem;
     } else {
@@ -6161,7 +6184,6 @@ static void *sys_realloc(void *mem, size_t prev_len, size_t new_len) {
       // memcpy(result, mem, prev_len);
       munmap(mem, prev_len); /* free original memory */
     }
-#endif
     return result;
   }
   if (new_len + 4096 < prev_len) /* more than a single dangling page */
@@ -6180,12 +6202,21 @@ Data Types
 ***************************************************************************** */
 
 /* The basic block header. Starts a 32Kib memory block */
-typedef struct block_s {
-  uint16_t ref; /* reference count (per memory page) */
-  uint16_t pos; /* position into the block */
-  uint16_t max; /* available memory count */
-  uint16_t pad; /* memory padding */
-} block_s;
+typedef struct block_s block_s;
+
+struct block_s {
+  block_s *parent;   /* REQUIRED, root == point to self */
+  uint16_t ref;      /* reference count (per memory page) */
+  uint16_t pos;      /* position into the block */
+  uint16_t max;      /* available memory count */
+  uint16_t root_ref; /* root reference memory padding */
+};
+
+typedef struct block_node_s block_node_s;
+struct block_node_s {
+  block_s dont_touch; /* prevent block internal data from being corrupted */
+  fio_ls_embd_s node; /* next block */
+};
 
 /* a per-CPU core "arena" for memory allocations  */
 typedef struct {
@@ -6195,14 +6226,14 @@ typedef struct {
 
 /* The memory allocators persistent state */
 static struct {
-  size_t active_size; /* active array size */
-  block_s *available; /* free list for memory blocks */
-  intptr_t count;     /* free list counter */
-  size_t cores;       /* the number of detected CPU cores*/
-  fio_lock_i lock;    /* a global lock */
+  fio_ls_embd_s available; /* free list for memory blocks */
+  // intptr_t count;          /* free list counter */
+  size_t cores;    /* the number of detected CPU cores*/
+  fio_lock_i lock; /* a global lock */
 } memory = {
     .cores = 1,
     .lock = FIO_LOCK_INIT,
+    .available = FIO_LS_INIT(memory.available),
 };
 
 /* The per-CPU arena array. */
@@ -6211,6 +6242,31 @@ static arena_s *arenas;
 /* The per-CPU arena array. */
 static long double on_malloc_zero;
 
+#if DEBUG
+/* The per-CPU arena array. */
+static size_t fio_mem_block_count_max;
+/* The per-CPU arena array. */
+static size_t fio_mem_block_count;
+#define FIO_MEMORY_ON_BLOCK_ALLOC()                                            \
+  do {                                                                         \
+    fio_atomic_add(&fio_mem_block_count, 1);                                   \
+    if (fio_mem_block_count > fio_mem_block_count_max)                         \
+      fio_mem_block_count_max = fio_mem_block_count;                           \
+  } while (0)
+#define FIO_MEMORY_ON_BLOCK_FREE()                                             \
+  do {                                                                         \
+    fio_atomic_sub(&fio_mem_block_count, 1);                                   \
+  } while (0)
+#define FIO_MEMORY_PRINT_BLOCK_STAT()                                          \
+  FIO_LOG_INFO(                                                                \
+      "(fio) Total memory blocks allocated before cleanup %zu\n"               \
+      "       Maximum memory blocks allocated at a single time %zu\n",         \
+      fio_mem_block_count, fio_mem_block_count_max)
+#else
+#define FIO_MEMORY_ON_BLOCK_ALLOC()
+#define FIO_MEMORY_ON_BLOCK_FREE()
+#define FIO_MEMORY_PRINT_BLOCK_STAT()
+#endif
 /* *****************************************************************************
 Per-CPU Arena management
 ***************************************************************************** */
@@ -6254,24 +6310,28 @@ void fio_malloc_after_fork(void) {
 }
 
 /* *****************************************************************************
-Block management
+Block management / allocation
 ***************************************************************************** */
 
-// static inline block_s **block_find(void *mem_) {
-//   const uintptr_t mem = (uintptr_t)mem_;
-//   block_s *blk = memory.active;
-// }
-
-/* intializes the block header for an available block of memory. */
-static inline block_s *block_init(void *blk_) {
-  block_s *blk = blk_;
+static inline void block_init_root(block_s *blk, block_s *parent) {
   *blk = (block_s){
+      .parent = parent,
       .ref = 1,
-      .pos = (2 + (sizeof(block_s) >> 4)),
-      .max = (FIO_MEMORY_BLOCK_SLICES - 1) -
-             (sizeof(block_s) >> 4), /* count available units of 16 bytes */
+      .pos = FIO_MEMORY_BLOCK_START_POS,
+      .root_ref = 1,
   };
-  return blk;
+}
+
+/* intializes the block header for an available block of memory. */
+static inline void block_init(block_s *blk) {
+  /* initialization shouldn't effect `parent` or `root_ref`*/
+  blk->ref = 1;
+  blk->pos = FIO_MEMORY_BLOCK_START_POS;
+  /* zero out linked list memory (everything else is already zero) */
+  ((block_node_s *)blk)->node.next = NULL;
+  ((block_node_s *)blk)->node.prev = NULL;
+  /* bump parent reference count */
+  fio_atomic_add(&blk->parent->root_ref, 1);
 }
 
 /* intializes the block header for an available block of memory. */
@@ -6279,46 +6339,63 @@ static inline void block_free(block_s *blk) {
   if (fio_atomic_sub(&blk->ref, 1))
     return;
 
-  if (fio_atomic_add(&memory.count, 1) >
-      (intptr_t)(FIO_MEM_MAX_BLOCKS_PER_CORE * memory.cores)) {
-    /* return memory to the system */
-    fio_atomic_sub(&memory.count, 1);
-    sys_free(blk, FIO_MEMORY_BLOCK_SIZE);
+  memset(blk + 1, 0, (FIO_MEMORY_BLOCK_SIZE - sizeof(*blk)));
+  fio_lock(&memory.lock);
+  fio_ls_embd_push(&memory.available, &((block_node_s *)blk)->node);
+
+  blk = blk->parent;
+
+  if (fio_atomic_sub(&blk->root_ref, 1)) {
+    fio_unlock(&memory.lock);
     return;
   }
-  memset(blk, 0, FIO_MEMORY_BLOCK_SIZE);
-  fio_lock(&memory.lock);
-  ((block_s **)blk)[0] = memory.available;
-  memory.available = (block_s *)blk;
+  // fio_unlock(&memory.lock);
+  // return;
+
+  /* remove all of the root block's children (slices) from the memory pool */
+  for (size_t i = 0; i < FIO_MEMORY_BLOCKS_PER_ALLOCATION; ++i) {
+    block_node_s *pos =
+        (block_node_s *)((uintptr_t)blk + (i * FIO_MEMORY_BLOCK_SIZE));
+    fio_ls_embd_remove(&pos->node);
+  }
+
   fio_unlock(&memory.lock);
+  sys_free(blk, FIO_MEMORY_BLOCK_SIZE * FIO_MEMORY_BLOCKS_PER_ALLOCATION);
+  FIO_LOG_DEBUG("memory allocator returned %p to the system", (void *)blk);
+  FIO_MEMORY_ON_BLOCK_FREE();
 }
 
 /* intializes the block header for an available block of memory. */
 static inline block_s *block_new(void) {
   block_s *blk = NULL;
 
-  if (memory.available) {
-    fio_lock(&memory.lock);
-    blk = memory.available;
-    if (blk) {
-      memory.available = ((block_s **)blk)[0];
-    }
-    fio_unlock(&memory.lock);
-  }
+  fio_lock(&memory.lock);
+  blk = (block_s *)fio_ls_embd_pop(&memory.available);
   if (blk) {
+    blk = (block_s *)FIO_LS_EMBD_OBJ(block_node_s, node, blk);
     FIO_ASSERT(((uintptr_t)blk & FIO_MEMORY_BLOCK_MASK) == 0,
                "Memory allocator error! double `fio_free`?\n");
-    fio_atomic_sub(&memory.count, 1);
-    ((block_s **)blk)[0] = NULL;
-    ((block_s **)blk)[1] = NULL;
-    return block_init(blk);
+    block_init(blk); /* must be performed within lock */
+    fio_unlock(&memory.lock);
+    return blk;
   }
   /* collect memory from the system */
-  blk = sys_alloc(FIO_MEMORY_BLOCK_SIZE, 0);
+  blk = sys_alloc(FIO_MEMORY_BLOCK_SIZE * FIO_MEMORY_BLOCKS_PER_ALLOCATION, 0);
   if (!blk)
     return NULL;
-  return block_init(blk);
-  ;
+  FIO_LOG_DEBUG("memory allocator allocated %p from the system", (void *)blk);
+  FIO_MEMORY_ON_BLOCK_ALLOC();
+  block_init_root(blk, blk);
+  /* the extra memory goes into the memory pool. initialize + linke-list. */
+  block_node_s *tmp = (block_node_s *)blk;
+  for (int i = 1; i < FIO_MEMORY_BLOCKS_PER_ALLOCATION; ++i) {
+    tmp = (block_node_s *)((uintptr_t)tmp + FIO_MEMORY_BLOCK_SIZE);
+    block_init_root((block_s *)tmp, blk);
+    fio_ls_embd_push(&memory.available, &tmp->node);
+  }
+  fio_unlock(&memory.lock);
+  /* return the root block (which isn't in the memory pool). */
+  return blk;
 }
 
 /* allocates memory from within a block - called within an arena's lock */
@@ -6328,7 +6405,7 @@ static inline void *block_slice(uint16_t units) {
     /* arena is empty */
     blk = block_new();
     arena_last_used->block = blk;
-  } else if (blk->pos + units > blk->max) {
+  } else if (blk->pos + units > FIO_MEMORY_MAX_SLICES_PER_BLOCK) {
     /* not enough memory in the block - rotate */
     block_free(blk);
     blk = block_new();
@@ -6343,7 +6420,7 @@ static inline void *block_slice(uint16_t units) {
   const void *mem = (void *)((uintptr_t)blk + ((uintptr_t)blk->pos << 4));
   fio_atomic_add(&blk->ref, 1);
   blk->pos += units;
-  if (blk->pos >= blk->max) {
+  if (blk->pos >= FIO_MEMORY_MAX_SLICES_PER_BLOCK) {
     /* ... the block was fully utilized, clear arena */
     block_free(blk);
     arena_last_used->block = NULL;
@@ -6397,6 +6474,34 @@ error:
 Allocator Initialization (initialize arenas and allocate a block for each CPU)
 ***************************************************************************** */
 
+#if DEBUG
+void fio_memory_dump_missing(void) {
+  fprintf(stderr, "\n ==== Attempting Memory Dump (will crash) ====\n");
+  if (fio_ls_embd_any(&memory.available))
+    return;
+  block_node_s *smallest =
+      FIO_LS_EMBD_OBJ(block_node_s, node, memory.available.next);
+  FIO_LS_EMBD_FOR(&memory.available, node) {
+    block_node_s *tmp = FIO_LS_EMBD_OBJ(block_node_s, node, node);
+    if (smallest > tmp)
+      smallest = tmp;
+  }
+
+  for (size_t i = 0;
+       i < FIO_MEMORY_BLOCK_SIZE * FIO_MEMORY_BLOCKS_PER_ALLOCATION; ++i) {
+    if ((((uintptr_t)smallest + i) & FIO_MEMORY_BLOCK_MASK) == 0) {
+      i += 32;
+      fprintf(stderr, "---block jump---\n");
+      continue;
+    }
+    if (((char *)smallest)[i])
+      fprintf(stderr, "%c", ((char *)smallest)[i]);
+  }
+}
+#else
+#define fio_memory_dump_missing()
+#endif
+
 static void fio_mem_init(void) {
   if (arenas)
     return;
@@ -6410,17 +6515,9 @@ static void fio_mem_init(void) {
   if (cpu_count <= 0)
     cpu_count = 8;
   memory.cores = cpu_count;
-  memory.count = 0 - cpu_count;
   arenas = big_alloc(sizeof(*arenas) * cpu_count);
   FIO_ASSERT_ALLOC(arenas);
-  size_t pre_pool = cpu_count > 32 ? 32 : cpu_count;
-  for (size_t i = 0; i < pre_pool; ++i) {
-    void *block = sys_alloc(FIO_MEMORY_BLOCK_SIZE, 0);
-    if (block) {
-      block_init(block);
-      block_free(block);
-    }
-  }
+  block_free(block_new());
   pthread_atfork(NULL, NULL, fio_malloc_after_fork);
 }
 
@@ -6428,20 +6525,25 @@ static void fio_mem_destroy(void) {
   if (!arenas)
     return;
 
+  FIO_MEMORY_PRINT_BLOCK_STAT();
+
   for (size_t i = 0; i < memory.cores; ++i) {
     if (arenas[i].block)
       block_free(arenas[i].block);
     arenas[i].block = NULL;
   }
-  while (memory.available) {
-    block_s *b = memory.available;
-    memory.available = ((block_s **)b)[0];
-    sys_free(b, FIO_MEMORY_BLOCK_SIZE);
+  if (fio_ls_embd_any(&memory.available)) {
+    FIO_LOG_WARNING("facil.io detected memory traces remaining after cleanup"
+                    " - memory leak?");
+    FIO_MEMORY_PRINT_BLOCK_STAT();
+    size_t count = 0;
+    FIO_LS_EMBD_FOR(&memory.available, node) { ++count; }
+    FIO_LOG_DEBUG("Memory pool size: %zu (%zu blocks per allocation).", count,
+                  (size_t)FIO_MEMORY_BLOCKS_PER_ALLOCATION);
   }
   big_free(arenas);
   arenas = NULL;
 }
-
 /* *****************************************************************************
 Memory allocation / deacclocation API
 ***************************************************************************** */
@@ -6491,8 +6593,9 @@ void fio_free(void *ptr) {
  * This variation is slightly faster as it might copy less data
  */
 void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length) {
-  if (!ptr || ptr == (void *)&on_malloc_zero)
+  if (!ptr || ptr == (void *)&on_malloc_zero) {
     return fio_malloc(new_size);
+  }
   if (!new_size) {
     goto zero_size;
   }
@@ -6514,7 +6617,7 @@ void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length) {
   return new_mem;
 zero_size:
   fio_free(ptr);
-  return malloc(0);
+  return fio_malloc(0);
 }
 
 void *fio_realloc(void *ptr, size_t new_size) {
@@ -8314,13 +8417,13 @@ void fio_malloc_test(void) {
         "block.\n",
         count,
         (size_t)((FIO_MEMORY_BLOCK_SLICES - 2) - (sizeof(block_s) >> 4) - 1));
-    intptr_t old_memory_pool_count = memory.count;
+    fio_ls_embd_s old_memory_list = memory.available;
     fio_free(mem);
-    FIO_ASSERT(memory.available,
+    FIO_ASSERT(fio_ls_embd_any(&memory.available),
                "memory pool empty (memory block wasn't freed)!\n");
-    FIO_ASSERT(old_memory_pool_count + 1 == memory.count,
-               "memory.count == %ld , was %ld (memory block counting error)!\n",
-               (long)memory.count, (long)old_memory_pool_count);
+    FIO_ASSERT(old_memory_list.next != memory.available.next ||
+                   memory.available.prev != old_memory_list.prev,
+               "memory pool not updated after block being freed!\n");
   }
   /* rotate block again */
   b = arena_last_used->block;
@@ -9990,7 +10093,4 @@ void fio_test(void) {
   (void)fio_poll;
 }
 
-#undef FIO_ASSERT
-#else
-#define fio_test()
-#endif
+#endif /* DEBUG */

data/ext/iodine/fio.h

@@ -227,6 +227,27 @@ Version and helper macros
 #include <sys/socket.h>
 #endif
 
+/* *****************************************************************************
+Patch for OSX version < 10.12 from https://stackoverflow.com/a/9781275/4025095
+***************************************************************************** */
+#if defined(__MACH__) && !defined(CLOCK_REALTIME)
+#include <sys/time.h>
+#define CLOCK_REALTIME 0
+#define clock_gettime patch_clock_gettime
+// clock_gettime is not implemented on older versions of OS X (< 10.12).
+// If implemented, CLOCK_REALTIME will have already been defined.
+static inline int patch_clock_gettime(int clk_id, struct timespec *t) {
+  struct timeval now;
+  int rv = gettimeofday(&now, NULL);
+  if (rv)
+    return rv;
+  t->tv_sec = now.tv_sec;
+  t->tv_nsec = now.tv_usec * 1000;
+  return 0;
+  (void)clk_id;
+}
+#endif
+
 /* *****************************************************************************
 C++ extern start
 ***************************************************************************** */
@@ -392,9 +413,9 @@ extern int FIO_LOG_LEVEL;
 #define FIO_LOG_PRINT(level, ...)                                              \
   do {                                                                         \
     if (level <= FIO_LOG_LEVEL) {                                              \
-      char tmp___log[512];                                                     \
-      int len___log = snprintf(tmp___log, 500, __VA_ARGS__);                   \
-      if (len___log <= 0 || len___log > 500) {                                 \
+      char tmp___log[1024];                                                    \
+      int len___log = snprintf(tmp___log, 1000, __VA_ARGS__);                  \
+      if (len___log <= 0 || len___log > 1000) {                                \
         fwrite("ERROR: log line output too long (can't write).", 46, 1,        \
                stderr);                                                        \
         break;                                                                 \
@@ -2558,36 +2579,30 @@ C++ extern end
  * When using tcmalloc or jemalloc, it's possible to define `FIO_FORCE_MALLOC`
  * to prevent the facil.io allocator from compiling (`-DFIO_FORCE_MALLOC`).
  */
-#define H_FIO_MEM_H /* prevent fiobj conflicts */
 
-/** Allocator default settings. */
-
-/** The logarithmic value for a memory block, 15 == 32Kb, 16 == 64Kb, etc' */
 #ifndef FIO_MEMORY_BLOCK_SIZE_LOG
+/**
+ * The logarithmic value for a memory block, 15 == 32Kb, 16 == 64Kb, etc'
+ *
+ * By default, a block of memory is 32Kb silce from an 8Mb allocation.
+ *
+ * A value of 16 will make this a 64Kb silce from a 16Mb allocation.
+ */
 #define FIO_MEMORY_BLOCK_SIZE_LOG (15)
 #endif
 
-/* dounb't change these - they are derived from FIO_MEMORY_BLOCK_SIZE_LOG */
 #undef FIO_MEMORY_BLOCK_SIZE
-#undef FIO_MEMORY_BLOCK_MASK
-#undef FIO_MEMORY_BLOCK_SLICES
+/** The resulting memoru block size, depends on `FIO_MEMORY_BLOCK_SIZE_LOG` */
 #define FIO_MEMORY_BLOCK_SIZE ((uintptr_t)1 << FIO_MEMORY_BLOCK_SIZE_LOG)
-#define FIO_MEMORY_BLOCK_MASK (FIO_MEMORY_BLOCK_SIZE - 1)    /* 0b0...1... */
-#define FIO_MEMORY_BLOCK_SLICES (FIO_MEMORY_BLOCK_SIZE >> 4) /* 16B slices */
-
-#ifndef FIO_MEMORY_BLOCK_ALLOC_LIMIT
-/* defaults to 37.5% of the block, after which `mmap` is used instead */
-#define FIO_MEMORY_BLOCK_ALLOC_LIMIT                                           \
-  ((FIO_MEMORY_BLOCK_SIZE >> 2) + (FIO_MEMORY_BLOCK_SIZE >> 3))
-#endif
 
-#ifndef FIO_MEM_MAX_BLOCKS_PER_CORE
 /**
- * The maximum number of available memory blocks that will be pooled before
- * memory is returned to the system.
+ * The maximum allocation size, after which `mmap` will be called instead of the
+ * facil.io allocator.
+ *
+ * Defaults to 50% of the block (16Kb), after which `mmap` is used instead
  */
-#define FIO_MEM_MAX_BLOCKS_PER_CORE                                            \
-  (1 << (22 - FIO_MEMORY_BLOCK_SIZE_LOG)) /* 22 == 4Mb per CPU core (1<<22) */
+#ifndef FIO_MEMORY_BLOCK_ALLOC_LIMIT
+#define FIO_MEMORY_BLOCK_ALLOC_LIMIT (FIO_MEMORY_BLOCK_SIZE >> 1)
 #endif
 
 /* *****************************************************************************
@@ -3565,48 +3580,51 @@ String Implementation - Memory management
  * since it uses 16 byte alignment right up until allocations are routed
  * directly to `mmap` (due to their size, usually over 12KB).
  */
-#define ROUND_UP_CAPA2WORDS(num)                                               \
-  ((((num) + 1) & (sizeof(long double) - 1))                                   \
-       ? (((num) + 1) | (sizeof(long double) - 1))                             \
-       : (num))
+#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
  * state of the String.
  */
 FIO_FUNC fio_str_info_s fio_str_capa_assert(fio_str_s *s, size_t needed) {
-  if (!s)
-    return (fio_str_info_s){.capa = 0};
+  if (!s || s->frozen) {
+    return fio_str_info(s);
+  }
   char *tmp;
   if (s->small || !s->data) {
+    if (needed < FIO_STR_SMALL_CAPA) {
+      return (fio_str_info_s){.capa = (FIO_STR_SMALL_CAPA - 1),
+                              .len = (size_t)(s->small >> 1),
+                              .data = FIO_STR_SMALL_DATA(s)};
+    }
     goto is_small;
   }
-  if (needed > s->capa) {
-    needed = ROUND_UP_CAPA2WORDS(needed);
-    if (s->dealloc == FIO_FREE) {
-      tmp = (char *)FIO_REALLOC(s->data, needed + 1, s->len);
-      FIO_ASSERT_ALLOC(tmp);
-    } else {
-      tmp = (char *)FIO_MALLOC(needed + 1);
-      FIO_ASSERT_ALLOC(tmp);
-      memcpy(tmp, s->data, s->len);
-      if (s->dealloc)
-        s->dealloc(s->data);
-      s->dealloc = FIO_FREE;
-    }
-    s->capa = needed;
-    s->data = tmp;
-    s->data[needed] = 0;
+  if (needed < s->capa) {
+    return (fio_str_info_s){.capa = s->capa, .len = s->len, .data = s->data};
+  }
+  needed = ROUND_UP_CAPA2WORDS(needed);
+  if (s->dealloc == FIO_FREE) {
+    tmp = (char *)FIO_REALLOC(s->data, needed + 1, s->len + 1);
+    FIO_ASSERT_ALLOC(tmp);
+  } else {
+    tmp = (char *)FIO_MALLOC(needed + 1);
+    FIO_ASSERT_ALLOC(tmp);
+    memcpy(tmp, s->data, s->len + 1);
+    if (s->dealloc)
+      s->dealloc(s->data);
+    s->dealloc = FIO_FREE;
   }
-  return (fio_str_info_s){
-      .capa = (s->frozen ? 0 : s->capa), .len = s->len, .data = s->data};
+  s->capa = needed;
+  s->data = tmp;
+  s->data[needed] = 0;
+  return (fio_str_info_s){.capa = s->capa, .len = s->len, .data = s->data};
 
 is_small:
   /* small string (string data is within the container) */
-  if (needed < FIO_STR_SMALL_CAPA) {
-    return (fio_str_info_s){.capa = (s->frozen ? 0 : (FIO_STR_SMALL_CAPA - 1)),
-                            .len = (size_t)(s->small >> 1),
-                            .data = FIO_STR_SMALL_DATA(s)};
-  }
   needed = ROUND_UP_CAPA2WORDS(needed);
   tmp = (char *)FIO_MALLOC(needed + 1);
   FIO_ASSERT_ALLOC(tmp);
@@ -3634,8 +3652,7 @@ is_small:
       .data = tmp,
   };
 #endif
-  return (fio_str_info_s){
-      .capa = (s->frozen ? 0 : needed), .len = existing_len, .data = s->data};
+  return (fio_str_info_s){.capa = needed, .len = existing_len, .data = s->data};
 }
 
 /** Performs a best attempt at minimizing memory consumption. */

data/ext/iodine/fiobj_data.c

@@ -287,7 +287,7 @@ static inline int swallow_ch(uint8_t **buffer, register uint8_t *const limit,
       break;
     }
   }
-#if !defined(__x86_64__)
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
 finish:
 #endif
   while (*buffer < limit) {

data/ext/iodine/http.c

@@ -18,27 +18,6 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <sys/types.h>
 #include <unistd.h>
 
-/* *****************************************************************************
-Patch for OSX version < 10.12 from https://stackoverflow.com/a/9781275/4025095
-***************************************************************************** */
-#if defined(__MACH__) && !defined(CLOCK_REALTIME)
-#include <sys/time.h>
-#define CLOCK_REALTIME 0
-#define clock_gettime patch_clock_gettime
-// clock_gettime is not implemented on older versions of OS X (< 10.12).
-// If implemented, CLOCK_REALTIME will have already been defined.
-static inline int patch_clock_gettime(int clk_id, struct timespec *t) {
-  struct timeval now;
-  int rv = gettimeofday(&now, NULL);
-  if (rv)
-    return rv;
-  t->tv_sec = now.tv_sec;
-  t->tv_nsec = now.tv_usec * 1000;
-  return 0;
-  (void)clk_id;
-}
-#endif
-
 /* *****************************************************************************
 SSL/TLS patch
 ***************************************************************************** */
@@ -2065,7 +2044,7 @@ void http_write_log(http_s *h) {
 
   struct timespec start, end;
   clock_gettime(CLOCK_REALTIME, &end);
-  start = fio_last_tick();
+  start = h->received_at;
 
   {
     // TODO Guess IP address from headers (forwarded) where possible
@@ -2097,9 +2076,9 @@ void http_write_log(http_s *h) {
   fiobj_str_join(l, h->version);
   fiobj_str_write(l, "\" ", 2);
   if (bytes_sent > 0) {
-    fiobj_str_join(l, fiobj_num_tmp(h->status));
+    fiobj_str_write_i(l, h->status);
     fiobj_str_write(l, " ", 1);
-    fiobj_str_join(l, fiobj_num_tmp(bytes_sent));
+    fiobj_str_write_i(l, bytes_sent);
     fiobj_str_write(l, "b ", 2);
   } else {
     fiobj_str_join(l, fiobj_num_tmp(h->status));
@@ -2108,7 +2087,7 @@ void http_write_log(http_s *h) {
 
   bytes_sent = ((end.tv_sec - start.tv_sec) * 1000) +
                ((end.tv_nsec - start.tv_nsec) / 1000000);
-  fiobj_str_join(l, fiobj_num_tmp(bytes_sent));
+  fiobj_str_write_i(l, bytes_sent);
   fiobj_str_write(l, "ms\r\n", 4);
 
   buff = fiobj_obj2cstr(l);
@@ -2693,12 +2672,9 @@ parse_path:
 Lookup Tables / functions
 ***************************************************************************** */
 
-static FIOBJ tmp_cpy_obj(FIOBJ o) { return fiobj_dup(o); }
-
 #define FIO_SET_NAME fio_mime_set
 #define FIO_SET_OBJ_TYPE FIOBJ
 #define FIO_SET_OBJ_COMPARE(o1, o2) (1)
-#define FIO_SET_OBJ_COPY(dest, o) (dest) = tmp_cpy_obj((o))
 #define FIO_SET_OBJ_DESTROY(o) fiobj_free((o))
 
 #include <fio.h>

data/ext/iodine/http.h

@@ -42,6 +42,22 @@ Compile Time Settings
 #define HTTP_MAX_HEADER_LENGTH 8192
 #endif
 
+#ifndef FIO_HTTP_EXACT_LOGGING
+/**
+ * By default, facil.io logs the HTTP request cycle using a fuzzy starting point
+ * (a close enough timestamp).
+ *
+ * The fuzzy timestamp includes delays that aren't related to the HTTP request,
+ * sometimes including time that was spent waiting on the client. On the other
+ * hand, `FIO_HTTP_EXACT_LOGGING` excludes time that the client might have been
+ * waiting for facil.io to read data from the network.
+ *
+ * Due to the preference to err on the side of causion, fuzzy time-stamping is
+ * the default.
+ */
+#define FIO_HTTP_EXACT_LOGGING 0
+#endif
+
 /** the `http_listen settings, see details in the struct definition. */
 typedef struct http_settings_s http_settings_s;
 

data/ext/iodine/http1.c

@@ -85,8 +85,9 @@ static int write_header(FIOBJ o, void *w_) {
   fio_str_info_s str = fiobj_obj2cstr(o);
   if (!str.data)
     return 0;
-  fiobj_str_capa_assert(w->dest,
-                        fiobj_obj2cstr(w->dest).len + name.len + str.len + 5);
+  // fiobj_str_capa_assert(w->dest,
+  //                       fiobj_obj2cstr(w->dest).len + name.len + str.len +
+  //                       5);
   fiobj_str_write(w->dest, name.data, name.len);
   fiobj_str_write(w->dest, ":", 1);
   fiobj_str_write(w->dest, str.data, str.len);
@@ -105,7 +106,7 @@ static FIOBJ headers2str(http_s *h, uintptr_t padding) {
   struct header_writer_s w;
   {
     const uintptr_t header_length_guess =
-        fiobj_hash_count(h->private_data.out_headers) * 48;
+        fiobj_hash_count(h->private_data.out_headers) * 64;
     w.dest = fiobj_str_buf(header_length_guess + padding);
   }
   http1pr_s *p = handle2pr(h);
@@ -602,6 +603,13 @@ static int http1_on_http_version(http1_parser_s *parser, char *version,
                                  size_t len) {
   http1_pr2handle(parser2http(parser)).version = fiobj_str_new(version, len);
   parser2http(parser)->header_size += len;
+/* start counting - occurs on the first line of both requests and responses */
+#if FIO_HTTP_EXACT_LOGGING
+  clock_gettime(CLOCK_REALTIME,
+                &http1_pr2handle(parser2http(parser)).received_at);
+#else
+  http1_pr2handle(parser2http(parser)).received_at = fio_last_tick();
+#endif
   return 0;
 }
 /** called when a header is parsed. */

data/ext/iodine/http1_parser.c

@@ -29,8 +29,8 @@ Seeking for characters in a string
  *
  * On newer systems, `memchr` should be faster.
  */
-static inline int seek2ch(uint8_t **buffer, register uint8_t *const limit,
-                          const uint8_t c) {
+static int seek2ch(uint8_t **buffer, register uint8_t *const limit,
+                   const uint8_t c) {
   if (**buffer == c) {
 #if HTTP1_PARSER_CONVERT_EOL2NUL
     **buffer = 0;
@@ -72,7 +72,7 @@ static inline int seek2ch(uint8_t **buffer, register uint8_t *const limit,
       break;
     }
   }
-#if !defined(__x86_64__)
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
 finish:
 #endif
   while (*buffer < limit) {

data/ext/iodine/http1_parser.h

@@ -34,6 +34,11 @@ to maintain and that could be used for an HTTP/1.x client as well.
 #define HTTP1_PARSER_CONVERT_EOL2NUL 0
 #endif
 
+#ifndef FIO_MEMCHAR
+/** Prefer a custom memchr implementation. Usualy memchr is better. */
+#define FIO_MEMCHAR 0
+#endif
+
 #if HTTP_HEADERS_LOWERCASE
 
 #define HEADER_NAME_IS_EQ(var_name, const_name, len)                           \

data/ext/iodine/http_internal.c

@@ -132,11 +132,11 @@ FIOBJ HTTP_HVALUE_GZIP;
 FIOBJ HTTP_HVALUE_KEEP_ALIVE;
 FIOBJ HTTP_HVALUE_MAX_AGE;
 FIOBJ HTTP_HVALUE_NO_CACHE;
+FIOBJ HTTP_HVALUE_SSE_MIME;
 FIOBJ HTTP_HVALUE_WEBSOCKET;
 FIOBJ HTTP_HVALUE_WS_SEC_VERSION;
 FIOBJ HTTP_HVALUE_WS_UPGRADE;
 FIOBJ HTTP_HVALUE_WS_VERSION;
-FIOBJ HTTP_HVALUE_SSE_MIME;
 
 static void http_lib_init(void *ignr_);
 static void http_lib_cleanup(void *ignr_);
@@ -163,7 +163,6 @@ static void http_lib_cleanup(void *ignr_) {
   HTTPLIB_RESET(HTTP_HEADER_DATE);
   HTTPLIB_RESET(HTTP_HEADER_ETAG);
   HTTPLIB_RESET(HTTP_HEADER_HOST);
-  HTTPLIB_RESET(HTTP_HVALUE_SSE_MIME);
   HTTPLIB_RESET(HTTP_HEADER_LAST_MODIFIED);
   HTTPLIB_RESET(HTTP_HEADER_ORIGIN);
   HTTPLIB_RESET(HTTP_HEADER_SET_COOKIE);
@@ -177,6 +176,7 @@ static void http_lib_cleanup(void *ignr_) {
   HTTPLIB_RESET(HTTP_HVALUE_KEEP_ALIVE);
   HTTPLIB_RESET(HTTP_HVALUE_MAX_AGE);
   HTTPLIB_RESET(HTTP_HVALUE_NO_CACHE);
+  HTTPLIB_RESET(HTTP_HVALUE_SSE_MIME);
   HTTPLIB_RESET(HTTP_HVALUE_WEBSOCKET);
   HTTPLIB_RESET(HTTP_HVALUE_WS_SEC_VERSION);
   HTTPLIB_RESET(HTTP_HVALUE_WS_UPGRADE);

data/ext/iodine/iodine.c

@@ -350,7 +350,7 @@ static VALUE iodine_cli_parse(VALUE self, VALUE desc) {
       "-redis -r an optional Redis URL server address. Default: none.",
       "-redis-ping -rp websocket ping interval (0..255). Default: 5 minutes",
       FIO_CLI_TYPE_INT, "\n\x1B[4mMisc:\x1B[0m", FIO_CLI_TYPE_PRINT,
-      "-warmup warm up the application. CAREFUL! iodine might fork.",
+      "-warmup --preload warm up the application. CAREFUL! with workers.",
       FIO_CLI_TYPE_BOOL,
       "-verbosity -V 0..5 server verbosity level. Default: 4",
       FIO_CLI_TYPE_INT);
@@ -360,6 +360,7 @@ static VALUE iodine_cli_parse(VALUE self, VALUE desc) {
     if (level > 0 && level < 100)
       FIO_LOG_LEVEL = level;
   }
+
   if (fio_cli_get("-w")) {
     iodine_workers_set(IodineModule, INT2NUM(fio_cli_get_i("-w")));
   }
@@ -372,14 +373,25 @@ static VALUE iodine_cli_parse(VALUE self, VALUE desc) {
   if (fio_cli_get_bool("-warmup")) {
     rb_hash_aset(defaults, ID2SYM(rb_intern("warmup_")), Qtrue);
   }
-  if (fio_cli_get("-p")) {
-    rb_hash_aset(defaults, ID2SYM(rb_intern("port")),
-                 rb_str_new_cstr(fio_cli_get("-p")));
-  }
   if (fio_cli_get("-b")) {
+    if (fio_cli_get("-b")[0] == '/' ||
+        (fio_cli_get("-b")[0] == '.' && fio_cli_get("-b")[1] == '/')) {
+      if (fio_cli_get("-p") &&
+          (fio_cli_get("-p")[0] != '0' || fio_cli_get("-p")[1])) {
+        FIO_LOG_WARNING(
+            "Detected a Unix socket binding (-b) conflicting with port.\n"
+            "            Port settings (-p %s) are ignored",
+            fio_cli_get("-p"));
+      }
+      fio_cli_set("-p", "0");
+    }
     rb_hash_aset(defaults, ID2SYM(rb_intern("address")),
                  rb_str_new_cstr(fio_cli_get("-b")));
   }
+  if (fio_cli_get("-p")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("port")),
+                 rb_str_new_cstr(fio_cli_get("-p")));
+  }
   if (fio_cli_get("-www")) {
     rb_hash_aset(defaults, ID2SYM(rb_intern("public")),
                  rb_str_new_cstr(fio_cli_get("-www")));

data/lib/iodine/mustache.rb

@@ -102,7 +102,7 @@ module Iodine
   #         x.report("Iodine::Mustache - no chaching - render list of 1000") do |times|
   #           Iodine::Mustache.render(nil, data_1000, template)
   #         end
-  #
+  #         nil
   #       end
   #     end
   #

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.10'.freeze
+  VERSION = '0.7.11'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.10
+  version: 0.7.11
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-19 00:00:00.000000000 Z
+date: 2018-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -210,7 +210,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.10.
+post_install_message: 'Thank you for installing Iodine 0.7.11.
 
 '
 rdoc_options: []