change gem name; refactor pure ruby weak reference implementation

Author: Brian Durand

README.rdoc

@@ -1,31 +1,31 @@
 This library provides object references for Ruby as well as some common utilities for working with references. Object references are used to point to other objects and come in three distinct flavors that interact differently with the garbage collector.
 
-* References::StrongReference - This is a plain old pointer to another object.
-* References::WeakReference - This is a pointer to another object, but it is not seen by the garbage collector and the memory used by the object can be reclaimed at any time.
-* References::SoftReference - This is similar to a weak reference, but the garbage collector is not as eager to reclaim the referenced object.
+* Ref::StrongReference - This is a plain old pointer to another object.
+* Ref::WeakReference - This is a pointer to another object, but it is not seen by the garbage collector and the memory used by the object can be reclaimed at any time.
+* Ref::SoftReference - This is similar to a weak reference, but the garbage collector is not as eager to reclaim the referenced object.
 
-All of these classes extend from a common References::Reference class and have a common interface.
+All of these classes extend from a common Ref::Reference class and have a common interface.
 
 Weak and soft references are useful when you have instantiated objects that you may want to use again but can recreate if necessary. Since the garbage collector determines when to reclaim the memory used by the objects, you don't need to worry about bloating the Ruby heap.
 
-== Example Usage
+= Example Usage
 
-  ref = References::WeakReference.new("hello")
+  ref = Ref::WeakReference.new("hello")
   ref.object # should be "hello"
   ObjectSpace.garbage_collect
   ref.object # should be nil (assuming the garbage collector reclaimed the reference)
 
-== Goodies
+= Goodies
 
 This library also includes tools for some common uses of weak and soft references.
 
-* References::WeakKeyMap - A map of keys to values where the keys are weak references
-* References::WeakValueMap - A map of keys to values where the values are weak references
-* References::SoftKeyMap - A map of keys to values where the keys are soft references
-* References::SoftValueMap - A map of keys to values where the values are soft references
-* References::ReferenceQueue - A thread safe implementation of a queue that will add references to itself as their objects are garbage collected.
+* Ref::WeakKeyMap - A map of keys to values where the keys are weak references
+* Ref::WeakValueMap - A map of keys to values where the values are weak references
+* Ref::SoftKeyMap - A map of keys to values where the keys are soft references
+* Ref::SoftValueMap - A map of keys to values where the values are soft references
+* Ref::ReferenceQueue - A thread safe implementation of a queue that will add references to itself as their objects are garbage collected.
 
-== Problems with WeakRef
+= Problems with WeakRef
 
 Ruby does come with the WeakRef class in the standard library. However, there are issues with this class across several different Ruby runtimes. This gem provides a common interface to weak references that works across MRI, Ruby Enterprise Edition, YARV, Jruby, Rubinius, and IronRuby.
 

Rakefile

@@ -2,7 +2,7 @@ require 'rake'
 require 'rake/rdoctask'
 require 'rake/testtask'
 require 'rake/gempackagetask'
-require File.expand_path('../lib/references', __FILE__)
+require File.expand_path('../lib/ref', __FILE__)
 
 desc 'Default: run unit tests.'
 task :default => :test
@@ -20,12 +20,12 @@ end
 desc 'Generate documentation.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.options << '--title' << 'References' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+  rdoc.options << '--title' << 'Ref' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
   rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-spec = eval(File.read(File.expand_path('../references.gemspec', __FILE__)))
+spec = eval(File.read(File.expand_path('../ref.gemspec', __FILE__)))
 
 Rake::GemPackageTask.new(spec) do |p|
   p.gem_spec = spec
@@ -45,11 +45,11 @@ namespace :java do
     base_dir = File.dirname(__FILE__)
     tmp_dir = File.join(base_dir, "tmp")
     classes_dir = File.join(tmp_dir, "classes")
-    jar_dir = File.join(base_dir, "lib", "org", "jruby", "ext", "references")
+    jar_dir = File.join(base_dir, "lib", "org", "jruby", "ext", "ref")
     FileUtils.rm_rf(classes_dir)
     ext_dir = File.join(base_dir, "ext", "java")
     source_files = FileList["#{base_dir}/**/*.java"]
-    jar_file = File.join(jar_dir, 'reference.jar')
+    jar_file = File.join(jar_dir, 'references.jar')
     # Only build if any of the source files have changed
     up_to_date = File.exist?(jar_file) && source_files.all?{|f| File.mtime(f) <= File.mtime(jar_file)}
     unless up_to_date
@@ -71,9 +71,12 @@ namespace :test do
     task :weak_reference do
       puts "Testing performance of weak references..."
       t = Time.now
-      100000.times do
-        References::WeakReference.new(Object.new)
+      Process.fork do
+        100000.times do
+          Ref::WeakReference.new(Object.new)
+        end
       end
+      Process.wait
       puts "Creating 100,000 weak references took #{Time.now - t} seconds"
     end
 
@@ -82,8 +85,10 @@ namespace :test do
       puts "Testing performance of soft references..."
       t = Time.now
       100000.times do |i|
