byte_buffer 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjExMjYwYzZjYjdhNGU2M2NhNWJlM2U1MjBjNGRkODRkMDcwNDgzMg==
+  data.tar.gz: !binary |-
+    MjM4NTRhMWVlOGY3NTNlNmYwNTkwNzU2YThkNWRiMGJiMWFlMjYwNw==
+SHA512:
+  metadata.gz: !binary |-
+    ZmFhZjhkODQyZjAzNTk0YjQxMzVjZGMyMjFhNDFkNTJkN2UxYmRkNDdjYzA3
+    NzAyMzZkMzcyYTNjMTQ0ZjA4MTA1ZDg4ODgyODllZmE3MGVlYWIzYzFhNDcx
+    MjIyNmIyYzE2MGRmNmI5NmFkY2IxMGVmYzNlYTkwNDE0NDU4Y2E=
+  data.tar.gz: !binary |-
+    MmI5YWM4OGYyYTdkYmI1YTlhODIzNTcyYzM4ODU2YjEzMzM2NGJkNGVjOTc4
+    YjM3NTY4ODEwZWU5ZDZiMjlmY2MzZWM1ZTI5ODI1ODkxMDdlNjcyN2FjNjQ5
+    MmE5M2UxZjk0NTdkNDE5ODQwZmU1Y2U4ZGVlYmUwZDk1ODk3OGM=

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/lib/byte_buffer_ext.*

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in byte_buffer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Apptopia Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# ByteBuffer
+
+Fast native implementation of binary buffer for MRI.
+
+ByteBuffer is designed to be a drop in replacement of https://github.com/iconara/ione `Ione::ByteBuffer`. It implements the same interface, extending it with support for additional numeric types and array operations.
+
+It can be used for marshalling/demarshalling of binary frame PDUs. A prime example of such use case is code for handling cassandra native protocol which can be found in `Cassandra::Protocol::CqlNativeByteBuffer` from https://github.com/apptopia/ruby-driver/tree/perf-tweaks
+
+## Benchmarks
+
+As hinted by the description above, main motivation for creating this gem is pursuit of performance. `ByteBuffer::Buffer` is designed to be faster than or even with implementations based on ruby strings and `String#pack`. Here are results of benchmarks taken with ruby 1.9.3 on Mac OS X:
+
+```
+  $ ./bin/benchmarks | grep slower
+  bm_allocation - Ione::ByteBuffer:  1317389.4 i/s - 1.14x slower
+  bm_churn - Ione::ByteBuffer space reuse, read/write interleaved:     6894.2 i/s - 3.32x slower
+  bm_append_big - ByteBuffer::Buffer big strings:     7546.2 i/s - 1.03x slower
+  bm_append_small - Ione::ByteBuffer small strings:    21482.4 i/s - 2.57x slower
+  bm_append_int - Cassandra::Protocol::CqlByteBuffer:    11363.9 i/s - 10.46x slower
+  bm_append_long - Cassandra::Protocol::CqlByteBuffer:     5554.0 i/s - 17.85x slower
+  bm_append_double - Cassandra::Protocol::CqlByteBuffer:     8569.1 i/s - 11.54x slower
+  bm_read - Cassandra::Protocol::CqlByteBuffer:    26853.6 i/s - 2.28x slower
+  bm_read_int - Cassandra::Protocol::CqlByteBuffer:    17687.1 i/s - 5.64x slower
+  bm_read_long - Cassandra::Protocol::CqlByteBuffer:    12658.3 i/s - 4.32x slower
+  bm_read_double - Cassandra::Protocol::CqlByteBuffer:    15554.9 i/s - 3.94x slower
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'byte_buffer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install byte_buffer
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, install dependencies by running:
+
+```
+  $ bundle install
+```
+
+Native module can be compiled by running:
+
+```
+  $ bundle exec rake compile
+```
+
+This should be enough to run tests successfully with:
+
+```
+  $ bundle exec rspec
+```
+
+Also, there's a script which runs benchmarks against `Ione::ByteBuffer` and `Cassandra::Protocol::CqlNativeByteBuffer`, here's how to run it:
+
+```
+  $ ./bin/benchmarks
+```

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('byte_buffer_ext')

data/bin/benchmarks

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "byte_buffer"
+require "benchmark/ips"
+require "ione"
+require "cassandra"
+
+def bm_allocation(buffer_class)
+  buffer_class.new
+end
+
+def bm_churn(buffer_class)
+  b = buffer_class.new
+  s = 'X' * 200
+  100.times {
+    b.append(s)
+    b.read(s.size)
+  }
+end
+
+def bm_append_big(buffer_class)
+  buffer = buffer_class.new
+  100.times {
+    buffer.append("HELLO" * 100)
+  }
+  buffer.to_str
+end
+
+def bm_append_small(buffer_class)
+  buffer = buffer_class.new
+  100.times {
+    buffer.append("HELLO")
+  }
+  buffer.to_str
+end
+
+def bm_append_int(buffer_class)
+  buffer = buffer_class.new
+  100.times {
+    buffer.append_int(101)
+  }
+  buffer.to_str
+end
+
+def bm_append_long(buffer_class)
+  buffer = buffer_class.new
+  100.times {
+    buffer.append_long(101)
+  }
+  buffer.to_str
+end
+
+def bm_append_double(buffer_class)
+  buffer = buffer_class.new
+  100.times {
+    buffer.append_double(101.101)
+  }
+  buffer.to_str
+end
+
+def bm_read(buffer_class)
+  buffer = buffer_class.new("ABCD" * 100)
+  100.times {buffer.read(4)}
+end
+
+def bm_read_int(buffer_class)
+  buffer = buffer_class.new("ABCD" * 100)
+  100.times {buffer.read_int}
+end
+
+def bm_read_long(buffer_class)
+  buffer = buffer_class.new("ABCDEFGH" * 100)
+  100.times {buffer.read_long}
+end
+
+def bm_read_double(buffer_class)
+  buffer = buffer_class.new("ABCDEFGH" * 100)
+  100.times {buffer.read_double}
+end
+
+def run_benchmark(method, other_klass = Cassandra::Protocol::CqlByteBuffer, name_suffix = nil)
+  name_a = ["#{method} - ByteBuffer::Buffer", name_suffix].compact.join(' ')
+  name_b = ["#{method} - #{other_klass}", name_suffix].compact.join(' ')
+
+  Benchmark.ips do |x|
+    x.report(name_a) {send(method, ByteBuffer::Buffer)}
+    x.report(name_b) {send(method, other_klass)}
+    x.compare!
+  end
+
+  puts "\n\n"
+end
+
+run_benchmark(:bm_allocation, Ione::ByteBuffer)
+run_benchmark(:bm_churn, Ione::ByteBuffer, 'space reuse, read/write interleaved')
+run_benchmark(:bm_append_big, Ione::ByteBuffer, 'big strings')
+run_benchmark(:bm_append_small, Ione::ByteBuffer, 'small strings')
+run_benchmark(:bm_append_int)
+run_benchmark(:bm_append_long)
+run_benchmark(:bm_append_double)
+run_benchmark(:bm_read)
+run_benchmark(:bm_read_int)
+run_benchmark(:bm_read_long)
+run_benchmark(:bm_read_double)

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "byte_buffer"
+
+require "pry"
+Pry.start

data/byte_buffer.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+require "#{lib}/byte_buffer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "byte_buffer"
+  spec.version       = ByteBuffer::VERSION
+  spec.authors       = ["Serge Balyuk"]
+  spec.email         = ["sergeb@apptopia.com", "bgipsy@gmail.com"]
+  spec.homepage      = "http://github.com/apptopia/byte_buffer"
+  spec.license       = "MIT"
+
+  spec.summary       = %q{
+    Fast native implementation of byte buffer intended to be used as part
+    of frame based protocol PDU handling code. Can serve as drop in replacement for Ione::ByteBuffer
+    and used in DataStax Cassandra Ruby driver.
+  }
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/byte_buffer_ext/extconf.rb"]
+
+  spec.add_development_dependency "bundler",            "~> 1.9"
+  spec.add_development_dependency "rake",               "~> 10.0"
+  spec.add_development_dependency "pry",                "~> 0.10.1"
+  spec.add_development_dependency "rspec",              "~> 3.2.0"
+  spec.add_development_dependency "rake-compiler",      "~> 0.9.5"
+  spec.add_development_dependency "benchmark-ips",      "~> 2.2.0"
+  spec.add_development_dependency "ione",               "~> 1.2.0"
+  spec.add_development_dependency "cassandra-driver",   "~> 2.1.3"
+end

data/ext/byte_buffer_ext/byte_buffer.c

@@ -0,0 +1,671 @@
+/*
+ * Copyright (C) 2015 Apptopia Inc.
+ * You may redistribute this under the terms of the MIT license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+#include <string.h>
+#include <inttypes.h>
+#include "portable_endian.h"
+
+#define BYTE_BUFFER_EMBEDDED_SIZE 512
+
+static VALUE rb_byte_buffer_allocate(VALUE klass);
+static VALUE rb_byte_buffer_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE rb_byte_buffer_capacity(VALUE self);
+static VALUE rb_byte_buffer_length(VALUE self);
+static VALUE rb_byte_buffer_append(VALUE self, VALUE str);
+static VALUE rb_byte_buffer_append_long(VALUE self, VALUE i);
+static VALUE rb_byte_buffer_append_int(VALUE self, VALUE i);
+static VALUE rb_byte_buffer_append_byte(VALUE self, VALUE i);
+static VALUE rb_byte_buffer_append_short(VALUE self, VALUE i);
+static VALUE rb_byte_buffer_append_double(VALUE self, VALUE i);
+static VALUE rb_byte_buffer_append_float(VALUE self, VALUE i);
+static VALUE rb_byte_buffer_append_byte_array(VALUE self, VALUE ary);
+static VALUE rb_byte_buffer_discard(VALUE self, VALUE n);
+static VALUE rb_byte_buffer_read(VALUE self, VALUE n);
+static VALUE rb_byte_buffer_read_long(int argc, VALUE *argv, VALUE self);
+static VALUE rb_byte_buffer_read_int(int argc, VALUE *argv, VALUE self);
+static VALUE rb_byte_buffer_read_short(int argc, VALUE *argv, VALUE self);
+static VALUE rb_byte_buffer_read_byte(int argc, VALUE *argv, VALUE self);
+static VALUE rb_byte_buffer_read_double(VALUE self);
+static VALUE rb_byte_buffer_read_float(VALUE self);
+static VALUE rb_byte_buffer_read_byte_array(int argc, VALUE *argv, VALUE self);
+static VALUE rb_byte_buffer_index(int argc, VALUE *argv, VALUE self);
+static VALUE rb_byte_buffer_update(VALUE self, VALUE location, VALUE bytes);
+static VALUE rb_byte_buffer_to_str(VALUE self);
+static VALUE rb_byte_buffer_inspect(VALUE self);
+
+static void byte_buffer_free(void *ptr);
+static size_t byte_buffer_memsize(const void *ptr);
+
+static const rb_data_type_t buffer_data_type = {
+    "byte_buffer/buffer",
+    {NULL, byte_buffer_free, byte_buffer_memsize}
+};
+
+typedef struct {
+    size_t size;
+    size_t write_pos;
+    size_t read_pos;
+    char   embedded_buffer[BYTE_BUFFER_EMBEDDED_SIZE];
+    char   *b_ptr;
+} buffer_t;
+
+#define READ_PTR(buffer_ptr) \
+    (buffer_ptr->b_ptr + buffer_ptr->read_pos)
+
+#define READ_SIZE(buffer_ptr) \
+    (buffer_ptr->write_pos - buffer_ptr->read_pos)
+
+#define WRITE_PTR(buffer_ptr) \
+    (buffer_ptr->b_ptr + buffer_ptr->write_pos)
+
+#define ENSURE_WRITE_CAPACITY(buffer_ptr,len) \
+    { if (buffer_ptr->write_pos + len > buffer_ptr->size) grow_buffer(buffer_ptr, len); }
+
+#define ENSURE_READ_CAPACITY(buffer_ptr,len) \
+    { if (buffer_ptr->read_pos + len > buffer_ptr->write_pos) \
+        rb_raise(rb_eRangeError, "%zu bytes requred, but only %zu available", (size_t)len, READ_SIZE(buffer_ptr)); }
+
+static int32_t value_to_int32(VALUE x);
+static int64_t value_to_int64(VALUE x);
+static double value_to_dbl(VALUE x);
+static void grow_buffer(buffer_t* buffer_ptr, size_t len);
+
+static VALUE rb_cBuffer = 0;
+
+void
+Init_byte_buffer_ext()
+{
+    VALUE rb_mByteBuffer;
+
+    rb_mByteBuffer  = rb_define_module("ByteBuffer");
+    rb_cBuffer      = rb_define_class_under(rb_mByteBuffer, "Buffer", rb_cObject);
+
+    rb_define_alloc_func(rb_cBuffer, rb_byte_buffer_allocate);
+    rb_define_const(rb_cBuffer, "DEFAULT_PREALLOC_SIZE", INT2FIX(BYTE_BUFFER_EMBEDDED_SIZE));
+    rb_define_method(rb_cBuffer, "initialize", rb_byte_buffer_initialize, -1);
+    rb_define_method(rb_cBuffer, "capacity", rb_byte_buffer_capacity, 0);
+    rb_define_method(rb_cBuffer, "length", rb_byte_buffer_length, 0);
+    rb_define_method(rb_cBuffer, "append", rb_byte_buffer_append, 1);
+    rb_define_method(rb_cBuffer, "append_long", rb_byte_buffer_append_long, 1);
+    rb_define_method(rb_cBuffer, "append_int", rb_byte_buffer_append_int, 1);
+    rb_define_method(rb_cBuffer, "append_byte", rb_byte_buffer_append_byte, 1);
+    rb_define_method(rb_cBuffer, "append_short", rb_byte_buffer_append_short, 1);
+    rb_define_method(rb_cBuffer, "append_double", rb_byte_buffer_append_double, 1);
+    rb_define_method(rb_cBuffer, "append_float", rb_byte_buffer_append_float, 1);
+    rb_define_method(rb_cBuffer, "append_byte_array", rb_byte_buffer_append_byte_array, 1);
+    rb_define_method(rb_cBuffer, "discard", rb_byte_buffer_discard, 1);
+    rb_define_method(rb_cBuffer, "read", rb_byte_buffer_read, 1);
+    rb_define_method(rb_cBuffer, "read_long", rb_byte_buffer_read_long, -1);
+    rb_define_method(rb_cBuffer, "read_int", rb_byte_buffer_read_int, -1);
+    rb_define_method(rb_cBuffer, "read_short", rb_byte_buffer_read_short, -1);
+    rb_define_method(rb_cBuffer, "read_byte", rb_byte_buffer_read_byte, -1);
+    rb_define_method(rb_cBuffer, "read_double", rb_byte_buffer_read_double, 0);
+    rb_define_method(rb_cBuffer, "read_float", rb_byte_buffer_read_float, 0);
+    rb_define_method(rb_cBuffer, "read_byte_array", rb_byte_buffer_read_byte_array, -1);
+    rb_define_method(rb_cBuffer, "index", rb_byte_buffer_index, -1);
+    rb_define_method(rb_cBuffer, "update", rb_byte_buffer_update, 2);
+    rb_define_method(rb_cBuffer, "to_str", rb_byte_buffer_to_str, 0);
+    rb_define_method(rb_cBuffer, "inspect", rb_byte_buffer_inspect, 0);
+}
+
+VALUE
+rb_byte_buffer_allocate(VALUE klass)
+{
+    buffer_t *b;
+    VALUE obj = TypedData_Make_Struct(klass, buffer_t, &buffer_data_type, b);
+    b->b_ptr = b->embedded_buffer;
+    b->size  = BYTE_BUFFER_EMBEDDED_SIZE;
+
+    return obj;
+}
+
+VALUE
+rb_byte_buffer_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE str, prealloc_size;
+
+    rb_scan_args(argc, argv, "02", &str, &prealloc_size);
+
+    if (!NIL_P(prealloc_size)) {
+        buffer_t *b;
+        long len;
+
+        Check_Type(prealloc_size, T_FIXNUM);
+        len = FIX2LONG(prealloc_size);
+        if (len < 0) rb_raise(rb_eRangeError, "prealloc size can't be negative");
+        TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+
+        if ((size_t)len > b->size) {
+            if (b->b_ptr != b->embedded_buffer) xfree(b->b_ptr);
+            b->b_ptr = ALLOC_N(char, len);
+            b->size = len;
+            b->read_pos = b->write_pos = 0;
+        }
+    }
+
+    if (!NIL_P(str))
+        rb_byte_buffer_append(self, str);
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_capacity(VALUE self)
+{
+    buffer_t *b;
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+
+    return UINT2NUM(b->size);
+}
+
+VALUE
+rb_byte_buffer_length(VALUE self)
+{
+    buffer_t *b;
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+
+    return UINT2NUM(READ_SIZE(b));
+}
+
+VALUE
+rb_byte_buffer_append(VALUE self, VALUE str)
+{
+    char     *c_str;
+    size_t   len;
+    buffer_t *b;
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+
+    if (CLASS_OF(str) == rb_cString) {
+        c_str = RSTRING_PTR(str);
+        len   = RSTRING_LEN(str);
+    } else if (rb_cBuffer && rb_obj_is_kind_of(str, rb_cBuffer)) {
+        buffer_t *other_b;
+        TypedData_Get_Struct(str, buffer_t, &buffer_data_type, other_b);
+        c_str = READ_PTR(other_b);
+        len   = READ_SIZE(other_b);
+    } else {
+        VALUE s = rb_funcall(str, rb_intern("to_s"), 0, 0);
+        c_str = RSTRING_PTR(s);
+        len   = RSTRING_LEN(s);
+    }
+
+    ENSURE_WRITE_CAPACITY(b, len);
+    memcpy(WRITE_PTR(b), c_str, len);
+    b->write_pos += len;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_append_long(VALUE self, VALUE i)
+{
+    buffer_t *b;
+    int64_t i64 = value_to_int64(i);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_WRITE_CAPACITY(b, 8);
+    i64 = htobe64(i64);
+    *((int64_t*)WRITE_PTR(b)) = i64;
+    b->write_pos += 8;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_append_int(VALUE self, VALUE i)
+{
+    buffer_t *b;
+    int32_t i32 = value_to_int32(i);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_WRITE_CAPACITY(b, 4);
+    i32 = htobe32(i32);
+    *((int32_t*)WRITE_PTR(b)) = i32;
+    b->write_pos += 4;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_append_byte(VALUE self, VALUE i)
+{
+    buffer_t *b;
+    int32_t i32 = value_to_int32(i);
+    int8_t i8 = (int8_t)i32;
+
+    if (i32 > 0xFF || -i32 > 0x80)
+        rb_raise(rb_eRangeError, "Number %d doesn't fit into byte", i32);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_WRITE_CAPACITY(b, 1);
+    *((int8_t*)WRITE_PTR(b)) = i8;
+    b->write_pos += 1;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_append_short(VALUE self, VALUE i)
+{
+    buffer_t *b;
+    int32_t i32 = value_to_int32(i);
+    int16_t i16 = (int16_t)i32;
+
+    if (i32 > 0xFFFF || -i32 > 0x8000)
+        rb_raise(rb_eRangeError, "Number %d doesn't fit into 2 bytes", i32);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_WRITE_CAPACITY(b, 2);
+    i16 = htobe16(i16);
+    *((int16_t*)WRITE_PTR(b)) = i16;
+    b->write_pos += 2;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_append_double(VALUE self, VALUE i)
+{
+    buffer_t *b;
+    union {double d; uint64_t i64;} ucast;
+
+    ucast.d = value_to_dbl(i);
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_WRITE_CAPACITY(b, 8);
+    ucast.i64 = htobe64(ucast.i64);
+    *(int64_t*)WRITE_PTR(b) = ucast.i64;
+    b->write_pos += 8;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_append_float(VALUE self, VALUE i)
+{
+    buffer_t *b;
+    union {float f; uint32_t i32;} ucast;
+
+    ucast.f = (float)value_to_dbl(i);
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_WRITE_CAPACITY(b, 4);
+    ucast.i32 = htobe32(ucast.i32);
+    *(int32_t*)WRITE_PTR(b) = ucast.i32;
+    b->write_pos += 4;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_append_byte_array(VALUE self, VALUE maybe_ary)
+{
+    VALUE ary = rb_check_array_type(maybe_ary);
+    VALUE *ary_ptr;
+    long len, i;
+    buffer_t *b;
+
+    if (NIL_P(ary))
+        rb_raise(rb_eTypeError, "expected Array, got %s", rb_obj_classname(maybe_ary));
+
+    len = RARRAY_LEN(ary);
+    ary_ptr = RARRAY_PTR(ary);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_WRITE_CAPACITY(b, len);
+    for (i = 0; i < RARRAY_LEN(ary); ++i) {
+        VALUE n = ary_ptr[i];
+        int32_t i32 = value_to_int32(n);
+        int8_t i8 = (int8_t)i32;
+
+        if (i32 > 0xFF || -i32 > 0x80)
+            rb_raise(rb_eRangeError, "Number %d doesn't fit into byte", i32);
+
+        ((int8_t*)WRITE_PTR(b))[i] = i8;
+    }
+
+    b->write_pos += len;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_discard(VALUE self, VALUE n)
+{
+    buffer_t *b;
+    long len;
+
+    Check_Type(n, T_FIXNUM);
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    len = FIX2LONG(n);
+    if (len < 0) rb_raise(rb_eRangeError, "Cannot discard a negative number of bytes");
+    ENSURE_READ_CAPACITY(b, len);
+    b->read_pos += len;
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_read(VALUE self, VALUE n)
+{
+    buffer_t *b;
+    long len;
+    VALUE str;
+
+    Check_Type(n, T_FIXNUM);
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    len = FIX2LONG(n);
+    if (len < 0) rb_raise(rb_eRangeError, "Cannot read a negative number of bytes");
+    ENSURE_READ_CAPACITY(b, len);
+    str = rb_str_new(READ_PTR(b), len);
+    b->read_pos += len;
+
+    return str;
+}
+
+VALUE
+rb_byte_buffer_read_long(int argc, VALUE *argv, VALUE self)
+{
+    VALUE f_signed;
+    buffer_t *b;
+    uint64_t i64;
+
+    rb_scan_args(argc, argv, "01", &f_signed);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_READ_CAPACITY(b, 8);
+    i64 = be64toh(*((uint64_t*)READ_PTR(b)));
+    b->read_pos += 8;
+
+    if (RTEST(f_signed))
+        return LONG2NUM((int64_t)i64);
+    else
+        return ULONG2NUM(i64);
+}
+
+VALUE
+rb_byte_buffer_read_int(int argc, VALUE *argv, VALUE self)
+{
+    VALUE f_signed;
+    buffer_t *b;
+    uint32_t i32;
+
+    rb_scan_args(argc, argv, "01", &f_signed);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_READ_CAPACITY(b, 4);
+    i32 = be32toh(*((uint32_t*)READ_PTR(b)));
+    b->read_pos += 4;
+
+    if (RTEST(f_signed))
+        return INT2NUM((int32_t)i32);
+    else
+        return UINT2NUM(i32);
+}
+
+VALUE
+rb_byte_buffer_read_short(int argc, VALUE *argv, VALUE self)
+{
+    VALUE f_signed;
+    buffer_t *b;
+    uint16_t i16;
+
+    rb_scan_args(argc, argv, "01", &f_signed);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_READ_CAPACITY(b, 2);
+    i16 = be16toh(*((uint16_t*)READ_PTR(b)));
+    b->read_pos += 2;
+
+    if (RTEST(f_signed))
+        return INT2NUM((int16_t)i16);
+    else
+        return UINT2NUM(i16);
+}
+
+VALUE
+rb_byte_buffer_read_byte(int argc, VALUE *argv, VALUE self)
+{
+    VALUE f_signed;
+    buffer_t *b;
+    uint8_t i8;
+
+    rb_scan_args(argc, argv, "01", &f_signed);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_READ_CAPACITY(b, 1);
+    i8 = *((uint8_t*)READ_PTR(b));
+    b->read_pos += 1;
+
+    if (RTEST(f_signed))
+        return INT2NUM((int8_t)i8);
+    else
+        return UINT2NUM(i8);
+}
+
+VALUE
+rb_byte_buffer_read_double(VALUE self)
+{
+    buffer_t *b;
+    union {uint64_t i64; double d;} ucast;
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_READ_CAPACITY(b, 8);
+    ucast.i64 = be64toh(*(uint64_t*)READ_PTR(b));
+    b->read_pos += 8;
+
+    return DBL2NUM(ucast.d);
+}
+
+VALUE
+rb_byte_buffer_read_float(VALUE self)
+{
+    buffer_t *b;
+    union {float d; uint32_t i32;} ucast;
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_READ_CAPACITY(b, 4);
+    ucast.i32 = be32toh(*(uint32_t*)READ_PTR(b));
+    b->read_pos += 4;
+
+    return DBL2NUM((double)ucast.d);
+}
+
+VALUE
+rb_byte_buffer_read_byte_array(int argc, VALUE *argv, VALUE self)
+{
+    buffer_t *b;
+    VALUE n;
+    VALUE f_signed;
+    VALUE ary;
+    long len, i;
+    int b_signed;
+
+    rb_scan_args(argc, argv, "11", &n, &f_signed);
+
+    Check_Type(n, T_FIXNUM);
+    len = FIX2LONG(n);
+    if (len < 0) rb_raise(rb_eRangeError, "Cannot read a negative number of bytes");
+    b_signed = RTEST(f_signed);
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    ENSURE_READ_CAPACITY(b, len);
+
+    ary = rb_ary_new();
+    for (i=0; i<len; ++i) {
+        uint8_t i8 = *((uint8_t*)READ_PTR(b));
+        b->read_pos += 1;
+
+        if (b_signed)
+            rb_ary_push(ary, INT2NUM((int8_t)i8));
+        else
+            rb_ary_push(ary, UINT2NUM(i8));
+    }
+
+    return ary;
+}
+
+VALUE
+rb_byte_buffer_index(int argc, VALUE *argv, VALUE self)
+{
+    VALUE substr;
+    VALUE voffset;
+    size_t offset;
+    buffer_t *b;
+
+    rb_scan_args(argc, argv, "11", &substr, &voffset);
+    Check_Type(substr, T_STRING);
+    if (!NIL_P(voffset)) {
+        long l = NUM2LONG(voffset);
+        if (l < 0) rb_raise(rb_eRangeError, "offset can't be negative");
+        offset = l;
+    } else
+        offset = 0;
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    if (offset >= READ_SIZE(b) || offset + RSTRING_LEN(substr) > READ_SIZE(b))
+        return Qnil;
+    else {
+        char* pos = memmem(READ_PTR(b) + offset, READ_SIZE(b), RSTRING_PTR(substr), RSTRING_LEN(substr));
+        if (pos)
+            return UINT2NUM(pos - READ_PTR(b));
+        else
+            return Qnil;
+    }
+}
+
+VALUE
+rb_byte_buffer_update(VALUE self, VALUE location, VALUE bytes)
+{
+    long offset;
+    long copy_bytes_len;
+    buffer_t *b;
+
+    Check_Type(location, T_FIXNUM);
+    Check_Type(bytes, T_STRING);
+    offset = NUM2LONG(location);
+    if (offset < 0) rb_raise(rb_eRangeError, "location can't be negative");
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    if ((size_t)offset >= READ_SIZE(b))
+        return self;
+
+    copy_bytes_len = RSTRING_LEN(bytes);
+    if ((size_t)(offset + copy_bytes_len) > READ_SIZE(b))
+        copy_bytes_len = READ_SIZE(b) - offset;
+    memcpy(READ_PTR(b) + offset, RSTRING_PTR(bytes), copy_bytes_len);
+
+    return self;
+}
+
+VALUE
+rb_byte_buffer_to_str(VALUE self)
+{
+    buffer_t *b;
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+
+    return rb_str_new(READ_PTR(b), READ_SIZE(b));
+}
+
+VALUE
+rb_byte_buffer_inspect(VALUE self)
+{
+    buffer_t *b;
+    VALUE str;
+
+    TypedData_Get_Struct(self, buffer_t, &buffer_data_type, b);
+    str = rb_sprintf("#<%s:%p read_pos:%zu write_pos:%zu len:%zu capacity:%zu>",
+        rb_obj_classname(self), (void*)self, b->read_pos, b->write_pos, READ_SIZE(b), b->size);
+
+    return str;
+}
+
+int32_t
+value_to_int32(VALUE x)
+{
+    if (FIXNUM_P(x)) {
+        int64_t i64 = FIX2LONG(x);
+
+        if (i64 > 0xFFFFFFFF || -i64 > 0x80000000)
+            rb_raise(rb_eRangeError, "Number %" PRId64 " is too big", i64);
+
+        return (int32_t)i64;
+    } else if (TYPE(x) == T_BIGNUM)
+        rb_raise(rb_eRangeError, "expected `interger', got `bignum'");
+    else
+        rb_raise(rb_eTypeError, "expected `interger', got %s ", rb_obj_classname(x));
+
+    return 0;
+}
+
+int64_t
+value_to_int64(VALUE x)
+{
+    if (FIXNUM_P(x))
+        return FIX2LONG(x);
+    else if (TYPE(x) == T_BIGNUM && RBIGNUM_SIGN(x))
+        return (int64_t)rb_big2ull(x);
+    else if (TYPE(x) == T_BIGNUM && !RBIGNUM_SIGN(x))
+        return rb_big2ll(x);
+    else
+        rb_raise(rb_eTypeError, "expected `interger' or `bignum', got %s ", rb_obj_classname(x));
+
+    return 0;
+}
+
+double
+value_to_dbl(VALUE x)
+{
+    if (FIXNUM_P(x))
+        return ((double)FIX2LONG(x));
+    else if (TYPE(x) == T_FLOAT)
+        return RFLOAT_VALUE(x);
+    else if (TYPE(x) == T_BIGNUM)
+        return rb_big2dbl(x);
+    else
+        rb_raise(rb_eTypeError, "expected a numeric type, got %s ", rb_obj_classname(x));
+
+    return 0.0;
+}
+
+void
+grow_buffer(buffer_t* buffer_ptr, size_t len)
+{
+    size_t new_size = buffer_ptr->write_pos - buffer_ptr->read_pos + len;
+
+    if (new_size <= buffer_ptr->size) {
+        memmove(buffer_ptr->b_ptr, READ_PTR(buffer_ptr), READ_SIZE(buffer_ptr));
+        buffer_ptr->write_pos -= buffer_ptr->read_pos;
+        buffer_ptr->read_pos = 0;
+    } else {
+        char *new_b_ptr;
+
+        new_size += new_size / 2;
+        new_b_ptr = ALLOC_N(char, new_size);
+        memcpy(new_b_ptr, READ_PTR(buffer_ptr), READ_SIZE(buffer_ptr));
+        if (buffer_ptr->b_ptr != buffer_ptr->embedded_buffer) xfree(buffer_ptr->b_ptr);
+        buffer_ptr->b_ptr = new_b_ptr;
+        buffer_ptr->size = new_size;
+        buffer_ptr->write_pos -= buffer_ptr->read_pos;
+        buffer_ptr->read_pos = 0;
+    }
+}
+
+void
+byte_buffer_free(void *ptr)
+{
+    buffer_t *b = ptr;
+    if (b->b_ptr != b->embedded_buffer) xfree(b->b_ptr);
+    xfree(b);
+}
+
+size_t
+byte_buffer_memsize(const void *ptr)
+{
+    return ptr ? sizeof(buffer_t) : 0;
+}

data/ext/byte_buffer_ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile("byte_buffer_ext")

data/ext/byte_buffer_ext/portable_endian.h

@@ -0,0 +1,118 @@
+// "License": Public Domain
+// I, Mathias Panzenböck, place this file hereby into the public domain. Use it at your own risk for whatever you like.
+// In case there are jurisdictions that don't support putting things in the public domain you can also consider it to
+// be "dual licensed" under the BSD, MIT and Apache licenses, if you want to. This code is trivial anyway. Consider it
+// an example on how to get the endian conversion functions on different platforms.
+
+#ifndef PORTABLE_ENDIAN_H__
+#define PORTABLE_ENDIAN_H__
+
+#if (defined(_WIN16) || defined(_WIN32) || defined(_WIN64)) && !defined(__WINDOWS__)
+
+# define __WINDOWS__
+
+#endif
+
+#if defined(__linux__) || defined(__CYGWIN__)
+
+# include <endian.h>
+
+#elif defined(__APPLE__)
+
+# include <libkern/OSByteOrder.h>
+
+# define htobe16(x) OSSwapHostToBigInt16(x)
+# define htole16(x) OSSwapHostToLittleInt16(x)
+# define be16toh(x) OSSwapBigToHostInt16(x)
+# define le16toh(x) OSSwapLittleToHostInt16(x)
+
+# define htobe32(x) OSSwapHostToBigInt32(x)
+# define htole32(x) OSSwapHostToLittleInt32(x)
+# define be32toh(x) OSSwapBigToHostInt32(x)
+# define le32toh(x) OSSwapLittleToHostInt32(x)
+
+# define htobe64(x) OSSwapHostToBigInt64(x)
+# define htole64(x) OSSwapHostToLittleInt64(x)
+# define be64toh(x) OSSwapBigToHostInt64(x)
+# define le64toh(x) OSSwapLittleToHostInt64(x)
+
+# define __BYTE_ORDER    BYTE_ORDER
+# define __BIG_ENDIAN    BIG_ENDIAN
+# define __LITTLE_ENDIAN LITTLE_ENDIAN
+# define __PDP_ENDIAN    PDP_ENDIAN
+
+#elif defined(__OpenBSD__)
+
+# include <sys/endian.h>
+
+#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+
+# include <sys/endian.h>
+
+# define be16toh(x) betoh16(x)
+# define le16toh(x) letoh16(x)
+
+# define be32toh(x) betoh32(x)
+# define le32toh(x) letoh32(x)
+
+# define be64toh(x) betoh64(x)
+# define le64toh(x) letoh64(x)
+
+#elif defined(__WINDOWS__)
+
+# include <winsock2.h>
+# include <sys/param.h>
+
+# if BYTE_ORDER == LITTLE_ENDIAN
+
+#   define htobe16(x) htons(x)
+#   define htole16(x) (x)
+#   define be16toh(x) ntohs(x)
+#   define le16toh(x) (x)
+
+#   define htobe32(x) htonl(x)
+#   define htole32(x) (x)
+#   define be32toh(x) ntohl(x)
+#   define le32toh(x) (x)
+
+#   define htobe64(x) htonll(x)
+#   define htole64(x) (x)
+#   define be64toh(x) ntohll(x)
+#   define le64toh(x) (x)
+
+# elif BYTE_ORDER == BIG_ENDIAN
+
+    /* that would be xbox 360 */
+#   define htobe16(x) (x)
+#   define htole16(x) __builtin_bswap16(x)
+#   define be16toh(x) (x)
+#   define le16toh(x) __builtin_bswap16(x)
+
+#   define htobe32(x) (x)
+#   define htole32(x) __builtin_bswap32(x)
+#   define be32toh(x) (x)
+#   define le32toh(x) __builtin_bswap32(x)
+
+#   define htobe64(x) (x)
+#   define htole64(x) __builtin_bswap64(x)
+#   define be64toh(x) (x)
+#   define le64toh(x) __builtin_bswap64(x)
+
+# else
+
+#   error byte order not supported
+
+# endif
+
+# define __BYTE_ORDER    BYTE_ORDER
+# define __BIG_ENDIAN    BIG_ENDIAN
+# define __LITTLE_ENDIAN LITTLE_ENDIAN
+# define __PDP_ENDIAN    PDP_ENDIAN
+
+#else
+
+# error platform not supported
+
+#endif
+
+#endif

