Improve CompileTrainingData::_init_deps_left handling

Author: iwanowww

src/hotspot/share/cds/cds_globals.hpp

@@ -141,7 +141,9 @@
                                                                             \
   product(bool, ArchiveLoaderLookupCache, false,                            \
           "Archive app loader's positive and negative lookup cache")        \
-
+                                                                            \
+  product(bool, VerifyTrainingData, trueInDebug, DIAGNOSTIC,                \
+          "Verify archived training data")                                  \
 
 // end of CDS_FLAGS
 

src/hotspot/share/classfile/compactHashtable.hpp

@@ -302,6 +302,26 @@ class CompactHashtable : public SimpleCompactHashtable {
     }
   }
 
+  template<typename Function>
+  inline void iterate(Function function) const { // lambda enabled API
+    for (u4 i = 0; i < _bucket_count; i++) {
+      u4 bucket_info = _buckets[i];
+      u4 bucket_offset = BUCKET_OFFSET(bucket_info);
+      int bucket_type = BUCKET_TYPE(bucket_info);
+      u4* entry = _entries + bucket_offset;
+
+      if (bucket_type == VALUE_ONLY_BUCKET_TYPE) {
+        function(decode(entry[0]));
+      } else {
+        u4*entry_max = _entries + BUCKET_OFFSET(_buckets[i + 1]);
+        while (entry < entry_max) {
+          function(decode(entry[1]));
+          entry += 2;
+        }
+      }
+    }
+  }
+
   void print_table_statistics(outputStream* st, const char* name) {
     st->print_cr("%s statistics:", name);
     int total_entries = 0;

src/hotspot/share/code/SCCache.cpp

@@ -53,6 +53,7 @@
 #include "memory/universe.hpp"
 #include "oops/klass.inline.hpp"
 #include "oops/method.inline.hpp"
+#include "oops/trainingData.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "runtime/atomic.hpp"
 #include "runtime/flags/flagSetting.hpp"
@@ -185,6 +186,11 @@ void SCCache::close() {
         SCCache::print_statistics_on(&log);
         log.cr();
         SCCache::print_timers_on(&log);
+
+        LogStreamHandle(Info, scc, init) log1;
+        if (log1.is_enabled()) {
+          SCCache::print_unused_entries_on(&log1);
+        }
       }
     }
 
@@ -3320,6 +3326,47 @@ void SCCache::print_on(outputStream* st) {
   }
 }
 
+void SCCache::print_unused_entries_on(outputStream* st) {
+  LogStreamHandle(Info, scc, init) info;
+  if (info.is_enabled()) {
+    SCCache::iterate([&](SCCEntry* entry) {
+      if (!entry->is_loaded()) {
+        MethodTrainingData* mtd = MethodTrainingData::lookup_for(entry->method());
+        if (mtd != nullptr) {
+          if (mtd->has_holder()) {
+            if (mtd->holder()->method_holder()->is_initialized()) {
+              ResourceMark rm;
+              mtd->iterate_all_compiles([&](CompileTrainingData* ctd) {
+                if ((uint)ctd->level() == entry->comp_level()) {
+                  if (ctd->init_deps_left() == 0) {
+                    CompiledMethod* cm = mtd->holder()->code();
+                    if (cm == nullptr) {
+                      if (mtd->holder()->queued_for_compilation()) {
+                        return; // scheduled for compilation
+                      }
+                    } else if ((uint)cm->comp_level() >= entry->comp_level()) {
+                      return; // already online compiled and superseded by a more optimal method
+                    }
+                    info.print("SCC entry not loaded: ");
+                    ctd->print_on(&info);
+                    info.cr();
+                  }
+                }
+              });
+            } else {
+              // not yet initialized
+            }
+          } else {
+            info.print("SCC entry doesn't have a holder: ");
+            mtd->print_on(&info);
+            info.cr();
+          }
+        }
+      }
+    });
+  }
+}
+
 void SCCReader::print_on(outputStream* st) {
   uint entry_position = _entry->offset();
   set_read_position(entry_position);
@@ -3967,3 +4014,21 @@ int SCAddressTable::id_for_address(address addr, RelocIterator reloc, CodeBuffer
   }
   return id;
 }
+
+template<typename Function>
+void SCCache::iterate(Function function) { // lambda enabled API
+  SCCache* cache = open_for_read();
+  if (cache != nullptr) {
+    ReadingMark rdmk;
+
+    uint count = cache->_load_header->entries_count();
+    uint* search_entries = (uint*)cache->addr(cache->_load_header->entries_offset()); // [id, index]
+    SCCEntry* load_entries = (SCCEntry*)(search_entries + 2 * count);
+
+    for (uint i = 0; i < count; i++) {
+      int index = search_entries[2*i + 1];
+      SCCEntry* entry = &(load_entries[index]);
+      function(entry);
+    }
+  }
+}

src/hotspot/share/code/SCCache.hpp

@@ -527,11 +527,15 @@ class SCCache : public CHeapObj<mtCode> {
   static SCCEntry* find_code_entry(const methodHandle& method, uint comp_level);
   static void preload_code(JavaThread* thread);
 
+  template<typename Function>
+  static void iterate(Function function); // lambda enabled API
+
   static void add_C_string(const char* str);
 
   static void print_on(outputStream* st);
   static void print_statistics_on(outputStream* st);
   static void print_timers_on(outputStream* st);
+  static void print_unused_entries_on(outputStream* st);
 
   static void new_workflow_start_writing_cache() NOT_CDS_JAVA_HEAP_RETURN;
   static void new_workflow_end_writing_cache() NOT_CDS_JAVA_HEAP_RETURN;

src/hotspot/share/compiler/compilationPolicy.cpp

@@ -268,6 +268,7 @@ void CompilationPolicy::replay_training_at_init(InstanceKlass* klass, TRAPS) {
     } else {
       replay_training_at_init_impl(klass, THREAD);
     }
+    guarantee(!HAS_PENDING_EXCEPTION, "");
   }
 }
 

src/hotspot/share/oops/instanceKlass.cpp

@@ -844,6 +844,7 @@ void InstanceKlass::initialize_from_cds(TRAPS) {
     log_class_init(THREAD, this);
     set_init_thread(THREAD);
     set_initialization_state_and_notify(fully_initialized, CHECK);
+    CompilationPolicy::replay_training_at_init(this, THREAD);
     return;
   }
 

src/hotspot/share/oops/trainingData.cpp

