cztop 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0a723ca2a3e3272f97e72dbf4b90ce750d56240
-  data.tar.gz: 579445f67959d4cd7f8db0166adff18881d01273
+  metadata.gz: 38df565064ee6d04ad3eeaaf668e68574cb8e0cc
+  data.tar.gz: 62eb8513064a9546d4c04c57411314ffb8bdc162
 SHA512:
-  metadata.gz: 0431bec1dd537a65ba20467226cb430a3affb229319da0aaefaf2d114e72a613a3f72fc579e43c8449ec0ccb3e473e7ef9e65b8b8ddb1e77d501b63fc9d4be8f
-  data.tar.gz: 0ae5624063f633046af71f27123b789bf1d547f713f6c87a2050c752c49f722ad30b03867ea754bf46a1943df7b7d05ec2e0cf18155c84730fcb624ad875ebbb
+  metadata.gz: 028dbf962ccf069d64048d12107fcc322e66a5553c34e2c8081e15319e602eac13c88ca903a0290bb9fbd6dda22c398ea8e4e16d99fa01f0fab6cf049110df13
+  data.tar.gz: 7f6f6cdf10066b9a8ae4c26f5b3d0025da04a1a6aeb0caec8bc6ab550a16955057162543ac83e0ec0fd2535923637c5beafb6acf1a6247228492f97531862dc4

data/CHANGES.md

@@ -1,3 +1,18 @@
+0.2.0 (xx/01/2016)
+-----
+* simplify CZTop::Z85::Padded
+  * no length encoding
+  * padding similar to PKCS#7
+* add utilities `z85encode` and `z85decode`
+* add CZTop::Z85::Pipe
+* CZTop::SUB#subscribe: subscribe to everything if no parameter given
+
+0.1.1 (23/01/2016)
+-----
+* add support for Ruby 2.0
+* improve documentation
+* fix require()s in examples
+
 0.1.0 (23/01/2016)
 -----
 * first release

data/README.md

