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 "cds/aotArtifactFinder.hpp"
26 #include "cds/aotClassLinker.hpp"
27 #include "cds/aotLogging.hpp"
28 #include "cds/aotMapLogger.hpp"
29 #include "cds/aotMetaspace.hpp"
30 #include "cds/archiveBuilder.hpp"
31 #include "cds/archiveUtils.hpp"
32 #include "cds/cdsConfig.hpp"
33 #include "cds/cppVtables.hpp"
34 #include "cds/dumpAllocStats.hpp"
35 #include "cds/dynamicArchive.hpp"
36 #include "cds/heapShared.hpp"
37 #include "cds/regeneratedClasses.hpp"
38 #include "classfile/classLoader.hpp"
39 #include "classfile/classLoaderDataShared.hpp"
40 #include "classfile/javaClasses.hpp"
41 #include "classfile/symbolTable.hpp"
42 #include "classfile/systemDictionaryShared.hpp"
43 #include "classfile/vmClasses.hpp"
44 #include "code/aotCodeCache.hpp"
45 #include "interpreter/abstractInterpreter.hpp"
46 #include "jvm.h"
47 #include "logging/log.hpp"
48 #include "memory/allStatic.hpp"
49 #include "memory/memoryReserver.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/methodCounters.hpp"
55 #include "oops/methodData.hpp"
56 #include "oops/objArrayKlass.hpp"
57 #include "oops/objArrayOop.inline.hpp"
58 #include "oops/oopHandle.inline.hpp"
59 #include "oops/trainingData.hpp"
60 #include "runtime/arguments.hpp"
61 #include "runtime/globals_extension.hpp"
62 #include "runtime/javaThread.hpp"
63 #include "runtime/sharedRuntime.hpp"
64 #include "utilities/align.hpp"
65 #include "utilities/bitMap.inline.hpp"
66 #include "utilities/formatBuffer.hpp"
67
68 ArchiveBuilder* ArchiveBuilder::_current = nullptr;
69
70 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() {
71 char* newtop = ArchiveBuilder::current()->_ro_region.top();
72 ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true);
73 }
74
75 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) {
76 _total_bytes = 0;
77 _objs = new (mtClassShared) GrowableArray<SourceObjInfo*>(128 * K, mtClassShared);
78 }
79
80 ArchiveBuilder::SourceObjList::~SourceObjList() {
81 delete _objs;
82 }
165 _ptrmap.iterate(&relocator, start, end);
166 }
167
168 ArchiveBuilder::ArchiveBuilder() :
169 _current_dump_region(nullptr),
170 _buffer_bottom(nullptr),
171 _requested_static_archive_bottom(nullptr),
172 _requested_static_archive_top(nullptr),
173 _requested_dynamic_archive_bottom(nullptr),
174 _requested_dynamic_archive_top(nullptr),
175 _mapped_static_archive_bottom(nullptr),
176 _mapped_static_archive_top(nullptr),
177 _buffer_to_requested_delta(0),
178 _pz_region("pz", MAX_SHARED_DELTA), // protection zone -- used only during dumping; does NOT exist in cds archive.
179 _rw_region("rw", MAX_SHARED_DELTA),
180 _ro_region("ro", MAX_SHARED_DELTA),
181 _ac_region("ac", MAX_SHARED_DELTA),
182 _ptrmap(mtClassShared),
183 _rw_ptrmap(mtClassShared),
184 _ro_ptrmap(mtClassShared),
185 _rw_src_objs(),
186 _ro_src_objs(),
187 _src_obj_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
188 _buffered_to_src_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
189 _total_heap_region_size(0)
190 {
191 _klasses = new (mtClassShared) GrowableArray<Klass*>(4 * K, mtClassShared);
192 _symbols = new (mtClassShared) GrowableArray<Symbol*>(256 * K, mtClassShared);
193 _entropy_seed = 0x12345678;
194 _relocated_ptr_info._num_ptrs = 0;
195 _relocated_ptr_info._num_tagged_ptrs = 0;
196 _relocated_ptr_info._num_nulled_ptrs = 0;
197 assert(_current == nullptr, "must be");
198 _current = this;
199 }
200
201 ArchiveBuilder::~ArchiveBuilder() {
202 assert(_current == this, "must be");
203 _current = nullptr;
204
1169 patcher.doit();
1170 }
1171 }
1172
1173 void ArchiveBuilder::print_stats() {
1174 _alloc_stats.print_stats(int(_ro_region.used()), int(_rw_region.used()));
1175 }
1176
1177 void ArchiveBuilder::write_archive(FileMapInfo* mapinfo, ArchiveMappedHeapInfo* mapped_heap_info, ArchiveStreamedHeapInfo* streamed_heap_info) {
1178 // Make sure NUM_CDS_REGIONS (exported in cds.h) agrees with
1179 // AOTMetaspace::n_regions (internal to hotspot).
1180 assert(NUM_CDS_REGIONS == AOTMetaspace::n_regions, "sanity");
1181
1182 ResourceMark rm;
1183
1184 write_region(mapinfo, AOTMetaspace::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false);
1185 write_region(mapinfo, AOTMetaspace::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false);
1186 write_region(mapinfo, AOTMetaspace::ac, &_ac_region, /*read_only=*/false,/*allow_exec=*/false);
1187
1188 // Split pointer map into read-write and read-only bitmaps
1189 ArchivePtrMarker::initialize_rw_ro_maps(&_rw_ptrmap, &_ro_ptrmap);
1190
1191 size_t bitmap_size_in_bytes;
1192 char* bitmap = mapinfo->write_bitmap_region(ArchivePtrMarker::rw_ptrmap(),
1193 ArchivePtrMarker::ro_ptrmap(),
1194 mapped_heap_info,
1195 streamed_heap_info,
1196 bitmap_size_in_bytes);
1197
1198 if (mapped_heap_info != nullptr && mapped_heap_info->is_used()) {
1199 _total_heap_region_size = mapinfo->write_mapped_heap_region(mapped_heap_info);
1200 } else if (streamed_heap_info != nullptr && streamed_heap_info->is_used()) {
1201 _total_heap_region_size = mapinfo->write_streamed_heap_region(streamed_heap_info);
1202 }
1203
1204 print_region_stats(mapinfo, mapped_heap_info, streamed_heap_info);
1205
1206 mapinfo->set_requested_base((char*)AOTMetaspace::requested_base_address());
1207 mapinfo->set_header_crc(mapinfo->compute_header_crc());
1208 // After this point, we should not write any data into mapinfo->header() since this
1209 // would corrupt its checksum we have calculated before.
1210 mapinfo->write_header();
1211 mapinfo->close();
1212
1213 if (log_is_enabled(Info, aot)) {
1214 log_info(aot)("Full module graph = %s", CDSConfig::is_dumping_full_module_graph() ? "enabled" : "disabled");
1215 print_stats();
1216 }
1217
1218 if (log_is_enabled(Info, aot, map)) {
1219 AOTMapLogger::dumptime_log(this, mapinfo, mapped_heap_info, streamed_heap_info, bitmap, bitmap_size_in_bytes);
1220 }
1221 CDS_JAVA_HEAP_ONLY(HeapShared::destroy_archived_object_cache());
1222 FREE_C_HEAP_ARRAY(char, bitmap);
1223 }
1224
1225 void ArchiveBuilder::write_region(FileMapInfo* mapinfo, int region_idx, DumpRegion* dump_region, bool read_only, bool allow_exec) {
1226 mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec);
1227 }
1228
1229 void ArchiveBuilder::count_relocated_pointer(bool tagged, bool nulled) {
1230 _relocated_ptr_info._num_ptrs ++;
1231 _relocated_ptr_info._num_tagged_ptrs += tagged ? 1 : 0;
1232 _relocated_ptr_info._num_nulled_ptrs += nulled ? 1 : 0;
1233 }
1234
|
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 "cds/aotArtifactFinder.hpp"
26 #include "cds/aotClassLinker.hpp"
27 #include "cds/aotLogging.hpp"
28 #include "cds/aotMapLogger.hpp"
29 #include "cds/aotMetaspace.hpp"
30 #include "cds/archiveBuilder.hpp"
31 #include "cds/archiveUtils.hpp"
32 #include "cds/cdsConfig.hpp"
33 #include "cds/cppVtables.hpp"
34 #include "cds/dumpAllocStats.hpp"
35 #include "cds/dynamicArchive.hpp"
36 #include "cds/finalImageRecipes.hpp"
37 #include "cds/heapShared.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 "code/aotCodeCache.hpp"
46 #include "interpreter/abstractInterpreter.hpp"
47 #include "jvm.h"
48 #include "logging/log.hpp"
49 #include "memory/allStatic.hpp"
50 #include "memory/memoryReserver.hpp"
51 #include "memory/memRegion.hpp"
52 #include "memory/resourceArea.hpp"
53 #include "oops/compressedKlass.inline.hpp"
54 #include "oops/instanceKlass.hpp"
55 #include "oops/methodCounters.hpp"
56 #include "oops/methodData.hpp"
57 #include "oops/objArrayKlass.hpp"
58 #include "oops/objArrayOop.inline.hpp"
59 #include "oops/oopHandle.inline.hpp"
60 #include "oops/trainingData.hpp"
61 #include "runtime/arguments.hpp"
62 #include "runtime/globals_extension.hpp"
63 #include "runtime/javaThread.hpp"
64 #include "runtime/safepointVerifiers.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 _ac_ptrmap(mtClassShared),
188 _rw_src_objs(),
189 _ro_src_objs(),
190 _src_obj_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
191 _buffered_to_src_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
192 _total_heap_region_size(0)
193 {
194 _klasses = new (mtClassShared) GrowableArray<Klass*>(4 * K, mtClassShared);
195 _symbols = new (mtClassShared) GrowableArray<Symbol*>(256 * K, mtClassShared);
196 _entropy_seed = 0x12345678;
197 _relocated_ptr_info._num_ptrs = 0;
198 _relocated_ptr_info._num_tagged_ptrs = 0;
199 _relocated_ptr_info._num_nulled_ptrs = 0;
200 assert(_current == nullptr, "must be");
201 _current = this;
202 }
203
204 ArchiveBuilder::~ArchiveBuilder() {
205 assert(_current == this, "must be");
206 _current = nullptr;
207
1172 patcher.doit();
1173 }
1174 }
1175
1176 void ArchiveBuilder::print_stats() {
1177 _alloc_stats.print_stats(int(_ro_region.used()), int(_rw_region.used()));
1178 }
1179
1180 void ArchiveBuilder::write_archive(FileMapInfo* mapinfo, ArchiveMappedHeapInfo* mapped_heap_info, ArchiveStreamedHeapInfo* streamed_heap_info) {
1181 // Make sure NUM_CDS_REGIONS (exported in cds.h) agrees with
1182 // AOTMetaspace::n_regions (internal to hotspot).
1183 assert(NUM_CDS_REGIONS == AOTMetaspace::n_regions, "sanity");
1184
1185 ResourceMark rm;
1186
1187 write_region(mapinfo, AOTMetaspace::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false);
1188 write_region(mapinfo, AOTMetaspace::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false);
1189 write_region(mapinfo, AOTMetaspace::ac, &_ac_region, /*read_only=*/false,/*allow_exec=*/false);
1190
1191 // Split pointer map into read-write and read-only bitmaps
1192 ArchivePtrMarker::initialize_rw_ro_ac_maps(&_rw_ptrmap, &_ro_ptrmap, &_ac_ptrmap);
1193
1194 size_t bitmap_size_in_bytes;
1195 char* bitmap = mapinfo->write_bitmap_region(ArchivePtrMarker::rw_ptrmap(),
1196 ArchivePtrMarker::ro_ptrmap(),
1197 ArchivePtrMarker::ac_ptrmap(),
1198 mapped_heap_info,
1199 streamed_heap_info,
1200 bitmap_size_in_bytes);
1201
1202 if (mapped_heap_info != nullptr && mapped_heap_info->is_used()) {
1203 _total_heap_region_size = mapinfo->write_mapped_heap_region(mapped_heap_info);
1204 } else if (streamed_heap_info != nullptr && streamed_heap_info->is_used()) {
1205 _total_heap_region_size = mapinfo->write_streamed_heap_region(streamed_heap_info);
1206 }
1207
1208 print_region_stats(mapinfo, mapped_heap_info, streamed_heap_info);
1209
1210 mapinfo->set_requested_base((char*)AOTMetaspace::requested_base_address());
1211 mapinfo->set_header_crc(mapinfo->compute_header_crc());
1212 // After this point, we should not write any data into mapinfo->header() since this
1213 // would corrupt its checksum we have calculated before.
1214 mapinfo->write_header();
1215 mapinfo->close();
1216
1217 aot_log_info(aot)("Full module graph = %s", CDSConfig::is_dumping_full_module_graph() ? "enabled" : "disabled");
1218 if (log_is_enabled(Info, aot)) {
1219 print_stats();
1220 }
1221
1222 if (log_is_enabled(Info, aot, map)) {
1223 AOTMapLogger::dumptime_log(this, mapinfo, mapped_heap_info, streamed_heap_info, bitmap, bitmap_size_in_bytes);
1224 }
1225 CDS_JAVA_HEAP_ONLY(HeapShared::destroy_archived_object_cache());
1226 FREE_C_HEAP_ARRAY(char, bitmap);
1227 }
1228
1229 void ArchiveBuilder::write_region(FileMapInfo* mapinfo, int region_idx, DumpRegion* dump_region, bool read_only, bool allow_exec) {
1230 mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec);
1231 }
1232
1233 void ArchiveBuilder::count_relocated_pointer(bool tagged, bool nulled) {
1234 _relocated_ptr_info._num_ptrs ++;
1235 _relocated_ptr_info._num_tagged_ptrs += tagged ? 1 : 0;
1236 _relocated_ptr_info._num_nulled_ptrs += nulled ? 1 : 0;
1237 }
1238
|