src/hotspot/share/oops/trainingData.cpp

*** 35,10 ***
--- 35,11 ---
  #include "memory/metadataFactory.hpp"
  #include "memory/metaspaceClosure.hpp"
  #include "memory/resourceArea.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);

*** 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;
  }
  
--- 220,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;
  }
  

*** 491,18 ***
--- 493,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 ***
--- 550,11 ---
        }
        j++;
      }
      _dumptime_training_data_dictionary->trunc_to(j);
    }
+   RecompilationSchedule::cleanup();
  }
  
  void KlassTrainingData::cleanup(Visitor& visitor) {
    if (visitor.is_visited(this)) {
      return;

*** 650,10 ***
--- 656,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 ***
--- 696,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));
  }