Merge

Author: JesperIRL

src/hotspot/share/c1/c1_Runtime1.cpp

@@ -539,6 +539,20 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* t
   }
 #endif
 
+  // debugging support
+  // tracing
+  if (log_is_enabled(Info, exceptions)) {
+    ResourceMark rm;
+    stringStream tempst;
+    assert(nm->method() != NULL, "Unexpected NULL method()");
+    tempst.print("C1 compiled method <%s>\n"
+                 " at PC" INTPTR_FORMAT " for thread " INTPTR_FORMAT,
+                 nm->method()->print_value_string(), p2i(pc), p2i(thread));
+    Exceptions::log_exception(exception, tempst.as_string());
+  }
+  // for AbortVMOnException flag
+  Exceptions::debug_check_abort(exception);
+
   // Check the stack guard pages and reenable them if necessary and there is
   // enough space on the stack to do so.  Use fast exceptions only if the guard
   // pages are enabled.
@@ -585,20 +599,6 @@ JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* t
     // New exception handling mechanism can support inlined methods
     // with exception handlers since the mappings are from PC to PC
 
-    // debugging support
-    // tracing
-    if (log_is_enabled(Info, exceptions)) {
-      ResourceMark rm;
-      stringStream tempst;
-      assert(nm->method() != NULL, "Unexpected NULL method()");
-      tempst.print("compiled method <%s>\n"
-                   " at PC" INTPTR_FORMAT " for thread " INTPTR_FORMAT,
-                   nm->method()->print_value_string(), p2i(pc), p2i(thread));
-      Exceptions::log_exception(exception, tempst.as_string());
-    }
-    // for AbortVMOnException flag
-    Exceptions::debug_check_abort(exception);
-
     // Clear out the exception oop and pc since looking up an
     // exception handler can cause class loading, which might throw an
     // exception and those fields are expected to be clear during

src/hotspot/share/ci/ciMethodData.cpp

@@ -47,6 +47,7 @@ ciMethodData::ciMethodData(MethodData* md)
   _saw_free_extra_data(false),
   // Initialize the escape information (to "don't know.");
   _eflags(0), _arg_local(0), _arg_stack(0), _arg_returned(0),
+  _creation_mileage(0),
   _current_mileage(0),
   _invocation_counter(0),
   _backedge_counter(0),
