cord 0.1

data/README

@@ -0,0 +1,29 @@
+Simple Concat Tree / Rope / Cord implementation for Ruby MRI
+  (c) 2010 Lourens Naudé (methodmissing)
+
+  http://github.com/methodmissing/cord
+
+See http://www.cs.ubc.ca/local/reading/proceedings/spe91-95/spe/vol25/issue12/spe986.pdf and  http://en.wikipedia.org/wiki/Rope_(computer_science) for context.
+
+This library works with Ruby 1.8 and 1.9 and exposes the following API :
+
+  c = Cord.new('test')
+  c.depth #=> 1
+  c << 'cord'
+  c.depth #=> 2
+
+  c = Cord.new('aaaa')
+  c << 'bbbb'
+  c.to_s #=> 'aaaabbbb'
+
+To run the test suite:
+
+  rake
+
+Todo:
+
+  Tree rebalance / normalization
+  Exploit shared string / COW semantics further
+  Cord#each
+
+Work in progress, thanks for watching!

data/Rakefile

@@ -0,0 +1,78 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+require 'rake/clean'
+$:.unshift(File.expand_path('lib'))
+CORD_ROOT = 'ext/cord'
+
+desc 'Default: test'
+task :default => :test
+
+desc 'Run cord tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs = [CORD_ROOT]
+  t.pattern = 'test/test_*.rb'
+  t.ruby_opts << '-rtest'
+  t.libs << 'test'
+  t.warning = true
+  t.verbose = true
+end
+task :test => :build
+
+namespace :build do
+  file "#{CORD_ROOT}/cord.c"
+  file "#{CORD_ROOT}/extconf.rb"
+  file "#{CORD_ROOT}/Makefile" => %W(#{CORD_ROOT}/cord.c #{CORD_ROOT}/extconf.rb) do
+    Dir.chdir(CORD_ROOT) do
+      ruby 'extconf.rb'
+    end
+  end
+
+  desc "generate makefile"
+  task :makefile => %W(#{CORD_ROOT}/Makefile #{CORD_ROOT}/cord.c)
+
+  dlext = Config::CONFIG['DLEXT']
+  file "#{CORD_ROOT}/cord.#{dlext}" => %W(#{CORD_ROOT}/Makefile #{CORD_ROOT}/cord.c) do
+    Dir.chdir(CORD_ROOT) do
+      sh 'make' # TODO - is there a config for which make somewhere?
+    end
+  end
+
+  desc "compile cord extension"
+  task :compile => "#{CORD_ROOT}/cord.#{dlext}"
+
+  task :clean do
+    Dir.chdir(CORD_ROOT) do
+      sh 'make clean'
+    end if File.exists?("#{CORD_ROOT}/Makefile")
+  end
+
+  CLEAN.include("#{CORD_ROOT}/Makefile")
+  CLEAN.include("#{CORD_ROOT}/cord.#{dlext}")
+end
+
+task :clean => %w(build:clean)
+
+desc "compile"
+task :build => %w(build:compile)
+
+task :install do |t|
+  Dir.chdir(CORD_ROOT) do
+    sh 'sudo make install'
+  end
+end
+
+desc "clean build install"
+task :setup => %w(clean build install)
+
+desc 'Run benchmarks'
+task :bench do
+  ruby "bench/cord.rb"
+end
+task :bench => :build
+
+desc 'Run qsort benchmarks from RubyQuiz'
+task :bench_qsort do
+  ruby "bench/quiz.rb String"
+  ruby "bench/quiz.rb Cord"
+end
+task :bench_qsort => :build

data/bench/cord.rb

@@ -0,0 +1,25 @@
+$:.unshift "."
+require 'benchmark'
+require File.dirname(__FILE__) + '/../ext/cord/cord'
+
+TESTS = 100_000
+PAYLOADS = [
+('a' * 5),
+('b' * 10),
+('c' * 20),
+('d' * 40),
+('e' * 80),
+('f' * 120),
+('g' * 200),
+('h' * 300)
+]
+
+string = ''
+cord = Cord.new
+ary = []
+
+Benchmark.bmbm do |results|
+  results.report("[cord] obj << a") { TESTS.times{ cord << PAYLOADS[rand(6)] } }
+  results.report("[str] obj << a") { TESTS.times{ string << PAYLOADS[rand(6)] } }
+  results.report("[ary] obj << a") { TESTS.times{ ary << PAYLOADS[rand(6)] } }
+end

data/bench/quiz.rb

@@ -0,0 +1,52 @@
+# from http://www.rubyquiz.com/quiz137.html
+$:.unshift "."
+require 'benchmark'
+require File.dirname(__FILE__) + '/../ext/cord/cord'
+
+  #This code make a String/Rope of  CHUNCKS chunks of text
+  #each chunck is SIZE bytes long.  Each chunck starts with 
+  #an 8 byte number.  Initially the chuncks are shuffled the
+  #qsort method sorts them into ascending order.
+  #
+  #pass the name of the class to use as a parameter
+  #ruby -r rope.rb this_file Rope
+
+  puts 'preparing data...'
+  TextClass = Object.const_get(ARGV.shift || :String)
+
+  def qsort(text)
+    return TextClass.new if text.length == 0
+    pivot = text.slice(0,8).to_s.to_i
+    less = TextClass.new
+    more = TextClass.new
+    offset = 8+SIZE
+    while (offset < text.length)
+      i = text.slice(offset,8).to_s.to_i
+      (i < pivot ? less : more) << text.slice(offset,8+SIZE)
+      offset = offset + 8+SIZE
+    end
+    print "*"
+    return qsort(less) << text.slice(0,8+SIZE) << qsort(more)
+  end
+
+  SIZE  = 512 * 1024
+  CHUNCKS = 128
+  CHARS = %w[R O P E]
+  data = TextClass.new
+  bulk_string =
+    TextClass.new(Array.new(SIZE) { CHARS[rand(4)] }.join)
+  puts 'Building Text...'
+  build = Benchmark.measure do
+    (0..CHUNCKS).sort_by { rand }.each do |n|
+      data<< sprintf("%08i",n) << bulk_string
+    end
+    data.normalize  if data.respond_to? :normalize
+  end
+  GC.start
+  sort = Benchmark.measure do
+    puts "Sorting Text..."
+    qsort(data)
+    puts"\nEND"
+  end
+
+  puts "Build: #{build}Sort: #{sort}"

data/cord.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'cord'
+  s.version = '0.1'
+  s.date = '2010-10-23'
+  s.authors = ['Lourens Naudé']
+  s.email = ['lourens@methodmissing.com']
+  s.description = 'WIP implementation of a Concat Tree / Rope / Cord for Ruby MRI.'
+  s.homepage = 'http://github.com/methodmissing/rehash'
+  s.summary = 'WIP implementation of a Concat Tree / Rope / Cord for Ruby MRI.'
+  s.extensions = 'ext/cord/extconf.rb'
+  s.files = Dir.glob("{ext,test,bench}/**/*") + %w[README Rakefile cord.gemspec]
+  s.has_rdoc = true
+  s.extra_rdoc_files = Dir['ext/cord/*.c']
+end

data/ext/cord/cord.c

@@ -0,0 +1,180 @@
+#include <ruby.h>
+#include "cord.h"
+
+static void rb_mark_cord_i(void *c)
+{
+    CORD_WALK_GC(STRING_CORD_P(c), rb_mark_cord_i, rb_gc_mark_maybe, VALUE);
+}
+
+static void rb_mark_cord(RCord *c)
+{
+    if (c) rb_mark_cord_i(c->cord);
+}
+
+static void rb_free_cord_i(void *c)
+{
+    CORD_WALK_GC((!STRING_CORD_P(c)), rb_free_cord_i, xfree, void*);
+}
+
+static void rb_free_cord(RCord *c)
+{
+    if (c){
+      rb_free_cord_i(c->cord);
+      xfree(c);
+    }
+}
+
+static VALUE rb_cord_alloc(VALUE klass)
+{
+    RCord *cs = NULL;
+    VALUE c;
+    c = Data_Make_Struct(klass, RCord, rb_mark_cord, rb_free_cord, cs);
+    cs->len = 0;
+    cs->depth = 0;
+    cs->cord = EMPTY_CORD;
+    return c;
+}
+
+static void *rb_cord_balance(void *cord)
+{
+    return cord;
+}
+
+static char *rb_merge_cords(void *left, void *right)
+{
+    char *cord = NULL;
+    long left_len, right_len, len;
+    left_len = CORD_LENGTH(left);
+    right_len = CORD_LENGTH(right);
+    len = left_len + right_len;
+    cord = ALLOC_N(char, len + 1);
+    memcpy(cord, RSTRING_PTR(left), left_len);
+    memcpy(cord + left_len, RSTRING_PTR(right), right_len);
+    cord[len] = '\0';
+    return cord;
+}
+
+static VALUE rb_new_flat_cord(void *left, void *right)
+{
+    char *cord = NULL;
+    cord = rb_merge_cords(left, right);
+    return rb_str_new2(cord);
+}
+
+static void *rb_new_concat_cord(void * left, void * right){
+    RConcatCord *cord = NULL;
+    short int depth;
+    cord = ALLOC(RConcatCord);
+    cord->left = (void*)left;
+    cord->right = (void*)right;
+    cord->len = CORD_LENGTH(left) + RSTRING_LEN((VALUE)right);
+    depth = (CORD_DEPTH(right) > CORD_DEPTH(left)) ? CORD_DEPTH(right) : CORD_DEPTH(left);
+    cord->depth = depth + 1;
+    return cord;
+}
+
+static void *rb_append_cords(void * left, void *right)
+{
+    RConcatCord *new_left = NULL;
+    RConcatCord *new_right = NULL;
+    if (CORD_LENGTH(left) + CORD_LENGTH(right) < STRING_CORD_THRESHOLD){
+      return (void *)rb_new_flat_cord(left, right);
+    }
+    if (!CONCAT_CORD_P(left) && CONCAT_CORD_P(right)){
+      new_right = CONCAT_CORD(right);
+      if (CORD_LENGTH(left) + CORD_LENGTH(new_right->left) < STRING_CORD_THRESHOLD){
+        return rb_new_concat_cord((void *)rb_new_flat_cord(left, new_right->left), new_right->right);
+      }
+    }
+    if (!CONCAT_CORD_P(right) && CONCAT_CORD_P(left)){
+      new_left = CONCAT_CORD(left);
+      if (CORD_LENGTH(right) + CORD_LENGTH(new_left->right) < STRING_CORD_THRESHOLD){
+        return rb_new_concat_cord(new_left->left, (void *)rb_new_flat_cord(new_left->right, right));
+      }
+    }
+    return rb_new_concat_cord(left, right);
+}
+
+static void concat_cord_to_s(VALUE buffer, void * cord)
+{
+    if (EMPTY_CORD_P(cord) || STRING_CORD_P(cord)) return;
+    concat_cord_to_s(buffer, CONCAT_CORD(cord)->left);
+    concat_cord_to_s(buffer, CONCAT_CORD(cord)->right);
+    if (STRING_CORD_P(CONCAT_CORD(cord)->left)) rb_str_cat2(buffer, RSTRING_PTR(CONCAT_CORD(cord)->left));
+    rb_str_cat2(buffer, RSTRING_PTR(CONCAT_CORD(cord)->right));
+}
+
+static VALUE rb_cord_to_s(VALUE obj)
+{
+    VALUE buffer;
+    RCord *c = GetCord(obj);
+    if (EMPTY_CORD_P(c->cord)) return rb_str_new2("");
+    if (STRING_CORD_P(c->cord)) return (VALUE)c->cord;
+    if (CONCAT_CORD_P(c->cord)){
+      buffer = rb_str_buf_new((long)CORD_LENGTH(c->cord));
+      concat_cord_to_s(buffer, c->cord);
+      return buffer;
+    }
+    return Qnil;
+}
+
+static VALUE rb_cord_append(VALUE obj, VALUE str)
+{
+    RCord *c = GetCord(obj);
+    if (rb_obj_is_kind_of(str, rb_cCord)) str = rb_cord_to_s(str);
+    Check_Type(str, T_STRING);
+    str = rb_str_new4(str);
+    if (RSTRING_LEN(str) == 0) return Qnil;
+    if (EMPTY_CORD_P(c->cord)){
+      c->cord = (void *)str;
+    }else{
+      c->cord = rb_cord_balance(rb_append_cords((void *)c->cord, (void *)str));
+    }
+    return obj;
+}
+
+static VALUE rb_cord_length(VALUE obj)
+{
+    RCord *c = GetCord(obj);
+    if (EMPTY_CORD_P(c->cord)) return INT2FIX(0);
+    return INT2FIX(CORD_LENGTH(c->cord));
+}
+
+static VALUE rb_cord_depth(VALUE obj)
+{
+    RCord *c = GetCord(obj);
+    if (EMPTY_CORD_P(c->cord)) return INT2FIX(0);
+    return INT2FIX(CORD_DEPTH(c->cord));
+}
+
+static VALUE rb_cord_initialize(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE val;
+    RCord *c = GetCord(obj);
+    rb_scan_args(argc, argv, "01", &val);
+    if (!NIL_P(val)) rb_cord_append(obj, val);
+    return obj;
+}
+
+static VALUE
+rb_cord_slice(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE str;
+    str = rb_cord_to_s(obj);
+    return rb_funcall2(str, rb_intern("slice"), argc, argv);
+}
+
+void
+Init_cord()
+{
+    rb_cCord = rb_define_class("Cord", rb_cObject);
+    rb_define_alloc_func(rb_cCord, rb_cord_alloc);
+
+    rb_define_method(rb_cCord, "initialize", rb_cord_initialize, -1);
+    rb_define_method(rb_cCord, "<<", rb_cord_append, 1);
+    rb_define_method(rb_cCord, "to_s", rb_cord_to_s, 0);
+    rb_define_method(rb_cCord, "to_str", rb_cord_to_s, 0);
+    rb_define_method(rb_cCord, "length", rb_cord_length, 0);
+    rb_define_method(rb_cCord, "depth", rb_cord_depth, 0);
+    rb_define_method(rb_cCord, "slice", rb_cord_slice, -1);
+}

data/ext/cord/cord.h

@@ -0,0 +1,35 @@
+typedef struct {
+    long len;
+    short int depth;
+    void *left, *right;
+} RConcatCord;
+
+typedef struct {
+    long len;
+    long depth;
+    void *cord;
+} RCord;
+
+VALUE rb_cCord;
+
+#define STRING_CORD_THRESHOLD 17
+#define MAX_CORD_DEPTH        96
+
+#define GetCord(obj)          (Check_Type(obj, T_DATA), (RCord*)DATA_PTR(obj))
+
+#define EMPTY_CORD            NULL
+#define STRING_CORD(c)        RSTRING(c)
+#define CONCAT_CORD(c)        ((RConcatCord *)(c))
+#define EMPTY_CORD_P(c)       (!(c))
+#define STRING_CORD_P(c)      (BUILTIN_TYPE(c) == T_STRING)
+#define CONCAT_CORD_P(c)      (!EMPTY_CORD_P(c) && !(STRING_CORD_P(c)))
+#define CORD_LENGTH(c)        (STRING_CORD_P(c) ? RSTRING_LEN(c) : CONCAT_CORD(c)->len)
+#define CORD_DEPTH(c)         (STRING_CORD_P(c) ? 1 : CONCAT_CORD(c)->depth)
+#define CORD_WALK_GC(cond, iter, func, cast) \
+    if (c == NULL) return; \
+    if (CONCAT_CORD_P(c)){  \
+      (iter)(CONCAT_CORD(c)->left); \
+      (iter)(CONCAT_CORD(c)->right); \
+    }else{ \
+      if((cond)) (func)((cast)c); \
+    }

data/ext/cord/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config('cord')
+have_func('rb_thread_blocking_region')
+$defs.push("-pedantic")
+create_makefile('cord')

data/test/test.rb

@@ -0,0 +1,3 @@
+$:.unshift "."
+require 'ext/cord/cord'
+require 'test/unit'

data/test/test_cord.rb

@@ -0,0 +1,71 @@
+class TestCord < Test::Unit::TestCase
+  def test_append
+    c = Cord.new
+    assert_equal 'string', (c << 'string').to_s
+    oc = Cord.new('test')
+    assert_equal 'stringtest', (c << oc).to_s
+  end
+
+  def test_to_s_empty_cord
+    c = Cord.new
+    assert_equal '', c.to_s
+  end
+
+  def test_append_non_string
+    c = Cord.new
+    assert_raises(TypeError){ c << :symbol }
+  end
+
+  def test_slice
+    c = Cord.new('test')
+    assert_equal 'te', c.slice(0..1)
+    assert_equal 'es', c.slice(1,2)
+  end
+
+  def test_length
+    c = Cord.new
+    assert_equal 0, c.length
+    c << 'cord'
+    assert_equal 4, c.length
+    c << 'test'
+    assert_equal 8, c.length
+  end
+
+  def test_depth
+    c = Cord.new
+    assert_equal 0, c.depth
+    c << 'aaaa'
+    assert_equal 1, c.depth
+    c << 'bbbbbbbbbbbbbbbbbbbbbbbbbbb'
+    assert_equal 2, c.depth
+    c << 'ccccccccccccccccccccccccccc'
+    assert_equal 3, c.depth
+  end
+
+  def test_initialize
+    c = Cord.new
+    assert_instance_of Cord, c
+    assert_equal '', c.to_s
+    c = Cord.new('test')
+    assert_equal 'test', c.to_s
+  end
+
+  def test_to_s
+    c = Cord.new
+    s = 'aaaa'
+    c << s
+    assert_equal 'aaaa', c.to_s
+    c << 'bbbb'
+    assert_equal 'aaaabbbb', c.to_s
+    c << ''
+    assert_equal 'aaaabbbb', c.to_s
+    c << 'cccccccccccccccccccccccccccccccccccc'
+    assert_equal "aaaabbbbcccccccccccccccccccccccccccccccccccc", c.to_s
+    c << 'ddddddddddddddddddddddddddddddddddddddd'
+    assert_equal 'aaaabbbbccccccccccccccccccccccccccccccccccccddddddddddddddddddddddddddddddddddddddd', c.to_s
+    c << 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+    assert_equal 'aaaabbbbccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', c.to_s
+    c << 'ffff'
+    assert_equal 'aaaabbbbccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffff', c.to_s
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: cord
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- "Lourens Naud\xC3\xA9"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-23 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: WIP implementation of a Concat Tree / Rope / Cord for Ruby MRI.
+email: 
+- lourens@methodmissing.com
+executables: []
+
+extensions: 
+- ext/cord/extconf.rb
+extra_rdoc_files: 
+- ext/cord/cord.c
+files: 
+- ext/cord/cord.c
+- ext/cord/cord.h
+- ext/cord/extconf.rb
+- test/test.rb
+- test/test_cord.rb
+- bench/cord.rb
+- bench/quiz.rb
+- README
+- Rakefile
+- cord.gemspec
+has_rdoc: true
+homepage: http://github.com/methodmissing/rehash
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: WIP implementation of a Concat Tree / Rope / Cord for Ruby MRI.
+test_files: []
+