binyo 0.0.1

data/ext/binyo/io_out_bytes.c

@@ -0,0 +1,120 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+#include "binyo.h"
+
+typedef struct binyo_outstream_bytes_st {
+    binyo_outstream_interface *methods;
+    binyo_byte_buffer *buffer;
+} binyo_outstream_bytes;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_outstream((out), (in), BINYO_OUTSTREAM_TYPE_BYTES, binyo_outstream_bytes)
+
+static binyo_outstream_bytes* int_bytes_alloc(void);
+static ssize_t int_bytes_write(binyo_outstream *out, uint8_t *buf, size_t len);
+static void int_bytes_free(binyo_outstream *out);
+
+static binyo_outstream_interface binyo_interface_bytes = {
+    BINYO_OUTSTREAM_TYPE_BYTES,
+    int_bytes_write,
+    NULL,
+    NULL,
+    int_bytes_free
+};
+
+binyo_outstream *
+binyo_outstream_new_bytes(void)
+{
+    binyo_outstream_bytes *out;
+
+    out = int_bytes_alloc();
+    out->buffer = binyo_buffer_new();
+    return (binyo_outstream *) out;
+}
+
+binyo_outstream *
+binyo_outstream_new_bytes_size(size_t size)
+{
+    binyo_outstream_bytes *out;
+
+    out = int_bytes_alloc();
+    out->buffer = binyo_buffer_new_size(size);
+    return (binyo_outstream *) out;
+}
+
+binyo_outstream *
+binyo_outstream_new_bytes_prealloc(uint8_t *b, size_t len)
+{
+    binyo_outstream_bytes *out;
+
+    out = int_bytes_alloc();
+    out->buffer = binyo_buffer_new_prealloc(b, len);
+    return (binyo_outstream *) out;
+}
+
+size_t
+binyo_outstream_bytes_get_bytes_free(binyo_outstream *outstream, uint8_t **bytes)
+{
+    binyo_outstream_bytes *out;
+    size_t len;
+
+    int_safe_cast(out, outstream);
+    len = binyo_buffer_get_bytes_free(out->buffer, bytes);
+    xfree(out);
+    return len;
+}
+
+static binyo_outstream_bytes *
+int_bytes_alloc(void)
+{
+    binyo_outstream_bytes *ret;
+    ret = ALLOC(binyo_outstream_bytes);
+    memset(ret, 0, sizeof(binyo_outstream_bytes));
+    ret->methods = &binyo_interface_bytes;
+    return ret;
+}
+
+static ssize_t
+int_bytes_write(binyo_outstream *outstream, uint8_t *buf, size_t len)
+{
+    binyo_outstream_bytes *out;
+
+    int_safe_cast(out, outstream);
+    return binyo_buffer_write(out->buffer, buf, len);
+}
+
+static void
+int_bytes_free(binyo_outstream *outstream)
+{
+    binyo_outstream_bytes *out;
+
+    if (!outstream) return;
+    int_safe_cast(out, outstream);
+    if (out->buffer)
+	binyo_buffer_free(out->buffer);
+}
+

data/ext/binyo/io_out_fd.c

