mirror of
https://github.com/openjdk/jdk.git
synced 2025-09-22 12:04:39 +02:00
6771742: Remove duplicate files from G1 merge
Remove duplicate files and add includeDB_gc_g1 file in windows Makefile Reviewed-by: jcoomes, ysr
This commit is contained in:
Jon Masamitsu
parent
cbf1c89d60
commit
a2078f04e8
3 changed files with 2 additions and 482 deletions
|
|
@ -56,7 +56,8 @@ IncludeDBs_gc=$(HOTSPOTWORKSPACE)/src/share/vm/includeDB_gc_parallel \
|
||||||
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_shared \
|
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_shared \
|
||||||
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_parNew \
|
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_parNew \
|
||||||
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_parallelScavenge \
|
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_parallelScavenge \
|
||||||
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_concurrentMarkSweep
|
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_concurrentMarkSweep \
|
||||||
|
$(HOTSPOTWORKSPACE)/src/share/vm/gc_implementation/includeDB_gc_g1
|
||||||
|
|
||||||
|
|
||||||
IncludeDBs_kernel =$(IncludeDBs_base) \
|
IncludeDBs_kernel =$(IncludeDBs_base) \
|
||||||
|
|
|
||||||
|
|
@ -1,314 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright 2001-2005 Sun Microsystems, Inc. All Rights Reserved.
|
|
||||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
||||||
*
|
|
||||||
* This code is free software; you can redistribute it and/or modify it
|
|
||||||
* under the terms of the GNU General Public License version 2 only, as
|
|
||||||
* published by the Free Software Foundation.
|
|
||||||
*
|
|
||||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
||||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
||||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
||||||
* version 2 for more details (a copy is included in the LICENSE file that
|
|
||||||
* accompanied this code).
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU General Public License version
|
|
||||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
||||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
||||||
*
|
|
||||||
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
||||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
|
||||||
* have any questions.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
// CopyrightVersion 1.2
|
|
||||||
|
|
||||||
# include "incls/_precompiled.incl"
|
|
||||||
# include "incls/_concurrentGCThread.cpp.incl"
|
|
||||||
|
|
||||||
bool ConcurrentGCThread::_should_terminate = false;
|
|
||||||
bool ConcurrentGCThread::_has_terminated = false;
|
|
||||||
int ConcurrentGCThread::_CGC_flag = CGC_nil;
|
|
||||||
|
|
||||||
SuspendibleThreadSet ConcurrentGCThread::_sts;
|
|
||||||
|
|
||||||
ConcurrentGCThread::ConcurrentGCThread() {
|
|
||||||
_sts.initialize();
|
|
||||||
};
|
|
||||||
|
|
||||||
void ConcurrentGCThread::stopWorldAndDo(VoidClosure* op) {
|
|
||||||
MutexLockerEx x(Heap_lock,
|
|
||||||
Mutex::_no_safepoint_check_flag);
|
|
||||||
// warning("CGC: about to try stopping world");
|
|
||||||
SafepointSynchronize::begin();
|
|
||||||
// warning("CGC: successfully stopped world");
|
|
||||||
op->do_void();
|
|
||||||
SafepointSynchronize::end();
|
|
||||||
// warning("CGC: successfully restarted world");
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::safepoint_synchronize() {
|
|
||||||
_sts.suspend_all();
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::safepoint_desynchronize() {
|
|
||||||
_sts.resume_all();
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::create_and_start() {
|
|
||||||
if (os::create_thread(this, os::cgc_thread)) {
|
|
||||||
// XXX: need to set this to low priority
|
|
||||||
// unless "agressive mode" set; priority
|
|
||||||
// should be just less than that of VMThread.
|
|
||||||
os::set_priority(this, NearMaxPriority);
|
|
||||||
if (!_should_terminate && !DisableStartThread) {
|
|
||||||
os::start_thread(this);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::initialize_in_thread() {
|
|
||||||
this->record_stack_base_and_size();
|
|
||||||
this->initialize_thread_local_storage();
|
|
||||||
this->set_active_handles(JNIHandleBlock::allocate_block());
|
|
||||||
// From this time Thread::current() should be working.
|
|
||||||
assert(this == Thread::current(), "just checking");
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::wait_for_universe_init() {
|
|
||||||
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
|
|
||||||
while (!is_init_completed() && !_should_terminate) {
|
|
||||||
CGC_lock->wait(Mutex::_no_safepoint_check_flag, 200);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::terminate() {
|
|
||||||
// Signal that it is terminated
|
|
||||||
{
|
|
||||||
MutexLockerEx mu(Terminator_lock,
|
|
||||||
Mutex::_no_safepoint_check_flag);
|
|
||||||
_has_terminated = true;
|
|
||||||
Terminator_lock->notify();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Thread destructor usually does this..
|
|
||||||
ThreadLocalStorage::set_thread(NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void SuspendibleThreadSet::initialize_work() {
|
|
||||||
MutexLocker x(STS_init_lock);
|
|
||||||
if (!_initialized) {
|
|
||||||
_m = new Monitor(Mutex::leaf,
|
|
||||||
"SuspendibleThreadSetLock", true);
|
|
||||||
_async = 0;
|
|
||||||
_async_stop = false;
|
|
||||||
_async_stopped = 0;
|
|
||||||
_initialized = true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void SuspendibleThreadSet::join() {
|
|
||||||
initialize();
|
|
||||||
MutexLockerEx x(_m, Mutex::_no_safepoint_check_flag);
|
|
||||||
while (_async_stop) _m->wait(Mutex::_no_safepoint_check_flag);
|
|
||||||
_async++;
|
|
||||||
assert(_async > 0, "Huh.");
|
|
||||||
}
|
|
||||||
|
|
||||||
void SuspendibleThreadSet::leave() {
|
|
||||||
assert(_initialized, "Must be initialized.");
|
|
||||||
MutexLockerEx x(_m, Mutex::_no_safepoint_check_flag);
|
|
||||||
_async--;
|
|
||||||
assert(_async >= 0, "Huh.");
|
|
||||||
if (_async_stop) _m->notify_all();
|
|
||||||
}
|
|
||||||
|
|
||||||
void SuspendibleThreadSet::yield(const char* id) {
|
|
||||||
assert(_initialized, "Must be initialized.");
|
|
||||||
if (_async_stop) {
|
|
||||||
MutexLockerEx x(_m, Mutex::_no_safepoint_check_flag);
|
|
||||||
if (_async_stop) {
|
|
||||||
_async_stopped++;
|
|
||||||
assert(_async_stopped > 0, "Huh.");
|
|
||||||
if (_async_stopped == _async) {
|
|
||||||
if (ConcGCYieldTimeout > 0) {
|
|
||||||
double now = os::elapsedTime();
|
|
||||||
guarantee((now - _suspend_all_start) * 1000.0 <
|
|
||||||
(double)ConcGCYieldTimeout,
|
|
||||||
"Long delay; whodunit?");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_m->notify_all();
|
|
||||||
while (_async_stop) _m->wait(Mutex::_no_safepoint_check_flag);
|
|
||||||
_async_stopped--;
|
|
||||||
assert(_async >= 0, "Huh");
|
|
||||||
_m->notify_all();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void SuspendibleThreadSet::suspend_all() {
|
|
||||||
initialize(); // If necessary.
|
|
||||||
if (ConcGCYieldTimeout > 0) {
|
|
||||||
_suspend_all_start = os::elapsedTime();
|
|
||||||
}
|
|
||||||
MutexLockerEx x(_m, Mutex::_no_safepoint_check_flag);
|
|
||||||
assert(!_async_stop, "Only one at a time.");
|
|
||||||
_async_stop = true;
|
|
||||||
while (_async_stopped < _async) _m->wait(Mutex::_no_safepoint_check_flag);
|
|
||||||
}
|
|
||||||
|
|
||||||
void SuspendibleThreadSet::resume_all() {
|
|
||||||
assert(_initialized, "Must be initialized.");
|
|
||||||
MutexLockerEx x(_m, Mutex::_no_safepoint_check_flag);
|
|
||||||
assert(_async_stopped == _async, "Huh.");
|
|
||||||
_async_stop = false;
|
|
||||||
_m->notify_all();
|
|
||||||
}
|
|
||||||
|
|
||||||
static void _sltLoop(JavaThread* thread, TRAPS) {
|
|
||||||
SurrogateLockerThread* slt = (SurrogateLockerThread*)thread;
|
|
||||||
slt->loop();
|
|
||||||
}
|
|
||||||
|
|
||||||
SurrogateLockerThread::SurrogateLockerThread() :
|
|
||||||
JavaThread(&_sltLoop),
|
|
||||||
_monitor(Mutex::nonleaf, "SLTMonitor"),
|
|
||||||
_buffer(empty)
|
|
||||||
{}
|
|
||||||
|
|
||||||
SurrogateLockerThread* SurrogateLockerThread::make(TRAPS) {
|
|
||||||
klassOop k =
|
|
||||||
SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(),
|
|
||||||
true, CHECK_NULL);
|
|
||||||
instanceKlassHandle klass (THREAD, k);
|
|
||||||
instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
|
|
||||||
|
|
||||||
const char thread_name[] = "Surrogate Locker Thread (CMS)";
|
|
||||||
Handle string = java_lang_String::create_from_str(thread_name, CHECK_NULL);
|
|
||||||
|
|
||||||
// Initialize thread_oop to put it into the system threadGroup
|
|
||||||
Handle thread_group (THREAD, Universe::system_thread_group());
|
|
||||||
JavaValue result(T_VOID);
|
|
||||||
JavaCalls::call_special(&result, thread_oop,
|
|
||||||
klass,
|
|
||||||
vmSymbolHandles::object_initializer_name(),
|
|
||||||
vmSymbolHandles::threadgroup_string_void_signature(),
|
|
||||||
thread_group,
|
|
||||||
string,
|
|
||||||
CHECK_NULL);
|
|
||||||
|
|
||||||
SurrogateLockerThread* res;
|
|
||||||
{
|
|
||||||
MutexLocker mu(Threads_lock);
|
|
||||||
res = new SurrogateLockerThread();
|
|
||||||
|
|
||||||
// At this point it may be possible that no osthread was created for the
|
|
||||||
// JavaThread due to lack of memory. We would have to throw an exception
|
|
||||||
// in that case. However, since this must work and we do not allow
|
|
||||||
// exceptions anyway, check and abort if this fails.
|
|
||||||
if (res == NULL || res->osthread() == NULL) {
|
|
||||||
vm_exit_during_initialization("java.lang.OutOfMemoryError",
|
|
||||||
"unable to create new native thread");
|
|
||||||
}
|
|
||||||
java_lang_Thread::set_thread(thread_oop(), res);
|
|
||||||
java_lang_Thread::set_priority(thread_oop(), NearMaxPriority);
|
|
||||||
java_lang_Thread::set_daemon(thread_oop());
|
|
||||||
|
|
||||||
res->set_threadObj(thread_oop());
|
|
||||||
Threads::add(res);
|
|
||||||
Thread::start(res);
|
|
||||||
}
|
|
||||||
os::yield(); // This seems to help with initial start-up of SLT
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
void SurrogateLockerThread::manipulatePLL(SLT_msg_type msg) {
|
|
||||||
MutexLockerEx x(&_monitor, Mutex::_no_safepoint_check_flag);
|
|
||||||
assert(_buffer == empty, "Should be empty");
|
|
||||||
assert(msg != empty, "empty message");
|
|
||||||
_buffer = msg;
|
|
||||||
while (_buffer != empty) {
|
|
||||||
_monitor.notify();
|
|
||||||
_monitor.wait(Mutex::_no_safepoint_check_flag);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ======= Surrogate Locker Thread =============
|
|
||||||
|
|
||||||
void SurrogateLockerThread::loop() {
|
|
||||||
BasicLock pll_basic_lock;
|
|
||||||
SLT_msg_type msg;
|
|
||||||
debug_only(unsigned int owned = 0;)
|
|
||||||
|
|
||||||
while (/* !isTerminated() */ 1) {
|
|
||||||
{
|
|
||||||
MutexLocker x(&_monitor);
|
|
||||||
// Since we are a JavaThread, we can't be here at a safepoint.
|
|
||||||
assert(!SafepointSynchronize::is_at_safepoint(),
|
|
||||||
"SLT is a JavaThread");
|
|
||||||
// wait for msg buffer to become non-empty
|
|
||||||
while (_buffer == empty) {
|
|
||||||
_monitor.notify();
|
|
||||||
_monitor.wait();
|
|
||||||
}
|
|
||||||
msg = _buffer;
|
|
||||||
}
|
|
||||||
switch(msg) {
|
|
||||||
case acquirePLL: {
|
|
||||||
instanceRefKlass::acquire_pending_list_lock(&pll_basic_lock);
|
|
||||||
debug_only(owned++;)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case releaseAndNotifyPLL: {
|
|
||||||
assert(owned > 0, "Don't have PLL");
|
|
||||||
instanceRefKlass::release_and_notify_pending_list_lock(&pll_basic_lock);
|
|
||||||
debug_only(owned--;)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case empty:
|
|
||||||
default: {
|
|
||||||
guarantee(false,"Unexpected message in _buffer");
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
{
|
|
||||||
MutexLocker x(&_monitor);
|
|
||||||
// Since we are a JavaThread, we can't be here at a safepoint.
|
|
||||||
assert(!SafepointSynchronize::is_at_safepoint(),
|
|
||||||
"SLT is a JavaThread");
|
|
||||||
_buffer = empty;
|
|
||||||
_monitor.notify();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
assert(!_monitor.owned_by_self(), "Should unlock before exit.");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// ===== STS Access From Outside CGCT =====
|
|
||||||
|
|
||||||
void ConcurrentGCThread::stsYield(const char* id) {
|
|
||||||
assert( Thread::current()->is_ConcurrentGC_thread(),
|
|
||||||
"only a conc GC thread can call this" );
|
|
||||||
_sts.yield(id);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ConcurrentGCThread::stsShouldYield() {
|
|
||||||
assert( Thread::current()->is_ConcurrentGC_thread(),
|
|
||||||
"only a conc GC thread can call this" );
|
|
||||||
return _sts.should_yield();
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::stsJoin() {
|
|
||||||
assert( Thread::current()->is_ConcurrentGC_thread(),
|
|
||||||
"only a conc GC thread can call this" );
|
|
||||||
_sts.join();
|
|
||||||
}
|
|
||||||
|
|
||||||
void ConcurrentGCThread::stsLeave() {
|
|
||||||
assert( Thread::current()->is_ConcurrentGC_thread(),
|
|
||||||
"only a conc GC thread can call this" );
|
|
||||||
_sts.leave();
|
|
||||||
}
|
|
||||||
|
|
@ -1,167 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright 2001-2005 Sun Microsystems, Inc. All Rights Reserved.
|
|
||||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
||||||
*
|
|
||||||
* This code is free software; you can redistribute it and/or modify it
|
|
||||||
* under the terms of the GNU General Public License version 2 only, as
|
|
||||||
* published by the Free Software Foundation.
|
|
||||||
*
|
|
||||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
||||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
||||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
||||||
* version 2 for more details (a copy is included in the LICENSE file that
|
|
||||||
* accompanied this code).
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU General Public License version
|
|
||||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
||||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
||||||
*
|
|
||||||
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
||||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
|
||||||
* have any questions.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
class VoidClosure;
|
|
||||||
|
|
||||||
// A SuspendibleThreadSet is (obviously) a set of threads that can be
|
|
||||||
// suspended. A thread can join and later leave the set, and periodically
|
|
||||||
// yield. If some thread (not in the set) requests, via suspend_all, that
|
|
||||||
// the threads be suspended, then the requesting thread is blocked until
|
|
||||||
// all the threads in the set have yielded or left the set. (Threads may
|
|
||||||
// not enter the set when an attempted suspension is in progress.) The
|
|
||||||
// suspending thread later calls resume_all, allowing the suspended threads
|
|
||||||
// to continue.
|
|
||||||
|
|
||||||
class SuspendibleThreadSet {
|
|
||||||
Monitor* _m;
|
|
||||||
int _async;
|
|
||||||
bool _async_stop;
|
|
||||||
int _async_stopped;
|
|
||||||
bool _initialized;
|
|
||||||
double _suspend_all_start;
|
|
||||||
|
|
||||||
void initialize_work();
|
|
||||||
|
|
||||||
public:
|
|
||||||
SuspendibleThreadSet() : _initialized(false) {}
|
|
||||||
|
|
||||||
// Add the current thread to the set. May block if a suspension
|
|
||||||
// is in progress.
|
|
||||||
void join();
|
|
||||||
// Removes the current thread from the set.
|
|
||||||
void leave();
|
|
||||||
// Returns "true" iff an suspension is in progress.
|
|
||||||
bool should_yield() { return _async_stop; }
|
|
||||||
// Suspends the current thread if a suspension is in progress (for
|
|
||||||
// the duration of the suspension.)
|
|
||||||
void yield(const char* id);
|
|
||||||
// Return when all threads in the set are suspended.
|
|
||||||
void suspend_all();
|
|
||||||
// Allow suspended threads to resume.
|
|
||||||
void resume_all();
|
|
||||||
// Redundant initializations okay.
|
|
||||||
void initialize() {
|
|
||||||
// Double-check dirty read idiom.
|
|
||||||
if (!_initialized) initialize_work();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
class ConcurrentGCThread: public NamedThread {
|
|
||||||
friend class VMStructs;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
static bool _should_terminate;
|
|
||||||
static bool _has_terminated;
|
|
||||||
|
|
||||||
enum CGC_flag_type {
|
|
||||||
CGC_nil = 0x0,
|
|
||||||
CGC_dont_suspend = 0x1,
|
|
||||||
CGC_CGC_safepoint = 0x2,
|
|
||||||
CGC_VM_safepoint = 0x4
|
|
||||||
};
|
|
||||||
|
|
||||||
static int _CGC_flag;
|
|
||||||
|
|
||||||
static bool CGC_flag_is_set(int b) { return (_CGC_flag & b) != 0; }
|
|
||||||
static int set_CGC_flag(int b) { return _CGC_flag |= b; }
|
|
||||||
static int reset_CGC_flag(int b) { return _CGC_flag &= ~b; }
|
|
||||||
|
|
||||||
void stopWorldAndDo(VoidClosure* op);
|
|
||||||
|
|
||||||
// All instances share this one set.
|
|
||||||
static SuspendibleThreadSet _sts;
|
|
||||||
|
|
||||||
// Create and start the thread (setting it's priority high.)
|
|
||||||
void create_and_start();
|
|
||||||
|
|
||||||
// Do initialization steps in the thread: record stack base and size,
|
|
||||||
// init thread local storage, set JNI handle block.
|
|
||||||
void initialize_in_thread();
|
|
||||||
|
|
||||||
// Wait until Universe::is_fully_initialized();
|
|
||||||
void wait_for_universe_init();
|
|
||||||
|
|
||||||
// Record that the current thread is terminating, and will do more
|
|
||||||
// concurrent work.
|
|
||||||
void terminate();
|
|
||||||
|
|
||||||
public:
|
|
||||||
// Constructor
|
|
||||||
|
|
||||||
ConcurrentGCThread();
|
|
||||||
~ConcurrentGCThread() {} // Exists to call NamedThread destructor.
|
|
||||||
|
|
||||||
// Tester
|
|
||||||
bool is_ConcurrentGC_thread() const { return true; }
|
|
||||||
|
|
||||||
static void safepoint_synchronize();
|
|
||||||
static void safepoint_desynchronize();
|
|
||||||
|
|
||||||
// All overridings should probably do _sts::yield, but we allow
|
|
||||||
// overriding for distinguished debugging messages. Default is to do
|
|
||||||
// nothing.
|
|
||||||
virtual void yield() {}
|
|
||||||
|
|
||||||
bool should_yield() { return _sts.should_yield(); }
|
|
||||||
|
|
||||||
// they are prefixed by sts since there are already yield() and
|
|
||||||
// should_yield() (non-static) methods in this class and it was an
|
|
||||||
// easy way to differentiate them.
|
|
||||||
static void stsYield(const char* id);
|
|
||||||
static bool stsShouldYield();
|
|
||||||
static void stsJoin();
|
|
||||||
static void stsLeave();
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
// The SurrogateLockerThread is used by concurrent GC threads for
|
|
||||||
// manipulating Java monitors, in particular, currently for
|
|
||||||
// manipulating the pending_list_lock. XXX
|
|
||||||
class SurrogateLockerThread: public JavaThread {
|
|
||||||
friend class VMStructs;
|
|
||||||
public:
|
|
||||||
enum SLT_msg_type {
|
|
||||||
empty = 0, // no message
|
|
||||||
acquirePLL, // acquire pending list lock
|
|
||||||
releaseAndNotifyPLL // notify and release pending list lock
|
|
||||||
};
|
|
||||||
private:
|
|
||||||
// the following are shared with the CMSThread
|
|
||||||
SLT_msg_type _buffer; // communication buffer
|
|
||||||
Monitor _monitor; // monitor controlling buffer
|
|
||||||
BasicLock _basicLock; // used for PLL locking
|
|
||||||
|
|
||||||
public:
|
|
||||||
static SurrogateLockerThread* make(TRAPS);
|
|
||||||
|
|
||||||
SurrogateLockerThread();
|
|
||||||
|
|
||||||
bool is_hidden_from_external_view() const { return true; }
|
|
||||||
|
|
||||||
void loop(); // main method
|
|
||||||
|
|
||||||
void manipulatePLL(SLT_msg_type msg);
|
|
||||||
|
|
||||||
};
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue