iodine 0.4.19 → 0.5.0

data/examples/redis.ru

@@ -1,19 +1,18 @@
 # This example implements a Redis pub/sub engine according to the Iodine::PubSub::Engine specifications.
 #
-# The engine code is locates at examples/redis_pubsub.rb and it requires the hiredis gem.
-#
 # 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
 #
 require 'uri'
+require 'iodine'
 # initialize the Redis engine for each Iodine process.
 if ENV["REDIS_URL"]
   uri = URI(ENV["REDIS_URL"])
   Iodine.default_pubsub = Iodine::PubSub::RedisEngine.new(uri.host, uri.port, 0, uri.password)
 else
-  puts "* No Redis, it's okay, pub/sub will still run on the whole process cluster."
+  puts "* No Redis, it's okay, pub/sub will support the process cluster."
 end
 
 # A simple router - Checks for Websocket Upgrade and answers HTTP.
@@ -28,8 +27,9 @@ module MyHTTPRouter
    # this is function will be called by the Rack server (iodine) for every request.
    def self.call env
      # check if this is an upgrade request.
-     if(env['upgrade.websocket?'.freeze])
-       env['upgrade.websocket'.freeze] = WS_RedisPubSub.new(env['PATH_INFO'] ? env['PATH_INFO'][1..-1] : "guest")
+     if(env['rack.upgrade?'.freeze])
+       puts "SSE connections will not be able te send data, just listen." if(env['rack.upgrade?'.freeze] == :sse)
+       env['rack.upgrade'.freeze] = WS_RedisPubSub.new(env['PATH_INFO'] && env['PATH_INFO'].length > 1 ? env['PATH_INFO'][1..-1] : "guest")
        return WS_RESPONSE
      end
      # simply return the RESPONSE object, no matter what request was received.
@@ -44,9 +44,9 @@ class WS_RedisPubSub
   end
   # seng a message to new clients.
   def on_open
-    subscribe channel: "chat"
+    subscribe "chat"
     # let everyone know we arrived
-    # publish channel: "chat", message: "#{@name} entered the chat."
+    publish "chat", "#{@name} entered the chat."
   end
   # send a message, letting the client know the server is suggunt down.
   def on_shutdown
@@ -54,11 +54,11 @@ class WS_RedisPubSub
   end
   # perform the echo
   def on_message data
-    publish channel: "chat", message: "#{@name}: #{data}"
+    publish "chat", "#{@name}: #{data}"
   end
   def on_close
     # let everyone know we left
-    publish channel: "chat", message: "#{@name} left the chat."
+    publish "chat", "#{@name} left the chat."
     # we don't need to unsubscribe, subscriptions are cleared automatically once the connection is closed.
   end
 end

data/examples/shootout.ru

@@ -1,4 +1,5 @@
 require 'iodine'
+require 'json'
 
 # ON_IDLE = proc { Iodine::Base.db_print_registry ; Iodine.on_idle(&ON_IDLE) }
 # ON_IDLE.call
@@ -6,24 +7,49 @@ require 'iodine'
 class ShootoutApp
   # the default HTTP response
   def self.call(env)
-    if env['upgrade.websocket?'.freeze] # && env['HTTP_UPGRADE'.freeze] =~ /websocket/i
-      env['upgrade.websocket'.freeze] = ShootoutApp.new
-      return [0, {}, []]
+    if(Iodine::VERSION >= "0.5.0")
+       if(env['rack.upgrade?'.freeze] == :websocket)
+        env['rack.upgrade'.freeze] = ShootoutApp.new
+        return [0, {}, []]
+      end
+    else
+       if(env['upgrade.websocket?'.freeze])
+        env['upgrade.websocket'.freeze] = ShootoutApp.new
+        return [0, {}, []]
+      end
     end
-    out = "ENV:\r\n#{env.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n"
+    out = []
+    len = 0
+    out << "ENV:\n"
+    len += 5
+    env.each { |k, v| out << "#{k}: #{v}\n" ; len += out[-1].length }
     request = Rack::Request.new(env)
