jruby · Aug 6, 2015 · Aug 28, 2015 · Aug 28, 2015 · Aug 28, 2015 · Aug 28, 2015
diff --git a/core/src/main/java/org/jruby/Main.java b/core/src/main/java/org/jruby/Main.java
@@ -45,6 +45,7 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.SafePropertyAccessor;
+import org.jruby.util.cli.Options;
 import org.jruby.util.cli.OutputStrings;
 import org.jruby.util.log.Logger;
 import org.jruby.util.log.LoggerFactory;
@@ -183,6 +184,8 @@ public static class Status {
      * @param args command-line args, provided by the JVM.
      */
     public static void main(String[] args) {
+        printTruffleTimeMetric("before-main");
+
         doGCJCheck();
 
         Main main;
@@ -217,6 +220,9 @@ public static void main(String[] args) {
 
             System.exit(1);
         }
+
+        printTruffleTimeMetric("after-main");
+        printTruffleMemoryMetric();
     }
 
     public Status run(String[] args) {
@@ -531,6 +537,28 @@ protected static int handleRaiseException(RaiseException rj) {
         }
     }
 
+    public static void printTruffleTimeMetric(String id) {
+        if (Options.TRUFFLE_METRICS_TIME.load()) {
+            final long millis = System.currentTimeMillis();
+            System.err.printf("%s %d.%03d%n", id, millis / 1000, millis % 1000);
+        }
+    }
+
+    private static void printTruffleMemoryMetric() {
+        if (Options.TRUFFLE_METRICS_MEMORY_USED_ON_EXIT.load()) {
+            for (int n = 0; n < 10; n++) {
+                System.gc();
+            }
+
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+            }
+
+            System.err.printf("allocated %d%n", ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed());
+        }
+    }
+
     private final RubyInstanceConfig config;
 }
 
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -79,7 +79,6 @@
 import org.jruby.common.RubyWarnings;
 import org.jruby.compiler.JITCompiler;
 import org.jruby.embed.Extension;
-import org.jruby.exceptions.JumpException;
 import org.jruby.exceptions.MainExitException;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.exceptions.Unrescuable;
@@ -549,7 +548,9 @@ public void runFromMain(InputStream inputStream, String filename) {
             return;
         }
 
+        Main.printTruffleTimeMetric("before-parse-initial");
         ParseResult parseResult = parseFromMain(filename, inputStream);
