google_hash 0.0.0 → 0.1.1

data/README

@@ -2,7 +2,7 @@ This is a ruby gem that wraps google's "sparse" and "dense" hashes.
 
 Current usage:
 
-a = GoogleHash.new
+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.

data/Rakefile

@@ -2,10 +2,10 @@ require 'jeweler'
 Jeweler::Tasks.new do |gemspec|
     gemspec.name = "google_hash"
     gemspec.summary = "Ruby wrappers to the google hash library"
-    gemspec.description = "A different and possibly longer explanation of"
+    gemspec.description = gemspec.summary
     gemspec.email = "rogerdpack@gmail.com"
     gemspec.homepage = "http://github.com/rdp/ruby_google_hash"
     gemspec.authors = ["rogerdpack"]
-    gemspec.add_development_dependency('sane')
+    gemspec.add_dependency('sane')
 end
 

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.1

data/ext/benchmark.rb

@@ -0,0 +1,9 @@
+require './google_hash'
+require 'benchmark'
+
+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)", ''
+
+end

data/ext/extconf.rb

@@ -1,15 +1,33 @@
 require 'mkmf'
+require 'erb'
 require 'rubygems'
 require 'sane'
 
 # build google's lib locally...
+
 dir = Dir.pwd
 Dir.chdir 'sparsehash-1.5.2' do
   dir = dir + '/local_installed'
   command = "sh configure --prefix=#{dir} && make && make install"
   puts command
-  system command
+  # only if necessary
+  system command unless File.directory?(dir)
 end
 
 $CFLAGS += " -I./local_installed/include "
+
+if RUBY_VERSION < '1.9'
+ # appears to link using gcc on 1.8 [mingw at least]
+ $LDFLAGS += " -lstdc++ "
+end
+
+# create our files...
+# currently we're int only...hmm...
+# ltodo 64 bit compat...
+
+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))
+end
+
 create_makefile('google_hash')

data/ext/go.bat

@@ -0,0 +1 @@
+ruby extconf.rb && make clean && make && ruby benchmark.rb

data/ext/main.cpp

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,114 @@
+#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/results.txt

@@ -0,0 +1,57 @@
+1.9 mingw:
+
+GoogleHashSparse
+0.53125   (populate)
+0.078125 (each)
+
+GoogleHashDense
+0.1875   (populate)
+0.078125 (each)
+
+Hash
+0.359375   (populate)
+1.1875 (each)
+
+
+ruby 1.8.6 mingw:
+
+GoogleHashSparse
+0.625   (populate)
+0.546875(each)
+
+GoogleHashDense
+0.234375(populate)
+0.421875(each)
+
+Hash
+0.5   (populate)
+0.53125 (each)
+
+
+1.9.2 linux:
+
+GoogleHashSparse
+0.3342118263244629   (populate)
+0.05078697204589844 (each)
+
+GoogleHashDense
+0.14588713645935059   (populate)
+0.056185007095336914 (each)
+
+Hash
+0.34199094772338867   (populate)
+0.8924679756164551 (each)
+
+1.8.6 linux:
+
+GoogleHashSparse
+0.305501222610474   (populate)
+0.78859806060791 (each)
+
+GoogleHashDense
+0.161197900772095   (populate)
+0.810173988342285 (each)
+
+Hash
+0.269010782241821   (populate)
+1.00644612312317 (each)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: google_hash
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - rogerdpack
@@ -9,12 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-15 00:00:00 -07:00
+date: 2009-12-15 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sane
-  type: :development
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-description: A different and possibly longer explanation of
+description: Ruby wrappers to the google hash library
 email: rogerdpack@gmail.com
 executables: []
 
@@ -34,8 +34,10 @@ files:
 - README
 - Rakefile
 - VERSION
+- ext/benchmark.rb
 - ext/extconf.rb
-- ext/go.cpp
+- ext/go.bat
+- ext/main.cpp
 - ext/sparsehash-1.5.2/AUTHORS
 - ext/sparsehash-1.5.2/COPYING
 - ext/sparsehash-1.5.2/ChangeLog
@@ -113,7 +115,8 @@ 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/test.rb
+- ext/template/go.cpp
+- results.txt
 - test/spec.go
 has_rdoc: true
 homepage: http://github.com/rdp/ruby_google_hash

data/ext/go.cpp

@@ -1,109 +0,0 @@
-#include <iostream>
-#include <google/sparse_hash_map>
-#include <ruby.h>
-
-using google::sparse_hash_map;      // namespace where class lives by default
-using std::cout;
-using std::endl;
-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 {
-  sparse_hash_map<int, VALUE> *hash_map;
-} RCallback;
-
-static VALUE rb_cGoogleHashSmall;
-
-
-static void mark_hash_map_values(RCallback incoming) {} // TODO, etc.
-
-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_mri_callback*/ 0, 0 /*free_mri_callback*/, cbs);
-    cbs->hash_map = new sparse_hash_map<int, VALUE>();
-    sparse_hash_map<int, int> a;
-    a[35] = 47;
-    sparse_hash_map<int, int> *a2 = new sparse_hash_map<int, int>;
-    (*a2)[35] = 37;
-    (*cbs->hash_map)[33] = 35;
-    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;
-}
-
-int main()
-{
-  sparse_hash_map<const char*, int, hash<const char*>, eqstr> months;
-  
-  months["april"] = 30;
-  
-  cout << "april     -> " << months["april"] << endl;
-  cout << "iterating";
-  for(sparse_hash_map<const char*, int, hash<const char*>, eqstr>::iterator it = months.begin(); it != months.end(); ++it) {
-    cout << it->first;
-  }
-   
-}
-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;
-}
-
-void Init_google_hash() {
-    rb_cGoogleHashSmall = rb_define_class("GoogleHashSmall", rb_cObject);
-
-    rb_define_alloc_func(rb_cGoogleHashSmall, callback_alloc); // I guess it calls this for us, pre initialize... 
-
-    rb_define_method(rb_cGoogleHashSmall, "initialize", RUBY_METHOD_FUNC(rb_mri_hash_new), 0); 
-    rb_define_method(rb_cGoogleHashSmall, "[]=", RUBY_METHOD_FUNC(rb_ghash_set), 2); 
-    rb_define_method(rb_cGoogleHashSmall, "[]", RUBY_METHOD_FUNC(rb_ghash_get), 1); 
-
-
-    main();
-
-  } 
-}
-

data/ext/test.rb

@@ -1,10 +0,0 @@
-require 'google_hash'
-a = GoogleHashSmall.new
-puts
-a[3] = 4
-
-require 'benchmark'
-b = {}
-puts Benchmark.realtime { 1000.times { 1000.times {|n| b[n] = 4}}}
-puts Benchmark.realtime { 1000.times { 1000.times {|n| a[n] = 4}}}
-