src/hotspot/share/oops/trainingData.cpp

*** 35,10 ***
--- 35,11 ---
  #include "memory/metaspaceClosure.hpp"
  #include "memory/resourceArea.hpp"
  #include "memory/universe.hpp"
  #include "oops/method.hpp"
  #include "oops/methodCounters.hpp"
+ #include "oops/recompilationSchedule.hpp"
  #include "oops/trainingData.hpp"
  #include "runtime/arguments.hpp"
  #include "runtime/javaThread.inline.hpp"
  #include "runtime/jniHandles.inline.hpp"
  #include "utilities/growableArray.hpp"

*** 71,10 ***
--- 72,11 ---
      // Data structures that we have do not currently support iterative training. So you cannot replay
      // and train at the same time. Going forward we may want to adjust iteration/search to enable that.
      guarantee(have_data() != need_data(), "Iterative training is not supported");
      TrainingDataLocker::initialize();
    }
+   RecompilationSchedule::initialize();
  }
  
  static void verify_archived_entry(TrainingData* td, const TrainingData::Key* k) {
    guarantee(TrainingData::Key::can_compute_cds_hash(k), "");
    TrainingData* td1 = TrainingData::lookup_archived_training_data(k);

*** 307,32 ***
  void CompileTrainingData::notice_jit_observation(ciEnv* env, ciBaseObject* what) {
    // A JIT is starting to look at class k.
    // We could follow the queries that it is making, but it is
    // simpler to assume, conservatively, that the JIT will
    // eventually depend on the initialization state of k.
!   CompileTask* task = env->task();
!   assert(task != nullptr, "");
!   Method* method = task->method();
!   InstanceKlass* compiling_klass = method->method_holder();
!   if (what->is_metadata()) {
!     ciMetadata* md = what->as_metadata();
!     if (md->is_loaded() && md->is_instance_klass()) {
!       ciInstanceKlass* cik = md->as_instance_klass();
! 
!       if (cik->is_initialized()) {
!         InstanceKlass* ik = md->as_instance_klass()->get_instanceKlass();
!         KlassTrainingData* ktd = KlassTrainingData::make(ik);
-         if (ktd == nullptr) {
-           // Allocation failure or snapshot in progress
-           return;
-         }
-         // This JIT task is (probably) requesting that ik be initialized,
-         // so add him to my _init_deps list.
-         TrainingDataLocker l;
-         add_init_dep(ktd);
-       }
      }
    }
  }
  
  void KlassTrainingData::prepare(Visitor& visitor) {
    if (visitor.is_visited(this)) {
--- 309,27 ---
  void CompileTrainingData::notice_jit_observation(ciEnv* env, ciBaseObject* what) {
    // A JIT is starting to look at class k.
    // We could follow the queries that it is making, but it is
    // simpler to assume, conservatively, that the JIT will
    // eventually depend on the initialization state of k.
!   ciMetadata* md = nullptr;
!   if (what->is_object()) {
!     md = what->as_object()->klass();
!   } else if (what->is_metadata()) {
!     md = what->as_metadata();
!   }
!   if (md != nullptr && md->is_loaded() && md->is_instance_klass()) {
!     InstanceKlass* ik = md->as_instance_klass()->get_instanceKlass();
!     KlassTrainingData* ktd = KlassTrainingData::make(ik);
!     if (ktd == nullptr) {
!       // Allocation failure or snapshot in progress
!       return;
      }
+     // This JIT task is (probably) requesting that ik be initialized,
+     // so add it to my _init_deps list.
+     TrainingDataLocker l;
+     add_init_dep(ktd);
    }
  }
  
  void KlassTrainingData::prepare(Visitor& visitor) {
    if (visitor.is_visited(this)) {

*** 487,10 ***
--- 484,12 ---
          _dumptime_training_data_dictionary->append(td);
        }
      });
    }
  
+   RecompilationSchedule::prepare(CHECK);
+ 
    if (AOTVerifyTrainingData) {
      TrainingData::verify();
    }
  }
  

*** 498,10 ***
--- 497,11 ---
    if (_dumptime_training_data_dictionary != nullptr) {
      for (int i = 0; i < _dumptime_training_data_dictionary->length(); i++) {
        _dumptime_training_data_dictionary->at(i).metaspace_pointers_do(it);
      }
    }
+   RecompilationSchedule::iterate_roots(it);
  }
  
  void TrainingData::dump_training_data() {
    if (_dumptime_training_data_dictionary != nullptr) {
      CompactHashtableStats stats;

*** 544,10 ***
--- 544,11 ---
        }
        j++;
      }
      _dumptime_training_data_dictionary->trunc_to(j);
    }
+   RecompilationSchedule::cleanup();
  }
  
  void KlassTrainingData::cleanup(Visitor& visitor) {
    if (visitor.is_visited(this)) {
      return;

*** 657,10 ***
--- 658,11 ---
    if (soc->writing()) {
      _archived_training_data_dictionary_for_dumping.serialize_header(soc);
    } else {
      _archived_training_data_dictionary.serialize_header(soc);
    }
+   RecompilationSchedule::serialize(soc);
  }
  
  class TrainingDataPrinter : StackObj {
    outputStream* _st;
    int _index;

*** 696,10 ***
--- 698,11 ---
  void TrainingData::print_archived_training_data_on(outputStream* st) {
    st->print_cr("Archived TrainingData Dictionary");
    TrainingDataPrinter tdp(st);
    TrainingDataLocker::initialize();
    _archived_training_data_dictionary.iterate(&tdp);
+   RecompilationSchedule::print_archived_training_data_on(st);
  }
  
  void TrainingData::Key::metaspace_pointers_do(MetaspaceClosure *iter) {
    iter->push(const_cast<Metadata**>(&_meta));
  }