@@ -3,6 +3,7 @@
 [![Inline docs](http://inch-ci.org/github/paddor/cztop.svg?branch=master&style=shields)](http://inch-ci.org/github/paddor/cztop)
 [![Dependency Status](https://gemnasium.com/paddor/cztop.svg)](https://gemnasium.com/paddor/cztop)
 [![Coverage Status](https://coveralls.io/repos/paddor/cztop/badge.svg?branch=master&service=github)](https://coveralls.io/github/paddor/cztop?branch=master)
+[![ISC License](https://img.shields.io/badge/license-ISC_License-blue.svg)](LICENSE)
 
 # CZTop
 
@@ -389,6 +390,10 @@ $
   * cannot handle CLIENT/SERVER sockets
   * there good timer gems for Ruby
   * Poller can be used to embed in an existing event loop (Celluloid), or make your own trivial one
+* [x] provide `z85encode` and `z85decode` utilities
+  * can be used in a pipeline (limited memory usage)
+  * reusable interface: `Z85::Pipe`
+
 
 ## Contributing
 

data/exe/z85decode

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require 'cztop'
+require 'optparse'
+require 'benchmark'
+
+options = { strategy: CZTop::Z85::Pipe::Strategy::Sequential }
+OptionParser.new do |opts|
+  opts.banner = "Usage: #$0 [options]"
+
+  opts.on("-p", "--parallel", "read, decode, and write in parallel " +
+                              "using 3 threads") do
+    options[:strategy] = CZTop::Z85::Pipe::Strategy::Parallel
+  end
+  opts.on("-v", "--verbose", "print some statistics afterwards") do
+    options[:verbose] = true
+  end
+end.parse!
+
+pipe = CZTop::Z85::Pipe.new(STDIN, STDOUT, strategy: options[:strategy])
+bytes_decoded = nil
+tms = Benchmark.measure { bytes_decoded = pipe.decode }
+exit unless options[:verbose]
+
+if tms.real < 0.1
+  warn "#{$0}: decoding took %.2f us." % (tms.real * 1_000_000)
+else
+  warn "#{$0}: decoding took %.3f seconds." % tms.real
+end
+
+throughput = (bytes_decoded * 8 / tms.real) / 1_000_000
+warn "#{$0}: mean throughput: %.3f [Mb/s]" % throughput

data/exe/z85encode

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require 'cztop'
+require 'optparse'
+require 'benchmark'
+
+options = { strategy: CZTop::Z85::Pipe::Strategy::Sequential }
+OptionParser.new do |opts|
+  opts.banner = "Usage: #$0 [options]"
+
+  opts.on("-p", "--parallel", "read, encode, and write in parallel " +
+                              "using 3 threads") do
+    options[:strategy] = CZTop::Z85::Pipe::Strategy::Parallel
+  end
+  opts.on("-v", "--verbose", "print some statistics afterwards") do
+    options[:verbose] = true
+  end
+end.parse!
+
+pipe = CZTop::Z85::Pipe.new(STDIN, STDOUT, strategy: options[:strategy])
+bytes_encoded = nil
+tms = Benchmark.measure { bytes_encoded = pipe.encode }
+exit unless options[:verbose]
+
+if tms.real < 0.1
+  warn "#{$0}: encoding took %.2f us." % (tms.real * 1_000_000)
+else
+  warn "#{$0}: encoding took %.3f seconds." % tms.real
+end
+
+throughput = (bytes_encoded * 8 / tms.real) / 1_000_000
+warn "#{$0}: mean throughput: %.3f [Mb/s]" % throughput

data/lib/cztop.rb

@@ -31,6 +31,8 @@ require_relative 'cztop/config/traversing'
 require_relative 'cztop/config/serialization'
 require_relative 'cztop/message/frames'
 require_relative 'cztop/socket/types'
+require_relative 'cztop/z85/padded'
+require_relative 'cztop/z85/pipe'
 
 
 # make Ctrl-C work in case a low-level call hangs

data/lib/cztop/poller.rb

@@ -30,57 +30,7 @@ module CZTop
   # ugly.
   #
   class Poller
-    # CZTop's interface to the low-level +zmq_poll()+ function.
-    module ZMQ
-
-      POLL    = 1
-      POLLIN  = 1
-      POLLOUT = 2
-      POLLERR = 4
-
-      extend ::FFI::Library
-      lib_name = 'libzmq'
-      lib_paths = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
-        .map { |path| "#{path}/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}" }
-      ffi_lib lib_paths + [lib_name]
-
-      # Represents a struct of type +zmq_pollitem_t+.
-      class PollItem < FFI::Struct
-        ##
-        # shamelessly taken from https://github.com/mtortonesi/ruby-czmq-ffi
-        #
-
-
-        FD_TYPE = if FFI::Platform::IS_WINDOWS && FFI::Platform::ADDRESS_SIZE == 64
-          # On Windows, zmq.h defines fd as a SOCKET, which is 64 bits on x64.
-          :uint64
-        else
-          :int
-        end
-
-        layout  :socket,  :pointer,
-                :fd,      FD_TYPE,
-                :events,  :short,
-                :revents, :short
-
-        # @return [Boolean] whether the socket is readable
-        def readable?
-          (self[:revents] & POLLIN) > 0
-        end
-
-        # @return [Boolean] whether the socket is writable
-        def writable?
-          (self[:revents] & POLLOUT) > 0
-        end
-      end
-
-      opts = {
-        blocking: true  # only necessary on MRI to deal with the GIL.
-      }
-
-      #ZMQ_EXPORT int  zmq_poll (zmq_pollitem_t *items, int nitems, long timeout);
-      attach_function :poll, :zmq_poll, [:pointer, :int, :long], :int, **opts
-    end
+    include ::CZMQ::FFI
 
     # @param readers [Socket, Actor] sockets to poll for input
     def initialize(*readers)
@@ -108,7 +58,7 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def add_reader(socket)
       raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = CZMQ::FFI::Zsock.resolve(socket) # get low-level handle
+      ptr = Zsock.resolve(socket) # get low-level handle
       @readers[ptr.to_i] = socket
       @rebuild_needed = true
     end
@@ -120,7 +70,7 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def remove_reader(socket)
       raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = CZMQ::FFI::Zsock.resolve(socket) # get low-level handle
+      ptr = Zsock.resolve(socket) # get low-level handle
       @readers.delete(ptr.to_i) and @rebuild_needed = true
     end
 
@@ -130,7 +80,7 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def add_writer(socket)
       raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = CZMQ::FFI::Zsock.resolve(socket) # get low-level handle
+      ptr = Zsock.resolve(socket) # get low-level handle
       @writers[ptr.to_i] = socket
       @rebuild_needed = true
     end
@@ -142,7 +92,7 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def remove_writer(socket)
       raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = CZMQ::FFI::Zsock.resolve(socket) # get low-level handle
+      ptr = Zsock.resolve(socket) # get low-level handle
       @writers.delete(ptr.to_i) and @rebuild_needed = true
     end
 
@@ -212,13 +162,65 @@ module CZTop
     # @return [ZMQ::PollItem] a new item for
     def new_item(address, socket, events)
       item = ZMQ::PollItem.new(address)
-      item[:socket] = CZMQ::FFI::Zsock.resolve(socket)
+      item[:socket] = Zsock.resolve(socket)
       item[:fd] = 0
       item[:events] = events
       item[:revents] = 0
       item
     end
 
+    # CZTop's interface to the low-level +zmq_poll()+ function.
+    module ZMQ
+
+      POLL    = 1
+      POLLIN  = 1
+      POLLOUT = 2
+      POLLERR = 4
+
+      extend ::FFI::Library
+      lib_name = 'libzmq'
+      lib_paths = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
+        .map { |path| "#{path}/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}" }
+      ffi_lib lib_paths + [lib_name]
+
+      # Represents a struct of type +zmq_pollitem_t+.
+      class PollItem < FFI::Struct
+        ##
+        # shamelessly taken from https://github.com/mtortonesi/ruby-czmq-ffi
+        #
+
+
+        FD_TYPE = if FFI::Platform::IS_WINDOWS && FFI::Platform::ADDRESS_SIZE == 64
+          # On Windows, zmq.h defines fd as a SOCKET, which is 64 bits on x64.
+          :uint64
+        else
+          :int
+        end
+
+        layout  :socket,  :pointer,
+                :fd,      FD_TYPE,
+                :events,  :short,
+                :revents, :short
+
+        # @return [Boolean] whether the socket is readable
+        def readable?
+          (self[:revents] & POLLIN) > 0
+        end
+
+        # @return [Boolean] whether the socket is writable
+        def writable?
+          (self[:revents] & POLLOUT) > 0
+        end
+      end
+
+      opts = {
+        blocking: true  # only necessary on MRI to deal with the GIL.
+      }
+
+      #ZMQ_EXPORT int  zmq_poll (zmq_pollitem_t *items, int nitems, long timeout);
+      attach_function :poll, :zmq_poll, [:pointer, :int, :long], :int, **opts
+    end
+
     # This is the trivial poller based on zpoller. It only supports polling
     # for reading, but it also supports doing that on CLIENT/SERVER sockets,
     # which is useful for {CZTop::Poller}.

data/lib/cztop/socket/types.rb

@@ -134,10 +134,13 @@ module CZTop
         attach_ffi_delegate(Zsock.new_sub(endpoints, subscription))
       end
 
+      # @return [String] subscription prefix to subscribe to everything
+      EVERYTHING = ""
+
       # Subscribes to the given prefix string.
       # @param prefix [String] prefix string to subscribe to
       # @return [void]
-      def subscribe(prefix)
+      def subscribe(prefix = EVERYTHING)
         ffi_delegate.set_subscribe(prefix)
       end
 

data/lib/cztop/version.rb

@@ -1,3 +1,3 @@
 module CZTop
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/cztop/z85.rb

@@ -7,6 +7,40 @@ module CZTop
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
 
+    class << self
+      # Same as {Z85#encode}, but without the need to create an instance
+      # first.
+      #
+      # @param input [String] possibly binary input data
+      # @return [String] Z85 encoded data as ASCII string
+      # @raise [ArgumentError] if input length isn't divisible by 4 with no
+      #   remainder
+      # @raise [SystemCallError] if this fails
+      def encode(input)
+        default.encode(input)
+      end
+
+      # Same as {Z85#decode}, but without the need to create an instance
+      # first.
+      #
+      # @param input [String] Z85 encoded data
+      # @return [String] original data as binary string
+      # @raise [ArgumentError] if input length isn't divisible by 5 with no
+      #   remainder
+      # @raise [SystemCallError] if this fails
+      def decode(input)
+        default.decode(input)
+      end
+
+      private
+
+      # Default instance of {Z85}.
+      # @return [Z85] memoized default instance
+      def default
+        @default ||= Z85.new
+      end
+    end
+
     def initialize
       attach_ffi_delegate(CZMQ::FFI::Zarmour.new)
       ffi_delegate.set_mode(:mode_z85)
@@ -63,95 +97,5 @@ module CZTop
         size_ptr.read_uint32
       end
     end
-
-    # Z85 with simple padding. This allows you to {#encode} input of any
-    # length.
-    #
-    # = Encoding Procedure
-    #
-    # If the data to be encoded is empty (0 bytes), it is encoded to the empty
-    # string, just like in Z85.
-    #
-    # Otherwise, a length information is prepended and, if needed, padding (1,
-    # 2, or 3 NULL bytes) is appended to bring the resulting blob to
-    # a multiple of 4 bytes.
-    #
-    # The length information is encoded similarly to lengths of messages
-    # (frames) in ZMTP. Up to 127 bytes, the data's length is encoded with
-    # a single byte (specifically, with the 7 least significant bits in it).
-    #
-    #   +--------+-------------------------------+------------+
-    #   | length |              data             |   padding  |
-    #   | 1 byte |        up to 127 bytes        |  0-3 bytes |
-    #   +--------+-------------------------------+------------+
-    #
-    # If the data is 128 bytes or more, the most significant bit will be set
-    # to indicate that fact, and a 64 bit unsigned integer in network byte
-    # order is appended after this first byte to encode the length of the
-    # data.  This means that up to 16EiB (exbibytes) can be encoded, which
-    # will be enough for the foreseeable future.
-    #
-    #   +--------+-----------+----------------------------------+------------+
-    #   |  big?  |   length  |                data              |   padding  |
-    #   | 1 byte |  8 bytes  |      128 bytes or much more      |  0-3 bytes |
-    #   +--------+-----------+----------------------------------+------------+
-    #
-    # The resulting blob is encoded using {CZTop::Z85#encode}.
-    # {CZTop::Z85#decode} does the inverse.
-    #
-    # @note Warning: This won't be compatible with other implementations of
-    #   Z85. Only use this if you really need padding, like when you can't
-    #   guarantee the input for {#encode} is always a multiple of 4 bytes.
-    #
-    class Padded < Z85
-      # Encododes to Z85, with padding if needed.
-      #
-      # If input isn't empty, 8 additional bytes for the encoded length will
-      # be prepended. If needed, 1 to 3 bytes of padding will be appended.
-      #
-      # If input is empty, returns the empty string.
-      #
-      # @param input [String] possibly binary input data
-      # @return [String] Z85 encoded data as ASCII string, including encoded
-      #   length and padding
-      # @raise [SystemCallError] if this fails
-      def encode(input)
-        return super if input.empty?
-        length = input.bytesize
-        if length < 1<<7 # up to 127 bytes
-          encoded_length = [length].pack("C")
-
-        else # larger input
-          low = length & 0xFFFFFFFF
-          high = (length >> 32) & 0xFFFFFFFF
-          encoded_length = [ 1<<7, high, low ].pack("CNN")
-        end
-        padding = "\0" * ((4 - ((length+1) % 4)) % 4)
-        super("#{encoded_length}#{input}#{padding}")
-      end
-
-      # Decodes from Z85 with padding.
-      #
-      # @param input [String] Z85 encoded data (including encoded length and
-      #   padding, or empty string)
-      # @return [String] original data as binary string
-      # @raise [ArgumentError] if input is invalid or truncated
-      # @raise [SystemCallError] if this fails
-      def decode(input)
-        return super if input.empty?
-        decoded = super
-        length = decoded.byteslice(0, 1).unpack("C")[0]
-        if (1<<7 & length).zero? # up to 127 bytes
-          decoded = decoded.byteslice(1, length) # extract payload
-
-        else # larger input
-          length = decoded.byteslice(1, 8).unpack("NN")
-                     .inject(0) { |sum, i| (sum << 32) + i }
-          decoded = decoded.byteslice(9, length) # extract payload
-        end
-        raise ArgumentError, "input truncated" if decoded.bytesize < length
-        return decoded
-      end
-    end
   end
 end

data/lib/cztop/z85/padded.rb

@@ -0,0 +1,98 @@
+# Z85 with simple padding. This allows you to {#encode} input of any
+# length.
+#
+# = Padding Scheme
+#
+# If the data to be encoded is empty (0 bytes), it is encoded to the empty
+# string, just like in Z85.
+#
+# Otherwise, a small padding sequence of 1 to 4 (identical) bytes is
+# appended to the binary data. Its last byte denotes the number of padding
+# bytes.  This padding is done even if the length of the binary input is
+# a multiple of 4 bytes.  This is similar to PKCS#7 padding.
+#
+#   +----------------------------------------+------------+
+#   |                 binary data            |   padding  |
+#   |           any number of bytes          |  1-4 bytes |
+#   +----------------------------------------+------------+
+#
+# The resulting blob is encoded using {CZTop::Z85#encode}.
+#
+# When decoding, {CZTop::Z85#decode} does the inverse. After decoding, it
+# checks the last byte to determine the number of bytes of padding used,
+# and chops those off.
+#
+# @note Warning: Z85 doesn't have a standardized padding procedure. So
+#   other implementations won't automatically recognize and chop off the
+#   padding. Only use this if you really need padding, like when you can't
+#   guarantee the input for {#encode} is always a multiple of 4 bytes.
+#
+# @see https://en.wikipedia.org/wiki/Padding_(cryptography)#PKCS7
+class CZTop::Z85::Padded < CZTop::Z85
+  class << self
+    # Same as {Z85::Padded#encode}, but without the need to create an
+    # instance first.
+    #
+    # @param input [String] possibly binary input data
+    # @return [String] Z85 encoded data as ASCII string, including encoded
+    #   length and padding
+    # @raise [SystemCallError] if this fails
+    def encode(input)
+      default.encode(input)
+    end
+
+    # Same as {Z85::Padded#decode}, but without the need to create an
+    # instance first.
+    #
+    # @param input [String] Z85 encoded data (including padding, or empty
+    #   string)
+    # @return [String] original data as binary string
+    # @raise [SystemCallError] if this fails
+    def decode(input)
+      default.decode(input)
+    end
+
+    private
+
+    # Default instance of {Z85::Padded}.
+    # @return [Z85::Padded] memoized default instance
+    def default
+      @default ||= CZTop::Z85::Padded.new
+    end
+  end
+
+  # Encododes to Z85, with padding if needed.
+  #
+  # @param input [String] possibly binary input data
+  # @return [String] Z85 encoded data as ASCII string, including padding
+  # @raise [SystemCallError] if this fails
+  def encode(input)
+    return super if input.empty?
+
+    padding_bytes = 4 - (input.bytesize % 4)
+
+    # if 0, make it 4. we MUST append padding.
+    padding_bytes = 4 if padding_bytes == 0
+
+    # generate and append padding
+    padding = [padding_bytes].pack("C") * padding_bytes
+
+    super("#{input}#{padding}")
+  end
+
+  # Decodes from Z85 with padding.
+  #
+  # @param input [String] Z85 encoded data (including padding, or empty
+  #   string)
+  # @return [String] original data as binary string
+  # @raise [SystemCallError] if this fails
+  def decode(input)
+    return super if input.empty?
+    decoded = super
+
+    # last byte contains number of padding bytes
+    padding_bytes = decoded.byteslice(-1).ord
+
+    decoded.byteslice( 0 ... -padding_bytes )
+  end
+end

data/lib/cztop/z85/pipe.rb

@@ -0,0 +1,178 @@
+# Can be used if you want to encode or decode data from one IO to another.
+# It'll do so until it hits EOF in the source IO.
+class CZTop::Z85::Pipe
+  # @param source [IO] where to read data
+  # @param sink [IO] where to write data
+  # @param strategy [Strategy] algorithm to use (pass the class itself,
+  #   not an instance)
+  def initialize(source, sink, strategy: Strategy::Parallel)
+    @source, @sink = source, sink
+    @strategy = strategy
+    @bin_bytes = 0 # processed binary data (non-Z85)
+  end
+
+  # @return [Integer] size of chunks read when encoding
+  ENCODE_READ_SZ = (32 * 2**10) # 32 KiB (for full chunks read)
+
+  # @return [Integer] size of chunks read when decoding
+  DECODE_READ_SZ = ENCODE_READ_SZ / 4 * 5
+
+  # Encodes data from source and writes Z85 data to sink. This is done
+  # until EOF is hit on the source.
+  #
+  # @return [Integer] number of bytes read (binary data)
+  def encode
+    padded = false
+    @strategy.new(@source, @sink, ENCODE_READ_SZ) do |chunk, prev_chunk|
+      @bin_bytes += chunk.bytesize if chunk
+      if prev_chunk && chunk
+        CZTop::Z85.encode(prev_chunk)
+      elsif prev_chunk && chunk.nil? # last chunk
+        CZTop::Z85::Padded.encode(prev_chunk)
+      elsif prev_chunk.nil? && chunk.nil?
+        CZTop::Z85.encode("") # empty input
+      else
+        "" # very first chunk. don't encode anything yet...
+      end
+    end.execute
+    return @bin_bytes
+  end
+
+  # Decodes Z85 data from source and writes decoded data to sink. This is
+  # done until EOF is hit on the source.
+  #
+  # @return [Integer] number of bytes written (binary data)
+  def decode
+    @strategy.new(@source, @sink, DECODE_READ_SZ) do |chunk, prev_chunk|
+      if prev_chunk && chunk
+        CZTop::Z85.decode(prev_chunk)
+      elsif prev_chunk && chunk.nil?
+        CZTop::Z85::Padded.decode(prev_chunk)
+      elsif prev_chunk.nil? && chunk.nil?
+        CZTop::Z85.decode("") # empty input
+      else
+        "" # very first chunk. don't decode anything yet...
+      end
+    end.execute
+    return @bin_bytes
+  end
+
+  # @abstract
+  # Different encoding/decoding strategies (algorithms).
+  #
+  # This is mainly just for me to practice the GoF Strategy Pattern.
+  class Strategy
+    # @param source [IO] the source
+    # @param sink [IO] the sink
+    # @param read_sz [Integer] chunk size when reading from source
+    # @param xcode [Proc] block to encode or decode data
+    # @yieldparam chunk [String, nil] current chunk (or +nil+ after the
+    #   last one)
+    # @yieldparam prev_chunk [String, nil] previous chunk (or +nil+ for
+    #   the first time)
+    # @yieldreturn [String] encoded/decoded chunk to write to sink
+    def initialize(source, sink, read_sz, &xcode)
+      @source = source
+      @sink = sink
+      @read_sz = read_sz
+      @xcode = xcode
+    end
+
+    # @abstract
+    # Runs the algorithm.
+    # @raise [void]
+    def execute() raise NotImplementedError end
+
+    # A single thread that is either reading input, encoding/decoding, or
+    # writing output.
+    class Sequential < Strategy
+      # Runs the algorithm.
+      # @raise [void]
+      def execute
+        previous_chunk = nil
+        while true
+          chunk = @source.read(@read_sz)
+          @sink << @xcode.(chunk, previous_chunk)
+          break if chunk.nil?
+          previous_chunk = chunk
+        end
+      end
+    end
+
+    # Uses three threads:
+    #
+    # 1. reads from source
+    # 2. encodes/decodes
+    # 3. thread that writes to sink
+    #
+    # This might give a performance increase on truly parallel
+    # platforms such as Rubinius and JRuby (and multiple CPU cores).
+    #
+    class Parallel < Strategy
+      # Initializes the 2 sized queues used.
+      def initialize(*)
+        super
+        # @source
+        # |
+        # V
+        @source_queue = SizedQueue.new(20) # limit memory usage
+        # |
+        # V
+        # xcode
+        # |
+        # V
+        @sink_queue   = SizedQueue.new(20) # limit memory usage
+        # |
+        # V
+        # @sink
+      end
+
+      # Runs the algorithm.
+      # @raise [void]
+      def execute
+        Thread.new { read }
+        Thread.new { xcode }
+        write
+      end
+
+      private
+
+      # Reads all chunks and pushes them into the source queue. Then
+      # pushes a +nil+ into the queue.
+      # @return [void]
+      def read
+        while chunk = @source.read(@read_sz)
+          @source_queue << chunk
+        end
+        @source_queue << nil
+      end
+
+      # Pops all chunks from the source queue, encodes or decodes them,
+      # and pushes the result into the sink queue. Then pushes a +nil+
+      # into the queue.
+      # @return [void]
+      def xcode
+        # Encode all but the last chunk with pure Z85.
+        previous_chunk = nil
+        while true
+          chunk = @source_queue.pop
+
+          # call @xcode for the trailing nil-chunk as well
+          @sink_queue << @xcode.(chunk, previous_chunk)
+
+          break if chunk.nil?
+          previous_chunk = chunk
+        end
+        @sink_queue << nil
+      end
+
+      # Pops all chunks from the sink queue and writes them to the sink.
+      # @return [void]
+      def write
+        while chunk = @sink_queue.pop
+          @sink << chunk
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cztop
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Patrik Wenger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-23 00:00:00.000000000 Z
+date: 2016-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: czmq-ffi-gen
@@ -209,7 +209,9 @@ dependencies:
 description: 
 email:
 - paddor@gmail.com
-executables: []
+executables:
+- z85decode
+- z85encode
 extensions: []
 extra_rdoc_files: []
 files:
@@ -241,6 +243,8 @@ files:
 - examples/taxi_system/generate_keys.rb
 - examples/taxi_system/start_broker.sh
 - examples/taxi_system/start_clients.sh
+- exe/z85decode
+- exe/z85encode
 - lib/cztop.rb
 - lib/cztop/actor.rb
 - lib/cztop/authenticator.rb
@@ -263,6 +267,8 @@ files:
 - lib/cztop/socket/types.rb
 - lib/cztop/version.rb
 - lib/cztop/z85.rb
+- lib/cztop/z85/padded.rb
+- lib/cztop/z85/pipe.rb
 - lib/cztop/zsock_options.rb
 - perf/README.md
 - perf/inproc_lat.rb