+        Main.printTruffleTimeMetric("after-parse-initial");
 
         // if no DATA, we're done with the stream, shut it down
         if (fetchGlobalConstant("DATA") == null) {
@@ -843,7 +844,9 @@ public IRubyObject runInterpreter(ThreadContext context, Node rootNode, IRubyObj
         if (getInstanceConfig().getCompileMode() == CompileMode.TRUFFLE) {
             assert rootNode instanceof RootNode;
             assert self == getTopSelf();
+            Main.printTruffleTimeMetric("before-run");
             getTruffleContext().execute((RootNode) rootNode);
+            Main.printTruffleTimeMetric("after-run");
             return getNil();
         } else {
             return Interpreter.getInstance().execute(this, rootNode, self);
@@ -891,6 +894,8 @@ public TruffleContextInterface getTruffleContext() {
     }
 
     private TruffleContextInterface loadTruffleContext() {
+        Main.printTruffleTimeMetric("before-load-truffle-context");
+
         final Class<?> clazz;
 
         try {
@@ -910,6 +915,8 @@ private TruffleContextInterface loadTruffleContext() {
 
         truffleContext.initialize();
 
+        Main.printTruffleTimeMetric("after-load-truffle-context");
+
         return truffleContext;
     }
 

diff --git a/core/src/main/java/org/jruby/util/cli/Options.java b/core/src/main/java/org/jruby/util/cli/Options.java
@@ -97,7 +97,8 @@ public class Options {
     public static final Option<Boolean> INVOKEDYNAMIC_CACHE_CONSTANTS = bool(INVOKEDYNAMIC, "invokedynamic.cache.constants", true, "Use invokedynamic to load constants.");
     public static final Option<Boolean> INVOKEDYNAMIC_CACHE_LITERALS = bool(INVOKEDYNAMIC, "invokedynamic.cache.literals", true, "Use invokedynamic to load literals.");
     public static final Option<Boolean> INVOKEDYNAMIC_CACHE_IVARS = bool(INVOKEDYNAMIC, "invokedynamic.cache.ivars", true, "Use invokedynamic to get/set instance variables.");
-    public static final Option<Boolean> INVOKEDYNAMIC_CLASS_VALUES = bool(INVOKEDYNAMIC, "invokedynamic.class.values", true, "Use ClassValue to store class-specific data.");
+    // ClassValue in OpenJDK appears to root data even after it goes away, so this is disabled again. See jruby/jruby#3228
+    public static final Option<Boolean> INVOKEDYNAMIC_CLASS_VALUES = bool(INVOKEDYNAMIC, "invokedynamic.class.values", false, "Use ClassValue to store class-specific data.");
     public static final Option<Integer> INVOKEDYNAMIC_GLOBAL_MAXFAIL = integer(INVOKEDYNAMIC, "invokedynamic.global.maxfail", 100, "Maximum global cache failures after which to use slow path.");
     public static final Option<Boolean> INVOKEDYNAMIC_HANDLES = bool(INVOKEDYNAMIC, "invokedynamic.handles", false, "Use MethodHandles rather than generated code to bind Ruby methods.");
 
@@ -125,7 +126,7 @@ public class Options {
     public static final Option<Boolean> IR_WRITING_DEBUG     = bool(IR, "ir.writing.debug", false, "Debug writing JRuby IR file.");
     public static final Option<String>  IR_INLINE_COMPILER_PASSES = string(IR, "ir.inline_passes", "Specify comma delimeted list of passes to run after inlining a method.");
 
-    public static final Option<String> TRUFFLE_CORE_LOAD_PATH = string(TRUFFLE, "truffle.core.load_path", "truffle:/", "Directory to load the Truffle core library from.");
+    public static final Option<String> TRUFFLE_CORE_LOAD_PATH = string(TRUFFLE, "truffle.core.load_path", "truffle:/jruby-truffle", "Directory to load the Truffle core library from.");
 
     public static final Option<Integer> TRUFFLE_DISPATCH_POLYMORPHIC_MAX = integer(TRUFFLE, "truffle.dispatch.polymorphic.max", 8, "Maximum size of a polymorphic call site cache.");
     public static final Option<Integer> TRUFFLE_ARRAYS_UNINITIALIZED_SIZE = integer(TRUFFLE, "truffle.arrays.uninitialized_size", 32, "How large an array to allocate when we have no other information to go on.");
@@ -151,6 +152,9 @@ public class Options {
 
     public static final Option<Boolean> TRUFFLE_INCLUDE_CORE_FILE_CALLERS_IN_SET_TRACE_FUNC = bool(TRUFFLE, "truffle.set_trace_func.include_core_file_callers", false, "Include internal core library calls in set_trace_func output.");
 
+    public static final Option<Boolean> TRUFFLE_METRICS_TIME = bool(TRUFFLE, "truffle.metrics.time", false, "Print the time at various stages of VM operation.");
+    public static final Option<Boolean> TRUFFLE_METRICS_MEMORY_USED_ON_EXIT = bool(TRUFFLE, "truffle.metrics.memory_used_on_exit", false, "Print the size of heap memory in use on exit.");
+
     public static final Option<Boolean> NATIVE_ENABLED = bool(NATIVE, "native.enabled", true, "Enable/disable native code, including POSIX features and C exts.");
     public static final Option<Boolean> NATIVE_VERBOSE = bool(NATIVE, "native.verbose", false, "Enable verbose logging of native extension loading.");
     public static final Option<Boolean> FFI_COMPILE_DUMP = bool(NATIVE, "ffi.compile.dump", false, "Dump bytecode-generated FFI stubs to console.");

diff --git a/core/src/main/java/org/jruby/util/collections/Java7ClassValue.java b/core/src/main/java/org/jruby/util/collections/Java7ClassValue.java
@@ -1,5 +1,9 @@
 package org.jruby.util.collections;
 
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * A proxy cache that uses Java 7's ClassValue.
  */
@@ -10,13 +14,28 @@ public Java7ClassValue(ClassValueCalculator<T> calculator) {
     }
 
     public T get(Class cls) {
-        return proxy.get(cls);
+        // We don't check for null on the WeakReference since the
+        // value is strongly referenced by proxy's list
+        return (T)proxy.get(cls).get();
     }
 
-    private final java.lang.ClassValue<T> proxy = new java.lang.ClassValue<T>() {
+    // If we put any objects that reference an org.jruby.Ruby runtime
+    // (like RubyClass instances) in here we run into a circular
+    // reference situation that GC isn't handling where they will
+    // always be strongly referenced and never garbage collected. We
+    // break that by holding the computed values with a WeakReference.
+    // This appears to be a bug in OpenJDK. See jruby/jruby#3228.
+    private final java.lang.ClassValue<WeakReference<T>> proxy = new java.lang.ClassValue<WeakReference<T>>() {
+        // Strongly reference all computed values so they don't get
+        // garbage collected until this Java7ClassValue instance goes
+        // out of scope
+        private final List<T> values = new ArrayList<T>();
+
         @Override
-        protected T computeValue(Class<?> type) {
-            return calculator.computeValue(type);
+        protected WeakReference<T> computeValue(Class<?> type) {
+            T value = calculator.computeValue(type);
+            values.add(value);
+            return new WeakReference(value);
         }
     };
 }
diff --git a/lib/pom.rb b/lib/pom.rb
@@ -19,7 +19,7 @@ def version
 
 default_gems =
   [
-   ImportedGem.new( 'jruby-openssl', '0.9.10', true ),
+   ImportedGem.new( 'jruby-openssl', '0.9.11', true ),
    ImportedGem.new( 'jruby-readline', '1.0', false ),
    ImportedGem.new( 'rake', 'rake.version', true ),
    ImportedGem.new( 'rdoc', 'rdoc.version', true ),
@@ -72,6 +72,9 @@ def to_pathname
               :id => 'rubygems-releases' )
   repository( :url => 'http://rubygems-proxy.torquebox.org/releases',
               :id => 'tb-rubygems-releases' )
+  # for testing out jruby-ossl before final release :
+  #repository( :url => 'http://oss.sonatype.org/content/repositories/staging',
+  #            :id => 'gem-staging' )
 
   plugin( :clean,
           :filesets => [ { :directory => '${basedir}/ruby/gems/shared/specifications/default',

diff --git a/lib/pom.xml b/lib/pom.xml
@@ -34,7 +34,7 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>rubygems</groupId>
       <artifactId>jruby-openssl</artifactId>
-      <version>0.9.10</version>
+      <version>0.9.11</version>
       <type>gem</type>
       <scope>provided</scope>
       <exclusions>

diff --git a/maven/jruby-complete/pom.rb b/maven/jruby-complete/pom.rb
@@ -117,6 +117,5 @@
       jdk '1.8'
     end
     plugin :invoker, :pomExcludes => ['osgi_many_bundles_with_embedded_gems_felix-3.2/pom.xml', '${its.j2ee}', '${its.osgi}']
-    properties 'javadoc.opts' => '-Xdoclint:none'
   end
 end
diff --git a/pom.rb b/pom.rb
@@ -288,7 +288,7 @@
       execute_goals('jar-no-fork', :id => 'attach-sources')
     end
     plugin(:javadoc) do
-      execute_goals('jar', :id => 'attach-javadocs', :configuration => [ xml('<additionalparam>${javadoc.opts}</additionalparam>') ])
+      execute_goals('jar', :id => 'attach-javadocs')
     end
   end
 
@@ -299,6 +299,13 @@
     properties 'invoker.skip' => false
   end
 
+  profile 'jdk8' do
+    activation do
+      jdk '1.8'
+    end
+    plugin :javadoc, :additionalparam => '-Xdoclint:none'
+  end
+
   reporting do
     plugin( :'project-info-reports', '2.4',
             'dependencyLocationsEnabled' =>  'false',

diff --git a/pom.xml b/pom.xml
@@ -871,5 +871,21 @@ DO NOT MODIFIY - GENERATED CODE
         <invoker.skip>false</invoker.skip>
       </properties>
     </profile>
+    <profile>
+      <id>jdk8</id>
+      <activation>
+        <jdk>1.8</jdk>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <artifactId>maven-javadoc-plugin</artifactId>
+            <configuration>
+              <additionalparam>-Xdoclint:none</additionalparam>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
   </profiles>
 </project>
diff --git a/spec/regression/embedded_runtime_leak_spec.rb b/spec/regression/embedded_runtime_leak_spec.rb
@@ -0,0 +1,18 @@
+describe "embedded runtimes" do
+  it "should not leak runtimes after tearing them down" do
+    num_runtimes = 10
+    mbean = java.lang.management.ManagementFactory.getMemoryMXBean
+    num_runtimes.times do
+      instance = org.jruby.Ruby.newInstance
+      instance.evalScriptlet <<-EOS
+        # eat up some memory in each runtime
+        $arr = 500000.times.map { |i| "foobarbaz\#{i}" }
+      EOS
+      instance.tearDown(false)
+      # Make sure GC can keep up
+      while mbean.getObjectPendingFinalizationCount > 0
+        sleep 0.2
+      end
+    end.should_not raise_error
+  end
+end