|
0
|
1 /*
|
|
|
2 * Copyright 2003-2007 Sun Microsystems, Inc. All Rights Reserved.
|
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
4 *
|
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
|
7 * published by the Free Software Foundation.
|
|
|
8 *
|
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
13 * accompanied this code).
|
|
|
14 *
|
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
18 *
|
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
|
21 * have any questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 class PlaceholderEntry;
|
|
|
26
|
|
|
27 // Placeholder objects. These represent classes currently
|
|
|
28 // being loaded, as well as arrays of primitives.
|
|
|
29 //
|
|
|
30
|
|
|
31 class PlaceholderTable : public TwoOopHashtable {
|
|
|
32 friend class VMStructs;
|
|
|
33
|
|
|
34 public:
|
|
|
35 PlaceholderTable(int table_size);
|
|
|
36
|
|
|
37 PlaceholderEntry* new_entry(int hash, symbolOop name, oop loader, bool havesupername, symbolOop supername);
|
|
|
38
|
|
|
39 PlaceholderEntry* bucket(int i) {
|
|
|
40 return (PlaceholderEntry*)Hashtable::bucket(i);
|
|
|
41 }
|
|
|
42
|
|
|
43 PlaceholderEntry** bucket_addr(int i) {
|
|
|
44 return (PlaceholderEntry**)Hashtable::bucket_addr(i);
|
|
|
45 }
|
|
|
46
|
|
|
47 void add_entry(int index, PlaceholderEntry* new_entry) {
|
|
|
48 Hashtable::add_entry(index, (HashtableEntry*)new_entry);
|
|
|
49 }
|
|
|
50
|
|
|
51 void add_entry(int index, unsigned int hash, symbolHandle name,
|
|
|
52 Handle loader, bool havesupername, symbolHandle supername);
|
|
|
53
|
|
|
54 // This returns a symbolOop to match type for SystemDictionary
|
|
|
55 symbolOop find_entry(int index, unsigned int hash,
|
|
|
56 symbolHandle name, Handle loader);
|
|
|
57
|
|
|
58 PlaceholderEntry* get_entry(int index, unsigned int hash,
|
|
|
59 symbolHandle name, Handle loader);
|
|
|
60
|
|
|
61 // caller to create a placeholder entry must enumerate an action
|
|
|
62 // caller claims ownership of that action
|
|
|
63 // For parallel classloading:
|
|
|
64 // multiple LOAD_INSTANCE threads can proceed in parallel
|
|
|
65 // multiple LOAD_SUPER threads can proceed in parallel
|
|
|
66 // LOAD_SUPER needed to check for class circularity
|
|
|
67 // DEFINE_CLASS: ultimately define class must be single threaded
|
|
|
68 // on a class/classloader basis
|
|
|
69 // so the head of that queue owns the token
|
|
|
70 // and the rest of the threads return the result the first thread gets
|
|
|
71 enum classloadAction {
|
|
|
72 LOAD_INSTANCE = 1, // calling load_instance_class
|
|
|
73 LOAD_SUPER = 2, // loading superclass for this class
|
|
|
74 DEFINE_CLASS = 3 // find_or_define class
|
|
|
75 };
|
|
|
76
|
|
|
77 // find_and_add returns probe pointer - old or new
|
|
|
78 // If no entry exists, add a placeholder entry and push SeenThread
|
|
|
79 // If entry exists, reuse entry and push SeenThread for classloadAction
|
|
|
80 PlaceholderEntry* find_and_add(int index, unsigned int hash,
|
|
|
81 symbolHandle name, Handle loader,
|
|
|
82 classloadAction action, symbolHandle supername,
|
|
|
83 Thread* thread);
|
|
|
84
|
|
|
85 void remove_entry(int index, unsigned int hash,
|
|
|
86 symbolHandle name, Handle loader);
|
|
|
87
|
|
|
88 // Remove placeholder information
|
|
|
89 void find_and_remove(int index, unsigned int hash,
|
|
|
90 symbolHandle name, Handle loader, Thread* thread);
|
|
|
91
|
|
|
92 // GC support.
|
|
|
93 void oops_do(OopClosure* f);
|
|
|
94
|
|
|
95 // JVMTI support
|
|
|
96 void entries_do(void f(symbolOop, oop));
|
|
|
97
|
|
|
98 #ifndef PRODUCT
|
|
|
99 void print();
|
|
|
100 #endif
|
|
|
101 void verify();
|
|
|
102 };
|
|
|
103
|
|
|
104 // SeenThread objects represent list of threads that are
|
|
|
105 // currently performing a load action on a class.
|
|
|
106 // For class circularity, set before loading a superclass.
|
|
|
107 // For bootclasssearchpath, set before calling load_instance_class.
|
|
|
108 // Defining must be single threaded on a class/classloader basis
|
|
|
109 // For DEFINE_CLASS, the head of the queue owns the
|
|
|
110 // define token and the rest of the threads wait to return the
|
|
|
111 // result the first thread gets.
|
|
|
112 class SeenThread: public CHeapObj {
|
|
|
113 private:
|
|
|
114 Thread *_thread;
|
|
|
115 SeenThread* _stnext;
|
|
|
116 SeenThread* _stprev;
|
|
|
117 public:
|
|
|
118 SeenThread(Thread *thread) {
|
|
|
119 _thread = thread;
|
|
|
120 _stnext = NULL;
|
|
|
121 _stprev = NULL;
|
|
|
122 }
|
|
|
123 Thread* thread() const { return _thread;}
|
|
|
124 void set_thread(Thread *thread) { _thread = thread; }
|
|
|
125
|
|
|
126 SeenThread* next() const { return _stnext;}
|
|
|
127 void set_next(SeenThread *seen) { _stnext = seen; }
|
|
|
128 void set_prev(SeenThread *seen) { _stprev = seen; }
|
|
|
129
|
|
|
130 #ifndef PRODUCT
|
|
|
131 void printActionQ() {
|
|
|
132 SeenThread* seen = this;
|
|
|
133 while (seen != NULL) {
|
|
|
134 seen->thread()->print_value();
|
|
|
135 tty->print(", ");
|
|
|
136 seen = seen->next();
|
|
|
137 }
|
|
|
138 }
|
|
|
139 #endif // PRODUCT
|
|
|
140 };
|
|
|
141
|
|
|
142 // Placeholder objects represent classes currently being loaded.
|
|
|
143 // All threads examining the placeholder table must hold the
|
|
|
144 // SystemDictionary_lock, so we don't need special precautions
|
|
|
145 // on store ordering here.
|
|
|
146 // The system dictionary is the only user of this class.
|
|
|
147
|
|
|
148 class PlaceholderEntry : public HashtableEntry {
|
|
|
149 friend class VMStructs;
|
|
|
150
|
|
|
151
|
|
|
152 private:
|
|
|
153 oop _loader; // initiating loader
|
|
|
154 bool _havesupername; // distinguish between null supername, and unknown
|
|
|
155 symbolOop _supername;
|
|
|
156 Thread* _definer; // owner of define token
|
|
|
157 klassOop _instanceKlass; // instanceKlass from successful define
|
|
|
158 SeenThread* _superThreadQ; // doubly-linked queue of Threads loading a superclass for this class
|
|
|
159 SeenThread* _loadInstanceThreadQ; // loadInstance thread
|
|
|
160 // can be multiple threads if classloader object lock broken by application
|
|
|
161 // or if classloader supports parallel classloading
|
|
|
162
|
|
|
163 SeenThread* _defineThreadQ; // queue of Threads trying to define this class
|
|
|
164 // including _definer
|
|
|
165 // _definer owns token
|
|
|
166 // queue waits for and returns results from _definer
|
|
|
167
|
|
|
168 public:
|
|
|
169 // Simple accessors, used only by SystemDictionary
|
|
|
170 symbolOop klass() const { return (symbolOop)literal(); }
|
|
|
171 symbolOop* klass_addr() { return (symbolOop*)literal_addr(); }
|
|
|
172
|
|
|
173 oop loader() const { return _loader; }
|
|
|
174 void set_loader(oop loader) { _loader = loader; }
|
|
|
175 oop* loader_addr() { return &_loader; }
|
|
|
176
|
|
|
177 bool havesupername() const { return _havesupername; }
|
|
|
178 void set_havesupername(bool havesupername) { _havesupername = havesupername; }
|
|
|
179
|
|
|
180 symbolOop supername() const { return _supername; }
|
|
|
181 void set_supername(symbolOop supername) { _supername = supername; }
|
|
|
182 symbolOop* supername_addr() { return &_supername; }
|
|
|
183
|
|
|
184 Thread* definer() const {return _definer; }
|
|
|
185 void set_definer(Thread* definer) { _definer = definer; }
|
|
|
186
|
|
|
187 klassOop instanceKlass() const {return _instanceKlass; }
|
|
|
188 void set_instanceKlass(klassOop instanceKlass) { _instanceKlass = instanceKlass; }
|
|
|
189 klassOop* instanceKlass_addr() { return &_instanceKlass; }
|
|
|
190
|
|
|
191 SeenThread* superThreadQ() const { return _superThreadQ; }
|
|
|
192 void set_superThreadQ(SeenThread* SeenThread) { _superThreadQ = SeenThread; }
|
|
|
193
|
|
|
194 SeenThread* loadInstanceThreadQ() const { return _loadInstanceThreadQ; }
|
|
|
195 void set_loadInstanceThreadQ(SeenThread* SeenThread) { _loadInstanceThreadQ = SeenThread; }
|
|
|
196
|
|
|
197 SeenThread* defineThreadQ() const { return _defineThreadQ; }
|
|
|
198 void set_defineThreadQ(SeenThread* SeenThread) { _defineThreadQ = SeenThread; }
|
|
|
199
|
|
|
200 PlaceholderEntry* next() const {
|
|
|
201 return (PlaceholderEntry*)HashtableEntry::next();
|
|
|
202 }
|
|
|
203
|
|
|
204 PlaceholderEntry** next_addr() {
|
|
|
205 return (PlaceholderEntry**)HashtableEntry::next_addr();
|
|
|
206 }
|
|
|
207
|
|
|
208 // Test for equality
|
|
|
209 // Entries are unique for class/classloader name pair
|
|
|
210 bool equals(symbolOop class_name, oop class_loader) const {
|
|
|
211 return (klass() == class_name && loader() == class_loader);
|
|
|
212 }
|
|
|
213
|
|
|
214 SeenThread* actionToQueue(PlaceholderTable::classloadAction action) {
|
|
|
215 SeenThread* queuehead;
|
|
|
216 switch (action) {
|
|
|
217 case PlaceholderTable::LOAD_INSTANCE:
|
|
|
218 queuehead = _loadInstanceThreadQ;
|
|
|
219 break;
|
|
|
220 case PlaceholderTable::LOAD_SUPER:
|
|
|
221 queuehead = _superThreadQ;
|
|
|
222 break;
|
|
|
223 case PlaceholderTable::DEFINE_CLASS:
|
|
|
224 queuehead = _defineThreadQ;
|
|
|
225 break;
|
|
|
226 default: Unimplemented();
|
|
|
227 }
|
|
|
228 return queuehead;
|
|
|
229 }
|
|
|
230
|
|
|
231 void set_threadQ(SeenThread* seenthread, PlaceholderTable::classloadAction action) {
|
|
|
232 switch (action) {
|
|
|
233 case PlaceholderTable::LOAD_INSTANCE:
|
|
|
234 _loadInstanceThreadQ = seenthread;
|
|
|
235 break;
|
|
|
236 case PlaceholderTable::LOAD_SUPER:
|
|
|
237 _superThreadQ = seenthread;
|
|
|
238 break;
|
|
|
239 case PlaceholderTable::DEFINE_CLASS:
|
|
|
240 _defineThreadQ = seenthread;
|
|
|
241 break;
|
|
|
242 default: Unimplemented();
|
|
|
243 }
|
|
|
244 return;
|
|
|
245 }
|
|
|
246
|
|
|
247 bool super_load_in_progress() {
|
|
|
248 return (_superThreadQ != NULL);
|
|
|
249 }
|
|
|
250
|
|
|
251 bool instance_load_in_progress() {
|
|
|
252 return (_loadInstanceThreadQ != NULL);
|
|
|
253 }
|
|
|
254
|
|
|
255 bool define_class_in_progress() {
|
|
|
256 return (_defineThreadQ != NULL);
|
|
|
257 }
|
|
|
258
|
|
|
259 // Doubly-linked list of Threads per action for class/classloader pair
|
|
|
260 // Class circularity support: links in thread before loading superclass
|
|
|
261 // bootstrapsearchpath support: links in a thread before load_instance_class
|
|
|
262 // definers: use as queue of define requestors, including owner of
|
|
|
263 // define token. Appends for debugging of requestor order
|
|
|
264 void add_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) {
|
|
|
265 assert_lock_strong(SystemDictionary_lock);
|
|
|
266 SeenThread* threadEntry = new SeenThread(thread);
|
|
|
267 SeenThread* seen = actionToQueue(action);
|
|
|
268
|
|
|
269 if (seen == NULL) {
|
|
|
270 set_threadQ(threadEntry, action);
|
|
|
271 return;
|
|
|
272 }
|
|
|
273 SeenThread* next;
|
|
|
274 while ((next = seen->next()) != NULL) {
|
|
|
275 seen = next;
|
|
|
276 }
|
|
|
277 seen->set_next(threadEntry);
|
|
|
278 threadEntry->set_prev(seen);
|
|
|
279 return;
|
|
|
280 }
|
|
|
281
|
|
|
282 bool check_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) {
|
|
|
283 assert_lock_strong(SystemDictionary_lock);
|
|
|
284 SeenThread* threadQ = actionToQueue(action);
|
|
|
285 SeenThread* seen = threadQ;
|
|
|
286 while (seen) {
|
|
|
287 if (thread == seen->thread()) {
|
|
|
288 return true;
|
|
|
289 }
|
|
|
290 seen = seen->next();
|
|
|
291 }
|
|
|
292 return false;
|
|
|
293 }
|
|
|
294
|
|
|
295 // returns true if seenthreadQ is now empty
|
|
|
296 // Note, caller must ensure probe still exists while holding
|
|
|
297 // SystemDictionary_lock
|
|
|
298 // ignores if cleanup has already been done
|
|
|
299 // if found, deletes SeenThread
|
|
|
300 bool remove_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) {
|
|
|
301 assert_lock_strong(SystemDictionary_lock);
|
|
|
302 SeenThread* threadQ = actionToQueue(action);
|
|
|
303 SeenThread* seen = threadQ;
|
|
|
304 SeenThread* prev = NULL;
|
|
|
305 while (seen) {
|
|
|
306 if (thread == seen->thread()) {
|
|
|
307 if (prev) {
|
|
|
308 prev->set_next(seen->next());
|
|
|
309 } else {
|
|
|
310 set_threadQ(seen->next(), action);
|
|
|
311 }
|
|
|
312 if (seen->next()) {
|
|
|
313 seen->next()->set_prev(prev);
|
|
|
314 }
|
|
|
315 delete seen;
|
|
|
316 break;
|
|
|
317 }
|
|
|
318 prev = seen;
|
|
|
319 seen = seen->next();
|
|
|
320 }
|
|
|
321 return (actionToQueue(action) == NULL);
|
|
|
322 }
|
|
|
323
|
|
|
324 // GC support
|
|
|
325 // Applies "f->do_oop" to all root oops in the placeholder table.
|
|
|
326 void oops_do(OopClosure* blk);
|
|
|
327
|
|
|
328 // Print method doesn't append a cr
|
|
|
329 void print() const PRODUCT_RETURN;
|
|
|
330 void verify() const;
|
|
|
331 };
|
