< prev index next > src/hotspot/share/oops/trainingData.cpp
Print this page
#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"
// 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);
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);
- }
+ 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)) {
_dumptime_training_data_dictionary->append(td);
}
});
}
+ RecompilationSchedule::prepare(CHECK);
+
if (AOTVerifyTrainingData) {
TrainingData::verify();
}
}
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;
}
j++;
}
_dumptime_training_data_dictionary->trunc_to(j);
}
+ RecompilationSchedule::cleanup();
}
void KlassTrainingData::cleanup(Visitor& visitor) {
if (visitor.is_visited(this)) {
return;
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;
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));
}
< prev index next >