Rearchitect weak references

Author: Brian Durand

README.rdoc

@@ -1,10 +1,10 @@
-This library provides implementations of various types of object references for Ruby as well as some common utilities for working with references. Reference objects are pretty much pointers, but they come in three distinct flavors that interact differently with the garbage collector.
+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.
 
-All of these classes extend from a common References::Reference class.
+All of these classes extend from a common References::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.
 

Rakefile

@@ -42,12 +42,17 @@ 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")
     FileUtils.rm_rf(classes_dir)
     ext_dir = File.join(base_dir, "ext", "java")
     source_files = FileList["#{base_dir}/**/*.java"]
     FileUtils.mkdir_p(classes_dir)
     `#{ENV['JAVA_HOME']}/bin/javac -classpath '#{"#{ENV['JRUBY_HOME']}/lib/jruby.jar"}' -d '#{classes_dir}' -sourcepath '#{ext_dir}' '#{source_files.join("' '")}'`
-    `#{ENV['JAVA_HOME']}/bin/jar cf '#{base_dir}/lib/references/java_support.jar' -C '#{classes_dir}' references`
+    if $? == 0
+      FileUtils.rm_rf(jar_dir) if File.exist?(jar_dir)
+      FileUtils.mkdir_p(jar_dir)
+      `#{ENV['JAVA_HOME']}/bin/jar cf '#{File.join(jar_dir, 'reference.jar')}' -C '#{classes_dir}' org`
+    end
     FileUtils.rm_rf(classes_dir)
   end
 end

VERSION

@@ -1 +1 @@
-0.0.1
+1.0.0

ext/java/references/JavaSupportService.java renamed to ext/java/references/ReferenceService.java

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

ext/java/references/RubySoftReference.java

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

ext/java/references/weak_reference/JavaImpl.java renamed to ext/java/references/RubyWeakReference.java

@@ -1,4 +1,4 @@
-package references.weak_reference;
+package org.jruby.ext.references;
 
 import java.lang.ref.WeakReference;
 import org.jruby.Ruby;
@@ -10,22 +10,24 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.Visibility;
 
