[GR-8510] Fixes for PrintBiasedLockingStatistics on x86.

PullRequest: graal-jvmci-8/36

Author: gilles-duboscq

make/linux/makefiles/gcc.make

@@ -264,6 +264,7 @@ else
   ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 3), 1)
     OPT_CFLAGS/mulnode.o += $(OPT_CFLAGS/NOOPT)
   endif
+  OPT_CFLAGS/jvmciCompilerToVM.o += -fno-var-tracking-assignments
 endif
 
 # Flags for generating make dependency flags.

src/cpu/x86/vm/c1_MacroAssembler_x86.cpp

@@ -45,6 +45,10 @@ int C1_MacroAssembler::lock_object(Register hdr, Register obj, Register disp_hdr
 
   verify_oop(obj);
 
+  if (PrintBiasedLockingStatistics) {
+    atomic_incl(ExternalAddress((address)BiasedLocking::total_entry_count_addr()), disp_hdr);
+  }
+
   // save object being locked into the BasicObjectLock
   movptr(Address(disp_hdr, BasicObjectLock::obj_offset_in_bytes()), obj);
 
@@ -90,6 +94,10 @@ int C1_MacroAssembler::lock_object(Register hdr, Register obj, Register disp_hdr
   // for recursive locking, the result is zero => save it in the displaced header
   // location (NULL in the displaced hdr location indicates recursive locking)
   movptr(Address(disp_hdr, 0), hdr);
+  if (PrintBiasedLockingStatistics) {
+    cond_inc32(Assembler::zero,
+               ExternalAddress((address)BiasedLocking::fast_path_entry_count_addr()));
+  }
   // otherwise we don't care about the result and handle locking via runtime call
   jcc(Assembler::notZero, slow_case);
   // done

src/cpu/x86/vm/interp_masm_x86_64.cpp

@@ -708,6 +708,10 @@ void InterpreterMacroAssembler::lock_object(Register lock_reg) {
 
     Label slow_case;
 
+    if (PrintBiasedLockingStatistics) {
+      atomic_incl(ExternalAddress((address)BiasedLocking::total_entry_count_addr()), obj_reg);
+    }
+
     // Load object pointer into obj_reg %c_rarg3
     movptr(obj_reg, Address(lock_reg, obj_offset));
 
@@ -758,6 +762,10 @@ void InterpreterMacroAssembler::lock_object(Register lock_reg) {
 
     bind(slow_case);
 
+    if (PrintBiasedLockingStatistics) {
+      atomic_incl(ExternalAddress((address) BiasedLocking::slow_path_entry_count_addr()), obj_reg);
+    }
+
     // Call the runtime routine for slow case
     call_VM(noreg,
             CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),

src/cpu/x86/vm/macroAssembler_x86.cpp

@@ -1137,7 +1137,7 @@ int MacroAssembler::biased_locking_enter(Register lock_reg,
     pop(tmp_reg);
   }
   if (counters != NULL) {
-    cond_inc32(Assembler::zero,
+    cond_inc32(Assembler::equal,
                ExternalAddress((address) counters->biased_lock_entry_count_addr()));
   }
   jcc(Assembler::equal, done);
@@ -1710,6 +1710,10 @@ void MacroAssembler::fast_lock(Register objReg, Register boxReg, Register tmpReg
     assert_different_registers(objReg, boxReg, tmpReg, scrReg);
   }
 
+  if (PrintBiasedLockingStatistics && counters == NULL) {
+    counters = BiasedLocking::counters();
+  }
+
   if (counters != NULL) {
     atomic_incl(ExternalAddress((address)counters->total_entry_count_addr()), scrReg);
   }
@@ -1958,6 +1962,10 @@ void MacroAssembler::fast_lock(Register objReg, Register boxReg, Register tmpReg
       lock();
     }
     cmpxchgptr(r15_thread, Address(boxReg, ObjectMonitor::owner_offset_in_bytes()-2));
+    if (counters != NULL) {
+      cond_inc32(Assembler::equal,
+                 ExternalAddress((address)counters->fast_path_entry_count_addr()));
+    }
     // Intentional fall-through into DONE_LABEL ...
 #endif // _LP64
 

src/cpu/x86/vm/sharedRuntime_x86_64.cpp

@@ -35,6 +35,7 @@
 #include "oops/compiledICHolder.hpp"
 #include "prims/jvmtiRedefineClassesTrace.hpp"
 #include "runtime/sharedRuntime.hpp"
+#include "runtime/biasedLocking.hpp"
 #include "runtime/vframeArray.hpp"
 #include "vmreg_x86.inline.hpp"
 #ifdef COMPILER1
@@ -2326,6 +2327,10 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
 
     __ lea(lock_reg, Address(rsp, lock_slot_offset * VMRegImpl::stack_slot_size));
 
+    if (PrintBiasedLockingStatistics) {
+      __ atomic_incl(ExternalAddress((address)BiasedLocking::total_entry_count_addr()), obj_reg);
+    }
+
     // Load the oop from the handle
     __ movptr(obj_reg, Address(oop_handle_reg, 0));
 
@@ -2348,6 +2353,10 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
 
     // src -> dest iff dest == rax else rax <- dest
     __ cmpxchgptr(lock_reg, Address(obj_reg, 0));
+    if (PrintBiasedLockingStatistics) {
+      __ cond_inc32(Assembler::equal,
+                 ExternalAddress((address) BiasedLocking::fast_path_entry_count_addr()));
+    }
     __ jcc(Assembler::equal, lock_done);
 
     // Hmm should this move to the slow path code area???
@@ -2366,6 +2375,10 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
 
     // Save the test result, for recursive case, the result is zero
     __ movptr(Address(lock_reg, mark_word_offset), swap_reg);
+    if (PrintBiasedLockingStatistics) {
+      __ cond_inc32(Assembler::zero,
+                 ExternalAddress((address) BiasedLocking::fast_path_entry_count_addr()));
+    }
     __ jcc(Assembler::notEqual, slow_path_lock);
 
     // Slow path will re-enter here

src/share/vm/interpreter/interpreterRuntime.cpp

@@ -619,7 +619,8 @@ IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, Ba
   thread->last_frame().interpreter_frame_verify_monitor(elem);
 #endif
   if (PrintBiasedLockingStatistics) {
-    Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
+    // Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
+    // Done in InterpreterMacroAssembler::lock_object. For some mysterious reason some increments from here are missed
   }
   Handle h_obj(thread, elem->obj());
   assert(Universe::heap()->is_in_reserved_or_null(h_obj()),

src/share/vm/runtime/biasedLocking.cpp

@@ -771,5 +771,6 @@ void BiasedLockingCounters::print_on(outputStream* st) {
   tty->print_cr("# rebiased lock entries: %d", _rebiased_lock_entry_count);
   tty->print_cr("# revoked lock entries: %d", _revoked_lock_entry_count);
   tty->print_cr("# fast path lock entries: %d", _fast_path_entry_count);
+  tty->print_cr("# raw slow path lock entries: %d", _slow_path_entry_count);
   tty->print_cr("# slow path lock entries: %d", slow_path_entry_count());
 }