1
|
1 |
/*
|
|
2 |
* Copyright 2001-2005 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 VoidClosure;
|
|
26 |
|
|
27 |
// A SuspendibleThreadSet is (obviously) a set of threads that can be
|
|
28 |
// suspended. A thread can join and later leave the set, and periodically
|
|
29 |
// yield. If some thread (not in the set) requests, via suspend_all, that
|
|
30 |
// the threads be suspended, then the requesting thread is blocked until
|
|
31 |
// all the threads in the set have yielded or left the set. (Threads may
|
|
32 |
// not enter the set when an attempted suspension is in progress.) The
|
|
33 |
// suspending thread later calls resume_all, allowing the suspended threads
|
|
34 |
// to continue.
|
|
35 |
|
|
36 |
class SuspendibleThreadSet {
|
|
37 |
Monitor* _m;
|
|
38 |
int _async;
|
|
39 |
bool _async_stop;
|
|
40 |
int _async_stopped;
|
|
41 |
bool _initialized;
|
|
42 |
double _suspend_all_start;
|
|
43 |
|
|
44 |
void initialize_work();
|
|
45 |
|
|
46 |
public:
|
|
47 |
SuspendibleThreadSet() : _initialized(false) {}
|
|
48 |
|
|
49 |
// Add the current thread to the set. May block if a suspension
|
|
50 |
// is in progress.
|
|
51 |
void join();
|
|
52 |
// Removes the current thread from the set.
|
|
53 |
void leave();
|
|
54 |
// Returns "true" iff an suspension is in progress.
|
|
55 |
bool should_yield() { return _async_stop; }
|
|
56 |
// Suspends the current thread if a suspension is in progress (for
|
|
57 |
// the duration of the suspension.)
|
|
58 |
void yield(const char* id);
|
|
59 |
// Return when all threads in the set are suspended.
|
|
60 |
void suspend_all();
|
|
61 |
// Allow suspended threads to resume.
|
|
62 |
void resume_all();
|
|
63 |
// Redundant initializations okay.
|
|
64 |
void initialize() {
|
|
65 |
// Double-check dirty read idiom.
|
|
66 |
if (!_initialized) initialize_work();
|
|
67 |
}
|
|
68 |
};
|
|
69 |
|
|
70 |
|
|
71 |
class ConcurrentGCThread: public NamedThread {
|
|
72 |
friend class VMStructs;
|
|
73 |
|
|
74 |
protected:
|
|
75 |
static bool _should_terminate;
|
|
76 |
static bool _has_terminated;
|
|
77 |
|
|
78 |
enum CGC_flag_type {
|
|
79 |
CGC_nil = 0x0,
|
|
80 |
CGC_dont_suspend = 0x1,
|
|
81 |
CGC_CGC_safepoint = 0x2,
|
|
82 |
CGC_VM_safepoint = 0x4
|
|
83 |
};
|
|
84 |
|
|
85 |
static int _CGC_flag;
|
|
86 |
|
|
87 |
static bool CGC_flag_is_set(int b) { return (_CGC_flag & b) != 0; }
|
|
88 |
static int set_CGC_flag(int b) { return _CGC_flag |= b; }
|
|
89 |
static int reset_CGC_flag(int b) { return _CGC_flag &= ~b; }
|
|
90 |
|
|
91 |
void stopWorldAndDo(VoidClosure* op);
|
|
92 |
|
|
93 |
// All instances share this one set.
|
|
94 |
static SuspendibleThreadSet _sts;
|
|
95 |
|
|
96 |
// Create and start the thread (setting it's priority high.)
|
|
97 |
void create_and_start();
|
|
98 |
|
|
99 |
// Do initialization steps in the thread: record stack base and size,
|
|
100 |
// init thread local storage, set JNI handle block.
|
|
101 |
void initialize_in_thread();
|
|
102 |
|
|
103 |
// Wait until Universe::is_fully_initialized();
|
|
104 |
void wait_for_universe_init();
|
|
105 |
|
|
106 |
// Record that the current thread is terminating, and will do more
|
|
107 |
// concurrent work.
|
|
108 |
void terminate();
|
|
109 |
|
|
110 |
public:
|
|
111 |
// Constructor
|
|
112 |
|
|
113 |
ConcurrentGCThread();
|
|
114 |
~ConcurrentGCThread() {} // Exists to call NamedThread destructor.
|
|
115 |
|
|
116 |
// Tester
|
|
117 |
bool is_ConcurrentGC_thread() const { return true; }
|
|
118 |
|
|
119 |
static void safepoint_synchronize();
|
|
120 |
static void safepoint_desynchronize();
|
|
121 |
|
|
122 |
// All overridings should probably do _sts::yield, but we allow
|
|
123 |
// overriding for distinguished debugging messages. Default is to do
|
|
124 |
// nothing.
|
|
125 |
virtual void yield() {}
|
|
126 |
|
|
127 |
bool should_yield() { return _sts.should_yield(); }
|
|
128 |
|
|
129 |
// they are prefixed by sts since there are already yield() and
|
|
130 |
// should_yield() (non-static) methods in this class and it was an
|
|
131 |
// easy way to differentiate them.
|
|
132 |
static void stsYield(const char* id);
|
|
133 |
static bool stsShouldYield();
|
|
134 |
static void stsJoin();
|
|
135 |
static void stsLeave();
|
|
136 |
|
|
137 |
};
|
|
138 |
|
|
139 |
// The SurrogateLockerThread is used by concurrent GC threads for
|
|
140 |
// manipulating Java monitors, in particular, currently for
|
|
141 |
// manipulating the pending_list_lock. XXX
|
|
142 |
class SurrogateLockerThread: public JavaThread {
|
|
143 |
friend class VMStructs;
|
|
144 |
public:
|
|
145 |
enum SLT_msg_type {
|
|
146 |
empty = 0, // no message
|
|
147 |
acquirePLL, // acquire pending list lock
|
|
148 |
releaseAndNotifyPLL // notify and release pending list lock
|
|
149 |
};
|
|
150 |
private:
|
|
151 |
// the following are shared with the CMSThread
|
|
152 |
SLT_msg_type _buffer; // communication buffer
|
|
153 |
Monitor _monitor; // monitor controlling buffer
|
|
154 |
BasicLock _basicLock; // used for PLL locking
|
|
155 |
|
|
156 |
public:
|
|
157 |
static SurrogateLockerThread* make(TRAPS);
|
|
158 |
|
|
159 |
SurrogateLockerThread();
|
|
160 |
|
|
161 |
bool is_hidden_from_external_view() const { return true; }
|
|
162 |
|
|
163 |
void loop(); // main method
|
|
164 |
|
|
165 |
void manipulatePLL(SLT_msg_type msg);
|
|
166 |
|
|
167 |
};
|