-    out += "\nRequest Path: #{request.path_info}\nParams:\r\n#{request.params.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n" unless request.params.empty?
-    [200, { 'Content-Length' => out.length, 'Content-Type' => 'text/plain; charset=UTF-8;' }, [out]]
+    out << "\nRequest Path: #{request.path_info}\n"
+    len += out[-1].length 
+    unless request.params.empty?
+      out << "Params:\n"
+      len += out[-1].length 
+      request.params.each { |k,v| out << "#{k}: #{v}\n" ; len += out[-1].length }
+    end
+    [200, { 'Content-Length' => len.to_s, 'Content-Type' => 'text/plain; charset=UTF-8;' }, out]
   end
   # We'll base the shootout on the internal Pub/Sub service.
   # It's slower than writing to every socket a pre-parsed message, but it's closer
   # to real-life implementations.
   def on_open
-    subscribe channel: "shootout"
+    if(Iodine::VERSION >= "0.5.0")
+      subscribe :shootout, as: :binary
+    else
+      subscribe channel: :shootout
+    end
   end
   def on_message data
     if data[0] == 'b' # binary
-      publish(channel: "shootout", message: data)
+      if(Iodine::VERSION >= "0.5.0")
+        publish :shootout, data
+      else
+        publish channel: :shootout, message: data
+      end
       data[0] = 'r'
       write data
       return
@@ -34,7 +60,11 @@ class ShootoutApp
     else
       # data = {type: 'broadcast', payload: payload}.to_json
       # broadcast :push2client, data
-      publish(channel: "shootout", message: ({type: 'broadcast', payload: payload}.to_json))
+      if(Iodine::VERSION >= "0.5.0")
+        publish :shootout, {type: 'broadcast', payload: payload}.to_json
+      else
+        publish channel: :shootout, message: {type: 'broadcast', payload: payload}.to_json
+      end
       write({type: "broadcastResult", payload: payload}.to_json)
     end
   rescue
@@ -42,12 +72,16 @@ class ShootoutApp
   end
 end
 
+# if defined?(Iodine)
+#   Iodine.run_every(5000) { Iodine::Base.db_print_registry }
+# end
+
 run ShootoutApp
 #
 # def cycle
 #   puts `websocket-bench broadcast ws://127.0.0.1:3000/ --concurrent 10 --sample-size 100 --server-type binary --step-size 1000 --limit-percentile 95 --limit-rtt 250ms --initial-clients 1000`
-#   sleep(2)
-#   puts `wrk -c4000 -d15 -t12 http://localhost:3000/`
+#   sleep(4)
+#   puts `wrk -c4000 -d15 -t2 http://localhost:3000/`
 #   true
 # end
 # sleep(10) while cycle

data/ext/iodine/defer.c

@@ -10,6 +10,7 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include <errno.h>
 #include <signal.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -20,18 +21,30 @@ Compile time settings
 ***************************************************************************** */
 
 #ifndef DEFER_THROTTLE
-#define DEFER_THROTTLE 524287UL
+#define DEFER_THROTTLE 1048574UL
 #endif
 #ifndef DEFER_THROTTLE_LIMIT
-#define DEFER_THROTTLE_LIMIT 1572864UL
+#define DEFER_THROTTLE_LIMIT 2097148UL
+#endif
+
+/**
+ * The progressive throttling model makes concurrency and parallelism more
+ * likely.
+ *
+ * Otherwise threads are assumed to be intended for "fallback" in case of slow
+ * user code, where a single thread should be active most of the time and other
+ * threads are activated only when that single thread is slow to perform.
+ */
+#ifndef DEFER_THROTTLE_PROGRESSIVE
+#define DEFER_THROTTLE_PROGRESSIVE 1
 #endif
 
 #ifndef DEFER_QUEUE_BLOCK_COUNT
 #if UINTPTR_MAX <= 0xFFFFFFFF
-/* Almost a page of memory on most 32 bit machines: ((4096/4)-4)/3 */
-#define DEFER_QUEUE_BLOCK_COUNT 340
+/* Almost a page of memory on most 32 bit machines: ((4096/4)-5)/3 */
+#define DEFER_QUEUE_BLOCK_COUNT 339
 #else
-/* Almost a page of memory on most 64 bit machines: ((4096/8)-4)/3 */
+/* Almost a page of memory on most 64 bit machines: ((4096/8)-5)/3 */
 #define DEFER_QUEUE_BLOCK_COUNT 168
 #endif
 #endif
@@ -126,10 +139,10 @@ critical_error:
 }
 
 static inline task_s pop_task(void) {
-  task_s ret = (task_s){NULL};
+  task_s ret = (task_s){.func = NULL};
   queue_block_s *to_free = NULL;
-  /* lock the state machine, to grab/create a task and place it at the tail
-  */ spn_lock(&deferred.lock);
+  /* lock the state machine, grab/create a task and place it at the tail */
+  spn_lock(&deferred.lock);
 
   /* empty? */
   if (deferred.reader->write == deferred.reader->read &&
@@ -148,6 +161,11 @@ static inline task_s pop_task(void) {
       to_free = deferred.reader;
       deferred.reader = deferred.reader->next;
     } else {
+      if (deferred.reader != &static_queue && static_queue.state == 2) {
+        to_free = deferred.reader;
+        deferred.writer = &static_queue;
+        deferred.reader = &static_queue;
+      }
       deferred.reader->write = deferred.reader->read = deferred.reader->state =
           0;
     }
@@ -157,6 +175,7 @@ static inline task_s pop_task(void) {
 finish:
   if (to_free == &static_queue) {
     static_queue.state = 2;
+    static_queue.next = NULL;
   }
   spn_unlock(&deferred.lock);
 
@@ -182,6 +201,8 @@ static inline void clear_tasks(void) {
   spn_unlock(&deferred.lock);
 }
 
+void defer_on_fork(void) { deferred.lock = SPN_LOCK_INIT; }
+
 #define push_task(...) push_task((task_s){__VA_ARGS__})
 
 /* *****************************************************************************
@@ -194,6 +215,7 @@ int defer(void (*func)(void *, void *), void *arg1, void *arg2) {
   if (!func)
     goto call_error;
   push_task(.func = func, .arg1 = arg1, .arg2 = arg2);
+  defer_thread_signal();
   return 0;
 
 call_error:
@@ -221,6 +243,16 @@ void defer_clear_queue(void) { clear_tasks(); }
 Thread Pool Support
 ***************************************************************************** */
 
+/* thread pool data container */
+struct defer_pool {
+  volatile unsigned int flag;
+  unsigned int count;
+  struct thread_msg_s {
+    pool_pt pool;
+    void *thrd;
+  } threads[];
+};
+
 #if defined(__unix__) || defined(__APPLE__) || defined(__linux__) ||           \
     defined(DEBUG)
 #include <pthread.h>
@@ -228,9 +260,9 @@ Thread Pool Support
 /* `weak` functions can be overloaded to change the thread implementation. */
 
 #pragma weak defer_new_thread
-void *defer_new_thread(void *(*thread_func)(void *), pool_pt arg) {
+void *defer_new_thread(void *(*thread_func)(void *), void *arg) {
   pthread_t *thread = malloc(sizeof(*thread));
-  if (thread == NULL || pthread_create(thread, NULL, thread_func, (void *)arg))
+  if (thread == NULL || pthread_create(thread, NULL, thread_func, arg))
     goto error;
   return thread;
 error:
@@ -238,12 +270,24 @@ error:
   return NULL;
 }
 
+/**
+ * OVERRIDE THIS to replace the default pthread implementation.
+ *
+ * Frees the memory asociated with a thread indentifier (allows the thread to
+ * run it's course, just the identifier is freed).
+ */
+#pragma weak defer_free_thread
+void defer_free_thread(void *p_thr) {
+  pthread_detach(*((pthread_t *)p_thr));
+  free(p_thr);
+}
+
 #pragma weak defer_join_thread
 int defer_join_thread(void *p_thr) {
   if (!p_thr)
     return -1;
   pthread_join(*((pthread_t *)p_thr), NULL);
-  free(p_thr);
+  defer_free_thread(p_thr);
   return 0;
 }
 
@@ -260,6 +304,10 @@ void *defer_new_thread(void *(*thread_func)(void *), void *arg) {
   (void)arg;
   return NULL;
 }
+
+#pragma weak defer_free_thread
+void defer_free_thread(void *p_thr) { void(p_thr); }
+
 #pragma weak defer_join_thread
 int defer_join_thread(void *p_thr) {
   (void)p_thr;
@@ -271,43 +319,80 @@ void defer_thread_throttle(unsigned long microsec) { return; }
 
 #endif /* DEBUG || pthread default */
 
-/* thread pool data container */
-struct defer_pool {
-  unsigned int flag;
-  unsigned int count;
-  void *threads[];
-};
+/**
+ * A thread entering this function should wait for new evennts.
+ */
+#pragma weak defer_thread_wait
+void defer_thread_wait(pool_pt pool, void *p_thr) {
+  if (DEFER_THROTTLE_PROGRESSIVE) {
+    /* keeps threads active (concurrent), but reduces performance */
+    static __thread size_t static_throttle = 1;
+    if (static_throttle < DEFER_THROTTLE_LIMIT)
+      static_throttle = (static_throttle << 1);
+    throttle_thread(static_throttle);
+    if (defer_has_queue())
+      static_throttle = 1;
+    (void)p_thr;
+    (void)pool;
+  } else {
+    /* Protects against slow user code, but mostly a single active thread */
+    size_t throttle =
+        pool ? ((pool->count) * DEFER_THROTTLE) : DEFER_THROTTLE_LIMIT;
+    if (!throttle || throttle > DEFER_THROTTLE_LIMIT)
+      throttle = DEFER_THROTTLE_LIMIT;
+    if (throttle == DEFER_THROTTLE)
+      throttle <<= 1;
+    throttle_thread(throttle);
+    (void)p_thr;
+  }
+}
+
+/**
+ * This should signal a single waiting thread to wake up (a new task entered the
+ * queue).
+ */
+#pragma weak defer_thread_signal
+void defer_thread_signal(void) { (void)0; }
 
 /* a thread's cycle. This is what a worker thread does... repeatedly. */
 static void *defer_worker_thread(void *pool_) {
-  volatile pool_pt pool = pool_;
+  struct thread_msg_s volatile *data = pool_;
   signal(SIGPIPE, SIG_IGN);
-  /* the throttle replaces conditional variables for better performance */
-  size_t throttle = (pool->count) * DEFER_THROTTLE;
-  if (!throttle || throttle > DEFER_THROTTLE_LIMIT)
-    throttle = DEFER_THROTTLE_LIMIT;
   /* perform any available tasks */
   defer_perform();
   /* as long as the flag is true, wait for and perform tasks. */
   do {
-    throttle_thread(throttle);
+    defer_thread_wait(data->pool, data->thrd);
     defer_perform();
-  } while (pool->flag);
+  } while (data->pool->flag);
   return NULL;
 }
 
 /** Signals a running thread pool to stop. Returns immediately. */
-void defer_pool_stop(pool_pt pool) { pool->flag = 0; }
+void defer_pool_stop(pool_pt pool) {
+  if (!pool)
+    return;
+  pool->flag = 0;
+  for (size_t i = 0; i < pool->count; ++i) {
+    defer_thread_signal();
+  }
+}
 
 /** Returns TRUE (1) if the pool is hadn't been signaled to finish up. */
-int defer_pool_is_active(pool_pt pool) { return pool->flag; }
+int defer_pool_is_active(pool_pt pool) { return (int)pool->flag; }
 
-/** Waits for a running thread pool, joining threads and finishing all tasks. */
+/**
+ * Waits for a running thread pool, joining threads and finishing all tasks.
+ *
+ * This function MUST be called in order to free the pool's data (the
+ * `pool_pt`).
+ */
 void defer_pool_wait(pool_pt pool) {
   while (pool->count) {
     pool->count--;
-    defer_join_thread(pool->threads[pool->count]);
+    defer_join_thread(pool->threads[pool->count].thrd);
   }
+  free(pool);
 }
 
 /** The logic behind `defer_pool_start`. */
@@ -316,8 +401,10 @@ static inline pool_pt defer_pool_initialize(unsigned int thread_count,
   pool->flag = 1;
   pool->count = 0;
   while (pool->count < thread_count &&
-         (pool->threads[pool->count] =
-              defer_new_thread(defer_worker_thread, pool)))
+         (pool->threads[pool->count].pool = pool) &&
+         (pool->threads[pool->count].thrd = defer_new_thread(
+              defer_worker_thread, (void *)(pool->threads + pool->count))))
+
     pool->count++;
   if (pool->count == thread_count) {
     return pool;
@@ -330,221 +417,44 @@ static inline pool_pt defer_pool_initialize(unsigned int thread_count,
 pool_pt defer_pool_start(unsigned int thread_count) {
   if (thread_count == 0)
     return NULL;
-  pool_pt pool = malloc(sizeof(*pool) + (thread_count * sizeof(void *)));
+  pool_pt pool =
+      malloc(sizeof(*pool) + (thread_count * sizeof(*pool->threads)));
   if (!pool)
     return NULL;
-  return defer_pool_initialize(thread_count, pool);
-}
-
-/* *****************************************************************************
-Child Process support (`fork`)
-***************************************************************************** */
-
-/**
-OVERRIDE THIS to replace the default `fork` implementation or to inject hooks
-into the forking function.
-
-Behaves like the system's `fork`.
-*/
-#pragma weak defer_new_child
-int defer_new_child(void) { return (int)fork(); }
-
-/* forked `defer` workers use a global thread pool object. */
-static pool_pt forked_pool;
-
-/* handles the SIGINT and SIGTERM signals by shutting down workers */
-static void sig_int_handler(int sig) {
-  if (sig != SIGINT && sig != SIGTERM)
-    return;
-  if (!forked_pool)
-    return;
-  defer_pool_stop(forked_pool);
-}
-
-/*
-Zombie Reaping
-With thanks to Dr Graham D Shaw.
-http://www.microhowto.info/howto/reap_zombie_processes_using_a_sigchld_handler.html
-*/
-void reap_child_handler(int sig) {
-  (void)(sig);
-  int old_errno = errno;
-  while (waitpid(-1, NULL, WNOHANG) > 0)
-    ;
-  errno = old_errno;
-}
-
-#if !defined(NO_CHILD_REAPER) || NO_CHILD_REAPER == 0
-/* initializes zombie reaping for the process */
-inline static void reap_children(void) {
-  struct sigaction sa;
-  sa.sa_handler = reap_child_handler;
-  sigemptyset(&sa.sa_mask);
-  sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
-  if (sigaction(SIGCHLD, &sa, 0) == -1) {
-    perror("Child reaping initialization failed");
-    kill(0, SIGINT), exit(errno);
-  }
-}
-#endif
-
-/* a global process identifier (0 == root) */
-static int defer_fork_pid_id = 0;
-
-/**
- * Forks the process, starts up a thread pool and waits for all tasks to run.
- * All existing tasks will run in all processes (multiple times).
- *
- * Returns 0 on success, -1 on error and a positive number if this is a child
- * process that was forked.
- */
-int defer_perform_in_fork(unsigned int process_count,
-                          unsigned int thread_count) {
-  if (forked_pool)
-    return -1; /* we're already running inside an active `fork` */
-
-  /* we use a placeholder while initializing the forked thread pool, so calls to
-   * `defer_fork_is_active` don't fail.
-   */
-  static struct defer_pool pool_placeholder = {.count = 1, .flag = 1};
-
-  /* setup signal handling */
-  struct sigaction act, old, old_term, old_pipe;
-  pid_t *pids = NULL;
-  int ret = 0;
-  unsigned int pids_count;
-
-  act.sa_handler = sig_int_handler;
-  sigemptyset(&act.sa_mask);
-  act.sa_flags = SA_RESTART | SA_NOCLDSTOP;
-
-  if (sigaction(SIGINT, &act, &old)) {
-    perror("couldn't set signal handler");
-    goto finish;
-  };
-
-  if (sigaction(SIGTERM, &act, &old_term)) {
-    perror("couldn't set signal handler");
-    goto finish;
-  };
-
-  act.sa_handler = SIG_IGN;
-  if (sigaction(SIGPIPE, &act, &old_pipe)) {
-    perror("couldn't set signal handler");
-    goto finish;
-  };
 
-/* setup zomie reaping */
-#if !defined(NO_CHILD_REAPER) || NO_CHILD_REAPER == 0
-  reap_children();
-#endif
-
-  if (!process_count)
-    process_count = 1;
-  --process_count;
-
-  /* for `process_count == 0` nothing happens */
-  pids = calloc(process_count, sizeof(*pids));
-  if (process_count && !pids)
-    goto finish;
-  for (pids_count = 0; pids_count < process_count; pids_count++) {
-    if (!(pids[pids_count] = (pid_t)defer_new_child())) {
-      defer_fork_pid_id = pids_count + 1;
-      forked_pool = &pool_placeholder;
-      forked_pool = defer_pool_start(thread_count);
-      defer_pool_wait(forked_pool);
-      defer_perform();
-      defer_perform();
-      return 1;
-    }
-    if (pids[pids_count] == -1) {
-      ret = -1;
-      goto finish;
-    }
-  }
-
-  forked_pool = &pool_placeholder;
-  forked_pool = defer_pool_start(thread_count);
-
-  defer_pool_wait(forked_pool);
-  forked_pool = NULL;
-
-  defer_perform();
-
-finish:
-  if (pids) {
-    for (size_t j = 0; j < pids_count; j++) {
-      kill(pids[j], SIGINT);
-    }
-    for (size_t j = 0; j < pids_count; j++) {
-      waitpid(pids[j], NULL, 0);
-    }
-    free(pids);
-  }
-  sigaction(SIGINT, &old, &act);
-  sigaction(SIGTERM, &old_term, &act);
-  sigaction(SIGTERM, &old_pipe, &act);
-  return ret;
+  return defer_pool_initialize(thread_count, pool);
 }
 
-/** Returns TRUE (1) if the forked thread pool hadn't been signaled to finish
- * up. */
-int defer_fork_is_active(void) { return forked_pool && forked_pool->flag; }
-
-/** Returns the process number for the current working proceess. 0 == parent. */
-int defer_fork_pid(void) { return defer_fork_pid_id; }
-
 /* *****************************************************************************
 Test
 ***************************************************************************** */
 #ifdef DEBUG
 
-#include <stdio.h>
-
 #include <pthread.h>
-#define DEFER_TEST_THREAD_COUNT 128
+#include <stdio.h>
+#include <sys/stat.h>
 
-static spn_lock_i i_lock = 0;
 static size_t i_count = 0;
 
-static void sample_task(void *unused, void *unused2) {
-  (void)(unused);
-  (void)(unused2);
-  spn_lock(&i_lock);
-  i_count++;
-  spn_unlock(&i_lock);
-}
+#define TOTAL_COUNT (512 * 1024)
 
-static void single_counter_task(void *unused, void *unused2) {
+static void sample_task(void *unused, void *unused2) {
   (void)(unused);
   (void)(unused2);
-  spn_lock(&i_lock);
-  i_count++;
-  spn_unlock(&i_lock);
-  if (i_count < (1024 * 1024))
-    defer(single_counter_task, NULL, NULL);
+  spn_add(&i_count, 1);
 }
 
-static void sched_sample_task(void *unused, void *unused2) {
-  (void)(unused);
+static void sched_sample_task(void *count, void *unused2) {
   (void)(unused2);
-  for (size_t i = 0; i < 1024; i++) {
+  for (size_t i = 0; i < (uintptr_t)count; i++) {
     defer(sample_task, NULL, NULL);
   }
 }
 
-static void thrd_sched(void *unused, void *unused2) {
-  for (size_t i = 0; i < (1024 / DEFER_TEST_THREAD_COUNT); i++) {
-    sched_sample_task(unused, unused2);
-  }
-}
-
 static void text_task_text(void *unused, void *unused2) {
   (void)(unused);
   (void)(unused2);
-  spn_lock(&i_lock);
   fprintf(stderr, "this text should print before defer_perform returns\n");
-  spn_unlock(&i_lock);
 }
 
 static void text_task(void *a1, void *a2) {
@@ -553,114 +463,101 @@ static void text_task(void *a1, void *a2) {
   defer(text_task_text, a1, a2);
 }
 
-static void pid_task(void *arg, void *unused2) {
-  (void)(unused2);
-  fprintf(stderr, "* %d pid is going to sleep... (%s)\n", getpid(),
-          arg ? (char *)arg : "unknown");
-}
-
 void defer_test(void) {
-  time_t start, end;
-  fprintf(stderr, "Starting defer testing\n");
+#define TEST_ASSERT(cond, ...)                                                 \
+  if (!(cond)) {                                                               \
+    fprintf(stderr, "* " __VA_ARGS__);                                         \
+    fprintf(stderr, "Testing failed.\n");                                      \
+    exit(-1);                                                                  \
+  }
 
-  spn_lock(&i_lock);
+  clock_t start, end;
+  fprintf(stderr, "Starting defer testing\n");
   i_count = 0;
-  spn_unlock(&i_lock);
   start = clock();
-  for (size_t i = 0; i < (1024 * 1024); i++) {
+  for (size_t i = 0; i < TOTAL_COUNT; i++) {
     sample_task(NULL, NULL);
   }
   end = clock();
   fprintf(stderr,
           "Deferless (direct call) counter: %lu cycles with i_count = %lu, "
           "%lu/%lu free/malloc\n",
-          end - start, i_count, count_dealloc, count_alloc);
-
-  spn_lock(&i_lock);
-  COUNT_RESET;
-  i_count = 0;
-  spn_unlock(&i_lock);
-  start = clock();
-  defer(single_counter_task, NULL, NULL);
-  defer(single_counter_task, NULL, NULL);
-  defer_perform();
-  end = clock();
-  fprintf(stderr,
-          "Defer single thread, two tasks: "
-          "%lu cycles with i_count = %lu, %lu/%lu "
-          "free/malloc\n",
-          end - start, i_count, count_dealloc, count_alloc);
-
-  spn_lock(&i_lock);
-  COUNT_RESET;
-  i_count = 0;
-  spn_unlock(&i_lock);
-  start = clock();
-  for (size_t i = 0; i < 1024; i++) {
-    defer(sched_sample_task, NULL, NULL);
+          (unsigned long)(end - start), (unsigned long)i_count,
+          (unsigned long)count_dealloc, (unsigned long)count_alloc);
+  size_t i_count_should_be = i_count;
+
+  fprintf(stderr, "\n");
+
+  for (int i = 1; TOTAL_COUNT >> i; ++i) {
+    COUNT_RESET;
+    i_count = 0;
+    const size_t per_task = TOTAL_COUNT >> i;
+    const size_t tasks = 1 << i;
+    start = clock();
+    for (size_t j = 0; j < tasks; ++j) {
+      defer(sched_sample_task, (void *)per_task, NULL);
+    }
+    defer_perform();
+    end = clock();
+    fprintf(stderr,
+            "- Defer single thread, %zu scheduling loops (%zu each):\n"
+            "    %lu cycles with i_count = %lu, %lu/%lu "
+            "free/malloc\n",
+            tasks, per_task, (unsigned long)(end - start),
+            (unsigned long)i_count, (unsigned long)count_dealloc,
+            (unsigned long)count_alloc);
+    TEST_ASSERT(i_count == i_count_should_be, "ERROR: defer count invalid\n");
   }
-  defer_perform();
-  end = clock();
-  fprintf(stderr,
-          "Defer single thread: %lu cycles with i_count = %lu, %lu/%lu "
-          "free/malloc\n",
-          end - start, i_count, count_dealloc, count_alloc);
 
-  spn_lock(&i_lock);
-  COUNT_RESET;
-  i_count = 0;
-  spn_unlock(&i_lock);
-  start = clock();
-  pool_pt pool = defer_pool_start(DEFER_TEST_THREAD_COUNT);
-  if (pool) {
-    for (size_t i = 0; i < DEFER_TEST_THREAD_COUNT; i++) {
-      defer(thrd_sched, NULL, NULL);
+  ssize_t cpu_count = 8;
+#ifdef _SC_NPROCESSORS_ONLN
+  cpu_count = (sysconf(_SC_NPROCESSORS_ONLN) >> 1) | 1;
+#endif
+
+  fprintf(stderr, "\n");
+
+  for (int i = 1; TOTAL_COUNT >> i; ++i) {
+    COUNT_RESET;
+    i_count = 0;
+    const size_t per_task = TOTAL_COUNT >> i;
+    const size_t tasks = 1 << i;
+    pool_pt pool = defer_pool_start(cpu_count);
+    start = clock();
+    for (size_t j = 0; j < tasks; ++j) {
+      defer(sched_sample_task, (void *)per_task, NULL);
     }
-    // defer((void (*)(void *))defer_pool_stop, pool);
     defer_pool_stop(pool);
     defer_pool_wait(pool);
     end = clock();
     fprintf(stderr,
-            "Defer multi-thread (%d threads): %lu cycles with i_count = %lu, "
-            "%lu/%lu free/malloc\n",
-            DEFER_TEST_THREAD_COUNT, end - start, i_count, count_dealloc,
-            count_alloc);
-  } else
-    fprintf(stderr, "Defer multi-thread: FAILED!\n");
-
-  spn_lock(&i_lock);
+            "- Defer %zu threads, %zu scheduling loops (%zu each):\n"
+            "    %lu cycles with i_count = %lu, %lu/%lu "
+            "free/malloc\n",
+            (size_t)cpu_count, tasks, per_task, (unsigned long)(end - start),
+            (unsigned long)i_count, (unsigned long)count_dealloc,
+            (unsigned long)count_alloc);
+    TEST_ASSERT(i_count == i_count_should_be, "ERROR: defer count invalid\n");
+  }
+
   COUNT_RESET;
   i_count = 0;
-  spn_unlock(&i_lock);
-  start = clock();
   for (size_t i = 0; i < 1024; i++) {
     defer(sched_sample_task, NULL, NULL);
   }
   defer_perform();
-  end = clock();
-  fprintf(stderr,
-          "Defer single thread (2): %lu cycles with i_count = %lu, %lu/%lu "
-          "free/malloc\n",
-          end - start, i_count, count_dealloc, count_alloc);
-
-  fprintf(stderr, "calling defer_perform.\n");
   defer(text_task, NULL, NULL);
+  fprintf(stderr, "calling defer_perform.\n");
   defer_perform();
   fprintf(stderr,
           "defer_perform returned. i_count = %lu, %lu/%lu free/malloc\n",
-          i_count, count_dealloc, count_alloc);
-
-  fprintf(stderr, "press ^C to finish PID test\n");
-  defer(pid_task, "pid test", NULL);
-  if (defer_perform_in_fork(4, 64) > 0) {
-    fprintf(stderr, "* %d finished\n", getpid());
-    exit(0);
-  };
-  fprintf(stderr, "* Defer queue %lu/%lu free/malloc\n", count_dealloc,
-          count_alloc);
+          (unsigned long)i_count, (unsigned long)count_dealloc,
+          (unsigned long)count_alloc);
+
+  COUNT_RESET;
+  i_count = 0;
   defer_clear_queue();
-  fprintf(stderr, "* Defer queue %lu/%lu free/malloc\n", count_dealloc,
-          count_alloc);
+  fprintf(stderr, "* Defer cleared queue: %lu/%lu free/malloc\n\n",
+          (unsigned long)count_dealloc, (unsigned long)count_alloc);
 }
 
 #endif