59 #include "runtime/signature.hpp"
60 #include "runtime/timerTrace.hpp"
61 #include "runtime/vmThread.hpp"
62 #include "runtime/vm_operations.hpp"
63 #include "utilities/align.hpp"
64 #include "utilities/bitMap.hpp"
65 #include "utilities/defaultStream.hpp"
66 #include "utilities/hashtable.inline.hpp"
67 #if INCLUDE_G1GC
68 #include "gc/g1/g1Allocator.inline.hpp"
69 #include "gc/g1/g1CollectedHeap.hpp"
70 #endif
71
72 ReservedSpace MetaspaceShared::_shared_rs;
73 VirtualSpace MetaspaceShared::_shared_vs;
74 MetaspaceSharedStats MetaspaceShared::_stats;
75 bool MetaspaceShared::_has_error_classes;
76 bool MetaspaceShared::_archive_loading_failed = false;
77 bool MetaspaceShared::_remapped_readwrite = false;
78 bool MetaspaceShared::_open_archive_heap_region_mapped = false;
79 address MetaspaceShared::_cds_i2i_entry_code_buffers = NULL;
80 size_t MetaspaceShared::_cds_i2i_entry_code_buffers_size = 0;
81 size_t MetaspaceShared::_core_spaces_size = 0;
82
83 // The CDS archive is divided into the following regions:
84 // mc - misc code (the method entry trampolines)
85 // rw - read-write metadata
86 // ro - read-only metadata and read-only tables
87 // md - misc data (the c++ vtables)
88 // od - optional data (original class files)
89 //
90 // s0 - shared strings(closed archive heap space) #0
91 // s1 - shared strings(closed archive heap space) #1 (may be empty)
92 // oa0 - open archive heap space #0
93 // oa1 - open archive heap space #1 (may be empty)
94 //
95 // The mc, rw, ro, md and od regions are linearly allocated, starting from
96 // SharedBaseAddress, in the order of mc->rw->ro->md->od. The size of these 5 regions
97 // are page-aligned, and there's no gap between any consecutive regions.
98 //
1923
1924 int hash = obj->identity_hash();
1925 oop archived_oop = (oop)G1CollectedHeap::heap()->archive_mem_allocate(len);
1926 if (archived_oop != NULL) {
1927 Copy::aligned_disjoint_words((HeapWord*)obj, (HeapWord*)archived_oop, len);
1928 relocate_klass_ptr(archived_oop);
1929 ArchivedObjectCache* cache = MetaspaceShared::archive_object_cache();
1930 cache->put(obj, archived_oop);
1931 log_debug(cds, heap)("Archived heap object " PTR_FORMAT " ==> " PTR_FORMAT,
1932 p2i(obj), p2i(archived_oop));
1933 } else {
1934 log_error(cds, heap)(
1935 "Cannot allocate space for object " PTR_FORMAT " in archived heap region",
1936 p2i(obj));
1937 vm_exit(1);
1938 }
1939 return archived_oop;
1940 }
1941
1942 oop MetaspaceShared::materialize_archived_object(narrowOop v) {
1943 if (!CompressedOops::is_null(v)) {
1944 oop obj = HeapShared::decode_with_archived_oop_encoding_mode(v);
1945 return G1CollectedHeap::heap()->materialize_archived_object(obj);
1946 }
1947 return NULL;
1948 }
1949
1950 void MetaspaceShared::archive_klass_objects(Thread* THREAD) {
1951 int i;
1952 for (i = 0; i < _global_klass_objects->length(); i++) {
1953 Klass* k = _global_klass_objects->at(i);
1954
1955 // archive mirror object
1956 java_lang_Class::archive_mirror(k, CHECK);
1957
1958 // archive the resolved_referenes array
1959 if (k->is_instance_klass()) {
1960 InstanceKlass* ik = InstanceKlass::cast(k);
1961 ik->constants()->archive_resolved_references(THREAD);
1962 }
1963 }
1964 }
1965
1966 bool MetaspaceShared::is_archive_object(oop p) {
1967 return (p == NULL) ? false : G1ArchiveAllocator::is_archive_object(p);
1968 }
1969
1970 void MetaspaceShared::fixup_mapped_heap_regions() {
1971 FileMapInfo *mapinfo = FileMapInfo::current_info();
1972 mapinfo->fixup_mapped_heap_regions();
1973 }
1974 #endif // INCLUDE_CDS_JAVA_HEAP
1975
1976 // Closure for serializing initialization data in from a data area
1977 // (ptr_array) read from the shared file.
1978
1979 class ReadClosure : public SerializeClosure {
1980 private:
1981 intptr_t** _ptr_array;
1982
1983 inline intptr_t nextPtr() {
1984 return *(*_ptr_array)++;
1985 }
1986
1987 public:
1988 ReadClosure(intptr_t** ptr_array) { _ptr_array = ptr_array; }
1989
1990 void do_ptr(void** p) {
1991 assert(*p == NULL, "initializing previous initialized pointer.");
1992 intptr_t obj = nextPtr();
|
59 #include "runtime/signature.hpp"
60 #include "runtime/timerTrace.hpp"
61 #include "runtime/vmThread.hpp"
62 #include "runtime/vm_operations.hpp"
63 #include "utilities/align.hpp"
64 #include "utilities/bitMap.hpp"
65 #include "utilities/defaultStream.hpp"
66 #include "utilities/hashtable.inline.hpp"
67 #if INCLUDE_G1GC
68 #include "gc/g1/g1Allocator.inline.hpp"
69 #include "gc/g1/g1CollectedHeap.hpp"
70 #endif
71
72 ReservedSpace MetaspaceShared::_shared_rs;
73 VirtualSpace MetaspaceShared::_shared_vs;
74 MetaspaceSharedStats MetaspaceShared::_stats;
75 bool MetaspaceShared::_has_error_classes;
76 bool MetaspaceShared::_archive_loading_failed = false;
77 bool MetaspaceShared::_remapped_readwrite = false;
78 bool MetaspaceShared::_open_archive_heap_region_mapped = false;
79 bool MetaspaceShared::_archive_heap_region_fixed = false;
80 address MetaspaceShared::_cds_i2i_entry_code_buffers = NULL;
81 size_t MetaspaceShared::_cds_i2i_entry_code_buffers_size = 0;
82 size_t MetaspaceShared::_core_spaces_size = 0;
83
84 // The CDS archive is divided into the following regions:
85 // mc - misc code (the method entry trampolines)
86 // rw - read-write metadata
87 // ro - read-only metadata and read-only tables
88 // md - misc data (the c++ vtables)
89 // od - optional data (original class files)
90 //
91 // s0 - shared strings(closed archive heap space) #0
92 // s1 - shared strings(closed archive heap space) #1 (may be empty)
93 // oa0 - open archive heap space #0
94 // oa1 - open archive heap space #1 (may be empty)
95 //
96 // The mc, rw, ro, md and od regions are linearly allocated, starting from
97 // SharedBaseAddress, in the order of mc->rw->ro->md->od. The size of these 5 regions
98 // are page-aligned, and there's no gap between any consecutive regions.
99 //
1924
1925 int hash = obj->identity_hash();
1926 oop archived_oop = (oop)G1CollectedHeap::heap()->archive_mem_allocate(len);
1927 if (archived_oop != NULL) {
1928 Copy::aligned_disjoint_words((HeapWord*)obj, (HeapWord*)archived_oop, len);
1929 relocate_klass_ptr(archived_oop);
1930 ArchivedObjectCache* cache = MetaspaceShared::archive_object_cache();
1931 cache->put(obj, archived_oop);
1932 log_debug(cds, heap)("Archived heap object " PTR_FORMAT " ==> " PTR_FORMAT,
1933 p2i(obj), p2i(archived_oop));
1934 } else {
1935 log_error(cds, heap)(
1936 "Cannot allocate space for object " PTR_FORMAT " in archived heap region",
1937 p2i(obj));
1938 vm_exit(1);
1939 }
1940 return archived_oop;
1941 }
1942
1943 oop MetaspaceShared::materialize_archived_object(narrowOop v) {
1944 assert(archive_heap_region_fixed(),
1945 "must be called after archive heap regions are fixed");
1946 if (!CompressedOops::is_null(v)) {
1947 oop obj = HeapShared::decode_with_archived_oop_encoding_mode(v);
1948 return G1CollectedHeap::heap()->materialize_archived_object(obj);
1949 }
1950 return NULL;
1951 }
1952
1953 void MetaspaceShared::archive_klass_objects(Thread* THREAD) {
1954 int i;
1955 for (i = 0; i < _global_klass_objects->length(); i++) {
1956 Klass* k = _global_klass_objects->at(i);
1957
1958 // archive mirror object
1959 java_lang_Class::archive_mirror(k, CHECK);
1960
1961 // archive the resolved_referenes array
1962 if (k->is_instance_klass()) {
1963 InstanceKlass* ik = InstanceKlass::cast(k);
1964 ik->constants()->archive_resolved_references(THREAD);
1965 }
1966 }
1967 }
1968
1969 bool MetaspaceShared::is_archive_object(oop p) {
1970 return (p == NULL) ? false : G1ArchiveAllocator::is_archive_object(p);
1971 }
1972
1973 void MetaspaceShared::fixup_mapped_heap_regions() {
1974 FileMapInfo *mapinfo = FileMapInfo::current_info();
1975 mapinfo->fixup_mapped_heap_regions();
1976 set_archive_heap_region_fixed();
1977 }
1978 #endif // INCLUDE_CDS_JAVA_HEAP
1979
1980 // Closure for serializing initialization data in from a data area
1981 // (ptr_array) read from the shared file.
1982
1983 class ReadClosure : public SerializeClosure {
1984 private:
1985 intptr_t** _ptr_array;
1986
1987 inline intptr_t nextPtr() {
1988 return *(*_ptr_array)++;
1989 }
1990
1991 public:
1992 ReadClosure(intptr_t** ptr_array) { _ptr_array = ptr_array; }
1993
1994 void do_ptr(void** p) {
1995 assert(*p == NULL, "initializing previous initialized pointer.");
1996 intptr_t obj = nextPtr();
|