jdk-sandbox: comparison src/hotspot/share/memory/dynamicArchive.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 void make_trampolines();
 void make_klasses_shareable();
 void sort_methods(InstanceKlass* ik) const;
 void set_symbols_permanent();
 void relocate_buffer_to_target();
-void write_archive(char* read_only_tables_start);
+void write_archive(char* serialized_data_start);
+void write_regions(FileMapInfo* dynamic_info);
 void init_first_dump_space(address reserved_bottom) {
 address first_space_base = reserved_bottom;
 DumpRegion* rw_space = MetaspaceShared::read_write_dump_space();
 MetaspaceShared::init_shared_dump_space(rw_space, first_space_base);
 iterate_roots(&ext_reloc);
 }
 verify_estimate_size(_estimated_metsapceobj_bytes, "MetaspaceObjs");
-char* read_only_tables_start;
+char* serialized_data_start;
 {
 set_symbols_permanent();
 // Write the symbol table and system dictionaries to the RO space.
 // Note that these tables still point to the *original* objects
 // get the correct addresses.
 assert(current_dump_space() == ro_space, "Must be RO space");
 SymbolTable::write_to_archive(false);
 SystemDictionaryShared::write_to_archive(false);
-read_only_tables_start = ro_space->top();
+serialized_data_start = ro_space->top();
 WriteClosure wc(ro_space);
 SymbolTable::serialize_shared_table_header(&wc, false);
 SystemDictionaryShared::serialize_dictionary_headers(&wc, false);
 }
 PointerMarker marker(this);
 iterate_roots(&marker);
 relocate_buffer_to_target();
 }
-write_archive(read_only_tables_start);
+write_archive(serialized_data_start);
 assert(_num_dump_regions_used == _total_dump_regions, "must be");
 verify_universe("After CDS dynamic dump");
 }
 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);
+_header->shared_path_table_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.
 //
 _other_region_used_bytes = 0;
 init_first_dump_space(reserved_bottom);
 FileMapInfo* mapinfo = new FileMapInfo(false);
-_header = (DynamicArchiveHeader*)mapinfo->_header;
+_header = mapinfo->dynamic_header();
 Thread* THREAD = Thread::current();
 FileMapInfo* base_info = FileMapInfo::current_info();
-int* crc = _header->_base_archive_crc;
+_header->set_base_header_crc(base_info->crc());
-*crc++ = base_info->crc(); // base archive header crc
 for (int i = 0; i < MetaspaceShared::n_regions; i++) {
-*crc++ = base_info->space_crc(i);
+_header->set_base_region_crc(i, base_info->space_crc(i));
 }
 _header->populate(base_info, os::vm_allocation_granularity());
 }
 size_t DynamicArchiveBuilder::estimate_trampoline_size() {
 for (int i = 0; i < _klasses->length(); i++) {
 InstanceKlass* ik = _klasses->at(i);
 Array<Method*>* methods = ik->methods();
 total += each_method_bytes * methods->length();
+}
+if (total == 0) {
+// We have nothing to archive, but let's avoid having an empty region.
+total = SharedRuntime::trampoline_size();
 }
 return total;
 }
 void DynamicArchiveBuilder::make_trampolines() {
 (AdapterHandlerEntry**)MetaspaceShared::misc_code_space_alloc(sizeof(AdapterHandlerEntry*));
 *adapter_trampoline = NULL;
 m->set_adapter_trampoline(to_target(adapter_trampoline));
 }
 }
+if (MetaspaceShared::misc_code_dump_space()->used() == 0) {
+// We have nothing to archive, but let's avoid having an empty region.
+MetaspaceShared::misc_code_space_alloc(SharedRuntime::trampoline_size());
+}
 }
 void DynamicArchiveBuilder::make_klasses_shareable() {
 int i, count = _klasses->length();
 void DynamicArchiveBuilder::relocate_buffer_to_target() {
 RelocateBufferToTarget patcher(this, (address*)_alloc_bottom, _buffer_to_target_delta);
 _ptrmap.iterate(&patcher);
-Array<u8>* table = _header->_shared_path_table.table();
+Array<u8>* table = _header->shared_path_table().table();
 table = to_target(table);
-_header->_shared_path_table.set_table(table);
+_header->relocate_shared_path_table(table);
 }
-static void write_archive_info(FileMapInfo* dynamic_info, DynamicArchiveHeader *header) {
+void DynamicArchiveBuilder::write_regions(FileMapInfo* dynamic_info) {
-dynamic_info->write_header();
-dynamic_info->align_file_position();
 dynamic_info->write_region(MetaspaceShared::rw,
 MetaspaceShared::read_write_dump_space()->base(),
 MetaspaceShared::read_write_dump_space()->used(),
 /*read_only=*/false,/*allow_exec=*/false);
 dynamic_info->write_region(MetaspaceShared::ro,
 MetaspaceShared::misc_code_dump_space()->base(),
 MetaspaceShared::misc_code_dump_space()->used(),
 /*read_only=*/false,/*allow_exec=*/true);
 }
-void DynamicArchiveBuilder::write_archive(char* read_only_tables_start) {
+void DynamicArchiveBuilder::write_archive(char* serialized_data_start) {
 int num_klasses = _klasses->length();
 int num_symbols = _symbols->length();
-_header->_read_only_tables_start = to_target(read_only_tables_start);
+_header->set_serialized_data_start(to_target(serialized_data_start));
 FileMapInfo* dynamic_info = FileMapInfo::dynamic_info();
 assert(dynamic_info != NULL, "Sanity");
-// Populate the file offsets, region crcs, etc. No data is written out.
-write_archive_info(dynamic_info, _header);
-// the header will no longer change. Compute its crc.
-dynamic_info->set_header_crc(dynamic_info->compute_header_crc());
 // Now write the archived data including the file offsets.
 const char* archive_name = Arguments::GetSharedDynamicArchivePath();
 dynamic_info->open_for_write(archive_name);
-write_archive_info(dynamic_info, _header);
+write_regions(dynamic_info);
+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;
-int file_size = int(top - base);
+size_t file_size = pointer_delta(top, base, sizeof(char));
-log_info(cds, dynamic)("Written dynamic archive " PTR_FORMAT " - " PTR_FORMAT " [%d bytes header, %d bytes total]",
+log_info(cds, dynamic)("Written dynamic archive " PTR_FORMAT " - " PTR_FORMAT
-p2i(base), p2i(top), (int)_header->_header_size, file_size);
+" [" 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);
 }
 class VM_PopulateDynamicDumpSharedSpace: public VM_Operation {
 static DynamicArchiveHeader *_dynamic_header = NULL;
 DynamicArchiveBuilder* DynamicArchive::_builder = NULL;
 void DynamicArchive::map_failed(FileMapInfo* mapinfo) {
-if (mapinfo->_header != NULL) {
+if (mapinfo->dynamic_header() != NULL) {
-os::free(mapinfo->_header);
+os::free((void*)mapinfo->dynamic_header());
 }
 delete mapinfo;
 }
 // Returns the top of the mapped address space
 }
 return result;
 }
 address DynamicArchive::map_impl(FileMapInfo* mapinfo) {
 // Read header
 if (!mapinfo->initialize(false)) {
 return NULL;
 }
-_dynamic_header = (DynamicArchiveHeader*)mapinfo->header();
+_dynamic_header = mapinfo->dynamic_header();
 int regions[] = {MetaspaceShared::rw,
 MetaspaceShared::ro,
 MetaspaceShared::mc};
 size_t len = sizeof(regions)/sizeof(int);
 if (_dynamic_header == NULL) {
 return NULL;
 }
-intptr_t* buffer = (intptr_t*)_dynamic_header->_read_only_tables_start;
+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 = (DynamicArchiveHeader*)dynamic_info->header();
+DynamicArchiveHeader* dynamic_header = dynamic_info->dynamic_header();
-int* crc = dynamic_header->_base_archive_crc;
 // Check the header crc
-if (*crc++ != base_info->crc()) {
+if (dynamic_header->base_header_crc() != base_info->crc()) {
 FileMapInfo::fail_continue("Archive header checksum verification failed.");
 return false;
 }
 // Check each space's crc
 for (int i = 0; i < MetaspaceShared::n_regions; i++) {
-if (*crc++ != base_info->space_crc(i)) {
+if (dynamic_header->base_region_crc(i) != base_info->space_crc(i)) {
 FileMapInfo::fail_continue("Archive region #%d checksum verification failed.", i);
 return false;
 }
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54932	0f934da77390
child 58679	9c3209ff7550