@@ -242,6 +243,7 @@ void ciMethodData::load_data() {
   load_remaining_extra_data();
 
   // Note:  Extra data are all BitData, and do not need translation.
+  _creation_mileage = mdo->creation_mileage();
   _current_mileage = MethodData::mileage_of(mdo->method());
   _invocation_counter = mdo->invocation_count();
   _backedge_counter = mdo->backedge_count();

src/hotspot/share/ci/ciMethodData.hpp

@@ -395,6 +395,8 @@ class ciMethodData : public ciMetadata {
   intx _arg_stack;    // bit set of stack-allocatable arguments
   intx _arg_returned; // bit set of returned arguments
 
+  int _creation_mileage; // method mileage at MDO creation
+
   // Maturity of the oop when the snapshot is taken.
   int _current_mileage;
 
@@ -475,7 +477,7 @@ class ciMethodData : public ciMetadata {
   bool is_empty()  { return _state == empty_state; }
   bool is_mature() { return _state == mature_state; }
 
-  int creation_mileage() { return _orig.creation_mileage(); }
+  int creation_mileage() { return _creation_mileage; }
   int current_mileage()  { return _current_mileage; }
 
   int invocation_count() { return _invocation_counter; }

src/hotspot/share/gc/g1/g1HeapVerifier.cpp

@@ -472,6 +472,7 @@ bool G1HeapVerifier::should_verify(G1VerifyType type) {
 
 void G1HeapVerifier::verify(VerifyOption vo) {
   assert_at_safepoint_on_vm_thread();
+  assert(Heap_lock->is_locked(), "heap must be locked");
 
   log_debug(gc, verify)("Roots");
   VerifyRootsClosure rootsCl(vo);

src/hotspot/share/gc/shared/allocTracer.cpp

@@ -24,111 +24,32 @@
 
 #include "precompiled.hpp"
 #include "gc/shared/allocTracer.hpp"
-#include "gc/shared/threadLocalAllocBuffer.inline.hpp"
 #include "jfr/jfrEvents.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/macros.hpp"
 #if INCLUDE_JFR
 #include "jfr/support/jfrAllocationTracer.hpp"
 #endif
 
-static THREAD_LOCAL int64_t _last_allocated_bytes = 0;
-
-inline void send_allocation_sample(const Klass* klass, int64_t allocated_bytes) {
-  assert(allocated_bytes > 0, "invariant");
-  EventObjectAllocationSample event;
-  if (event.should_commit()) {
-    const size_t weight = allocated_bytes - _last_allocated_bytes;
-    assert(weight > 0, "invariant");
-    event.set_objectClass(klass);
-    event.set_weight(weight);
-    event.commit();
-    _last_allocated_bytes = allocated_bytes;
-  }
-}
-
-inline bool send_allocation_sample_with_result(const Klass* klass, int64_t allocated_bytes) {
-  assert(allocated_bytes > 0, "invariant");
-  EventObjectAllocationSample event;
-  if (event.should_commit()) {
-    const size_t weight = allocated_bytes - _last_allocated_bytes;
-    assert(weight > 0, "invariant");
-    event.set_objectClass(klass);
-    event.set_weight(weight);
-    event.commit();
-    _last_allocated_bytes = allocated_bytes;
-    return true;
-  }
-  return false;
-}
-
-inline intptr_t estimate_tlab_size_bytes(Thread* thread) {
-  assert(thread != NULL, "invariant");
-  const size_t desired_tlab_size_bytes = thread->tlab().desired_size() * HeapWordSize;
-  const size_t alignment_reserve_bytes = thread->tlab().alignment_reserve_in_bytes();
-  assert(desired_tlab_size_bytes > alignment_reserve_bytes, "invariant");
-  return static_cast<intptr_t>(desired_tlab_size_bytes - alignment_reserve_bytes);
-}
-
-inline int64_t load_allocated_bytes(Thread* thread) {
-  const int64_t allocated_bytes = thread->allocated_bytes();
-  if (allocated_bytes < _last_allocated_bytes) {
-    // A hw thread can detach and reattach to the VM, and when it does,
-    // it gets a new JavaThread representation. The thread local variable
-    // tracking _last_allocated_bytes is mapped to the existing hw thread,
-    // so it needs to be reset.
-    _last_allocated_bytes = 0;
-  }
-  return allocated_bytes == _last_allocated_bytes ? 0 : allocated_bytes;
-}
-
-// To avoid large objects from being undersampled compared to the regular TLAB samples,
-// the data amount is normalized as if it was a TLAB, giving a number of TLAB sampling attempts to the large object.
-static void normalize_as_tlab_and_send_allocation_samples(Klass* klass, intptr_t obj_alloc_size_bytes, Thread* thread) {
-  const int64_t allocated_bytes = load_allocated_bytes(thread);
-  assert(allocated_bytes > 0, "invariant"); // obj_alloc_size_bytes is already attributed to allocated_bytes at this point.
-  if (!UseTLAB) {
-    send_allocation_sample(klass, allocated_bytes);
-    return;
-  }
-  const intptr_t tlab_size_bytes = estimate_tlab_size_bytes(thread);
-  if (allocated_bytes - _last_allocated_bytes < tlab_size_bytes) {
-    return;
-  }
-  assert(obj_alloc_size_bytes > 0, "invariant");
-  do {
-    if (send_allocation_sample_with_result(klass, allocated_bytes)) {
-      return;
-    }
-    obj_alloc_size_bytes -= tlab_size_bytes;
-  } while (obj_alloc_size_bytes > 0);
-}
-
 void AllocTracer::send_allocation_outside_tlab(Klass* klass, HeapWord* obj, size_t alloc_size, Thread* thread) {
-  JFR_ONLY(JfrAllocationTracer tracer(obj, alloc_size, thread);)
+  JFR_ONLY(JfrAllocationTracer tracer(klass, obj, alloc_size, true, thread);)
   EventObjectAllocationOutsideTLAB event;
   if (event.should_commit()) {
     event.set_objectClass(klass);
     event.set_allocationSize(alloc_size);
     event.commit();
   }
-  normalize_as_tlab_and_send_allocation_samples(klass, static_cast<intptr_t>(alloc_size), thread);
 }
 
 void AllocTracer::send_allocation_in_new_tlab(Klass* klass, HeapWord* obj, size_t tlab_size, size_t alloc_size, Thread* thread) {
-  JFR_ONLY(JfrAllocationTracer tracer(obj, alloc_size, thread);)
+  JFR_ONLY(JfrAllocationTracer tracer(klass, obj, alloc_size, false, thread);)
   EventObjectAllocationInNewTLAB event;
   if (event.should_commit()) {
     event.set_objectClass(klass);
     event.set_allocationSize(alloc_size);
     event.set_tlabSize(tlab_size);
     event.commit();
   }
-  const int64_t allocated_bytes = load_allocated_bytes(thread);
-  if (allocated_bytes == 0) {
-    return;
-  }
-  send_allocation_sample(klass, allocated_bytes);
 }
 
 void AllocTracer::send_allocation_requiring_gc_event(size_t size, uint gcId) {

src/hotspot/share/gc/shared/gcVMOperations.cpp

@@ -46,6 +46,20 @@
 #include "gc/g1/g1Policy.hpp"
 #endif // INCLUDE_G1GC
 
+bool VM_GC_Sync_Operation::doit_prologue() {
+  Heap_lock->lock();
+  return true;
+}
+
+void VM_GC_Sync_Operation::doit_epilogue() {
+  Heap_lock->unlock();
+}
+
+void VM_Verify::doit() {
+  Universe::heap()->prepare_for_verify();
+  Universe::verify();
+}
+
 VM_GC_Operation::~VM_GC_Operation() {
   CollectedHeap* ch = Universe::heap();
   ch->soft_ref_policy()->set_all_soft_refs_clear(false);
@@ -94,8 +108,7 @@ bool VM_GC_Operation::doit_prologue() {
               proper_unit_for_byte_size(NewSize)));
   }
 
-  // If the GC count has changed someone beat us to the collection
-  Heap_lock->lock();
+  VM_GC_Sync_Operation::doit_prologue();
 
   // Check invocations
   if (skip_operation()) {
@@ -116,7 +129,7 @@ void VM_GC_Operation::doit_epilogue() {
   if (Universe::has_reference_pending_list()) {
     Heap_lock->notify_all();
   }
-  Heap_lock->unlock();
+  VM_GC_Sync_Operation::doit_epilogue();
 }
 
 bool VM_GC_HeapInspection::skip_operation() const {

src/hotspot/share/gc/shared/gcVMOperations.hpp

@@ -39,17 +39,27 @@
 // a set of operations (VM_Operation) related to GC.
 //
 //  VM_Operation
+//    VM_GC_Sync_Operation
 //      VM_GC_Operation
-//          VM_GC_HeapInspection
-//          VM_GenCollectFull
-//          VM_GenCollectFullConcurrent
-//          VM_ParallelGCSystemGC
-//          VM_CollectForAllocation
-//              VM_GenCollectForAllocation
-//              VM_ParallelGCFailedAllocation
+//        VM_GC_HeapInspection
+//        VM_PopulateDynamicDumpSharedSpace
+//        VM_GenCollectFull
+//        VM_GenCollectFullConcurrent
+//        VM_ParallelGCSystemGC
+//        VM_CollectForAllocation
+//          VM_GenCollectForAllocation
+//          VM_ParallelGCFailedAllocation
+//      VM_Verify
+//      VM_PopulateDumpSharedSpace
+//
+//  VM_GC_Sync_Operation
+//   - implements only synchronization with other VM operations of the
+//     same kind using the Heap_lock, not actually doing a GC.
+//
 //  VM_GC_Operation
-//   - implements methods common to all classes in the hierarchy:
-//     prevents multiple gc requests and manages lock on heap;
+//   - implements methods common to all operations that perform garbage collections,
+//     checking that the VM is in a state to do GC and preventing multiple GC
+//     requests.
 //
 //  VM_GC_HeapInspection
 //   - prints class histogram on SIGBREAK if PrintClassHistogram
@@ -68,11 +78,37 @@
 //   - these operations preform full collection of heaps of
 //     different kind
 //
+//  VM_Verify
+//   - verifies the heap
+//
+//  VM_PopulateDynamicDumpSharedSpace
+//   - populates the CDS archive area with the information from the archive file.
+//
+//  VM_PopulateDumpSharedSpace
+//   - creates the CDS archive
+//
+
+class VM_GC_Sync_Operation : public VM_Operation {
+public:
+
+  VM_GC_Sync_Operation() : VM_Operation() { }
+
+  // Acquires the Heap_lock.
+  virtual bool doit_prologue();
+  // Releases the Heap_lock.
+  virtual void doit_epilogue();
+};
+
+class VM_Verify : public VM_GC_Sync_Operation {
+ public:
+  VMOp_Type type() const { return VMOp_Verify; }
+  void doit();
+};
 
-class VM_GC_Operation: public VM_Operation {
+class VM_GC_Operation: public VM_GC_Sync_Operation {
  protected:
-  uint           _gc_count_before;         // gc count before acquiring PLL
-  uint           _full_gc_count_before;    // full gc count before acquiring PLL
+  uint           _gc_count_before;         // gc count before acquiring the Heap_lock
+  uint           _full_gc_count_before;    // full gc count before acquiring the Heap_lock
   bool           _full;                    // whether a "full" collection
   bool           _prologue_succeeded;      // whether doit_prologue succeeded
   GCCause::Cause _gc_cause;                // the putative cause for this gc op
@@ -84,7 +120,7 @@ class VM_GC_Operation: public VM_Operation {
   VM_GC_Operation(uint gc_count_before,
                   GCCause::Cause _cause,
                   uint full_gc_count_before = 0,
-                  bool full = false) {
+                  bool full = false) : VM_GC_Sync_Operation() {
     _full = full;
     _prologue_succeeded = false;
     _gc_count_before    = gc_count_before;
@@ -106,9 +142,10 @@ class VM_GC_Operation: public VM_Operation {
   }
   ~VM_GC_Operation();
 
-  // Acquire the reference synchronization lock
+  // Acquire the Heap_lock and determine if this VM operation should be executed
+  // (i.e. not skipped). Return this result, and also store it in _prologue_succeeded.
   virtual bool doit_prologue();
-  // Do notifyAll (if needed) and release held lock
+  // Notify the Heap_lock if needed and release it.
   virtual void doit_epilogue();
 
   virtual bool allow_nested_vm_operations() const  { return true; }

src/hotspot/share/gc/z/zDriver.cpp

@@ -24,6 +24,7 @@
 #include "precompiled.hpp"
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/gcLocker.hpp"
+#include "gc/shared/gcVMOperations.hpp"
 #include "gc/shared/isGCActiveMark.hpp"
 #include "gc/z/zBreakpoint.hpp"
 #include "gc/z/zCollectedHeap.hpp"

src/hotspot/share/jfr/support/jfrAllocationTracer.cpp

@@ -25,10 +25,12 @@
 #include "precompiled.hpp"
 #include "jfr/leakprofiler/leakProfiler.hpp"
 #include "jfr/support/jfrAllocationTracer.hpp"
+#include "jfr/support/jfrObjectAllocationSample.hpp"
 #include "jfr/support/jfrThreadLocal.hpp"
 #include "runtime/thread.hpp"
 
-JfrAllocationTracer::JfrAllocationTracer(HeapWord* obj, size_t alloc_size, Thread* thread) : _tl(NULL) {
+JfrAllocationTracer::JfrAllocationTracer(const Klass* klass, HeapWord* obj, size_t alloc_size, bool outside_tlab, Thread* thread) : _tl(NULL) {
+  JfrObjectAllocationSample::send_event(klass, alloc_size, outside_tlab, thread);
   if (LeakProfiler::is_running()) {
     _tl = thread->jfr_thread_local();
     LeakProfiler::sample(obj, alloc_size, thread->as_Java_thread());

src/hotspot/share/jfr/support/jfrAllocationTracer.hpp

@@ -27,13 +27,15 @@
 
 #include "memory/allocation.hpp"
 
+class Klass;
 class JfrThreadLocal;
+class Thread;
 
 class JfrAllocationTracer : public StackObj {
  private:
   JfrThreadLocal* _tl;
  public:
-  JfrAllocationTracer(HeapWord* obj, size_t alloc_size, Thread* thread);
+  JfrAllocationTracer(const Klass* klass, HeapWord* obj, size_t alloc_size, bool outside_tlab, Thread* thread);
   ~JfrAllocationTracer();
 };