author | coleenp |
Tue, 16 May 2017 19:36:55 -0400 | |
changeset 46464 | 6432a858a220 |
parent 46435 | 3f6cac9867d4 |
child 46522 | 86b13b03a053 |
permissions | -rw-r--r-- |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1 |
/* |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
2 |
* Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
4 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
5 |
* This code is free software; you can redistribute it and/or modify it |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
7 |
* published by the Free Software Foundation. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
8 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
13 |
* accompanied this code). |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
14 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
15 |
* You should have received a copy of the GNU General Public License version |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
18 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
21 |
* questions. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
22 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
23 |
*/ |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
24 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
25 |
#include "precompiled.hpp" |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
26 |
#include "classfile/classListParser.hpp" |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
27 |
#include "classfile/classLoaderExt.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
28 |
#include "classfile/dictionary.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
29 |
#include "classfile/loaderConstraints.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
30 |
#include "classfile/placeholders.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
31 |
#include "classfile/sharedClassUtil.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
32 |
#include "classfile/symbolTable.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
33 |
#include "classfile/systemDictionary.hpp" |
37995 | 34 |
#include "classfile/systemDictionaryShared.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
35 |
#include "code/codeCache.hpp" |
30764 | 36 |
#include "gc/shared/gcLocker.hpp" |
30117
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
37 |
#include "interpreter/bytecodeStream.hpp" |
30764 | 38 |
#include "interpreter/bytecodes.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
39 |
#include "memory/filemap.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
40 |
#include "memory/metaspace.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
41 |
#include "memory/metaspaceShared.hpp" |
37248 | 42 |
#include "memory/resourceArea.hpp" |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
43 |
#include "oops/instanceClassLoaderKlass.hpp" |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
44 |
#include "oops/instanceMirrorKlass.hpp" |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
45 |
#include "oops/instanceRefKlass.hpp" |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
46 |
#include "oops/objArrayKlass.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
47 |
#include "oops/objArrayOop.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
48 |
#include "oops/oop.inline.hpp" |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
49 |
#include "oops/typeArrayKlass.hpp" |
37161
e881f320966e
8150015: Integrate TraceTime with Unified Logging more seamlessly
rehn
parents:
37094
diff
changeset
|
50 |
#include "runtime/timerTrace.hpp" |
25468
5331df506290
8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents:
24424
diff
changeset
|
51 |
#include "runtime/os.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
52 |
#include "runtime/signature.hpp" |
30764 | 53 |
#include "runtime/vmThread.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
54 |
#include "runtime/vm_operations.hpp" |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
55 |
#include "utilities/defaultStream.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
56 |
#include "utilities/hashtable.inline.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
57 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
58 |
int MetaspaceShared::_max_alignment = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
59 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
60 |
ReservedSpace* MetaspaceShared::_shared_rs = NULL; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
61 |
|
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
62 |
MetaspaceSharedStats MetaspaceShared::_stats; |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
63 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
64 |
bool MetaspaceShared::_has_error_classes; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
65 |
bool MetaspaceShared::_archive_loading_failed = false; |
39714 | 66 |
bool MetaspaceShared::_remapped_readwrite = false; |
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
67 |
address MetaspaceShared::_cds_i2i_entry_code_buffers = NULL; |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
68 |
size_t MetaspaceShared::_cds_i2i_entry_code_buffers_size = 0; |
35231 | 69 |
SharedMiscRegion MetaspaceShared::_mc; |
70 |
SharedMiscRegion MetaspaceShared::_md; |
|
41182 | 71 |
SharedMiscRegion MetaspaceShared::_od; |
35231 | 72 |
|
73 |
void SharedMiscRegion::initialize(ReservedSpace rs, size_t committed_byte_size, SharedSpaceType space_type) { |
|
74 |
_vs.initialize(rs, committed_byte_size); |
|
75 |
_alloc_top = _vs.low(); |
|
76 |
_space_type = space_type; |
|
77 |
} |
|
78 |
||
79 |
// NOT thread-safe, but this is called during dump time in single-threaded mode. |
|
80 |
char* SharedMiscRegion::alloc(size_t num_bytes) { |
|
81 |
assert(DumpSharedSpaces, "dump time only"); |
|
82 |
size_t alignment = sizeof(char*); |
|
83 |
num_bytes = align_size_up(num_bytes, alignment); |
|
84 |
_alloc_top = (char*)align_ptr_up(_alloc_top, alignment); |
|
85 |
if (_alloc_top + num_bytes > _vs.high()) { |
|
86 |
report_out_of_shared_space(_space_type); |
|
87 |
} |
|
88 |
||
89 |
char* p = _alloc_top; |
|
90 |
_alloc_top += num_bytes; |
|
91 |
||
92 |
memset(p, 0, num_bytes); |
|
93 |
return p; |
|
94 |
} |
|
95 |
||
96 |
void MetaspaceShared::initialize_shared_rs(ReservedSpace* rs) { |
|
97 |
assert(DumpSharedSpaces, "dump time only"); |
|
98 |
_shared_rs = rs; |
|
99 |
||
41182 | 100 |
size_t core_spaces_size = FileMapInfo::core_spaces_size(); |
35231 | 101 |
size_t metadata_size = SharedReadOnlySize + SharedReadWriteSize; |
41182 | 102 |
|
103 |
// Split into the core and optional sections |
|
104 |
ReservedSpace core_data = _shared_rs->first_part(core_spaces_size); |
|
105 |
ReservedSpace optional_data = _shared_rs->last_part(core_spaces_size); |
|
35231 | 106 |
|
41182 | 107 |
// The RO/RW and the misc sections |
108 |
ReservedSpace shared_ro_rw = core_data.first_part(metadata_size); |
|
109 |
ReservedSpace misc_section = core_data.last_part(metadata_size); |
|
110 |
||
111 |
// Now split the misc code and misc data sections. |
|
35231 | 112 |
ReservedSpace md_rs = misc_section.first_part(SharedMiscDataSize); |
113 |
ReservedSpace mc_rs = misc_section.last_part(SharedMiscDataSize); |
|
41182 | 114 |
|
35231 | 115 |
_md.initialize(md_rs, SharedMiscDataSize, SharedMiscData); |
41182 | 116 |
_mc.initialize(mc_rs, SharedMiscCodeSize, SharedMiscCode); |
117 |
_od.initialize(optional_data, metadata_size, SharedOptional); |
|
35231 | 118 |
} |
119 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
120 |
// Read/write a data stream for restoring/preserving metadata pointers and |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
121 |
// miscellaneous data from/to the shared archive file. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
122 |
|
37995 | 123 |
void MetaspaceShared::serialize(SerializeClosure* soc, GrowableArray<MemRegion> *string_space, |
124 |
size_t* space_size) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
125 |
int tag = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
126 |
soc->do_tag(--tag); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
127 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
128 |
// Verify the sizes of various metadata in the system. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
129 |
soc->do_tag(sizeof(Method)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
130 |
soc->do_tag(sizeof(ConstMethod)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
131 |
soc->do_tag(arrayOopDesc::base_offset_in_bytes(T_BYTE)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
132 |
soc->do_tag(sizeof(ConstantPool)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
133 |
soc->do_tag(sizeof(ConstantPoolCache)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
134 |
soc->do_tag(objArrayOopDesc::base_offset_in_bytes()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
135 |
soc->do_tag(typeArrayOopDesc::base_offset_in_bytes(T_BYTE)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
136 |
soc->do_tag(sizeof(Symbol)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
137 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
138 |
// Dump/restore miscellaneous metadata. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
139 |
Universe::serialize(soc, true); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
140 |
soc->do_tag(--tag); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
141 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
142 |
// Dump/restore references to commonly used names and signatures. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
143 |
vmSymbols::serialize(soc); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
144 |
soc->do_tag(--tag); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
145 |
|
37995 | 146 |
// Dump/restore the symbol and string tables |
147 |
SymbolTable::serialize(soc); |
|
148 |
StringTable::serialize(soc, string_space, space_size); |
|
149 |
soc->do_tag(--tag); |
|
150 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
151 |
soc->do_tag(666); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
152 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
153 |
|
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
154 |
address MetaspaceShared::cds_i2i_entry_code_buffers(size_t total_size) { |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
155 |
if (DumpSharedSpaces) { |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
156 |
if (_cds_i2i_entry_code_buffers == NULL) { |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
157 |
_cds_i2i_entry_code_buffers = (address)misc_data_space_alloc(total_size); |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
158 |
_cds_i2i_entry_code_buffers_size = total_size; |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
159 |
} |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
160 |
} else if (UseSharedSpaces) { |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
161 |
assert(_cds_i2i_entry_code_buffers != NULL, "must already been initialized"); |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
162 |
} else { |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
163 |
return NULL; |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
164 |
} |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
165 |
|
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
166 |
assert(_cds_i2i_entry_code_buffers_size == total_size, "must not change"); |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
167 |
return _cds_i2i_entry_code_buffers; |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
168 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
169 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
170 |
// CDS code for dumping shared archive. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
171 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
172 |
// Global object for holding classes that have been loaded. Since this |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
173 |
// is run at a safepoint just before exit, this is the entire set of classes. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
174 |
static GrowableArray<Klass*>* _global_klass_objects; |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
175 |
class CollectClassesClosure : public KlassClosure { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
176 |
void do_klass(Klass* k) { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
177 |
_global_klass_objects->append_if_missing(k); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
178 |
} |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
179 |
}; |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
180 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
181 |
static void remove_unshareable_in_classes() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
182 |
for (int i = 0; i < _global_klass_objects->length(); i++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
183 |
Klass* k = _global_klass_objects->at(i); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
184 |
k->remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
185 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
186 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
187 |
|
30117
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
188 |
static void rewrite_nofast_bytecode(Method* method) { |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
189 |
RawBytecodeStream bcs(method); |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
190 |
while (!bcs.is_last_bytecode()) { |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
191 |
Bytecodes::Code opcode = bcs.raw_next(); |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
192 |
switch (opcode) { |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
193 |
case Bytecodes::_getfield: *bcs.bcp() = Bytecodes::_nofast_getfield; break; |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
194 |
case Bytecodes::_putfield: *bcs.bcp() = Bytecodes::_nofast_putfield; break; |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
195 |
case Bytecodes::_aload_0: *bcs.bcp() = Bytecodes::_nofast_aload_0; break; |
38943
2e5c855d6b1e
8157189: 'iload_w' in shared class is not interpreted correctly.
jiangli
parents:
38151
diff
changeset
|
196 |
case Bytecodes::_iload: { |
2e5c855d6b1e
8157189: 'iload_w' in shared class is not interpreted correctly.
jiangli
parents:
38151
diff
changeset
|
197 |
if (!bcs.is_wide()) { |
2e5c855d6b1e
8157189: 'iload_w' in shared class is not interpreted correctly.
jiangli
parents:
38151
diff
changeset
|
198 |
*bcs.bcp() = Bytecodes::_nofast_iload; |
2e5c855d6b1e
8157189: 'iload_w' in shared class is not interpreted correctly.
jiangli
parents:
38151
diff
changeset
|
199 |
} |
2e5c855d6b1e
8157189: 'iload_w' in shared class is not interpreted correctly.
jiangli
parents:
38151
diff
changeset
|
200 |
break; |
2e5c855d6b1e
8157189: 'iload_w' in shared class is not interpreted correctly.
jiangli
parents:
38151
diff
changeset
|
201 |
} |
30117
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
202 |
default: break; |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
203 |
} |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
204 |
} |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
205 |
} |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
206 |
|
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
207 |
// Walk all methods in the class list to ensure that they won't be modified at |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
208 |
// run time. This includes: |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
209 |
// [1] Rewrite all bytecodes as needed, so that the ConstMethod* will not be modified |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
210 |
// at run time by RewriteBytecodes/RewriteFrequentPairs |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
211 |
// [2] Assign a fingerprint, so one doesn't need to be assigned at run-time. |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
212 |
static void rewrite_nofast_bytecodes_and_calculate_fingerprints() { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
213 |
for (int i = 0; i < _global_klass_objects->length(); i++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
214 |
Klass* k = _global_klass_objects->at(i); |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
215 |
if (k->is_instance_klass()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
216 |
InstanceKlass* ik = InstanceKlass::cast(k); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
217 |
for (int i = 0; i < ik->methods()->length(); i++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
218 |
Method* m = ik->methods()->at(i); |
30117
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
219 |
rewrite_nofast_bytecode(m); |
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19319
diff
changeset
|
220 |
Fingerprinter fp(m); |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19319
diff
changeset
|
221 |
// The side effect of this call sets method's fingerprint field. |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19319
diff
changeset
|
222 |
fp.fingerprint(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
223 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
224 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
225 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
226 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
227 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
228 |
// Objects of the Metadata types (such as Klass and ConstantPool) have C++ vtables. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
229 |
// (In GCC this is the field <Type>::_vptr, i.e., first word in the object.) |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
230 |
// |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
231 |
// Addresses of the vtables and the methods may be different across JVM runs, |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
232 |
// if libjvm.so is dynamically loaded at a different base address. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
233 |
// |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
234 |
// To ensure that the Metadata objects in the CDS archive always have the correct vtable: |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
235 |
// |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
236 |
// + at dump time: we redirect the _vptr to point to our own vtables inside |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
237 |
// the CDS image |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
238 |
// + at run time: we clone the actual contents of the vtables from libjvm.so |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
239 |
// into our own tables. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
240 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
241 |
// Currently, the archive contain ONLY the following types of objects that have C++ vtables. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
242 |
#define CPP_VTABLE_PATCH_TYPES_DO(f) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
243 |
f(ConstantPool) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
244 |
f(InstanceKlass) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
245 |
f(InstanceClassLoaderKlass) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
246 |
f(InstanceMirrorKlass) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
247 |
f(InstanceRefKlass) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
248 |
f(Method) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
249 |
f(ObjArrayKlass) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
250 |
f(TypeArrayKlass) |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
251 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
252 |
class CppVtableInfo { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
253 |
intptr_t _vtable_size; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
254 |
intptr_t _cloned_vtable[1]; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
255 |
public: |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
256 |
static int num_slots(int vtable_size) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
257 |
return 1 + vtable_size; // Need to add the space occupied by _vtable_size; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
258 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
259 |
int vtable_size() { return int(uintx(_vtable_size)); } |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
260 |
void set_vtable_size(int n) { _vtable_size = intptr_t(n); } |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
261 |
intptr_t* cloned_vtable() { return &_cloned_vtable[0]; } |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
262 |
void zero() { memset(_cloned_vtable, 0, sizeof(intptr_t) * vtable_size()); } |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
263 |
// Returns the address of the next CppVtableInfo that can be placed immediately after this CppVtableInfo |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
264 |
intptr_t* next(int vtable_size) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
265 |
return &_cloned_vtable[vtable_size]; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
266 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
267 |
}; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
268 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
269 |
template <class T> class CppVtableCloner : public T { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
270 |
static intptr_t* vtable_of(Metadata& m) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
271 |
return *((intptr_t**)&m); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
272 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
273 |
static CppVtableInfo* _info; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
274 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
275 |
static int get_vtable_length(const char* name); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
276 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
277 |
public: |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
278 |
// Allocate and initialize the C++ vtable, starting from top, but do not go past end. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
279 |
static intptr_t* allocate(const char* name, intptr_t* top, intptr_t* end); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
280 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
281 |
// Clone the vtable to ... |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
282 |
static intptr_t* clone_vtable(const char* name, CppVtableInfo* info); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
283 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
284 |
static void zero_vtable_clone() { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
285 |
assert(DumpSharedSpaces, "dump-time only"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
286 |
_info->zero(); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
287 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
288 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
289 |
// Switch the vtable pointer to point to the cloned vtable. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
290 |
static void patch(Metadata* obj) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
291 |
assert(DumpSharedSpaces, "dump-time only"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
292 |
*(void**)obj = (void*)(_info->cloned_vtable()); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
293 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
294 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
295 |
static bool is_valid_shared_object(const T* obj) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
296 |
intptr_t* vptr = *(intptr_t**)obj; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
297 |
return vptr == _info->cloned_vtable(); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
298 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
299 |
}; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
300 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
301 |
template <class T> CppVtableInfo* CppVtableCloner<T>::_info = NULL; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
302 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
303 |
template <class T> |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
304 |
intptr_t* CppVtableCloner<T>::allocate(const char* name, intptr_t* top, intptr_t* end) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
305 |
int n = get_vtable_length(name); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
306 |
_info = (CppVtableInfo*)top; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
307 |
intptr_t* next = _info->next(n); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
308 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
309 |
if (next > end) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
310 |
report_out_of_shared_space(SharedMiscData); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
311 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
312 |
_info->set_vtable_size(n); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
313 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
314 |
intptr_t* p = clone_vtable(name, _info); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
315 |
assert(p == next, "must be"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
316 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
317 |
return p; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
318 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
319 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
320 |
template <class T> |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
321 |
intptr_t* CppVtableCloner<T>::clone_vtable(const char* name, CppVtableInfo* info) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
322 |
if (!DumpSharedSpaces) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
323 |
assert(_info == 0, "_info is initialized only at dump time"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
324 |
_info = info; // Remember it -- it will be used by MetaspaceShared::is_valid_shared_method() |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
325 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
326 |
T tmp; // Allocate temporary dummy metadata object to get to the original vtable. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
327 |
int n = info->vtable_size(); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
328 |
intptr_t* srcvtable = vtable_of(tmp); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
329 |
intptr_t* dstvtable = info->cloned_vtable(); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
330 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
331 |
// We already checked (and, if necessary, adjusted n) when the vtables were allocated, so we are |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
332 |
// safe to do memcpy. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
333 |
if (PrintSharedSpaces) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
334 |
tty->print_cr("Copying %3d vtable entries for %s", n, name); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
335 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
336 |
memcpy(dstvtable, srcvtable, sizeof(intptr_t) * n); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
337 |
return dstvtable + n; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
338 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
339 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
340 |
// To determine the size of the vtable for each type, we use the following |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
341 |
// trick by declaring 2 subclasses: |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
342 |
// |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
343 |
// class CppVtableTesterA: public InstanceKlass {virtual int last_virtual_method() {return 1;} }; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
344 |
// class CppVtableTesterB: public InstanceKlass {virtual void* last_virtual_method() {return NULL}; }; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
345 |
// |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
346 |
// CppVtableTesterA and CppVtableTesterB's vtables have the following properties: |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
347 |
// - Their size (N+1) is exactly one more than the size of InstanceKlass's vtable (N) |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
348 |
// - The first N entries have are exactly the same as in InstanceKlass's vtable. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
349 |
// - Their last entry is different. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
350 |
// |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
351 |
// So to determine the value of N, we just walk CppVtableTesterA and CppVtableTesterB's tables |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
352 |
// and find the first entry that's different. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
353 |
// |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
354 |
// This works on all C++ compilers supported by Oracle, but you may need to tweak it for more |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
355 |
// esoteric compilers. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
356 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
357 |
template <class T> class CppVtableTesterB: public T { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
358 |
public: |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
359 |
virtual int last_virtual_method() {return 1;} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
360 |
}; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
361 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
362 |
template <class T> class CppVtableTesterA : public T { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
363 |
public: |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
364 |
virtual void* last_virtual_method() { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
365 |
// Make this different than CppVtableTesterB::last_virtual_method so the C++ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
366 |
// compiler/linker won't alias the two functions. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
367 |
return NULL; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
368 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
369 |
}; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
370 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
371 |
template <class T> |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
372 |
int CppVtableCloner<T>::get_vtable_length(const char* name) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
373 |
CppVtableTesterA<T> a; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
374 |
CppVtableTesterB<T> b; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
375 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
376 |
intptr_t* avtable = vtable_of(a); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
377 |
intptr_t* bvtable = vtable_of(b); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
378 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
379 |
// Start at slot 1, because slot 0 may be RTTI (on Solaris/Sparc) |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
380 |
int vtable_len = 1; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
381 |
for (; ; vtable_len++) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
382 |
if (avtable[vtable_len] != bvtable[vtable_len]) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
383 |
break; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
384 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
385 |
} |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
386 |
if (PrintSharedSpaces) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
387 |
tty->print_cr("Found %3d vtable entries for %s", vtable_len, name); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
388 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
389 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
390 |
return vtable_len; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
391 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
392 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
393 |
#define ALLOC_CPP_VTABLE_CLONE(c) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
394 |
top = CppVtableCloner<c>::allocate(#c, top, end); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
395 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
396 |
#define CLONE_CPP_VTABLE(c) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
397 |
p = CppVtableCloner<c>::clone_vtable(#c, (CppVtableInfo*)p); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
398 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
399 |
#define ZERO_CPP_VTABLE(c) \ |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
400 |
CppVtableCloner<c>::zero_vtable_clone(); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
401 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
402 |
// This can be called at both dump time and run time. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
403 |
intptr_t* MetaspaceShared::clone_cpp_vtables(intptr_t* p) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
404 |
assert(DumpSharedSpaces || UseSharedSpaces, "sanity"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
405 |
CPP_VTABLE_PATCH_TYPES_DO(CLONE_CPP_VTABLE); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
406 |
return p; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
407 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
408 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
409 |
void MetaspaceShared::zero_cpp_vtable_clones_for_writing() { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
410 |
assert(DumpSharedSpaces, "dump-time only"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
411 |
CPP_VTABLE_PATCH_TYPES_DO(ZERO_CPP_VTABLE); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
412 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
413 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
414 |
// Allocate and initialize the C++ vtables, starting from top, but do not go past end. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
415 |
intptr_t* MetaspaceShared::allocate_cpp_vtable_clones(intptr_t* top, intptr_t* end) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
416 |
assert(DumpSharedSpaces, "dump-time only"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
417 |
// Layout (each slot is a intptr_t): |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
418 |
// [number of slots in the first vtable = n1] |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
419 |
// [ <n1> slots for the first vtable] |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
420 |
// [number of slots in the first second = n2] |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
421 |
// [ <n2> slots for the second vtable] |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
422 |
// ... |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
423 |
// The order of the vtables is the same as the CPP_VTAB_PATCH_TYPES_DO macro. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
424 |
CPP_VTABLE_PATCH_TYPES_DO(ALLOC_CPP_VTABLE_CLONE); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
425 |
return top; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
426 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
427 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
428 |
// Switch the vtable pointer to point to the cloned vtable. We assume the |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
429 |
// vtable pointer is in first slot in object. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
430 |
void MetaspaceShared::patch_cpp_vtable_pointers() { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
431 |
int n = _global_klass_objects->length(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
432 |
for (int i = 0; i < n; i++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
433 |
Klass* obj = _global_klass_objects->at(i); |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
434 |
if (obj->is_instance_klass()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
435 |
InstanceKlass* ik = InstanceKlass::cast(obj); |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
436 |
if (ik->is_class_loader_instance_klass()) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
437 |
CppVtableCloner<InstanceClassLoaderKlass>::patch(ik); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
438 |
} else if (ik->is_reference_instance_klass()) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
439 |
CppVtableCloner<InstanceRefKlass>::patch(ik); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
440 |
} else if (ik->is_mirror_instance_klass()) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
441 |
CppVtableCloner<InstanceMirrorKlass>::patch(ik); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
442 |
} else { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
443 |
CppVtableCloner<InstanceKlass>::patch(ik); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
444 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
445 |
ConstantPool* cp = ik->constants(); |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
446 |
CppVtableCloner<ConstantPool>::patch(cp); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
447 |
for (int j = 0; j < ik->methods()->length(); j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
448 |
Method* m = ik->methods()->at(j); |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
449 |
CppVtableCloner<Method>::patch(m); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
450 |
assert(CppVtableCloner<Method>::is_valid_shared_object(m), "must be"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
451 |
} |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
452 |
} else if (obj->is_objArray_klass()) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
453 |
CppVtableCloner<ObjArrayKlass>::patch(obj); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
454 |
} else { |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
455 |
assert(obj->is_typeArray_klass(), "sanity"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
456 |
CppVtableCloner<TypeArrayKlass>::patch(obj); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
457 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
458 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
459 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
460 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
461 |
bool MetaspaceShared::is_valid_shared_method(const Method* m) { |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
462 |
assert(is_in_shared_space(m), "must be"); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
463 |
return CppVtableCloner<Method>::is_valid_shared_object(m); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
464 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
465 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
466 |
// Closure for serializing initialization data out to a data area to be |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
467 |
// written to the shared file. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
468 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
469 |
class WriteClosure : public SerializeClosure { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
470 |
private: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
471 |
intptr_t* top; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
472 |
char* end; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
473 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
474 |
inline void check_space() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
475 |
if ((char*)top + sizeof(intptr_t) > end) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
476 |
report_out_of_shared_space(SharedMiscData); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
477 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
478 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
479 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
480 |
public: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
481 |
WriteClosure(char* md_top, char* md_end) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
482 |
top = (intptr_t*)md_top; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
483 |
end = md_end; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
484 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
485 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
486 |
char* get_top() { return (char*)top; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
487 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
488 |
void do_ptr(void** p) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
489 |
check_space(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
490 |
*top = (intptr_t)*p; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
491 |
++top; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
492 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
493 |
|
37995 | 494 |
void do_u4(u4* p) { |
495 |
void* ptr = (void*)(uintx(*p)); |
|
496 |
do_ptr(&ptr); |
|
497 |
} |
|
498 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
499 |
void do_tag(int tag) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
500 |
check_space(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
501 |
*top = (intptr_t)tag; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
502 |
++top; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
503 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
504 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
505 |
void do_region(u_char* start, size_t size) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
506 |
if ((char*)top + size > end) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
507 |
report_out_of_shared_space(SharedMiscData); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
508 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
509 |
assert((intptr_t)start % sizeof(intptr_t) == 0, "bad alignment"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
510 |
assert(size % sizeof(intptr_t) == 0, "bad size"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
511 |
do_tag((int)size); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
512 |
while (size > 0) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
513 |
*top = *(intptr_t*)start; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
514 |
++top; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
515 |
start += sizeof(intptr_t); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
516 |
size -= sizeof(intptr_t); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
517 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
518 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
519 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
520 |
bool reading() const { return false; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
521 |
}; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
522 |
|
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
523 |
// This is for dumping detailed statistics for the allocations |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
524 |
// in the shared spaces. |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
525 |
class DumpAllocClosure : public Metaspace::AllocRecordClosure { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
526 |
public: |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
527 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
528 |
// Here's poor man's enum inheritance |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
529 |
#define SHAREDSPACE_OBJ_TYPES_DO(f) \ |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
530 |
METASPACE_OBJ_TYPES_DO(f) \ |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
531 |
f(SymbolHashentry) \ |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
532 |
f(SymbolBucket) \ |
37995 | 533 |
f(StringHashentry) \ |
534 |
f(StringBucket) \ |
|
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
535 |
f(Other) |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
536 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
537 |
#define SHAREDSPACE_OBJ_TYPE_DECLARE(name) name ## Type, |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
538 |
#define SHAREDSPACE_OBJ_TYPE_NAME_CASE(name) case name ## Type: return #name; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
539 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
540 |
enum Type { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
541 |
// Types are MetaspaceObj::ClassType, MetaspaceObj::SymbolType, etc |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
542 |
SHAREDSPACE_OBJ_TYPES_DO(SHAREDSPACE_OBJ_TYPE_DECLARE) |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
543 |
_number_of_types |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
544 |
}; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
545 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
546 |
static const char * type_name(Type type) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
547 |
switch(type) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
548 |
SHAREDSPACE_OBJ_TYPES_DO(SHAREDSPACE_OBJ_TYPE_NAME_CASE) |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
549 |
default: |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
550 |
ShouldNotReachHere(); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
551 |
return NULL; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
552 |
} |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
553 |
} |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
554 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
555 |
public: |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
556 |
enum { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
557 |
RO = 0, |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
558 |
RW = 1 |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
559 |
}; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
560 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
561 |
int _counts[2][_number_of_types]; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
562 |
int _bytes [2][_number_of_types]; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
563 |
int _which; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
564 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
565 |
DumpAllocClosure() { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
566 |
memset(_counts, 0, sizeof(_counts)); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
567 |
memset(_bytes, 0, sizeof(_bytes)); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
568 |
}; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
569 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
570 |
void iterate_metaspace(Metaspace* space, int which) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
571 |
assert(which == RO || which == RW, "sanity"); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
572 |
_which = which; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
573 |
space->iterate(this); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
574 |
} |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
575 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
576 |
virtual void doit(address ptr, MetaspaceObj::Type type, int byte_size) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
577 |
assert(int(type) >= 0 && type < MetaspaceObj::_number_of_types, "sanity"); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
578 |
_counts[_which][type] ++; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
579 |
_bytes [_which][type] += byte_size; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
580 |
} |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
581 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
582 |
void dump_stats(int ro_all, int rw_all, int md_all, int mc_all); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
583 |
}; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
584 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
585 |
void DumpAllocClosure::dump_stats(int ro_all, int rw_all, int md_all, int mc_all) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
586 |
rw_all += (md_all + mc_all); // md and mc are all mapped Read/Write |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
587 |
int other_bytes = md_all + mc_all; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
588 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
589 |
// Calculate size of data that was not allocated by Metaspace::allocate() |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
590 |
MetaspaceSharedStats *stats = MetaspaceShared::stats(); |
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
591 |
|
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
592 |
// symbols |
37995 | 593 |
_counts[RO][SymbolHashentryType] = stats->symbol.hashentry_count; |
594 |
_bytes [RO][SymbolHashentryType] = stats->symbol.hashentry_bytes; |
|
595 |
_bytes [RO][TypeArrayU4Type] -= stats->symbol.hashentry_bytes; |
|
596 |
||
597 |
_counts[RO][SymbolBucketType] = stats->symbol.bucket_count; |
|
598 |
_bytes [RO][SymbolBucketType] = stats->symbol.bucket_bytes; |
|
599 |
_bytes [RO][TypeArrayU4Type] -= stats->symbol.bucket_bytes; |
|
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
600 |
|
37995 | 601 |
// strings |
602 |
_counts[RO][StringHashentryType] = stats->string.hashentry_count; |
|
603 |
_bytes [RO][StringHashentryType] = stats->string.hashentry_bytes; |
|
604 |
_bytes [RO][TypeArrayU4Type] -= stats->string.hashentry_bytes; |
|
605 |
||
606 |
_counts[RO][StringBucketType] = stats->string.bucket_count; |
|
607 |
_bytes [RO][StringBucketType] = stats->string.bucket_bytes; |
|
608 |
_bytes [RO][TypeArrayU4Type] -= stats->string.bucket_bytes; |
|
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
609 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
610 |
// TODO: count things like dictionary, vtable, etc |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
611 |
_bytes[RW][OtherType] = other_bytes; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
612 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
613 |
// prevent divide-by-zero |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
614 |
if (ro_all < 1) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
615 |
ro_all = 1; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
616 |
} |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
617 |
if (rw_all < 1) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
618 |
rw_all = 1; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
619 |
} |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
620 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
621 |
int all_ro_count = 0; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
622 |
int all_ro_bytes = 0; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
623 |
int all_rw_count = 0; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
624 |
int all_rw_bytes = 0; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
625 |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
626 |
// To make fmt_stats be a syntactic constant (for format warnings), use #define. |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
627 |
#define fmt_stats "%-20s: %8d %10d %5.1f | %8d %10d %5.1f | %8d %10d %5.1f" |
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
628 |
const char *sep = "--------------------+---------------------------+---------------------------+--------------------------"; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
629 |
const char *hdr = " ro_cnt ro_bytes % | rw_cnt rw_bytes % | all_cnt all_bytes %"; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
630 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
631 |
tty->print_cr("Detailed metadata info (rw includes md and mc):"); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
632 |
tty->print_cr("%s", hdr); |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
633 |
tty->print_cr("%s", sep); |
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
634 |
for (int type = 0; type < int(_number_of_types); type ++) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
635 |
const char *name = type_name((Type)type); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
636 |
int ro_count = _counts[RO][type]; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
637 |
int ro_bytes = _bytes [RO][type]; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
638 |
int rw_count = _counts[RW][type]; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
639 |
int rw_bytes = _bytes [RW][type]; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
640 |
int count = ro_count + rw_count; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
641 |
int bytes = ro_bytes + rw_bytes; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
642 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
643 |
double ro_perc = 100.0 * double(ro_bytes) / double(ro_all); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
644 |
double rw_perc = 100.0 * double(rw_bytes) / double(rw_all); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
645 |
double perc = 100.0 * double(bytes) / double(ro_all + rw_all); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
646 |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
647 |
tty->print_cr(fmt_stats, name, |
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
648 |
ro_count, ro_bytes, ro_perc, |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
649 |
rw_count, rw_bytes, rw_perc, |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
650 |
count, bytes, perc); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
651 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
652 |
all_ro_count += ro_count; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
653 |
all_ro_bytes += ro_bytes; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
654 |
all_rw_count += rw_count; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
655 |
all_rw_bytes += rw_bytes; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
656 |
} |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
657 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
658 |
int all_count = all_ro_count + all_rw_count; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
659 |
int all_bytes = all_ro_bytes + all_rw_bytes; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
660 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
661 |
double all_ro_perc = 100.0 * double(all_ro_bytes) / double(ro_all); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
662 |
double all_rw_perc = 100.0 * double(all_rw_bytes) / double(rw_all); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
663 |
double all_perc = 100.0 * double(all_bytes) / double(ro_all + rw_all); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
664 |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
665 |
tty->print_cr("%s", sep); |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
666 |
tty->print_cr(fmt_stats, "Total", |
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
667 |
all_ro_count, all_ro_bytes, all_ro_perc, |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
668 |
all_rw_count, all_rw_bytes, all_rw_perc, |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
669 |
all_count, all_bytes, all_perc); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
670 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
671 |
assert(all_ro_bytes == ro_all, "everything should have been counted"); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
672 |
assert(all_rw_bytes == rw_all, "everything should have been counted"); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
673 |
#undef fmt_stats |
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
674 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
675 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
676 |
// Populate the shared space. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
677 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
678 |
class VM_PopulateDumpSharedSpace: public VM_Operation { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
679 |
private: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
680 |
ClassLoaderData* _loader_data; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
681 |
GrowableArray<Klass*> *_class_promote_order; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
682 |
VirtualSpace _md_vs; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
683 |
VirtualSpace _mc_vs; |
41182 | 684 |
VirtualSpace _od_vs; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
685 |
GrowableArray<MemRegion> *_string_regions; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
686 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
687 |
public: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
688 |
VM_PopulateDumpSharedSpace(ClassLoaderData* loader_data, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
689 |
GrowableArray<Klass*> *class_promote_order) : |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
690 |
_loader_data(loader_data) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
691 |
_class_promote_order = class_promote_order; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
692 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
693 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
694 |
VMOp_Type type() const { return VMOp_PopulateDumpSharedSpace; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
695 |
void doit(); // outline because gdb sucks |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
696 |
|
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
697 |
private: |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
698 |
void handle_misc_data_space_failure(bool success) { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
699 |
if (!success) { |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
700 |
report_out_of_shared_space(SharedMiscData); |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
701 |
} |
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
702 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
703 |
}; // class VM_PopulateDumpSharedSpace |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
704 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
705 |
void VM_PopulateDumpSharedSpace::doit() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
706 |
Thread* THREAD = VMThread::vm_thread(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
707 |
NOT_PRODUCT(SystemDictionary::verify();) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
708 |
// The following guarantee is meant to ensure that no loader constraints |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
709 |
// exist yet, since the constraints table is not shared. This becomes |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
710 |
// more important now that we don't re-initialize vtables/itables for |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
711 |
// shared classes at runtime, where constraints were previously created. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
712 |
guarantee(SystemDictionary::constraints()->number_of_entries() == 0, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
713 |
"loader constraints are not saved"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
714 |
guarantee(SystemDictionary::placeholders()->number_of_entries() == 0, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
715 |
"placeholders are not saved"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
716 |
// Revisit and implement this if we prelink method handle call sites: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
717 |
guarantee(SystemDictionary::invoke_method_table() == NULL || |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
718 |
SystemDictionary::invoke_method_table()->number_of_entries() == 0, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
719 |
"invoke method table is not saved"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
720 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
721 |
// At this point, many classes have been loaded. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
722 |
// Gather systemDictionary classes in a global array and do everything to |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
723 |
// that so we don't have to walk the SystemDictionary again. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
724 |
_global_klass_objects = new GrowableArray<Klass*>(1000); |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
725 |
CollectClassesClosure collect_classes; |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
726 |
ClassLoaderDataGraph::loaded_classes_do(&collect_classes); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
727 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
728 |
tty->print_cr("Number of classes %d", _global_klass_objects->length()); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
729 |
{ |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
730 |
int num_type_array = 0, num_obj_array = 0, num_inst = 0; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
731 |
for (int i = 0; i < _global_klass_objects->length(); i++) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
732 |
Klass* k = _global_klass_objects->at(i); |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
733 |
if (k->is_instance_klass()) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
734 |
num_inst ++; |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
735 |
} else if (k->is_objArray_klass()) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
736 |
num_obj_array ++; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
737 |
} else { |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
738 |
assert(k->is_typeArray_klass(), "sanity"); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
739 |
num_type_array ++; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
740 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
741 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
742 |
tty->print_cr(" instance classes = %5d", num_inst); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
743 |
tty->print_cr(" obj array classes = %5d", num_obj_array); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
744 |
tty->print_cr(" type array classes = %5d", num_type_array); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
745 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
746 |
|
30117
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
747 |
|
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
748 |
// Ensure the ConstMethods won't be modified at run-time |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
749 |
tty->print("Updating ConstMethods ... "); |
cce2cdac56dc
8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents:
28363
diff
changeset
|
750 |
rewrite_nofast_bytecodes_and_calculate_fingerprints(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
751 |
tty->print_cr("done. "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
752 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
753 |
// Remove all references outside the metadata |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
754 |
tty->print("Removing unshareable information ... "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
755 |
remove_unshareable_in_classes(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
756 |
tty->print_cr("done. "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
757 |
|
41182 | 758 |
// Set up the misc data, misc code and optional data segments. |
35231 | 759 |
_md_vs = *MetaspaceShared::misc_data_region()->virtual_space(); |
760 |
_mc_vs = *MetaspaceShared::misc_code_region()->virtual_space(); |
|
41182 | 761 |
_od_vs = *MetaspaceShared::optional_data_region()->virtual_space(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
762 |
char* md_low = _md_vs.low(); |
35231 | 763 |
char* md_top = MetaspaceShared::misc_data_region()->alloc_top(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
764 |
char* md_end = _md_vs.high(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
765 |
char* mc_low = _mc_vs.low(); |
35231 | 766 |
char* mc_top = MetaspaceShared::misc_code_region()->alloc_top(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
767 |
char* mc_end = _mc_vs.high(); |
41182 | 768 |
char* od_low = _od_vs.low(); |
769 |
char* od_top = MetaspaceShared::optional_data_region()->alloc_top(); |
|
770 |
char* od_end = _od_vs.high(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
771 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
772 |
char* vtbl_list = md_top; |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
773 |
md_top = (char*)MetaspaceShared::allocate_cpp_vtable_clones((intptr_t*)md_top, (intptr_t*)md_end); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
774 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
775 |
// We don't use MC section anymore. We will remove it in a future RFE. For now, put one |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
776 |
// byte inside so the region writing/mapping code works. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
777 |
mc_top ++; |
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
778 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
779 |
// Reorder the system dictionary. (Moving the symbols affects |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
780 |
// how the hash table indices are calculated.) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
781 |
// Not doing this either. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
782 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
783 |
SystemDictionary::reorder_dictionary(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
784 |
NOT_PRODUCT(SystemDictionary::verify();) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
785 |
SystemDictionary::copy_buckets(&md_top, md_end); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
786 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
787 |
SystemDictionary::copy_table(&md_top, md_end); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
788 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
789 |
// Write the other data to the output array. |
37995 | 790 |
// SymbolTable, StringTable and extra information for system dictionary |
791 |
NOT_PRODUCT(SymbolTable::verify()); |
|
792 |
NOT_PRODUCT(StringTable::verify()); |
|
793 |
size_t ss_bytes = 0; |
|
794 |
char* ss_low; |
|
795 |
// The string space has maximum two regions. See FileMapInfo::write_string_regions() for details. |
|
796 |
_string_regions = new GrowableArray<MemRegion>(2); |
|
797 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
798 |
WriteClosure wc(md_top, md_end); |
37995 | 799 |
MetaspaceShared::serialize(&wc, _string_regions, &ss_bytes); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
800 |
md_top = wc.get_top(); |
37995 | 801 |
ss_low = _string_regions->is_empty() ? NULL : (char*)_string_regions->first().start(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
802 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
803 |
// Print shared spaces all the time |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
804 |
Metaspace* ro_space = _loader_data->ro_metaspace(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
805 |
Metaspace* rw_space = _loader_data->rw_metaspace(); |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
806 |
|
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
807 |
// Allocated size of each space (may not be all occupied) |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
15197
diff
changeset
|
808 |
const size_t ro_alloced = ro_space->capacity_bytes_slow(Metaspace::NonClassType); |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
15197
diff
changeset
|
809 |
const size_t rw_alloced = rw_space->capacity_bytes_slow(Metaspace::NonClassType); |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
810 |
const size_t md_alloced = md_end-md_low; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
811 |
const size_t mc_alloced = mc_end-mc_low; |
41182 | 812 |
const size_t od_alloced = od_end-od_low; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
813 |
const size_t total_alloced = ro_alloced + rw_alloced + md_alloced + mc_alloced |
41182 | 814 |
+ ss_bytes + od_alloced; |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
815 |
|
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
816 |
// Occupied size of each space. |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
15197
diff
changeset
|
817 |
const size_t ro_bytes = ro_space->used_bytes_slow(Metaspace::NonClassType); |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
15197
diff
changeset
|
818 |
const size_t rw_bytes = rw_space->used_bytes_slow(Metaspace::NonClassType); |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
819 |
const size_t md_bytes = size_t(md_top - md_low); |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
820 |
const size_t mc_bytes = size_t(mc_top - mc_low); |
41182 | 821 |
const size_t od_bytes = size_t(od_top - od_low); |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
822 |
|
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
823 |
// Percent of total size |
41182 | 824 |
const size_t total_bytes = ro_bytes + rw_bytes + md_bytes + mc_bytes + ss_bytes + od_bytes; |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
825 |
const double ro_t_perc = ro_bytes / double(total_bytes) * 100.0; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
826 |
const double rw_t_perc = rw_bytes / double(total_bytes) * 100.0; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
827 |
const double md_t_perc = md_bytes / double(total_bytes) * 100.0; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
828 |
const double mc_t_perc = mc_bytes / double(total_bytes) * 100.0; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
829 |
const double ss_t_perc = ss_bytes / double(total_bytes) * 100.0; |
41182 | 830 |
const double od_t_perc = od_bytes / double(total_bytes) * 100.0; |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
831 |
|
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
832 |
// Percent of fullness of each space |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
833 |
const double ro_u_perc = ro_bytes / double(ro_alloced) * 100.0; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
834 |
const double rw_u_perc = rw_bytes / double(rw_alloced) * 100.0; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
835 |
const double md_u_perc = md_bytes / double(md_alloced) * 100.0; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
836 |
const double mc_u_perc = mc_bytes / double(mc_alloced) * 100.0; |
41182 | 837 |
const double od_u_perc = od_bytes / double(od_alloced) * 100.0; |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
838 |
const double total_u_perc = total_bytes / double(total_alloced) * 100.0; |
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
839 |
|
37995 | 840 |
#define fmt_space "%s space: " SIZE_FORMAT_W(9) " [ %4.1f%% of total] out of " SIZE_FORMAT_W(9) " bytes [%5.1f%% used] at " INTPTR_FORMAT |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
31362
diff
changeset
|
841 |
tty->print_cr(fmt_space, "ro", ro_bytes, ro_t_perc, ro_alloced, ro_u_perc, p2i(ro_space->bottom())); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
31362
diff
changeset
|
842 |
tty->print_cr(fmt_space, "rw", rw_bytes, rw_t_perc, rw_alloced, rw_u_perc, p2i(rw_space->bottom())); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
31362
diff
changeset
|
843 |
tty->print_cr(fmt_space, "md", md_bytes, md_t_perc, md_alloced, md_u_perc, p2i(md_low)); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
31362
diff
changeset
|
844 |
tty->print_cr(fmt_space, "mc", mc_bytes, mc_t_perc, mc_alloced, mc_u_perc, p2i(mc_low)); |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
31362
diff
changeset
|
845 |
tty->print_cr(fmt_space, "st", ss_bytes, ss_t_perc, ss_bytes, 100.0, p2i(ss_low)); |
41182 | 846 |
tty->print_cr(fmt_space, "od", od_bytes, od_t_perc, od_alloced, od_u_perc, p2i(od_low)); |
37995 | 847 |
tty->print_cr("total : " SIZE_FORMAT_W(9) " [100.0%% of total] out of " SIZE_FORMAT_W(9) " bytes [%5.1f%% used]", |
15197
cef3fb881307
8005467: CDS size information is incorrect and unfriendly
coleenp
parents:
15100
diff
changeset
|
848 |
total_bytes, total_alloced, total_u_perc); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
849 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
850 |
// During patching, some virtual methods may be called, so at this point |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
851 |
// the vtables must contain valid methods (as filled in by CppVtableCloner::allocate). |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
852 |
MetaspaceShared::patch_cpp_vtable_pointers(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
853 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
854 |
// The vtable clones contain addresses of the current process. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
855 |
// We don't want to write these addresses into the archive. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
856 |
MetaspaceShared::zero_cpp_vtable_clones_for_writing(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
857 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
858 |
// Create and write the archive file that maps the shared spaces. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
859 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
860 |
FileMapInfo* mapinfo = new FileMapInfo(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
861 |
mapinfo->populate_header(MetaspaceShared::max_alignment()); |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
862 |
mapinfo->set_misc_data_patching_start(vtbl_list); |
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
863 |
mapinfo->set_cds_i2i_entry_code_buffers(MetaspaceShared::cds_i2i_entry_code_buffers()); |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
864 |
mapinfo->set_cds_i2i_entry_code_buffers_size(MetaspaceShared::cds_i2i_entry_code_buffers_size()); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
865 |
|
35231 | 866 |
for (int pass=1; pass<=2; pass++) { |
867 |
if (pass == 1) { |
|
868 |
// The first pass doesn't actually write the data to disk. All it |
|
869 |
// does is to update the fields in the mapinfo->_header. |
|
870 |
} else { |
|
871 |
// After the first pass, the contents of mapinfo->_header are finalized, |
|
872 |
// so we can compute the header's CRC, and write the contents of the header |
|
873 |
// and the regions into disk. |
|
874 |
mapinfo->open_for_write(); |
|
875 |
mapinfo->set_header_crc(mapinfo->compute_header_crc()); |
|
876 |
} |
|
877 |
mapinfo->write_header(); |
|
878 |
mapinfo->write_space(MetaspaceShared::ro, _loader_data->ro_metaspace(), true); |
|
879 |
mapinfo->write_space(MetaspaceShared::rw, _loader_data->rw_metaspace(), false); |
|
880 |
mapinfo->write_region(MetaspaceShared::md, _md_vs.low(), |
|
881 |
pointer_delta(md_top, _md_vs.low(), sizeof(char)), |
|
882 |
SharedMiscDataSize, |
|
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
883 |
false, true); |
35231 | 884 |
mapinfo->write_region(MetaspaceShared::mc, _mc_vs.low(), |
885 |
pointer_delta(mc_top, _mc_vs.low(), sizeof(char)), |
|
886 |
SharedMiscCodeSize, |
|
887 |
true, true); |
|
888 |
mapinfo->write_string_regions(_string_regions); |
|
41182 | 889 |
mapinfo->write_region(MetaspaceShared::od, _od_vs.low(), |
890 |
pointer_delta(od_top, _od_vs.low(), sizeof(char)), |
|
891 |
pointer_delta(od_end, _od_vs.low(), sizeof(char)), |
|
892 |
true, false); |
|
35231 | 893 |
} |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
894 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
895 |
mapinfo->close(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
896 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
897 |
// Restore the vtable in case we invoke any virtual methods. |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
898 |
MetaspaceShared::clone_cpp_vtables((intptr_t*)vtbl_list); |
17858
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
899 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
900 |
if (PrintSharedSpaces) { |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
901 |
DumpAllocClosure dac; |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
902 |
dac.iterate_metaspace(_loader_data->ro_metaspace(), DumpAllocClosure::RO); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
903 |
dac.iterate_metaspace(_loader_data->rw_metaspace(), DumpAllocClosure::RW); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
904 |
|
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
905 |
dac.dump_stats(int(ro_bytes), int(rw_bytes), int(md_bytes), int(mc_bytes)); |
c292f8791cca
8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents:
17109
diff
changeset
|
906 |
} |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23540
diff
changeset
|
907 |
#undef fmt_space |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
908 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
909 |
|
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
910 |
class LinkSharedClassesClosure : public KlassClosure { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
911 |
Thread* THREAD; |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
912 |
bool _made_progress; |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
913 |
public: |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
914 |
LinkSharedClassesClosure(Thread* thread) : THREAD(thread), _made_progress(false) {} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
915 |
|
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
916 |
void reset() { _made_progress = false; } |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
917 |
bool made_progress() const { return _made_progress; } |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
918 |
|
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
919 |
void do_klass(Klass* k) { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
920 |
if (k->is_instance_klass()) { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
921 |
InstanceKlass* ik = InstanceKlass::cast(k); |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
922 |
// Link the class to cause the bytecodes to be rewritten and the |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
923 |
// cpcache to be created. Class verification is done according |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
924 |
// to -Xverify setting. |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
925 |
_made_progress |= MetaspaceShared::try_link_class(ik, THREAD); |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
926 |
guarantee(!HAS_PENDING_EXCEPTION, "exception in link_class"); |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
927 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
928 |
} |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
929 |
}; |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
930 |
|
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
931 |
class CheckSharedClassesClosure : public KlassClosure { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
932 |
bool _made_progress; |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
933 |
public: |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
934 |
CheckSharedClassesClosure() : _made_progress(false) {} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
935 |
|
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
936 |
void reset() { _made_progress = false; } |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
937 |
bool made_progress() const { return _made_progress; } |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
938 |
void do_klass(Klass* k) { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
939 |
if (k->is_instance_klass() && InstanceKlass::cast(k)->check_sharing_error_state()) { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
940 |
_made_progress = true; |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
941 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
942 |
} |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
943 |
}; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
944 |
|
36508 | 945 |
void MetaspaceShared::check_shared_class_loader_type(Klass* k) { |
946 |
if (k->is_instance_klass()) { |
|
947 |
InstanceKlass* ik = InstanceKlass::cast(k); |
|
948 |
u2 loader_type = ik->loader_type(); |
|
949 |
ResourceMark rm; |
|
950 |
guarantee(loader_type != 0, |
|
951 |
"Class loader type is not set for this class %s", ik->name()->as_C_string()); |
|
952 |
} |
|
953 |
} |
|
954 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
955 |
void MetaspaceShared::link_and_cleanup_shared_classes(TRAPS) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
956 |
// We need to iterate because verification may cause additional classes |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
957 |
// to be loaded. |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
958 |
LinkSharedClassesClosure link_closure(THREAD); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
959 |
do { |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
960 |
link_closure.reset(); |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
961 |
ClassLoaderDataGraph::loaded_classes_do(&link_closure); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
962 |
guarantee(!HAS_PENDING_EXCEPTION, "exception in link_class"); |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
963 |
} while (link_closure.made_progress()); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
964 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
965 |
if (_has_error_classes) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
966 |
// Mark all classes whose super class or interfaces failed verification. |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
967 |
CheckSharedClassesClosure check_closure; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
968 |
do { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
969 |
// Not completely sure if we need to do this iteratively. Anyway, |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
970 |
// we should come here only if there are unverifiable classes, which |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
971 |
// shouldn't happen in normal cases. So better safe than sorry. |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
972 |
check_closure.reset(); |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
973 |
ClassLoaderDataGraph::loaded_classes_do(&check_closure); |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
974 |
} while (check_closure.made_progress()); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
975 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
976 |
if (IgnoreUnverifiableClassesDuringDump) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
977 |
// This is useful when running JCK or SQE tests. You should not |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
978 |
// enable this when running real apps. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
979 |
SystemDictionary::remove_classes_in_error_state(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
980 |
} else { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
981 |
tty->print_cr("Please remove the unverifiable classes from your class list and try again"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
982 |
exit(1); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
983 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
984 |
} |
39713 | 985 |
|
986 |
// Copy the verification constraints from C_HEAP-alloced GrowableArrays to RO-alloced |
|
987 |
// Arrays |
|
988 |
SystemDictionaryShared::finalize_verification_constraints(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
989 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
990 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
991 |
void MetaspaceShared::prepare_for_dumping() { |
36508 | 992 |
Arguments::check_unsupported_dumping_properties(); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
993 |
ClassLoader::initialize_shared_path(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
994 |
FileMapInfo::allocate_classpath_entry_table(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
995 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
996 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
997 |
// Preload classes from a list, populate the shared spaces and dump to a |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
998 |
// file. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
999 |
void MetaspaceShared::preload_and_dump(TRAPS) { |
37161
e881f320966e
8150015: Integrate TraceTime with Unified Logging more seamlessly
rehn
parents:
37094
diff
changeset
|
1000 |
{ TraceTime timer("Dump Shared Spaces", TRACETIME_LOG(Info, startuptime)); |
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1001 |
ResourceMark rm; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1002 |
char class_list_path_str[JVM_MAXPATHLEN]; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1003 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1004 |
tty->print_cr("Allocated shared space: " SIZE_FORMAT " bytes at " PTR_FORMAT, |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1005 |
MetaspaceShared::shared_rs()->size(), |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1006 |
p2i(MetaspaceShared::shared_rs()->base())); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1007 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1008 |
// Preload classes to be shared. |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1009 |
// Should use some os:: method rather than fopen() here. aB. |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1010 |
const char* class_list_path; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1011 |
if (SharedClassListFile == NULL) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1012 |
// Construct the path to the class list (in jre/lib) |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1013 |
// Walk up two directories from the location of the VM and |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1014 |
// optionally tack on "lib" (depending on platform) |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1015 |
os::jvm_path(class_list_path_str, sizeof(class_list_path_str)); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1016 |
for (int i = 0; i < 3; i++) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1017 |
char *end = strrchr(class_list_path_str, *os::file_separator()); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1018 |
if (end != NULL) *end = '\0'; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1019 |
} |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1020 |
int class_list_path_len = (int)strlen(class_list_path_str); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1021 |
if (class_list_path_len >= 3) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1022 |
if (strcmp(class_list_path_str + class_list_path_len - 3, "lib") != 0) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1023 |
if (class_list_path_len < JVM_MAXPATHLEN - 4) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1024 |
jio_snprintf(class_list_path_str + class_list_path_len, |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1025 |
sizeof(class_list_path_str) - class_list_path_len, |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1026 |
"%slib", os::file_separator()); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1027 |
class_list_path_len += 4; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1028 |
} |
27471 | 1029 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1030 |
} |
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1031 |
if (class_list_path_len < JVM_MAXPATHLEN - 10) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1032 |
jio_snprintf(class_list_path_str + class_list_path_len, |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1033 |
sizeof(class_list_path_str) - class_list_path_len, |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1034 |
"%sclasslist", os::file_separator()); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1035 |
} |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1036 |
class_list_path = class_list_path_str; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1037 |
} else { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1038 |
class_list_path = SharedClassListFile; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1039 |
} |
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1040 |
|
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1041 |
int class_count = 0; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1042 |
GrowableArray<Klass*>* class_promote_order = new GrowableArray<Klass*>(); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1043 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1044 |
// sun.io.Converters |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1045 |
static const char obj_array_sig[] = "[[Ljava/lang/Object;"; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1046 |
SymbolTable::new_permanent_symbol(obj_array_sig, THREAD); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1047 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1048 |
// java.util.HashMap |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1049 |
static const char map_entry_array_sig[] = "[Ljava/util/Map$Entry;"; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1050 |
SymbolTable::new_permanent_symbol(map_entry_array_sig, THREAD); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1051 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1052 |
// Need to allocate the op here: |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1053 |
// op.misc_data_space_alloc() will be called during preload_and_dump(). |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1054 |
ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data(); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1055 |
VM_PopulateDumpSharedSpace op(loader_data, class_promote_order); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1056 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1057 |
tty->print_cr("Loading classes to share ..."); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1058 |
_has_error_classes = false; |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1059 |
class_count += preload_and_dump(class_list_path, class_promote_order, |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1060 |
THREAD); |
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1061 |
if (ExtraSharedClassListFile) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1062 |
class_count += preload_and_dump(ExtraSharedClassListFile, class_promote_order, |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1063 |
THREAD); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1064 |
} |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1065 |
tty->print_cr("Loading classes to share: done."); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1066 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1067 |
if (PrintSharedSpaces) { |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1068 |
tty->print_cr("Shared spaces: preloaded %d classes", class_count); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1069 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1070 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1071 |
// Rewrite and link classes |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1072 |
tty->print_cr("Rewriting and linking classes ..."); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1073 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1074 |
// Link any classes which got missed. This would happen if we have loaded classes that |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1075 |
// were not explicitly specified in the classlist. E.g., if an interface implemented by class K |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1076 |
// fails verification, all other interfaces that were not specified in the classlist but |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1077 |
// are implemented by K are not verified. |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1078 |
link_and_cleanup_shared_classes(CATCH); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1079 |
tty->print_cr("Rewriting and linking classes: done"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1080 |
|
36178
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1081 |
VMThread::execute(&op); |
9739f8c767da
8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents:
35231
diff
changeset
|
1082 |
} |
46464
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
1083 |
|
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
1084 |
if (PrintSystemDictionaryAtExit) { |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
1085 |
SystemDictionary::print(); |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
1086 |
} |
6432a858a220
8180325: Use ClassLoaderData::classes_do for CDS classes
coleenp
parents:
46435
diff
changeset
|
1087 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1088 |
// Since various initialization steps have been undone by this process, |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1089 |
// it is not reasonable to continue running a java process. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1090 |
exit(0); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1091 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1092 |
|
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1093 |
|
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1094 |
int MetaspaceShared::preload_and_dump(const char* class_list_path, |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1095 |
GrowableArray<Klass*>* class_promote_order, |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1096 |
TRAPS) { |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1097 |
ClassListParser parser(class_list_path); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1098 |
int class_count = 0; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1099 |
|
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1100 |
while (parser.parse_one_line()) { |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1101 |
Klass* klass = ClassLoaderExt::load_one_class(&parser, THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1102 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1103 |
CLEAR_PENDING_EXCEPTION; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1104 |
if (klass != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1105 |
if (PrintSharedSpaces && Verbose && WizardMode) { |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1106 |
ResourceMark rm; |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1107 |
tty->print_cr("Shared spaces preloaded: %s", klass->external_name()); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1108 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1109 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1110 |
InstanceKlass* ik = InstanceKlass::cast(klass); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1111 |
|
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
37995
diff
changeset
|
1112 |
// Should be class load order as per -Xlog:class+preorder |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1113 |
class_promote_order->append(ik); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1114 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1115 |
// Link the class to cause the bytecodes to be rewritten and the |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1116 |
// cpcache to be created. The linking is done as soon as classes |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1117 |
// are loaded in order that the related data structures (klass and |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1118 |
// cpCache) are located together. |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1119 |
try_link_class(ik, THREAD); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1120 |
guarantee(!HAS_PENDING_EXCEPTION, "exception in link_class"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1121 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1122 |
class_count++; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1123 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1124 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1125 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1126 |
return class_count; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1127 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1128 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1129 |
// Returns true if the class's status has changed |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1130 |
bool MetaspaceShared::try_link_class(InstanceKlass* ik, TRAPS) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1131 |
assert(DumpSharedSpaces, "should only be called during dumping"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1132 |
if (ik->init_state() < InstanceKlass::linked) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1133 |
bool saved = BytecodeVerificationLocal; |
36508 | 1134 |
if (!(ik->is_shared_boot_class())) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1135 |
// The verification decision is based on BytecodeVerificationRemote |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1136 |
// for non-system classes. Since we are using the NULL classloader |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1137 |
// to load non-system classes during dumping, we need to temporarily |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1138 |
// change BytecodeVerificationLocal to be the same as |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1139 |
// BytecodeVerificationRemote. Note this can cause the parent system |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1140 |
// classes also being verified. The extra overhead is acceptable during |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1141 |
// dumping. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1142 |
BytecodeVerificationLocal = BytecodeVerificationRemote; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1143 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1144 |
ik->link_class(THREAD); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1145 |
if (HAS_PENDING_EXCEPTION) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1146 |
ResourceMark rm; |
27618
790a8bf5488b
8064375: Change certain errors to warnings in CDS output.
jiangli
parents:
27025
diff
changeset
|
1147 |
tty->print_cr("Preload Warning: Verification failed for %s", |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1148 |
ik->external_name()); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1149 |
CLEAR_PENDING_EXCEPTION; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1150 |
ik->set_in_error_state(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1151 |
_has_error_classes = true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1152 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1153 |
BytecodeVerificationLocal = saved; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1154 |
return true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1155 |
} else { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1156 |
return false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1157 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1158 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1159 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1160 |
// Closure for serializing initialization data in from a data area |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1161 |
// (ptr_array) read from the shared file. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1162 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1163 |
class ReadClosure : public SerializeClosure { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1164 |
private: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1165 |
intptr_t** _ptr_array; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1166 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1167 |
inline intptr_t nextPtr() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1168 |
return *(*_ptr_array)++; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1169 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1170 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1171 |
public: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1172 |
ReadClosure(intptr_t** ptr_array) { _ptr_array = ptr_array; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1173 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1174 |
void do_ptr(void** p) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1175 |
assert(*p == NULL, "initializing previous initialized pointer."); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1176 |
intptr_t obj = nextPtr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1177 |
assert((intptr_t)obj >= 0 || (intptr_t)obj < -100, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1178 |
"hit tag while initializing ptrs."); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1179 |
*p = (void*)obj; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1180 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1181 |
|
37995 | 1182 |
void do_u4(u4* p) { |
1183 |
intptr_t obj = nextPtr(); |
|
1184 |
*p = (u4)(uintx(obj)); |
|
1185 |
} |
|
1186 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1187 |
void do_tag(int tag) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1188 |
int old_tag; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1189 |
old_tag = (int)(intptr_t)nextPtr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1190 |
// do_int(&old_tag); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1191 |
assert(tag == old_tag, "old tag doesn't match"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1192 |
FileMapInfo::assert_mark(tag == old_tag); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1193 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1194 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1195 |
void do_region(u_char* start, size_t size) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1196 |
assert((intptr_t)start % sizeof(intptr_t) == 0, "bad alignment"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1197 |
assert(size % sizeof(intptr_t) == 0, "bad size"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1198 |
do_tag((int)size); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1199 |
while (size > 0) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1200 |
*(intptr_t*)start = nextPtr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1201 |
start += sizeof(intptr_t); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1202 |
size -= sizeof(intptr_t); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1203 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1204 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1205 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1206 |
bool reading() const { return true; } |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1207 |
}; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1208 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1209 |
// Return true if given address is in the mapped shared space. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1210 |
bool MetaspaceShared::is_in_shared_space(const void* p) { |
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1211 |
return UseSharedSpaces && FileMapInfo::current_info()->is_in_shared_space(p); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1212 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1213 |
|
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
1214 |
// Return true if given address is in the misc data region |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
1215 |
bool MetaspaceShared::is_in_shared_region(const void* p, int idx) { |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
1216 |
return UseSharedSpaces && FileMapInfo::current_info()->is_in_shared_region(p, idx); |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
1217 |
} |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
1218 |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1219 |
bool MetaspaceShared::is_string_region(int idx) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1220 |
return (idx >= MetaspaceShared::first_string && |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1221 |
idx < MetaspaceShared::first_string + MetaspaceShared::max_strings); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1222 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1223 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1224 |
void MetaspaceShared::print_shared_spaces() { |
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1225 |
if (UseSharedSpaces) { |
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1226 |
FileMapInfo::current_info()->print_shared_spaces(); |
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1227 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1228 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1229 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1230 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1231 |
// Map shared spaces at requested addresses and return if succeeded. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1232 |
bool MetaspaceShared::map_shared_spaces(FileMapInfo* mapinfo) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1233 |
size_t image_alignment = mapinfo->alignment(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1234 |
|
15100
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1235 |
#ifndef _WINDOWS |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1236 |
// Map in the shared memory and then map the regions on top of it. |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1237 |
// On Windows, don't map the memory here because it will cause the |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1238 |
// mappings of the regions to fail. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1239 |
ReservedSpace shared_rs = mapinfo->reserve_shared_memory(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1240 |
if (!shared_rs.is_reserved()) return false; |
15100
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1241 |
#endif |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1242 |
|
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1243 |
assert(!DumpSharedSpaces, "Should not be called with DumpSharedSpaces"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1244 |
|
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1245 |
char* _ro_base = NULL; |
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1246 |
char* _rw_base = NULL; |
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1247 |
char* _md_base = NULL; |
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1248 |
char* _mc_base = NULL; |
41182 | 1249 |
char* _od_base = NULL; |
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17858
diff
changeset
|
1250 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1251 |
// Map each shared region |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1252 |
if ((_ro_base = mapinfo->map_region(ro)) != NULL && |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1253 |
mapinfo->verify_region_checksum(ro) && |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1254 |
(_rw_base = mapinfo->map_region(rw)) != NULL && |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1255 |
mapinfo->verify_region_checksum(rw) && |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1256 |
(_md_base = mapinfo->map_region(md)) != NULL && |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1257 |
mapinfo->verify_region_checksum(md) && |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1258 |
(_mc_base = mapinfo->map_region(mc)) != NULL && |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1259 |
mapinfo->verify_region_checksum(mc) && |
41182 | 1260 |
(_od_base = mapinfo->map_region(od)) != NULL && |
1261 |
mapinfo->verify_region_checksum(od) && |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1262 |
(image_alignment == (size_t)max_alignment()) && |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1263 |
mapinfo->validate_classpath_entry_table()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1264 |
// Success (no need to do anything) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1265 |
return true; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1266 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1267 |
// If there was a failure in mapping any of the spaces, unmap the ones |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1268 |
// that succeeded |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1269 |
if (_ro_base != NULL) mapinfo->unmap_region(ro); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1270 |
if (_rw_base != NULL) mapinfo->unmap_region(rw); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1271 |
if (_md_base != NULL) mapinfo->unmap_region(md); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1272 |
if (_mc_base != NULL) mapinfo->unmap_region(mc); |
41182 | 1273 |
if (_od_base != NULL) mapinfo->unmap_region(od); |
15100
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1274 |
#ifndef _WINDOWS |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1275 |
// Release the entire mapped region |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1276 |
shared_rs.release(); |
15100
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14488
diff
changeset
|
1277 |
#endif |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1278 |
// If -Xshare:on is specified, print out the error message and exit VM, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1279 |
// otherwise, set UseSharedSpaces to false and continue. |
28017
84009002b566
8066670: PrintSharedArchiveAndExit does not exit the VM when the archive is invalid
iklam
parents:
27619
diff
changeset
|
1280 |
if (RequireSharedSpaces || PrintSharedArchiveAndExit) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1281 |
vm_exit_during_initialization("Unable to use shared archive.", "Failed map_region for using -Xshare:on."); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1282 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1283 |
FLAG_SET_DEFAULT(UseSharedSpaces, false); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1284 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1285 |
return false; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1286 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1287 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1288 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1289 |
// Read the miscellaneous data from the shared file, and |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1290 |
// serialize it out to its various destinations. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1291 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1292 |
void MetaspaceShared::initialize_shared_spaces() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1293 |
FileMapInfo *mapinfo = FileMapInfo::current_info(); |
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
1294 |
_cds_i2i_entry_code_buffers = mapinfo->cds_i2i_entry_code_buffers(); |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37248
diff
changeset
|
1295 |
_cds_i2i_entry_code_buffers_size = mapinfo->cds_i2i_entry_code_buffers_size(); |
35231 | 1296 |
char* buffer = mapinfo->misc_data_patching_start(); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33638
diff
changeset
|
1297 |
|
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
43410
diff
changeset
|
1298 |
buffer = (char*)clone_cpp_vtables((intptr_t*)buffer); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1299 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1300 |
int sharedDictionaryLen = *(intptr_t*)buffer; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1301 |
buffer += sizeof(intptr_t); |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
1302 |
int number_of_entries = *(intptr_t*)buffer; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1303 |
buffer += sizeof(intptr_t); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1304 |
SystemDictionary::set_shared_dictionary((HashtableBucket<mtClass>*)buffer, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1305 |
sharedDictionaryLen, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1306 |
number_of_entries); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1307 |
buffer += sharedDictionaryLen; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1308 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1309 |
// The following data in the shared misc data region are the linked |
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
1310 |
// list elements (HashtableEntry objects) for the shared dictionary |
36508 | 1311 |
// table. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1312 |
|
28363
047115468f16
8059510: Compact symbol table layout inside shared archive.
jiangli
parents:
28017
diff
changeset
|
1313 |
int len = *(intptr_t*)buffer; // skip over shared dictionary entries |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1314 |
buffer += sizeof(intptr_t); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1315 |
buffer += len; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1316 |
|
37995 | 1317 |
// Verify various attributes of the archive, plus initialize the |
1318 |
// shared string/symbol tables |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1319 |
intptr_t* array = (intptr_t*)buffer; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1320 |
ReadClosure rc(&array); |
37995 | 1321 |
serialize(&rc, NULL, NULL); |
1322 |
||
1323 |
// Initialize the run-time symbol table. |
|
1324 |
SymbolTable::create_table(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1325 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1326 |
// Close the mapinfo file |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1327 |
mapinfo->close(); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1328 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1329 |
if (PrintSharedArchiveAndExit) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1330 |
if (PrintSharedDictionary) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1331 |
tty->print_cr("\nShared classes:\n"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1332 |
SystemDictionary::print_shared(false); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1333 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1334 |
if (_archive_loading_failed) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1335 |
tty->print_cr("archive is invalid"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1336 |
vm_exit(1); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1337 |
} else { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1338 |
tty->print_cr("archive is valid"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1339 |
vm_exit(0); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1340 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
1341 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1342 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1343 |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1344 |
void MetaspaceShared::fixup_shared_string_regions() { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1345 |
FileMapInfo *mapinfo = FileMapInfo::current_info(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1346 |
mapinfo->fixup_string_regions(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1347 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
30773
diff
changeset
|
1348 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1349 |
// JVM/TI RedefineClasses() support: |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1350 |
bool MetaspaceShared::remap_shared_readonly_as_readwrite() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1351 |
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1352 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1353 |
if (UseSharedSpaces) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1354 |
// remap the shared readonly space to shared readwrite, private |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1355 |
FileMapInfo* mapinfo = FileMapInfo::current_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1356 |
if (!mapinfo->remap_shared_readonly_as_readwrite()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1357 |
return false; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1358 |
} |
39714 | 1359 |
_remapped_readwrite = true; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1360 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1361 |
return true; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1362 |
} |
26304
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1363 |
|
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1364 |
int MetaspaceShared::count_class(const char* classlist_file) { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1365 |
if (classlist_file == NULL) { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1366 |
return 0; |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1367 |
} |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1368 |
char class_name[256]; |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1369 |
int class_count = 0; |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1370 |
FILE* file = fopen(classlist_file, "r"); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1371 |
if (file != NULL) { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1372 |
while ((fgets(class_name, sizeof class_name, file)) != NULL) { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1373 |
if (*class_name == '#') { // comment |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1374 |
continue; |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1375 |
} |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1376 |
class_count++; |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1377 |
} |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1378 |
fclose(file); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1379 |
} else { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1380 |
char errmsg[JVM_MAXPATHLEN]; |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1381 |
os::lasterror(errmsg, JVM_MAXPATHLEN); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1382 |
tty->print_cr("Loading classlist failed: %s", errmsg); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1383 |
exit(1); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1384 |
} |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1385 |
|
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1386 |
return class_count; |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1387 |
} |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1388 |
|
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1389 |
// the sizes are good for typical large applications that have a lot of shared |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1390 |
// classes |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1391 |
void MetaspaceShared::estimate_regions_size() { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1392 |
int class_count = count_class(SharedClassListFile); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1393 |
class_count += count_class(ExtraSharedClassListFile); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1394 |
|
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1395 |
if (class_count > LargeThresholdClassCount) { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1396 |
if (class_count < HugeThresholdClassCount) { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1397 |
SET_ESTIMATED_SIZE(Large, ReadOnly); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1398 |
SET_ESTIMATED_SIZE(Large, ReadWrite); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1399 |
SET_ESTIMATED_SIZE(Large, MiscData); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1400 |
SET_ESTIMATED_SIZE(Large, MiscCode); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1401 |
} else { |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1402 |
SET_ESTIMATED_SIZE(Huge, ReadOnly); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1403 |
SET_ESTIMATED_SIZE(Huge, ReadWrite); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1404 |
SET_ESTIMATED_SIZE(Huge, MiscData); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1405 |
SET_ESTIMATED_SIZE(Huge, MiscCode); |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1406 |
} |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1407 |
} |
a28e6335ce60
8048150: Allow easy configurations for large CDS archives
ccheung
parents:
26135
diff
changeset
|
1408 |
} |