-        References::SoftReference.new(Object.new)
+        Ref::SoftReference.new(Object.new)
       end
+      GC.start
+      GC.start
       puts "Creating 100,000 soft references took #{Time.now - t} seconds"
     end
   end

ext/java/org/jruby/ext/references/ReferenceService.java renamed to ext/java/org/jruby/ext/ref/ReferencesService.java

@@ -1,4 +1,4 @@
-package org.jruby.ext.references;
+package org.jruby.ext.ref;
 
 import java.io.IOException;
 import org.jruby.Ruby;
@@ -12,15 +12,15 @@
  * 
  * @author Brian Durand
  */
-public class ReferenceService implements BasicLibraryService {
+public class ReferencesService implements BasicLibraryService {
   public boolean basicLoad(Ruby runtime) throws IOException {
-    RubyModule referencesModule = runtime.getModule("References");
-    RubyClass referenceClass = referencesModule.getClass("Reference");
+    RubyModule refModule = runtime.getModule("Ref");
+    RubyClass referenceClass = refModule.getClass("Reference");
 
-    RubyClass rubyWeakReferenceClass = runtime.defineClassUnder("WeakReference", referenceClass, RubyWeakReference.ALLOCATOR, referencesModule);
+    RubyClass rubyWeakReferenceClass = runtime.defineClassUnder("WeakReference", referenceClass, RubyWeakReference.ALLOCATOR, refModule);
     rubyWeakReferenceClass.defineAnnotatedMethods(RubyWeakReference.class);
 
-    RubyClass rubySoftReferenceClass = runtime.defineClassUnder("SoftReference", referenceClass, RubySoftReference.ALLOCATOR, referencesModule);
+    RubyClass rubySoftReferenceClass = runtime.defineClassUnder("SoftReference", referenceClass, RubySoftReference.ALLOCATOR, refModule);
     rubySoftReferenceClass.defineAnnotatedMethods(RubySoftReference.class);
 
     return true;

ext/java/org/jruby/ext/references/RubySoftReference.java renamed to ext/java/org/jruby/ext/ref/RubySoftReference.java

@@ -1,4 +1,4 @@
-package org.jruby.ext.references;
+package org.jruby.ext.ref;
 
 import java.lang.ref.SoftReference;
 import org.jruby.Ruby;

ext/java/org/jruby/ext/references/RubyWeakReference.java renamed to ext/java/org/jruby/ext/ref/RubyWeakReference.java

@@ -1,4 +1,4 @@
-package org.jruby.ext.references;
+package org.jruby.ext.ref;
 
 import java.lang.ref.WeakReference;
 import org.jruby.Ruby;

lib/org/jruby/ext/ref/references.jar

@@ -1,40 +1,39 @@
-require 'monitor'
-
-module References
-  autoload :AbstractReferenceValueMap, File.join(File.dirname(__FILE__), "references", "abstract_reference_value_map.rb")
-  autoload :AbstractReferenceKeyMap, File.join(File.dirname(__FILE__), "references", "abstract_reference_key_map.rb")
-  autoload :Mock, File.join(File.dirname(__FILE__), "references", "mock.rb")
-  autoload :Reference, File.join(File.dirname(__FILE__), "references", "reference.rb")
-  autoload :ReferenceQueue, File.join(File.dirname(__FILE__), "references", "reference_queue.rb")
-  autoload :SoftKeyMap, File.join(File.dirname(__FILE__), "references", "soft_key_map.rb")
-  autoload :SoftValueMap, File.join(File.dirname(__FILE__), "references", "soft_value_map.rb")
-  autoload :StrongReference, File.join(File.dirname(__FILE__), "references", "strong_reference.rb")
-  autoload :WeakKeyMap, File.join(File.dirname(__FILE__), "references", "weak_key_map.rb")
-  autoload :WeakValueMap, File.join(File.dirname(__FILE__), "references", "weak_value_map.rb")
+module Ref
+  autoload :AbstractReferenceValueMap, File.join(File.dirname(__FILE__), "ref", "abstract_reference_value_map.rb")
+  autoload :AbstractReferenceKeyMap, File.join(File.dirname(__FILE__), "ref", "abstract_reference_key_map.rb")
+  autoload :Mock, File.join(File.dirname(__FILE__), "ref", "mock.rb")
+  autoload :Reference, File.join(File.dirname(__FILE__), "ref", "reference.rb")
+  autoload :ReferenceQueue, File.join(File.dirname(__FILE__), "ref", "reference_queue.rb")
+  autoload :SafeMonitor, File.join(File.dirname(__FILE__), "ref", "safe_monitor.rb")
+  autoload :SoftKeyMap, File.join(File.dirname(__FILE__), "ref", "soft_key_map.rb")
+  autoload :SoftValueMap, File.join(File.dirname(__FILE__), "ref", "soft_value_map.rb")
+  autoload :StrongReference, File.join(File.dirname(__FILE__), "ref", "strong_reference.rb")
+  autoload :WeakKeyMap, File.join(File.dirname(__FILE__), "ref", "weak_key_map.rb")
+  autoload :WeakValueMap, File.join(File.dirname(__FILE__), "ref", "weak_value_map.rb")
 
   # Set the best implementation for weak references based on the runtime.
   if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java'
     # Use native Java references
     begin
       $LOAD_PATH.unshift(File.dirname(__FILE__))
-      require 'org/jruby/ext/references/reference'
+      require 'org/jruby/ext/ref/references'
     ensure
       $LOAD_PATH.shift if $LOAD_PATH.first == File.dirname(__FILE__)
     end
   else
-    autoload :SoftReference, File.join(File.dirname(__FILE__), "references", "soft_reference.rb")
+    autoload :SoftReference, File.join(File.dirname(__FILE__), "ref", "soft_reference.rb")
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ironruby'
       # IronRuby has it's own implementation of weak references.
-      autoload :WeakReference, File.join(File.dirname(__FILE__), "references", "weak_reference", "iron_ruby.rb")
+      autoload :WeakReference, File.join(File.dirname(__FILE__), "ref", "weak_reference", "iron_ruby.rb")
     elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
       # If using Rubinius set the implementation to use WeakRef since it is very efficient.
-      autoload :WeakReference, File.join(File.dirname(__FILE__), "references", "weak_reference", "weak_ref.rb")
+      autoload :WeakReference, File.join(File.dirname(__FILE__), "ref", "weak_reference", "weak_ref.rb")
     elsif defined?(ObjectSpace._id2ref)
       # If ObjectSpace can lookup objects from their object_id, then use the pure ruby implementation.
-      autoload :WeakReference, File.join(File.dirname(__FILE__), "references", "weak_reference", "pure_ruby.rb")
+      autoload :WeakReference, File.join(File.dirname(__FILE__), "ref", "weak_reference", "pure_ruby.rb")
     else
       # Otherwise, wrap the standard library WeakRef class
-      autoload :WeakReference, File.join(File.dirname(__FILE__), "references", "weak_reference", "weak_ref.rb")
+      autoload :WeakReference, File.join(File.dirname(__FILE__), "ref", "weak_reference", "weak_ref.rb")
     end
   end
 end

lib/org/jruby/ext/references/reference.jar

@@ -1,4 +1,4 @@
-module References
+module Ref
   # Abstract base class for WeakKeyMap and SoftKeyMap.
   #
   # The classes behave similar to Hashes, but the keys in the map are not strong references
@@ -21,8 +21,8 @@ def reference_class #:nodoc:
     def initialize
       @values = {}
       @references_to_keys_map = {}
+      @lock = SafeMonitor.new
       @reference_cleanup = lambda{|object_id| remove_reference_to(object_id)}
-      @monitor = Monitor.new
     end
 
     # Get a value from the map by key. If the value has been reclaimed by the garbage
@@ -35,7 +35,7 @@ def [](key)
     # Add a key/value to the map.
     def []=(key, value)
       ObjectSpace.define_finalizer(key, @reference_cleanup)
-      @monitor.synchronize do
+      @lock.synchronize do
         @references_to_keys_map[key.__id__] = self.class.reference_class.new(key)
         @values[key.__id__] = value
       end
@@ -75,7 +75,7 @@ def each
 
     # Clear the map of all key/value pairs.
     def clear
-      @monitor.synchronize do
+      @lock.synchronize do
         @values.clear
         @references_to_keys_map.clear
       end
@@ -108,8 +108,10 @@ def ref_key (key)
       end
 
       def remove_reference_to(object_id)
-        @references_to_keys_map.delete(object_id)
-        @values.delete(object_id)
+        @lock.synchronize do
+          @references_to_keys_map.delete(object_id)
+          @values.delete(object_id)
+        end
       end
   end
 end

lib/references.rb renamed to lib/ref.rb

@@ -1,4 +1,4 @@
-module References
+module Ref
   # Abstract base class for WeakValueMap and SoftValueMap.
   #
   # The classes behave similar to Hashes, but the values in the map are not strong references
@@ -21,8 +21,8 @@ def reference_class #:nodoc:
     def initialize
       @references = {}
       @references_to_keys_map = {}
+      @lock = SafeMonitor.new
       @reference_cleanup = lambda{|object_id| remove_reference_to(object_id)}
-      @monitor = Monitor.new
     end
 
     # Get a value from the map by key. If the value has been reclaimed by the garbage
@@ -37,7 +37,7 @@ def [](key)
     def []=(key, value)
       ObjectSpace.define_finalizer(value, @reference_cleanup)
       key = key.dup if key.is_a?(String)
-      @monitor.synchronize do
+      @lock.synchronize do
         @references[key] = self.class.reference_class.new(value)
         keys_for_id = @references_to_keys_map[value.__id__]
         unless keys_for_id
@@ -89,7 +89,7 @@ def each
 
     # Clear the map of all key/value pairs.
     def clear
-      @monitor.synchronize do
+      @lock.synchronize do
         @references.clear
         @references_to_keys_map.clear
       end
@@ -113,7 +113,7 @@ def inspect
     private
 
       def remove_reference_to(object_id)
-        @monitor.synchronize do
+        @lock.synchronize do
           keys = @references_to_keys_map[object_id]
           if keys
             keys.each do |key|