msgpack 0.6.0pre1-x64-mingw32

data/bench/pack_log_long.rb

@@ -0,0 +1,65 @@
+# viiite report --regroup bench,threads bench/pack_log_long.rb
+
+require 'viiite'
+require 'msgpack'
+
+data_plain = { 'message' => '127.0.0.1 - - [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 "http://www.example.com/start.html" "Mozilla/4.08 [en] (Win98; I ;Nav)"' }
+data_structure = {
+  'remote_host' => '127.0.0.1',
+  'remote_user' => '-',
+  'date' => '10/Oct/2000:13:55:36 -0700',
+  'request' => 'GET /apache_pb.gif HTTP/1.0',
+  'method' => 'GET',
+  'path' => '/apache_pb.gif',
+  'protocol' => 'HTTP/1.0',
+  'status' => 200,
+  'bytes' => 2326,
+  'referer' => 'http://www.example.com/start.html',
+  'agent' => 'Mozilla/4.08 [en] (Win98; I ;Nav)',
+}
+
+seconds = 3600 # 1 hour
+
+Viiite.bench do |b|
+  b.range_over([1, 2, 4, 8, 16], :threads) do |threads|
+    b.report(:plain) do
+      ths = []
+      end_at = Time.now + seconds
+      threads.times do
+        t = Thread.new do
+          packs = 0
+          while Time.now < end_at
+            10000.times do
+              MessagePack.pack(data_plain)
+            end
+            packs += 10000
+          end
+          packs
+        end
+        ths.push t
+      end
+      sum = ths.reduce(0){|r,t| r + t.value }
+      puts "MessagePack.pack, plain, #{threads} threads: #{sum} times, #{sum / seconds} times/second."
+    end
+
+    b.report(:structure) do
+      ths = []
+      end_at = Time.now + seconds
+      threads.times do
+        t = Thread.new do
+          packs = 0
+          while Time.now < end_at
+            10000.times do
+              MessagePack.pack(data_structure)
+            end
+            packs += 10000
+          end
+          packs
+        end
+        ths.push t
+      end
+      sum = ths.reduce(0){|r,t| r + t.value }
+      puts "MessagePack.pack, structured, #{threads} threads: #{sum} times, #{sum / seconds} times/second."
+    end
+  end
+end

data/bench/run.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# prerequisites
+# $ rbenv shell 2.2.1 (or jruby-x.x.x or ...)
+# $ rake install
+
+echo "pack"
+viiite report --regroup bench,runs bench/pack.rb 
+echo "unpack"
+viiite report --regroup bench,runs bench/unpack.rb 
+echo "pack log"
+viiite report --regroup bench,runs bench/pack_log.rb 
+echo "unpack log"
+viiite report --regroup bench,runs bench/unpack_log.rb 

data/bench/run_long.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+
+# prerequisites
+# $ sudo apt-get install sysstat
+# $ rbenv shell 2.2.1 (or jruby-x.x.x or ...)
+# $ rake install
+
+# 60 * 600 : 60*60 * 5[threads] * 2[bench]
+
+ruby -v
+
+echo "pack log long"
+viiite report --regroup bench,threads bench/pack_log_long.rb &
+sar -o pack_log_long.sar -r 60 600 > /dev/null 2>&1 &
+
+declare -i i=0
+while [ $i -lt 600 ]; do
+    ps auxww | grep ruby | grep -v grep | awk '{print $5,$6;}' >> pack_log_long.mem.txt
+    i=i+1
+    sleep 60
+done
+
+sleep 120 # cool down
+
+echo "unpack log long"
+viiite report --regroup bench,threads bench/unpack_log_long.rb &
+sar -o unpack_log_long.sar -r 60 600 > /dev/null 2>&1 &
+
+i=0
+while [ $i -lt 600 ]; do
+    ps auxww | grep ruby | grep -v grep | awk '{print $5,$6;}' >> pack_log_long.mem.txt
+    i=i+1
+    sleep 60
+done
+

data/bench/unpack.rb

@@ -0,0 +1,21 @@
+require 'viiite'
+require 'msgpack'
+
+data = MessagePack.pack(:hello => 'world', :nested => ['structure', {:value => 42}])
+
+Viiite.bench do |b|
+  b.range_over([10_000, 100_000, 1000_000], :runs) do |runs|
+    b.report(:strings) do
+      runs.times do
+        MessagePack.unpack(data)
+      end
+    end
+
+    b.report(:symbols) do
+      options = {:symbolize_keys => true}
+      runs.times do
+        MessagePack.unpack(data, options)
+      end
+    end
+  end
+end