@@ -0,0 +1,110 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+#include <unistd.h>
+#include <errno.h>
+#include "binyo.h"
+
+typedef struct binyo_outstream_fd_st {
+    binyo_outstream_interface *methods;
+    int fd;
+} binyo_outstream_fd;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_outstream((out), (in), BINYO_OUTSTREAM_TYPE_FD, binyo_outstream_fd)
+
+static binyo_outstream_fd* int_fd_alloc(void);
+static ssize_t int_fd_write(binyo_outstream *out, uint8_t *buf, size_t len);
+static void int_fd_free(binyo_outstream *out);
+
+static binyo_outstream_interface binyo_interface_fd = {
+    BINYO_OUTSTREAM_TYPE_FD,
+    int_fd_write,
+    NULL,
+    NULL,
+    int_fd_free
+};
+
+binyo_outstream *
+binyo_outstream_new_fd_io(VALUE value)
+{
+    rb_io_t *fptr;
+    GetOpenFile(value, fptr);
+    rb_io_check_writable(fptr);
+    return binyo_outstream_new_fd(fptr->fd);
+}
+
+binyo_outstream *
+binyo_outstream_new_fd(int fd)
+{
+    binyo_outstream_fd *out;
+
+    out = int_fd_alloc();
+    out->fd = fd;
+    return (binyo_outstream *) out;
+}
+
+static binyo_outstream_fd*
+int_fd_alloc(void)
+{
+    binyo_outstream_fd *ret;
+    ret = ALLOC(binyo_outstream_fd);
+    memset(ret, 0, sizeof(binyo_outstream_fd));
+    ret->methods = &binyo_interface_fd;
+    return ret;
+}
+
+static ssize_t
+int_fd_write(binyo_outstream *outstream, uint8_t *buf, size_t len)
+{
+    int fd;
+    ssize_t w;
+    binyo_outstream_fd *out;
+   
+    int_safe_cast(out, outstream); 
+
+    if (!buf) return BINYO_ERR;
+
+    fd = out->fd;
+    binyo_clear_sys_error();
+    /* no need to increase out->num_written */
+    w = write(fd, buf, len);
+    
+    if (w < 0) {
+	binyo_add_io_error();
+	return BINYO_ERR;
+    }
+    else {
+    	return w;
+    }
+}
+
+static void
+int_fd_free(binyo_outstream *out)
+{
+    /* do not close the fd, should be done explicitly */
+}
+

data/ext/binyo/io_out_generic.c

@@ -0,0 +1,125 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+#include "binyo.h"
+
+typedef struct binyo_outstream_io_st {
+    binyo_outstream_interface *methods;
+    VALUE io;
+} binyo_outstream_io;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_outstream((out), (in), BINYO_OUTSTREAM_TYPE_IO_GENERIC, binyo_outstream_io)
+
+static binyo_outstream_io* int_io_alloc(void);
+static ssize_t int_io_write(binyo_outstream *out, uint8_t *buf, size_t len);
+static int int_io_rb_write(binyo_outstream *out, VALUE vbuf, VALUE *ret);
+static void int_io_mark(binyo_outstream *out);
+static void int_io_free(binyo_outstream *out);
+
+static binyo_outstream_interface binyo_interface_io = {
+    BINYO_OUTSTREAM_TYPE_IO_GENERIC,
+    int_io_write,
+    int_io_rb_write,
+    int_io_mark,
+    int_io_free
+};
+
+binyo_outstream *
+binyo_outstream_new_io_generic(VALUE io)
+{
+    binyo_outstream_io *out;
+
+    out = int_io_alloc();
+    out->io = io;
+    return (binyo_outstream *) out;
+}
+
+static binyo_outstream_io *
+int_io_alloc(void)
+{
+    binyo_outstream_io *ret;
+    ret = ALLOC(binyo_outstream_io);
+    memset(ret, 0, sizeof(binyo_outstream_io));
+    ret->methods = &binyo_interface_io;
+    return ret;
+}
+
+static ssize_t
+int_io_write(binyo_outstream *outstream, uint8_t *buf, size_t len)
+{
+    VALUE vbuf, ret;
+
+    if (!buf) return BINYO_ERR;
+
+    vbuf = rb_str_new((const char *)buf, len);
+    if(int_io_rb_write(outstream, vbuf, &ret) == BINYO_ERR) {
+	binyo_error_add("Error while writing to IO");
+	return BINYO_ERR;
+    }
+    return NUM2LONG(ret);
+}
+
+static VALUE
+int_io_rb_protected_write(VALUE args)
+{
+    VALUE io, vbuf;
+    io = rb_ary_entry(args, 0);
+    vbuf = rb_ary_entry(args, 1);
+    return rb_funcall(io, sBinyo_ID_WRITE, 1, vbuf);
+}
+
+static int
+int_io_rb_write(binyo_outstream *outstream, VALUE vbuf, VALUE *ret)
+{
+    binyo_outstream_io *out;
+    VALUE args;
+    int state = 0;
+
+    int_safe_cast(out, outstream);
+    args = rb_ary_new();
+    rb_ary_push(args, out->io);
+    rb_ary_push(args, vbuf);
+    *ret = rb_protect(int_io_rb_protected_write, args, &state);
+    return state == 0 ? BINYO_OK : BINYO_ERR;
+}
+
+static void
+int_io_mark(binyo_outstream *outstream)
+{
+    binyo_outstream_io *out;
+
+    if (!outstream) return;
+    int_safe_cast(out, outstream);
+    rb_gc_mark(out->io);
+}
+
+static void
+int_io_free(binyo_outstream *outstream)
+{
+    /* do nothing */
+}
+

