iodine 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 227ead92403069fa835295863ddaf99c1ba87ca8
-  data.tar.gz: 78a7b0dda1d37631471bc77018f985181ab20ff8
+  metadata.gz: 252241f38288180ae589bbe3787c5214a62cef10
+  data.tar.gz: 39f4936e62585c3f95dc9910de67a82d43093776
 SHA512:
-  metadata.gz: b28193f978e8ea93aab821e7109386a0df6e617396c6588732724e96e52587a0a0a48ecf742f5fa3c474f2c00bed38442db9bb53520cf725311d3c3464437f28
-  data.tar.gz: 852b315197992b6fd55213015b6dc5bd0ae06b98c6420a6fde671c373c436676a09e89287c15307224dbb9d8ea467e2ce78bfa1a728c40797184ffabfe8e9baa
+  metadata.gz: c41af300fdffcc3e5721a2c2da23841686b19b1eb6bae2f7c70e3b2bfb954d0182bffa0610846d656b4812ff6abd0b2f678767c908fda305e266cc2b847e2679
+  data.tar.gz: 1f17f2dd33c1a95ab5e4e5e64afbbea417743b7364fb2826a4d628eea9dabf33f71056a9184892c92c063f2ff6df9e86654fa4199da60cfab017b850fe5baabe

data/CHANGELOG.md

@@ -8,6 +8,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+Change log v.0.2.7
+
+**Minor Fix**: fixed an issue where a negative number or processes or threads would initiate a very large number of forks, promoting a resource choke to the system. limited the number of threads (1023) and processes (127).
+
+**Update**: Automated the number of processes (forks) and threads used when these are not explicitly specified. These follow the number of cores / 2.
+
+***
+
 Change log v.0.2.6
 
 **Update**: The IO reactor review will now be delayed until all events scheduled are done. This means that is events schedule future events, no IO data will be reviewed until all scheduled data is done. Foolish use might cause infinite loops that skip the IO reactor, but otherwise performance is improved (since the IO reactor might cause a thread to "sleep", delaying event execution).

data/README.md

@@ -10,21 +10,15 @@ Iodine makes writing Object Oriented **Network Services** easy to write.
 
 Iodine is an **evented** framework with a simple API that builds off the low level [C code library facil.io](https://github.com/boazsegev/facil.io) with support for **epoll** and **kqueue** - this means that:
 
-* Iodine can handle **thousands of concurrent connections** (tested with 20K connections).
+* Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections).
 
     That's right, Iodine isn't subject to the 1024 connection limit imposed by native Ruby and `select`/`poll` based applications.
 
     This makes Iodine ideal for writing HTTP/2 and Websocket servers (which is what started this whole thing).
 
-* Iodine supports only **Linux/Unix** based systems (i.e. OS X, Ubuntu, FreeBSD etc'). This allows us to:
+* Iodine supports only **Linux/Unix** based systems (i.e. OS X, Ubuntu, FreeBSD etc'), which are ideal for evented IO (while Windows and Solaris are better at IO *completion* events, which are totally different).
 
-     * Optimize our code for the production environment.
-
-     * Have our testing and development machines behave the same as our ultimate production environment.
-
-     * Catch any issues (read: bugs) while in development - just ask AT&T about how important this is ;-)
-
-Iodine is a C extension for Ruby, developed for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 family, but Rack requires Ruby 2.2.2, and so Iodine matches this requirement.
+Iodine is a C extension for Ruby, developed 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::Rack - an HTTP and Websockets server
 
@@ -219,13 +213,15 @@ Of course, if you still want to use Rack's `hijack` API, Iodine will support you
 
 ### How does it compare to other servers?
 
+Personally, after looking around, the only comparable servers are Puma and Passenger (the open source version), which Iodine significantly outperformed on my tests.
+
 Since the HTTP and Websocket parsers are written in C (with no RegExp), they're fairly fast.
 
-Also, Iodine's core and parsers are running outside of Ruby's global lock, meaning that they enjoy true concurrency before entering the Ruby layer (your application) - this offers Iodine a big advantage over other servers.
+Also, Iodine's core and parsers are running outside of Ruby's global lock, meaning that they enjoy true concurrency before entering the Ruby layer (your application) - this offers Iodine a big advantage over other Ruby servers.
 
-Another assumption Iodine makes is that it is behind a load balancer / proxy (which is the normal way Ruby applications are deployed) - this allows Iodine to disregard header validity checks (we're not checking for invalid characters) which speeds up the parsing process even more.
+Another assumption Iodine makes is that it is behind a load balancer / proxy (which is the normal way Ruby applications are deployed) - this allows Iodine to disregard header validity checks (we're not checking for invalid characters) which speeds up the parsing process even further.
 
-I'm not posting any data because Iodine is still under development and things are somewhat dynamic - but you can compare the performance for yourself using `wrk` or `ab`:
+I recommend benchmarking the performance for yourself using `wrk` or `ab`:
 
 ```bash
 $ wrk -c200 -d4 -t12 http://localhost:3000/
@@ -246,31 +242,15 @@ end
 run App
 ```
 
-Then start comparing servers:
-
-```bash
-$ rackup -p 3000 -E production -s iodine
-```
-
-vs.
+Then start comparing servers. Here are the settings I used to compare Iodine and Puma (4 processes, 16 threads):
 
 ```bash
-$ rackup -p 3000 -E production -s <Other_Server_Here>
-```
-
-Puma has ~16 threads by default, so when comparing against Puma, consider using an equal number of threads:
-
-```bash
-# (t - threads, w - worker processes)
 $ RACK_ENV=production iodine -p 3000 -t 16 -w 4
+# vs.
+$ RACK_ENV=production puma -p 3000 -t 16 -w 4
 ```
 
-vs.
-
-```bash
-# (t - threads, w - worker processes)
-$ RACK_ENV=production puma -p 3000 -w 4 -q
-```
+Iodine performed almost twice as well, (~90K req/sec vs. ~44K req/sec) while keeping a memory foot print that was more then 20% lower (~65Mb vs. ~85Mb).
 
 Review the `iodine -?` help for more data.
 

data/bin/ws-echo

@@ -36,7 +36,7 @@ class WSEcho
   end
 
   def on_ready
-    puts "on_ready called foe #{self}"
+    puts "on_ready called for #{self}"
   end
 
   def on_message(data)

data/ext/iodine/iodine_core.c

@@ -553,11 +553,16 @@ static void *srv_start_no_gvl(void *_) {
   // collect requested settings
   VALUE rb_th_i = rb_iv_get(Iodine, "@threads");
   VALUE rb_pr_i = rb_iv_get(Iodine, "@processes");
-  size_t threads = (TYPE(rb_th_i) == T_FIXNUM) ? FIX2ULONG(rb_th_i) : 0;
-  size_t processes = (TYPE(rb_pr_i) == T_FIXNUM) ? FIX2ULONG(rb_pr_i) : 0;
+  ssize_t threads = (TYPE(rb_th_i) == T_FIXNUM) ? FIX2LONG(rb_th_i) : 0;
+  ssize_t processes = (TYPE(rb_pr_i) == T_FIXNUM) ? FIX2LONG(rb_pr_i) : 0;
 // print a warnning if settings are sub optimal
 #ifdef _SC_NPROCESSORS_ONLN
   size_t cpu_count = sysconf(_SC_NPROCESSORS_ONLN);
+  if (processes <= 0)
+    processes = (cpu_count >> 1) ? (cpu_count >> 1) : 1;
+  if (threads <= 0)
+    threads = (cpu_count >> 1) ? (cpu_count >> 1) : 1;
+
   if (cpu_count > 0 &&
       ((processes << 1) < cpu_count || processes > (cpu_count << 1)))
     fprintf(
@@ -571,6 +576,11 @@ static void *srv_start_no_gvl(void *_) {
              ? "Some CPUs won't be utilized, inhibiting performance."
              : "This causes excessive context switches, wasting resources."),
         cpu_count, cpu_count);
+#else
+  if (processes <= 0)
+    processes = 1;
+  if (threads <= 0)
+    threads = 1;
 #endif
   server_run(.threads = threads, .processes = processes);
   return NULL;

data/ext/iodine/iodine_http.c

@@ -541,33 +541,23 @@ int iodine_http_review(void) {
     // initialize the Rack env template
     init_env_template();
 
-    // get Iodine concurrency info
-    VALUE rb_threads = rb_ivar_get(Iodine, rb_intern("@threads"));
-    int threads = rb_threads == Qnil ? 1 : (FIX2INT(rb_threads));
-    VALUE rb_processes = rb_ivar_get(Iodine, rb_intern("@processes"));
-    int processes = rb_processes == Qnil ? 1 : (FIX2INT(rb_processes));
-
     // Write message
     VALUE iodine_version = rb_const_get(Iodine, rb_intern("VERSION"));
     VALUE ruby_version = rb_const_get(Iodine, rb_intern("RUBY_VERSION"));
     if (public_folder)
       fprintf(stderr, "Starting up Iodine Http Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
-                      " * %lu processes X %lu thread%s\n"
                       " * %lu max concurrent connections / open files\n"
                       " * Serving static files from:\n"
                       "           %s\n\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
-              (size_t)processes, (size_t)threads, (threads > 1 ? "s" : ""),
               (size_t)sock_max_capacity(), public_folder);
     else
       fprintf(stderr, "Starting up Iodine Http Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
-                      " * %lu processes X %lu thread%s\n"
                       " * %lu max concurrent connections / open files\n"
                       "\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
-              (size_t)processes, (size_t)threads, (threads > 1 ? "s" : ""),
               (size_t)sock_max_capacity());
 
     // listen

data/ext/iodine/libserver.c

@@ -518,12 +518,12 @@ ssize_t server_run(struct ServerSettings settings) {
 
 #if defined(SERVER_PRINT_STATE) && SERVER_PRINT_STATE == 1
   if (settings.threads == 0)
-    fprintf(stderr, "* Running %lu processes"
+    fprintf(stderr, "* Running %u processes"
                     " in single thread mode.\n",
             settings.processes);
   else
-    fprintf(stderr, "* Running %lu processes"
-                    " X %lu threads.\n",
+    fprintf(stderr, "* Running %u processes"
+                    " X %u threads.\n",
             settings.processes, settings.threads);
 #endif
 
@@ -814,6 +814,28 @@ static void perform_each_task(void *task) {
 API
 ******* */
 
+/**
+Performs a task for each connection except the origin connection, unsafely and
+synchronously.
+*/
+void server_each_unsafe(intptr_t origin_uuid,
+                        void (*task)(intptr_t origin_uuid, intptr_t target_uuid,
+                                     protocol_s *target_protocol, void *arg),
+                        void *arg) {
+  intptr_t target;
+  protocol_s *protocol;
+  for (size_t i = 0; i < server_data.capacity; i++) {
+    target = sock_fd2uuid(p2task(task).target);
+    if (target == -1)
+      continue;
+    protocol = protocol_uuid(target);
+    if (protocol == NULL || protocol->service == listener_protocol_name ||
+        protocol->service == timer_protocol_name)
+      continue;
+    task(origin_uuid, target, protocol, arg);
+  }
+}
+
 /**
 Schedules a specific task to run asyncronously for each connection (except the
 origin connection) on a specific protocol.

data/ext/iodine/libserver.h

@@ -265,12 +265,12 @@ struct ServerSettings {
   /**
   Sets the amount of threads to be created for the server's thread-pool.
   Defaults to 1 - the reactor and all callbacks will work using a single working
-  thread, allowing for an evented single threaded design.
+  thread, allowing for an evented single threaded design. Limited to 1024.
   */
-  size_t threads;
+  unsigned threads : 10;
   /** Sets the amount of processes to be used (processes will be forked).
-  Defaults to 1 working processes (no forking). */
-  size_t processes;
+  Defaults to 1 working processes (no forking), limited to 127.*/
+  unsigned processes : 7;
 };
 
 /* *****************************************************************************
@@ -400,10 +400,27 @@ long server_count(char *service);
 * Tasks + Async
 */
 
+/**
+Performs a task for each connection except the origin connection, unsafely and
+synchronously.
+
+The task will be performed synchronously (blocking), without waiting for a lock.
+
+The task will be performed unsafely. For example, the protocol object might be
+invalid midway through (or at the beginning) the execution, as there is no
+protection against memory deallocation.
+
+This function should probably be avoided except when implementing publication or
+broadcast algorithms.
+*/
+void server_each_unsafe(intptr_t origin_uuid,
+                        void (*task)(intptr_t origin_uuid, intptr_t target_uuid,
+                                     protocol_s *target_protocol, void *arg),
+                        void *arg);
+
 /**
 Schedules a specific task to run asyncronously for each connection (except the
 origin connection).
-a NULL service identifier == all connections (all protocols).
 
 The task is performed within each target connection's busy "lock", meanning no
 two tasks (or `on_data` events) should be performed at the same time
@@ -414,11 +431,8 @@ The `on_finish` callback will be called once the task is finished and it will
 receive the originating connection's UUID (could be 0). The originating
 connection might have been closed by that time.
 
-The `service` string (pointer) identifier MUST be a constant string object OR
-a string that will persist until the `on_finish` callback is called. In other
-words, either hardcode the string or use `malloc` to allocate it before
-calling `each` and `free` to release the string from within the `on_finish`
-callback.
+The `service` identifier is required. The comparison is pointer value comparison
+and isn't related to the content of the service string.
 
 It is recommended the `on_finish` callback is only used to perform any
 resource cleanup necessary.

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.6'.freeze
+  VERSION = '0.2.7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-19 00:00:00.000000000 Z
+date: 2016-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack