All Versions
125
Latest Version
Avg Release Cycle
63 days
Latest Release
-

Changelog History
Page 10

  • v0.2.12 Changes

    🛠 Fix: removed mempool after it failed some stress and concurrency tests.


  • v0.2.11 Changes

    🛠 Fix: C layer memory pool had a race-condition that could have caused, in some unlikely events, memory allocation failure for Websocket protocol handlers. This had now been addressed and fixed.

    Experimental feature: added an each_write feature to allow direct write operations that write data to all open Websocket connections sharing the same process (worker). When this method is called without the optional block, the data will be sent without the need to acquire the Ruby GIL.

    ⚡️ Update: lessons learned from facil.io have been implemented for better compatibility of Iodine's core C layer.


  • v0.2.10 Changes

    ⚡️ Update: added documentation and an extra helper method to set a connection's timeout when using custom protocols (Iodine as an EventMachine alternative).

    ⚡️ C Layer Update updated the facil.io library used, to incorporate the following fixes / update:

    • 👍 Better cross platform compilation by avoiding some name-space clashes. i.e, fixes a name clash with the __used directive / macro, where some OSs (i.e. CentOS) used a similar directive with different semantics.

    • 🛠 Reviewed and fixed some signed vs. unsigned integer comparisons.

    • ⏱ Smoother event scheduling by increasing the event-node's pool size.

    • Smoother thread concurrency growth by managing thread nanosleep times as thread count dependent.

    • ⚠ Cleared out "unused variable" warnings.

    • 🚚 Streamlined the accept process to remove a double socket's data clean-up.

    • SERVER_DELAY_IO is now implemented as an event instead of a stack frame.

    • 🛠 Fixed a possible Linux sendfile implementation issue where sometimes errors wouldn't be caught or sendfile would be called past a file's limit (edge case handling).

    • bscrypt random generator (where dev/random is unavailable) should now provide more entropy.


  • v0.2.9 Changes

    🛠 Fix: fixed a gcc-4.8 compatibility issue that prevented iodine 0.2.8 from compiling on Heroku's cedar-14 stack. This was related to missing system include files in gcc-4.8. It should be noted that Heroku's stack and compiler (which utilizes Ubuntu 14) has known issues and / or limited support for some of it's published features... but I should have remembered that before releasing version 0.2.8... sorry about that.


  • v0.2.8 Changes

    🐎 Memory Performance: The Websocket connection Protocol now utilizes both a C level memory pool and a local thread storage for temporary data. This helps mitigate possible memory fragmentation issues related to long running processes and long-lived objects. In addition, the socket read buffer was moved from the protocol object to a local thread storage (assumes pthreads and not green threads). This minimizes the memory footprint for each connection (at the expense of memory locality) and should allow Iodine to support more concurrent connections using less system resources. Last, but not least, the default message buffer per connection starts at 4Kb instead of 16Kb (grows as needed, up to Iodine::Rack.max_msg_size), assuming smaller messages are the norm.

    Housekeeping: Cleaned up some code, removed old files, copied over the latest facil.io library. There's probably some more housekeeping left to perform, especially anywhere where documentation is concerned. I welcome help with documentation.


  • v0.2.7 Changes

    Minor Fix: fixed an issue where a negative number of processes or threads would initiate a very large number of forks, promoting a system resource choke. 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.


  • v0.2.6 Changes

    ⚡️ 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).


  • v0.2.5 Changes

    🛠 Fix:: fix for issue #9 (credit to Jack Christensen for exposing the issue) caused by an unlocked critical section's "window of opportunity" that allowed asynchronous Websocket each blocks to run during the tail of the Websocket handshake (while the on_open callback was running in parallel).

    Minor Fix: Fix Iodine::Rack's startup message's fprintf call to fit correct argument sizes (Linux warnings).


  • v0.2.4 Changes

    Minor Fix: Patched Iodine against Apple's broken getrlimit on macOS. This allows correct auto-setting of open file limits for the socket layer.

    Minor Fix: Fixed the processor under-utilization warning, where "0" might be shown for the number processes instead of "1".

    ⚡️ Update: Added support for the env keys HTTP_VERSION and SERVER_PROTOCOL to indicate the HTTP protocol version. Iodine implements an HTTP/1.1 server, so versions aren't expected to be higher than 1.x.

    ⚡️ Update: Iodine::Rack startup messages now include details regarding open file limits imposed by the OS (open file limits control the maximum allowed concurrent connections and other resource limits).


  • v0.2.3 Changes

    ⚡️ Update: The write system call is now deferred when resources allow, meaning that (as long as the write buffer isn't full) write is not only non-blocking, but it's performed as a separate event, outside of the Ruby GIL.

    ⚡️ Update: The global socket write buffer was increased to ~16Mb (from ~4Mb), allowing for more concurrent write operations. However, the write buffer is still limited and write might block while the buffer is full. Blocking and "hanging" the server until there's enough room in the buffer for the requested write will slow the server down while keeping it healthy and more secure. IMHO, it is the lesser of two evils.