data/bench/unpack_log.rb

@@ -0,0 +1,34 @@
+require 'viiite'
+require 'msgpack'
+
+data_plain = MessagePack.pack({ 'message' => '127.0.0.1 - - [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 "http://www.example.com/start.html" "Mozilla/4.08 [en] (Win98; I ;Nav)"' })
+
+data_structure = MessagePack.pack({
+  'remote_host' => '127.0.0.1',
+  'remote_user' => '-',
+  'date' => '10/Oct/2000:13:55:36 -0700',
+  'request' => 'GET /apache_pb.gif HTTP/1.0',
+  'method' => 'GET',
+  'path' => '/apache_pb.gif',
+  'protocol' => 'HTTP/1.0',
+  'status' => 200,
+  'bytes' => 2326,
+  'referer' => 'http://www.example.com/start.html',
+  'agent' => 'Mozilla/4.08 [en] (Win98; I ;Nav)',
+})
+
+Viiite.bench do |b|
+  b.range_over([10_000, 100_000, 1000_000], :runs) do |runs|
+    b.report(:plain) do
+      runs.times do
+        MessagePack.unpack(data_plain)
+      end
+    end
+
+    b.report(:structure) do
+      runs.times do
+        MessagePack.unpack(data_structure)
+      end
+    end
+  end
+end

data/bench/unpack_log_long.rb

@@ -0,0 +1,67 @@
+# viiite report --regroup bench,threads bench/pack_log_long.rb
+
+require 'viiite'
+require 'msgpack'
+
+data_plain = MessagePack.pack({
+    'message' => '127.0.0.1 - - [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 "http://www.example.com/start.html" "Mozilla/4.08 [en] (Win98; I ;Nav)"'
+})
+data_structure = MessagePack.pack({
+  'remote_host' => '127.0.0.1',
+  'remote_user' => '-',
+  'date' => '10/Oct/2000:13:55:36 -0700',
+  'request' => 'GET /apache_pb.gif HTTP/1.0',
+  'method' => 'GET',
+  'path' => '/apache_pb.gif',
+  'protocol' => 'HTTP/1.0',
+  'status' => 200,
+  'bytes' => 2326,
+  'referer' => 'http://www.example.com/start.html',
+  'agent' => 'Mozilla/4.08 [en] (Win98; I ;Nav)',
+})
+
+seconds = 3600 # 1 hour
+
+Viiite.bench do |b|
+  b.range_over([1, 2, 4, 8, 16], :threads) do |threads|
+    b.report(:plain) do
+      ths = []
+      end_at = Time.now + seconds
+      threads.times do
+        t = Thread.new do
+          packs = 0
+          while Time.now < end_at
+            10000.times do
+              MessagePack.unpack(data_plain)
+            end
+            packs += 10000
+          end
+          packs
+        end
+        ths.push t
+      end
+      sum = ths.reduce(0){|r,t| r + t.value }
+      puts "MessagePack.unpack, plain, #{threads} threads: #{sum} times, #{sum / seconds} times/second."
+    end
+
+    b.report(:structure) do
+      ths = []
+      end_at = Time.now + seconds
+      threads.times do
+        t = Thread.new do
+          packs = 0
+          while Time.now < end_at
+            10000.times do
+              MessagePack.unpack(data_structure)
+            end
+            packs += 10000
+          end
+          packs
+        end
+        ths.push t
+      end
+      sum = ths.reduce(0){|r,t| r + t.value }
+      puts "MessagePack.unpack, structured, #{threads} threads: #{sum} times, #{sum / seconds} times/second."
+    end
+  end
+end

data/cross-build.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+cd /home/ubuntu/msgpack-ruby
+git remote add onetime $MSGPACK_REPO
+git checkout master
+git pull onetime $BUILD_BRANCH
+git reset --hard $BUILD_POSITION
+bundle install
+bundle rake cross native gem

data/doclib/msgpack/buffer.rb

