< prev index next > src/hotspot/share/cds/aotMetaspace.cpp
Print this page
* questions.
*
*/
#include "cds/aotArtifactFinder.hpp"
+ #include "cds/aotCacheAccess.hpp"
#include "cds/aotClassInitializer.hpp"
#include "cds/aotClassLinker.hpp"
#include "cds/aotClassLocation.hpp"
#include "cds/aotConstantPoolResolver.hpp"
#include "cds/aotLinkedClassBulkLoader.hpp"
#include "classfile/systemDictionaryShared.hpp"
#include "classfile/vmClasses.hpp"
#include "classfile/vmSymbols.hpp"
#include "code/aotCodeCache.hpp"
#include "code/codeCache.hpp"
+ #include "compiler/compileBroker.hpp"
+ #include "compiler/precompiler.hpp"
#include "gc/shared/gcVMOperations.hpp"
#include "interpreter/bytecodes.hpp"
#include "interpreter/bytecodeStream.hpp"
#include "jvm_io.h"
#include "logging/log.hpp"
#include "nmt/memTracker.hpp"
#include "oops/compressedKlass.hpp"
#include "oops/constantPool.inline.hpp"
#include "oops/instanceMirrorKlass.hpp"
#include "oops/klass.inline.hpp"
+ #include "oops/method.inline.hpp"
#include "oops/objArrayOop.hpp"
#include "oops/oop.inline.hpp"
#include "oops/oopHandle.hpp"
#include "oops/resolvedFieldEntry.hpp"
#include "oops/trainingData.hpp"
#include "prims/jvmtiExport.hpp"
+ #include "prims/whitebox.hpp"
#include "runtime/arguments.hpp"
#include "runtime/globals.hpp"
#include "runtime/globals_extension.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/javaCalls.hpp"
OopHandle mirror = mirrors->at(i);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror.resolve());
if (may_be_eagerly_linked(ik)) {
has_linked |= try_link_class(current, ik);
}
+ if (CDSConfig::is_dumping_heap() && ik->is_linked() && !ik->is_initialized()) {
+ AOTClassInitializer::maybe_preinit_class(ik, current);
+ }
}
if (!has_linked) {
break;
}
const GrowableArray<OopHandle>* mirrors = collect_classes.mirrors();
for (int i = 0; i < mirrors->length(); i++) {
OopHandle mirror = mirrors->at(i);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror.resolve());
AOTConstantPoolResolver::preresolve_string_cp_entries(ik, CHECK);
}
}
}
void AOTMetaspace::dump_static_archive(TRAPS) {
CDSConfig::DumperThreadMark dumper_thread_mark(THREAD);
ResourceMark rm(THREAD);
HandleMark hm(THREAD);
! if (CDSConfig::is_dumping_final_static_archive() && AOTPrintTrainingInfo) {
! tty->print_cr("==================== archived_training_data ** before dumping ====================");
! TrainingData::print_archived_training_data_on(tty);
! }
StaticArchiveBuilder builder;
dump_static_archive_impl(builder, THREAD);
if (HAS_PENDING_EXCEPTION) {
if (PENDING_EXCEPTION->is_a(vmClasses::OutOfMemoryError_klass())) {
const GrowableArray<OopHandle>* mirrors = collect_classes.mirrors();
for (int i = 0; i < mirrors->length(); i++) {
OopHandle mirror = mirrors->at(i);
InstanceKlass* ik = java_lang_Class::as_InstanceKlass(mirror.resolve());
AOTConstantPoolResolver::preresolve_string_cp_entries(ik, CHECK);
+ if (CDSConfig::is_dumping_preimage_static_archive()) {
+ FinalImageRecipes::add_reflection_data_flags(ik, CHECK);
+ }
}
}
}
void AOTMetaspace::dump_static_archive(TRAPS) {
CDSConfig::DumperThreadMark dumper_thread_mark(THREAD);
ResourceMark rm(THREAD);
HandleMark hm(THREAD);
! if (CDSConfig::is_dumping_final_static_archive() && AOTPrintTrainingInfo) {
! tty->print_cr("==================== archived_training_data ** before dumping ====================");
! TrainingData::print_archived_training_data_on(tty);
! }
StaticArchiveBuilder builder;
dump_static_archive_impl(builder, THREAD);
if (HAS_PENDING_EXCEPTION) {
if (PENDING_EXCEPTION->is_a(vmClasses::OutOfMemoryError_klass())) {
ClassLoaderDataShared::ensure_module_entry_tables_exist();
ClassLoaderDataShared::build_tables(CHECK);
HeapShared::reset_archived_object_states(CHECK);
}
+ if (ArchiveLoaderLookupCache) {
+ SystemDictionaryShared::create_loader_positive_lookup_cache(CHECK);
+ }
+
AOTReferenceObjSupport::initialize(CHECK);
AOTReferenceObjSupport::stabilize_cached_reference_objects(CHECK);
if (CDSConfig::is_dumping_aot_linked_classes()) {
// java.lang.Class::reflectionFactory cannot be archived yet. We set this field
}
VM_PopulateDumpSharedSpace op(builder, _output_mapinfo);
VMThread::execute(&op);
! if (AOTCodeCache::is_on_for_dump() && CDSConfig::is_dumping_final_static_archive()) {
! CDSConfig::enable_dumping_aot_code();
! {
! builder.start_ac_region();
! // Write the contents to AOT code region and close AOTCodeCache before packing the region
! AOTCodeCache::close();
! builder.end_ac_region();
}
- CDSConfig::disable_dumping_aot_code();
}
bool status = write_static_archive(&builder, _output_mapinfo, op.mapped_heap_info(), op.streamed_heap_info());
assert(!_output_mapinfo->is_open(), "Must be closed already");
_output_mapinfo = nullptr;
}
VM_PopulateDumpSharedSpace op(builder, _output_mapinfo);
VMThread::execute(&op);
! if (CDSConfig::is_dumping_final_static_archive()) {
! if (AOTCodeCache::is_caching_enabled()) {
! // We have just created the final image. Let's run the AOT compiler
! if (AOTPrintTrainingInfo) {
! tty->print_cr("==================== archived_training_data ** after dumping ====================");
! TrainingData::print_archived_training_data_on(tty);
! }
+
+ {
+ builder.start_ac_region();
+ if (AOTCodeCache::is_dumping_code()) {
+ CDSConfig::enable_dumping_aot_code();
+ log_info(aot)("Compiling AOT code");
+ Precompiler::compile_aot_code(&builder, CHECK);
+ log_info(aot)("Finished compiling AOT code");
+ CDSConfig::disable_dumping_aot_code();
+ }
+ // Write the contents to aot code region and close AOTCodeCache before packing the region
+ AOTCodeCache::close();
+ log_info(aot)("Dumped AOT code Cache");
+ builder.end_ac_region();
+ }
}
}
bool status = write_static_archive(&builder, _output_mapinfo, op.mapped_heap_info(), op.streamed_heap_info());
assert(!_output_mapinfo->is_open(), "Must be closed already");
_output_mapinfo = nullptr;
}
void VM_PopulateDumpSharedSpace::dump_java_heap_objects() {
if (CDSConfig::is_dumping_heap()) {
HeapShared::write_heap(&_mapped_heap_info, &_streamed_heap_info);
! } else {
CDSConfig::log_reasons_for_not_dumping_heap();
}
}
void AOTMetaspace::set_aot_metaspace_range(void* base, void *static_top, void* top) {
}
void VM_PopulateDumpSharedSpace::dump_java_heap_objects() {
if (CDSConfig::is_dumping_heap()) {
HeapShared::write_heap(&_mapped_heap_info, &_streamed_heap_info);
! } else if (!CDSConfig::is_dumping_preimage_static_archive()) {
CDSConfig::log_reasons_for_not_dumping_heap();
}
}
void AOTMetaspace::set_aot_metaspace_range(void* base, void *static_top, void* top) {
void AOTMetaspace::initialize_runtime_shared_and_meta_spaces() {
assert(CDSConfig::is_using_archive(), "Must be called when UseSharedSpaces is enabled");
MapArchiveResult result = MAP_ARCHIVE_OTHER_FAILURE;
! FileMapInfo* static_mapinfo = open_static_archive();
FileMapInfo* dynamic_mapinfo = nullptr;
if (static_mapinfo != nullptr) {
aot_log_info(aot)("Core region alignment: %zu", static_mapinfo->core_region_alignment());
dynamic_mapinfo = open_dynamic_archive();
void AOTMetaspace::initialize_runtime_shared_and_meta_spaces() {
assert(CDSConfig::is_using_archive(), "Must be called when UseSharedSpaces is enabled");
MapArchiveResult result = MAP_ARCHIVE_OTHER_FAILURE;
! FileMapInfo* static_mapinfo = FileMapInfo::current_info();
FileMapInfo* dynamic_mapinfo = nullptr;
if (static_mapinfo != nullptr) {
aot_log_info(aot)("Core region alignment: %zu", static_mapinfo->core_region_alignment());
dynamic_mapinfo = open_dynamic_archive();
if (dynamic_mapinfo != nullptr && !dynamic_mapinfo->is_mapped()) {
has_failed = true;
delete dynamic_mapinfo;
}
if (RequireSharedSpaces && has_failed) {
AOTMetaspace::unrecoverable_loading_error("Unable to map shared spaces");
}
}
! FileMapInfo* AOTMetaspace::open_static_archive() {
const char* static_archive = CDSConfig::input_static_archive_path();
assert(static_archive != nullptr, "sanity");
FileMapInfo* mapinfo = new FileMapInfo(static_archive, true);
if (!mapinfo->open_as_input()) {
delete(mapinfo);
log_info(cds)("Opening of static archive %s failed", static_archive);
! return nullptr;
}
- return mapinfo;
}
FileMapInfo* AOTMetaspace::open_dynamic_archive() {
if (CDSConfig::is_dumping_dynamic_archive()) {
return nullptr;
if (dynamic_mapinfo != nullptr && !dynamic_mapinfo->is_mapped()) {
has_failed = true;
delete dynamic_mapinfo;
}
if (RequireSharedSpaces && has_failed) {
+ // static archive mapped but dynamic archive failed
AOTMetaspace::unrecoverable_loading_error("Unable to map shared spaces");
}
}
! // This is called very early at VM start up to get the size of the cached_code region
+ void AOTMetaspace::open_static_archive() {
+ if (!UseSharedSpaces) { // FIXME -- is this still needed??
+ return;
+ }
const char* static_archive = CDSConfig::input_static_archive_path();
assert(static_archive != nullptr, "sanity");
FileMapInfo* mapinfo = new FileMapInfo(static_archive, true);
if (!mapinfo->open_as_input()) {
delete(mapinfo);
log_info(cds)("Opening of static archive %s failed", static_archive);
! } else {
+ FileMapRegion* r = mapinfo->region_at(AOTMetaspace::ac);
+ AOTCacheAccess::set_aot_code_region_size(r->used_aligned());
}
}
FileMapInfo* AOTMetaspace::open_dynamic_archive() {
if (CDSConfig::is_dumping_dynamic_archive()) {
return nullptr;
assert(CDSConfig::is_using_archive(), "must be runtime");
if (mapinfo == nullptr) {
return MAP_ARCHIVE_SUCCESS; // The dynamic archive has not been specified. No error has happened -- trivially succeeded.
}
+ if (!mapinfo->validate_aot_class_linking()) {
+ return MAP_ARCHIVE_OTHER_FAILURE;
+ }
+
mapinfo->set_is_mapped(false);
if (mapinfo->core_region_alignment() != (size_t)core_region_alignment()) {
report_loading_error("Unable to map CDS archive -- core_region_alignment() expected: %zu"
" actual: %zu", mapinfo->core_region_alignment(), core_region_alignment());
return MAP_ARCHIVE_OTHER_FAILURE;
< prev index next >