data/lib/binyo.rb

@@ -0,0 +1,32 @@
+=begin
+
+= Info
+
+binyo - Fast binary IO for Ruby
+
+Copyright (C) 2012-2013
+Martin Bosslet <martin.bosslet@gmail.com>
+All rights reserved.
+
+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.
+
+=end
+
+require 'binyo.so'

data/test/hex.rb

@@ -0,0 +1,135 @@
+require 'binyo'
+require 'benchmark'
+
+HEX_TABLE = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102]
+HEX_TABLE_INV = [
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, 
+  -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 
+  13, 14, 15
+] #102
+HEX_INV_MAX = 102
+
+module Hex
+
+  def self.encode(data)
+    ("\0" * (data.size * 2)).tap do |ret|
+      data.each_byte.each_with_index do |b, i|
+        ret.setbyte(i * 2, HEX_TABLE[b >> 4])
+        ret.setbyte(i * 2 + 1, HEX_TABLE[b & 0x0f])
+      end
+    end
+  end
+
+  def self.decode(data)
+    len = data.size
+    raise RuntimeError.new("Hex-encoded data length must be a multiple of 2") unless len % 2 == 0
+    "".tap do |ret|
+      (len / 2).times do |i|
+        dbl_i = i * 2
+        c = data[dbl_i].ord
+        d = data[dbl_i + 1].ord
+        if c > HEX_INV_MAX || d > HEX_INV_MAX
+          raise RuntimeError.new("Illegal hex character detected: #{c}|#{d}")
+        end
+        b = HEX_TABLE_INV[c]
+        raise illegal_hex_char(c) if b < 0
+        b = b << 4
+        bb = HEX_TABLE_INV[d]
+        raise illegal_hex_char(d) if bb < 0
+        ret << (b | bb)
+      end
+    end
+  end
+
+  private
+
+  def self.illegal_hex_char(c)
+    RuntimeError.new("Illegal hex character detected: #{c}")
+  end
+
+end
+
+module BinyoHex
+
+  def self.encode(data)
+    input = Binyo::ByteList.new(data)
+    bl = Binyo::ByteList.new(data.size * 2)
+    input.each do |b|
+      bl << HEX_TABLE[b >> 4]
+      bl << HEX_TABLE[b & 0x0f]
+    end
+    bl.to_s
+  end
+
+  def self.decode(data)
+    raise RuntimeError.new("Hex-encoded data length must be a multiple of 2") unless data.size % 2 == 0
+    input = Binyo::ByteList.new(data)
+    half_len = data.size / 2
+    bl = Binyo::ByteList.new(half_len)
+    half_len.times do |i|
+      dbl_i = i * 2
+      c = input[dbl_i]
+      d = input[dbl_i + 1]
+      if c > HEX_INV_MAX || d > HEX_INV_MAX
+        raise RuntimeError.new("Illegal hex character detected: #{c}|#{d}")
+      end
+      b = HEX_TABLE_INV[c]
+      raise illegal_hex_char(c) if b < 0
+      b = b << 4
+      bb = HEX_TABLE_INV[d]
+      raise illegal_hex_char(d) if bb < 0
+      bl << (b | bb)
+    end
+    bl.to_s
+  end
+
+end
+
+Benchmark.bm do |bm|
+  n = 1000
+
+  data = "test" * 10000
+
+  bm.report("unpack('H*')") do
+    n.times do
+      data.unpack("H*")[0]
+    end
+  end
+
+  bm.report("Hex.encode") do
+    n.times do
+      Hex.encode(data)
+    end
+  end
+
+  bm.report("BinyoHex.encode") do
+    n.times do
+      BinyoHex.encode(data)
+    end
+  end
+
+  enc = data.unpack("H*")[0]
+
+  bm.report("pack('H*')") do
+    n.times do
+      [enc].pack("H*")
+    end
+  end
+
+  bm.report("Hex.decode") do
+    n.times do
+      Hex.decode(enc)
+    end
+  end
+
+  bm.report("BinyoHex.decode") do
+    n.times do
+      BinyoHex.decode(enc)
+    end
+  end
+
+end
+