[Draft] Test/shen oc

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

@@ -27,6 +27,8 @@
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTrace.hpp"
+#include "jfr/jfrEvents.hpp"
+#include "gc/shared/objectCountClosure.hpp"
 #include "gc/shared/objectCountEventSender.hpp"
 #include "gc/shared/referenceProcessorStats.hpp"
 #include "memory/heapInspection.hpp"
@@ -74,6 +76,8 @@ void GCTracer::report_gc_reference_stats(const ReferenceProcessorStats& rps) con
 }
 
 #if INCLUDE_SERVICES
+
+template <typename Event>
 class ObjectCountEventSenderClosure : public KlassInfoClosure {
   const double _size_threshold_percentage;
   const size_t _total_size_in_words;
@@ -88,7 +92,7 @@ class ObjectCountEventSenderClosure : public KlassInfoClosure {
 
   virtual void do_cinfo(KlassInfoEntry* entry) {
     if (should_send_event(entry)) {
-      ObjectCountEventSender::send(entry, _timestamp);
+      ObjectCountEventSender::send<Event>(entry, _timestamp);
     }
   }
 
@@ -99,21 +103,32 @@ class ObjectCountEventSenderClosure : public KlassInfoClosure {
   }
 };
 
+void GCTracer::report_object_count() {
+  KlassInfoTable* cit = ObjectCountClosure::get_table();
+  if (cit == nullptr || !ObjectCountEventSender::should_send_event<EventObjectCountAfterGC>()) {
+    return;
+  }
+
+  ObjectCountEventSenderClosure<EventObjectCountAfterGC> event_sender(cit->size_of_instances_in_words(), Ticks::now());
+  cit->iterate(&event_sender);
+  ObjectCountClosure::reset_table();
+}
+
 void GCTracer::report_object_count_after_gc(BoolObjectClosure* is_alive_cl, WorkerThreads* workers) {
   assert(is_alive_cl != nullptr, "Must supply function to check liveness");
-
-  if (ObjectCountEventSender::should_send_event()) {
+  if (ObjectCountEventSender::should_send_event<EventObjectCountAfterGC>()) {
     ResourceMark rm;
 
     KlassInfoTable cit(false);
     if (!cit.allocation_failed()) {
       HeapInspection hi;
       hi.populate_table(&cit, is_alive_cl, workers);
-      ObjectCountEventSenderClosure event_sender(cit.size_of_instances_in_words(), Ticks::now());
+      ObjectCountEventSenderClosure<EventObjectCountAfterGC> event_sender(cit.size_of_instances_in_words(), Ticks::now());
       cit.iterate(&event_sender);
     }
   }
 }
+
 #endif // INCLUDE_SERVICES
 
 void GCTracer::report_gc_heap_summary(GCWhen::Type when, const GCHeapSummary& heap_summary) const {

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

@@ -103,6 +103,8 @@ class GCTracer {
   void report_gc_heap_summary(GCWhen::Type when, const GCHeapSummary& heap_summary) const;
   void report_metaspace_summary(GCWhen::Type when, const MetaspaceSummary& metaspace_summary) const;
   void report_gc_reference_stats(const ReferenceProcessorStats& rp) const;
+  // Sends event data to the ObjectCountAfterGC event
+  void report_object_count() NOT_SERVICES_RETURN;
   void report_object_count_after_gc(BoolObjectClosure* object_filter, WorkerThreads* workers) NOT_SERVICES_RETURN;
   void report_cpu_time_event(double user_time, double system_time, double real_time) const;
 

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

@@ -0,0 +1,49 @@
+
+#include "gc/shared/objectCountClosure.hpp"
+#include "gc/shared/objectCountEventSender.hpp"
+#include "jfr/jfrEvents.hpp"
+#include "memory/heapInspection.hpp"
+#include "utilities/macros.hpp"
+#include "utilities/ticks.hpp"
+
+#if INCLUDE_SERVICES
+
+KlassInfoTable* ObjectCountClosure::cit = nullptr;
+
+void ObjectCountClosure::reset_table() {
+    if (!check_table_exists()) {
+        return;
+    }
+    cit->clear_entries();
+  }
+
+
+bool ObjectCountClosure::check_table_exists() {
+    if (cit == nullptr) {
+        static KlassInfoTable temp_table(false);
+        cit = &temp_table;
+    }
+    return !cit->allocation_failed();
+}
+
+bool ObjectCountClosure::record_object(oop o) {
+    if (!check_table_exists()) {
+        return false;
+    }
+    return cit->record_instance(o);
+}
+
+KlassInfoTable* ObjectCountClosure::get_table() {
+    return check_table_exists() ? cit : nullptr;
+}
+
+
+template <class Event>
+bool ObjectCountClosure::should_send_event() {
+    return ObjectCountEventSender::should_send_event<Event>();
+}
+
+template bool ObjectCountClosure::should_send_event<EventObjectCount>();
+template bool ObjectCountClosure::should_send_event<EventObjectCountAfterGC>();
+
+#endif // INCLUDE_SERVICES

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

@@ -0,0 +1,34 @@
+#ifndef SHARE_GC_SHARED_OBJECTCOUNTCLOSURE_HPP
+#define SHARE_GC_SHARED_OBJECTCOUNTCLOSURE_HPP
+
+#include "gc/shared/gcId.hpp"
+#include "gc/shared/objectCountEventSender.hpp"
+#include "jfr/jfrEvents.hpp"
+#include "memory/allStatic.hpp"
+#include "runtime/mutex.hpp"
+#include "memory/heapInspection.hpp"
+#include "utilities/macros.hpp"
+#include "utilities/ticks.hpp"
+
+class KlassInfoEntry;
+class Klass;
+
+class ObjectCountClosure : public AllStatic {
+    static KlassInfoTable* cit;
+
+public:
+    // Return false if allocation of KlassInfoTable failed.
+    static bool check_table_exists();
+    // Return false if object could not be recorded in the KlassInfoTable.
+    static bool record_object(oop o);
+    // Returns the KlassInfoTable if it exists, otherwise returns nullptr.
+    static KlassInfoTable* get_table();
+    // Clear entries of the KlassInfoTable
+    static void reset_table();
+
+    // Returns true if event is enabled
+    template <class Event>
+    static bool should_send_event();
+};
+
+#endif // SHARE_GC_SHARED_OBJECTCOUNTCLOSURE_HPP

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

@@ -26,14 +26,16 @@
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/objectCountEventSender.hpp"
 #include "jfr/jfrEvents.hpp"
+#include "runtime/mutex.hpp"
 #include "memory/heapInspection.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/ticks.hpp"
 #if INCLUDE_SERVICES
 
+template <class Event>
 bool ObjectCountEventSender::should_send_event() {
 #if INCLUDE_JFR
-  return _should_send_requestable_event || EventObjectCountAfterGC::is_enabled();
+  return _should_send_requestable_event || Event::is_enabled();
 #else
   return false;
 #endif // INCLUDE_JFR
@@ -63,13 +65,25 @@ void ObjectCountEventSender::send_event_if_enabled(Klass* klass, jlong count, ju
   }
 }
 
+
+template <class Event>
 void ObjectCountEventSender::send(const KlassInfoEntry* entry, const Ticks& timestamp) {
   Klass* klass = entry->klass();
   jlong count = entry->count();
   julong total_size = entry->words() * BytesPerWord;
 
-  send_event_if_enabled<EventObjectCount>(klass, count, total_size, timestamp);
-  send_event_if_enabled<EventObjectCountAfterGC>(klass, count, total_size, timestamp);
+  send_event_if_enabled<Event>(klass, count, total_size, timestamp);
+  // If sending ObjectCountAfterGCEvent, check if ObjectCount is enabled and send event data to ObjectCount
+  // If sending ObjectCountEvent, do not send send ObjectCountAfterGCEvent
+  if (std::is_same<Event, EventObjectCountAfterGC>::value && ObjectCountEventSender::should_send_event<EventObjectCount>()) {
+    send_event_if_enabled<EventObjectCount>(klass, count, total_size, timestamp);
+  }
 }
 
+template bool ObjectCountEventSender::should_send_event<EventObjectCount>();
+template bool ObjectCountEventSender::should_send_event<EventObjectCountAfterGC>();
+
+template void ObjectCountEventSender::send<EventObjectCount>(const KlassInfoEntry*, const Ticks&);
+template void ObjectCountEventSender::send<EventObjectCountAfterGC>(const KlassInfoEntry*, const Ticks&);
+
 #endif // INCLUDE_SERVICES

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

@@ -25,7 +25,6 @@
 #ifndef SHARE_GC_SHARED_OBJECTCOUNTEVENTSENDER_HPP
 #define SHARE_GC_SHARED_OBJECTCOUNTEVENTSENDER_HPP
 
-#include "gc/shared/gcTrace.hpp"
 #include "memory/allStatic.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/macros.hpp"
@@ -39,17 +38,21 @@ class Klass;
 class ObjectCountEventSender : public AllStatic {
   static bool _should_send_requestable_event;
 
-  template <typename T>
+  template <typename Event>
   static void send_event_if_enabled(Klass* klass, jlong count, julong size, const Ticks& timestamp);
 
  public:
   static void enable_requestable_event();
   static void disable_requestable_event();
 
+  template <class Event>
   static void send(const KlassInfoEntry* entry, const Ticks& timestamp);
+
+  template <class Event>
   static bool should_send_event();
 };
 
+
 #endif // INCLUDE_SERVICES
 
 #endif // SHARE_GC_SHARED_OBJECTCOUNTEVENTSENDER_HPP

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

@@ -28,13 +28,15 @@
 #include "gc/shared/barrierSetNMethod.hpp"
 #include "gc/shared/collectorCounters.hpp"
 #include "gc/shared/continuationGCSupport.inline.hpp"
+#include "gc/shared/gcTrace.hpp"
 #include "gc/shenandoah/shenandoahBreakpoint.hpp"
 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
 #include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
 #include "gc/shenandoah/shenandoahConcurrentGC.hpp"
 #include "gc/shenandoah/shenandoahFreeSet.hpp"
 #include "gc/shenandoah/shenandoahGeneration.hpp"
 #include "gc/shenandoah/shenandoahGenerationalHeap.hpp"
+#include "gc/shenandoah/shenandoahHeap.hpp"
 #include "gc/shenandoah/shenandoahLock.hpp"
 #include "gc/shenandoah/shenandoahMark.inline.hpp"
 #include "gc/shenandoah/shenandoahMonitoringSupport.hpp"
@@ -770,6 +772,11 @@ void ShenandoahConcurrentGC::op_final_mark() {
     heap->verifier()->verify_roots_no_forwarded();
   }
 
+  {
+    heap->tracer()->report_object_count();
+  }
+
+
   if (!heap->cancelled_gc()) {
     _mark.finish_mark();
     assert(!heap->cancelled_gc(), "STW mark cannot OOM");

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

@@ -47,6 +47,7 @@
 #include "runtime/prefetch.inline.hpp"
 #include "utilities/devirtualizer.inline.hpp"
 #include "utilities/powerOfTwo.hpp"
+#include "gc/shared/objectCountClosure.hpp"
 
 template <StringDedupMode STRING_DEDUP>
 void ShenandoahMark::dedup_string(oop obj, StringDedup::Requests* const req) {
@@ -367,6 +368,10 @@ inline void ShenandoahMark::mark_ref(ShenandoahObjToScanQueue* q,
   if (marked) {
     bool pushed = q->push(ShenandoahMarkTask(obj, skip_live, weak));
     assert(pushed, "overflow queue should always succeed pushing");
+    bool should_record = ObjectCountClosure::should_send_event<EventObjectCountAfterGC>();
+    if (should_record) {
+      ObjectCountClosure::record_object(obj);
+    }
   }
 }
 

src/hotspot/share/memory/heapInspection.cpp

@@ -217,9 +217,10 @@ bool KlassInfoTable::record_instance(const oop obj) {
   // elt may be null if it's a new klass for which we
   // could not allocate space for a new entry in the hashtable.
   if (elt != nullptr) {
-    elt->set_count(elt->count() + 1);
-    elt->set_words(elt->words() + obj->size());
-    _size_of_instances_in_words += obj->size();
+    elt->atomic_inc_count();
+    size_t obj_size = obj->size();
+    elt->atomic_add_words(obj_size);
+    Atomic::add(&_size_of_instances_in_words, obj_size);
     return true;
   } else {
     return false;
@@ -265,6 +266,16 @@ class KlassInfoTableMergeClosure : public KlassInfoClosure {
   bool success() { return _success; }
 };
 
+void KlassInfoTable::clear_entries() {
+  if (_buckets != nullptr) {
+    for (int index = 0; index < _num_buckets; index++) {
+      _buckets[index].empty();
+      _buckets[index].initialize();
+    }
+    _size_of_instances_in_words = 0;
+  }
+}
+
 // merge from table
 bool KlassInfoTable::merge(KlassInfoTable* table) {
   KlassInfoTableMergeClosure closure(this);

src/hotspot/share/memory/heapInspection.hpp

@@ -30,6 +30,7 @@
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.hpp"
 #include "oops/annotations.hpp"
+#include "runtime/atomic.hpp"
 #include "utilities/macros.hpp"
 
 class ParallelObjectIterator;
@@ -71,8 +72,11 @@ class KlassInfoEntry: public CHeapObj<mtInternal> {
   Klass* klass()  const          { return _klass; }
   uint64_t count()    const      { return _instance_count; }
   void set_count(uint64_t ct)    { _instance_count = ct; }
+  void atomic_inc_count()        { Atomic::inc(&_instance_count); }
+  void atomic_add_count(uint64_t add) { Atomic::add(&_instance_count, add); }
   size_t words()  const          { return _instance_words; }
   void set_words(size_t wds)     { _instance_words = wds; }
+  void atomic_add_words(size_t add) { Atomic::add(&_instance_words, add); }
   void set_index(int64_t index)  { _index = index; }
   int64_t index()    const       { return _index; }
   GrowableArray<KlassInfoEntry*>* subclasses() const { return _subclasses; }
@@ -126,7 +130,8 @@ class KlassInfoTable: public StackObj {
   size_t size_of_instances_in_words() const;
   bool merge(KlassInfoTable* table);
   bool merge_entry(const KlassInfoEntry* cie);
-
+  // Clears entries in the table
+  void clear_entries();
   friend class KlassInfoHisto;
   friend class KlassHierarchy;
 };