google_hash 0.1.1 → 0.2.0

data/README

@@ -1,21 +1,57 @@
-This is a ruby gem that wraps google's "sparse" and "dense" hashes.
+Pleased to announce the initial release of the "google_hash" gem.
 
-Current usage:
+Its goal. To boldly be faster than any hash hash before (cue star trek TNG theme).
 
-a = GoogleHashSmall.new
-a[3] = 'abc' # only accept integers for keys currently.
 
-The dense hash tends to be a bit faster than ruby's normal hash, and the sparse hash tends to use less RAM.
+The goal is basically a better hash, either one that is faster or more space efficient than ruby's default.  To attempt this we wrap the google sparse and dense hashes [1].
 
-Still in pre-alpha.
+Speed results (populating 500000 integers):
 
-The goal is basically a faster hash, but also one that is more space efficient than ruby's default.
+1.9.1p376 (mingw):
 
+Hash (Ruby default)
+0.359375 (populate)
+1.1875   (each)
 
-ex (end goal):
+GoogleHashDense
+0.1875   (populate)
+0.078125 (each)
 
-Google::Hash::Dense(:int => :int) # stores them away as real ints, instead of ruby value's, thus they don't cause a hit to garbage collection.
+GoogleHashSparse
+0.53125  (populate)
+0.078125 (each)
 
-Google::Hash::Sparse(:symbol => :string) # stores away its own separate copies of the strings, stores the symbols as ints, thus saving tons of space and also both objects don't have to hit garbage collection.  Saves on speed.
+Usage:
 