@@ -0,0 +1,193 @@
+module MessagePack
+
+  class Buffer
+    #
+    # Creates a MessagePack::Buffer instance.
+    #
+    # @overload initialize(options={})
+    #   @param options [Hash]
+    #
+    # @overload initialize(io, options={})
+    #   @param io [IO]
+    #   @param options [Hash]
+    #   This buffer writes written data into the IO when it is filled.
+    #   This buffer reads data from the IO when it is empty.
+    #
+    # _io_ must respond to readpartial(length, [,string]) or read(string) method and
+    # write(string) or append(string) method.
+    #
+    # Supported options:
+    #
+    # * *:io_buffer_size* buffer size to read data from the internal IO. (default: 32768)
+    # * *:read_reference_threshold* the threshold size to enable zero-copy deserialize optimization. Read strings longer than this threshold will refer the original string instead of copying it. (default: 256) (supported in MRI only)
+    # * *:write_reference_threshold* the threshold size to enable zero-copy serialize optimization. The buffer refers written strings longer than this threshold instead of copying it. (default: 524288) (supported in MRI only)
+    #
+    def initialize(*args)
+    end
+
+    #
+    # Makes the buffer empty
+    #
+    # @return nil
+    #
+    def clear
+    end
+
+    #
+    # Returns byte size of the buffer.
+    #
+    # @return nil
+    #
+    def size
+    end
+
+    #
+    # Returns _true_ if the buffer is empty.
+    # This method is slightly faster than _size_.
+    #
+    # @return [Boolean]
+    #
+    def empty?
+    end
+
+    #
+    # Appends the given data to the buffer.
+    #
+    # @param data [String]
+    # @return [Integer] byte size written
+    #
+    def write(data)
+    end
+
+    #
+    # Appends the given data to the buffer.
+    #
+    # @param data [String]
+    # @return [Buffer] self
+    #
+    def <<(data)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer and returns consumed data.
+    # If the size of the buffer is less than _n_, it reads all of data in the buffer.
+    #
+    # If _n_ is 0, it does nothing and returns an empty string.
+    # If the optional _buffer_ argument is given, the content of the string will be replaced with the consumed data.
+    #
+    # @overload read
+    #
+    # @overload read(n)
+    #   @param n [Integer] bytes to read
+    #
+    # @overload read(n, buffer)
+    #   @param n [Integer] bytes to read
+    #   @param buffer [String] buffer to read into
+    #
+    # @return [String]
+    #
+    def read(n)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer and returns consumed data.
+    # If the size of the buffer is less than _n_, it does nothing and raises EOFError.
+    #
+    # If _n_ is 0, it does nothing and returns an empty string.
+    # If the optional _buffer_ argument is given, the content of the string will be replaced with the consumed data.
+    #
+    # @overload read_all
+    #
+    # @overload read_all(n)
+    #   @param n [Integer] bytes to read
+    #
+    # @overload read_all(n, buffer)
+    #   @param n [Integer] bytes to read
+    #   @param buffer [String] buffer to read into
+    #
+    # @return [String]
+    #
+    def read_all(n, buffer=nil)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer.
+    # If the size of the buffer is less than _n_, it skips all of data in the buffer and returns integer less than _n_.
+    #
+    # If _n_ is 0, it does nothing and returns _0_.
+    #
+    # @param n [Integer] byte size to skip
+    # @return [Integer] byte size actually skipped
+    #
+    def skip(n)
+    end
+
+    #
+    # Consumes _n_ bytes from the head of the buffer.
+    # If the size of the buffer is less than _n_, it does nothing and raises EOFError.
+    # If _n_ is 0, it does nothing.
+    #
+    # @param n [Integer] byte size to skip
+    # @return [Buffer] self
+    #
+    def skip_all(n)
+    end
+
+    #
+    # Returns all data in the buffer as a string.
+    # Destructive update to the returned string does NOT effect the buffer.
+    #
+    # @return [String]
+    #
+    def to_str
+    end
+
+    #
+    # Returns content of the buffer as an array of strings.
+    #
+    # This method is sometimes faster than to_s because the internal
+    # structure of the buffer is a queue of buffer chunks.
+    #
+    # @return [Array] array of strings
+    #
+    def to_a
+    end
+
+    #
+    # Internal io
+    #
+    # @return IO
+    #
+    attr_reader :io
+
+    #
+    # Flushes data in the internal buffer to the internal IO.
+    # If internal IO is not set, it does nothing.
+    #
+    # @return [Buffer] self
+    #
+    def flush
+    end
+
+    #
+    # Closes internal IO if its set.
+    # If internal IO is not set, it does nothing
+    #
+    # @return nil
+    #
+    def close
+    end
+
+    #
+    # Writes all of data in the internal buffer into the given IO.
+    # This method consumes and removes data from the internal buffer.
+    # _io_ must respond to write(data) method.
+    #
+    # @param io [IO]
+    # @return [Integer] byte size of written data
+    #
+    def write_to(io)
+    end
+  end
+
+end

