Mercurial > hg > truffle
comparison src/share/vm/memory/filemap.hpp @ 20375:6e0cb14ce59b
8046070: Class Data Sharing clean up and refactoring
Summary: Cleaned up CDS to be more configurable, maintainable and extensible
Reviewed-by: dholmes, coleenp, acorn, mchung
author | iklam |
---|---|
date | Thu, 21 Aug 2014 13:57:51 -0700 |
parents | 85c1ca43713f |
children | 8cb56c8cb30d |
comparison
equal
deleted
inserted
replaced
20374:999824269b71 | 20375:6e0cb14ce59b |
---|---|
35 // read-write space from CompactingPermGenGen | 35 // read-write space from CompactingPermGenGen |
36 // read-only space from CompactingPermGenGen | 36 // read-only space from CompactingPermGenGen |
37 // misc data (block offset table, string table, symbols, dictionary, etc.) | 37 // misc data (block offset table, string table, symbols, dictionary, etc.) |
38 // tag(666) | 38 // tag(666) |
39 | 39 |
40 static const int JVM_SHARED_JARS_MAX = 128; | |
41 static const int JVM_SPACENAME_MAX = 128; | |
42 static const int JVM_IDENT_MAX = 256; | 40 static const int JVM_IDENT_MAX = 256; |
43 static const int JVM_ARCH_MAX = 12; | |
44 | |
45 | 41 |
46 class Metaspace; | 42 class Metaspace; |
43 | |
44 class SharedClassPathEntry VALUE_OBJ_CLASS_SPEC { | |
45 public: | |
46 const char *_name; | |
47 time_t _timestamp; // jar timestamp, 0 if is directory | |
48 long _filesize; // jar file size, -1 if is directory | |
49 bool is_dir() { | |
50 return _filesize == -1; | |
51 } | |
52 }; | |
47 | 53 |
48 class FileMapInfo : public CHeapObj<mtInternal> { | 54 class FileMapInfo : public CHeapObj<mtInternal> { |
49 private: | 55 private: |
56 friend class ManifestStream; | |
50 enum { | 57 enum { |
51 _invalid_version = -1, | 58 _invalid_version = -1, |
52 _current_version = 1 | 59 _current_version = 2 |
53 }; | 60 }; |
54 | 61 |
55 bool _file_open; | 62 bool _file_open; |
56 int _fd; | 63 int _fd; |
57 long _file_offset; | 64 long _file_offset; |
58 | 65 |
66 private: | |
67 static SharedClassPathEntry* _classpath_entry_table; | |
68 static int _classpath_entry_table_size; | |
69 static size_t _classpath_entry_size; | |
70 static bool _validating_classpath_entry_table; | |
71 | |
59 // FileMapHeader describes the shared space data in the file to be | 72 // FileMapHeader describes the shared space data in the file to be |
60 // mapped. This structure gets written to a file. It is not a class, so | 73 // mapped. This structure gets written to a file. It is not a class, so |
61 // that the compilers don't add any compiler-private data to it. | 74 // that the compilers don't add any compiler-private data to it. |
62 | 75 |
63 struct FileMapHeader { | 76 public: |
77 struct FileMapHeaderBase : public CHeapObj<mtClass> { | |
78 virtual bool validate() = 0; | |
79 virtual void populate(FileMapInfo* info, size_t alignment) = 0; | |
80 }; | |
81 struct FileMapHeader : FileMapHeaderBase { | |
82 // Use data() and data_size() to memcopy to/from the FileMapHeader. We need to | |
83 // avoid read/writing the C++ vtable pointer. | |
84 static size_t data_size(); | |
85 char* data() { | |
86 return ((char*)this) + sizeof(FileMapHeaderBase); | |
87 } | |
88 | |
64 int _magic; // identify file type. | 89 int _magic; // identify file type. |
65 int _version; // (from enum, above.) | 90 int _version; // (from enum, above.) |
66 size_t _alignment; // how shared archive should be aligned | 91 size_t _alignment; // how shared archive should be aligned |
67 int _obj_alignment; // value of ObjectAlignmentInBytes | 92 int _obj_alignment; // value of ObjectAlignmentInBytes |
68 | 93 |
76 } _space[MetaspaceShared::n_regions]; | 101 } _space[MetaspaceShared::n_regions]; |
77 | 102 |
78 // The following fields are all sanity checks for whether this archive | 103 // The following fields are all sanity checks for whether this archive |
79 // will function correctly with this JVM and the bootclasspath it's | 104 // will function correctly with this JVM and the bootclasspath it's |
80 // invoked with. | 105 // invoked with. |
81 char _arch[JVM_ARCH_MAX]; // architecture | |
82 char _jvm_ident[JVM_IDENT_MAX]; // identifier for jvm | 106 char _jvm_ident[JVM_IDENT_MAX]; // identifier for jvm |
83 int _num_jars; // Number of jars in bootclasspath | 107 |
84 | 108 // The _paths_misc_info is a variable-size structure that records "miscellaneous" |
85 // Per jar file data: timestamp, size. | 109 // information during dumping. It is generated and validated by the |
86 | 110 // SharedPathsMiscInfo class. See SharedPathsMiscInfo.hpp and sharedClassUtil.hpp for |
87 struct { | 111 // detailed description. |
88 time_t _timestamp; // jar timestamp. | 112 // |
89 long _filesize; // jar file size. | 113 // The _paths_misc_info data is stored as a byte array in the archive file header, |
90 } _jar[JVM_SHARED_JARS_MAX]; | 114 // immediately after the _header field. This information is used only when |
91 } _header; | 115 // checking the validity of the archive and is deallocated after the archive is loaded. |
116 // | |
117 // Note that the _paths_misc_info does NOT include information for JAR files | |
118 // that existed during dump time. Their information is stored in _classpath_entry_table. | |
119 int _paths_misc_info_size; | |
120 | |
121 // The following is a table of all the class path entries that were used | |
122 // during dumping. At run time, we require these files to exist and have the same | |
123 // size/modification time, or else the archive will refuse to load. | |
124 // | |
125 // All of these entries must be JAR files. The dumping process would fail if a non-empty | |
126 // directory was specified in the classpaths. If an empty directory was specified | |
127 // it is checked by the _paths_misc_info as described above. | |
128 // | |
129 // FIXME -- if JAR files in the tail of the list were specified but not used during dumping, | |
130 // they should be removed from this table, to save space and to avoid spurious | |
131 // loading failures during runtime. | |
132 int _classpath_entry_table_size; | |
133 size_t _classpath_entry_size; | |
134 SharedClassPathEntry* _classpath_entry_table; | |
135 | |
136 virtual bool validate(); | |
137 virtual void populate(FileMapInfo* info, size_t alignment); | |
138 }; | |
139 | |
140 FileMapHeader * _header; | |
141 | |
92 const char* _full_path; | 142 const char* _full_path; |
143 char* _paths_misc_info; | |
93 | 144 |
94 static FileMapInfo* _current_info; | 145 static FileMapInfo* _current_info; |
95 | 146 |
96 bool init_from_file(int fd); | 147 bool init_from_file(int fd); |
97 void align_file_position(); | 148 void align_file_position(); |
149 bool validate_header_impl(); | |
98 | 150 |
99 public: | 151 public: |
100 FileMapInfo() { | 152 FileMapInfo(); |
101 _file_offset = 0; | 153 ~FileMapInfo(); |
102 _file_open = false; | |
103 _header._version = _invalid_version; | |
104 } | |
105 | 154 |
106 static int current_version() { return _current_version; } | 155 static int current_version() { return _current_version; } |
107 void populate_header(size_t alignment); | 156 void populate_header(size_t alignment); |
108 bool validate(); | 157 bool validate_header(); |
109 void invalidate(); | 158 void invalidate(); |
110 int version() { return _header._version; } | 159 int version() { return _header->_version; } |
111 size_t alignment() { return _header._alignment; } | 160 size_t alignment() { return _header->_alignment; } |
112 size_t space_capacity(int i) { return _header._space[i]._capacity; } | 161 size_t space_capacity(int i) { return _header->_space[i]._capacity; } |
113 char* region_base(int i) { return _header._space[i]._base; } | 162 char* region_base(int i) { return _header->_space[i]._base; } |
114 struct FileMapHeader* header() { return &_header; } | 163 struct FileMapHeader* header() { return _header; } |
115 | |
116 static void set_current_info(FileMapInfo* info) { | |
117 CDS_ONLY(_current_info = info;) | |
118 } | |
119 | 164 |
120 static FileMapInfo* current_info() { | 165 static FileMapInfo* current_info() { |
121 CDS_ONLY(return _current_info;) | 166 CDS_ONLY(return _current_info;) |
122 NOT_CDS(return NULL;) | 167 NOT_CDS(return NULL;) |
123 } | 168 } |
144 // Remap the shared readonly space to shared readwrite, private. | 189 // Remap the shared readonly space to shared readwrite, private. |
145 bool remap_shared_readonly_as_readwrite(); | 190 bool remap_shared_readonly_as_readwrite(); |
146 | 191 |
147 // Errors. | 192 // Errors. |
148 static void fail_stop(const char *msg, ...); | 193 static void fail_stop(const char *msg, ...); |
149 void fail_continue(const char *msg, ...); | 194 static void fail_continue(const char *msg, ...); |
150 | 195 |
151 // Return true if given address is in the mapped shared space. | 196 // Return true if given address is in the mapped shared space. |
152 bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false); | 197 bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false); |
153 void print_shared_spaces() NOT_CDS_RETURN; | 198 void print_shared_spaces() NOT_CDS_RETURN; |
154 | 199 |
158 os::vm_allocation_granularity()); | 203 os::vm_allocation_granularity()); |
159 } | 204 } |
160 | 205 |
161 // Stop CDS sharing and unmap CDS regions. | 206 // Stop CDS sharing and unmap CDS regions. |
162 static void stop_sharing_and_unmap(const char* msg); | 207 static void stop_sharing_and_unmap(const char* msg); |
208 | |
209 static void allocate_classpath_entry_table(); | |
210 bool validate_classpath_entry_table(); | |
211 | |
212 static SharedClassPathEntry* shared_classpath(int index) { | |
213 char* p = (char*)_classpath_entry_table; | |
214 p += _classpath_entry_size * index; | |
215 return (SharedClassPathEntry*)p; | |
216 } | |
217 static const char* shared_classpath_name(int index) { | |
218 return shared_classpath(index)->_name; | |
219 } | |
220 | |
221 static int get_number_of_share_classpaths() { | |
222 return _classpath_entry_table_size; | |
223 } | |
163 }; | 224 }; |
164 | 225 |
165 #endif // SHARE_VM_MEMORY_FILEMAP_HPP | 226 #endif // SHARE_VM_MEMORY_FILEMAP_HPP |