src/hotspot/share/oops/trainingData.cpp

*** 33,12 ***
--- 33,14 ---
  #include "classfile/systemDictionaryShared.hpp"
  #include "compiler/compileTask.hpp"
  #include "memory/metadataFactory.hpp"
  #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 ***
--- 73,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);

*** 218,12 ***
        if (last_ctd->compile_id() < compile_id) {
          last_ctd->clear_init_deps();
          last_ctd = ctd;
        }
      } else {
!        last_ctd = ctd;
!        mtd->notice_toplevel_compilation(level);
      }
    }
    return ctd;
  }
  
--- 221,12 ---
        if (last_ctd->compile_id() < compile_id) {
          last_ctd->clear_init_deps();
          last_ctd = ctd;
        }
      } else {
!       last_ctd = ctd;
!       mtd->notice_toplevel_compilation(level);
      }
    }
    return ctd;
  }
  

*** 430,28 ***
      }
    }
  }
  
  KlassTrainingData::KlassTrainingData(InstanceKlass* klass) : TrainingData(klass) {
!   if (holder() == klass) {
!     return;   // no change to make
!   }
! 
!   jobject hmj = _holder_mirror;
-   if (hmj != nullptr) {   // clear out previous handle, if any
-     _holder_mirror = nullptr;
-     assert(JNIHandles::is_global_handle(hmj), "");
-     JNIHandles::destroy_global(hmj);
-   }
- 
-   if (klass != nullptr) {
-     Handle hm(JavaThread::current(), klass->java_mirror());
-     hmj = JNIHandles::make_global(hm);
-     Atomic::release_store(&_holder_mirror, hmj);
-   }
- 
-   Atomic::release_store(&_holder, const_cast<InstanceKlass*>(klass));
    assert(holder() == klass, "");
  }
  
  void KlassTrainingData::notice_fully_initialized() {
    ResourceMark rm;
--- 433,15 ---
      }
    }
  }
  
  KlassTrainingData::KlassTrainingData(InstanceKlass* klass) : TrainingData(klass) {
!   assert(klass != nullptr, "");
!   // The OopHandle constructor will allocate a handle. We don't need to ever release it so we don't preserve
!   // the handle object.
!   OopHandle handle(Universe::vm_global(), klass->java_mirror());
!   _holder = klass;
    assert(holder() == klass, "");
  }
  
  void KlassTrainingData::notice_fully_initialized() {
    ResourceMark rm;

*** 491,18 ***
--- 481,21 ---
  
      if (AOTVerifyTrainingData) {
        training_data_set()->verify();
      }
    }
+ 
+   RecompilationSchedule::prepare(CHECK);
  }
  
  void TrainingData::iterate_roots(MetaspaceClosure* it) {
    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;

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

*** 650,10 ***
--- 644,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;

*** 689,10 ***
--- 684,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));
  }

*** 770,11 ***
    }
  }
  
  void KlassTrainingData::remove_unshareable_info() {
    TrainingData::remove_unshareable_info();
-   _holder_mirror = nullptr;
    _comp_deps.remove_unshareable_info();
  }
  
  void MethodTrainingData::remove_unshareable_info() {
    TrainingData::remove_unshareable_info();
--- 766,10 ---