@@ -101,13 +101,6 @@ void TrainingData::initialize() {
     TrainingDataLocker::initialize();
   }
   if (have_data()) {
-    // Initialize dependency tracking
-    training_data_set()->iterate_all([](const Key* k, TrainingData* td) {
-      if (td->is_MethodTrainingData()) {
-        td->as_MethodTrainingData()->initialize_deps_tracking();
-      }
-    });
-
     if (_recompilation_schedule != nullptr && _recompilation_schedule->length() > 0) {
       const int size = _recompilation_schedule->length();
       _recompilation_status = NEW_C_HEAP_ARRAY(bool, size, mtCompiler);
@@ -118,6 +111,17 @@ void TrainingData::initialize() {
   }
 }
 
+void TrainingData::verify() {
+  if (TrainingData::have_data()) {
+    archived_training_data_dictionary()->iterate([&](TrainingData* td) {
+      if (td->is_MethodTrainingData()) {
+        td->as_MethodTrainingData()->verify();
+      }
+    });
+  }
+}
+
+
 TrainingData::Key::Key(const KlassTrainingData* klass, Symbol* method_name, Symbol* signature)
   : Key(method_name, signature, klass) {}
 
@@ -278,7 +282,27 @@ void CompileTrainingData::dec_init_deps_left(KlassTrainingData* ktd) {
   assert(_init_deps.contains(ktd), "");
   assert(_init_deps_left > 0, "");
 
-  Atomic::sub(&_init_deps_left, 1);
+  uint init_deps_left1 = Atomic::sub(&_init_deps_left, 1);
+
+  if (log.is_enabled()) {
+    uint init_deps_left2 = compute_init_deps_left();
+    log.print("init_deps_left: %d (%d)", init_deps_left1, init_deps_left2);
+    ktd->print_on(&log, true);
+  }
+}
+
+uint CompileTrainingData::compute_init_deps_left(bool count_initialized) {
+  int left = 0;
+  for (int i = 0; i < _init_deps.length(); i++) {
+    KlassTrainingData* ktd = _init_deps.at(i);
+    // Ignore symbolic refs and already initialized classes (unless explicitly requested).
+    if (ktd->has_holder()) {
+      if (!ktd->holder()->is_initialized() || count_initialized) {
+        ++left;
+      }
+    }
+  }
+  return left;
 }
 
 void CompileTrainingData::print_on(outputStream* st, bool name_only) const {
@@ -1037,18 +1061,19 @@ void MethodTrainingData::restore_unshareable_info(TRAPS) {
   if (_final_profile != nullptr) {
     _final_profile->restore_unshareable_info(CHECK);
   }
-  initialize_deps_tracking();
 }
 
 void CompileTrainingData::remove_unshareable_info() {
   TrainingData::remove_unshareable_info();
   _init_deps.remove_unshareable_info();
   _ci_records.remove_unshareable_info();
+  _init_deps_left = compute_init_deps_left(true);
 }
 
 void CompileTrainingData::restore_unshareable_info(TRAPS) {
   TrainingData::restore_unshareable_info(CHECK);
   _init_deps.restore_unshareable_info(CHECK);
   _ci_records.restore_unshareable_info(CHECK);
+  guarantee(_init_deps_left == (int)compute_init_deps_left(), "mismatch");
 }
 #endif // INCLUDE_CDS

src/hotspot/share/oops/trainingData.hpp

@@ -265,6 +265,8 @@ class TrainingData : public Metadata {
 
   static void initialize();
 
+  static void verify();
+
   // Widget for recording dependencies, as an N-to-M graph relation,
   // possibly cyclic.
   template<typename E>
@@ -630,16 +632,10 @@ class CompileTrainingData : public TrainingData {
   }
   void dec_init_deps_left(KlassTrainingData* ktd);
   int init_deps_left() const {
-    return _init_deps_left;
-  }
-  void initialize_deps_tracking() {
-    for (int i = 0; i < _init_deps.length(); i++) {
-      KlassTrainingData* dep = _init_deps.at(i);
-      if (dep->has_holder() && !dep->holder()->is_initialized()) {
-        _init_deps_left++; // ignore symbolic refs && already initialized classes
-      }
-    }
+    return Atomic::load(&_init_deps_left);
   }
+  uint compute_init_deps_left(bool count_initialized = false);
+
   void record_compilation_queued(CompileTask* task);
   void record_compilation_start(CompileTask* task);
   void record_compilation_end(CompileTask* task);
@@ -785,8 +781,13 @@ class MethodTrainingData : public TrainingData {
     }
   }
 
-  void initialize_deps_tracking() {
-    iterate_all_compiles([](CompileTrainingData* ctd) { ctd->initialize_deps_tracking(); });
+  void verify() {
+    iterate_all_compiles([](CompileTrainingData* ctd) {
+      int init_deps_left1 = ctd->init_deps_left();
+      int init_deps_left2 = ctd->compute_init_deps_left();
+      guarantee(init_deps_left1 == init_deps_left2, "mismatch: %d %d %d",
+                init_deps_left1, init_deps_left2, ctd->init_deps_left());
+    });
   }
 
   virtual void metaspace_pointers_do(MetaspaceClosure* iter);

src/hotspot/share/runtime/java.cpp

@@ -591,6 +591,10 @@ void before_exit(JavaThread* thread, bool halt) {
   // Note: we don't wait until it actually dies.
   os::terminate_signal_thread();
 
+  if (VerifyTrainingData) {
+    TrainingData::verify();
+  }
+
   print_statistics();
   Universe::heap()->print_tracing_info();