-public class JavaImpl extends RubyObject {
+public class RubyWeakReference extends RubyObject {
   private WeakReference _ref;
+  private static final String REFERENCED_OBJECT_ID_VARIABLE = "@referenced_object_id".intern();
 
-  public JavaImpl(Ruby runtime, RubyClass klass) {
+  public RubyWeakReference(Ruby runtime, RubyClass klass) {
     super(runtime, klass);
   }
 
   public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
     public IRubyObject allocate(Ruby runtime, RubyClass klass) {
-      return new JavaImpl(runtime, klass);
+      return new RubyWeakReference(runtime, klass);
     }
   };
 
   @JRubyMethod(name = "initialize", frame = true, visibility = Visibility.PRIVATE)
   public IRubyObject initialize(ThreadContext context, IRubyObject obj) {
     _ref = new WeakReference<IRubyObject>(obj);
+    fastSetInstanceVariable(REFERENCED_OBJECT_ID_VARIABLE, obj.id());
     return context.getRuntime().getNil();
   }
 

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

@@ -3,34 +3,38 @@
 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 :WeakReference, File.join(File.dirname(__FILE__), "references", "weak_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")
 
   # 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 'references/java_support'
-      WeakReference.implementation = WeakReference::JavaImpl
+      require 'org/jruby/ext/references/reference'
     ensure
       $LOAD_PATH.shift if $LOAD_PATH.first == File.dirname(__FILE__)
     end
   else
     autoload :SoftReference, File.join(File.dirname(__FILE__), "references", "soft_reference.rb")
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ironruby'
-      WeakReference.implementation = WeakReference::IronRubyImpl
+      # IronRuby has it's own implementation of weak references.
+      autoload :WeakReference, File.join(File.dirname(__FILE__), "references", "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.
-      require 'weakref'
-      WeakReference.implementation = WeakReference::WeakRefImpl
+      autoload :WeakReference, File.join(File.dirname(__FILE__), "references", "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")
     else
-      WeakReference.implementation = WeakReference::RubyImpl
+      # Otherwise, wrap the standard library WeakRef class
+      autoload :WeakReference, File.join(File.dirname(__FILE__), "references", "weak_reference", "weak_ref.rb")
     end
   end
 end

lib/references.rb

@@ -0,0 +1,145 @@
+module References
+  # This module provides mock weak and strong references that are designed to be
+  # used in tests. You can define a block where all weak and soft references created
+  # will be mock references. You can then mimic running the garbage collector on
+  # the objects pointed to by the references.
+  #
+  # Example usage:
+  #
+  #   References::Mock.use do
+  #     obj = Object.new
+  #     ref = References::WeakReference.new(obj)
+  #     ref.object   # obj
+  #     References::Mock.gc(obj)  # mimics the garbage collector reclaiming the referenced object
+  #     ref.object   # nil
+  #   end
+  module Mock
+    class << self
+      # Use the mock implementation inside a block and then restore the original implementation.
+      def use
+        if object_space
+          yield
+        else
+          setup
+          begin
+            yield
+          ensure
+            cleanup
+          end
+        end
+      end
+      
+      # Start using mock references.
+      def setup
+        raise "References::Mock already setup" if object_space
+        
+        @object_space = {}
+        
+        class << ObjectSpace
+          unless method_defined?(:define_finalizer_with_mock_reference)
+            def define_finalizer_with_mock_reference(obj, finalizer)
+              if Mock.object_space.include?(obj.__id__)
+                Mock.object_space[obj.__id__] << finalizer
+              else
+                define_finalizer_without_mock_reference(obj, finalizer)
+              end
+            end
+          end
+          
+          alias_method :define_finalizer_without_mock_reference, :define_finalizer
+          alias_method :define_finalizer, :define_finalizer_with_mock_reference
+        end
+        
+        class << WeakReference
+          unless method_defined?(:new_with_mock_reference)
+            def new_with_mock_reference(obj)
+              if self == MockWeakReference
+                new_without_mock_reference(obj)
+              else
+                MockWeakReference.new(obj)
+              end
+            end
+          end
+          
+          alias_method :new_without_mock_reference, :new
+          alias_method :new, :new_with_mock_reference
+        end
+        
+        class << SoftReference
+          unless method_defined?(:new_with_mock_reference)
+            def new_with_mock_reference(obj)
+              if self == MockSoftReference
+                new_without_mock_reference(obj)
+              else
+                MockSoftReference.new(obj)
+              end
+            end
+          end
+          
+          alias_method :new_without_mock_reference, :new
+          alias_method :new, :new_with_mock_reference
+        end
+      end
+      
+      # Stop using mock references.
+      def cleanup
+        @object_space = nil
+        class << ObjectSpace
+          alias_method :define_finalizer_with_mock_reference, :define_finalizer
+          alias_method :define_finalizer, :define_finalizer_without_mock_reference
+        end
+        
+        class << WeakReference
+          alias_method :new_with_mock_reference, :new
+          alias_method :new, :new_without_mock_reference
+        end
+        
+        class << SoftReference
+          alias_method :new_with_mock_reference, :new
+          alias_method :new, :new_without_mock_reference
+        end
+      end
+
+      def object_space # :nodoc:
+        @object_space if instance_variable_defined?(:@object_space)
+      end
+
+      # Simulate garbage collection of the objects passed in as arguments. If no objects
+      # are specified, all objects will be reclaimed.
+      def gc(*objects)
+        objects = object_space.keys if objects.empty?
+        objects.each do |obj|
+          finalizers = object_space.delete(obj.__id__)
+          if finalizers
+            finalizers.each{|finalizer| finalizer.call(obj.__id__)}
+          end
+        end
+      end
+    end
+    
+    module MockReference #:nodoc:
+      def initialize(obj)
+        @object = obj
+        @referenced_object_id = obj.__id__
+        raise "Reference::Mock not setup yet" unless Mock.object_space
+        Mock.object_space[obj.__id__] ||= []
+      end
+    
+      def object
+        if @object && Mock.object_space.include?(@object.__id__)
+          @object
+        else
+          @object = nil
+        end
+      end
+    end
+  
+    class MockWeakReference < WeakReference #:nodoc:
+      include MockReference
+    end
+  
+    class MockSoftReference < SoftReference #:nodoc:
+      include MockReference
+    end
+  end  
+end