data/doclib/msgpack/core_ext.rb

@@ -0,0 +1,101 @@
+
+class NilClass
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class TrueClass
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class FalseClass
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class Fixnum < Integer
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class Bignum < Integer
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class Float < Numeric
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class String
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class Array
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class Hash
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+
+class Symbol
+  #
+  # Same as MessagePack.to_msgpack(self[, io]).
+  #
+  # @return [String] serialized data
+  #
+  def to_msgpack(io=nil)
+  end
+end
+

data/doclib/msgpack/error.rb

@@ -0,0 +1,14 @@
+module MessagePack
+
+  class UnpackError < StandardError
+  end
+
+  class MalformedFormatError < UnpackError
+  end
+
+  class StackError < UnpackError
+  end
+
+  class TypeError < StandardError
+  end
+end

data/doclib/msgpack/packer.rb

@@ -0,0 +1,134 @@
+module MessagePack
+
+  #
+  # MessagePack::Packer is a class to serialize objects.
+  #
+  class Packer
+    #
+    # Creates a MessagePack::Packer instance.
+    # See Buffer#initialize for supported options.
+    #
+    # @overload initialize(options={})
+    #   @param options [Hash]
+    #
+    # @overload initialize(io, options={})
+    #   @param io [IO]
+    #   @param options [Hash]
+    #   This packer writes serialzied objects into the IO when the internal buffer is filled.
+    #   _io_ must respond to write(string) or append(string) method.
+    #
+    # See also Buffer#initialize for options.
+    #
+    def initialize(*args)
+    end
+
+    #
+    # Internal buffer
+    #
+    # @return MessagePack::Buffer
+    #
+    attr_reader :buffer
+
+    #
+    # Serializes an object into internal buffer, and flushes to io if necessary.
+    #
+    # If it could not serialize the object, it raises
+    # NoMethodError: undefined method `to_msgpack' for #<the_object>.
+    #
+    # @param obj [Object] object to serialize
+    # @return [Packer] self
+    #
+    def write(obj)
+    end
+
+    alias pack write
+
+    #
+    # Serializes a nil object. Same as write(nil).
+    #
+    def write_nil
+    end
+
+    #
+    # Write a header of an array whose size is _n_.
+    # For example, write_array_header(1).write(true) is same as write([ true ]).
+    #
+    # @return [Packer] self
+    #
+    def write_array_header(n)
+    end
+
+    #
+    # Write a header of an map whose size is _n_.
+    # For example, write_map_header(1).write('key').write(true) is same as write('key'=>true).
+    #
+    # @return [Packer] self
+    #
+    def write_map_header(n)
+    end
+
+    #
+    # Flushes data in the internal buffer to the internal IO. Same as _buffer.flush.
+    # If internal IO is not set, it does nothing.
+    #
+    # @return [Packer] self
+    #
+    def flush
+    end
+
+    #
+    # Makes the internal buffer empty. Same as _buffer.clear_.
+    #
+    # @return nil
+    #
+    def clear
+    end
+
+    #
+    # Returns size of the internal buffer. Same as buffer.size.
+    #
+    # @return [Integer]
+    #
+    def size
+    end
+
+    #
+    # Returns _true_ if the internal buffer is empty. Same as buffer.empty?.
+    # This method is slightly faster than _size_.
+    #
+    # @return [Boolean]
+    #
+    def empty?
+    end
+
+    #
+    # Returns all data in the buffer as a string. Same as buffer.to_str.
+    #
+    # @return [String]
+    #
+    def to_str
+    end
+
+    alias to_s to_str
+
+    #
+    # Returns content of the internal buffer as an array of strings. Same as buffer.to_a.
+    # This method is faster than _to_str_.
+    #
+    # @return [Array] array of strings
+    #
+    def to_a
+    end
+
+    #
+    # Writes all of data in the internal buffer into the given IO. Same as buffer.write_to(io).
+    # This method consumes and removes data from the internal buffer.
+    # _io_ must respond to write(data) method.
+    #
+    # @param io [IO]
+    # @return [Integer] byte size of written data
+    #
+    def write_to(io)
+    end
+  end
+end