src/hotspot/share/oops/trainingData.cpp

*** 34,10 ***
--- 34,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"

*** 70,10 ***
--- 71,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);

*** 306,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();
!   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;
!         if (l.can_add()) {
!           add_init_dep(ktd);
!         }
-       }
      }
    }
  }
  
  void KlassTrainingData::prepare(Visitor& visitor) {
--- 308,31 ---
  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()) {
!     ciInstanceKlass* cik = md->as_instance_klass();
!     if (!cik->is_initialized()) {
!       return;
!     }
!     KlassTrainingData* ktd = KlassTrainingData::make(cik->get_instanceKlass());
!     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;
!     if (l.can_add()) {
!       add_init_dep(ktd);
      }
    }
  }
  
  void KlassTrainingData::prepare(Visitor& visitor) {

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

*** 490,10 ***
--- 493,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;

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

*** 649,10 ***
--- 654,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;

*** 688,10 ***
--- 694,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));
  }