Merge

.gitignore

@@ -13,3 +13,5 @@ test/nashorn/lib
 NashornProfile.txt
 **/JTreport/**
 **/JTwork/**
+/src/utils/hsdis/build/
+/microbenchmarks/loom/target/

microbenchmarks/loom/.gitignore

@@ -0,0 +1,4 @@
+/.factorypath
+/.classpath
+/.project
+/.settings/

microbenchmarks/loom/run_perf.sh

@@ -37,5 +37,8 @@ run_benchmark() {
 	echo
 }
 
-run_benchmark justYield    5 10 15 20 25 30
-run_benchmark justContinue 105 110 112 115 120 125 130
+run_benchmark baseline 1000
+run_benchmark yieldAndContinue 1000
+
+# run_benchmark justYield    5 10 15 20 25 30
+# run_benchmark justContinue 105 110 112 115 120 125 130

microbenchmarks/loom/src/main/java/org/openjdk/benchmarks/cont/FreezeAndThaw.java

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package org.openjdk.benchmarks.cont;
+
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.*;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Thread)
+@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@Fork(1)
+public class FreezeAndThaw {
+    static final ContinuationScope SCOPE = new ContinuationScope() { };
+
+    static class Arg {
+        volatile int field;
+    }
+
+    /**
+     * A recursive task that optionally yields when the stack gets to a specific
+     * depth. If continued after yielding, it runs to completion.
+     */
+    static class Yielder implements Runnable {
+        private final int paramCount;
+        private final int maxDepth;
+        private final boolean yieldAtLimit;
+
+        private Yielder(int paramCount, int maxDepth, boolean yieldAtLimit) {
+            if (paramCount < 1 || paramCount > 3)
+                throw new IllegalArgumentException();
+            this.paramCount = paramCount;
+            this.maxDepth = maxDepth;
+            this.yieldAtLimit = yieldAtLimit;
+        }
+
+        @Override
+        public void run() {
+            switch (paramCount) {
+                case 1: run1(maxDepth); break;
+                case 2: run2(maxDepth, new Arg()); break;
+                case 3: run3(maxDepth, new Arg(), new Arg()); break;
+                default: throw new Error("should not happen");
+            }
+        }
+
+        private void run1(int depth) {
+            if (depth > 0) {
+                run1(depth - 1);
+            } if (depth == 0) {
+                if (yieldAtLimit) Continuation.yield(SCOPE);
+            }
+        }
+
+        private void run2(int depth, Arg arg2) {
+            if (depth > 0) {
+                run2(depth - 1, arg2);
+            } if (depth == 0) {
+                if (yieldAtLimit) Continuation.yield(SCOPE);
+            } else {
+                // never executed
+                arg2.field = 0;
+            }
+        }
+
+        private void run3(int depth, Arg arg2, Arg arg3) {
+            if (depth > 0) {
+                run3(depth - 1, arg2, arg3);
+            } if (depth == 0) {
+                if (yieldAtLimit) { 
+                    Continuation.yield(SCOPE);
+                }
+            } else {
+                // never executed
+                arg2.field = 0;
+                arg3.field = 0;
+            }
+        }
+
+        static Continuation continuation(int paramCount, int maxDepth,
+                                         boolean yieldAtLimit) {
+            Runnable task = new Yielder(paramCount, maxDepth, yieldAtLimit);
+            return new Continuation(SCOPE, 2000, task);
+        }
+    }
+
+    @Param({"1", "2", "3"})
+    public int paramCount;
+
+    @Param({"5", "10", "20", "100"})
+    public int stackDepth;
+
+    Continuation cont;
+    Continuation cont0;
+
+    @Setup(Level.Invocation)
+    public void setup() {
+        // System.out.println("pc = " + paramCount + " sd = " + stackDepth);
+        cont = Yielder.continuation(paramCount, stackDepth, true);
+        cont0 = Yielder.continuation(paramCount, stackDepth, false);
+    }
+
+    /**
+     * Creates and runs a continuation that yields at a given stack depth.
+     */
+    @Benchmark
+    public void baseline() {
+        // Continuation cont0 = Yielder.continuation(paramCount, stackDepth, false);
+        cont0.run();
+        assert cont0.isDone();
+    }
+
+    /**
+     * Creates and runs a continuation that yields at a given stack depth.
+     */
+    @Benchmark
+    public void yieldAndContinue() {
+        // Continuation cont = Yielder.continuation(paramCount, stackDepth, true);
+        cont.run();
+        assert !cont.isDone();
+        cont.run();
+        assert cont.isDone();
+    }
+}

src/hotspot/cpu/x86/c1_LIRAssembler_x86.cpp

@@ -466,7 +466,7 @@ int LIR_Assembler::emit_unwind_handler() {
 
   // Fetch the exception from TLS and clear out exception related thread state
   Register thread = NOT_LP64(rsi) LP64_ONLY(r15_thread);
-  NOT_LP64(__ get_thread(rsi));
+  NOT_LP64(__ get_thread(thread));
   __ movptr(rax, Address(thread, JavaThread::exception_oop_offset()));
   __ movptr(Address(thread, JavaThread::exception_oop_offset()), (intptr_t)NULL_WORD);
   __ movptr(Address(thread, JavaThread::exception_pc_offset()), (intptr_t)NULL_WORD);
@@ -484,6 +484,8 @@ int LIR_Assembler::emit_unwind_handler() {
     stub = new MonitorExitStub(FrameMap::rax_opr, true, 0);
     __ unlock_object(rdi, rsi, rax, *stub->entry());
     __ bind(*stub->continuation());
+    NOT_LP64(__ get_thread(thread);)
+    __ dec_held_monitor_count(thread);
   }
 
   if (compilation()->env()->dtrace_method_probes()) {
@@ -3530,6 +3532,17 @@ void LIR_Assembler::emit_lock(LIR_OpLock* op) {
     Unimplemented();
   }
   __ bind(*op->stub()->continuation());
+
+  NOT_LP64(Register scratch = op->scratch_opr()->as_register();)
+  Register thread = LP64_ONLY(r15_thread) NOT_LP64(scratch);
+  NOT_LP64(__ get_thread(thread);)
+  if (op->code() == lir_lock) {
+    __ inc_held_monitor_count(thread);
+  } else if (op->code() == lir_unlock) {
+    __ dec_held_monitor_count(thread);
+  } else {
+    Unimplemented();
+  }
 }
 
 

src/hotspot/cpu/x86/c1_MacroAssembler_x86.cpp

@@ -98,6 +98,7 @@ int C1_MacroAssembler::lock_object(Register hdr, Register obj, Register disp_hdr
   jcc(Assembler::notZero, slow_case);
   // done
   bind(done);
+
   return null_check_offset;
 }