google_hash 0.7.0 → 0.8.0

data/README

@@ -21,18 +21,27 @@ populate integer        0.114
 lookup int              0.080
 
 
-GoogleHashSparseIntToInt # said to be much more memory efficient
+GoogleHashSparseIntToInt # said to be more memory efficient
 populate integer        0.242
 #each                   0.046
 lookup int              0.099
 
-These also use significantly less memory, because (if you specify IntToInt, it stores only 4 bytes per int, instead of Ruby's
-usual 20 bytes).  This also frees up Ruby so it doesn't hvae to garbage collect as much.  Yea!
+These also use less memory, because (if you specify IntToInt, it stores only 4 bytes per int, instead of Ruby's
+usual 20 bytes), and usually less overall RAM for the hash store.
+This also frees up Ruby so it doesn't hvae to garbage collect as much.  Yea!
+
+For instance, with 1M ints, doing a GC takes this long, comparatively:
+GoogleHashDenseIntToInt "dense took 0.002"
+"ruby hash took 0.103"
+
+per GC.  And those garbage collects happen all the time, so this is meant to speed those up.
 
 See also the results.txt file for more OS benchmark results.
 
 You can also run your own benchmarks to see how much faster it would be for you ("try before you buy"), see spec/benchmark.rb file.
 
+The best benchmark, of course, is to integrate and run it in your own app.
+
 Here is how it performs, if used as a "replacement" for the Ruby standard Hash:
 
 Ruby Standard Hash
@@ -45,7 +54,7 @@ lookup string           0.642
 lookup symbol           0.082
 
 GoogleHashDenseRubyToRuby
-populate string         0.312
+populate string         0.312 # slower here
 populate symbol         0.136
 populate integer        0.172
 #each                   0.077

data/TODO

@@ -2,4 +2,7 @@ could be faster:
 
 http://code.google.com/p/ulib/wiki/AlignedHashingPerformance
 
-some specs fail [?]
+some specs fail [?]
+
+faster install, yikes!
+  single file for C code...remove unit test junk from sparsehash code?

data/VERSION

@@ -1 +1 @@
-0.7.0
+0.8.0

data/changelog

@@ -1,3 +1,8 @@
+0.8.0:
+  add a delete method for the Sparse** classes
+  actually delete the hashmaps when the object is collected by Ruby, instead of leaking
+  hopefully work with more versions of GCC
+
 0.7.0:
   fix building in linux with newer GCC's, fix building in windows with broken system command (?)
   bump internal google_hash version to 0.8.2

data/ext/clean.bat

@@ -0,0 +1,4 @@
+rm *.cpp 
+rm *.o
+rm *.so
+rm *.def

data/ext/extconf.rb

@@ -37,7 +37,8 @@ else
 end
 
 ruby_key =  {:convert_keys_from_ruby => "", :convert_keys_to_ruby => "", :key_type => "VALUE", :english_key_type => "ruby",
-  :extra_hash_params => ", hashrb, eqrb", :unreachable_key => "current_instance"} # TODO NULL is false here?
+  :extra_hash_params => ", hashrb, eqrb", :unreachable_key => "current_instance"}
+  
 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}"}
   
