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 +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.
-   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);
-         }
-       }
+   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));
  }