[Draft] Test/shen aggregate closure

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

@@ -27,7 +27,6 @@
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTrace.hpp"
-#include "gc/shared/objectCountEventSender.hpp"
 #include "gc/shared/referenceProcessorStats.hpp"
 #include "memory/heapInspection.hpp"
 #include "memory/resourceArea.hpp"
@@ -74,31 +73,6 @@ void GCTracer::report_gc_reference_stats(const ReferenceProcessorStats& rps) con
 }
 
 #if INCLUDE_SERVICES
-class ObjectCountEventSenderClosure : public KlassInfoClosure {
-  const double _size_threshold_percentage;
-  const size_t _total_size_in_words;
-  const Ticks _timestamp;
-
- public:
-  ObjectCountEventSenderClosure(size_t total_size_in_words, const Ticks& timestamp) :
-    _size_threshold_percentage(ObjectCountCutOffPercent / 100),
-    _total_size_in_words(total_size_in_words),
-    _timestamp(timestamp)
-  {}
-
-  virtual void do_cinfo(KlassInfoEntry* entry) {
-    if (should_send_event(entry)) {
-      ObjectCountEventSender::send(entry, _timestamp);
-    }
-  }
-
- private:
-  bool should_send_event(const KlassInfoEntry* entry) const {
-    double percentage_of_heap = ((double) entry->words()) / _total_size_in_words;
-    return percentage_of_heap >= _size_threshold_percentage;
-  }
-};
-
 void GCTracer::report_object_count_after_gc(BoolObjectClosure* is_alive_cl, WorkerThreads* workers) {
   assert(is_alive_cl != nullptr, "Must supply function to check liveness");
 

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

@@ -30,7 +30,9 @@
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/gcName.hpp"
 #include "gc/shared/gcWhen.hpp"
+#include "gc/shared/objectCountEventSender.hpp"
 #include "gc/shared/workerThread.hpp"
+#include "memory/heapInspection.hpp"
 #include "memory/metaspace.hpp"
 #include "memory/referenceType.hpp"
 #include "utilities/macros.hpp"
@@ -92,6 +94,33 @@ class ParallelOldGCInfo {
   void* dense_prefix() const { return _dense_prefix; }
 };
 
+#if INCLUDE_SERVICES
+class ObjectCountEventSenderClosure : public KlassInfoClosure {
+  const double _size_threshold_percentage;
+  const size_t _total_size_in_words;
+  const Ticks _timestamp;
+
+ public:
+  ObjectCountEventSenderClosure(size_t total_size_in_words, const Ticks& timestamp) :
+    _size_threshold_percentage(ObjectCountCutOffPercent / 100),
+    _total_size_in_words(total_size_in_words),
+    _timestamp(timestamp)
+  {}
+
+  virtual void do_cinfo(KlassInfoEntry* entry) {
+    if (should_send_event(entry)) {
+      ObjectCountEventSender::send(entry, _timestamp);
+    }
+  }
+
+ private:
+  bool should_send_event(const KlassInfoEntry* entry) const {
+    double percentage_of_heap = ((double) entry->words()) / _total_size_in_words;
+    return percentage_of_heap >= _size_threshold_percentage;
+  }
+};
+#endif // INCLUDE_SERVICES
+
 class GCTracer {
  protected:
   SharedGCInfo _shared_gc_info;
@@ -104,6 +133,10 @@ class GCTracer {
   void report_metaspace_summary(GCWhen::Type when, const MetaspaceSummary& metaspace_summary) const;
   void report_gc_reference_stats(const ReferenceProcessorStats& rp) const;
   void report_object_count_after_gc(BoolObjectClosure* object_filter, WorkerThreads* workers) NOT_SERVICES_RETURN;
+  // Report object count without performing a heap inspection. This method will
+  // only work if there's a global KlassInfoTable in the heap.
+  template <typename T>
+  void report_object_count() NOT_SERVICES_RETURN;
   void report_cpu_time_event(double user_time, double system_time, double real_time) const;
 
  protected:

src/hotspot/share/gc/shared/gcTrace.inline.hpp

@@ -0,0 +1,25 @@
+#ifndef SHARE_GC_SHARED_GCTRACE_INLINE_HPP
+#define SHARE_GC_SHARED_GCTRACE_INLINE_HPP
+
+#include "gc/shared/gcTrace.hpp"
+#include "memory/heapInspection.hpp"
+#include "utilities/macros.hpp"
+
+#if INCLUDE_SERVICES
+template <typename T>
+void GCTracer::report_object_count() {
+  if (!ObjectCountEventSender::should_send_event()) {
+    return;
+  }
+
+  T* heap = T::heap();
+  KlassInfoTable* cit = heap->get_cit();
+
+  if (!cit->allocation_failed()) {
+    ObjectCountEventSenderClosure event_sender(cit->size_of_instances_in_words(), Ticks::now());
+    cit->iterate(&event_sender);
+  }
+}
+#endif // INCLUDE_SERVICES
+
+#endif // SHARE_GC_SHARED_GCTRACE_INLINE_HPP

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

@@ -22,7 +22,6 @@
  *
  */
 
-
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/objectCountEventSender.hpp"
 #include "jfr/jfrEvents.hpp"

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

@@ -25,8 +25,8 @@
 #ifndef SHARE_GC_SHARED_OBJECTCOUNTEVENTSENDER_HPP
 #define SHARE_GC_SHARED_OBJECTCOUNTEVENTSENDER_HPP
 
-#include "gc/shared/gcTrace.hpp"
 #include "memory/allStatic.hpp"
+#include "memory/heapInspection.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/ticks.hpp"

src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp

@@ -27,6 +27,7 @@
 #include "code/nmethod.hpp"
 #include "gc/shared/stringdedup/stringDedup.hpp"
 #include "gc/shenandoah/shenandoahGenerationType.hpp"
+#include "gc/shenandoah/shenandoahObjectCountClosure.hpp"
 #include "gc/shenandoah/shenandoahTaskqueue.hpp"
 #include "memory/iterator.hpp"
 #include "runtime/javaThread.hpp"
@@ -73,7 +74,8 @@ class ShenandoahMarkRefsSuperClosure : public ShenandoahSuperClosure {
 
 protected:
   template <class T, ShenandoahGenerationType GENERATION>
-  void work(T *p);
+  // Return true if object was not previously marked strong by another thread.
+  bool work(T *p);
 
 public:
   inline ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp, ShenandoahObjToScanQueue* old_q);
@@ -106,6 +108,29 @@ class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
   virtual void do_oop(oop* p)       { do_oop_work(p); }
 };
 
+#if INCLUDE_JFR
+template <ShenandoahGenerationType GENERATION>
+class ShenandoahMarkRefsAndCountClosure : public ShenandoahMarkRefsSuperClosure {
+private:
+  ShenandoahObjectCountClosure* _count;
+  template <class T>
+  inline void do_oop_work(T* p) {
+    // Count newly marked strong references to avoid double counting.
+    const bool newly_marked_strong = work<T, GENERATION>(p);
+    if (newly_marked_strong) {
+      _count->do_oop(p);
+    }
+  }
+
+public:
+  ShenandoahMarkRefsAndCountClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp, ShenandoahObjToScanQueue* old_q, ShenandoahObjectCountClosure* count) :
+          ShenandoahMarkRefsSuperClosure(q, rp, old_q), _count(count) {};
+
+  virtual void do_oop(narrowOop* p) { do_oop_work(p); }
+  virtual void do_oop(oop* p)       { do_oop_work(p); }
+};
+#endif // INCLUDE_JFR
+
 class ShenandoahForwardedIsAliveClosure : public BoolObjectClosure {
 private:
   ShenandoahMarkingContext* const _mark_context;

src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp

@@ -77,8 +77,8 @@ ShenandoahMarkRefsSuperClosure::ShenandoahMarkRefsSuperClosure(ShenandoahObjToSc
         _weak(false) {}
 
 template<class T, ShenandoahGenerationType GENERATION>
-inline void ShenandoahMarkRefsSuperClosure::work(T* p) {
-  ShenandoahMark::mark_through_ref<T, GENERATION>(p, _queue, _old_queue, _mark_context, _weak);
+inline bool ShenandoahMarkRefsSuperClosure::work(T* p) {
+  return ShenandoahMark::mark_through_ref<T, GENERATION>(p, _queue, _old_queue, _mark_context, _weak);
 }
 
 ShenandoahForwardedIsAliveClosure::ShenandoahForwardedIsAliveClosure() :

src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp

@@ -28,6 +28,7 @@
 #include "gc/shared/barrierSetNMethod.hpp"
 #include "gc/shared/collectorCounters.hpp"
 #include "gc/shared/continuationGCSupport.inline.hpp"
+#include "gc/shared/gcTrace.inline.hpp"
 #include "gc/shenandoah/shenandoahBreakpoint.hpp"
 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
 #include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
@@ -314,6 +315,9 @@ void ShenandoahConcurrentGC::vmop_entry_final_mark() {
   heap->try_inject_alloc_failure();
   VM_ShenandoahFinalMarkStartEvac op(this);
   VMThread::execute(&op); // jump to entry_final_mark under safepoint
+  // Do not report object count during a safepoint
+  assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Should not be at safepoint");
+  heap->tracer()->report_object_count<ShenandoahHeap>();
 }
 
 void ShenandoahConcurrentGC::vmop_entry_init_update_refs() {

src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.cpp

@@ -23,7 +23,7 @@
  *
  */
 
-
+#include "gc/shared/objectCountEventSender.hpp"
 #include "gc/shared/satbMarkQueue.hpp"
 #include "gc/shared/strongRootsScope.hpp"
 #include "gc/shared/taskTerminator.hpp"
@@ -33,6 +33,7 @@
 #include "gc/shenandoah/shenandoahGeneration.hpp"
 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc/shenandoah/shenandoahMark.inline.hpp"
+#include "gc/shenandoah/shenandoahObjectCountClosure.hpp"
 #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
 #include "gc/shenandoah/shenandoahReferenceProcessor.hpp"
 #include "gc/shenandoah/shenandoahRootProcessor.inline.hpp"
@@ -45,6 +46,7 @@
 #include "runtime/continuation.hpp"
 #include "runtime/threads.hpp"
 
+
 template <ShenandoahGenerationType GENERATION>
 class ShenandoahConcurrentMarkingTask : public WorkerTask {
 private:
@@ -170,8 +172,24 @@ void ShenandoahMarkConcurrentRootsTask<GENERATION>::work(uint worker_id) {
   ShenandoahObjToScanQueue* q = _queue_set->queue(worker_id);
   ShenandoahObjToScanQueue* old_q = (_old_queue_set == nullptr) ?
           nullptr : _old_queue_set->queue(worker_id);
-  ShenandoahMarkRefsClosure<GENERATION> cl(q, _rp, old_q);
-  _root_scanner.roots_do(&cl, worker_id);
+
+#if INCLUDE_JFR
+  // Use object counting closure if ObjectCount or ObjectCountAfterGC event is enabled.
+  const bool object_count_enabled = ObjectCountEventSender::should_send_event();
+  if (object_count_enabled && !ShenandoahHeap::heap()->mode()->is_generational()) {
+    KlassInfoTable* const global_cit = ShenandoahHeap::heap()->get_cit();
+    KlassInfoTable local_cit(false);
+    ShenandoahIsAliveClosure is_alive;
+    ShenandoahObjectCountClosure count(&local_cit, &is_alive);
+    ShenandoahMarkRefsAndCountClosure<GENERATION> cl(q, _rp, old_q, &count);
+    _root_scanner.roots_do(&cl, worker_id);
+    count.merge_table(global_cit);
+  } else
+#endif // INCLUDE_JFR
+  {
+    ShenandoahMarkRefsClosure<GENERATION> cl(q, _rp, old_q);
+    _root_scanner.roots_do(&cl, worker_id);
+  }
 }
 
 void ShenandoahConcurrentMark::mark_concurrent_roots() {

src/hotspot/share/gc/shenandoah/shenandoahControlThread.cpp

@@ -125,6 +125,12 @@ void ShenandoahControlThread::run_service() {
     assert (!gc_requested || cause != GCCause::_last_gc_cause, "GC cause should be set");
 
     if (gc_requested) {
+      // Create the KlassInfoTable for Shenandoah only if JFR is enabled.
+#if INCLUDE_JFR
+      KlassInfoTable cit(false);
+      heap->set_cit(&cit);
+#endif // INCLUDE_JFR
+
       // Cannot uncommit bitmap slices during concurrent reset
       ShenandoahNoUncommitMark forbid_region_uncommit(heap);
 
@@ -224,6 +230,9 @@ void ShenandoahControlThread::run_service() {
 
       // Print Metaspace change following GC (if logging is enabled).
       MetaspaceUtils::print_metaspace_change(meta_sizes);
+#if INCLUDE_JFR
+      heap->set_cit(nullptr);
+#endif // INCLUDE_JFR
     }
 
     // Check if we have seen a new target for soft max heap size or if a gc was requested.

src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp

@@ -533,6 +533,7 @@ ShenandoahHeap::ShenandoahHeap(ShenandoahCollectorPolicy* policy) :
   _active_generation(nullptr),
   _initial_size(0),
   _committed(0),
+  _cit(nullptr),
   _max_workers(MAX3(ConcGCThreads, ParallelGCThreads, 1U)),
   _workers(nullptr),
   _safepoint_workers(nullptr),

src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp

@@ -43,6 +43,7 @@
 #include "gc/shenandoah/shenandoahPadding.hpp"
 #include "gc/shenandoah/shenandoahSharedVariables.hpp"
 #include "gc/shenandoah/shenandoahUnload.hpp"
+#include "memory/heapInspection.hpp"
 #include "memory/metaspace.hpp"
 #include "services/memoryManager.hpp"
 #include "utilities/globalDefinitions.hpp"
@@ -228,7 +229,8 @@ class ShenandoahHeap : public CollectedHeap {
   shenandoah_padding(0);
   volatile size_t _committed;
   shenandoah_padding(1);
-
+  // Used for JFR object count event support.
+  KlassInfoTable* _cit;
   void increase_used(const ShenandoahAllocRequest& req);
 
 public:
@@ -252,6 +254,10 @@ class ShenandoahHeap : public CollectedHeap {
 
   void set_soft_max_capacity(size_t v);
 
+  // Setter & accessor for class histogram
+  inline void set_cit(KlassInfoTable* cit);
+  inline KlassInfoTable* get_cit();
+
 // ---------- Periodic Tasks
 //
 public:

src/hotspot/share/gc/shenandoah/shenandoahHeap.inline.hpp

@@ -46,6 +46,7 @@
 #include "gc/shenandoah/shenandoahMarkingContext.inline.hpp"
 #include "gc/shenandoah/shenandoahThreadLocalData.hpp"
 #include "gc/shenandoah/shenandoahWorkGroup.hpp"
+#include "memory/heapInspection.hpp"
 #include "oops/compressedOops.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/atomic.hpp"
@@ -647,4 +648,15 @@ inline ShenandoahMarkingContext* ShenandoahHeap::marking_context() const {
   return _marking_context;
 }
 
+inline void ShenandoahHeap::set_cit(KlassInfoTable* cit) {
+  assert(_cit == nullptr || cit == nullptr, "Overwriting an existing histogram");
+  assert(_cit != nullptr || cit != nullptr, "Already cleared");
+  _cit = cit;
+}
+
+inline KlassInfoTable* ShenandoahHeap::get_cit() {
+  assert(_cit != nullptr, "KlassInfoTable is null");
+  return _cit;
+}
+
 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHHEAP_INLINE_HPP

src/hotspot/share/gc/shenandoah/shenandoahMark.cpp

@@ -24,7 +24,7 @@
  */
 
 
-
+#include "gc/shared/objectCountEventSender.hpp"
 #include "gc/shenandoah/shenandoahBarrierSet.hpp"
 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
 #include "gc/shenandoah/shenandoahGeneration.hpp"
@@ -69,9 +69,25 @@ void ShenandoahMark::mark_loop_prework(uint w, TaskTerminator *t, ShenandoahRefe
     Closure cl(q, rp, old_q);
     mark_loop_work<Closure, GENERATION, CANCELLABLE, STRING_DEDUP>(&cl, ld, w, t, req);
   } else {
-    using Closure = ShenandoahMarkRefsClosure<GENERATION>;
-    Closure cl(q, rp, old_q);
-    mark_loop_work<Closure, GENERATION, CANCELLABLE, STRING_DEDUP>(&cl, ld, w, t, req);
+#if INCLUDE_JFR
+    // Use object counting closure if ObjectCount or ObjectCountAfterGC event is enabled.
+    const bool object_count_enabled = ObjectCountEventSender::should_send_event();
+    if (object_count_enabled && !ShenandoahHeap::heap()->mode()->is_generational()) {
+      KlassInfoTable* const global_cit = ShenandoahHeap::heap()->get_cit();
+      KlassInfoTable local_cit(false);
+      ShenandoahIsAliveClosure is_alive;
+      ShenandoahObjectCountClosure count(&local_cit, &is_alive);
+      using Closure = ShenandoahMarkRefsAndCountClosure<GENERATION>;
+      Closure cl(q, rp, old_q, &count);
+      mark_loop_work<Closure, GENERATION, CANCELLABLE, STRING_DEDUP>(&cl, ld, w, t, req);
+      count.merge_table(global_cit);
+    } else
+#endif // INCLUDE_JFR
+    {
+      using Closure = ShenandoahMarkRefsClosure<GENERATION>;
+      Closure cl(q, rp, old_q);
+      mark_loop_work<Closure, GENERATION, CANCELLABLE, STRING_DEDUP>(&cl, ld, w, t, req);
+    }
   }
 
   heap->flush_liveness_cache(w);