@@ -46,9 +47,11 @@ int_key = {:assert_key_type => 'T_FIXNUM', :convert_keys_from_ruby => "FIX2INT",
 long_key = {:assert_key_type => 'T_FIXNUM', :convert_keys_from_ruby => "FIX2LONG",
   :convert_keys_to_ruby => "LONG2FIX", :key_type => "long", :unreachable_key => "1<<#{unreachable_long}"}
 
+# currently "big numbers" we handle by storing them as a double
+# TODO floats [does ruby do real doubles underneath?] too
 bignum_as_double_key = {:assert_key_type => ['T_BIGNUM', 'T_FIXNUM'], :convert_keys_from_ruby => "rb_big2dbl",
   :convert_keys_to_ruby => "rb_dbl2big", :key_type => "double", :unreachable_key => "1<<#{unreachable_long}",  # LODO is this a bignum value though? LODO TEST this key on 64 bit!
-  :extra_hash_params => ", hashdouble, eqdouble",
+  #:extra_hash_params => ", hashdouble, eqdouble", # these methods provided natively these days?
   :extra_set_code => "if(TYPE(set_this) == T_FIXNUM)\nset_this = rb_int2big(FIX2INT(set_this));",
   :extra_get_code => "if(TYPE(get_this) == T_FIXNUM) \n get_this = rb_int2big(FIX2INT(get_this));"
 }
@@ -63,8 +66,7 @@ bignum_as_double_value = {:assert_value_type => ['T_BIGNUM', 'T_FIXNUM'], :conve
   :convert_values_to_ruby => "rb_dbl2big", :value_type => "double",
   :extra_set_code2 => "if(TYPE(to_this) == T_FIXNUM)\nto_this = rb_int2big(FIX2INT(to_this));"
 }
-  
-  
+
 init_funcs = []
 
 for key in [ruby_key, int_key, bignum_as_double_key, long_key] do

data/ext/go.bat

@@ -1,6 +1,4 @@
-rm *.cpp 
-rm *.o
-rm *.so
+call clean.bat
 ruby extconf.rb
 call make
 spec.bat

data/ext/spec.bat

@@ -0,0 +1 @@
+ruby -C ../spec spec.google_hash.rb

data/ext/template/google_hash.cpp.erb

@@ -170,35 +170,36 @@ static void mark_hash_map_values(RCallback *incoming) {
 }
 
 static void free_hash_callback(RCallback* cb) {
-  //  delete cb->hash_map;
+  delete cb->hash_map; // I had this line commented out one? huh?
 }
 
-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);
+    VALUE current_instance = Data_Make_Struct(klass, RCallback, mark_hash_map_values, free_hash_callback, cbs); // XXXX the last parameter is just a pointer? huh?
     
     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 %>);
+    <% if type == 'dense' %> 
+       // cbs->hash_map->set_deleted_key(<%= unreachable_key %>);
+       // also needs another one ?
+	   cbs->hash_map->set_empty_key(<%= unreachable_key %>);
     <% end %> 
     
+    <% if type == 'sparse' %> 
+       cbs->hash_map->set_deleted_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
+  // XXXX test
   return freshly_created;
 }
 
@@ -227,8 +228,8 @@ static VALUE rb_ghash_set(VALUE cb, VALUE set_this, VALUE to_this) {
   return to_this; // ltodo test that it returns value...
 }
 