-If you have a desired use case let me know and I might well code it up for you.
+a = GoogleHashDenseRubyToRuby.new # or GoogleHash.new
+b = GoogleHashDenseLongToRuby.new # :int => Ruby
+
+a[3] = 4
+b[4] = 'abc'
+b['abc'.hash] = 'some complex object' 
+
+a.each{|k, v| ... }
+
+a.keys => Array
+a.values => Array
+
+Installation:
+
+gem install google_hash (if on doze, you'll need the devkit installed)
+
+Both classes are currently more space efficient than a hash, because they store keys as "native" ints, so the keys no longer affect GC time, as well as only use 4 bytes instead of 20 (or 8 instead of 40, on 64 bit).  This should release stress on the GC, and both GoogleHashDense and GoogleHashSparse do this.  In terms of total memory usage GoogleHashDense uses more, and is more speedy, GoogleHashSparse uses less, and is much more memory efficient (2 bits per entry, or so I'm told).
+
+If you have a desired use case let me know and I might well be able to code it up for you.
+
+ex: currently it uses longs internally instead of ints--if you want ints or chars or what not, let me know.
+
+This is meant to be one more tool in the rubyists toolbelt when trying to optimize speed-wise, and plans to expand to more types, but at least with this release it has a #each method.
+
+Note that sparse maps can be saved to disk--ask if you want/need this functionality.
+
+Enjoy.
+-r
+
+[1] http://code.google.com/p/google-sparsehash
+
+If you want to see the code/hack on it, run extconf.rb within the ext directory, to create the code it actually uses (from a template).

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/ext/benchmark.rb

@@ -1,9 +1,47 @@
 require './google_hash'
 require 'benchmark'
+require 'hitimes'
 
-for name in [GoogleHashSparse, GoogleHashDense, Hash, GoogleHash] do
- subject = name.new
- puts name, Benchmark.realtime { 500000.times {|n| subject[n] = 4}}.to_s + "   (populate)"
- puts Benchmark.realtime { subject.each{|k, v| }}.to_s + " (each)", ''
+def measure
+ Hitimes::Interval.measure { yield }
+end
 
+def meas string
+ puts "% -23s" % string + measure { yield }.to_s
 end
+
+def go num
+  puts num
+  # get all existing
+  all = [Hash] + Object.constants.grep(/Goog/).reject{|n| n == :GoogleHash}.map{|n| eval n}
+
+  for name in all do
+    GC.start
+    subject = name.new
+    puts
+    puts name
+
+    subject = name.new
+    meas( "populate string ") { num.times {|n| subject['abc'] = 4 } } rescue nil
+    subject = name.new
+    meas( "populate symbol") { num.times {|n| subject[:abc] = 4} } rescue nil
+
+    meas( "populate int") { num.times {|n| subject[n] = 4}}
+    meas("each") { subject.each{|k, v| } }
+
+    begin
+      subject = name.new
+      subject[3] = 4
+      meas("lookup int") { num.times {|n| subject[3]}}
+      subject['abc'] = 3
+      subject[:abc] = 3
+
+      meas("lookup string")  { num.times {|n| subject['abc']}}
+      meas( "lookup symbol" ) { num.times {|n| subject[:abc]}}
+    rescue
+    end
+  end
+end
+
+num = 200_000
+go num if $0 ==__FILE__

data/ext/extconf.rb

@@ -2,7 +2,7 @@ require 'mkmf'
 require 'erb'
 require 'rubygems'
 require 'sane'
-
+puts 'got', xsystem("ls")
 # build google's lib locally...
 
 dir = Dir.pwd
@@ -23,11 +23,68 @@ end
 
 # create our files...
 # currently we're int only...hmm...
-# ltodo 64 bit compat...
+# ltodo if I am using longs, this 31 needs to be a 63 on 64 bit machines...
+# if I ever use longs :)
+
+# my goal is...ruby friendly hashers
 
-for type, setup_code in {'sparse' => nil, 'dense' => 'set_empty_key(1<<31);' } do
-  template = ERB.new(File.read('template/go.cpp'))
-  File.write(type.to_s + '.cpp', template.result(binding))
+if OS.bits == 32
+  unreachable_int = 31
+else
+    unreachable_int = 63
 end
 
+ruby_key =  {:convert_keys_from_ruby => "", :convert_keys_to_ruby => "", :key_type => "VALUE", :unreachable_key => "current_instance"} # TODO NULL is false here?
+long_key = {:assert_key_type => 'T_FIXNUM', :convert_keys_from_ruby => "FIX2LONG", 
+  :convert_keys_to_ruby => "LONG2FIX", :key_type => "long", :unreachable_key => "1<<#{unreachable_int}"}  
+int_key = {:assert_key_type => 'T_FIXNUM', :convert_keys_from_ruby => "FIX2INT", 
+  :convert_keys_to_ruby => "INT2FIX", :key_type => "int", :unreachable_key => "1<<#{unreachable_int}"}
+
+
+ruby_value =  {:value_type => "VALUE"}
+long_value = {:assert_value_type => 'T_FIXNUM', :convert_values_from_ruby => "FIX2LONG", 
+  :convert_values_to_ruby => "LONG2FIX", :value_type => "long"}
+
+
+
+int_to_ruby = long_key.merge(ruby_value)
+ruby_to_ruby = ruby_key.merge(ruby_value)
+
+init_funcs = []
+
+for options in [int_to_ruby, ruby_to_ruby] do
+ for type in ['sparse', 'dense'] do
+  raise unless options[:value_type] && options[:key_type]
+  
+  # create local variables so that the template can look cleaner
+  unreachable_key = options[:unreachable_key]
+  convert_keys_from_ruby = options[:convert_keys_from_ruby]
+  convert_keys_to_ruby = options[:convert_keys_to_ruby]
+  key_type = options[:key_type]
+  value_type = options[:value_type]
+  english_key_type = options[:key_type] == 'VALUE' ? 'ruby' : options[:key_type]
+  english_value_type = options[:value_type] == 'VALUE' ? 'ruby' : options[:value_type]
+  
+  assert_key_type = options[:assert_key_type]
+  convert_values_from_ruby = options[:convert_values_from_ruby]
+  convert_values_to_ruby = options[:convert_values_to_ruby]
+  
+  
+  if options[:key_type] == 'VALUE'
+    extra_hash_params =  ", hashrb, eqrb"  # use these methods for comparison
+    # ltodo is that the right hash -- is is type_t
+  end
+  
+  template = ERB.new(File.read('template/google_hash.cpp.erb'))  
+  descriptor = type + '_' + english_key_type + '_to_' + english_value_type;
+  File.write(descriptor + '.cpp', template.result(binding))
+  init_funcs << "init_" + descriptor
+ end
+end
+
+# write our Init method
+
+template = ERB.new(File.read('template/main.cpp.erb'))  
+File.write 'main.cpp', template.result(binding)
+
 create_makefile('google_hash')

data/ext/go.bat

@@ -1 +1,2 @@
-ruby extconf.rb && make clean && make && ruby benchmark.rb
+rm *.cpp 
+ruby extconf.rb && make clean && make && ruby ..\spec\spec.google_hash.rb

data/ext/scale.rb

@@ -0,0 +1,6 @@
+require 'sane'
+require_rel 'benchmark'
+
+for n in [100_000, 500_000, 1_000_000, 10_000_000, 150000000] do # 1_000_000 is about the last one that doesn't have an awful each
+ go n
+end

data/ext/template/google_hash.cpp.erb

@@ -0,0 +1,261 @@
+#include <iostream>
+#include <google/<%= type %>_hash_map>
+#include <ruby.h>
+
+// much code stolen shamelessly from lourens' cb gem
+
+using google::<%= type %>_hash_map;      // namespace where class lives by default
+using std::cout;
+using std::endl;
+<% if OS.linux? %>
+  #include <ext/hash_set>
+<% end %>
+using __gnu_cxx::hash;  // or __gnu_cxx::hash, or maybe tr1::hash, depending on your OS
+extern "C" {
+
+// some helpers
+
+struct eqstr
+{
+  bool operator()(const char* s1, const char* s2) const
+  {
+    return (s1 == s2) || (s1 && s2 && strcmp(s1, s2) == 0);
+  }
+};
+
+static hash<const char*> H;
+
+// hashing it is like hash<const char*>
+
+static ID id_eql, id_hash;
+
+struct eqrb
+{
+  bool operator()(const VALUE s1, const VALUE s2) const
+  {
+    // speeds up populate int 18/11
+    // slows down string 21/22
+    // ltodo
+    if(s1 == s2) {
+      return true;
+    }
+    
+    // this line from object.c's rb_eql 
+    // lookup 0.278 -> 0.26 
+
+    return RTEST(rb_funcall(s1, id_eql, 1, s2));
+  }
+};
+
+struct hashrb
+{
+    size_t operator()(VALUE hash_me) const
+      {
+           // stolen from hash.c populate -> 0.64 0.625
+        
+           // hmm
+           // use our own custom hash function for well known types
+           // to avoid a function call
+           // this speeds up ints 29/44
+           // and speeds up string 26/22
+           // though I suppose we could 
+           
+            switch (TYPE(hash_me)) {
+              // ltodo does this help?
+              // if so more types?
+              case T_FIXNUM:              
+              case T_FLOAT:
+              case T_SYMBOL:
+               // ltodo
+                return hash_me;
+            <% unless RUBY_VERSION < '1.9' %>
+              case T_BIGNUM:
+	              return LONG2FIX(((long*)(RBIGNUM_DIGITS(hash_me)))[0]); // its first digit...I'm thinkin'
+            <% end %>
+	            case T_STRING:
+	             //return H(StringValueCStr(hash_me)); // populate/lookup 0.26 -> 0.23 [core is 0.16 somehow]
+	             // perhaps they cache?
+	             return H(RSTRING_PTR(hash_me)); // 0.23 -> -.22
+	          }        
+           
+            VALUE hval = rb_funcall(hash_me, id_hash, 0);
+            
+            retry:
+            switch (TYPE(hval)) {
+              case T_FIXNUM:
+	              return hval;
+<% unless RUBY_VERSION < '1.9' %>
+              case T_BIGNUM:
+	              return LONG2FIX(((long*)(RBIGNUM_DIGITS(hval)))[0]);
+<% end %>
+
+              default:
+	              hval = rb_to_int(hval);
+	              goto retry;
+        }  
+  
+      }
+};
+
+
+
+/* we end up not needing this...or at least not using it, I don't know if it would be faster than using the default or not
+struct eqint
+{
+  inline bool operator()(int s1, int s2) const
+  {
+    return s1 == s2;
+  }
+};
+*/
+
+
+typedef struct {
+  <%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> > *hash_map;
+} RCallback;
+
+
+static void mark_hash_map_values(RCallback *incoming) {
+  <% if value_type == 'VALUE' || key_type == 'VALUE' %>
+
+    for(<%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
+     
+     <% if value_type == 'VALUE' %>
+       rb_gc_mark(it->second);
+     <% end %>
+     
+     <% if key_type == 'VALUE' %>
+       rb_gc_mark(it->first);
+     <% end %>
+    }
+  <% end %>
+}
+
+static void free_hash_callback(RCallback* cb) {
+  //  delete cb->hash_map;
+}
+
+static VALUE callback_alloc _((VALUE)); // what does this line do?
+
+static VALUE
+callback_alloc( VALUE klass )
+{
+    RCallback* cbs;
+    VALUE current_instance = Data_Make_Struct(klass, RCallback, mark_hash_map_values, free_hash_callback, cbs);
+    
+    cbs->hash_map = new <%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >();
+    <% if unreachable_key && type == 'dense' %>
+       cbs->hash_map->set_empty_key(<%= unreachable_key %>);
+    <% end %> 
+    
+    return current_instance;
+}
+
+
+#define GetCallbackStruct(obj)	(Check_Type(obj, T_DATA), (RCallback*)DATA_PTR(obj))
+
+
+static VALUE
+rb_mri_hash_new(VALUE freshly_created) {
+
+  // we don't actually have anything special to do here...
+  // unless someone subclassed us or something [?]
+  // ltodo test
+  return freshly_created;
+}
+
+
+static VALUE rb_ghash_set(VALUE cb, VALUE set_this, VALUE to_this) {
+  <% if assert_key_type %>
+    if(!(TYPE(set_this) == <%= assert_key_type %>)) {
+       rb_raise(rb_eTypeError, "not valid value #{assert_key_type}");
+    }
+  <% end %>
+  RCallback* cbs = GetCallbackStruct(cb);
+  (*cbs->hash_map)[ <%= convert_keys_from_ruby %>(set_this)] = <%= convert_values_from_ruby %>(to_this);  
+  return to_this; // ltodo test that it returns value...
+}
+
+static VALUE rb_ghash_get(VALUE cb, VALUE get_this) {
+  // TODO optionally not assert [?]
+  <% if assert_key_type %>
+    if(!(TYPE(get_this) == <%= assert_key_type %>)) {
+       rb_raise(rb_eTypeError, "not valid value #{assert_key_type}");
+    }
+  <% end %>
+  RCallback* cbs = GetCallbackStruct(cb);
+  
+  <%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator out = cbs->hash_map->find(<%= convert_keys_from_ruby %>(get_this));
+  
+  if(out == cbs->hash_map->end()) { // not found...hmm...is this False, though?
+    return Qnil;
+  } else {
+    return <%= convert_values_to_ruby %>(out->second);
+  }
+}
+
+static VALUE rb_ghash_each(VALUE cb) {
+    RCallback* incoming = GetCallbackStruct(cb);
+    for(<%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
+      rb_yield_values(2, <%= convert_keys_to_ruby %>(it->first), <%= convert_values_to_ruby %>(it->second));
+    }
+    return cb;  
+}
+  
+static VALUE rb_ghash_values(VALUE cb) {
+    RCallback* incoming = GetCallbackStruct(cb);
+    VALUE out = rb_ary_new2(incoming->hash_map->size());
+     for(<%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %>  >::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
+      rb_ary_push(out, <%= convert_values_to_ruby %>(it->second));
+    } 
+    return out;
+}
+  
+static VALUE rb_ghash_keys(VALUE cb) {
+    RCallback* incoming = GetCallbackStruct(cb);
+    VALUE out = rb_ary_new2(incoming->hash_map->size());
+     for(<%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
+      rb_ary_push(out, <%= convert_keys_to_ruby %>(it->first));
+    } 
+    return out;
+}
+
+
+// only yields for now :)
+
+static VALUE rb_ghash_combination_2(VALUE cb) {
+    RCallback* incoming = GetCallbackStruct(cb);
+    
+     for(<%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
+       
+       <%= type %>_hash_map< <%= key_type %>, <%= value_type %> <%= extra_hash_params %> >::iterator next = it;
+       ++next; // advance it
+       
+       while(next != incoming->hash_map->end()) {
+         rb_yield_values(2, <%= convert_keys_to_ruby %>(it->first), <%= convert_keys_to_ruby %>(next->first));
+         ++next;
+       }
+    }
+    return cb;
+}
+
+
+void init_<%= type %>_<%= english_key_type %>_to_<%= english_value_type %>() {
+  
+    VALUE rb_cGoogleHashLocal;
+    rb_cGoogleHashLocal = rb_define_class("GoogleHash<%= type.capitalize %><%= english_key_type.capitalize %>To<%= english_value_type.capitalize %>", rb_cObject);
+
+    rb_define_alloc_func(rb_cGoogleHashLocal, callback_alloc); // I guess it calls this for us, pre initialize... 
+
+    rb_define_method(rb_cGoogleHashLocal, "initialize", RUBY_METHOD_FUNC(rb_mri_hash_new), 0); 
+    rb_define_method(rb_cGoogleHashLocal, "[]=", RUBY_METHOD_FUNC(rb_ghash_set), 2); 
+    rb_define_method(rb_cGoogleHashLocal, "[]", RUBY_METHOD_FUNC(rb_ghash_get), 1); 
+    rb_define_method(rb_cGoogleHashLocal, "each", RUBY_METHOD_FUNC(rb_ghash_each), 0);
+    rb_define_method(rb_cGoogleHashLocal, "values", RUBY_METHOD_FUNC(rb_ghash_values), 0); 
+    rb_define_method(rb_cGoogleHashLocal, "keys", RUBY_METHOD_FUNC(rb_ghash_keys), 0); 
+    rb_define_method(rb_cGoogleHashLocal, "keys_combination_2", RUBY_METHOD_FUNC(rb_ghash_combination_2), 0); 
+    id_eql = rb_intern("eql?");
+    id_hash = rb_intern("hash");
+  } 
+}
+

data/ext/template/main.cpp.erb

@@ -0,0 +1,19 @@
+
+extern "C" {
+#include <ruby.h>
+// like extern void init_dense_ruby_to_ruby_;
+<% init_funcs.each do |func| %>
+  <%=  "extern void #{func}();" %>
+<% end %>
+
+void Init_google_hash() {
+  
+<% init_funcs.each do |func| %>
+  <%=  func %>();
+<% end %>
+  
+  rb_eval_string("GoogleHash = GoogleHashDenseRubyToRuby"); // give a default
+ }
+ 
+}
+

data/results.txt

@@ -1,33 +1,23 @@
-1.9 mingw:
-
-GoogleHashSparse
-0.53125   (populate)
-0.078125 (each)
-
-GoogleHashDense
-0.1875   (populate)
-0.078125 (each)
-
-Hash
-0.359375   (populate)
-1.1875 (each)
-
-
+Here some 1.9 mingw results
+
+http://pastie.org/752318
+
+
+
 ruby 1.8.6 mingw:
-
+
 GoogleHashSparse
 0.625   (populate)
 0.546875(each)
-
+
 GoogleHashDense
 0.234375(populate)
 0.421875(each)
-
-Hash
+
+Hash
 0.5   (populate)
 0.53125 (each)
 
-
 1.9.2 linux:
 
 GoogleHashSparse

data/spec/spec.google_hash.rb

@@ -0,0 +1,170 @@
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'sane'
+require_rel '../ext/google_hash.so'
+require 'spec/autorun'
+
+describe "google_hash" do
+
+  before do
+   @subject = GoogleHashSparseLongToRuby.new
+  end
+
+  it "should be instantiable" do
+    # nothing
+  end
+
+  it "should allow you to set a key" do
+    @subject[33] = 'abc'
+  end
+
+  it "should allow you to retrieve a key" do
+    @subject[33] = 'abc'
+    @subject[33].should == 'abc'
+  end
+
+  it "should allow you to iterate" do
+   @subject[33] = 'abc'
+   @subject[44] = 'def'
+   all_got = []
+   @subject.each{|k, v|
+    all_got << v
+   }
+   assert all_got.sort == ['abc', 'def']
+  end
+
+  it "should have all the methods desired" do
+    pending "need"
+    # guess these could all be tests, themselves...
+    @subject.each_key {}
+    @subject.each_value{}
+    @subject.each{}
+    @subject[33] = 'abc'
+    @subject.length.should == 1
+    @subject.delete(33).should == 'abc'
+    @subject.clear
+    @subject.length.should == 0
+  end
+
+  it "should not leak" do
+    pending "testing if it leaks"
+  end
+  
+  def populate(a)
+    a['abc'] = 'def'
+    a['bbc'] = 'yoyo'
+  end
+  
+  it "should not die with GC" do
+    a = GoogleHashSparseRubyToRuby.new
+    populate(a)
+    a['abc'].should == 'def'
+    a['bbc'].should == 'yoyo'
+    GC.start
+    a.keys.each{|k| k}
+    a.values.each{|v| v}
+  end
+    
+
+  it "should work with value => value" do
+    a = GoogleHashSparseRubyToRuby.new
+    a['abc'] = 'def'
+    a['abc'].should == 'def'
+    a = GoogleHashDenseRubyToRuby.new
+    a['abc'] = 'def'
+    a['abc'].should == 'def'
+  end
+
+  it "should have better namespace" do
+    pending do
+      GoogleHash::Sparse
+    end
+  end
+
+  it "should disallow non numeric keys" do
+    lambda { @subject['33']}.should raise_error(TypeError)
+  end
+
+#  it "should allow for non numeric keys" do
+    # todo instantiate new type here...
+    # todo allow for floats, ints, symbols, strings [freeze 'em]
+    # wait are any of those actually useful tho?
+#    @subject['33'] = 33
+#    @subject['33'].should == 33
+#  end
+
+  it "should return nil if key is absent" do
+    @subject[33].should be_nil
+  end
+
+  it "should work with 0's" do
+   @subject[0] = 'abc'
+   @subject[0].should == 'abc'
+  end
+
+  it "should do BigNums" do
+    pending "if necessary"
+  end
+
+  it "should do longs eventually" do
+    pending "caring about 64 bit"
+  end
+
+  it "should do 63 bit thingy for longs on 64 bit" do
+    pending "caring about 64 bit"
+  end
+
+  it "should have sets"
+  it "should have Set#each"
+
+  it "Set should have #combination calls" do
+    @subject[33] = 34
+    @subject[36] = 37
+    @subject.keys_combination_2{|a, b|
+      assert a == 33
+      assert b == 36
+    }
+    
+  end
+  
+  it "Set should have #combination calls with more than one" do
+    @subject[1] = 34
+    @subject[2] = 37
+    @subject[3]= 39
+    sum = 0
+    count = 0
+    @subject.keys_combination_2{|a, b|
+      sum += a
+      sum += b
+      count += 1
+    }
+    assert count == 3
+    assert sum == 1 + 2 + 1 + 3 + 2 + 3
+  end
+
+
+  it "should have an Array for values, keys" do
+    @subject[33] = 34
+    @subject.keys.should == [33]
+    @subject.values.should == [34]
+  end
+  
+  it "should work with all Longs" do
+    a = GoogleHashDenseLongToLong.new
+    a[3] = 4
+    a[3].should == 4
+  end
+  
+  it "should raise on errant values" do
+    a = GoogleHashDenseLongToLong.new
+    proc { a[3] = 4}.should raise_error
+  end  
+  
+  it "should have an Enumerator for values, keys, on demand"
+  
+  it "should have a block for values, keys, on demand"
+  
+  it "should have real sets"
+  
+  it "should skip GC when native to native"
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: google_hash
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - rogerdpack
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-15 00:00:00 +00:00
+date: 2009-12-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,8 +26,8 @@ description: Ruby wrappers to the google hash library
 email: rogerdpack@gmail.com
 executables: []
 
-extensions: 
-- ext/extconf.rb
+extensions: []
+
 extra_rdoc_files: 
 - README
 files: 
@@ -37,7 +37,7 @@ files:
 - ext/benchmark.rb
 - ext/extconf.rb
 - ext/go.bat
-- ext/main.cpp
+- ext/scale.rb
 - ext/sparsehash-1.5.2/AUTHORS
 - ext/sparsehash-1.5.2/COPYING
 - ext/sparsehash-1.5.2/ChangeLog
@@ -115,9 +115,10 @@ files:
 - ext/sparsehash-1.5.2/vsprojects/sparsetable_unittest/sparsetable_unittest.vcproj
 - ext/sparsehash-1.5.2/vsprojects/time_hash_map/time_hash_map.vcproj
 - ext/sparsehash-1.5.2/vsprojects/type_traits_unittest/type_traits_unittest.vcproj
-- ext/template/go.cpp
+- ext/template/google_hash.cpp.erb
+- ext/template/main.cpp.erb
 - results.txt
-- test/spec.go
+- spec/spec.google_hash.rb
 has_rdoc: true
 homepage: http://github.com/rdp/ruby_google_hash
 licenses: []
@@ -146,5 +147,5 @@ rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Ruby wrappers to the google hash library
-test_files: []
-
+test_files: 
+- spec/spec.google_hash.rb

data/ext/main.cpp

@@ -1,12 +0,0 @@
-extern "C" {
-#include <ruby.h>
-extern void init_dense();
-extern void init_sparse();
-
-void Init_google_hash() {
-  init_dense();
-  init_sparse();
-  rb_eval_string("GoogleHash = GoogleHashDense");
-}
-}
-

data/ext/template/go.cpp

@@ -1,114 +0,0 @@
-#include <iostream>
-#include <google/<%= type %>_hash_map>
-#include <ruby.h>
-
-using google::<%= type %>_hash_map;      // namespace where class lives by default
-using std::cout;
-using std::endl;
-<% if !OS.windows? %>
-#include <ext/hash_set>
-<% end %>
-using __gnu_cxx::hash;  // or __gnu_cxx::hash, or maybe tr1::hash, depending on your OS
-extern "C" {
-
-struct eqstr
-{
-  bool operator()(const char* s1, const char* s2) const
-  {
-    return (s1 == s2) || (s1 && s2 && strcmp(s1, s2) == 0);
-  }
-};
-
-
-struct eqint
-{
-  inline bool operator()(int s1, int s2) const
-  {
-    return s1 == s2;
-  }
-};
-
-typedef struct {
-  <%= type %>_hash_map<int, VALUE> *hash_map;
-} RCallback;
-
-static VALUE rb_cGoogleHash<%= type %>;
-
-
-static void mark_hash_map_values(RCallback *incoming) {
-  for(<%= type %>_hash_map<int, VALUE>::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
-     rb_gc_mark(it->second);
-  }
-}
-
-static void free_hash_callback(RCallback* cb) {
-  //  delete cb->hash_map;
-}
-
-static VALUE callback_alloc _((VALUE)); // what does this line do?
-
-static VALUE
-callback_alloc( VALUE klass )
-{
-    VALUE cb;
-    RCallback* cbs;
-    cb = Data_Make_Struct(klass, RCallback, mark_hash_map_values, free_hash_callback, cbs);
-    cbs->hash_map = new <%= type %>_hash_map<int, VALUE>();
-    <% if setup_code %>
-	 cbs->hash_map-><%= setup_code %>;
-    <% end %> 
-    return cb;
-}
-
-#define GetCallbackStruct(obj)	(Check_Type(obj, T_DATA), (RCallback*)DATA_PTR(obj))
-
-static VALUE
-rb_mri_hash_new(VALUE freshly_created) {
-
-  // we don't actually have anything special to do here...
-  return freshly_created;
-}
-
-
-static VALUE rb_ghash_set(VALUE cb, VALUE set_this, VALUE to_this) {
-  if(!(TYPE(set_this) == T_FIXNUM)) {
-     rb_raise(rb_eTypeError, "not valid value");
-  }
-  RCallback* cbs = GetCallbackStruct(cb);
-  (*cbs->hash_map)[FIX2INT(set_this)] = to_this;  
-  return to_this; // ltodo test that it returns value...
-}
-
-static VALUE rb_ghash_get(VALUE cb, VALUE get_this) {
-  if(!(TYPE(get_this) == T_FIXNUM)) {
-     rb_raise(rb_eTypeError, "not valid value");
-  }
-  RCallback* cbs = GetCallbackStruct(cb);
-  VALUE out = (*cbs->hash_map)[FIX2INT(get_this)];
-  // todo if out == 0 return Qnil
-  return out;
-}
-
-  static VALUE rb_ghash_each(VALUE cb) {
-    RCallback* incoming = GetCallbackStruct(cb);
-    // TODO assert block given
-  for(<%= type %>_hash_map<int, VALUE>::iterator it = incoming->hash_map->begin(); it != incoming->hash_map->end(); ++it) {
-    rb_yield_values(2, INT2FIX(it->first), it->second);
-  }
-  return cb;
-  
-  }
-
-void init_<%= type %>() {
-    rb_cGoogleHash<%= type %> = rb_define_class("GoogleHash<%= type.capitalize %>", rb_cObject);
-
-    rb_define_alloc_func(rb_cGoogleHash<%= type %>, callback_alloc); // I guess it calls this for us, pre initialize... 
-
-    rb_define_method(rb_cGoogleHash<%= type %>, "initialize", RUBY_METHOD_FUNC(rb_mri_hash_new), 0); 
-    rb_define_method(rb_cGoogleHash<%= type %>, "[]=", RUBY_METHOD_FUNC(rb_ghash_set), 2); 
-    rb_define_method(rb_cGoogleHash<%= type %>, "[]", RUBY_METHOD_FUNC(rb_ghash_get), 1); 
-    rb_define_method(rb_cGoogleHash<%= type %>, "each", RUBY_METHOD_FUNC(rb_ghash_each), 0); 
-
-  } 
-}
-

data/test/spec.go

@@ -1,70 +0,0 @@
-require 'sane'
-require_rel '../ext/google_hash.so'
-require 'spec/autorun'
-
-describe GoogleHashSmall do
-
-  before do
-   @subject = GoogleHashSmall.new
-  end
-
-  it "should be instantiable" do
-    # nothing
-  end
-
-  it "should allow you to set a key" do
-    @subject[33] = 'abc'
-  end
-
-  it "should allow you to retrieve a key" do
-    @subject[33] = 'abc'
-    @subject[33].should == 'abc'
-  end
-
-  it "should allow you to iterate" do
-   @subject[33] = 'abc'
-   @subject[44] = 'def'
-   all_got = []
-   @subject.each{|k, v|
-    all_got << v
-   }
-   assert all_got.sort == ['abc', 'def']
-  end
-
-  it "should have all the methods desired" do
-    # guess these could all be tests, themselves...
-    @subject.each_key {}
-    @subject.each_value{}
-    @subject.each{}
-    @subject.delete(33)
-    @subject.clear
-    @subject.length.should == 0
-  end
-
-  it "should not leak" do
-    raise 'not done'
-  end
-
-  it "should have better namespace" do
-    GoogleHash::Space
-  end
-
-  it "should disallow non numeric keys" do
-    @subject['33'].should raise_exception
-  end
-
-  it "should allow for non numeric keys" do
-    # todo instantiate new type here...
-    # todo allow for floats, ints, symbols, strings [freeze 'em]
-    # wait are any of those actually useful tho?
-    @subject['33'] = 33
-    @subject['33'].should == 33
-  end
-
-  # todo do the non sparse, too...
-
-  it "should return nil if key is absent" do
-    @subject[33].should be_nil
-  end
-
-end