data/lib/byte_buffer.rb

@@ -0,0 +1,5 @@
+module ByteBuffer
+  require_relative 'byte_buffer/version'
+  require_relative 'byte_buffer_ext'
+  require_relative 'byte_buffer/buffer'
+end

data/lib/byte_buffer/buffer.rb

@@ -0,0 +1,26 @@
+module ByteBuffer
+  class Buffer
+    alias_method :size, :length
+    alias_method :bytesize, :length
+    alias_method :<<, :append
+    alias_method :cheap_peek, :to_str
+    alias_method :to_s, :to_str
+
+    def empty?
+      self.length == 0
+    end
+
+    def eql?(other)
+      self.to_str.eql?(other.to_str)
+    end
+    alias_method :==, :eql?
+
+    def hash
+      to_str.hash
+    end
+
+    def dup
+      self.class.new(self.to_str)
+    end
+  end
+end

data/lib/byte_buffer/version.rb

@@ -0,0 +1,3 @@
+module ByteBuffer
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: byte_buffer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Serge Balyuk
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: ione
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+description: 
+email:
+- sergeb@apptopia.com
+- bgipsy@gmail.com
+executables: []
+extensions:
+- ext/byte_buffer_ext/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/benchmarks
+- bin/console
+- byte_buffer.gemspec
+- ext/byte_buffer_ext/byte_buffer.c
+- ext/byte_buffer_ext/extconf.rb
+- ext/byte_buffer_ext/portable_endian.h
+- lib/byte_buffer.rb
+- lib/byte_buffer/buffer.rb
+- lib/byte_buffer/version.rb
+homepage: http://github.com/apptopia/byte_buffer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Fast native implementation of byte buffer intended to be used as part of
+  frame based protocol PDU handling code. Can serve as drop in replacement for Ione::ByteBuffer
+  and used in DataStax Cassandra Ruby driver.
+test_files: []