-static VALUE rb_ghash_get(VALUE cb, VALUE get_this, int just_check_for_presence) {
-  // TODO optionally not type check assert anywhere [?]
+static VALUE rb_ghash_get(VALUE cb, VALUE get_this, int just_check_for_presence, int delete_it) {
+  // TODO optionally not type check assert anymore [if it slows down computationally, that is...]
   <% if assert_key_type %>
     if(!(TYPE(get_this) == <%= assert_key_type %>)) {
        <%= "if(!(TYPE(get_this) == #{assert_key_type2}))" if assert_key_type2 %>
@@ -240,26 +241,38 @@ static VALUE rb_ghash_get(VALUE cb, VALUE get_this, int just_check_for_presence)
   
   <%= 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?
+  if(out == cbs->hash_map->end()) { // key not found in hashmap
     if(just_check_for_presence)
       return Qfalse;
-    else
-      return Qnil;
+    else {
+	  // key not found, or delete requested and key not found, return nil
+      return Qnil;
+	}
   } else {
     if(just_check_for_presence)
       return Qtrue;
-    else
-      return <%= convert_values_to_ruby %>(out->second);
+    else {
+      VALUE out2 = <%= convert_values_to_ruby %>(out->second);
+	  if(delete_it) {
+	    cbs->hash_map->erase(out);
+		// still return it
+	  }
+	  return out2;
+	}
   }
   
 }
 
 static VALUE rb_ghash_get_value(VALUE cb, VALUE get_this) {
-  return rb_ghash_get(cb, get_this, 0);
+  return rb_ghash_get(cb, get_this, 0, 0);
 }
 
 static VALUE rb_ghash_get_present(VALUE cb, VALUE get_this) {
-  return  rb_ghash_get(cb, get_this, 1);
+  return rb_ghash_get(cb, get_this, 1, 0);
+}
+
+static VALUE rb_ghash_delete(VALUE cb, VALUE delete_this) {
+  return rb_ghash_get(cb, delete_this, 0, 1);
 }
 
 static VALUE rb_ghash_size(VALUE cb) {
@@ -267,6 +280,11 @@ static VALUE rb_ghash_size(VALUE cb) {
   return INT2FIX(incoming->hash_map->size());
 }
 
+static VALUE rb_ghash_clear(VALUE cb) {
+  RCallback* incoming = GetCallbackStruct(cb);
+  incoming->hash_map->clear();
+  return cb;
+}
 
 static VALUE rb_ghash_each(VALUE cb) {
     RCallback* incoming = GetCallbackStruct(cb);
@@ -325,10 +343,14 @@ void init_<%= type %>_<%= english_key_type %>_to_<%= english_value_type %>() {
     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_value), 1); 
-    rb_define_method(rb_cGoogleHashLocal, "each", RUBY_METHOD_FUNC(rb_ghash_each), 0);
+    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, "has_key?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);
+    <% if type == 'sparse' %>  // only ones its safe on for now, till I get it figured out...
+      rb_define_method(rb_cGoogleHashLocal, "delete", RUBY_METHOD_FUNC(rb_ghash_delete), 1);
+      rb_define_method(rb_cGoogleHashLocal, "clear", RUBY_METHOD_FUNC(rb_ghash_clear), 0);	
+	<% end %>
     rb_define_method(rb_cGoogleHashLocal, "key?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);
     rb_define_method(rb_cGoogleHashLocal, "member?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);
     rb_define_method(rb_cGoogleHashLocal, "include?", RUBY_METHOD_FUNC(rb_ghash_get_present), 1);

data/spec/bench_gc.rb

@@ -0,0 +1,20 @@
+
+require 'google_hash'
+require 'sane'
+require 'benchmark'
+sparse = false
+dense = false
+ruby = true
+if sparse
+ a = GoogleHashSparseIntToInt.new
+ p 'sparse'
+elsif dense
+ p 'dense'
+ a = GoogleHashDenseIntToInt.new
+else
+ p 'ruby'
+ a = []
+end
+took = Benchmark.realtime { 200_00000.times {|i| a[i] = i} }
+
+ p 'took', took.group_digits, OS.rss_bytes.group_digits, Benchmark.realtime { GC.start}.group_digits, ObjectSpace.count_objects

data/spec/spec.google_hash.rb

@@ -49,24 +49,44 @@ describe "google_hash" do
   
   it "should have all the methods desired" do
     # guess these could all be tests, themselves...
-    @subject.each{}
-    @subject[33] = 'abc'
+    @subject.each{|k, v| raise}
+	@subject[33] = 34
     @subject.length.should == 1
-    @subject.each{}
+	sum = 0
+    @subject.each{|k, v| sum += k; sum += v}
+	sum.should == (33+34)
+    @subject[33] = 'abc'
     @subject.each{|k, v|
       k.should == 33
       v.should == 'abc'
     }
-    @subject.delete(33).should == 'abc' # guess we don't do delete yet [?]
-    @subject.length.should == 0
-    @subject[33] = 'abc'
-    @subject.length.should == 1
+	
     @subject.clear
+	@subject.length.should == 0
+	@subject.keys.should == []
+    @subject[33] = 'abc'
+    @subject.delete(33).should == 'abc' # we don't actually have these methods yet :)
     @subject.length.should == 0
+    @subject[33] = 'def'
+    @subject[33].should == 'def'	
   end
   
-  it 'should not be able to set the absent key for double' do
-    fail
+  pending "they should all have a clear method" do
+    for kls in get_all_classes
+	  kls.new.clear
+	end  
+  end
+  
+  it 'should not be able to set the absent key for double' do  
+    if OS.bits == 32
+      unreachable_int = 31
+      unreachable_long = 31
+    else
+      unreachable_int = 31
+      unreachable_long = 63  
+    end
+    proc { GoogleHashSparseIntToInt[1<<unreachable_int] = 3 } # should raise...
+    proc { GoogleHashSparseLongToInt[1<<unreachable_long] = 3 }
   end
 
   def populate(a)
@@ -122,11 +142,10 @@ describe "google_hash" do
   end
 
   if OS.bits == 64
-    it "should disallow keys like 1<<40 for ints on 64 bit"
+    it "should disallow keys like 1<<40 for ints on 64 bit, since they'll be lost"
   end
 
-  it "should have sets"
-  it "should have Set#each"
+  it "should have sets, Set#each, etc."
 
   it "Set should have #combination calls" do
     @subject[33] = 34
@@ -176,29 +195,34 @@ describe "google_hash" do
     a[10000000000000000000].should == 1
   end
   
-  it "should not leak" do
-    pending 'something that might leak'
-    a = GoogleHashDenseIntToInt.new
+  it "should not leak [?]" do
+    a = GoogleHashSparseIntToInt.new
     100_000.times {
       a[1] = 1
       a[1]
       a.each{|k, v|}
       a.delete(1) rescue nil
     }
+	a.length.should == 0
     OS.rss_bytes.should be < 25_000_000
   end
   
+  it "should do delete from dense" do
+    GoogleHashDenseDoubleToInt.new.delete('a').should == nil
+  end
+  
   it "should do int values as doubles" do
     a = GoogleHashDenseDoubleToInt.new
     a[1] = 1
     a[1].should == 1
   end
 
-  it "should do float values as doubles" do
-    pending "interest in floats"
-    a = GoogleHashDenseDoubleToInt.new
-    a[1.0] = 1
-    a[1.0].should == 1
+  it "should do float values as doubles, too, not just big numbers" do
+    pending "request" do
+      a = GoogleHashDenseDoubleToInt.new
+      a[1.0] = 1
+      a[1.0].should == 1
+	end
   end
   
   it "should do bignum to doubles et al" do
@@ -220,25 +244,16 @@ describe "google_hash" do
     a[10000000000000000000] = 'abc'
   end
   
-  it 'should be able to delete bignums without leaking' do
-    pending
-    a = GoogleHashDenseBignumToBignum.new
-    100_000.times {
-      a[10000000000000000000] = 1
-      a.size.should == 1
-      a.delete[10000000000000000000]
-      a.size.should == 0
-    }
-    assert OS.rss_bytes < 100_000
-  end
-  
-  it "should have an Enumerator for values, keys, an on demand, getNext enumerator object..."
+  it "should have an Enumerator return for values, keys [?] instead of an array?"
   
-  it "should have a block access for values, keys" do
-    pending "interest"
-    @a[3] = 4
-    a.each_value {}
-    a.each_key {}
+  it "should have a block access for just values, or just keys" do
+    pending "interest" do
+      @subject[3] = 4
+	  sum = 0
+      @subject.each_value {|v| sum += v}
+      @subject.each_key {|k| sum += k}
+	  sum.should == 7
+	end
   end
   
   it "should have nice inspect" do
@@ -248,24 +263,29 @@ describe "google_hash" do
     a.inspect.should == "GoogleHashSparseIntToRuby {3=>4,4=>5}"
   end
   
-  it "should have sets, too, not just hashes"
-  
   it "should skip GC when native to native" do
-    # tough to test...
+    pending 'caring, get from gc_bench.rb'
+  end
+  
+  def get_all_classes
+    Object.constants.grep(/googlehash/i).map{|c| Object.const_get(c) }
   end
   
   it "should allow for setting the right keys" do
-    all_classes = Object.constants.grep(/googlehash/i).map{|c| Object.const_get(c) }
-    all_classes.select{|c| c.to_s =~ /(int|long)to/i}.each{|c| 
+    all_classes = get_all_classes
+    all_classes.select{|c| c.to_s =~ /(int|long|double)to/i}.each{|c| 
       p c
       keys = [0, 1, -1, 1<<29]
       if OS.bits == 64
-       keys << (1<<61)
+        keys << (1<<61)
       end
       keys.each{|k|
         instance = c.new
+		instance[k].should == nil
         instance[k] = 0
+        instance[k-1] = 2
         instance[k].should == 0
+        instance[k-1].should == 2
       }
     }
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google_hash
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-10 00:00:00.000000000 Z
+date: 2013-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sane
@@ -58,6 +58,7 @@ files:
 - TODO
 - VERSION
 - changelog
+- ext/clean.bat
 - ext/extconf.rb
 - ext/go.bat
 - ext/sparsehash-1.8.1/AUTHORS
@@ -142,12 +143,15 @@ files:
 - ext/sparsehash-1.8.1/vsprojects/sparsetable_unittest/sparsetable_unittest.vcproj
 - ext/sparsehash-1.8.1/vsprojects/time_hash_map/time_hash_map.vcproj
 - ext/sparsehash-1.8.1/vsprojects/type_traits_unittest/type_traits_unittest.vcproj
+- ext/spec.bat
 - ext/template/google_hash.cpp.erb
 - ext/template/main.cpp.erb
 - results.txt
+- spec/bench_gc.rb
 - spec/benchmark.rb
 - spec/scale.rb
 - spec/spec.google_hash.rb
+- to_build_locally_run_ext_go_bat
 homepage: http://github.com/rdp/ruby_google_hash
 licenses: []
 post_install_message: 
@@ -168,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Ruby wrappers to the google hash library