1 /* 2 * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "cds/archiveBuilder.hpp" 27 #include "cds/archiveHeapWriter.hpp" 28 #include "cds/archiveUtils.hpp" 29 #include "cds/cdsConfig.hpp" 30 #include "cds/classPrelinker.hpp" 31 #include "cds/classPreloader.hpp" 32 #include "cds/cppVtables.hpp" 33 #include "cds/dumpAllocStats.hpp" 34 #include "cds/dynamicArchive.hpp" 35 #include "cds/finalImageRecipes.hpp" 36 #include "cds/heapShared.hpp" 37 #include "cds/metaspaceShared.hpp" 38 #include "cds/regeneratedClasses.hpp" 39 #include "classfile/classLoader.hpp" 40 #include "classfile/classLoaderDataShared.hpp" 41 #include "classfile/javaClasses.hpp" 42 #include "classfile/symbolTable.hpp" 43 #include "classfile/systemDictionaryShared.hpp" 44 #include "classfile/vmClasses.hpp" 45 #include "interpreter/abstractInterpreter.hpp" 46 #include "jvm.h" 47 #include "logging/log.hpp" 48 #include "logging/logStream.hpp" 49 #include "memory/allStatic.hpp" 50 #include "memory/memRegion.hpp" 51 #include "memory/resourceArea.hpp" 52 #include "oops/compressedKlass.inline.hpp" 53 #include "oops/instanceKlass.hpp" 54 #include "oops/objArrayKlass.hpp" 55 #include "oops/objArrayOop.inline.hpp" 56 #include "oops/oopHandle.inline.hpp" 57 #include "oops/trainingData.hpp" 58 #include "runtime/arguments.hpp" 59 #include "runtime/fieldDescriptor.inline.hpp" 60 #include "runtime/globals_extension.hpp" 61 #include "runtime/javaThread.hpp" 62 #include "runtime/sharedRuntime.hpp" 63 #include "utilities/align.hpp" 64 #include "utilities/bitMap.inline.hpp" 65 #include "utilities/formatBuffer.hpp" 66 67 ArchiveBuilder* ArchiveBuilder::_current = nullptr; 68 69 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() { 70 char* newtop = ArchiveBuilder::current()->_ro_region.top(); 71 ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true); 72 } 73 74 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) { 75 _total_bytes = 0; 76 _objs = new (mtClassShared) GrowableArray<SourceObjInfo*>(128 * K, mtClassShared); 77 } 78 79 ArchiveBuilder::SourceObjList::~SourceObjList() { 80 delete _objs; 81 } 82 83 void ArchiveBuilder::SourceObjList::append(SourceObjInfo* src_info) { 84 // Save this source object for copying 85 src_info->set_id(_objs->length()); 86 _objs->append(src_info); 87 88 // Prepare for marking the pointers in this source object 89 assert(is_aligned(_total_bytes, sizeof(address)), "must be"); 90 src_info->set_ptrmap_start(_total_bytes / sizeof(address)); 91 _total_bytes = align_up(_total_bytes + (uintx)src_info->size_in_bytes(), sizeof(address)); 92 src_info->set_ptrmap_end(_total_bytes / sizeof(address)); 93 94 BitMap::idx_t bitmap_size_needed = BitMap::idx_t(src_info->ptrmap_end()); 95 if (_ptrmap.size() <= bitmap_size_needed) { 96 _ptrmap.resize((bitmap_size_needed + 1) * 2); 97 } 98 } 99 100 void ArchiveBuilder::SourceObjList::remember_embedded_pointer(SourceObjInfo* src_info, MetaspaceClosure::Ref* ref) { 101 // src_obj contains a pointer. Remember the location of this pointer in _ptrmap, 102 // so that we can copy/relocate it later. 103 src_info->set_has_embedded_pointer(); 104 address src_obj = src_info->source_addr(); 105 address* field_addr = ref->addr(); 106 assert(src_info->ptrmap_start() < _total_bytes, "sanity"); 107 assert(src_info->ptrmap_end() <= _total_bytes, "sanity"); 108 assert(*field_addr != nullptr, "should have checked"); 109 110 intx field_offset_in_bytes = ((address)field_addr) - src_obj; 111 DEBUG_ONLY(int src_obj_size = src_info->size_in_bytes();) 112 assert(field_offset_in_bytes >= 0, "must be"); 113 assert(field_offset_in_bytes + intx(sizeof(intptr_t)) <= intx(src_obj_size), "must be"); 114 assert(is_aligned(field_offset_in_bytes, sizeof(address)), "must be"); 115 116 BitMap::idx_t idx = BitMap::idx_t(src_info->ptrmap_start() + (uintx)(field_offset_in_bytes / sizeof(address))); 117 _ptrmap.set_bit(BitMap::idx_t(idx)); 118 } 119 120 class RelocateEmbeddedPointers : public BitMapClosure { 121 ArchiveBuilder* _builder; 122 address _buffered_obj; 123 BitMap::idx_t _start_idx; 124 public: 125 RelocateEmbeddedPointers(ArchiveBuilder* builder, address buffered_obj, BitMap::idx_t start_idx) : 126 _builder(builder), _buffered_obj(buffered_obj), _start_idx(start_idx) {} 127 128 bool do_bit(BitMap::idx_t bit_offset) { 129 size_t field_offset = size_t(bit_offset - _start_idx) * sizeof(address); 130 address* ptr_loc = (address*)(_buffered_obj + field_offset); 131 132 address old_p = *ptr_loc; 133 address new_p = _builder->get_buffered_addr(old_p); 134 135 log_trace(cds)("Ref: [" PTR_FORMAT "] -> " PTR_FORMAT " => " PTR_FORMAT, 136 p2i(ptr_loc), p2i(old_p), p2i(new_p)); 137 138 ArchivePtrMarker::set_and_mark_pointer(ptr_loc, new_p); 139 return true; // keep iterating the bitmap 140 } 141 }; 142 143 void ArchiveBuilder::SourceObjList::relocate(int i, ArchiveBuilder* builder) { 144 SourceObjInfo* src_info = objs()->at(i); 145 assert(src_info->should_copy(), "must be"); 146 BitMap::idx_t start = BitMap::idx_t(src_info->ptrmap_start()); // inclusive 147 BitMap::idx_t end = BitMap::idx_t(src_info->ptrmap_end()); // exclusive 148 149 RelocateEmbeddedPointers relocator(builder, src_info->buffered_addr(), start); 150 _ptrmap.iterate(&relocator, start, end); 151 } 152 153 ArchiveBuilder::ArchiveBuilder() : 154 _current_dump_region(nullptr), 155 _buffer_bottom(nullptr), 156 _last_verified_top(nullptr), 157 _num_dump_regions_used(0), 158 _other_region_used_bytes(0), 159 _requested_static_archive_bottom(nullptr), 160 _requested_static_archive_top(nullptr), 161 _requested_dynamic_archive_bottom(nullptr), 162 _requested_dynamic_archive_top(nullptr), 163 _mapped_static_archive_bottom(nullptr), 164 _mapped_static_archive_top(nullptr), 165 _buffer_to_requested_delta(0), 166 _rw_region("rw", MAX_SHARED_DELTA), 167 _ro_region("ro", MAX_SHARED_DELTA), 168 _cc_region("cc", MAX_SHARED_DELTA), 169 _ptrmap(mtClassShared), 170 _rw_ptrmap(mtClassShared), 171 _ro_ptrmap(mtClassShared), 172 _cc_ptrmap(mtClassShared), 173 _rw_src_objs(), 174 _ro_src_objs(), 175 _src_obj_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE), 176 _buffered_to_src_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE), 177 _total_heap_region_size(0), 178 _estimated_metaspaceobj_bytes(0), 179 _estimated_hashtable_bytes(0) 180 { 181 _klasses = new (mtClassShared) GrowableArray<Klass*>(4 * K, mtClassShared); 182 _symbols = new (mtClassShared) GrowableArray<Symbol*>(256 * K, mtClassShared); 183 _entropy_seed = 0x12345678; 184 assert(_current == nullptr, "must be"); 185 _current = this; 186 } 187 188 ArchiveBuilder::~ArchiveBuilder() { 189 assert(_current == this, "must be"); 190 _current = nullptr; 191 192 for (int i = 0; i < _symbols->length(); i++) { 193 _symbols->at(i)->decrement_refcount(); 194 } 195 196 delete _klasses; 197 delete _symbols; 198 if (_shared_rs.is_reserved()) { 199 _shared_rs.release(); 200 } 201 } 202 203 // Returns a deterministic sequence of pseudo random numbers. The main purpose is NOT 204 // for randomness but to get good entropy for the identity_hash() of archived Symbols, 205 // while keeping the contents of static CDS archives deterministic to ensure 206 // reproducibility of JDK builds. 207 int ArchiveBuilder::entropy() { 208 assert(SafepointSynchronize::is_at_safepoint(), "needed to ensure deterministic sequence"); 209 _entropy_seed = os::next_random(_entropy_seed); 210 return static_cast<int>(_entropy_seed); 211 } 212 213 class GatherKlassesAndSymbols : public UniqueMetaspaceClosure { 214 ArchiveBuilder* _builder; 215 216 public: 217 GatherKlassesAndSymbols(ArchiveBuilder* builder) : _builder(builder) {} 218 219 virtual bool do_unique_ref(Ref* ref, bool read_only) { 220 return _builder->gather_klass_and_symbol(ref, read_only); 221 } 222 }; 223 224 bool ArchiveBuilder::gather_klass_and_symbol(MetaspaceClosure::Ref* ref, bool read_only) { 225 if (ref->obj() == nullptr) { 226 return false; 227 } 228 if (get_follow_mode(ref) != make_a_copy) { 229 return false; 230 } 231 if (ref->msotype() == MetaspaceObj::ClassType) { 232 Klass* klass = (Klass*)ref->obj(); 233 assert(klass->is_klass(), "must be"); 234 if (!is_excluded(klass)) { 235 _klasses->append(klass); 236 if (klass->is_hidden() && klass->is_instance_klass()) { 237 update_hidden_class_loader_type(InstanceKlass::cast(klass)); 238 } 239 } 240 // See RunTimeClassInfo::get_for() 241 _estimated_metaspaceobj_bytes += align_up(BytesPerWord, SharedSpaceObjectAlignment); 242 } else if (ref->msotype() == MetaspaceObj::SymbolType) { 243 // Make sure the symbol won't be GC'ed while we are dumping the archive. 244 Symbol* sym = (Symbol*)ref->obj(); 245 sym->increment_refcount(); 246 _symbols->append(sym); 247 } 248 249 int bytes = ref->size() * BytesPerWord; 250 _estimated_metaspaceobj_bytes += align_up(bytes, SharedSpaceObjectAlignment); 251 252 return true; // recurse 253 } 254 255 void ArchiveBuilder::gather_klasses_and_symbols() { 256 ResourceMark rm; 257 log_info(cds)("Gathering classes and symbols ... "); 258 GatherKlassesAndSymbols doit(this); 259 iterate_roots(&doit); 260 #if INCLUDE_CDS_JAVA_HEAP 261 if (CDSConfig::is_dumping_full_module_graph()) { 262 ClassLoaderDataShared::iterate_symbols(&doit); 263 } 264 #endif 265 doit.finish(); 266 267 if (CDSConfig::is_dumping_static_archive()) { 268 // To ensure deterministic contents in the static archive, we need to ensure that 269 // we iterate the MetaspaceObjs in a deterministic order. It doesn't matter where 270 // the MetaspaceObjs are located originally, as they are copied sequentially into 271 // the archive during the iteration. 272 // 273 // The only issue here is that the symbol table and the system directories may be 274 // randomly ordered, so we copy the symbols and klasses into two arrays and sort 275 // them deterministically. 276 // 277 // During -Xshare:dump, the order of Symbol creation is strictly determined by 278 // the SharedClassListFile (class loading is done in a single thread and the JIT 279 // is disabled). Also, Symbols are allocated in monotonically increasing addresses 280 // (see Symbol::operator new(size_t, int)). So if we iterate the Symbols by 281 // ascending address order, we ensure that all Symbols are copied into deterministic 282 // locations in the archive. 283 // 284 // TODO: in the future, if we want to produce deterministic contents in the 285 // dynamic archive, we might need to sort the symbols alphabetically (also see 286 // DynamicArchiveBuilder::sort_methods()). 287 log_info(cds)("Sorting symbols ... "); 288 _symbols->sort(compare_symbols_by_address); 289 sort_klasses(); 290 291 // TODO -- we need a proper estimate for the archived modules, etc, 292 // but this should be enough for now 293 _estimated_metaspaceobj_bytes += 200 * 1024 * 1024; 294 } 295 } 296 297 #if INCLUDE_CDS_JAVA_HEAP 298 299 void ArchiveBuilder::update_hidden_class_loader_type(InstanceKlass* ik) { 300 s2 classloader_type; 301 if (HeapShared::is_lambda_form_klass(ik)) { 302 assert(CDSConfig::is_dumping_invokedynamic(), "lambda form classes are archived only if ArchiveInvokeDynamic is true"); 303 classloader_type = ClassLoader::BOOT_LOADER; 304 } else if (HeapShared::is_lambda_proxy_klass(ik)) { 305 oop loader = ik->class_loader(); 306 307 if (loader == nullptr) { 308 classloader_type = ClassLoader::BOOT_LOADER; 309 } else if (SystemDictionary::is_platform_class_loader(loader)) { 310 classloader_type = ClassLoader::PLATFORM_LOADER; 311 } else if (SystemDictionary::is_system_class_loader(loader)) { 312 classloader_type = ClassLoader::APP_LOADER; 313 } else { 314 ShouldNotReachHere(); 315 } 316 } else { 317 ShouldNotReachHere(); 318 } 319 320 ik->set_shared_class_loader_type(classloader_type); 321 if (HeapShared::is_lambda_proxy_klass(ik)) { 322 InstanceKlass* nest_host = ik->nest_host_not_null(); 323 ik->set_shared_classpath_index(nest_host->shared_classpath_index()); 324 } 325 } 326 327 #endif //INCLUDE_CDS_JAVA_HEAP 328 329 int ArchiveBuilder::compare_symbols_by_address(Symbol** a, Symbol** b) { 330 if (a[0] < b[0]) { 331 return -1; 332 } else { 333 assert(a[0] > b[0], "Duplicated symbol %s unexpected", (*a)->as_C_string()); 334 return 1; 335 } 336 } 337 338 int ArchiveBuilder::compare_klass_by_name(Klass** a, Klass** b) { 339 return a[0]->name()->fast_compare(b[0]->name()); 340 } 341 342 void ArchiveBuilder::sort_klasses() { 343 log_info(cds)("Sorting classes ... "); 344 _klasses->sort(compare_klass_by_name); 345 } 346 347 size_t ArchiveBuilder::estimate_archive_size() { 348 // size of the symbol table and two dictionaries, plus the RunTimeClassInfo's 349 size_t symbol_table_est = SymbolTable::estimate_size_for_archive(); 350 size_t dictionary_est = SystemDictionaryShared::estimate_size_for_archive(); 351 size_t training_data_est = TrainingData::estimate_size_for_archive(); 352 _estimated_hashtable_bytes = symbol_table_est + dictionary_est + training_data_est; 353 354 if (CDSConfig::is_dumping_final_static_archive()) { 355 _estimated_hashtable_bytes += 200 * 1024 * 1024; // FIXME -- need to iterate archived symbols?? 356 } 357 358 if (CDSConfig::is_dumping_dynamic_archive()) { 359 // Some extra space for traning data. Be generous. Unused areas will be trimmed from the archive file. 360 _estimated_hashtable_bytes += 200 * 1024 * 1024; 361 } 362 size_t total = 0; 363 364 total += _estimated_metaspaceobj_bytes; 365 total += _estimated_hashtable_bytes; 366 367 // allow fragmentation at the end of each dump region 368 total += _total_dump_regions * MetaspaceShared::core_region_alignment(); 369 370 log_info(cds)("_estimated_hashtable_bytes = " SIZE_FORMAT " + " SIZE_FORMAT " = " SIZE_FORMAT, 371 symbol_table_est, dictionary_est, _estimated_hashtable_bytes); 372 log_info(cds)("_estimated_metaspaceobj_bytes = " SIZE_FORMAT, _estimated_metaspaceobj_bytes); 373 log_info(cds)("total estimate bytes = " SIZE_FORMAT, total); 374 375 return align_up(total, MetaspaceShared::core_region_alignment()); 376 } 377 378 address ArchiveBuilder::reserve_buffer() { 379 size_t buffer_size = estimate_archive_size(); 380 ReservedSpace rs(buffer_size, MetaspaceShared::core_region_alignment(), os::vm_page_size()); 381 if (!rs.is_reserved()) { 382 log_error(cds)("Failed to reserve " SIZE_FORMAT " bytes of output buffer.", buffer_size); 383 MetaspaceShared::unrecoverable_writing_error(); 384 } 385 386 // buffer_bottom is the lowest address of the 2 core regions (rw, ro) when 387 // we are copying the class metadata into the buffer. 388 address buffer_bottom = (address)rs.base(); 389 log_info(cds)("Reserved output buffer space at " PTR_FORMAT " [" SIZE_FORMAT " bytes]", 390 p2i(buffer_bottom), buffer_size); 391 _shared_rs = rs; 392 393 _buffer_bottom = buffer_bottom; 394 _last_verified_top = buffer_bottom; 395 _current_dump_region = &_rw_region; 396 _num_dump_regions_used = 1; 397 _other_region_used_bytes = 0; 398 _current_dump_region->init(&_shared_rs, &_shared_vs); 399 400 ArchivePtrMarker::initialize(&_ptrmap, &_shared_vs); 401 402 // The bottom of the static archive should be mapped at this address by default. 403 _requested_static_archive_bottom = (address)MetaspaceShared::requested_base_address(); 404 405 // The bottom of the archive (that I am writing now) should be mapped at this address by default. 406 address my_archive_requested_bottom; 407 408 if (CDSConfig::is_dumping_static_archive()) { 409 my_archive_requested_bottom = _requested_static_archive_bottom; 410 } else { 411 _mapped_static_archive_bottom = (address)MetaspaceObj::shared_metaspace_base(); 412 _mapped_static_archive_top = (address)MetaspaceObj::shared_metaspace_top(); 413 assert(_mapped_static_archive_top >= _mapped_static_archive_bottom, "must be"); 414 size_t static_archive_size = _mapped_static_archive_top - _mapped_static_archive_bottom; 415 416 // At run time, we will mmap the dynamic archive at my_archive_requested_bottom 417 _requested_static_archive_top = _requested_static_archive_bottom + static_archive_size; 418 my_archive_requested_bottom = align_up(_requested_static_archive_top, MetaspaceShared::core_region_alignment()); 419 420 _requested_dynamic_archive_bottom = my_archive_requested_bottom; 421 } 422 423 _buffer_to_requested_delta = my_archive_requested_bottom - _buffer_bottom; 424 425 address my_archive_requested_top = my_archive_requested_bottom + buffer_size; 426 if (my_archive_requested_bottom < _requested_static_archive_bottom || 427 my_archive_requested_top <= _requested_static_archive_bottom) { 428 // Size overflow. 429 log_error(cds)("my_archive_requested_bottom = " INTPTR_FORMAT, p2i(my_archive_requested_bottom)); 430 log_error(cds)("my_archive_requested_top = " INTPTR_FORMAT, p2i(my_archive_requested_top)); 431 log_error(cds)("SharedBaseAddress (" INTPTR_FORMAT ") is too high. " 432 "Please rerun java -Xshare:dump with a lower value", p2i(_requested_static_archive_bottom)); 433 MetaspaceShared::unrecoverable_writing_error(); 434 } 435 436 if (CDSConfig::is_dumping_static_archive()) { 437 // We don't want any valid object to be at the very bottom of the archive. 438 // See ArchivePtrMarker::mark_pointer(). 439 rw_region()->allocate(16); 440 } 441 442 return buffer_bottom; 443 } 444 445 void ArchiveBuilder::iterate_sorted_roots(MetaspaceClosure* it) { 446 int num_symbols = _symbols->length(); 447 for (int i = 0; i < num_symbols; i++) { 448 it->push(_symbols->adr_at(i)); 449 } 450 451 int num_klasses = _klasses->length(); 452 for (int i = 0; i < num_klasses; i++) { 453 it->push(_klasses->adr_at(i)); 454 } 455 456 iterate_roots(it); 457 } 458 459 class GatherSortedSourceObjs : public MetaspaceClosure { 460 ArchiveBuilder* _builder; 461 462 public: 463 GatherSortedSourceObjs(ArchiveBuilder* builder) : _builder(builder) {} 464 465 virtual bool do_ref(Ref* ref, bool read_only) { 466 return _builder->gather_one_source_obj(ref, read_only); 467 } 468 }; 469 470 bool ArchiveBuilder::gather_one_source_obj(MetaspaceClosure::Ref* ref, bool read_only) { 471 address src_obj = ref->obj(); 472 if (src_obj == nullptr) { 473 return false; 474 } 475 476 remember_embedded_pointer_in_enclosing_obj(ref); 477 if (RegeneratedClasses::has_been_regenerated(src_obj)) { 478 // No need to copy it. We will later relocate it to point to the regenerated klass/method. 479 return false; 480 } 481 482 FollowMode follow_mode = get_follow_mode(ref); 483 SourceObjInfo src_info(ref, read_only, follow_mode); 484 bool created; 485 SourceObjInfo* p = _src_obj_table.put_if_absent(src_obj, src_info, &created); 486 if (created) { 487 if (_src_obj_table.maybe_grow()) { 488 log_info(cds, hashtables)("Expanded _src_obj_table table to %d", _src_obj_table.table_size()); 489 } 490 } 491 492 #ifdef ASSERT 493 if (ref->msotype() == MetaspaceObj::MethodType) { 494 Method* m = (Method*)ref->obj(); 495 assert(!RegeneratedClasses::has_been_regenerated((address)m->method_holder()), 496 "Should not archive methods in a class that has been regenerated"); 497 } 498 #endif 499 500 assert(p->read_only() == src_info.read_only(), "must be"); 501 502 if (created && src_info.should_copy()) { 503 if (read_only) { 504 _ro_src_objs.append(p); 505 } else { 506 _rw_src_objs.append(p); 507 } 508 return true; // Need to recurse into this ref only if we are copying it 509 } else { 510 return false; 511 } 512 } 513 514 void ArchiveBuilder::record_regenerated_object(address orig_src_obj, address regen_src_obj) { 515 // Record the fact that orig_src_obj has been replaced by regen_src_obj. All calls to get_buffered_addr(orig_src_obj) 516 // should return the same value as get_buffered_addr(regen_src_obj). 517 SourceObjInfo* p = _src_obj_table.get(regen_src_obj); 518 assert(p != nullptr, "regenerated object should always be dumped"); 519 SourceObjInfo orig_src_info(orig_src_obj, p); 520 bool created; 521 _src_obj_table.put_if_absent(orig_src_obj, orig_src_info, &created); 522 assert(created, "We shouldn't have archived the original copy of a regenerated object"); 523 } 524 525 // Remember that we have a pointer inside ref->enclosing_obj() that points to ref->obj() 526 void ArchiveBuilder::remember_embedded_pointer_in_enclosing_obj(MetaspaceClosure::Ref* ref) { 527 assert(ref->obj() != nullptr, "should have checked"); 528 529 address enclosing_obj = ref->enclosing_obj(); 530 if (enclosing_obj == nullptr) { 531 return; 532 } 533 534 // We are dealing with 3 addresses: 535 // address o = ref->obj(): We have found an object whose address is o. 536 // address* mpp = ref->mpp(): The object o is pointed to by a pointer whose address is mpp. 537 // I.e., (*mpp == o) 538 // enclosing_obj : If non-null, it is the object which has a field that points to o. 539 // mpp is the address if that field. 540 // 541 // Example: We have an array whose first element points to a Method: 542 // Method* o = 0x0000abcd; 543 // Array<Method*>* enclosing_obj = 0x00001000; 544 // enclosing_obj->at_put(0, o); 545 // 546 // We the MetaspaceClosure iterates on the very first element of this array, we have 547 // ref->obj() == 0x0000abcd (the Method) 548 // ref->mpp() == 0x00001008 (the location of the first element in the array) 549 // ref->enclosing_obj() == 0x00001000 (the Array that contains the Method) 550 // 551 // We use the above information to mark the bitmap to indicate that there's a pointer on address 0x00001008. 552 SourceObjInfo* src_info = _src_obj_table.get(enclosing_obj); 553 if (src_info == nullptr || !src_info->should_copy()) { 554 // source objects of point_to_it/set_to_null types are not copied 555 // so we don't need to remember their pointers. 556 } else { 557 if (src_info->read_only()) { 558 _ro_src_objs.remember_embedded_pointer(src_info, ref); 559 } else { 560 _rw_src_objs.remember_embedded_pointer(src_info, ref); 561 } 562 } 563 } 564 565 void ArchiveBuilder::gather_source_objs() { 566 ResourceMark rm; 567 log_info(cds)("Gathering all archivable objects ... "); 568 gather_klasses_and_symbols(); 569 GatherSortedSourceObjs doit(this); 570 iterate_sorted_roots(&doit); 571 doit.finish(); 572 } 573 574 bool ArchiveBuilder::is_excluded(Klass* klass) { 575 if (klass->is_instance_klass()) { 576 InstanceKlass* ik = InstanceKlass::cast(klass); 577 return SystemDictionaryShared::is_excluded_class(ik); 578 } else if (klass->is_objArray_klass()) { 579 Klass* bottom = ObjArrayKlass::cast(klass)->bottom_klass(); 580 if (CDSConfig::is_dumping_dynamic_archive() && MetaspaceShared::is_shared_static(bottom)) { 581 // The bottom class is in the static archive so it's clearly not excluded. 582 assert(CDSConfig::is_dumping_dynamic_archive(), "sanity"); 583 return false; 584 } else if (bottom->is_instance_klass()) { 585 return SystemDictionaryShared::is_excluded_class(InstanceKlass::cast(bottom)); 586 } 587 } 588 589 return false; 590 } 591 592 ArchiveBuilder::FollowMode ArchiveBuilder::get_follow_mode(MetaspaceClosure::Ref *ref) { 593 address obj = ref->obj(); 594 if (CDSConfig::is_dumping_dynamic_archive() && MetaspaceShared::is_in_shared_metaspace(obj)) { 595 // Don't dump existing shared metadata again. 596 return point_to_it; 597 } else if (ref->msotype() == MetaspaceObj::MethodDataType || 598 ref->msotype() == MetaspaceObj::MethodCountersType || 599 ref->msotype() == MetaspaceObj::KlassTrainingDataType || 600 ref->msotype() == MetaspaceObj::MethodTrainingDataType || 601 ref->msotype() == MetaspaceObj::CompileTrainingDataType) { 602 return TrainingData::need_data() ? make_a_copy : set_to_null; 603 } else { 604 if (ref->msotype() == MetaspaceObj::ClassType) { 605 Klass* klass = (Klass*)ref->obj(); 606 assert(klass->is_klass(), "must be"); 607 if (is_excluded(klass)) { 608 ResourceMark rm; 609 log_debug(cds, dynamic)("Skipping class (excluded): %s", klass->external_name()); 610 return set_to_null; 611 } 612 } 613 614 return make_a_copy; 615 } 616 } 617 618 void ArchiveBuilder::start_dump_region(DumpRegion* next) { 619 address bottom = _last_verified_top; 620 address top = (address)(current_dump_region()->top()); 621 _other_region_used_bytes += size_t(top - bottom); 622 623 current_dump_region()->pack(next); 624 _current_dump_region = next; 625 _num_dump_regions_used ++; 626 627 _last_verified_top = (address)(current_dump_region()->top()); 628 } 629 630 void ArchiveBuilder::verify_estimate_size(size_t estimate, const char* which) { 631 address bottom = _last_verified_top; 632 address top = (address)(current_dump_region()->top()); 633 size_t used = size_t(top - bottom) + _other_region_used_bytes; 634 int diff = int(estimate) - int(used); 635 636 log_info(cds)("%s estimate = " SIZE_FORMAT " used = " SIZE_FORMAT "; diff = %d bytes", which, estimate, used, diff); 637 assert(diff >= 0, "Estimate is too small"); 638 639 _last_verified_top = top; 640 _other_region_used_bytes = 0; 641 } 642 643 char* ArchiveBuilder::ro_strdup(const char* s) { 644 char* archived_str = ro_region_alloc((int)strlen(s) + 1); 645 strcpy(archived_str, s); 646 return archived_str; 647 } 648 649 // The objects that have embedded pointers will sink 650 // towards the end of the list. This ensures we have a maximum 651 // number of leading zero bits in the relocation bitmap. 652 int ArchiveBuilder::compare_src_objs(SourceObjInfo** a, SourceObjInfo** b) { 653 if ((*a)->has_embedded_pointer() && !(*b)->has_embedded_pointer()) { 654 return 1; 655 } else if (!(*a)->has_embedded_pointer() && (*b)->has_embedded_pointer()) { 656 return -1; 657 } else { 658 // This is necessary to keep the sorting order stable. Otherwise the 659 // archive's contents may not be deterministic. 660 return (*a)->id() - (*b)->id(); 661 } 662 } 663 664 void ArchiveBuilder::sort_metadata_objs() { 665 _rw_src_objs.objs()->sort(compare_src_objs); 666 _ro_src_objs.objs()->sort(compare_src_objs); 667 } 668 669 void ArchiveBuilder::dump_rw_metadata() { 670 ResourceMark rm; 671 log_info(cds)("Allocating RW objects ... "); 672 make_shallow_copies(&_rw_region, &_rw_src_objs); 673 674 #if INCLUDE_CDS_JAVA_HEAP 675 if (CDSConfig::is_dumping_full_module_graph()) { 676 // Archive the ModuleEntry's and PackageEntry's of the 3 built-in loaders 677 char* start = rw_region()->top(); 678 ClassLoaderDataShared::allocate_archived_tables(); 679 alloc_stats()->record_modules(rw_region()->top() - start, /*read_only*/false); 680 } 681 #endif 682 } 683 684 void ArchiveBuilder::dump_ro_metadata() { 685 ResourceMark rm; 686 log_info(cds)("Allocating RO objects ... "); 687 688 start_dump_region(&_ro_region); 689 make_shallow_copies(&_ro_region, &_ro_src_objs); 690 691 #if INCLUDE_CDS_JAVA_HEAP 692 if (CDSConfig::is_dumping_full_module_graph()) { 693 char* start = ro_region()->top(); 694 ClassLoaderDataShared::init_archived_tables(); 695 alloc_stats()->record_modules(ro_region()->top() - start, /*read_only*/true); 696 } 697 #endif 698 699 RegeneratedClasses::record_regenerated_objects(); 700 } 701 702 void ArchiveBuilder::make_shallow_copies(DumpRegion *dump_region, 703 const ArchiveBuilder::SourceObjList* src_objs) { 704 for (int i = 0; i < src_objs->objs()->length(); i++) { 705 make_shallow_copy(dump_region, src_objs->objs()->at(i)); 706 } 707 log_info(cds)("done (%d objects)", src_objs->objs()->length()); 708 } 709 710 void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* src_info) { 711 address src = src_info->source_addr(); 712 int bytes = src_info->size_in_bytes(); 713 char* dest; 714 char* oldtop; 715 char* newtop; 716 717 oldtop = dump_region->top(); 718 if (src_info->msotype() == MetaspaceObj::ClassType) { 719 // Save a pointer immediate in front of an InstanceKlass, so 720 // we can do a quick lookup from InstanceKlass* -> RunTimeClassInfo* 721 // without building another hashtable. See RunTimeClassInfo::get_for() 722 // in systemDictionaryShared.cpp. 723 Klass* klass = (Klass*)src; 724 if (klass->is_instance_klass()) { 725 SystemDictionaryShared::validate_before_archiving(InstanceKlass::cast(klass)); 726 dump_region->allocate(sizeof(address)); 727 } 728 } 729 dest = dump_region->allocate(bytes); 730 newtop = dump_region->top(); 731 732 memcpy(dest, src, bytes); 733 734 // Update the hash of buffered sorted symbols for static dump so that the symbols have deterministic contents 735 if (CDSConfig::is_dumping_static_archive() && (src_info->msotype() == MetaspaceObj::SymbolType)) { 736 Symbol* buffered_symbol = (Symbol*)dest; 737 assert(((Symbol*)src)->is_permanent(), "archived symbols must be permanent"); 738 buffered_symbol->update_identity_hash(); 739 } 740 741 { 742 bool created; 743 _buffered_to_src_table.put_if_absent((address)dest, src, &created); 744 assert(created, "must be"); 745 if (_buffered_to_src_table.maybe_grow()) { 746 log_info(cds, hashtables)("Expanded _buffered_to_src_table table to %d", _buffered_to_src_table.table_size()); 747 } 748 } 749 750 intptr_t* archived_vtable = CppVtables::get_archived_vtable(src_info->msotype(), (address)dest); 751 if (archived_vtable != nullptr) { 752 *(address*)dest = (address)archived_vtable; 753 ArchivePtrMarker::mark_pointer((address*)dest); 754 } 755 756 log_trace(cds)("Copy: " PTR_FORMAT " ==> " PTR_FORMAT " %d", p2i(src), p2i(dest), bytes); 757 src_info->set_buffered_addr((address)dest); 758 759 _alloc_stats.record(src_info->msotype(), int(newtop - oldtop), src_info->read_only()); 760 } 761 762 // This is used by code that hand-assembles data structures, such as the LambdaProxyClassKey, that are 763 // not handled by MetaspaceClosure. 764 void ArchiveBuilder::write_pointer_in_buffer(address* ptr_location, address src_addr) { 765 assert(is_in_buffer_space(ptr_location), "must be"); 766 if (src_addr == nullptr) { 767 *ptr_location = nullptr; 768 ArchivePtrMarker::clear_pointer(ptr_location); 769 } else { 770 *ptr_location = get_buffered_addr(src_addr); 771 ArchivePtrMarker::mark_pointer(ptr_location); 772 } 773 } 774 775 void ArchiveBuilder::mark_and_relocate_to_buffered_addr(address* ptr_location) { 776 assert(*ptr_location != nullptr, "sanity"); 777 if (!is_in_mapped_static_archive(*ptr_location)) { 778 *ptr_location = get_buffered_addr(*ptr_location); 779 } 780 ArchivePtrMarker::mark_pointer(ptr_location); 781 } 782 783 address ArchiveBuilder::get_buffered_addr(address src_addr) const { 784 SourceObjInfo* p = _src_obj_table.get(src_addr); 785 assert(p != nullptr, "src_addr " INTPTR_FORMAT " is used but has not been archived", 786 p2i(src_addr)); 787 788 return p->buffered_addr(); 789 } 790 791 bool ArchiveBuilder::has_been_archived(address src_addr) const { 792 SourceObjInfo* p = _src_obj_table.get(src_addr); 793 return (p != nullptr); 794 } 795 796 address ArchiveBuilder::get_source_addr(address buffered_addr) const { 797 assert(is_in_buffer_space(buffered_addr), "must be"); 798 address* src_p = _buffered_to_src_table.get(buffered_addr); 799 assert(src_p != nullptr && *src_p != nullptr, "must be"); 800 return *src_p; 801 } 802 803 void ArchiveBuilder::relocate_embedded_pointers(ArchiveBuilder::SourceObjList* src_objs) { 804 for (int i = 0; i < src_objs->objs()->length(); i++) { 805 src_objs->relocate(i, this); 806 } 807 } 808 809 void ArchiveBuilder::relocate_metaspaceobj_embedded_pointers() { 810 log_info(cds)("Relocating embedded pointers in core regions ... "); 811 relocate_embedded_pointers(&_rw_src_objs); 812 relocate_embedded_pointers(&_ro_src_objs); 813 } 814 815 #define ADD_COUNT(x) \ 816 x += 1; \ 817 x ## _p += preloaded; \ 818 x ## _i += inited; 819 820 #define DECLARE_INSTANCE_KLASS_COUNTER(x) \ 821 int x = 0; \ 822 int x ## _p = 0; \ 823 int x ## _i = 0; \ 824 825 void ArchiveBuilder::make_klasses_shareable() { 826 DECLARE_INSTANCE_KLASS_COUNTER(num_instance_klasses); 827 DECLARE_INSTANCE_KLASS_COUNTER(num_boot_klasses); 828 DECLARE_INSTANCE_KLASS_COUNTER(num_vm_klasses); 829 DECLARE_INSTANCE_KLASS_COUNTER(num_platform_klasses); 830 DECLARE_INSTANCE_KLASS_COUNTER(num_app_klasses); 831 DECLARE_INSTANCE_KLASS_COUNTER(num_hidden_klasses); 832 DECLARE_INSTANCE_KLASS_COUNTER(num_unlinked_klasses); 833 DECLARE_INSTANCE_KLASS_COUNTER(num_unregistered_klasses); 834 int num_obj_array_klasses = 0; 835 int num_type_array_klasses = 0; 836 837 int boot_unlinked = 0; 838 int platform_unlinked = 0; 839 int app_unlinked = 0; 840 int unreg_unlinked = 0; 841 842 for (int i = 0; i < klasses()->length(); i++) { 843 // Some of the code in ConstantPool::remove_unshareable_info() requires the classes 844 // to be in linked state, so it must be call here before the next loop, which returns 845 // all classes to unlinked state. 846 Klass* k = get_buffered_addr(klasses()->at(i)); 847 if (k->is_instance_klass()) { 848 InstanceKlass::cast(k)->constants()->remove_unshareable_info(); 849 } 850 } 851 852 for (int i = 0; i < klasses()->length(); i++) { 853 const char* type; 854 const char* unlinked = ""; 855 const char* hidden = ""; 856 const char* generated = ""; 857 const char* preloaded_msg = ""; 858 const char* inited_msg = ""; 859 Klass* k = get_buffered_addr(klasses()->at(i)); 860 k->remove_java_mirror(); 861 if (k->is_objArray_klass()) { 862 // InstanceKlass and TypeArrayKlass will in turn call remove_unshareable_info 863 // on their array classes. 864 num_obj_array_klasses ++; 865 type = "array"; 866 } else if (k->is_typeArray_klass()) { 867 num_type_array_klasses ++; 868 type = "array"; 869 k->remove_unshareable_info(); 870 } else { 871 assert(k->is_instance_klass(), " must be"); 872 InstanceKlass* ik = InstanceKlass::cast(k); 873 InstanceKlass* src_ik = get_source_addr(ik); 874 int preloaded = ClassPreloader::is_preloaded_class(src_ik); 875 int inited = ik->has_preinitialized_mirror(); 876 ADD_COUNT(num_instance_klasses); 877 if (CDSConfig::is_dumping_dynamic_archive()) { 878 // For static dump, class loader type are already set. 879 ik->assign_class_loader_type(); 880 } 881 if (ik->is_hidden()) { 882 oop loader = k->class_loader(); 883 if (loader == nullptr) { 884 type = "boot"; 885 ADD_COUNT(num_boot_klasses); 886 } else if (loader == SystemDictionary::java_platform_loader()) { 887 type = "plat"; 888 ADD_COUNT(num_platform_klasses); 889 } else if (loader == SystemDictionary::java_system_loader()) { 890 type = "app"; 891 ADD_COUNT(num_app_klasses); 892 } else { 893 type = "bad"; 894 assert(0, "shouldn't happen"); 895 } 896 } else if (ik->is_shared_boot_class()) { 897 type = "boot"; 898 ADD_COUNT(num_boot_klasses); 899 } else if (ik->is_shared_platform_class()) { 900 type = "plat"; 901 ADD_COUNT(num_platform_klasses); 902 } else if (ik->is_shared_app_class()) { 903 type = "app"; 904 ADD_COUNT(num_app_klasses); 905 } else { 906 assert(ik->is_shared_unregistered_class(), "must be"); 907 type = "unreg"; 908 ADD_COUNT(num_unregistered_klasses); 909 } 910 911 if (ClassPreloader::is_vm_class(src_ik)) { 912 ADD_COUNT(num_vm_klasses); 913 } 914 915 if (!ik->is_linked()) { 916 ADD_COUNT(num_unlinked_klasses); 917 unlinked = " unlinked"; 918 if (ik->is_shared_boot_class()) { 919 boot_unlinked ++; 920 } else if (ik->is_shared_platform_class()) { 921 platform_unlinked ++; 922 } else if (ik->is_shared_app_class()) { 923 app_unlinked ++; 924 } else { 925 unreg_unlinked ++; 926 } 927 } 928 929 if (ik->is_hidden()) { 930 ADD_COUNT(num_hidden_klasses); 931 hidden = " hidden"; 932 } 933 934 if (ik->is_generated_shared_class()) { 935 generated = " generated"; 936 } 937 if (preloaded) { 938 preloaded_msg = " preloaded"; 939 } 940 if (inited) { 941 inited_msg = " inited"; 942 } 943 944 MetaspaceShared::rewrite_nofast_bytecodes_and_calculate_fingerprints(Thread::current(), ik); 945 ik->remove_unshareable_info(); 946 } 947 948 if (log_is_enabled(Debug, cds, class)) { 949 ResourceMark rm; 950 log_debug(cds, class)("klasses[%5d] = " PTR_FORMAT " %-5s %s%s%s%s%s%s", i, 951 p2i(to_requested(k)), type, k->external_name(), 952 hidden, unlinked, generated, preloaded_msg, inited_msg); 953 } 954 } 955 956 #define STATS_FORMAT "= %5d, preloaded = %5d, inited = %5d" 957 #define STATS_PARAMS(x) num_ ## x, num_ ## x ## _p, num_ ## x ## _i 958 959 log_info(cds)("Number of classes %d", num_instance_klasses + num_obj_array_klasses + num_type_array_klasses); 960 log_info(cds)(" instance classes " STATS_FORMAT, STATS_PARAMS(instance_klasses)); 961 log_info(cds)(" boot " STATS_FORMAT, STATS_PARAMS(boot_klasses)); 962 log_info(cds)(" vm " STATS_FORMAT, STATS_PARAMS(vm_klasses)); 963 log_info(cds)(" platform " STATS_FORMAT, STATS_PARAMS(platform_klasses)); 964 log_info(cds)(" app " STATS_FORMAT, STATS_PARAMS(app_klasses)); 965 log_info(cds)(" unregistered " STATS_FORMAT, STATS_PARAMS(unregistered_klasses)); 966 log_info(cds)(" (hidden) " STATS_FORMAT, STATS_PARAMS(hidden_klasses)); 967 log_info(cds)(" (unlinked) " STATS_FORMAT ", boot = %d, plat = %d, app = %d, unreg = %d", 968 STATS_PARAMS(unlinked_klasses), 969 boot_unlinked, platform_unlinked, 970 app_unlinked, unreg_unlinked); 971 log_info(cds)(" obj array classes = %5d", num_obj_array_klasses); 972 log_info(cds)(" type array classes = %5d", num_type_array_klasses); 973 log_info(cds)(" symbols = %5d", _symbols->length()); 974 975 #undef STATS_FORMAT 976 #undef STATS_PARAMS 977 978 DynamicArchive::make_array_klasses_shareable(); 979 } 980 981 void ArchiveBuilder::make_training_data_shareable() { 982 auto clean_td = [&] (address& src_obj, SourceObjInfo& info) { 983 if (!is_in_buffer_space(info.buffered_addr())) { 984 return; 985 } 986 987 if (info.msotype() == MetaspaceObj::KlassTrainingDataType || 988 info.msotype() == MetaspaceObj::MethodTrainingDataType || 989 info.msotype() == MetaspaceObj::CompileTrainingDataType) { 990 TrainingData* buffered_td = (TrainingData*)info.buffered_addr(); 991 buffered_td->remove_unshareable_info(); 992 } else if (info.msotype() == MetaspaceObj::MethodDataType) { 993 MethodData* buffered_mdo = (MethodData*)info.buffered_addr(); 994 buffered_mdo->remove_unshareable_info(); 995 } else if (info.msotype() == MetaspaceObj::MethodCountersType) { 996 MethodCounters* buffered_mc = (MethodCounters*)info.buffered_addr(); 997 buffered_mc->remove_unshareable_info(); 998 } 999 }; 1000 _src_obj_table.iterate_all(clean_td); 1001 } 1002 1003 void ArchiveBuilder::serialize_dynamic_archivable_items(SerializeClosure* soc) { 1004 SymbolTable::serialize_shared_table_header(soc, false); 1005 SystemDictionaryShared::serialize_dictionary_headers(soc, false); 1006 DynamicArchive::serialize_array_klasses(soc); 1007 ClassPreloader::serialize(soc, false); 1008 FinalImageRecipes::serialize(soc, false); 1009 TrainingData::serialize_training_data(soc); 1010 } 1011 1012 uintx ArchiveBuilder::buffer_to_offset(address p) const { 1013 address requested_p = to_requested(p); 1014 assert(requested_p >= _requested_static_archive_bottom, "must be"); 1015 return requested_p - _requested_static_archive_bottom; 1016 } 1017 1018 uintx ArchiveBuilder::any_to_offset(address p) const { 1019 if (is_in_mapped_static_archive(p)) { 1020 assert(CDSConfig::is_dumping_dynamic_archive(), "must be"); 1021 return p - _mapped_static_archive_bottom; 1022 } 1023 if (!is_in_buffer_space(p)) { 1024 // p must be a "source" address 1025 p = get_buffered_addr(p); 1026 } 1027 return buffer_to_offset(p); 1028 } 1029 1030 void ArchiveBuilder::start_cc_region() { 1031 ro_region()->pack(); 1032 start_dump_region(&_cc_region); 1033 } 1034 1035 void ArchiveBuilder::end_cc_region() { 1036 _cc_region.pack(); 1037 } 1038 1039 #if INCLUDE_CDS_JAVA_HEAP 1040 narrowKlass ArchiveBuilder::get_requested_narrow_klass(Klass* k) { 1041 assert(CDSConfig::is_dumping_heap(), "sanity"); 1042 k = get_buffered_klass(k); 1043 Klass* requested_k = to_requested(k); 1044 address narrow_klass_base = _requested_static_archive_bottom; // runtime encoding base == runtime mapping start 1045 const int narrow_klass_shift = ArchiveHeapWriter::precomputed_narrow_klass_shift; 1046 return CompressedKlassPointers::encode_not_null(requested_k, narrow_klass_base, narrow_klass_shift); 1047 } 1048 #endif // INCLUDE_CDS_JAVA_HEAP 1049 1050 // RelocateBufferToRequested --- Relocate all the pointers in rw/ro, 1051 // so that the archive can be mapped to the "requested" location without runtime relocation. 1052 // 1053 // - See ArchiveBuilder header for the definition of "buffer", "mapped" and "requested" 1054 // - ArchivePtrMarker::ptrmap() marks all the pointers in the rw/ro regions 1055 // - Every pointer must have one of the following values: 1056 // [a] nullptr: 1057 // No relocation is needed. Remove this pointer from ptrmap so we don't need to 1058 // consider it at runtime. 1059 // [b] Points into an object X which is inside the buffer: 1060 // Adjust this pointer by _buffer_to_requested_delta, so it points to X 1061 // when the archive is mapped at the requested location. 1062 // [c] Points into an object Y which is inside mapped static archive: 1063 // - This happens only during dynamic dump 1064 // - Adjust this pointer by _mapped_to_requested_static_archive_delta, 1065 // so it points to Y when the static archive is mapped at the requested location. 1066 template <bool STATIC_DUMP> 1067 class RelocateBufferToRequested : public BitMapClosure { 1068 ArchiveBuilder* _builder; 1069 address _buffer_bottom; 1070 intx _buffer_to_requested_delta; 1071 intx _mapped_to_requested_static_archive_delta; 1072 size_t _max_non_null_offset; 1073 1074 public: 1075 RelocateBufferToRequested(ArchiveBuilder* builder) { 1076 _builder = builder; 1077 _buffer_bottom = _builder->buffer_bottom(); 1078 _buffer_to_requested_delta = builder->buffer_to_requested_delta(); 1079 _mapped_to_requested_static_archive_delta = builder->requested_static_archive_bottom() - builder->mapped_static_archive_bottom(); 1080 _max_non_null_offset = 0; 1081 1082 address bottom = _builder->buffer_bottom(); 1083 address top = _builder->buffer_top(); 1084 address new_bottom = bottom + _buffer_to_requested_delta; 1085 address new_top = top + _buffer_to_requested_delta; 1086 log_debug(cds)("Relocating archive from [" INTPTR_FORMAT " - " INTPTR_FORMAT "] to " 1087 "[" INTPTR_FORMAT " - " INTPTR_FORMAT "]", 1088 p2i(bottom), p2i(top), 1089 p2i(new_bottom), p2i(new_top)); 1090 } 1091 1092 bool do_bit(size_t offset) { 1093 address* p = (address*)_buffer_bottom + offset; 1094 assert(_builder->is_in_buffer_space(p), "pointer must live in buffer space"); 1095 1096 if (*p == nullptr) { 1097 // todo -- clear bit, etc 1098 ArchivePtrMarker::ptrmap()->clear_bit(offset); 1099 } else { 1100 if (STATIC_DUMP) { 1101 assert(_builder->is_in_buffer_space(*p), "old pointer must point inside buffer space"); 1102 *p += _buffer_to_requested_delta; 1103 assert(_builder->is_in_requested_static_archive(*p), "new pointer must point inside requested archive"); 1104 } else { 1105 if (_builder->is_in_buffer_space(*p)) { 1106 *p += _buffer_to_requested_delta; 1107 // assert is in requested dynamic archive 1108 } else { 1109 assert(_builder->is_in_mapped_static_archive(*p), "old pointer must point inside buffer space or mapped static archive"); 1110 *p += _mapped_to_requested_static_archive_delta; 1111 assert(_builder->is_in_requested_static_archive(*p), "new pointer must point inside requested archive"); 1112 } 1113 } 1114 _max_non_null_offset = offset; 1115 } 1116 1117 return true; // keep iterating 1118 } 1119 1120 void doit() { 1121 ArchivePtrMarker::ptrmap()->iterate(this); 1122 ArchivePtrMarker::compact(_max_non_null_offset); 1123 } 1124 }; 1125 1126 1127 void ArchiveBuilder::relocate_to_requested() { 1128 if (!ro_region()->is_packed()) { 1129 ro_region()->pack(); 1130 } 1131 1132 size_t my_archive_size = buffer_top() - buffer_bottom(); 1133 1134 if (CDSConfig::is_dumping_static_archive()) { 1135 _requested_static_archive_top = _requested_static_archive_bottom + my_archive_size; 1136 RelocateBufferToRequested<true> patcher(this); 1137 patcher.doit(); 1138 } else { 1139 assert(CDSConfig::is_dumping_dynamic_archive(), "must be"); 1140 _requested_dynamic_archive_top = _requested_dynamic_archive_bottom + my_archive_size; 1141 RelocateBufferToRequested<false> patcher(this); 1142 patcher.doit(); 1143 } 1144 } 1145 1146 // Write detailed info to a mapfile to analyze contents of the archive. 1147 // static dump: 1148 // java -Xshare:dump -Xlog:cds+map=trace:file=cds.map:none:filesize=0 1149 // dynamic dump: 1150 // java -cp MyApp.jar -XX:ArchiveClassesAtExit=MyApp.jsa \ 1151 // -Xlog:cds+map=trace:file=cds.map:none:filesize=0 MyApp 1152 // 1153 // We need to do some address translation because the buffers used at dump time may be mapped to 1154 // a different location at runtime. At dump time, the buffers may be at arbitrary locations 1155 // picked by the OS. At runtime, we try to map at a fixed location (SharedBaseAddress). For 1156 // consistency, we log everything using runtime addresses. 1157 class ArchiveBuilder::CDSMapLogger : AllStatic { 1158 static intx buffer_to_runtime_delta() { 1159 // Translate the buffers used by the RW/RO regions to their eventual (requested) locations 1160 // at runtime. 1161 return ArchiveBuilder::current()->buffer_to_requested_delta(); 1162 } 1163 1164 // rw/ro regions only 1165 static void log_metaspace_region(const char* name, DumpRegion* region, 1166 const ArchiveBuilder::SourceObjList* src_objs) { 1167 address region_base = address(region->base()); 1168 address region_top = address(region->top()); 1169 log_region(name, region_base, region_top, region_base + buffer_to_runtime_delta()); 1170 log_metaspace_objects(region, src_objs); 1171 } 1172 1173 #define _LOG_PREFIX PTR_FORMAT ": @@ %-17s %d" 1174 1175 static void log_klass(Klass* k, address runtime_dest, const char* type_name, int bytes, Thread* current) { 1176 ResourceMark rm(current); 1177 log_debug(cds, map)(_LOG_PREFIX " %s", 1178 p2i(runtime_dest), type_name, bytes, k->external_name()); 1179 } 1180 static void log_method(Method* m, address runtime_dest, const char* type_name, int bytes, Thread* current) { 1181 ResourceMark rm(current); 1182 log_debug(cds, map)(_LOG_PREFIX " %s", 1183 p2i(runtime_dest), type_name, bytes, m->external_name()); 1184 } 1185 1186 // rw/ro regions only 1187 static void log_metaspace_objects(DumpRegion* region, const ArchiveBuilder::SourceObjList* src_objs) { 1188 address last_obj_base = address(region->base()); 1189 address last_obj_end = address(region->base()); 1190 address region_end = address(region->end()); 1191 Thread* current = Thread::current(); 1192 for (int i = 0; i < src_objs->objs()->length(); i++) { 1193 SourceObjInfo* src_info = src_objs->at(i); 1194 address src = src_info->source_addr(); 1195 address dest = src_info->buffered_addr(); 1196 log_as_hex(last_obj_base, dest, last_obj_base + buffer_to_runtime_delta()); 1197 address runtime_dest = dest + buffer_to_runtime_delta(); 1198 int bytes = src_info->size_in_bytes(); 1199 1200 MetaspaceObj::Type type = src_info->msotype(); 1201 const char* type_name = MetaspaceObj::type_name(type); 1202 1203 switch (type) { 1204 case MetaspaceObj::ClassType: 1205 log_klass((Klass*)src, runtime_dest, type_name, bytes, current); 1206 break; 1207 case MetaspaceObj::ConstantPoolType: 1208 log_klass(((ConstantPool*)src)->pool_holder(), 1209 runtime_dest, type_name, bytes, current); 1210 break; 1211 case MetaspaceObj::ConstantPoolCacheType: 1212 log_klass(((ConstantPoolCache*)src)->constant_pool()->pool_holder(), 1213 runtime_dest, type_name, bytes, current); 1214 break; 1215 case MetaspaceObj::MethodType: 1216 log_method((Method*)src, runtime_dest, type_name, bytes, current); 1217 break; 1218 case MetaspaceObj::ConstMethodType: 1219 log_method(((ConstMethod*)src)->method(), runtime_dest, type_name, bytes, current); 1220 break; 1221 case MetaspaceObj::SymbolType: 1222 { 1223 ResourceMark rm(current); 1224 Symbol* s = (Symbol*)src; 1225 log_debug(cds, map)(_LOG_PREFIX " %s", p2i(runtime_dest), type_name, bytes, 1226 s->as_quoted_ascii()); 1227 } 1228 break; 1229 default: 1230 log_debug(cds, map)(_LOG_PREFIX, p2i(runtime_dest), type_name, bytes); 1231 break; 1232 } 1233 1234 last_obj_base = dest; 1235 last_obj_end = dest + bytes; 1236 } 1237 1238 log_as_hex(last_obj_base, last_obj_end, last_obj_base + buffer_to_runtime_delta()); 1239 if (last_obj_end < region_end) { 1240 log_debug(cds, map)(PTR_FORMAT ": @@ Misc data " SIZE_FORMAT " bytes", 1241 p2i(last_obj_end + buffer_to_runtime_delta()), 1242 size_t(region_end - last_obj_end)); 1243 log_as_hex(last_obj_end, region_end, last_obj_end + buffer_to_runtime_delta()); 1244 } 1245 } 1246 1247 #undef _LOG_PREFIX 1248 1249 // Log information about a region, whose address at dump time is [base .. top). At 1250 // runtime, this region will be mapped to requested_base. requested_base is 0 if this 1251 // region will be mapped at os-selected addresses (such as the bitmap region), or will 1252 // be accessed with os::read (the header). 1253 // 1254 // Note: across -Xshare:dump runs, base may be different, but requested_base should 1255 // be the same as the archive contents should be deterministic. 1256 static void log_region(const char* name, address base, address top, address requested_base) { 1257 size_t size = top - base; 1258 base = requested_base; 1259 top = requested_base + size; 1260 log_info(cds, map)("[%-18s " PTR_FORMAT " - " PTR_FORMAT " " SIZE_FORMAT_W(9) " bytes]", 1261 name, p2i(base), p2i(top), size); 1262 } 1263 1264 #if INCLUDE_CDS_JAVA_HEAP 1265 static void log_heap_region(ArchiveHeapInfo* heap_info) { 1266 MemRegion r = heap_info->buffer_region(); 1267 address start = address(r.start()); // start of the current oop inside the buffer 1268 address end = address(r.end()); 1269 log_region("heap", start, end, ArchiveHeapWriter::buffered_addr_to_requested_addr(start)); 1270 1271 LogStreamHandle(Info, cds, map) st; 1272 1273 while (start < end) { 1274 size_t byte_size; 1275 oop source_oop = ArchiveHeapWriter::buffered_addr_to_source_obj(start); 1276 address requested_start = ArchiveHeapWriter::buffered_addr_to_requested_addr(start); 1277 st.print(PTR_FORMAT ": @@ Object ", p2i(requested_start)); 1278 int permobj_segment = -1; 1279 int permobj_segment_length = -1; 1280 1281 if (source_oop != nullptr) { 1282 // This is a regular oop that got archived. 1283 print_oop_with_requested_addr_cr(&st, source_oop, false); 1284 byte_size = source_oop->size() * BytesPerWord; 1285 } else if (start == ArchiveHeapWriter::buffered_heap_roots_addr()) { 1286 // HeapShared::roots() is copied specially, so it doesn't exist in 1287 // ArchiveHeapWriter::BufferOffsetToSourceObjectTable. 1288 // See ArchiveHeapWriter::copy_roots_to_buffer(). 1289 st.print_cr("HeapShared::roots[%d]", HeapShared::pending_roots()->length()); 1290 byte_size = ArchiveHeapWriter::heap_roots_word_size() * BytesPerWord; 1291 } else if ((byte_size = ArchiveHeapWriter::get_filler_size_at(start)) > 0) { 1292 // We have a filler oop, which also does not exist in BufferOffsetToSourceObjectTable. 1293 st.print_cr("filler " SIZE_FORMAT " bytes", byte_size); 1294 } else if ((permobj_segment = ArchiveHeapWriter::get_permobj_segment_at(start, &byte_size, &permobj_segment_length)) >= 0) { 1295 st.print_cr("permobj_%d[%d] %zu bytes", permobj_segment, permobj_segment_length, byte_size); 1296 } else { 1297 ShouldNotReachHere(); 1298 } 1299 1300 address oop_end = start + byte_size; 1301 log_as_hex(start, oop_end, requested_start, /*is_heap=*/true); 1302 1303 if (source_oop != nullptr) { 1304 log_oop_details(heap_info, source_oop, /*buffered_addr=*/start); 1305 } else if (start == ArchiveHeapWriter::buffered_heap_roots_addr()) { 1306 log_heap_roots(); 1307 } else if (permobj_segment >= 0) { 1308 log_permobj_segment(permobj_segment, permobj_segment_length); 1309 } 1310 start = oop_end; 1311 } 1312 } 1313 1314 // ArchivedFieldPrinter is used to print the fields of archived objects. We can't 1315 // use _source_obj->print_on(), because we want to print the oop fields 1316 // in _source_obj with their requested addresses using print_oop_with_requested_addr_cr(). 1317 class ArchivedFieldPrinter : public FieldClosure { 1318 ArchiveHeapInfo* _heap_info; 1319 outputStream* _st; 1320 oop _source_obj; 1321 address _buffered_addr; 1322 public: 1323 ArchivedFieldPrinter(ArchiveHeapInfo* heap_info, outputStream* st, oop src_obj, address buffered_addr) : 1324 _heap_info(heap_info), _st(st), _source_obj(src_obj), _buffered_addr(buffered_addr) {} 1325 1326 void do_field(fieldDescriptor* fd) { 1327 _st->print(" - "); 1328 BasicType ft = fd->field_type(); 1329 switch (ft) { 1330 case T_ARRAY: 1331 case T_OBJECT: 1332 fd->print_on(_st); // print just the name and offset 1333 print_oop_with_requested_addr_cr(_st, _source_obj->obj_field(fd->offset())); 1334 break; 1335 default: 1336 if (ArchiveHeapWriter::is_marked_as_native_pointer(_heap_info, _source_obj, fd->offset())) { 1337 print_as_native_pointer(fd); 1338 } else { 1339 fd->print_on_for(_st, cast_to_oop(_buffered_addr)); // name, offset, value 1340 _st->cr(); 1341 } 1342 } 1343 } 1344 1345 void print_as_native_pointer(fieldDescriptor* fd) { 1346 LP64_ONLY(assert(fd->field_type() == T_LONG, "must be")); 1347 NOT_LP64 (assert(fd->field_type() == T_INT, "must be")); 1348 1349 // We have a field that looks like an integer, but it's actually a pointer to a MetaspaceObj. 1350 address source_native_ptr = (address) 1351 LP64_ONLY(_source_obj->long_field(fd->offset())) 1352 NOT_LP64( _source_obj->int_field (fd->offset())); 1353 ArchiveBuilder* builder = ArchiveBuilder::current(); 1354 1355 // The value of the native pointer at runtime. 1356 address requested_native_ptr = builder->to_requested(builder->get_buffered_addr(source_native_ptr)); 1357 1358 // The address of _source_obj at runtime 1359 oop requested_obj = ArchiveHeapWriter::source_obj_to_requested_obj(_source_obj); 1360 // The address of this field in the requested space 1361 assert(requested_obj != nullptr, "Attempting to load field from null oop"); 1362 address requested_field_addr = cast_from_oop<address>(requested_obj) + fd->offset(); 1363 1364 fd->print_on(_st); 1365 _st->print_cr(PTR_FORMAT " (marked metadata pointer @" PTR_FORMAT " )", 1366 p2i(requested_native_ptr), p2i(requested_field_addr)); 1367 } 1368 }; 1369 1370 // Print the fields of instanceOops, or the elements of arrayOops 1371 static void log_oop_details(ArchiveHeapInfo* heap_info, oop source_oop, address buffered_addr) { 1372 LogStreamHandle(Trace, cds, map, oops) st; 1373 if (st.is_enabled()) { 1374 Klass* source_klass = source_oop->klass(); 1375 ArchiveBuilder* builder = ArchiveBuilder::current(); 1376 Klass* requested_klass = builder->to_requested(builder->get_buffered_addr(source_klass)); 1377 1378 st.print(" - klass: "); 1379 source_klass->print_value_on(&st); 1380 st.print(" " PTR_FORMAT, p2i(requested_klass)); 1381 st.cr(); 1382 1383 if (source_oop->is_typeArray()) { 1384 TypeArrayKlass::cast(source_klass)->oop_print_elements_on(typeArrayOop(source_oop), &st); 1385 } else if (source_oop->is_objArray()) { 1386 objArrayOop source_obj_array = objArrayOop(source_oop); 1387 for (int i = 0; i < source_obj_array->length(); i++) { 1388 st.print(" -%4d: ", i); 1389 print_oop_with_requested_addr_cr(&st, source_obj_array->obj_at(i)); 1390 } 1391 } else { 1392 st.print_cr(" - fields (" SIZE_FORMAT " words):", source_oop->size()); 1393 ArchivedFieldPrinter print_field(heap_info, &st, source_oop, buffered_addr); 1394 InstanceKlass::cast(source_klass)->print_nonstatic_fields(&print_field); 1395 } 1396 } 1397 } 1398 1399 static void log_heap_roots() { 1400 LogStreamHandle(Trace, cds, map, oops) st; 1401 if (st.is_enabled()) { 1402 for (int i = 0; i < HeapShared::pending_roots()->length(); i++) { 1403 st.print("roots[%4d]: ", i); 1404 print_oop_with_requested_addr_cr(&st, HeapShared::pending_roots()->at(i)); 1405 } 1406 } 1407 } 1408 1409 static void log_permobj_segment(int permobj_segment, int permobj_segment_length) { 1410 LogStreamHandle(Trace, cds, map, oops) st; 1411 if (st.is_enabled()) { 1412 for (int i = 0; i < permobj_segment_length; i++) { 1413 st.print("permobj_%d[%4d]: ", permobj_segment, i); 1414 print_oop_with_requested_addr_cr(&st, ArchiveHeapWriter::get_permobj_source_addr(permobj_segment, i)); 1415 } 1416 } 1417 } 1418 1419 1420 // The output looks like this. The first number is the requested address. The second number is 1421 // the narrowOop version of the requested address. 1422 // 0x00000007ffc7e840 (0xfff8fd08) java.lang.Class 1423 // 0x00000007ffc000f8 (0xfff8001f) [B length: 11 1424 static void print_oop_with_requested_addr_cr(outputStream* st, oop source_oop, bool print_addr = true) { 1425 if (source_oop == nullptr) { 1426 st->print_cr("null"); 1427 } else { 1428 ResourceMark rm; 1429 oop requested_obj = ArchiveHeapWriter::source_obj_to_requested_obj(source_oop); 1430 if (print_addr) { 1431 st->print(PTR_FORMAT " ", p2i(requested_obj)); 1432 } 1433 if (UseCompressedOops) { 1434 st->print("(0x%08x) ", CompressedOops::narrow_oop_value(requested_obj)); 1435 } 1436 if (source_oop->is_array()) { 1437 int array_len = arrayOop(source_oop)->length(); 1438 st->print_cr("%s length: %d", source_oop->klass()->external_name(), array_len); 1439 } else { 1440 st->print("%s", source_oop->klass()->external_name()); 1441 if (java_lang_invoke_MethodType::is_instance(source_oop)) { 1442 st->print(" "); 1443 java_lang_invoke_MethodType::print_signature(source_oop, st); 1444 } 1445 st->cr(); 1446 } 1447 } 1448 } 1449 #endif // INCLUDE_CDS_JAVA_HEAP 1450 1451 // Log all the data [base...top). Pretend that the base address 1452 // will be mapped to requested_base at run-time. 1453 static void log_as_hex(address base, address top, address requested_base, bool is_heap = false) { 1454 assert(top >= base, "must be"); 1455 1456 LogStreamHandle(Trace, cds, map) lsh; 1457 if (lsh.is_enabled()) { 1458 int unitsize = sizeof(address); 1459 if (is_heap && UseCompressedOops) { 1460 // This makes the compressed oop pointers easier to read, but 1461 // longs and doubles will be split into two words. 1462 unitsize = sizeof(narrowOop); 1463 } 1464 os::print_hex_dump(&lsh, base, top, unitsize, 32, requested_base); 1465 } 1466 } 1467 1468 static void log_header(FileMapInfo* mapinfo) { 1469 LogStreamHandle(Info, cds, map) lsh; 1470 if (lsh.is_enabled()) { 1471 mapinfo->print(&lsh); 1472 } 1473 } 1474 1475 public: 1476 static void log(ArchiveBuilder* builder, FileMapInfo* mapinfo, 1477 ArchiveHeapInfo* heap_info, 1478 char* bitmap, size_t bitmap_size_in_bytes) { 1479 log_info(cds, map)("%s CDS archive map for %s", CDSConfig::is_dumping_static_archive() ? "Static" : "Dynamic", mapinfo->full_path()); 1480 1481 address header = address(mapinfo->header()); 1482 address header_end = header + mapinfo->header()->header_size(); 1483 log_region("header", header, header_end, 0); 1484 log_header(mapinfo); 1485 log_as_hex(header, header_end, 0); 1486 1487 DumpRegion* rw_region = &builder->_rw_region; 1488 DumpRegion* ro_region = &builder->_ro_region; 1489 1490 log_metaspace_region("rw region", rw_region, &builder->_rw_src_objs); 1491 log_metaspace_region("ro region", ro_region, &builder->_ro_src_objs); 1492 1493 address bitmap_end = address(bitmap + bitmap_size_in_bytes); 1494 log_region("bitmap", address(bitmap), bitmap_end, 0); 1495 log_as_hex((address)bitmap, bitmap_end, 0); 1496 1497 #if INCLUDE_CDS_JAVA_HEAP 1498 if (heap_info->is_used()) { 1499 log_heap_region(heap_info); 1500 } 1501 #endif 1502 1503 log_info(cds, map)("[End of CDS archive map]"); 1504 } 1505 }; // end ArchiveBuilder::CDSMapLogger 1506 1507 void ArchiveBuilder::print_stats() { 1508 _alloc_stats.print_stats(int(_ro_region.used()), int(_rw_region.used())); 1509 } 1510 1511 void ArchiveBuilder::write_archive(FileMapInfo* mapinfo, ArchiveHeapInfo* heap_info) { 1512 // Make sure NUM_CDS_REGIONS (exported in cds.h) agrees with 1513 // MetaspaceShared::n_regions (internal to hotspot). 1514 assert(NUM_CDS_REGIONS == MetaspaceShared::n_regions, "sanity"); 1515 1516 write_region(mapinfo, MetaspaceShared::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false); 1517 write_region(mapinfo, MetaspaceShared::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false); 1518 write_region(mapinfo, MetaspaceShared::cc, &_cc_region, /*read_only=*/false,/*allow_exec=*/true); 1519 1520 // Split pointer map into read-write and read-only bitmaps 1521 ArchivePtrMarker::initialize_rw_ro_cc_maps(&_rw_ptrmap, &_ro_ptrmap, &_cc_ptrmap); 1522 1523 size_t bitmap_size_in_bytes; 1524 char* bitmap = mapinfo->write_bitmap_region(ArchivePtrMarker::rw_ptrmap(), 1525 ArchivePtrMarker::ro_ptrmap(), 1526 ArchivePtrMarker::cc_ptrmap(), 1527 heap_info, 1528 bitmap_size_in_bytes); 1529 1530 if (heap_info->is_used()) { 1531 _total_heap_region_size = mapinfo->write_heap_region(heap_info); 1532 } 1533 1534 print_region_stats(mapinfo, heap_info); 1535 1536 mapinfo->set_requested_base((char*)MetaspaceShared::requested_base_address()); 1537 mapinfo->set_header_crc(mapinfo->compute_header_crc()); 1538 // After this point, we should not write any data into mapinfo->header() since this 1539 // would corrupt its checksum we have calculated before. 1540 mapinfo->write_header(); 1541 mapinfo->close(); 1542 1543 if (log_is_enabled(Info, cds)) { 1544 print_stats(); 1545 } 1546 1547 if (log_is_enabled(Info, cds, map)) { 1548 CDSMapLogger::log(this, mapinfo, heap_info, 1549 bitmap, bitmap_size_in_bytes); 1550 } 1551 CDS_JAVA_HEAP_ONLY(HeapShared::destroy_archived_object_cache()); 1552 FREE_C_HEAP_ARRAY(char, bitmap); 1553 } 1554 1555 void ArchiveBuilder::write_region(FileMapInfo* mapinfo, int region_idx, DumpRegion* dump_region, bool read_only, bool allow_exec) { 1556 mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec); 1557 } 1558 1559 void ArchiveBuilder::print_region_stats(FileMapInfo *mapinfo, ArchiveHeapInfo* heap_info) { 1560 // Print statistics of all the regions 1561 const size_t bitmap_used = mapinfo->region_at(MetaspaceShared::bm)->used(); 1562 const size_t bitmap_reserved = mapinfo->region_at(MetaspaceShared::bm)->used_aligned(); 1563 const size_t total_reserved = _ro_region.reserved() + _rw_region.reserved() + 1564 bitmap_reserved + 1565 _total_heap_region_size; 1566 const size_t total_bytes = _ro_region.used() + _rw_region.used() + 1567 bitmap_used + 1568 _total_heap_region_size; 1569 const double total_u_perc = percent_of(total_bytes, total_reserved); 1570 1571 _rw_region.print(total_reserved); 1572 _ro_region.print(total_reserved); 1573 _cc_region.print(total_reserved); 1574 1575 print_bitmap_region_stats(bitmap_used, total_reserved); 1576 1577 if (heap_info->is_used()) { 1578 print_heap_region_stats(heap_info, total_reserved); 1579 } 1580 1581 log_debug(cds)("total : " SIZE_FORMAT_W(9) " [100.0%% of total] out of " SIZE_FORMAT_W(9) " bytes [%5.1f%% used]", 1582 total_bytes, total_reserved, total_u_perc); 1583 } 1584 1585 void ArchiveBuilder::print_bitmap_region_stats(size_t size, size_t total_size) { 1586 log_debug(cds)("bm space: " SIZE_FORMAT_W(9) " [ %4.1f%% of total] out of " SIZE_FORMAT_W(9) " bytes [100.0%% used]", 1587 size, size/double(total_size)*100.0, size); 1588 } 1589 1590 void ArchiveBuilder::print_heap_region_stats(ArchiveHeapInfo *info, size_t total_size) { 1591 char* start = info->buffer_start(); 1592 size_t size = info->buffer_byte_size(); 1593 char* top = start + size; 1594 log_debug(cds)("hp space: " SIZE_FORMAT_W(9) " [ %4.1f%% of total] out of " SIZE_FORMAT_W(9) " bytes [100.0%% used] at " INTPTR_FORMAT, 1595 size, size/double(total_size)*100.0, size, p2i(start)); 1596 } 1597 1598 void ArchiveBuilder::report_out_of_space(const char* name, size_t needed_bytes) { 1599 // This is highly unlikely to happen on 64-bits because we have reserved a 4GB space. 1600 // On 32-bit we reserve only 256MB so you could run out of space with 100,000 classes 1601 // or so. 1602 _rw_region.print_out_of_space_msg(name, needed_bytes); 1603 _ro_region.print_out_of_space_msg(name, needed_bytes); 1604 1605 log_error(cds)("Unable to allocate from '%s' region: Please reduce the number of shared classes.", name); 1606 MetaspaceShared::unrecoverable_writing_error(); 1607 }