< prev index next >
src/hotspot/share/memory/dynamicArchive.cpp
Print this page
@@ -27,16 +27,17 @@
#include "classfile/classLoaderData.inline.hpp"
#include "classfile/symbolTable.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/systemDictionaryShared.hpp"
#include "logging/log.hpp"
+#include "memory/archiveUtils.hpp"
+#include "memory/dynamicArchive.hpp"
#include "memory/metadataFactory.hpp"
#include "memory/metaspace.hpp"
#include "memory/metaspaceClosure.hpp"
#include "memory/metaspaceShared.hpp"
#include "memory/resourceArea.hpp"
-#include "memory/dynamicArchive.hpp"
#include "oops/compressedOops.hpp"
#include "oops/objArrayKlass.hpp"
#include "prims/jvmtiRedefineClasses.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/os.inline.hpp"
@@ -48,11 +49,10 @@
#ifndef O_BINARY // if defined (Win32) use binary files.
#define O_BINARY 0 // otherwise do nothing.
#endif
class DynamicArchiveBuilder : ResourceObj {
- CHeapBitMap _ptrmap;
static unsigned my_hash(const address& a) {
return primitive_hash<address>(a);
}
static bool my_equals(const address& a0, const address& a1) {
return primitive_equals<address>(a0, a1);
@@ -75,14 +75,11 @@
static const int _total_dump_regions = 3;
int _num_dump_regions_used;
public:
void mark_pointer(address* ptr_loc) {
- if (is_in_buffer_space(ptr_loc)) {
- size_t idx = pointer_delta(ptr_loc, _alloc_bottom, sizeof(address));
- _ptrmap.set_bit(idx);
- }
+ ArchivePtrMarker::mark_pointer(ptr_loc);
}
DumpRegion* current_dump_space() const {
return _current_dump_space;
}
@@ -126,10 +123,32 @@
template <typename T> bool has_new_loc(T obj) {
address* pp = _new_loc_table.get((address)obj);
return pp != NULL;
}
+ static intx _method_comparator_name_delta;
+
+ static int dynamic_dump_method_comparator(Method* a, Method* b) {
+ Symbol* a_name = a->name();
+ Symbol* b_name = b->name();
+
+ if (!MetaspaceShared::is_in_shared_metaspace(a_name)) {
+ // a_name points to a Symbol in the top archive.
+ // When this method is called, a_name is still pointing to the output space.
+ // Translate it to point to the output space, so that it can be compared with
+ // Symbols in the base archive.
+ a_name = (Symbol*)(address(a_name) + _method_comparator_name_delta);
+ //tty->print_cr("%p", a_name);
+ }
+ if (!MetaspaceShared::is_in_shared_metaspace(b_name)) {
+ b_name = (Symbol*)(address(b_name) + _method_comparator_name_delta);
+ //tty->print_cr("%p", b_name);
+ }
+
+ return a_name->fast_compare(b_name);
+ }
+
protected:
enum FollowMode {
make_a_copy, point_to_it, set_to_null
};
@@ -238,10 +257,20 @@
orig_ref->metaspace_pointers_do(&updater);
}
return true; // keep recursing until every object is visited exactly once.
}
+
+ virtual void push_special(SpecialRef type, Ref* ref, intptr_t* p) {
+ assert(type == _method_entry_ref, "only special type allowed for now");
+ address obj = ref->obj();
+ address new_obj = _builder->get_new_loc(ref);
+ size_t offset = pointer_delta(p, obj, sizeof(u1));
+ intptr_t* new_p = (intptr_t*)(new_obj + offset);
+ assert(*p == *new_p, "must be a copy");
+ ArchivePtrMarker::mark_pointer((address*)new_p);
+ }
};
class EmbeddedRefUpdater: public MetaspaceClosure {
DynamicArchiveBuilder* _builder;
address _orig_obj;
@@ -329,11 +358,11 @@
DynamicArchiveBuilder* _builder;
public:
EmbeddedRefMarker(DynamicArchiveBuilder* shuffler) : _builder(shuffler) {}
virtual bool do_ref(Ref* ref, bool read_only) {
- if (ref->not_null() && _builder->is_in_buffer_space(ref->obj())) {
+ if (ref->not_null()) {
_builder->mark_pointer(ref->addr());
}
return false; // Do not recurse.
}
};
@@ -439,14 +468,14 @@
address obj = ref->obj();
log_debug(cds, dynamic)("COPY: " PTR_FORMAT " ==> " PTR_FORMAT " %5d %s",
p2i(obj), p2i(p), bytes,
MetaspaceObj::type_name(ref->msotype()));
memcpy(p, obj, bytes);
-
intptr_t* cloned_vtable = MetaspaceShared::fix_cpp_vtable_for_dynamic_archive(ref->msotype(), p);
if (cloned_vtable != NULL) {
update_pointer((address*)p, (address)cloned_vtable, "vtb", 0, /*is_mso_pointer*/false);
+ mark_pointer((address*)p);
}
return (address)p;
}
@@ -549,10 +578,13 @@
// rw space starts ...
address reserved_bottom = reserve_space_and_init_buffer_to_target_delta();
init_header(reserved_bottom);
+ CHeapBitMap ptrmap;
+ ArchivePtrMarker::initialize(&ptrmap, (address*)reserved_bottom, (address*)current_dump_space()->top());
+
verify_estimate_size(sizeof(DynamicArchiveHeader), "header");
log_info(cds, dynamic)("Copying %d klasses and %d symbols",
_klasses->length(), _symbols->length());
@@ -574,14 +606,10 @@
ResourceMark rm;
ShallowCopier ro_copier(this, true);
iterate_roots(&ro_copier);
}
- size_t bitmap_size = pointer_delta(current_dump_space()->top(),
- _alloc_bottom, sizeof(address));
- _ptrmap.initialize(bitmap_size);
-
{
log_info(cds)("Relocating embedded pointers ... ");
ResourceMark rm;
ShallowCopyEmbeddedRefRelocator emb_reloc(this);
iterate_roots(&emb_reloc);
@@ -651,11 +679,11 @@
int num_symbols = _symbols->length();
for (i = 0; i < num_symbols; i++) {
it->push(&_symbols->at(i));
}
- _header->shared_path_table_metaspace_pointers_do(it);
+ FileMapInfo::metaspace_pointers_do(it);
// Do not call these again, as we have already collected all the classes and symbols
// that we want to archive. Also, these calls would corrupt the tables when
// ExternalRefUpdater is used.
//
@@ -664,10 +692,13 @@
it->finish();
}
};
+intx DynamicArchiveBuilder::_method_comparator_name_delta;
+
+
size_t DynamicArchiveBuilder::estimate_archive_size() {
// size of the symbol table and two dictionaries, plus the RunTimeSharedClassInfo's
_estimated_hashtable_bytes = 0;
_estimated_hashtable_bytes += SymbolTable::estimate_size_for_archive();
_estimated_hashtable_bytes += SystemDictionaryShared::estimate_size_for_archive();
@@ -686,30 +717,20 @@
return align_up(total, reserve_alignment());
}
address DynamicArchiveBuilder::reserve_space_and_init_buffer_to_target_delta() {
size_t total = estimate_archive_size();
- bool large_pages = false; // No large pages when dumping the CDS archive.
- size_t increment = align_up(1*G, reserve_alignment());
- char* addr = (char*)align_up(CompressedKlassPointers::base() + MetaspaceSize + increment,
- reserve_alignment());
-
- ReservedSpace* rs = MetaspaceShared::reserve_shared_rs(
- total, reserve_alignment(), large_pages, addr);
- while (!rs->is_reserved() && (addr + increment > addr)) {
- addr += increment;
- rs = MetaspaceShared::reserve_shared_rs(
- total, reserve_alignment(), large_pages, addr);
- }
- if (!rs->is_reserved()) {
+ ReservedSpace rs = MetaspaceShared::reserve_shared_space(total);
+ if (!rs.is_reserved()) {
log_error(cds, dynamic)("Failed to reserve %d bytes of output buffer.", (int)total);
vm_direct_exit(0);
}
- address buffer_base = (address)rs->base();
+ address buffer_base = (address)rs.base();
log_info(cds, dynamic)("Reserved output buffer space at : " PTR_FORMAT " [%d bytes]",
p2i(buffer_base), (int)total);
+ MetaspaceShared::set_shared_rs(rs);
// At run time, we will mmap the dynamic archive at target_space_bottom.
// However, at dump time, we may not be able to write into the target_space,
// as it's occupied by dynamically loaded Klasses. So we allocate a buffer
// at an arbitrary location chosen by the OS. We will write all the dynamically
@@ -786,10 +807,12 @@
}
void DynamicArchiveBuilder::make_klasses_shareable() {
int i, count = _klasses->length();
+ InstanceKlass::disable_method_binary_search();
+ _method_comparator_name_delta = _buffer_to_target_delta;
for (i = 0; i < count; i++) {
InstanceKlass* ik = _klasses->at(i);
sort_methods(ik);
}
@@ -845,22 +868,28 @@
for (int i = 0; i < len; i++) {
sort_methods(interfaces->at(i));
}
#ifdef ASSERT
- {
+ if (ik->methods() != NULL) {
for (int m = 0; m < ik->methods()->length(); m++) {
Symbol* name = ik->methods()->at(m)->name();
assert(MetaspaceShared::is_in_shared_metaspace(name) || is_in_buffer_space(name), "must be");
}
}
+ if (ik->default_methods() != NULL) {
+ for (int m = 0; m < ik->default_methods()->length(); m++) {
+ Symbol* name = ik->default_methods()->at(m)->name();
+ assert(MetaspaceShared::is_in_shared_metaspace(name) || is_in_buffer_space(name), "must be");
+ }
+ }
#endif
Thread* THREAD = Thread::current();
- Method::sort_methods(ik->methods());
+ Method::sort_methods(ik->methods(), /*set_idnums=*/true, dynamic_dump_method_comparator);
if (ik->default_methods() != NULL) {
- Method::sort_methods(ik->default_methods(), /*set_idnums=*/false);
+ Method::sort_methods(ik->default_methods(), /*set_idnums=*/false, dynamic_dump_method_comparator);
}
ik->vtable().initialize_vtable(true, THREAD); assert(!HAS_PENDING_EXCEPTION, "cannot fail");
ik->itable().initialize_itable(true, THREAD); assert(!HAS_PENDING_EXCEPTION, "cannot fail");
}
@@ -900,18 +929,54 @@
return true; // keep iterating
}
};
-
void DynamicArchiveBuilder::relocate_buffer_to_target() {
RelocateBufferToTarget patcher(this, (address*)_alloc_bottom, _buffer_to_target_delta);
- _ptrmap.iterate(&patcher);
+ ArchivePtrMarker::ptrmap()->iterate(&patcher);
- Array<u8>* table = _header->shared_path_table().table();
- table = to_target(table);
- _header->relocate_shared_path_table(table);
+ Array<u8>* table = FileMapInfo::shared_path_table().table();
+ SharedPathTable runtime_table(to_target(table), FileMapInfo::shared_path_table().size());
+ _header->set_shared_path_table(runtime_table);
+
+ address relocatable_base = (address)SharedBaseAddress;
+ address relocatable_end = (address)(current_dump_space()->top()) + _buffer_to_target_delta;
+
+ ArchivePtrMarker::compact(relocatable_base, relocatable_end);
+
+ intx addr_delta = MetaspaceShared::final_delta();
+ if (addr_delta != 0) {
+ // Patch all pointers that are marked by ptrmap within this region,
+ // where we have just dumped all the metaspace data.
+ address patch_base = (address)_alloc_bottom;
+ address patch_end = (address)current_dump_space()->top();
+
+ // debug only -- the current value of the pointers to be patched must be within this
+ // range (i.e., must point to either the top archive (as currently mapped), or to the
+ // (targeted address of) the top archive)
+ address valid_old_base = relocatable_base;
+ address valid_old_end = relocatable_end;
+ size_t base_plus_top_size = valid_old_end - valid_old_base;
+ size_t top_size = patch_end - patch_base;
+ size_t base_size = base_plus_top_size - top_size;
+ assert(base_plus_top_size > base_size, "no overflow");
+ assert(base_plus_top_size > top_size, "no overflow");
+
+ // debug only -- after patching, the pointers must point inside this range
+ // (the requested location of the archive, as mapped at runtime).
+ address valid_new_base = (address)Arguments::default_SharedBaseAddress();
+ address valid_new_end = valid_new_base + base_plus_top_size;
+
+ log_debug(cds)("Relocating archive from [" INTPTR_FORMAT " - " INTPTR_FORMAT "] to "
+ "[" INTPTR_FORMAT " - " INTPTR_FORMAT "], delta = " INTX_FORMAT " bytes", p2i(patch_base + base_size), p2i(patch_end),
+ p2i(valid_new_base + base_size), p2i(valid_new_end), addr_delta);
+
+ SharedDataRelocator patcher((address*)patch_base, (address*)patch_end, valid_old_base, valid_old_end,
+ valid_new_base, valid_new_end, addr_delta);
+ ArchivePtrMarker::ptrmap()->iterate(&patcher);
+ }
}
void DynamicArchiveBuilder::write_regions(FileMapInfo* dynamic_info) {
dynamic_info->write_region(MetaspaceShared::rw,
MetaspaceShared::read_write_dump_space()->base(),
@@ -923,10 +988,11 @@
/*read_only=*/true, /*allow_exec=*/false);
dynamic_info->write_region(MetaspaceShared::mc,
MetaspaceShared::misc_code_dump_space()->base(),
MetaspaceShared::misc_code_dump_space()->used(),
/*read_only=*/false,/*allow_exec=*/true);
+ dynamic_info->write_bitmap_region(ArchivePtrMarker::ptrmap());
}
void DynamicArchiveBuilder::write_archive(char* serialized_data_start) {
int num_klasses = _klasses->length();
int num_symbols = _symbols->length();
@@ -938,18 +1004,21 @@
// Now write the archived data including the file offsets.
const char* archive_name = Arguments::GetSharedDynamicArchivePath();
dynamic_info->open_for_write(archive_name);
write_regions(dynamic_info);
+ dynamic_info->set_final_requested_base((char*)Arguments::default_SharedBaseAddress());
dynamic_info->set_header_crc(dynamic_info->compute_header_crc());
dynamic_info->write_header();
dynamic_info->close();
address base = to_target(_alloc_bottom);
address top = address(current_dump_space()->top()) + _buffer_to_target_delta;
size_t file_size = pointer_delta(top, base, sizeof(char));
+ base += MetaspaceShared::final_delta();
+ top += MetaspaceShared::final_delta();
log_info(cds, dynamic)("Written dynamic archive " PTR_FORMAT " - " PTR_FORMAT
" [" SIZE_FORMAT " bytes header, " SIZE_FORMAT " bytes total]",
p2i(base), p2i(top), _header->header_size(), file_size);
log_info(cds, dynamic)("%d klasses; %d symbols", num_klasses, num_symbols);
}
@@ -1034,83 +1103,12 @@
assert(DynamicDumpSharedSpaces, "must be");
return _builder->is_in_target_space(obj);
}
-static DynamicArchiveHeader *_dynamic_header = NULL;
DynamicArchiveBuilder* DynamicArchive::_builder = NULL;
-void DynamicArchive::map_failed(FileMapInfo* mapinfo) {
- if (mapinfo->dynamic_header() != NULL) {
- os::free((void*)mapinfo->dynamic_header());
- }
- delete mapinfo;
-}
-
-// Returns the top of the mapped address space
-address DynamicArchive::map() {
- assert(UseSharedSpaces, "Sanity");
-
- // Create the dynamic archive map info
- FileMapInfo* mapinfo;
- const char* filename = Arguments::GetSharedDynamicArchivePath();
- struct stat st;
- address result;
- if ((filename != NULL) && (os::stat(filename, &st) == 0)) {
- mapinfo = new FileMapInfo(false);
- if (!mapinfo->open_for_read(filename)) {
- result = NULL;
- }
- result = map_impl(mapinfo);
- if (result == NULL) {
- map_failed(mapinfo);
- mapinfo->restore_shared_path_table();
- }
- } else {
- if (filename != NULL) {
- log_warning(cds, dynamic)("specified dynamic archive doesn't exist: %s", filename);
- }
- result = NULL;
- }
- return result;
-}
-
-address DynamicArchive::map_impl(FileMapInfo* mapinfo) {
- // Read header
- if (!mapinfo->initialize(false)) {
- return NULL;
- }
-
- _dynamic_header = mapinfo->dynamic_header();
- int regions[] = {MetaspaceShared::rw,
- MetaspaceShared::ro,
- MetaspaceShared::mc};
-
- size_t len = sizeof(regions)/sizeof(int);
- char* saved_base[] = {NULL, NULL, NULL};
- char* top = mapinfo->map_regions(regions, saved_base, len);
- if (top == NULL) {
- mapinfo->unmap_regions(regions, saved_base, len);
- FileMapInfo::fail_continue("Unable to use dynamic archive. Failed map_region for using -Xshare:on.");
- return NULL;
- }
-
- if (!validate(mapinfo)) {
- return NULL;
- }
-
- if (_dynamic_header == NULL) {
- return NULL;
- }
-
- intptr_t* buffer = (intptr_t*)_dynamic_header->serialized_data_start();
- ReadClosure rc(&buffer);
- SymbolTable::serialize_shared_table_header(&rc, false);
- SystemDictionaryShared::serialize_dictionary_headers(&rc, false);
-
- return (address)top;
-}
bool DynamicArchive::validate(FileMapInfo* dynamic_info) {
// Check if the recorded base archive matches with the current one
FileMapInfo* base_info = FileMapInfo::current_info();
DynamicArchiveHeader* dynamic_header = dynamic_info->dynamic_header();
@@ -1134,13 +1132,5 @@
if (!dynamic_info->validate_shared_path_table()) {
return false;
}
return true;
}
-
-bool DynamicArchive::is_mapped() {
- return (_dynamic_header != NULL);
-}
-
-void DynamicArchive::disable() {
- _dynamic_header = NULL;
-}
< prev index next >