< prev index next >

src/hotspot/share/cds/archiveBuilder.cpp

Print this page

  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 "cds/aotArtifactFinder.hpp"
  26 #include "cds/aotClassLinker.hpp"
  27 #include "cds/aotLinkedClassBulkLoader.hpp"
  28 #include "cds/aotLogging.hpp"
  29 #include "cds/aotMapLogger.hpp"
  30 #include "cds/aotMetaspace.hpp"
  31 #include "cds/archiveBuilder.hpp"
  32 #include "cds/archiveHeapWriter.hpp"
  33 #include "cds/archiveUtils.hpp"
  34 #include "cds/cdsConfig.hpp"
  35 #include "cds/cppVtables.hpp"
  36 #include "cds/dumpAllocStats.hpp"
  37 #include "cds/dynamicArchive.hpp"

  38 #include "cds/heapShared.hpp"
  39 #include "cds/regeneratedClasses.hpp"
  40 #include "classfile/classLoader.hpp"
  41 #include "classfile/classLoaderDataShared.hpp"
  42 #include "classfile/javaClasses.hpp"
  43 #include "classfile/symbolTable.hpp"
  44 #include "classfile/systemDictionaryShared.hpp"
  45 #include "classfile/vmClasses.hpp"
  46 #include "code/aotCodeCache.hpp"
  47 #include "interpreter/abstractInterpreter.hpp"
  48 #include "jvm.h"
  49 #include "logging/log.hpp"
  50 #include "memory/allStatic.hpp"
  51 #include "memory/memoryReserver.hpp"
  52 #include "memory/memRegion.hpp"
  53 #include "memory/resourceArea.hpp"
  54 #include "oops/compressedKlass.inline.hpp"
  55 #include "oops/instanceKlass.hpp"
  56 #include "oops/methodCounters.hpp"
  57 #include "oops/methodData.hpp"
  58 #include "oops/objArrayKlass.hpp"
  59 #include "oops/objArrayOop.inline.hpp"
  60 #include "oops/oopHandle.inline.hpp"
  61 #include "oops/trainingData.hpp"
  62 #include "runtime/arguments.hpp"
  63 #include "runtime/globals_extension.hpp"
  64 #include "runtime/javaThread.hpp"

  65 #include "runtime/sharedRuntime.hpp"
  66 #include "utilities/align.hpp"
  67 #include "utilities/bitMap.inline.hpp"
  68 #include "utilities/formatBuffer.hpp"
  69 
  70 ArchiveBuilder* ArchiveBuilder::_current = nullptr;
  71 
  72 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() {
  73   char* newtop = ArchiveBuilder::current()->_ro_region.top();
  74   ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true);
  75 }
  76 
  77 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) {
  78   _total_bytes = 0;
  79   _objs = new (mtClassShared) GrowableArray<SourceObjInfo*>(128 * K, mtClassShared);
  80 }
  81 
  82 ArchiveBuilder::SourceObjList::~SourceObjList() {
  83   delete _objs;
  84 }

 167   _ptrmap.iterate(&relocator, start, end);
 168 }
 169 
 170 ArchiveBuilder::ArchiveBuilder() :
 171   _current_dump_region(nullptr),
 172   _buffer_bottom(nullptr),
 173   _requested_static_archive_bottom(nullptr),
 174   _requested_static_archive_top(nullptr),
 175   _requested_dynamic_archive_bottom(nullptr),
 176   _requested_dynamic_archive_top(nullptr),
 177   _mapped_static_archive_bottom(nullptr),
 178   _mapped_static_archive_top(nullptr),
 179   _buffer_to_requested_delta(0),
 180   _pz_region("pz", MAX_SHARED_DELTA), // protection zone -- used only during dumping; does NOT exist in cds archive.
 181   _rw_region("rw", MAX_SHARED_DELTA),
 182   _ro_region("ro", MAX_SHARED_DELTA),
 183   _ac_region("ac", MAX_SHARED_DELTA),
 184   _ptrmap(mtClassShared),
 185   _rw_ptrmap(mtClassShared),
 186   _ro_ptrmap(mtClassShared),

 187   _rw_src_objs(),
 188   _ro_src_objs(),
 189   _src_obj_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
 190   _buffered_to_src_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
 191   _total_heap_region_size(0)
 192 {
 193   _klasses = new (mtClassShared) GrowableArray<Klass*>(4 * K, mtClassShared);
 194   _symbols = new (mtClassShared) GrowableArray<Symbol*>(256 * K, mtClassShared);
 195   _entropy_seed = 0x12345678;
 196   _relocated_ptr_info._num_ptrs = 0;
 197   _relocated_ptr_info._num_tagged_ptrs = 0;
 198   _relocated_ptr_info._num_nulled_ptrs = 0;
 199   assert(_current == nullptr, "must be");
 200   _current = this;
 201 }
 202 
 203 ArchiveBuilder::~ArchiveBuilder() {
 204   assert(_current == this, "must be");
 205   _current = nullptr;
 206 

1179     _requested_dynamic_archive_top = _requested_dynamic_archive_bottom + my_archive_size;
1180     RelocateBufferToRequested<false> patcher(this);
1181     patcher.doit();
1182   }
1183 }
1184 
1185 void ArchiveBuilder::print_stats() {
1186   _alloc_stats.print_stats(int(_ro_region.used()), int(_rw_region.used()));
1187 }
1188 
1189 void ArchiveBuilder::write_archive(FileMapInfo* mapinfo, ArchiveHeapInfo* heap_info) {
1190   // Make sure NUM_CDS_REGIONS (exported in cds.h) agrees with
1191   // AOTMetaspace::n_regions (internal to hotspot).
1192   assert(NUM_CDS_REGIONS == AOTMetaspace::n_regions, "sanity");
1193 
1194   write_region(mapinfo, AOTMetaspace::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false);
1195   write_region(mapinfo, AOTMetaspace::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false);
1196   write_region(mapinfo, AOTMetaspace::ac, &_ac_region, /*read_only=*/false,/*allow_exec=*/false);
1197 
1198   // Split pointer map into read-write and read-only bitmaps
1199   ArchivePtrMarker::initialize_rw_ro_maps(&_rw_ptrmap, &_ro_ptrmap);
1200 
1201   size_t bitmap_size_in_bytes;
1202   char* bitmap = mapinfo->write_bitmap_region(ArchivePtrMarker::rw_ptrmap(), ArchivePtrMarker::ro_ptrmap(), heap_info,



1203                                               bitmap_size_in_bytes);
1204 
1205   if (heap_info->is_used()) {
1206     _total_heap_region_size = mapinfo->write_heap_region(heap_info);
1207   }
1208 
1209   print_region_stats(mapinfo, heap_info);
1210 
1211   mapinfo->set_requested_base((char*)AOTMetaspace::requested_base_address());
1212   mapinfo->set_header_crc(mapinfo->compute_header_crc());
1213   // After this point, we should not write any data into mapinfo->header() since this
1214   // would corrupt its checksum we have calculated before.
1215   mapinfo->write_header();
1216   mapinfo->close();
1217 

1218   if (log_is_enabled(Info, aot)) {
1219     log_info(aot)("Full module graph = %s", CDSConfig::is_dumping_full_module_graph() ? "enabled" : "disabled");
1220     print_stats();
1221   }
1222 
1223   if (log_is_enabled(Info, aot, map)) {
1224     AOTMapLogger::dumptime_log(this, mapinfo, heap_info, bitmap, bitmap_size_in_bytes);
1225   }
1226   CDS_JAVA_HEAP_ONLY(HeapShared::destroy_archived_object_cache());
1227   FREE_C_HEAP_ARRAY(char, bitmap);
1228 }
1229 
1230 void ArchiveBuilder::write_region(FileMapInfo* mapinfo, int region_idx, DumpRegion* dump_region, bool read_only,  bool allow_exec) {
1231   mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec);
1232 }
1233 
1234 void ArchiveBuilder::count_relocated_pointer(bool tagged, bool nulled) {
1235   _relocated_ptr_info._num_ptrs ++;
1236   _relocated_ptr_info._num_tagged_ptrs += tagged ? 1 : 0;
1237   _relocated_ptr_info._num_nulled_ptrs += nulled ? 1 : 0;
1238 }
1239 

  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 "cds/aotArtifactFinder.hpp"
  26 #include "cds/aotClassLinker.hpp"
  27 #include "cds/aotLinkedClassBulkLoader.hpp"
  28 #include "cds/aotLogging.hpp"
  29 #include "cds/aotMapLogger.hpp"
  30 #include "cds/aotMetaspace.hpp"
  31 #include "cds/archiveBuilder.hpp"
  32 #include "cds/archiveHeapWriter.hpp"
  33 #include "cds/archiveUtils.hpp"
  34 #include "cds/cdsConfig.hpp"
  35 #include "cds/cppVtables.hpp"
  36 #include "cds/dumpAllocStats.hpp"
  37 #include "cds/dynamicArchive.hpp"
  38 #include "cds/finalImageRecipes.hpp"
  39 #include "cds/heapShared.hpp"
  40 #include "cds/regeneratedClasses.hpp"
  41 #include "classfile/classLoader.hpp"
  42 #include "classfile/classLoaderDataShared.hpp"
  43 #include "classfile/javaClasses.hpp"
  44 #include "classfile/symbolTable.hpp"
  45 #include "classfile/systemDictionaryShared.hpp"
  46 #include "classfile/vmClasses.hpp"
  47 #include "code/aotCodeCache.hpp"
  48 #include "interpreter/abstractInterpreter.hpp"
  49 #include "jvm.h"
  50 #include "logging/log.hpp"
  51 #include "memory/allStatic.hpp"
  52 #include "memory/memoryReserver.hpp"
  53 #include "memory/memRegion.hpp"
  54 #include "memory/resourceArea.hpp"
  55 #include "oops/compressedKlass.inline.hpp"
  56 #include "oops/instanceKlass.hpp"
  57 #include "oops/methodCounters.hpp"
  58 #include "oops/methodData.hpp"
  59 #include "oops/objArrayKlass.hpp"
  60 #include "oops/objArrayOop.inline.hpp"
  61 #include "oops/oopHandle.inline.hpp"
  62 #include "oops/trainingData.hpp"
  63 #include "runtime/arguments.hpp"
  64 #include "runtime/globals_extension.hpp"
  65 #include "runtime/javaThread.hpp"
  66 #include "runtime/safepointVerifiers.hpp"
  67 #include "runtime/sharedRuntime.hpp"
  68 #include "utilities/align.hpp"
  69 #include "utilities/bitMap.inline.hpp"
  70 #include "utilities/formatBuffer.hpp"
  71 
  72 ArchiveBuilder* ArchiveBuilder::_current = nullptr;
  73 
  74 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() {
  75   char* newtop = ArchiveBuilder::current()->_ro_region.top();
  76   ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true);
  77 }
  78 
  79 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) {
  80   _total_bytes = 0;
  81   _objs = new (mtClassShared) GrowableArray<SourceObjInfo*>(128 * K, mtClassShared);
  82 }
  83 
  84 ArchiveBuilder::SourceObjList::~SourceObjList() {
  85   delete _objs;
  86 }

 169   _ptrmap.iterate(&relocator, start, end);
 170 }
 171 
 172 ArchiveBuilder::ArchiveBuilder() :
 173   _current_dump_region(nullptr),
 174   _buffer_bottom(nullptr),
 175   _requested_static_archive_bottom(nullptr),
 176   _requested_static_archive_top(nullptr),
 177   _requested_dynamic_archive_bottom(nullptr),
 178   _requested_dynamic_archive_top(nullptr),
 179   _mapped_static_archive_bottom(nullptr),
 180   _mapped_static_archive_top(nullptr),
 181   _buffer_to_requested_delta(0),
 182   _pz_region("pz", MAX_SHARED_DELTA), // protection zone -- used only during dumping; does NOT exist in cds archive.
 183   _rw_region("rw", MAX_SHARED_DELTA),
 184   _ro_region("ro", MAX_SHARED_DELTA),
 185   _ac_region("ac", MAX_SHARED_DELTA),
 186   _ptrmap(mtClassShared),
 187   _rw_ptrmap(mtClassShared),
 188   _ro_ptrmap(mtClassShared),
 189   _ac_ptrmap(mtClassShared),
 190   _rw_src_objs(),
 191   _ro_src_objs(),
 192   _src_obj_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
 193   _buffered_to_src_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
 194   _total_heap_region_size(0)
 195 {
 196   _klasses = new (mtClassShared) GrowableArray<Klass*>(4 * K, mtClassShared);
 197   _symbols = new (mtClassShared) GrowableArray<Symbol*>(256 * K, mtClassShared);
 198   _entropy_seed = 0x12345678;
 199   _relocated_ptr_info._num_ptrs = 0;
 200   _relocated_ptr_info._num_tagged_ptrs = 0;
 201   _relocated_ptr_info._num_nulled_ptrs = 0;
 202   assert(_current == nullptr, "must be");
 203   _current = this;
 204 }
 205 
 206 ArchiveBuilder::~ArchiveBuilder() {
 207   assert(_current == this, "must be");
 208   _current = nullptr;
 209 

1182     _requested_dynamic_archive_top = _requested_dynamic_archive_bottom + my_archive_size;
1183     RelocateBufferToRequested<false> patcher(this);
1184     patcher.doit();
1185   }
1186 }
1187 
1188 void ArchiveBuilder::print_stats() {
1189   _alloc_stats.print_stats(int(_ro_region.used()), int(_rw_region.used()));
1190 }
1191 
1192 void ArchiveBuilder::write_archive(FileMapInfo* mapinfo, ArchiveHeapInfo* heap_info) {
1193   // Make sure NUM_CDS_REGIONS (exported in cds.h) agrees with
1194   // AOTMetaspace::n_regions (internal to hotspot).
1195   assert(NUM_CDS_REGIONS == AOTMetaspace::n_regions, "sanity");
1196 
1197   write_region(mapinfo, AOTMetaspace::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false);
1198   write_region(mapinfo, AOTMetaspace::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false);
1199   write_region(mapinfo, AOTMetaspace::ac, &_ac_region, /*read_only=*/false,/*allow_exec=*/false);
1200 
1201   // Split pointer map into read-write and read-only bitmaps
1202   ArchivePtrMarker::initialize_rw_ro_ac_maps(&_rw_ptrmap, &_ro_ptrmap, &_ac_ptrmap);
1203 
1204   size_t bitmap_size_in_bytes;
1205   char* bitmap = mapinfo->write_bitmap_region(ArchivePtrMarker::rw_ptrmap(),
1206                                               ArchivePtrMarker::ro_ptrmap(),
1207                                               ArchivePtrMarker::ac_ptrmap(),
1208                                               heap_info,
1209                                               bitmap_size_in_bytes);
1210 
1211   if (heap_info->is_used()) {
1212     _total_heap_region_size = mapinfo->write_heap_region(heap_info);
1213   }
1214 
1215   print_region_stats(mapinfo, heap_info);
1216 
1217   mapinfo->set_requested_base((char*)AOTMetaspace::requested_base_address());
1218   mapinfo->set_header_crc(mapinfo->compute_header_crc());
1219   // After this point, we should not write any data into mapinfo->header() since this
1220   // would corrupt its checksum we have calculated before.
1221   mapinfo->write_header();
1222   mapinfo->close();
1223 
1224   aot_log_info(aot)("Full module graph = %s", CDSConfig::is_dumping_full_module_graph() ? "enabled" : "disabled");
1225   if (log_is_enabled(Info, aot)) {

1226     print_stats();
1227   }
1228 
1229   if (log_is_enabled(Info, aot, map)) {
1230     AOTMapLogger::dumptime_log(this, mapinfo, heap_info, bitmap, bitmap_size_in_bytes);
1231   }
1232   CDS_JAVA_HEAP_ONLY(HeapShared::destroy_archived_object_cache());
1233   FREE_C_HEAP_ARRAY(char, bitmap);
1234 }
1235 
1236 void ArchiveBuilder::write_region(FileMapInfo* mapinfo, int region_idx, DumpRegion* dump_region, bool read_only,  bool allow_exec) {
1237   mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec);
1238 }
1239 
1240 void ArchiveBuilder::count_relocated_pointer(bool tagged, bool nulled) {
1241   _relocated_ptr_info._num_ptrs ++;
1242   _relocated_ptr_info._num_tagged_ptrs += tagged ? 1 : 0;
1243   _relocated_ptr_info._num_nulled_ptrs += nulled ? 1 : 0;
1244 }
1245 
< prev index next >