8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
Summary: Checkpoint do_space_filter.ksh cleanups for Contended Locking.
Reviewed-by: sspitsyn, coleenp
--- a/hotspot/src/os/bsd/vm/os_bsd.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/os/bsd/vm/os_bsd.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -786,7 +786,7 @@
case os::java_thread:
// Java threads use ThreadStackSize which default value can be
// changed with the flag -Xss
- assert (JavaThread::stack_size_at_create() > 0, "this should be set");
+ assert(JavaThread::stack_size_at_create() > 0, "this should be set");
stack_size = JavaThread::stack_size_at_create();
break;
case os::compiler_thread:
@@ -1303,7 +1303,7 @@
if (pelements == NULL) {
return false;
}
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
// Really shouldn't be NULL, but check can't hurt
if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
continue; // skip the empty path values
@@ -1316,7 +1316,7 @@
}
}
// release the storage
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
if (pelements[i] != NULL) {
FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
}
@@ -1467,7 +1467,7 @@
bool failed_to_read_elf_head=
(sizeof(elf_head)!=
- (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
+ (::read(file_descriptor, &elf_head,sizeof(elf_head))));
::close(file_descriptor);
if (failed_to_read_elf_head) {
@@ -1565,7 +1565,7 @@
arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
int running_arch_index=-1;
- for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
+ for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) {
if (running_arch_code == arch_array[i].code) {
running_arch_index = i;
}
@@ -1596,7 +1596,7 @@
#endif // !S390
if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
- if ( lib_arch.name!=NULL ) {
+ if (lib_arch.name!=NULL) {
::snprintf(diag_msg_buf, diag_msg_max_length-1,
" (Possible cause: can't load %s-bit .so on a %s-bit platform)",
lib_arch.name, arch_array[running_arch_index].name);
@@ -2598,7 +2598,7 @@
sched_yield();
}
-os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN ;}
+os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN; }
void os::yield_all() {
// Yields to all threads, including threads with lower priorities
@@ -2686,7 +2686,7 @@
}
OSReturn os::set_native_priority(Thread* thread, int newpri) {
- if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) return OS_OK;
+ if (!UseThreadPriorities || ThreadPriorityPolicy == 0) return OS_OK;
#ifdef __OpenBSD__
// OpenBSD pthread_setprio starves low priority threads
@@ -2713,7 +2713,7 @@
}
OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
- if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) {
+ if (!UseThreadPriorities || ThreadPriorityPolicy == 0) {
*priority_ptr = java_to_os_priority[NormPriority];
return OS_OK;
}
@@ -3079,7 +3079,7 @@
}
struct sigaction* os::Bsd::get_preinstalled_handler(int sig) {
- if ((( (unsigned int)1 << sig ) & sigs) != 0) {
+ if ((((unsigned int)1 << sig) & sigs) != 0) {
return &sigact[sig];
}
return NULL;
@@ -3300,7 +3300,7 @@
address rh = VMError::get_resetted_sighandler(sig);
// May be, handler was resetted by VMError?
- if(rh != NULL) {
+ if (rh != NULL) {
handler = rh;
sa.sa_flags = VMError::get_resetted_sigflags(sig) & SIGNIFICANT_SIGNAL_MASK;
}
@@ -3309,11 +3309,11 @@
os::Posix::print_sa_flags(st, sa.sa_flags);
// Check: is it our handler?
- if(handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) ||
+ if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) ||
handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
// It is our signal handler
// check for flags, reset system-used one!
- if((int)sa.sa_flags != os::Bsd::get_our_sigflags(sig)) {
+ if ((int)sa.sa_flags != os::Bsd::get_our_sigflags(sig)) {
st->print(
", flags was changed from " PTR32_FORMAT ", consider using jsig library",
os::Bsd::get_our_sigflags(sig));
@@ -3382,10 +3382,10 @@
address thisHandler = (act.sa_flags & SA_SIGINFO)
? CAST_FROM_FN_PTR(address, act.sa_sigaction)
- : CAST_FROM_FN_PTR(address, act.sa_handler) ;
-
-
- switch(sig) {
+ : CAST_FROM_FN_PTR(address, act.sa_handler);
+
+
+ switch (sig) {
case SIGSEGV:
case SIGBUS:
case SIGFPE:
@@ -3515,22 +3515,22 @@
{
// Allocate a single page and mark it as readable for safepoint polling
address polling_page = (address) ::mmap(NULL, Bsd::page_size(), PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
- guarantee( polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page" );
-
- os::set_polling_page( polling_page );
+ guarantee(polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page");
+
+ os::set_polling_page(polling_page);
#ifndef PRODUCT
- if(Verbose && PrintMiscellaneous)
+ if (Verbose && PrintMiscellaneous)
tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
#endif
if (!UseMembar) {
address mem_serialize_page = (address) ::mmap(NULL, Bsd::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
- guarantee( mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
- os::set_memory_serialize_page( mem_serialize_page );
+ guarantee(mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
+ os::set_memory_serialize_page(mem_serialize_page);
#ifndef PRODUCT
- if(Verbose && PrintMiscellaneous)
+ if (Verbose && PrintMiscellaneous)
tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
#endif
}
@@ -3631,13 +3631,13 @@
// Mark the polling page as unreadable
void os::make_polling_page_unreadable(void) {
- if( !guard_memory((char*)_polling_page, Bsd::page_size()) )
+ if (!guard_memory((char*)_polling_page, Bsd::page_size()))
fatal("Could not disable polling page");
};
// Mark the polling page as readable
void os::make_polling_page_readable(void) {
- if( !bsd_mprotect((char *)_polling_page, Bsd::page_size(), PROT_READ)) {
+ if (!bsd_mprotect((char *)_polling_page, Bsd::page_size(), PROT_READ)) {
fatal("Could not enable polling page");
}
};
@@ -4229,9 +4229,9 @@
int os::PlatformEvent::TryPark() {
for (;;) {
- const int v = _Event ;
- guarantee ((v == 0) || (v == 1), "invariant") ;
- if (Atomic::cmpxchg (0, &_Event, v) == v) return v ;
+ const int v = _Event;
+ guarantee((v == 0) || (v == 1), "invariant");
+ if (Atomic::cmpxchg(0, &_Event, v) == v) return v;
}
}
@@ -4239,18 +4239,18 @@
// Invariant: Only the thread associated with the Event/PlatformEvent
// may call park().
// TODO: assert that _Assoc != NULL or _Assoc == Self
- int v ;
+ int v;
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
}
- guarantee (v >= 0, "invariant") ;
+ guarantee(v >= 0, "invariant");
if (v == 0) {
// Do this the hard way by blocking ...
int status = pthread_mutex_lock(_mutex);
assert_status(status == 0, status, "mutex_lock");
- guarantee (_nParked == 0, "invariant") ;
- ++ _nParked ;
+ guarantee(_nParked == 0, "invariant");
+ ++_nParked;
while (_Event < 0) {
status = pthread_cond_wait(_cond, _mutex);
// for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
@@ -4258,28 +4258,28 @@
if (status == ETIMEDOUT) { status = EINTR; }
assert_status(status == 0 || status == EINTR, status, "cond_wait");
}
- -- _nParked ;
-
- _Event = 0 ;
+ --_nParked;
+
+ _Event = 0;
status = pthread_mutex_unlock(_mutex);
assert_status(status == 0, status, "mutex_unlock");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other.
OrderAccess::fence();
}
- guarantee (_Event >= 0, "invariant") ;
+ guarantee(_Event >= 0, "invariant");
}
int os::PlatformEvent::park(jlong millis) {
- guarantee (_nParked == 0, "invariant") ;
-
- int v ;
+ guarantee(_nParked == 0, "invariant");
+
+ int v;
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
}
- guarantee (v >= 0, "invariant") ;
- if (v != 0) return OS_OK ;
+ guarantee(v >= 0, "invariant");
+ if (v != 0) return OS_OK;
// We do this the hard way, by blocking the thread.
// Consider enforcing a minimum timeout value.
@@ -4289,8 +4289,8 @@
int ret = OS_TIMEOUT;
int status = pthread_mutex_lock(_mutex);
assert_status(status == 0, status, "mutex_lock");
- guarantee (_nParked == 0, "invariant") ;
- ++_nParked ;
+ guarantee(_nParked == 0, "invariant");
+ ++_nParked;
// Object.wait(timo) will return because of
// (a) notification
@@ -4308,24 +4308,24 @@
while (_Event < 0) {
status = os::Bsd::safe_cond_timedwait(_cond, _mutex, &abst);
if (status != 0 && WorkAroundNPTLTimedWaitHang) {
- pthread_cond_destroy (_cond);
- pthread_cond_init (_cond, NULL) ;
+ pthread_cond_destroy(_cond);
+ pthread_cond_init(_cond, NULL);
}
assert_status(status == 0 || status == EINTR ||
status == ETIMEDOUT,
status, "cond_timedwait");
- if (!FilterSpuriousWakeups) break ; // previous semantics
- if (status == ETIMEDOUT) break ;
+ if (!FilterSpuriousWakeups) break; // previous semantics
+ if (status == ETIMEDOUT) break;
// We consume and ignore EINTR and spurious wakeups.
}
- --_nParked ;
+ --_nParked;
if (_Event >= 0) {
ret = OS_OK;
}
- _Event = 0 ;
+ _Event = 0;
status = pthread_mutex_unlock(_mutex);
assert_status(status == 0, status, "mutex_unlock");
- assert (_nParked == 0, "invariant") ;
+ assert(_nParked == 0, "invariant");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other.
OrderAccess::fence();
@@ -4409,7 +4409,7 @@
*/
static void unpackTime(struct timespec* absTime, bool isAbsolute, jlong time) {
- assert (time > 0, "convertTime");
+ assert(time > 0, "convertTime");
struct timeval now;
int status = gettimeofday(&now, NULL);
@@ -4470,7 +4470,7 @@
// Next, demultiplex/decode time arguments
struct timespec absTime;
- if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
+ if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
return;
}
if (time > 0) {
@@ -4492,11 +4492,11 @@
return;
}
- int status ;
+ int status;
if (_counter > 0) { // no wait needed
_counter = 0;
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
OrderAccess::fence();
@@ -4516,12 +4516,12 @@
// cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
if (time == 0) {
- status = pthread_cond_wait (_cond, _mutex) ;
+ status = pthread_cond_wait(_cond, _mutex);
} else {
- status = os::Bsd::safe_cond_timedwait (_cond, _mutex, &absTime) ;
+ status = os::Bsd::safe_cond_timedwait(_cond, _mutex, &absTime);
if (status != 0 && WorkAroundNPTLTimedWaitHang) {
- pthread_cond_destroy (_cond) ;
- pthread_cond_init (_cond, NULL);
+ pthread_cond_destroy(_cond);
+ pthread_cond_init(_cond, NULL);
}
}
assert_status(status == 0 || status == EINTR ||
@@ -4532,9 +4532,9 @@
pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
#endif
- _counter = 0 ;
- status = pthread_mutex_unlock(_mutex) ;
- assert_status(status == 0, status, "invariant") ;
+ _counter = 0;
+ status = pthread_mutex_unlock(_mutex);
+ assert_status(status == 0, status, "invariant");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
OrderAccess::fence();
@@ -4546,26 +4546,26 @@
}
void Parker::unpark() {
- int s, status ;
+ int s, status;
status = pthread_mutex_lock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
s = _counter;
_counter = 1;
if (s < 1) {
if (WorkAroundNPTLTimedWaitHang) {
- status = pthread_cond_signal (_cond) ;
- assert (status == 0, "invariant") ;
+ status = pthread_cond_signal(_cond);
+ assert(status == 0, "invariant");
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
} else {
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
- status = pthread_cond_signal (_cond) ;
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
+ status = pthread_cond_signal(_cond);
+ assert(status == 0, "invariant");
}
} else {
pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
}
}
--- a/hotspot/src/os/linux/vm/os_linux.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/os/linux/vm/os_linux.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -862,7 +862,7 @@
case os::java_thread:
// Java threads use ThreadStackSize which default value can be
// changed with the flag -Xss
- assert (JavaThread::stack_size_at_create() > 0, "this should be set");
+ assert(JavaThread::stack_size_at_create() > 0, "this should be set");
stack_size = JavaThread::stack_size_at_create();
break;
case os::compiler_thread:
@@ -1097,7 +1097,7 @@
if (low <= addr && addr < high) {
if (vma_low) *vma_low = low;
if (vma_high) *vma_high = high;
- fclose (fp);
+ fclose(fp);
return true;
}
}
@@ -1420,7 +1420,7 @@
// must return at least tp.tv_sec == 0 which means a resolution
// better than 1 sec. This is extra check for reliability.
- if(pthread_getcpuclockid_func &&
+ if (pthread_getcpuclockid_func &&
pthread_getcpuclockid_func(_main_thread, &clockid) == 0 &&
sys_clock_getres(clockid, &tp) == 0 && tp.tv_sec == 0) {
@@ -1630,7 +1630,7 @@
if (pelements == NULL) {
return false;
}
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
// Really shouldn't be NULL, but check can't hurt
if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
continue; // skip the empty path values
@@ -1642,7 +1642,7 @@
}
}
// release the storage
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
if (pelements[i] != NULL) {
FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
}
@@ -1906,7 +1906,7 @@
bool failed_to_read_elf_head=
(sizeof(elf_head)!=
- (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
+ (::read(file_descriptor, &elf_head,sizeof(elf_head))));
::close(file_descriptor);
if (failed_to_read_elf_head) {
@@ -1988,7 +1988,7 @@
arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
int running_arch_index=-1;
- for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
+ for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) {
if (running_arch_code == arch_array[i].code) {
running_arch_index = i;
}
@@ -2019,7 +2019,7 @@
#endif // !S390
if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
- if ( lib_arch.name!=NULL ) {
+ if (lib_arch.name!=NULL) {
::snprintf(diag_msg_buf, diag_msg_max_length-1,
" (Possible cause: can't load %s-bit .so on a %s-bit platform)",
lib_arch.name, arch_array[running_arch_index].name);
@@ -3793,7 +3793,7 @@
sched_yield();
}
-os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN ;}
+os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN; }
void os::yield_all() {
// Yields to all threads, including threads with lower priorities
@@ -3858,14 +3858,14 @@
}
OSReturn os::set_native_priority(Thread* thread, int newpri) {
- if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) return OS_OK;
+ if (!UseThreadPriorities || ThreadPriorityPolicy == 0) return OS_OK;
int ret = setpriority(PRIO_PROCESS, thread->osthread()->thread_id(), newpri);
return (ret == 0) ? OS_OK : OS_ERR;
}
OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
- if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) {
+ if (!UseThreadPriorities || ThreadPriorityPolicy == 0) {
*priority_ptr = java_to_os_priority[NormPriority];
return OS_OK;
}
@@ -4219,7 +4219,7 @@
}
struct sigaction* os::Linux::get_preinstalled_handler(int sig) {
- if ((( (unsigned int)1 << sig ) & sigs) != 0) {
+ if ((((unsigned int)1 << sig) & sigs) != 0) {
return &sigact[sig];
}
return NULL;
@@ -4423,7 +4423,7 @@
address rh = VMError::get_resetted_sighandler(sig);
// May be, handler was resetted by VMError?
- if(rh != NULL) {
+ if (rh != NULL) {
handler = rh;
sa.sa_flags = VMError::get_resetted_sigflags(sig) & SIGNIFICANT_SIGNAL_MASK;
}
@@ -4432,11 +4432,11 @@
os::Posix::print_sa_flags(st, sa.sa_flags);
// Check: is it our handler?
- if(handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) ||
+ if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) ||
handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
// It is our signal handler
// check for flags, reset system-used one!
- if((int)sa.sa_flags != os::Linux::get_our_sigflags(sig)) {
+ if ((int)sa.sa_flags != os::Linux::get_our_sigflags(sig)) {
st->print(
", flags was changed from " PTR32_FORMAT ", consider using jsig library",
os::Linux::get_our_sigflags(sig));
@@ -4507,10 +4507,10 @@
address thisHandler = (act.sa_flags & SA_SIGINFO)
? CAST_FROM_FN_PTR(address, act.sa_sigaction)
- : CAST_FROM_FN_PTR(address, act.sa_handler) ;
-
-
- switch(sig) {
+ : CAST_FROM_FN_PTR(address, act.sa_handler);
+
+
+ switch (sig) {
case SIGSEGV:
case SIGBUS:
case SIGFPE:
@@ -4662,22 +4662,22 @@
// Allocate a single page and mark it as readable for safepoint polling
address polling_page = (address) ::mmap(NULL, Linux::page_size(), PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
- guarantee( polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page" );
-
- os::set_polling_page( polling_page );
+ guarantee(polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page");
+
+ os::set_polling_page(polling_page);
#ifndef PRODUCT
- if(Verbose && PrintMiscellaneous)
+ if (Verbose && PrintMiscellaneous)
tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
#endif
if (!UseMembar) {
address mem_serialize_page = (address) ::mmap(NULL, Linux::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
- guarantee( mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
- os::set_memory_serialize_page( mem_serialize_page );
+ guarantee(mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
+ os::set_memory_serialize_page(mem_serialize_page);
#ifndef PRODUCT
- if(Verbose && PrintMiscellaneous)
+ if (Verbose && PrintMiscellaneous)
tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
#endif
}
@@ -4819,13 +4819,13 @@
// Mark the polling page as unreadable
void os::make_polling_page_unreadable(void) {
- if( !guard_memory((char*)_polling_page, Linux::page_size()) )
+ if (!guard_memory((char*)_polling_page, Linux::page_size()))
fatal("Could not disable polling page");
};
// Mark the polling page as readable
void os::make_polling_page_readable(void) {
- if( !linux_mprotect((char *)_polling_page, Linux::page_size(), PROT_READ)) {
+ if (!linux_mprotect((char *)_polling_page, Linux::page_size(), PROT_READ)) {
fatal("Could not enable polling page");
}
};
@@ -5288,7 +5288,7 @@
snprintf(proc_name, 64, "/proc/self/task/%d/stat", tid);
fp = fopen(proc_name, "r");
- if ( fp == NULL ) return -1;
+ if (fp == NULL) return -1;
statlen = fread(stat, 1, 2047, fp);
stat[statlen] = '\0';
fclose(fp);
@@ -5300,7 +5300,7 @@
// We don't really need to know the command string, just find the last
// occurrence of ")" and then start parsing from there. See bug 4726580.
s = strrchr(stat, ')');
- if (s == NULL ) return -1;
+ if (s == NULL) return -1;
// Skip blank chars
do s++; while (isspace(*s));
@@ -5309,7 +5309,7 @@
&cdummy, &idummy, &idummy, &idummy, &idummy, &idummy,
&ldummy, &ldummy, &ldummy, &ldummy, &ldummy,
&user_time, &sys_time);
- if ( count != 13 ) return -1;
+ if (count != 13) return -1;
if (user_sys_cpu_time) {
return ((jlong)sys_time + (jlong)user_time) * (1000000000 / clock_tics_per_sec);
} else {
@@ -5468,9 +5468,9 @@
int os::PlatformEvent::TryPark() {
for (;;) {
- const int v = _Event ;
- guarantee ((v == 0) || (v == 1), "invariant") ;
- if (Atomic::cmpxchg (0, &_Event, v) == v) return v ;
+ const int v = _Event;
+ guarantee((v == 0) || (v == 1), "invariant");
+ if (Atomic::cmpxchg(0, &_Event, v) == v) return v;
}
}
@@ -5478,18 +5478,18 @@
// Invariant: Only the thread associated with the Event/PlatformEvent
// may call park().
// TODO: assert that _Assoc != NULL or _Assoc == Self
- int v ;
+ int v;
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
- }
- guarantee (v >= 0, "invariant") ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
+ }
+ guarantee(v >= 0, "invariant");
if (v == 0) {
// Do this the hard way by blocking ...
int status = pthread_mutex_lock(_mutex);
assert_status(status == 0, status, "mutex_lock");
- guarantee (_nParked == 0, "invariant") ;
- ++ _nParked ;
+ guarantee(_nParked == 0, "invariant");
+ ++_nParked;
while (_Event < 0) {
status = pthread_cond_wait(_cond, _mutex);
// for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
@@ -5497,28 +5497,28 @@
if (status == ETIME) { status = EINTR; }
assert_status(status == 0 || status == EINTR, status, "cond_wait");
}
- -- _nParked ;
-
- _Event = 0 ;
+ --_nParked;
+
+ _Event = 0;
status = pthread_mutex_unlock(_mutex);
assert_status(status == 0, status, "mutex_unlock");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other.
OrderAccess::fence();
}
- guarantee (_Event >= 0, "invariant") ;
+ guarantee(_Event >= 0, "invariant");
}
int os::PlatformEvent::park(jlong millis) {
- guarantee (_nParked == 0, "invariant") ;
-
- int v ;
+ guarantee(_nParked == 0, "invariant");
+
+ int v;
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
- }
- guarantee (v >= 0, "invariant") ;
- if (v != 0) return OS_OK ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
+ }
+ guarantee(v >= 0, "invariant");
+ if (v != 0) return OS_OK;
// We do this the hard way, by blocking the thread.
// Consider enforcing a minimum timeout value.
@@ -5528,8 +5528,8 @@
int ret = OS_TIMEOUT;
int status = pthread_mutex_lock(_mutex);
assert_status(status == 0, status, "mutex_lock");
- guarantee (_nParked == 0, "invariant") ;
- ++_nParked ;
+ guarantee(_nParked == 0, "invariant");
+ ++_nParked;
// Object.wait(timo) will return because of
// (a) notification
@@ -5547,24 +5547,24 @@
while (_Event < 0) {
status = os::Linux::safe_cond_timedwait(_cond, _mutex, &abst);
if (status != 0 && WorkAroundNPTLTimedWaitHang) {
- pthread_cond_destroy (_cond);
- pthread_cond_init (_cond, os::Linux::condAttr()) ;
+ pthread_cond_destroy(_cond);
+ pthread_cond_init(_cond, os::Linux::condAttr());
}
assert_status(status == 0 || status == EINTR ||
status == ETIME || status == ETIMEDOUT,
status, "cond_timedwait");
- if (!FilterSpuriousWakeups) break ; // previous semantics
- if (status == ETIME || status == ETIMEDOUT) break ;
+ if (!FilterSpuriousWakeups) break; // previous semantics
+ if (status == ETIME || status == ETIMEDOUT) break;
// We consume and ignore EINTR and spurious wakeups.
}
- --_nParked ;
+ --_nParked;
if (_Event >= 0) {
ret = OS_OK;
}
- _Event = 0 ;
+ _Event = 0;
status = pthread_mutex_unlock(_mutex);
assert_status(status == 0, status, "mutex_unlock");
- assert (_nParked == 0, "invariant") ;
+ assert(_nParked == 0, "invariant");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other.
OrderAccess::fence();
@@ -5647,7 +5647,7 @@
*/
static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
- assert (time > 0, "convertTime");
+ assert(time > 0, "convertTime");
time_t max_secs = 0;
if (!os::supports_monotonic_clock() || isAbsolute) {
@@ -5726,7 +5726,7 @@
// Next, demultiplex/decode time arguments
timespec absTime;
- if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
+ if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
return;
}
if (time > 0) {
@@ -5748,11 +5748,11 @@
return;
}
- int status ;
+ int status;
if (_counter > 0) { // no wait needed
_counter = 0;
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
OrderAccess::fence();
@@ -5774,13 +5774,13 @@
assert(_cur_index == -1, "invariant");
if (time == 0) {
_cur_index = REL_INDEX; // arbitrary choice when not timed
- status = pthread_cond_wait (&_cond[_cur_index], _mutex) ;
+ status = pthread_cond_wait(&_cond[_cur_index], _mutex);
} else {
_cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;
- status = os::Linux::safe_cond_timedwait (&_cond[_cur_index], _mutex, &absTime) ;
+ status = os::Linux::safe_cond_timedwait(&_cond[_cur_index], _mutex, &absTime);
if (status != 0 && WorkAroundNPTLTimedWaitHang) {
- pthread_cond_destroy (&_cond[_cur_index]) ;
- pthread_cond_init (&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr());
+ pthread_cond_destroy(&_cond[_cur_index]);
+ pthread_cond_init(&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr());
}
}
_cur_index = -1;
@@ -5792,9 +5792,9 @@
pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
#endif
- _counter = 0 ;
- status = pthread_mutex_unlock(_mutex) ;
- assert_status(status == 0, status, "invariant") ;
+ _counter = 0;
+ status = pthread_mutex_unlock(_mutex);
+ assert_status(status == 0, status, "invariant");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
OrderAccess::fence();
@@ -5806,9 +5806,9 @@
}
void Parker::unpark() {
- int s, status ;
+ int s, status;
status = pthread_mutex_lock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
s = _counter;
_counter = 1;
if (s < 1) {
@@ -5817,22 +5817,22 @@
// thread is definitely parked
if (WorkAroundNPTLTimedWaitHang) {
status = pthread_cond_signal (&_cond[_cur_index]);
- assert (status == 0, "invariant");
+ assert(status == 0, "invariant");
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant");
+ assert(status == 0, "invariant");
} else {
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant");
+ assert(status == 0, "invariant");
status = pthread_cond_signal (&_cond[_cur_index]);
- assert (status == 0, "invariant");
+ assert(status == 0, "invariant");
}
} else {
pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
}
} else {
pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
}
}
--- a/hotspot/src/os/solaris/vm/os_solaris.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/os/solaris/vm/os_solaris.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -212,13 +212,13 @@
"sp must be inside of selected thread stack");
thread->set_self_raw_id(raw_id); // mark for quick retrieval
- _get_thread_cache[ index ] = thread;
+ _get_thread_cache[index] = thread;
}
return thread;
}
-static const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0};
+static const double all_zero[sizeof(Thread) / sizeof(double) + 1] = {0};
#define NO_CACHED_THREAD ((Thread*)all_zero)
void ThreadLocalStorage::pd_set_thread(Thread* thread) {
@@ -270,8 +270,8 @@
}
address os::current_stack_base() {
- int r = thr_main() ;
- guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
+ int r = thr_main();
+ guarantee(r == 0 || r == 1, "CR6501650 or CR6493689");
bool is_primordial_thread = r;
// Workaround 4352906, avoid calls to thr_stksegment by
@@ -293,9 +293,9 @@
size_t os::current_stack_size() {
size_t size;
- int r = thr_main() ;
- guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
- if(!r) {
+ int r = thr_main();
+ guarantee(r == 0 || r == 1, "CR6501650 or CR6493689");
+ if (!r) {
size = get_stack_info().ss_size;
} else {
struct rlimit limits;
@@ -409,7 +409,7 @@
static bool find_processors_online(processorid_t** id_array,
uint* id_length) {
- const processorid_t MAX_PROCESSOR_ID = 100000 ;
+ const processorid_t MAX_PROCESSOR_ID = 100000;
// Find the number of processors online.
*id_length = sysconf(_SC_NPROCESSORS_ONLN);
// Make up an array to hold their ids.
@@ -436,7 +436,7 @@
// we've got. Note that in the worst case find_processors_online() could
// return an empty set. (As a fall-back in the case of the empty set we
// could just return the ID of the current processor).
- *id_length = found ;
+ *id_length = found;
}
return true;
@@ -552,13 +552,13 @@
}
bool os::getenv(const char* name, char* buffer, int len) {
- char* val = ::getenv( name );
- if ( val == NULL
+ char* val = ::getenv(name);
+ if (val == NULL
|| strlen(val) + 1 > len ) {
if (len > 0) buffer[0] = 0; // return a null string
return false;
}
- strcpy( buffer, val );
+ strcpy(buffer, val);
return true;
}
@@ -672,7 +672,7 @@
// Determine search path count and required buffer size.
if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) {
- FREE_C_HEAP_ARRAY(char, buf, mtInternal);
+ FREE_C_HEAP_ARRAY(char, buf, mtInternal);
vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror());
}
@@ -683,7 +683,7 @@
// Obtain search path information.
if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) {
- FREE_C_HEAP_ARRAY(char, buf, mtInternal);
+ FREE_C_HEAP_ARRAY(char, buf, mtInternal);
FREE_C_HEAP_ARRAY(char, info, mtInternal);
vm_exit_during_initialization("dlinfo SERINFO request", dlerror());
}
@@ -794,7 +794,7 @@
bool os::Solaris::valid_stack_address(Thread* thread, address sp) {
address stackStart = (address)thread->stack_base();
address stackEnd = (address)(stackStart - (address)thread->stack_size());
- if (sp < stackStart && sp >= stackEnd ) return true;
+ if (sp < stackStart && sp >= stackEnd) return true;
return false;
}
@@ -819,8 +819,8 @@
Thread* thread = (Thread*)thread_addr;
OSThread* osthr = thread->osthread();
- osthr->set_lwp_id( _lwp_self() ); // Store lwp in case we are bound
- thread->_schedctl = (void *) schedctl_init () ;
+ osthr->set_lwp_id(_lwp_self()); // Store lwp in case we are bound
+ thread->_schedctl = (void *) schedctl_init();
if (UseNUMA) {
int lgrp_id = os::numa_get_group_id();
@@ -839,8 +839,8 @@
// in java_to_os_priority. So we save the native priority
// in the osThread and recall it here.
- if ( osthr->thread_id() != -1 ) {
- if ( UseThreadPriorities ) {
+ if (osthr->thread_id() != -1) {
+ if (UseThreadPriorities) {
int prio = osthr->native_priority();
if (ThreadPriorityVerbose) {
tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is "
@@ -882,7 +882,7 @@
// Store info on the Solaris thread into the OSThread
osthread->set_thread_id(thread_id);
osthread->set_lwp_id(_lwp_self());
- thread->_schedctl = (void *) schedctl_init () ;
+ thread->_schedctl = (void *) schedctl_init();
if (UseNUMA) {
int lgrp_id = os::numa_get_group_id();
@@ -891,9 +891,9 @@
}
}
- if ( ThreadPriorityVerbose ) {
+ if (ThreadPriorityVerbose) {
tty->print_cr("In create_os_thread, Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT "\n",
- osthread->thread_id(), osthread->lwp_id() );
+ osthread->thread_id(), osthread->lwp_id());
}
// Initial thread state is INITIALIZED, not SUSPENDED
@@ -974,9 +974,9 @@
return false;
}
- if ( ThreadPriorityVerbose ) {
+ if (ThreadPriorityVerbose) {
char *thrtyp;
- switch ( thr_type ) {
+ switch (thr_type) {
case vm_thread:
thrtyp = (char *)"vm";
break;
@@ -1207,11 +1207,11 @@
// First crack at OS-specific initialization, from inside the new thread.
void os::initialize_thread(Thread* thr) {
- int r = thr_main() ;
- guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
+ int r = thr_main();
+ guarantee(r == 0 || r == 1, "CR6501650 or CR6493689");
if (r) {
JavaThread* jt = (JavaThread *)thr;
- assert(jt != NULL,"Sanity check");
+ assert(jt != NULL, "Sanity check");
size_t stack_size;
address base = jt->stack_base();
if (Arguments::created_by_java_launcher()) {
@@ -1322,7 +1322,7 @@
// JavaThread in Java code, and have stubs simply
// treat %g2 as a caller-save register, preserving it in a %lN.
thread_key_t tk;
- if (thr_keycreate( &tk, NULL ) )
+ if (thr_keycreate( &tk, NULL))
fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed "
"(%s)", strerror(errno)));
return int(tk);
@@ -1347,7 +1347,7 @@
"(%s)", strerror(errno)));
}
} else {
- ThreadLocalStorage::set_thread_in_slot ((Thread *) value) ;
+ ThreadLocalStorage::set_thread_in_slot((Thread *) value);
}
}
@@ -1579,7 +1579,7 @@
if (pelements == NULL) {
return false;
}
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
// really shouldn't be NULL but what the heck, check can't hurt
if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
continue; // skip the empty path values
@@ -1591,7 +1591,7 @@
}
}
// release the storage
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
if (pelements[i] != NULL) {
FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
}
@@ -1795,7 +1795,7 @@
bool failed_to_read_elf_head=
(sizeof(elf_head)!=
- (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
+ (::read(file_descriptor, &elf_head,sizeof(elf_head))));
::close(file_descriptor);
if (failed_to_read_elf_head) {
@@ -1851,7 +1851,7 @@
arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
int running_arch_index=-1;
- for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
+ for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) {
if (running_arch_code == arch_array[i].code) {
running_arch_index = i;
}
@@ -1880,7 +1880,7 @@
}
if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
- if ( lib_arch.name!=NULL ) {
+ if (lib_arch.name!=NULL) {
::snprintf(diag_msg_buf, diag_msg_max_length-1,
" (Possible cause: can't load %s-bit .so on a %s-bit platform)",
lib_arch.name, arch_array[running_arch_index].name);
@@ -1969,7 +1969,7 @@
int fd = ::open("/proc/self/map",O_RDONLY);
if (fd >= 0) {
prmap_t p;
- while(::read(fd, &p, sizeof(p)) > 0) {
+ while (::read(fd, &p, sizeof(p)) > 0) {
if (p.pr_vaddr == 0x0) {
st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname);
st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname);
@@ -2079,7 +2079,7 @@
address rh = VMError::get_resetted_sighandler(sig);
// May be, handler was resetted by VMError?
- if(rh != NULL) {
+ if (rh != NULL) {
handler = rh;
sa.sa_flags = VMError::get_resetted_sigflags(sig);
}
@@ -2088,11 +2088,11 @@
os::Posix::print_sa_flags(st, sa.sa_flags);
// Check: is it our handler?
- if(handler == CAST_FROM_FN_PTR(address, signalHandler) ||
+ if (handler == CAST_FROM_FN_PTR(address, signalHandler) ||
handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {
// It is our signal handler
// check for flags
- if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {
+ if (sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {
st->print(
", flags was changed from " PTR32_FORMAT ", consider using jsig library",
os::Solaris::get_our_sigflags(sig));
@@ -2403,7 +2403,7 @@
do {
thread->set_suspend_equivalent();
// cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
- while((ret = ::sema_wait(&sig_sem)) == EINTR)
+ while ((ret = ::sema_wait(&sig_sem)) == EINTR)
;
assert(ret == 0, "sema_wait() failed");
@@ -2635,7 +2635,7 @@
}
if (!r) {
// That's a leaf node.
- assert (bottom <= cur, "Sanity check");
+ assert(bottom <= cur, "Sanity check");
// Check if the node has memory
if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur],
NULL, 0, LGRP_RSRC_MEM) > 0) {
@@ -3051,7 +3051,7 @@
const size_t size_limit =
FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes;
int beg;
- for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */ ;
+ for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */;
const int end = MIN2((int)usable_count, n) - 1;
for (int cur = 0; cur < end; ++cur, ++beg) {
_page_sizes[cur] = _page_sizes[beg];
@@ -3264,7 +3264,7 @@
//
// Return errno or 0 if OK.
//
-static int lwp_priocntl_init () {
+static int lwp_priocntl_init() {
int rslt;
pcinfo_t ClassInfo;
pcparms_t ParmInfo;
@@ -3274,7 +3274,7 @@
// If ThreadPriorityPolicy is 1, switch tables
if (ThreadPriorityPolicy == 1) {
- for (i = 0 ; i < CriticalPriority+1; i++)
+ for (i = 0; i < CriticalPriority+1; i++)
os::java_to_os_priority[i] = prio_policy1[i];
}
if (UseCriticalJavaThreadPriority) {
@@ -3373,12 +3373,12 @@
} else {
// No clue - punt
if (ThreadPriorityVerbose)
- tty->print_cr ("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname);
+ tty->print_cr("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname);
return EINVAL; // no clue, punt
}
if (ThreadPriorityVerbose) {
- tty->print_cr ("Thread priority Range: [%d..%d]\n", myMin, myMax);
+ tty->print_cr("Thread priority Range: [%d..%d]\n", myMin, myMax);
}
priocntl_enable = true; // Enable changing priorities
@@ -3424,7 +3424,7 @@
// TODO: elide set-to-same-value
// If something went wrong on init, don't change priorities.
- if ( !priocntl_enable ) {
+ if (!priocntl_enable) {
if (ThreadPriorityVerbose)
tty->print_cr("Trying to set priority but init failed, ignoring");
return EINVAL;
@@ -3432,9 +3432,9 @@
// If lwp hasn't started yet, just return
// the _start routine will call us again.
- if ( lwpid <= 0 ) {
+ if (lwpid <= 0) {
if (ThreadPriorityVerbose) {
- tty->print_cr ("deferring the set_lwp_class_and_priority of thread "
+ tty->print_cr("deferring the set_lwp_class_and_priority of thread "
INTPTR_FORMAT " to %d, lwpid not set",
ThreadID, newPrio);
}
@@ -3653,7 +3653,7 @@
OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
int p;
- if ( !UseThreadPriorities ) {
+ if (!UseThreadPriorities) {
*priority_ptr = NormalPriority;
return OS_OK;
}
@@ -4099,7 +4099,7 @@
void os::run_periodic_checks() {
// A big source of grief is hijacking virt. addr 0x0 on Solaris,
// thereby preventing a NULL checks.
- if(!check_addr0_done) check_addr0_done = check_addr0(tty);
+ if (!check_addr0_done) check_addr0_done = check_addr0(tty);
if (check_signals == false) return;
@@ -4148,10 +4148,10 @@
address thisHandler = (act.sa_flags & SA_SIGINFO)
? CAST_FROM_FN_PTR(address, act.sa_sigaction)
- : CAST_FROM_FN_PTR(address, act.sa_handler) ;
-
-
- switch(sig) {
+ : CAST_FROM_FN_PTR(address, act.sa_handler);
+
+
+ switch (sig) {
case SIGSEGV:
case SIGBUS:
case SIGFPE:
@@ -4332,7 +4332,7 @@
static address resolve_symbol_lazy(const char* name) {
address addr = (address) dlsym(RTLD_DEFAULT, name);
- if(addr == NULL) {
+ if (addr == NULL) {
// RTLD_DEFAULT was not defined on some early versions of 2.5.1
addr = (address) dlsym(RTLD_NEXT, name);
}
@@ -4341,7 +4341,7 @@
static address resolve_symbol(const char* name) {
address addr = resolve_symbol_lazy(name);
- if(addr == NULL) {
+ if (addr == NULL) {
fatal(dlerror());
}
return addr;
@@ -4353,7 +4353,7 @@
lwp_priocntl_init();
// RTLD_DEFAULT was not defined on some early versions of 5.5.1
- if(func == NULL) {
+ if (func == NULL) {
func = (address) dlsym(RTLD_NEXT, "_thr_suspend_allmutators");
// Guarantee that this VM is running on an new enough OS (5.6 or
// later) that it will have a new enough libthread.so.
@@ -4384,7 +4384,7 @@
int os::Solaris::_cond_scope = USYNC_THREAD;
void os::Solaris::synchronization_init() {
- if(UseLWPSynchronization) {
+ if (UseLWPSynchronization) {
os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_lock")));
os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_trylock")));
os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_unlock")));
@@ -4404,7 +4404,7 @@
os::Solaris::set_mutex_scope(USYNC_THREAD);
os::Solaris::set_cond_scope(USYNC_THREAD);
- if(UsePthreads) {
+ if (UsePthreads) {
os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock")));
os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_trylock")));
os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_unlock")));
@@ -4576,17 +4576,17 @@
os::set_polling_page(polling_page);
#ifndef PRODUCT
- if( Verbose && PrintMiscellaneous )
+ if (Verbose && PrintMiscellaneous)
tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
#endif
if (!UseMembar) {
- address mem_serialize_page = (address)Solaris::mmap_chunk( NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE );
- guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page");
- os::set_memory_serialize_page( mem_serialize_page );
+ address mem_serialize_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE);
+ guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page");
+ os::set_memory_serialize_page(mem_serialize_page);
#ifndef PRODUCT
- if(Verbose && PrintMiscellaneous)
+ if (Verbose && PrintMiscellaneous)
tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
#endif
}
@@ -4725,13 +4725,13 @@
// Mark the polling page as unreadable
void os::make_polling_page_unreadable(void) {
- if( mprotect((char *)_polling_page, page_size, PROT_NONE) != 0 )
+ if (mprotect((char *)_polling_page, page_size, PROT_NONE) != 0)
fatal("Could not disable polling page");
};
// Mark the polling page as readable
void os::make_polling_page_readable(void) {
- if( mprotect((char *)_polling_page, page_size, PROT_READ) != 0 )
+ if (mprotect((char *)_polling_page, page_size, PROT_READ) != 0)
fatal("Could not enable polling page");
};
@@ -5221,7 +5221,7 @@
getpid(),
thread->osthread()->lwp_id());
fd = ::open(proc_name, O_RDONLY);
- if ( fd == -1 ) return -1;
+ if (fd == -1) return -1;
do {
count = ::pread(fd,
@@ -5230,7 +5230,7 @@
thr_time_off);
} while (count < 0 && errno == EINTR);
::close(fd);
- if ( count < 0 ) return -1;
+ if (count < 0) return -1;
if (user_sys_cpu_time) {
// user + system CPU time
@@ -5244,7 +5244,7 @@
(jlong)prusage.pr_utime.tv_nsec;
}
- return(lwp_time);
+ return (lwp_time);
}
void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
@@ -5448,43 +5448,43 @@
int os::PlatformEvent::TryPark() {
for (;;) {
- const int v = _Event ;
- guarantee ((v == 0) || (v == 1), "invariant") ;
- if (Atomic::cmpxchg (0, &_Event, v) == v) return v ;
+ const int v = _Event;
+ guarantee((v == 0) || (v == 1), "invariant");
+ if (Atomic::cmpxchg(0, &_Event, v) == v) return v;
}
}
void os::PlatformEvent::park() { // AKA: down()
// Invariant: Only the thread associated with the Event/PlatformEvent
// may call park().
- int v ;
+ int v;
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
- }
- guarantee (v >= 0, "invariant") ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
+ }
+ guarantee(v >= 0, "invariant");
if (v == 0) {
// Do this the hard way by blocking ...
// See http://monaco.sfbay/detail.jsf?cr=5094058.
// TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
// Only for SPARC >= V8PlusA
#if defined(__sparc) && defined(COMPILER2)
- if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
+ if (ClearFPUAtPark) { _mark_fpu_nosave(); }
#endif
int status = os::Solaris::mutex_lock(_mutex);
- assert_status(status == 0, status, "mutex_lock");
- guarantee (_nParked == 0, "invariant") ;
- ++ _nParked ;
+ assert_status(status == 0, status, "mutex_lock");
+ guarantee(_nParked == 0, "invariant");
+ ++_nParked;
while (_Event < 0) {
// for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
// Treat this the same as if the wait was interrupted
// With usr/lib/lwp going to kernel, always handle ETIME
status = os::Solaris::cond_wait(_cond, _mutex);
- if (status == ETIME) status = EINTR ;
+ if (status == ETIME) status = EINTR;
assert_status(status == 0 || status == EINTR, status, "cond_wait");
}
- -- _nParked ;
- _Event = 0 ;
+ --_nParked;
+ _Event = 0;
status = os::Solaris::mutex_unlock(_mutex);
assert_status(status == 0, status, "mutex_unlock");
// Paranoia to ensure our locked and lock-free paths interact
@@ -5494,41 +5494,41 @@
}
int os::PlatformEvent::park(jlong millis) {
- guarantee (_nParked == 0, "invariant") ;
- int v ;
+ guarantee(_nParked == 0, "invariant");
+ int v;
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
- }
- guarantee (v >= 0, "invariant") ;
- if (v != 0) return OS_OK ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
+ }
+ guarantee(v >= 0, "invariant");
+ if (v != 0) return OS_OK;
int ret = OS_TIMEOUT;
timestruc_t abst;
- compute_abstime (&abst, millis);
+ compute_abstime(&abst, millis);
// See http://monaco.sfbay/detail.jsf?cr=5094058.
// For Solaris SPARC set fprs.FEF=0 prior to parking.
// Only for SPARC >= V8PlusA
#if defined(__sparc) && defined(COMPILER2)
- if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
+ if (ClearFPUAtPark) { _mark_fpu_nosave(); }
#endif
int status = os::Solaris::mutex_lock(_mutex);
assert_status(status == 0, status, "mutex_lock");
- guarantee (_nParked == 0, "invariant") ;
- ++ _nParked ;
+ guarantee(_nParked == 0, "invariant");
+ ++_nParked;
while (_Event < 0) {
int status = os::Solaris::cond_timedwait(_cond, _mutex, &abst);
assert_status(status == 0 || status == EINTR ||
status == ETIME || status == ETIMEDOUT,
status, "cond_timedwait");
- if (!FilterSpuriousWakeups) break ; // previous semantics
- if (status == ETIME || status == ETIMEDOUT) break ;
+ if (!FilterSpuriousWakeups) break; // previous semantics
+ if (status == ETIME || status == ETIMEDOUT) break;
// We consume and ignore EINTR and spurious wakeups.
}
- -- _nParked ;
- if (_Event >= 0) ret = OS_OK ;
- _Event = 0 ;
+ --_nParked;
+ if (_Event >= 0) ret = OS_OK;
+ _Event = 0;
status = os::Solaris::mutex_unlock(_mutex);
assert_status(status == 0, status, "mutex_unlock");
// Paranoia to ensure our locked and lock-free paths interact
@@ -5605,7 +5605,7 @@
* years from "now".
*/
static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
- assert (time > 0, "convertTime");
+ assert(time > 0, "convertTime");
struct timeval now;
int status = gettimeofday(&now, NULL);
@@ -5664,7 +5664,7 @@
// First, demultiplex/decode time arguments
timespec absTime;
- if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
+ if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
return;
}
if (time > 0) {
@@ -5688,12 +5688,12 @@
return;
}
- int status ;
+ int status;
if (_counter > 0) { // no wait needed
_counter = 0;
status = os::Solaris::mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
+ assert(status == 0, "invariant");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
OrderAccess::fence();
@@ -5717,11 +5717,11 @@
// TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
// Only for SPARC >= V8PlusA
#if defined(__sparc) && defined(COMPILER2)
- if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
+ if (ClearFPUAtPark) { _mark_fpu_nosave(); }
#endif
if (time == 0) {
- status = os::Solaris::cond_wait (_cond, _mutex) ;
+ status = os::Solaris::cond_wait(_cond, _mutex);
} else {
status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime);
}
@@ -5734,9 +5734,9 @@
#ifdef ASSERT
thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);
#endif
- _counter = 0 ;
+ _counter = 0;
status = os::Solaris::mutex_unlock(_mutex);
- assert_status(status == 0, status, "mutex_unlock") ;
+ assert_status(status == 0, status, "mutex_unlock");
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
OrderAccess::fence();
@@ -5748,17 +5748,17 @@
}
void Parker::unpark() {
- int s, status ;
- status = os::Solaris::mutex_lock (_mutex) ;
- assert (status == 0, "invariant") ;
+ int s, status;
+ status = os::Solaris::mutex_lock(_mutex);
+ assert(status == 0, "invariant");
s = _counter;
_counter = 1;
- status = os::Solaris::mutex_unlock (_mutex) ;
- assert (status == 0, "invariant") ;
+ status = os::Solaris::mutex_unlock(_mutex);
+ assert(status == 0, "invariant");
if (s < 1) {
- status = os::Solaris::cond_signal (_cond) ;
- assert (status == 0, "invariant") ;
+ status = os::Solaris::cond_signal(_cond);
+ assert(status == 0, "invariant");
}
}
@@ -5925,14 +5925,14 @@
gettimeofday(&t, &aNull);
prevtime = ((julong)t.tv_sec * 1000) + t.tv_usec / 1000;
- for(;;) {
+ for (;;) {
res = ::poll(&pfd, 1, timeout);
- if(res == OS_ERR && errno == EINTR) {
- if(timeout != -1) {
+ if (res == OS_ERR && errno == EINTR) {
+ if (timeout != -1) {
gettimeofday(&t, &aNull);
newtime = ((julong)t.tv_sec * 1000) + t.tv_usec /1000;
timeout -= newtime - prevtime;
- if(timeout <= 0)
+ if (timeout <= 0)
return OS_OK;
prevtime = newtime;
}
--- a/hotspot/src/os/windows/vm/os_windows.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/os/windows/vm/os_windows.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -125,11 +125,11 @@
switch (reason) {
case DLL_PROCESS_ATTACH:
vm_lib_handle = hinst;
- if(ForceTimeHighResolution)
+ if (ForceTimeHighResolution)
timeBeginPeriod(1L);
break;
case DLL_PROCESS_DETACH:
- if(ForceTimeHighResolution)
+ if (ForceTimeHighResolution)
timeEndPeriod(1L);
// Workaround for issue when a custom launcher doesn't call
@@ -318,7 +318,7 @@
*/
address os::get_caller_pc(int n) {
#ifdef _NMT_NOINLINE_
- n ++;
+ n++;
#endif
address pc;
if (os::Kernel32Dll::RtlCaptureStackBackTrace(n + 1, 1, (PVOID*)&pc, NULL) == 1) {
@@ -345,10 +345,10 @@
// Add up the sizes of all the regions with the same
// AllocationBase.
- while( 1 )
+ while (1)
{
VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo));
- if ( stack_bottom == (address)minfo.AllocationBase )
+ if (stack_bottom == (address)minfo.AllocationBase)
stack_size += minfo.RegionSize;
else
break;
@@ -644,7 +644,7 @@
jlong as_long(LARGE_INTEGER x) {
jlong result = 0; // initialization to avoid warning
set_high(&result, x.HighPart);
- set_low(&result, x.LowPart);
+ set_low(&result, x.LowPart);
return result;
}
@@ -999,7 +999,7 @@
#endif
cwd = get_current_directory(NULL, 0);
- jio_snprintf(buffer, bufferSize, "%s\\hs_err_pid%u.mdmp",cwd, current_process_id());
+ jio_snprintf(buffer, bufferSize, "%s\\hs_err_pid%u.mdmp", cwd, current_process_id());
dumpFile = CreateFile(buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (dumpFile == INVALID_HANDLE_VALUE) {
@@ -1217,7 +1217,7 @@
if (pelements == NULL) {
return false;
}
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
char* path = pelements[i];
// Really shouldn't be NULL, but check can't hurt
size_t plen = (path == NULL) ? 0 : strlen(path);
@@ -1236,7 +1236,7 @@
}
}
// release the storage
- for (int i = 0 ; i < n ; i++) {
+ for (int i = 0; i < n; i++) {
if (pelements[i] != NULL) {
FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
}
@@ -1271,12 +1271,12 @@
MODULEINFO minfo;
hmod = GetModuleHandle("NTDLL.DLL");
- if ( hmod == NULL ) return false;
- if ( !os::PSApiDll::GetModuleInformation( GetCurrentProcess(), hmod,
+ if (hmod == NULL) return false;
+ if (!os::PSApiDll::GetModuleInformation( GetCurrentProcess(), hmod,
&minfo, sizeof(MODULEINFO)) )
return false;
- if ( (addr >= minfo.lpBaseOfDll) &&
+ if ((addr >= minfo.lpBaseOfDll) &&
(addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage)))
return true;
else
@@ -1304,11 +1304,11 @@
// enumerate_modules for Windows NT, using PSAPI
static int _enumerate_modules_winnt( int pid, EnumModulesCallbackFunc func, void * param)
{
- HANDLE hProcess ;
+ HANDLE hProcess;
# define MAX_NUM_MODULES 128
HMODULE modules[MAX_NUM_MODULES];
- static char filename[ MAX_PATH ];
+ static char filename[MAX_PATH];
int result = 0;
if (!os::PSApiDll::PSApiAvailable()) {
@@ -1316,13 +1316,13 @@
}
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
- FALSE, pid ) ;
+ FALSE, pid);
if (hProcess == NULL) return 0;
DWORD size_needed;
if (!os::PSApiDll::EnumProcessModules(hProcess, modules,
sizeof(modules), &size_needed)) {
- CloseHandle( hProcess );
+ CloseHandle(hProcess);
return 0;
}
@@ -1331,7 +1331,7 @@
for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
// Get Full pathname:
- if(!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i],
+ if (!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i],
filename, sizeof(filename))) {
filename[0] = '\0';
}
@@ -1349,7 +1349,7 @@
if (result) break;
}
- CloseHandle( hProcess ) ;
+ CloseHandle(hProcess);
return result;
}
@@ -1357,8 +1357,8 @@
// enumerate_modules for Windows 95/98/ME, using TOOLHELP
static int _enumerate_modules_windows( int pid, EnumModulesCallbackFunc func, void *param)
{
- HANDLE hSnapShot ;
- static MODULEENTRY32 modentry ;
+ HANDLE hSnapShot;
+ static MODULEENTRY32 modentry;
int result = 0;
if (!os::Kernel32Dll::HelpToolsAvailable()) {
@@ -1366,22 +1366,22 @@
}
// Get a handle to a Toolhelp snapshot of the system
- hSnapShot = os::Kernel32Dll::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid ) ;
- if( hSnapShot == INVALID_HANDLE_VALUE ) {
- return FALSE ;
+ hSnapShot = os::Kernel32Dll::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
+ if (hSnapShot == INVALID_HANDLE_VALUE) {
+ return FALSE;
}
// iterate through all modules
- modentry.dwSize = sizeof(MODULEENTRY32) ;
+ modentry.dwSize = sizeof(MODULEENTRY32);
bool not_done = os::Kernel32Dll::Module32First( hSnapShot, &modentry ) != 0;
- while( not_done ) {
+ while (not_done) {
// invoke the callback
result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr,
modentry.modBaseSize, param);
if (result) break;
- modentry.dwSize = sizeof(MODULEENTRY32) ;
+ modentry.dwSize = sizeof(MODULEENTRY32);
not_done = os::Kernel32Dll::Module32Next( hSnapShot, &modentry ) != 0;
}
@@ -1941,7 +1941,7 @@
// that raises SIGTERM for the latter cases.
//
static BOOL WINAPI consoleHandler(DWORD event) {
- switch(event) {
+ switch (event) {
case CTRL_C_EVENT:
if (is_error_reported()) {
// Ctrl-C is pressed during error reporting, likely because the error
@@ -1965,7 +1965,7 @@
HANDLE handle = GetProcessWindowStation();
if (handle != NULL &&
GetUserObjectInformation(handle, UOI_FLAGS, &flags,
- sizeof( USEROBJECTFLAGS), NULL)) {
+ sizeof(USEROBJECTFLAGS), NULL)) {
// If it is a non-interactive session, let next handler to deal
// with it.
if ((flags.dwFlags & WSF_VISIBLE) == 0) {
@@ -1991,7 +1991,7 @@
// Return maximum OS signal used + 1 for internal use only
// Used as exit signal for signal_thread
-int os::sigexitnum_pd(){
+int os::sigexitnum_pd() {
return NSIG;
}
@@ -2422,11 +2422,11 @@
// process of write protecting the memory serialization page.
// It write enables the page immediately after protecting it
// so just return.
- if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
+ if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
JavaThread* thread = (JavaThread*) t;
PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
address addr = (address) exceptionRecord->ExceptionInformation[1];
- if ( os::is_memory_serialize_page(thread, addr) ) {
+ if (os::is_memory_serialize_page(thread, addr)) {
// Block current thread until the memory serialize page permission restored.
os::block_on_serialize_page_trap();
return EXCEPTION_CONTINUE_EXECUTION;
@@ -2543,7 +2543,7 @@
//
PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
address addr = (address) exceptionRecord->ExceptionInformation[1];
- if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
+ if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base()) {
addr = (address)((uintptr_t)addr &
(~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
os::commit_memory((char *)addr, thread->stack_base() - addr,
@@ -2623,7 +2623,7 @@
// Compiled method patched to be non entrant? Following conditions must apply:
// 1. must be first instruction in bundle
// 2. must be a break instruction with appropriate code
- if((((uint64_t) pc & 0x0F) == 0) &&
+ if ((((uint64_t) pc & 0x0F) == 0) &&
(((IPF_Bundle*) pc)->get_slot0() == handle_wrong_method_break.bits())) {
return Handle_Exception(exceptionInfo,
(address)SharedRuntime::get_handle_wrong_method_stub());
@@ -2794,7 +2794,7 @@
return (_numa_used_node_count > 1);
}
- int get_count() {return _numa_used_node_count;}
+ int get_count() { return _numa_used_node_count; }
int get_node_list_entry(int n) {
// for indexes out of range, returns -1
return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
@@ -3112,14 +3112,14 @@
res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
} else {
elapsedTimer reserveTimer;
- if( Verbose && PrintMiscellaneous ) reserveTimer.start();
+ if (Verbose && PrintMiscellaneous) reserveTimer.start();
// in numa interleaving, we have to allocate pages individually
// (well really chunks of NUMAInterleaveGranularity size)
res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
if (res == NULL) {
warning("NUMA page allocation failed");
}
- if( Verbose && PrintMiscellaneous ) {
+ if (Verbose && PrintMiscellaneous) {
reserveTimer.stop();
tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes,
reserveTimer.milliseconds(), reserveTimer.ticks());
@@ -3450,14 +3450,14 @@
int os::sleep(Thread* thread, jlong ms, bool interruptable) {
jlong limit = (jlong) MAXDWORD;
- while(ms > limit) {
+ while (ms > limit) {
int res;
if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
return res;
ms -= limit;
}
- assert(thread == Thread::current(), "thread consistency check");
+ assert(thread == Thread::current(), "thread consistency check");
OSThread* osthread = thread->osthread();
OSThreadWaitState osts(osthread, false /* not Object.wait() */);
int result;
@@ -3473,8 +3473,8 @@
HANDLE events[1];
events[0] = osthread->interrupt_event();
HighResolutionInterval *phri=NULL;
- if(!ForceTimeHighResolution)
- phri = new HighResolutionInterval( ms );
+ if (!ForceTimeHighResolution)
+ phri = new HighResolutionInterval(ms);
if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
result = OS_TIMEOUT;
} else {
@@ -3511,17 +3511,17 @@
}
}
-typedef BOOL (WINAPI * STTSignature)(void) ;
+typedef BOOL (WINAPI * STTSignature)(void);
os::YieldResult os::NakedYield() {
// Use either SwitchToThread() or Sleep(0)
// Consider passing back the return value from SwitchToThread().
if (os::Kernel32Dll::SwitchToThreadAvailable()) {
- return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
+ return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY;
} else {
Sleep(0);
}
- return os::YIELD_UNKNOWN ;
+ return os::YIELD_UNKNOWN;
}
void os::yield() { os::NakedYield(); }
@@ -3574,7 +3574,7 @@
}
}
if (UseCriticalJavaThreadPriority) {
- os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority] ;
+ os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority];
}
return 0;
}
@@ -3586,7 +3586,7 @@
}
OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
- if ( !UseThreadPriorities ) {
+ if (!UseThreadPriorities) {
*priority_ptr = java_to_os_priority[NormPriority];
return OS_OK;
}
@@ -3620,8 +3620,8 @@
if (thread->is_Java_thread())
((JavaThread*)thread)->parker()->unpark();
- ParkEvent * ev = thread->_ParkEvent ;
- if (ev != NULL) ev->unpark() ;
+ ParkEvent * ev = thread->_ParkEvent;
+ if (ev != NULL) ev->unpark();
}
@@ -3715,7 +3715,7 @@
OSVERSIONINFOEX oi;
oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
GetVersionEx((OSVERSIONINFO*)&oi);
- switch(oi.dwPlatformId) {
+ switch (oi.dwPlatformId) {
case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
case VER_PLATFORM_WIN32_NT:
_is_nt = true;
@@ -3898,29 +3898,29 @@
jint os::init_2(void) {
// Allocate a single page and mark it as readable for safepoint polling
address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
- guarantee( polling_page != NULL, "Reserve Failed for polling page");
+ guarantee(polling_page != NULL, "Reserve Failed for polling page");
address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
- guarantee( return_page != NULL, "Commit Failed for polling page");
-
- os::set_polling_page( polling_page );
+ guarantee(return_page != NULL, "Commit Failed for polling page");
+
+ os::set_polling_page(polling_page);
#ifndef PRODUCT
- if( Verbose && PrintMiscellaneous )
+ if (Verbose && PrintMiscellaneous)
tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
#endif
if (!UseMembar) {
address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
- guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
+ guarantee(mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
- guarantee( return_page != NULL, "Commit Failed for memory serialize page");
-
- os::set_memory_serialize_page( mem_serialize_page );
+ guarantee(return_page != NULL, "Commit Failed for memory serialize page");
+
+ os::set_memory_serialize_page(mem_serialize_page);
#ifndef PRODUCT
- if(Verbose && PrintMiscellaneous)
+ if (Verbose && PrintMiscellaneous)
tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
#endif
}
@@ -4036,14 +4036,14 @@
// Mark the polling page as unreadable
void os::make_polling_page_unreadable(void) {
DWORD old_status;
- if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
+ if (!VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status))
fatal("Could not disable polling page");
};
// Mark the polling page as readable
void os::make_polling_page_readable(void) {
DWORD old_status;
- if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
+ if (!VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status))
fatal("Could not enable polling page");
};
@@ -4121,7 +4121,7 @@
FILETIME KernelTime;
FILETIME UserTime;
- if ( GetThreadTimes(thread->osthread()->thread_handle(),
+ if (GetThreadTimes(thread->osthread()->thread_handle(),
&CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
return -1;
else
@@ -4157,7 +4157,7 @@
FILETIME KernelTime;
FILETIME UserTime;
- if ( GetThreadTimes(GetCurrentThread(),
+ if (GetThreadTimes(GetCurrentThread(),
&CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
return false;
else
@@ -4391,7 +4391,7 @@
int os::fsync(int fd) {
HANDLE handle = (HANDLE)::_get_osfhandle(fd);
- if ( (!::FlushFileBuffers(handle)) &&
+ if ((!::FlushFileBuffers(handle)) &&
(GetLastError() != ERROR_ACCESS_DENIED) ) {
/* from winerror.h */
return -1;
@@ -4512,7 +4512,7 @@
}
/* Examine input records for the number of bytes available */
- for(i=0; i<numEvents; i++) {
+ for (i=0; i<numEvents; i++) {
if (lpBuffer[i].EventType == KEY_EVENT) {
KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
@@ -4527,7 +4527,7 @@
}
}
- if(lpBuffer != NULL) {
+ if (lpBuffer != NULL) {
os::free(lpBuffer, mtInternal);
}
@@ -4790,19 +4790,19 @@
// with explicit "PARKED" and "SIGNALED" bits.
int os::PlatformEvent::park (jlong Millis) {
- guarantee (_ParkHandle != NULL , "Invariant") ;
- guarantee (Millis > 0 , "Invariant") ;
- int v ;
+ guarantee(_ParkHandle != NULL , "Invariant");
+ guarantee(Millis > 0 , "Invariant");
+ int v;
// CONSIDER: defer assigning a CreateEvent() handle to the Event until
// the initial park() operation.
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
}
- guarantee ((v == 0) || (v == 1), "invariant") ;
- if (v != 0) return OS_OK ;
+ guarantee((v == 0) || (v == 1), "invariant");
+ if (v != 0) return OS_OK;
// Do this the hard way by blocking ...
// TODO: consider a brief spin here, gated on the success of recent
@@ -4820,59 +4820,59 @@
// In the future, however, we might want to track the accumulated wait time and
// adjust Millis accordingly if we encounter a spurious wakeup.
- const int MAXTIMEOUT = 0x10000000 ;
- DWORD rv = WAIT_TIMEOUT ;
+ const int MAXTIMEOUT = 0x10000000;
+ DWORD rv = WAIT_TIMEOUT;
while (_Event < 0 && Millis > 0) {
- DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT)
+ DWORD prd = Millis; // set prd = MAX (Millis, MAXTIMEOUT)
if (Millis > MAXTIMEOUT) {
- prd = MAXTIMEOUT ;
+ prd = MAXTIMEOUT;
}
- rv = ::WaitForSingleObject (_ParkHandle, prd) ;
- assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
+ rv = ::WaitForSingleObject(_ParkHandle, prd);
+ assert(rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed");
if (rv == WAIT_TIMEOUT) {
- Millis -= prd ;
+ Millis -= prd;
}
}
- v = _Event ;
- _Event = 0 ;
+ v = _Event;
+ _Event = 0;
// see comment at end of os::PlatformEvent::park() below:
- OrderAccess::fence() ;
+ OrderAccess::fence();
// If we encounter a nearly simultanous timeout expiry and unpark()
// we return OS_OK indicating we awoke via unpark().
// Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
- return (v >= 0) ? OS_OK : OS_TIMEOUT ;
-}
-
-void os::PlatformEvent::park () {
- guarantee (_ParkHandle != NULL, "Invariant") ;
+ return (v >= 0) ? OS_OK : OS_TIMEOUT;
+}
+
+void os::PlatformEvent::park() {
+ guarantee(_ParkHandle != NULL, "Invariant");
// Invariant: Only the thread associated with the Event/PlatformEvent
// may call park().
- int v ;
+ int v;
for (;;) {
- v = _Event ;
- if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
+ v = _Event;
+ if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
}
- guarantee ((v == 0) || (v == 1), "invariant") ;
- if (v != 0) return ;
+ guarantee((v == 0) || (v == 1), "invariant");
+ if (v != 0) return;
// Do this the hard way by blocking ...
// TODO: consider a brief spin here, gated on the success of recent
// spin attempts by this thread.
while (_Event < 0) {
- DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
- assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
+ DWORD rv = ::WaitForSingleObject(_ParkHandle, INFINITE);
+ assert(rv == WAIT_OBJECT_0, "WaitForSingleObject failed");
}
// Usually we'll find _Event == 0 at this point, but as
// an optional optimization we clear it, just in case can
// multiple unpark() operations drove _Event up to 1.
- _Event = 0 ;
- OrderAccess::fence() ;
- guarantee (_Event >= 0, "invariant") ;
+ _Event = 0;
+ OrderAccess::fence();
+ guarantee(_Event >= 0, "invariant");
}
void os::PlatformEvent::unpark() {
- guarantee (_ParkHandle != NULL, "Invariant") ;
+ guarantee(_ParkHandle != NULL, "Invariant");
// Transitions for _Event:
// 0 :=> 1
@@ -4907,7 +4907,7 @@
void Parker::park(bool isAbsolute, jlong time) {
- guarantee (_ParkEvent != NULL, "invariant") ;
+ guarantee(_ParkEvent != NULL, "invariant");
// First, demultiplex/decode time arguments
if (time < 0) { // don't wait
return;
@@ -4941,7 +4941,7 @@
OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
jt->set_suspend_equivalent();
- WaitForSingleObject(_ParkEvent, time);
+ WaitForSingleObject(_ParkEvent, time);
ResetEvent(_ParkEvent);
// If externally suspended while waiting, re-suspend
@@ -4952,7 +4952,7 @@
}
void Parker::unpark() {
- guarantee (_ParkEvent != NULL, "invariant") ;
+ guarantee(_ParkEvent != NULL, "invariant");
SetEvent(_ParkEvent);
}
@@ -5040,7 +5040,7 @@
LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
DWORD exception_code = e->ExceptionRecord->ExceptionCode;
- if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
+ if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
address addr = (address) exceptionRecord->ExceptionInformation[1];
--- a/hotspot/src/share/vm/runtime/objectMonitor.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/share/vm/runtime/objectMonitor.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -114,38 +114,38 @@
// The knob* variables are effectively final. Once set they should
// never be modified hence. Consider using __read_mostly with GCC.
-int ObjectMonitor::Knob_Verbose = 0 ;
-int ObjectMonitor::Knob_SpinLimit = 5000 ; // derived by an external tool -
-static int Knob_LogSpins = 0 ; // enable jvmstat tally for spins
-static int Knob_HandOff = 0 ;
-static int Knob_ReportSettings = 0 ;
+int ObjectMonitor::Knob_Verbose = 0;
+int ObjectMonitor::Knob_SpinLimit = 5000; // derived by an external tool -
+static int Knob_LogSpins = 0; // enable jvmstat tally for spins
+static int Knob_HandOff = 0;
+static int Knob_ReportSettings = 0;
-static int Knob_SpinBase = 0 ; // Floor AKA SpinMin
-static int Knob_SpinBackOff = 0 ; // spin-loop backoff
-static int Knob_CASPenalty = -1 ; // Penalty for failed CAS
-static int Knob_OXPenalty = -1 ; // Penalty for observed _owner change
-static int Knob_SpinSetSucc = 1 ; // spinners set the _succ field
-static int Knob_SpinEarly = 1 ;
-static int Knob_SuccEnabled = 1 ; // futile wake throttling
-static int Knob_SuccRestrict = 0 ; // Limit successors + spinners to at-most-one
-static int Knob_MaxSpinners = -1 ; // Should be a function of # CPUs
-static int Knob_Bonus = 100 ; // spin success bonus
-static int Knob_BonusB = 100 ; // spin success bonus
-static int Knob_Penalty = 200 ; // spin failure penalty
-static int Knob_Poverty = 1000 ;
-static int Knob_SpinAfterFutile = 1 ; // Spin after returning from park()
-static int Knob_FixedSpin = 0 ;
-static int Knob_OState = 3 ; // Spinner checks thread state of _owner
-static int Knob_UsePause = 1 ;
-static int Knob_ExitPolicy = 0 ;
-static int Knob_PreSpin = 10 ; // 20-100 likely better
-static int Knob_ResetEvent = 0 ;
-static int BackOffMask = 0 ;
+static int Knob_SpinBase = 0; // Floor AKA SpinMin
+static int Knob_SpinBackOff = 0; // spin-loop backoff
+static int Knob_CASPenalty = -1; // Penalty for failed CAS
+static int Knob_OXPenalty = -1; // Penalty for observed _owner change
+static int Knob_SpinSetSucc = 1; // spinners set the _succ field
+static int Knob_SpinEarly = 1;
+static int Knob_SuccEnabled = 1; // futile wake throttling
+static int Knob_SuccRestrict = 0; // Limit successors + spinners to at-most-one
+static int Knob_MaxSpinners = -1; // Should be a function of # CPUs
+static int Knob_Bonus = 100; // spin success bonus
+static int Knob_BonusB = 100; // spin success bonus
+static int Knob_Penalty = 200; // spin failure penalty
+static int Knob_Poverty = 1000;
+static int Knob_SpinAfterFutile = 1; // Spin after returning from park()
+static int Knob_FixedSpin = 0;
+static int Knob_OState = 3; // Spinner checks thread state of _owner
+static int Knob_UsePause = 1;
+static int Knob_ExitPolicy = 0;
+static int Knob_PreSpin = 10; // 20-100 likely better
+static int Knob_ResetEvent = 0;
+static int BackOffMask = 0;
-static int Knob_FastHSSEC = 0 ;
-static int Knob_MoveNotifyee = 2 ; // notify() - disposition of notifyee
-static int Knob_QMode = 0 ; // EntryList-cxq policy - queue discipline
-static volatile int InitDone = 0 ;
+static int Knob_FastHSSEC = 0;
+static int Knob_MoveNotifyee = 2; // notify() - disposition of notifyee
+static int Knob_QMode = 0; // EntryList-cxq policy - queue discipline
+static volatile int InitDone = 0;
#define TrySpin TrySpin_VaryDuration
@@ -265,9 +265,9 @@
if (THREAD != _owner) {
if (THREAD->is_lock_owned ((address)_owner)) {
assert(_recursions == 0, "internal state error");
- _owner = THREAD ;
- _recursions = 1 ;
- OwnerIsThread = 1 ;
+ _owner = THREAD;
+ _recursions = 1;
+ OwnerIsThread = 1;
return true;
}
if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
@@ -283,37 +283,37 @@
void ATTR ObjectMonitor::enter(TRAPS) {
// The following code is ordered to check the most common cases first
// and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors.
- Thread * const Self = THREAD ;
- void * cur ;
+ Thread * const Self = THREAD;
+ void * cur;
- cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
+ cur = Atomic::cmpxchg_ptr(Self, &_owner, NULL);
if (cur == NULL) {
// Either ASSERT _recursions == 0 or explicitly set _recursions = 0.
- assert (_recursions == 0 , "invariant") ;
- assert (_owner == Self, "invariant") ;
+ assert(_recursions == 0 , "invariant");
+ assert(_owner == Self, "invariant");
// CONSIDER: set or assert OwnerIsThread == 1
- return ;
+ return;
}
if (cur == Self) {
// TODO-FIXME: check for integer overflow! BUGID 6557169.
- _recursions ++ ;
- return ;
+ _recursions++;
+ return;
}
if (Self->is_lock_owned ((address)cur)) {
- assert (_recursions == 0, "internal state error");
- _recursions = 1 ;
+ assert(_recursions == 0, "internal state error");
+ _recursions = 1;
// Commute owner from a thread-specific on-stack BasicLockObject address to
// a full-fledged "Thread *".
- _owner = Self ;
- OwnerIsThread = 1 ;
- return ;
+ _owner = Self;
+ OwnerIsThread = 1;
+ return;
}
// We've encountered genuine contention.
- assert (Self->_Stalled == 0, "invariant") ;
- Self->_Stalled = intptr_t(this) ;
+ assert(Self->_Stalled == 0, "invariant");
+ Self->_Stalled = intptr_t(this);
// Try one round of spinning *before* enqueueing Self
// and before going through the awkward and expensive state
@@ -321,21 +321,21 @@
// Note that if we acquire the monitor from an initial spin
// we forgo posting JVMTI events and firing DTRACE probes.
if (Knob_SpinEarly && TrySpin (Self) > 0) {
- assert (_owner == Self , "invariant") ;
- assert (_recursions == 0 , "invariant") ;
- assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
- Self->_Stalled = 0 ;
- return ;
+ assert(_owner == Self , "invariant");
+ assert(_recursions == 0 , "invariant");
+ assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
+ Self->_Stalled = 0;
+ return;
}
- assert (_owner != Self , "invariant") ;
- assert (_succ != Self , "invariant") ;
- assert (Self->is_Java_thread() , "invariant") ;
- JavaThread * jt = (JavaThread *) Self ;
- assert (!SafepointSynchronize::is_at_safepoint(), "invariant") ;
- assert (jt->thread_state() != _thread_blocked , "invariant") ;
- assert (this->object() != NULL , "invariant") ;
- assert (_count >= 0, "invariant") ;
+ assert(_owner != Self , "invariant");
+ assert(_succ != Self , "invariant");
+ assert(Self->is_Java_thread() , "invariant");
+ JavaThread * jt = (JavaThread *) Self;
+ assert(!SafepointSynchronize::is_at_safepoint(), "invariant");
+ assert(jt->thread_state() != _thread_blocked , "invariant");
+ assert(this->object() != NULL , "invariant");
+ assert(_count >= 0, "invariant");
// Prevent deflation at STW-time. See deflate_idle_monitors() and is_busy().
// Ensure the object-monitor relationship remains stable while there's contention.
@@ -368,9 +368,9 @@
// cleared by handle_special_suspend_equivalent_condition()
// or java_suspend_self()
- EnterI (THREAD) ;
+ EnterI(THREAD);
- if (!ExitSuspendEquivalent(jt)) break ;
+ if (!ExitSuspendEquivalent(jt)) break;
//
// We have acquired the contended monitor, but while we were
@@ -378,9 +378,9 @@
// the monitor while suspended because that would surprise the
// thread that suspended us.
//
- _recursions = 0 ;
- _succ = NULL ;
- exit (false, Self) ;
+ _recursions = 0;
+ _succ = NULL;
+ exit(false, Self);
jt->java_suspend_self();
}
@@ -397,14 +397,14 @@
}
Atomic::dec_ptr(&_count);
- assert (_count >= 0, "invariant") ;
- Self->_Stalled = 0 ;
+ assert(_count >= 0, "invariant");
+ Self->_Stalled = 0;
// Must either set _recursions = 0 or ASSERT _recursions == 0.
- assert (_recursions == 0 , "invariant") ;
- assert (_owner == Self , "invariant") ;
- assert (_succ != Self , "invariant") ;
- assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
+ assert(_recursions == 0 , "invariant");
+ assert(_owner == Self , "invariant");
+ assert(_succ != Self , "invariant");
+ assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
// The thread -- now the owner -- is back in vm mode.
// Report the glorious news via TI,DTrace and jvmstat.
@@ -437,7 +437,7 @@
}
if (ObjectMonitor::_sync_ContendedLockAttempts != NULL) {
- ObjectMonitor::_sync_ContendedLockAttempts->inc() ;
+ ObjectMonitor::_sync_ContendedLockAttempts->inc();
}
}
@@ -447,37 +447,37 @@
int ObjectMonitor::TryLock (Thread * Self) {
for (;;) {
- void * own = _owner ;
- if (own != NULL) return 0 ;
+ void * own = _owner;
+ if (own != NULL) return 0;
if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
// Either guarantee _recursions == 0 or set _recursions = 0.
- assert (_recursions == 0, "invariant") ;
- assert (_owner == Self, "invariant") ;
+ assert(_recursions == 0, "invariant");
+ assert(_owner == Self, "invariant");
// CONSIDER: set or assert that OwnerIsThread == 1
- return 1 ;
+ return 1;
}
// The lock had been free momentarily, but we lost the race to the lock.
// Interference -- the CAS failed.
// We can either return -1 or retry.
// Retry doesn't make as much sense because the lock was just acquired.
- if (true) return -1 ;
+ if (true) return -1;
}
}
void ATTR ObjectMonitor::EnterI (TRAPS) {
- Thread * Self = THREAD ;
- assert (Self->is_Java_thread(), "invariant") ;
- assert (((JavaThread *) Self)->thread_state() == _thread_blocked , "invariant") ;
+ Thread * Self = THREAD;
+ assert(Self->is_Java_thread(), "invariant");
+ assert(((JavaThread *) Self)->thread_state() == _thread_blocked , "invariant");
// Try the lock - TATAS
if (TryLock (Self) > 0) {
- assert (_succ != Self , "invariant") ;
- assert (_owner == Self , "invariant") ;
- assert (_Responsible != Self , "invariant") ;
- return ;
+ assert(_succ != Self , "invariant");
+ assert(_owner == Self , "invariant");
+ assert(_Responsible != Self , "invariant");
+ return;
}
- DeferredInitialize () ;
+ DeferredInitialize();
// We try one round of spinning *before* enqueueing Self.
//
@@ -487,16 +487,16 @@
// effects.
if (TrySpin (Self) > 0) {
- assert (_owner == Self , "invariant") ;
- assert (_succ != Self , "invariant") ;
- assert (_Responsible != Self , "invariant") ;
- return ;
+ assert(_owner == Self , "invariant");
+ assert(_succ != Self , "invariant");
+ assert(_Responsible != Self , "invariant");
+ return;
}
// The Spin failed -- Enqueue and park the thread ...
- assert (_succ != Self , "invariant") ;
- assert (_owner != Self , "invariant") ;
- assert (_Responsible != Self , "invariant") ;
+ assert(_succ != Self , "invariant");
+ assert(_owner != Self , "invariant");
+ assert(_Responsible != Self , "invariant");
// Enqueue "Self" on ObjectMonitor's _cxq.
//
@@ -508,27 +508,27 @@
// TODO: eliminate ObjectWaiter and enqueue either Threads or Events.
//
- ObjectWaiter node(Self) ;
- Self->_ParkEvent->reset() ;
- node._prev = (ObjectWaiter *) 0xBAD ;
- node.TState = ObjectWaiter::TS_CXQ ;
+ ObjectWaiter node(Self);
+ Self->_ParkEvent->reset();
+ node._prev = (ObjectWaiter *) 0xBAD;
+ node.TState = ObjectWaiter::TS_CXQ;
// Push "Self" onto the front of the _cxq.
// Once on cxq/EntryList, Self stays on-queue until it acquires the lock.
// Note that spinning tends to reduce the rate at which threads
// enqueue and dequeue on EntryList|cxq.
- ObjectWaiter * nxt ;
+ ObjectWaiter * nxt;
for (;;) {
- node._next = nxt = _cxq ;
- if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) break ;
+ node._next = nxt = _cxq;
+ if (Atomic::cmpxchg_ptr(&node, &_cxq, nxt) == nxt) break;
// Interference - the CAS failed because _cxq changed. Just retry.
// As an optional optimization we retry the lock.
if (TryLock (Self) > 0) {
- assert (_succ != Self , "invariant") ;
- assert (_owner == Self , "invariant") ;
- assert (_Responsible != Self , "invariant") ;
- return ;
+ assert(_succ != Self , "invariant");
+ assert(_owner == Self , "invariant");
+ assert(_Responsible != Self , "invariant");
+ return;
}
}
@@ -558,7 +558,7 @@
if ((SyncFlags & 16) == 0 && nxt == NULL && _EntryList == NULL) {
// Try to assume the role of responsible thread for the monitor.
// CONSIDER: ST vs CAS vs { if (Responsible==null) Responsible=Self }
- Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
+ Atomic::cmpxchg_ptr(Self, &_Responsible, NULL);
}
// The lock have been released while this thread was occupied queueing
@@ -572,49 +572,49 @@
// to defer the state transitions until absolutely necessary,
// and in doing so avoid some transitions ...
- TEVENT (Inflated enter - Contention) ;
- int nWakeups = 0 ;
- int RecheckInterval = 1 ;
+ TEVENT(Inflated enter - Contention);
+ int nWakeups = 0;
+ int RecheckInterval = 1;
for (;;) {
- if (TryLock (Self) > 0) break ;
- assert (_owner != Self, "invariant") ;
+ if (TryLock(Self) > 0) break;
+ assert(_owner != Self, "invariant");
if ((SyncFlags & 2) && _Responsible == NULL) {
- Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
+ Atomic::cmpxchg_ptr(Self, &_Responsible, NULL);
}
// park self
if (_Responsible == Self || (SyncFlags & 1)) {
- TEVENT (Inflated enter - park TIMED) ;
- Self->_ParkEvent->park ((jlong) RecheckInterval) ;
+ TEVENT(Inflated enter - park TIMED);
+ Self->_ParkEvent->park((jlong) RecheckInterval);
// Increase the RecheckInterval, but clamp the value.
- RecheckInterval *= 8 ;
- if (RecheckInterval > 1000) RecheckInterval = 1000 ;
+ RecheckInterval *= 8;
+ if (RecheckInterval > 1000) RecheckInterval = 1000;
} else {
- TEVENT (Inflated enter - park UNTIMED) ;
- Self->_ParkEvent->park() ;
+ TEVENT(Inflated enter - park UNTIMED);
+ Self->_ParkEvent->park();
}
- if (TryLock(Self) > 0) break ;
+ if (TryLock(Self) > 0) break;
// The lock is still contested.
// Keep a tally of the # of futile wakeups.
// Note that the counter is not protected by a lock or updated by atomics.
// That is by design - we trade "lossy" counters which are exposed to
// races during updates for a lower probe effect.
- TEVENT (Inflated enter - Futile wakeup) ;
+ TEVENT(Inflated enter - Futile wakeup);
if (ObjectMonitor::_sync_FutileWakeups != NULL) {
- ObjectMonitor::_sync_FutileWakeups->inc() ;
+ ObjectMonitor::_sync_FutileWakeups->inc();
}
- ++ nWakeups ;
+ ++nWakeups;
// Assuming this is not a spurious wakeup we'll normally find _succ == Self.
// We can defer clearing _succ until after the spin completes
// TrySpin() must tolerate being called with _succ == Self.
// Try yet another round of adaptive spinning.
- if ((Knob_SpinAfterFutile & 1) && TrySpin (Self) > 0) break ;
+ if ((Knob_SpinAfterFutile & 1) && TrySpin(Self) > 0) break;
// We can find that we were unpark()ed and redesignated _succ while
// we were spinning. That's harmless. If we iterate and call park(),
@@ -625,13 +625,13 @@
// in the next iteration.
if ((Knob_ResetEvent & 1) && Self->_ParkEvent->fired()) {
- Self->_ParkEvent->reset() ;
- OrderAccess::fence() ;
+ Self->_ParkEvent->reset();
+ OrderAccess::fence();
}
- if (_succ == Self) _succ = NULL ;
+ if (_succ == Self) _succ = NULL;
// Invariant: after clearing _succ a thread *must* retry _owner before parking.
- OrderAccess::fence() ;
+ OrderAccess::fence();
}
// Egress :
@@ -642,18 +642,18 @@
// The head of cxq is volatile but the interior is stable.
// In addition, Self.TState is stable.
- assert (_owner == Self , "invariant") ;
- assert (object() != NULL , "invariant") ;
+ assert(_owner == Self , "invariant");
+ assert(object() != NULL , "invariant");
// I'd like to write:
// guarantee (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
// but as we're at a safepoint that's not safe.
- UnlinkAfterAcquire (Self, &node) ;
- if (_succ == Self) _succ = NULL ;
+ UnlinkAfterAcquire(Self, &node);
+ if (_succ == Self) _succ = NULL;
- assert (_succ != Self, "invariant") ;
+ assert(_succ != Self, "invariant");
if (_Responsible == Self) {
- _Responsible = NULL ;
+ _Responsible = NULL;
OrderAccess::fence(); // Dekker pivot-point
// We may leave threads on cxq|EntryList without a designated
@@ -700,9 +700,9 @@
// execute a serializing instruction.
if (SyncFlags & 8) {
- OrderAccess::fence() ;
+ OrderAccess::fence();
}
- return ;
+ return;
}
// ReenterI() is a specialized inline form of the latter half of the
@@ -714,24 +714,24 @@
// loop accordingly.
void ATTR ObjectMonitor::ReenterI (Thread * Self, ObjectWaiter * SelfNode) {
- assert (Self != NULL , "invariant") ;
- assert (SelfNode != NULL , "invariant") ;
- assert (SelfNode->_thread == Self , "invariant") ;
- assert (_waiters > 0 , "invariant") ;
- assert (((oop)(object()))->mark() == markOopDesc::encode(this) , "invariant") ;
- assert (((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant") ;
- JavaThread * jt = (JavaThread *) Self ;
+ assert(Self != NULL , "invariant");
+ assert(SelfNode != NULL , "invariant");
+ assert(SelfNode->_thread == Self , "invariant");
+ assert(_waiters > 0 , "invariant");
+ assert(((oop)(object()))->mark() == markOopDesc::encode(this) , "invariant");
+ assert(((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant");
+ JavaThread * jt = (JavaThread *) Self;
- int nWakeups = 0 ;
+ int nWakeups = 0;
for (;;) {
- ObjectWaiter::TStates v = SelfNode->TState ;
- guarantee (v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant") ;
- assert (_owner != Self, "invariant") ;
+ ObjectWaiter::TStates v = SelfNode->TState;
+ guarantee(v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant");
+ assert(_owner != Self, "invariant");
- if (TryLock (Self) > 0) break ;
- if (TrySpin (Self) > 0) break ;
+ if (TryLock(Self) > 0) break;
+ if (TrySpin(Self) > 0) break;
- TEVENT (Wait Reentry - parking) ;
+ TEVENT(Wait Reentry - parking);
// State transition wrappers around park() ...
// ReenterI() wisely defers state transitions until
@@ -744,14 +744,14 @@
// or java_suspend_self()
jt->set_suspend_equivalent();
if (SyncFlags & 1) {
- Self->_ParkEvent->park ((jlong)1000) ;
+ Self->_ParkEvent->park((jlong)1000);
} else {
- Self->_ParkEvent->park () ;
+ Self->_ParkEvent->park();
}
// were we externally suspended while we were waiting?
for (;;) {
- if (!ExitSuspendEquivalent (jt)) break ;
+ if (!ExitSuspendEquivalent(jt)) break;
if (_succ == Self) { _succ = NULL; OrderAccess::fence(); }
jt->java_suspend_self();
jt->set_suspend_equivalent();
@@ -761,26 +761,26 @@
// Try again, but just so we distinguish between futile wakeups and
// successful wakeups. The following test isn't algorithmically
// necessary, but it helps us maintain sensible statistics.
- if (TryLock(Self) > 0) break ;
+ if (TryLock(Self) > 0) break;
// The lock is still contested.
// Keep a tally of the # of futile wakeups.
// Note that the counter is not protected by a lock or updated by atomics.
// That is by design - we trade "lossy" counters which are exposed to
// races during updates for a lower probe effect.
- TEVENT (Wait Reentry - futile wakeup) ;
- ++ nWakeups ;
+ TEVENT(Wait Reentry - futile wakeup);
+ ++nWakeups;
// Assuming this is not a spurious wakeup we'll normally
// find that _succ == Self.
- if (_succ == Self) _succ = NULL ;
+ if (_succ == Self) _succ = NULL;
// Invariant: after clearing _succ a contending thread
// *must* retry _owner before parking.
- OrderAccess::fence() ;
+ OrderAccess::fence();
if (ObjectMonitor::_sync_FutileWakeups != NULL) {
- ObjectMonitor::_sync_FutileWakeups->inc() ;
+ ObjectMonitor::_sync_FutileWakeups->inc();
}
}
@@ -792,13 +792,13 @@
// The head of cxq is volatile but the interior is stable.
// In addition, Self.TState is stable.
- assert (_owner == Self, "invariant") ;
- assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
- UnlinkAfterAcquire (Self, SelfNode) ;
- if (_succ == Self) _succ = NULL ;
- assert (_succ != Self, "invariant") ;
- SelfNode->TState = ObjectWaiter::TS_RUN ;
- OrderAccess::fence() ; // see comments at the end of EnterI()
+ assert(_owner == Self, "invariant");
+ assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
+ UnlinkAfterAcquire(Self, SelfNode);
+ if (_succ == Self) _succ = NULL;
+ assert(_succ != Self, "invariant");
+ SelfNode->TState = ObjectWaiter::TS_RUN;
+ OrderAccess::fence(); // see comments at the end of EnterI()
}
// after the thread acquires the lock in ::enter(). Equally, we could defer
@@ -806,22 +806,22 @@
void ObjectMonitor::UnlinkAfterAcquire (Thread * Self, ObjectWaiter * SelfNode)
{
- assert (_owner == Self, "invariant") ;
- assert (SelfNode->_thread == Self, "invariant") ;
+ assert(_owner == Self, "invariant");
+ assert(SelfNode->_thread == Self, "invariant");
if (SelfNode->TState == ObjectWaiter::TS_ENTER) {
// Normal case: remove Self from the DLL EntryList .
// This is a constant-time operation.
- ObjectWaiter * nxt = SelfNode->_next ;
- ObjectWaiter * prv = SelfNode->_prev ;
- if (nxt != NULL) nxt->_prev = prv ;
- if (prv != NULL) prv->_next = nxt ;
- if (SelfNode == _EntryList ) _EntryList = nxt ;
- assert (nxt == NULL || nxt->TState == ObjectWaiter::TS_ENTER, "invariant") ;
- assert (prv == NULL || prv->TState == ObjectWaiter::TS_ENTER, "invariant") ;
- TEVENT (Unlink from EntryList) ;
+ ObjectWaiter * nxt = SelfNode->_next;
+ ObjectWaiter * prv = SelfNode->_prev;
+ if (nxt != NULL) nxt->_prev = prv;
+ if (prv != NULL) prv->_next = nxt;
+ if (SelfNode == _EntryList) _EntryList = nxt;
+ assert(nxt == NULL || nxt->TState == ObjectWaiter::TS_ENTER, "invariant");
+ assert(prv == NULL || prv->TState == ObjectWaiter::TS_ENTER, "invariant");
+ TEVENT(Unlink from EntryList);
} else {
- guarantee (SelfNode->TState == ObjectWaiter::TS_CXQ, "invariant") ;
+ guarantee(SelfNode->TState == ObjectWaiter::TS_CXQ, "invariant");
// Inopportune interleaving -- Self is still on the cxq.
// This usually means the enqueue of self raced an exiting thread.
// Normally we'll find Self near the front of the cxq, so
@@ -835,36 +835,36 @@
// and then unlink Self from EntryList. We have to drain eventually,
// so it might as well be now.
- ObjectWaiter * v = _cxq ;
- assert (v != NULL, "invariant") ;
+ ObjectWaiter * v = _cxq;
+ assert(v != NULL, "invariant");
if (v != SelfNode || Atomic::cmpxchg_ptr (SelfNode->_next, &_cxq, v) != v) {
// The CAS above can fail from interference IFF a "RAT" arrived.
// In that case Self must be in the interior and can no longer be
// at the head of cxq.
if (v == SelfNode) {
- assert (_cxq != v, "invariant") ;
- v = _cxq ; // CAS above failed - start scan at head of list
+ assert(_cxq != v, "invariant");
+ v = _cxq; // CAS above failed - start scan at head of list
}
- ObjectWaiter * p ;
- ObjectWaiter * q = NULL ;
- for (p = v ; p != NULL && p != SelfNode; p = p->_next) {
- q = p ;
- assert (p->TState == ObjectWaiter::TS_CXQ, "invariant") ;
+ ObjectWaiter * p;
+ ObjectWaiter * q = NULL;
+ for (p = v; p != NULL && p != SelfNode; p = p->_next) {
+ q = p;
+ assert(p->TState == ObjectWaiter::TS_CXQ, "invariant");
}
- assert (v != SelfNode, "invariant") ;
- assert (p == SelfNode, "Node not found on cxq") ;
- assert (p != _cxq, "invariant") ;
- assert (q != NULL, "invariant") ;
- assert (q->_next == p, "invariant") ;
- q->_next = p->_next ;
+ assert(v != SelfNode, "invariant");
+ assert(p == SelfNode, "Node not found on cxq");
+ assert(p != _cxq, "invariant");
+ assert(q != NULL, "invariant");
+ assert(q->_next == p, "invariant");
+ q->_next = p->_next;
}
- TEVENT (Unlink from cxq) ;
+ TEVENT(Unlink from cxq);
}
// Diagnostic hygiene ...
- SelfNode->_prev = (ObjectWaiter *) 0xBAD ;
- SelfNode->_next = (ObjectWaiter *) 0xBAD ;
- SelfNode->TState = ObjectWaiter::TS_RUN ;
+ SelfNode->_prev = (ObjectWaiter *) 0xBAD;
+ SelfNode->_next = (ObjectWaiter *) 0xBAD;
+ SelfNode->TState = ObjectWaiter::TS_RUN;
}
// -----------------------------------------------------------------------------
@@ -919,22 +919,22 @@
// a monitor will use a timer.
void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
- Thread * Self = THREAD ;
+ Thread * Self = THREAD;
if (THREAD != _owner) {
if (THREAD->is_lock_owned((address) _owner)) {
// Transmute _owner from a BasicLock pointer to a Thread address.
// We don't need to hold _mutex for this transition.
// Non-null to Non-null is safe as long as all readers can
// tolerate either flavor.
- assert (_recursions == 0, "invariant") ;
- _owner = THREAD ;
- _recursions = 0 ;
- OwnerIsThread = 1 ;
+ assert(_recursions == 0, "invariant");
+ _owner = THREAD;
+ _recursions = 0;
+ OwnerIsThread = 1;
} else {
// NOTE: we need to handle unbalanced monitor enter/exit
// in native code by throwing an exception.
// TODO: Throw an IllegalMonitorStateException ?
- TEVENT (Exit - Throw IMSX) ;
+ TEVENT(Exit - Throw IMSX);
assert(false, "Non-balanced monitor enter/exit!");
if (false) {
THROW(vmSymbols::java_lang_IllegalMonitorStateException());
@@ -945,14 +945,14 @@
if (_recursions != 0) {
_recursions--; // this is simple recursive enter
- TEVENT (Inflated exit - recursive) ;
- return ;
+ TEVENT(Inflated exit - recursive);
+ return;
}
// Invariant: after setting Responsible=null an thread must execute
// a MEMBAR or other serializing instruction before fetching EntryList|cxq.
if ((SyncFlags & 4) == 0) {
- _Responsible = NULL ;
+ _Responsible = NULL;
}
#if INCLUDE_TRACE
@@ -964,7 +964,7 @@
#endif
for (;;) {
- assert (THREAD == _owner, "invariant") ;
+ assert(THREAD == _owner, "invariant");
if (Knob_ExitPolicy == 0) {
@@ -980,13 +980,13 @@
// in massive wasteful coherency traffic on classic SMP systems.
// Instead, I use release_store(), which is implemented as just a simple
// ST on x64, x86 and SPARC.
- OrderAccess::release_store_ptr (&_owner, NULL) ; // drop the lock
- OrderAccess::storeload() ; // See if we need to wake a successor
+ OrderAccess::release_store_ptr(&_owner, NULL); // drop the lock
+ OrderAccess::storeload(); // See if we need to wake a successor
if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
- TEVENT (Inflated exit - simple egress) ;
- return ;
+ TEVENT(Inflated exit - simple egress);
+ return;
}
- TEVENT (Inflated exit - complex egress) ;
+ TEVENT(Inflated exit - complex egress);
// Normally the exiting thread is responsible for ensuring succession,
// but if other successors are ready or other entering threads are spinning
@@ -1026,17 +1026,17 @@
// falls to the new owner.
//
if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
- return ;
+ return;
}
- TEVENT (Exit - Reacquired) ;
+ TEVENT(Exit - Reacquired);
} else {
if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
- OrderAccess::release_store_ptr (&_owner, NULL) ; // drop the lock
- OrderAccess::storeload() ;
+ OrderAccess::release_store_ptr(&_owner, NULL); // drop the lock
+ OrderAccess::storeload();
// Ratify the previously observed values.
if (_cxq == NULL || _succ != NULL) {
- TEVENT (Inflated exit - simple egress) ;
- return ;
+ TEVENT(Inflated exit - simple egress);
+ return;
}
// inopportune interleaving -- the exiting thread (this thread)
@@ -1051,29 +1051,29 @@
// we could simply unpark() the lead thread and return
// without having set _succ.
if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
- TEVENT (Inflated exit - reacquired succeeded) ;
- return ;
+ TEVENT(Inflated exit - reacquired succeeded);
+ return;
}
- TEVENT (Inflated exit - reacquired failed) ;
+ TEVENT(Inflated exit - reacquired failed);
} else {
- TEVENT (Inflated exit - complex egress) ;
+ TEVENT(Inflated exit - complex egress);
}
}
- guarantee (_owner == THREAD, "invariant") ;
+ guarantee(_owner == THREAD, "invariant");
- ObjectWaiter * w = NULL ;
- int QMode = Knob_QMode ;
+ ObjectWaiter * w = NULL;
+ int QMode = Knob_QMode;
if (QMode == 2 && _cxq != NULL) {
// QMode == 2 : cxq has precedence over EntryList.
// Try to directly wake a successor from the cxq.
// If successful, the successor will need to unlink itself from cxq.
- w = _cxq ;
- assert (w != NULL, "invariant") ;
- assert (w->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
- ExitEpilog (Self, w) ;
- return ;
+ w = _cxq;
+ assert(w != NULL, "invariant");
+ assert(w->TState == ObjectWaiter::TS_CXQ, "Invariant");
+ ExitEpilog(Self, w);
+ return;
}
if (QMode == 3 && _cxq != NULL) {
@@ -1082,33 +1082,33 @@
// Drain _cxq into EntryList - bulk transfer.
// First, detach _cxq.
// The following loop is tantamount to: w = swap (&cxq, NULL)
- w = _cxq ;
+ w = _cxq;
for (;;) {
- assert (w != NULL, "Invariant") ;
- ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
- if (u == w) break ;
- w = u ;
+ assert(w != NULL, "Invariant");
+ ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr(NULL, &_cxq, w);
+ if (u == w) break;
+ w = u;
}
- assert (w != NULL , "invariant") ;
+ assert(w != NULL , "invariant");
- ObjectWaiter * q = NULL ;
- ObjectWaiter * p ;
- for (p = w ; p != NULL ; p = p->_next) {
- guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
- p->TState = ObjectWaiter::TS_ENTER ;
- p->_prev = q ;
- q = p ;
+ ObjectWaiter * q = NULL;
+ ObjectWaiter * p;
+ for (p = w; p != NULL; p = p->_next) {
+ guarantee(p->TState == ObjectWaiter::TS_CXQ, "Invariant");
+ p->TState = ObjectWaiter::TS_ENTER;
+ p->_prev = q;
+ q = p;
}
// Append the RATs to the EntryList
// TODO: organize EntryList as a CDLL so we can locate the tail in constant-time.
- ObjectWaiter * Tail ;
- for (Tail = _EntryList ; Tail != NULL && Tail->_next != NULL ; Tail = Tail->_next) ;
+ ObjectWaiter * Tail;
+ for (Tail = _EntryList; Tail != NULL && Tail->_next != NULL; Tail = Tail->_next);
if (Tail == NULL) {
- _EntryList = w ;
+ _EntryList = w;
} else {
- Tail->_next = w ;
- w->_prev = Tail ;
+ Tail->_next = w;
+ w->_prev = Tail;
}
// Fall thru into code that tries to wake a successor from EntryList
@@ -1121,35 +1121,35 @@
// Drain _cxq into EntryList - bulk transfer.
// First, detach _cxq.
// The following loop is tantamount to: w = swap (&cxq, NULL)
- w = _cxq ;
+ w = _cxq;
for (;;) {
- assert (w != NULL, "Invariant") ;
- ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
- if (u == w) break ;
- w = u ;
+ assert(w != NULL, "Invariant");
+ ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr(NULL, &_cxq, w);
+ if (u == w) break;
+ w = u;
}
- assert (w != NULL , "invariant") ;
+ assert(w != NULL , "invariant");
- ObjectWaiter * q = NULL ;
- ObjectWaiter * p ;
- for (p = w ; p != NULL ; p = p->_next) {
- guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
- p->TState = ObjectWaiter::TS_ENTER ;
- p->_prev = q ;
- q = p ;
+ ObjectWaiter * q = NULL;
+ ObjectWaiter * p;
+ for (p = w; p != NULL; p = p->_next) {
+ guarantee(p->TState == ObjectWaiter::TS_CXQ, "Invariant");
+ p->TState = ObjectWaiter::TS_ENTER;
+ p->_prev = q;
+ q = p;
}
// Prepend the RATs to the EntryList
if (_EntryList != NULL) {
- q->_next = _EntryList ;
- _EntryList->_prev = q ;
+ q->_next = _EntryList;
+ _EntryList->_prev = q;
}
- _EntryList = w ;
+ _EntryList = w;
// Fall thru into code that tries to wake a successor from EntryList
}
- w = _EntryList ;
+ w = _EntryList;
if (w != NULL) {
// I'd like to write: guarantee (w->_thread != Self).
// But in practice an exiting thread may find itself on the EntryList.
@@ -1162,29 +1162,29 @@
// reacquires the lock and then finds itself on the EntryList.
// Given all that, we have to tolerate the circumstance where "w" is
// associated with Self.
- assert (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
- ExitEpilog (Self, w) ;
- return ;
+ assert(w->TState == ObjectWaiter::TS_ENTER, "invariant");
+ ExitEpilog(Self, w);
+ return;
}
// If we find that both _cxq and EntryList are null then just
// re-run the exit protocol from the top.
- w = _cxq ;
- if (w == NULL) continue ;
+ w = _cxq;
+ if (w == NULL) continue;
// Drain _cxq into EntryList - bulk transfer.
// First, detach _cxq.
// The following loop is tantamount to: w = swap (&cxq, NULL)
for (;;) {
- assert (w != NULL, "Invariant") ;
- ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
- if (u == w) break ;
- w = u ;
+ assert(w != NULL, "Invariant");
+ ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr(NULL, &_cxq, w);
+ if (u == w) break;
+ w = u;
}
- TEVENT (Inflated exit - drain cxq into EntryList) ;
+ TEVENT(Inflated exit - drain cxq into EntryList);
- assert (w != NULL , "invariant") ;
- assert (_EntryList == NULL , "invariant") ;
+ assert(w != NULL , "invariant");
+ assert(_EntryList == NULL , "invariant");
// Convert the LIFO SLL anchored by _cxq into a DLL.
// The list reorganization step operates in O(LENGTH(w)) time.
@@ -1198,30 +1198,30 @@
if (QMode == 1) {
// QMode == 1 : drain cxq to EntryList, reversing order
// We also reverse the order of the list.
- ObjectWaiter * s = NULL ;
- ObjectWaiter * t = w ;
- ObjectWaiter * u = NULL ;
+ ObjectWaiter * s = NULL;
+ ObjectWaiter * t = w;
+ ObjectWaiter * u = NULL;
while (t != NULL) {
- guarantee (t->TState == ObjectWaiter::TS_CXQ, "invariant") ;
- t->TState = ObjectWaiter::TS_ENTER ;
- u = t->_next ;
- t->_prev = u ;
- t->_next = s ;
+ guarantee(t->TState == ObjectWaiter::TS_CXQ, "invariant");
+ t->TState = ObjectWaiter::TS_ENTER;
+ u = t->_next;
+ t->_prev = u;
+ t->_next = s;
s = t;
- t = u ;
+ t = u;
}
- _EntryList = s ;
- assert (s != NULL, "invariant") ;
+ _EntryList = s;
+ assert(s != NULL, "invariant");
} else {
// QMode == 0 or QMode == 2
- _EntryList = w ;
- ObjectWaiter * q = NULL ;
- ObjectWaiter * p ;
- for (p = w ; p != NULL ; p = p->_next) {
- guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
- p->TState = ObjectWaiter::TS_ENTER ;
- p->_prev = q ;
- q = p ;
+ _EntryList = w;
+ ObjectWaiter * q = NULL;
+ ObjectWaiter * p;
+ for (p = w; p != NULL; p = p->_next) {
+ guarantee(p->TState == ObjectWaiter::TS_CXQ, "Invariant");
+ p->TState = ObjectWaiter::TS_ENTER;
+ p->_prev = q;
+ q = p;
}
}
@@ -1233,11 +1233,11 @@
// context-switch rate.
if (_succ != NULL) continue;
- w = _EntryList ;
+ w = _EntryList;
if (w != NULL) {
- guarantee (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
- ExitEpilog (Self, w) ;
- return ;
+ guarantee(w->TState == ObjectWaiter::TS_ENTER, "invariant");
+ ExitEpilog(Self, w);
+ return;
}
}
}
@@ -1275,22 +1275,22 @@
bool ObjectMonitor::ExitSuspendEquivalent (JavaThread * jSelf) {
- int Mode = Knob_FastHSSEC ;
+ int Mode = Knob_FastHSSEC;
if (Mode && !jSelf->is_external_suspend()) {
- assert (jSelf->is_suspend_equivalent(), "invariant") ;
- jSelf->clear_suspend_equivalent() ;
- if (2 == Mode) OrderAccess::storeload() ;
- if (!jSelf->is_external_suspend()) return false ;
+ assert(jSelf->is_suspend_equivalent(), "invariant");
+ jSelf->clear_suspend_equivalent();
+ if (2 == Mode) OrderAccess::storeload();
+ if (!jSelf->is_external_suspend()) return false;
// We raced a suspension -- fall thru into the slow path
- TEVENT (ExitSuspendEquivalent - raced) ;
- jSelf->set_suspend_equivalent() ;
+ TEVENT(ExitSuspendEquivalent - raced);
+ jSelf->set_suspend_equivalent();
}
- return jSelf->handle_special_suspend_equivalent_condition() ;
+ return jSelf->handle_special_suspend_equivalent_condition();
}
void ObjectMonitor::ExitEpilog (Thread * Self, ObjectWaiter * Wakee) {
- assert (_owner == Self, "invariant") ;
+ assert(_owner == Self, "invariant");
// Exit protocol:
// 1. ST _succ = wakee
@@ -1298,28 +1298,28 @@
// 2. ST _owner = NULL
// 3. unpark(wakee)
- _succ = Knob_SuccEnabled ? Wakee->_thread : NULL ;
- ParkEvent * Trigger = Wakee->_event ;
+ _succ = Knob_SuccEnabled ? Wakee->_thread : NULL;
+ ParkEvent * Trigger = Wakee->_event;
// Hygiene -- once we've set _owner = NULL we can't safely dereference Wakee again.
// The thread associated with Wakee may have grabbed the lock and "Wakee" may be
// out-of-scope (non-extant).
- Wakee = NULL ;
+ Wakee = NULL;
// Drop the lock
- OrderAccess::release_store_ptr (&_owner, NULL) ;
- OrderAccess::fence() ; // ST _owner vs LD in unpark()
+ OrderAccess::release_store_ptr(&_owner, NULL);
+ OrderAccess::fence(); // ST _owner vs LD in unpark()
if (SafepointSynchronize::do_call_back()) {
- TEVENT (unpark before SAFEPOINT) ;
+ TEVENT(unpark before SAFEPOINT);
}
DTRACE_MONITOR_PROBE(contended__exit, this, object(), Self);
- Trigger->unpark() ;
+ Trigger->unpark();
// Maintain stats and report events to JVMTI
if (ObjectMonitor::_sync_Parks != NULL) {
- ObjectMonitor::_sync_Parks->inc() ;
+ ObjectMonitor::_sync_Parks->inc();
}
}
@@ -1343,17 +1343,17 @@
if (THREAD != _owner) {
if (THREAD->is_lock_owned ((address)_owner)) {
assert(_recursions == 0, "internal state error");
- _owner = THREAD ; /* Convert from basiclock addr to Thread addr */
- _recursions = 0 ;
- OwnerIsThread = 1 ;
+ _owner = THREAD; /* Convert from basiclock addr to Thread addr */
+ _recursions = 0;
+ OwnerIsThread = 1;
}
}
guarantee(Self == _owner, "complete_exit not owner");
intptr_t save = _recursions; // record the old recursion count
_recursions = 0; // set the recursion level to be 0
- exit (true, Self) ; // exit the monitor
- guarantee (_owner != Self, "invariant");
+ exit(true, Self); // exit the monitor
+ guarantee(_owner != Self, "invariant");
return save;
}
@@ -1365,8 +1365,8 @@
JavaThread *jt = (JavaThread *)THREAD;
guarantee(_owner != Self, "reenter already owner");
- enter (THREAD); // enter the monitor
- guarantee (_recursions == 0, "reenter recursion");
+ enter(THREAD); // enter the monitor
+ guarantee(_recursions == 0, "reenter recursion");
_recursions = recursions;
return;
}
@@ -1382,11 +1382,11 @@
do { \
if (THREAD != _owner) { \
if (THREAD->is_lock_owned((address) _owner)) { \
- _owner = THREAD ; /* Convert from basiclock addr to Thread addr */ \
+ _owner = THREAD; /* Convert from basiclock addr to Thread addr */ \
_recursions = 0; \
- OwnerIsThread = 1 ; \
+ OwnerIsThread = 1; \
} else { \
- TEVENT (Throw IMSX) ; \
+ TEVENT(Throw IMSX); \
THROW(vmSymbols::java_lang_IllegalMonitorStateException()); \
} \
} \
@@ -1396,15 +1396,15 @@
// TODO-FIXME: remove check_slow() -- it's likely dead.
void ObjectMonitor::check_slow(TRAPS) {
- TEVENT (check_slow - throw IMSX) ;
+ TEVENT(check_slow - throw IMSX);
assert(THREAD != _owner && !THREAD->is_lock_owned((address) _owner), "must not be owner");
THROW_MSG(vmSymbols::java_lang_IllegalMonitorStateException(), "current thread not owner");
}
static int Adjust (volatile int * adr, int dx) {
- int v ;
- for (v = *adr ; Atomic::cmpxchg (v + dx, adr, v) != v; v = *adr) ;
- return v ;
+ int v;
+ for (v = *adr; Atomic::cmpxchg(v + dx, adr, v) != v; v = *adr);
+ return v;
}
// helper method for posting a monitor wait event
@@ -1426,11 +1426,11 @@
// Note: a subset of changes to ObjectMonitor::wait()
// will need to be replicated in complete_exit above
void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
- Thread * const Self = THREAD ;
+ Thread * const Self = THREAD;
assert(Self->is_Java_thread(), "Must be Java thread!");
JavaThread *jt = (JavaThread *)THREAD;
- DeferredInitialize () ;
+ DeferredInitialize();
// Throw IMSX or IEX.
CHECK_OWNER();
@@ -1456,23 +1456,23 @@
if (event.should_commit()) {
post_monitor_wait_event(&event, 0, millis, false);
}
- TEVENT (Wait - Throw IEX) ;
+ TEVENT(Wait - Throw IEX);
THROW(vmSymbols::java_lang_InterruptedException());
- return ;
+ return;
}
- TEVENT (Wait) ;
+ TEVENT(Wait);
- assert (Self->_Stalled == 0, "invariant") ;
- Self->_Stalled = intptr_t(this) ;
+ assert(Self->_Stalled == 0, "invariant");
+ Self->_Stalled = intptr_t(this);
jt->set_current_waiting_monitor(this);
// create a node to be put into the queue
// Critically, after we reset() the event but prior to park(), we must check
// for a pending interrupt.
ObjectWaiter node(Self);
- node.TState = ObjectWaiter::TS_WAIT ;
- Self->_ParkEvent->reset() ;
+ node.TState = ObjectWaiter::TS_WAIT;
+ Self->_ParkEvent->reset();
OrderAccess::fence(); // ST into Event; membar ; LD interrupted-flag
// Enter the waiting queue, which is a circular doubly linked list in this case
@@ -1482,18 +1482,18 @@
// returns because of a timeout of interrupt. Contention is exceptionally rare
// so we use a simple spin-lock instead of a heavier-weight blocking lock.
- Thread::SpinAcquire (&_WaitSetLock, "WaitSet - add") ;
- AddWaiter (&node) ;
- Thread::SpinRelease (&_WaitSetLock) ;
+ Thread::SpinAcquire(&_WaitSetLock, "WaitSet - add");
+ AddWaiter(&node);
+ Thread::SpinRelease(&_WaitSetLock);
if ((SyncFlags & 4) == 0) {
- _Responsible = NULL ;
+ _Responsible = NULL;
}
intptr_t save = _recursions; // record the old recursion count
_waiters++; // increment the number of waiters
_recursions = 0; // set the recursion level to be 1
- exit (true, Self) ; // exit the monitor
- guarantee (_owner != Self, "invariant") ;
+ exit(true, Self); // exit the monitor
+ guarantee(_owner != Self, "invariant");
// The thread is on the WaitSet list - now park() it.
// On MP systems it's conceivable that a brief spin before we park
@@ -1502,8 +1502,8 @@
// TODO-FIXME: change the following logic to a loop of the form
// while (!timeout && !interrupted && _notified == 0) park()
- int ret = OS_OK ;
- int WasNotified = 0 ;
+ int ret = OS_OK;
+ int WasNotified = 0;
{ // State transition wrappers
OSThread* osthread = Self->osthread();
OSThreadWaitState osts(osthread, true);
@@ -1517,9 +1517,9 @@
} else
if (node._notified == 0) {
if (millis <= 0) {
- Self->_ParkEvent->park () ;
+ Self->_ParkEvent->park();
} else {
- ret = Self->_ParkEvent->park (millis) ;
+ ret = Self->_ParkEvent->park(millis);
}
}
@@ -1548,23 +1548,23 @@
// That is, we fail toward safety.
if (node.TState == ObjectWaiter::TS_WAIT) {
- Thread::SpinAcquire (&_WaitSetLock, "WaitSet - unlink") ;
+ Thread::SpinAcquire(&_WaitSetLock, "WaitSet - unlink");
if (node.TState == ObjectWaiter::TS_WAIT) {
- DequeueSpecificWaiter (&node) ; // unlink from WaitSet
+ DequeueSpecificWaiter(&node); // unlink from WaitSet
assert(node._notified == 0, "invariant");
- node.TState = ObjectWaiter::TS_RUN ;
+ node.TState = ObjectWaiter::TS_RUN;
}
- Thread::SpinRelease (&_WaitSetLock) ;
+ Thread::SpinRelease(&_WaitSetLock);
}
// The thread is now either on off-list (TS_RUN),
// on the EntryList (TS_ENTER), or on the cxq (TS_CXQ).
// The Node's TState variable is stable from the perspective of this thread.
// No other threads will asynchronously modify TState.
- guarantee (node.TState != ObjectWaiter::TS_WAIT, "invariant") ;
- OrderAccess::loadload() ;
- if (_succ == Self) _succ = NULL ;
- WasNotified = node._notified ;
+ guarantee(node.TState != ObjectWaiter::TS_WAIT, "invariant");
+ OrderAccess::loadload();
+ if (_succ == Self) _succ = NULL;
+ WasNotified = node._notified;
// Reentry phase -- reacquire the monitor.
// re-enter contended monitor after object.wait().
@@ -1601,18 +1601,18 @@
post_monitor_wait_event(&event, node._notifier_tid, millis, ret == OS_TIMEOUT);
}
- OrderAccess::fence() ;
+ OrderAccess::fence();
- assert (Self->_Stalled != 0, "invariant") ;
- Self->_Stalled = 0 ;
+ assert(Self->_Stalled != 0, "invariant");
+ Self->_Stalled = 0;
- assert (_owner != Self, "invariant") ;
- ObjectWaiter::TStates v = node.TState ;
+ assert(_owner != Self, "invariant");
+ ObjectWaiter::TStates v = node.TState;
if (v == ObjectWaiter::TS_RUN) {
- enter (Self) ;
+ enter(Self);
} else {
- guarantee (v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant") ;
- ReenterI (Self, &node) ;
+ guarantee(v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant");
+ ReenterI(Self, &node);
node.wait_reenter_end(this);
}
@@ -1620,24 +1620,24 @@
// Lifecycle - the node representing Self must not appear on any queues.
// Node is about to go out-of-scope, but even if it were immortal we wouldn't
// want residual elements associated with this thread left on any lists.
- guarantee (node.TState == ObjectWaiter::TS_RUN, "invariant") ;
- assert (_owner == Self, "invariant") ;
- assert (_succ != Self , "invariant") ;
+ guarantee(node.TState == ObjectWaiter::TS_RUN, "invariant");
+ assert(_owner == Self, "invariant");
+ assert(_succ != Self , "invariant");
} // OSThreadWaitState()
jt->set_current_waiting_monitor(NULL);
- guarantee (_recursions == 0, "invariant") ;
+ guarantee(_recursions == 0, "invariant");
_recursions = save; // restore the old recursion count
_waiters--; // decrement the number of waiters
// Verify a few postconditions
- assert (_owner == Self , "invariant") ;
- assert (_succ != Self , "invariant") ;
- assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
+ assert(_owner == Self , "invariant");
+ assert(_succ != Self , "invariant");
+ assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
if (SyncFlags & 32) {
- OrderAccess::fence() ;
+ OrderAccess::fence();
}
// check if the notification happened
@@ -1645,7 +1645,7 @@
// no, it could be timeout or Thread.interrupt() or both
// check for interrupt event, otherwise it is timeout
if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) {
- TEVENT (Wait - throw IEX from epilog) ;
+ TEVENT(Wait - throw IEX from epilog);
THROW(vmSymbols::java_lang_InterruptedException());
}
}
@@ -1663,99 +1663,99 @@
void ObjectMonitor::notify(TRAPS) {
CHECK_OWNER();
if (_WaitSet == NULL) {
- TEVENT (Empty-Notify) ;
- return ;
+ TEVENT(Empty-Notify);
+ return;
}
DTRACE_MONITOR_PROBE(notify, this, object(), THREAD);
- int Policy = Knob_MoveNotifyee ;
+ int Policy = Knob_MoveNotifyee;
- Thread::SpinAcquire (&_WaitSetLock, "WaitSet - notify") ;
- ObjectWaiter * iterator = DequeueWaiter() ;
+ Thread::SpinAcquire(&_WaitSetLock, "WaitSet - notify");
+ ObjectWaiter * iterator = DequeueWaiter();
if (iterator != NULL) {
- TEVENT (Notify1 - Transfer) ;
- guarantee (iterator->TState == ObjectWaiter::TS_WAIT, "invariant") ;
- guarantee (iterator->_notified == 0, "invariant") ;
+ TEVENT(Notify1 - Transfer);
+ guarantee(iterator->TState == ObjectWaiter::TS_WAIT, "invariant");
+ guarantee(iterator->_notified == 0, "invariant");
if (Policy != 4) {
- iterator->TState = ObjectWaiter::TS_ENTER ;
+ iterator->TState = ObjectWaiter::TS_ENTER;
}
- iterator->_notified = 1 ;
+ iterator->_notified = 1;
Thread * Self = THREAD;
iterator->_notifier_tid = Self->osthread()->thread_id();
- ObjectWaiter * List = _EntryList ;
+ ObjectWaiter * List = _EntryList;
if (List != NULL) {
- assert (List->_prev == NULL, "invariant") ;
- assert (List->TState == ObjectWaiter::TS_ENTER, "invariant") ;
- assert (List != iterator, "invariant") ;
+ assert(List->_prev == NULL, "invariant");
+ assert(List->TState == ObjectWaiter::TS_ENTER, "invariant");
+ assert(List != iterator, "invariant");
}
if (Policy == 0) { // prepend to EntryList
if (List == NULL) {
- iterator->_next = iterator->_prev = NULL ;
- _EntryList = iterator ;
+ iterator->_next = iterator->_prev = NULL;
+ _EntryList = iterator;
} else {
- List->_prev = iterator ;
- iterator->_next = List ;
- iterator->_prev = NULL ;
- _EntryList = iterator ;
+ List->_prev = iterator;
+ iterator->_next = List;
+ iterator->_prev = NULL;
+ _EntryList = iterator;
}
} else
if (Policy == 1) { // append to EntryList
if (List == NULL) {
- iterator->_next = iterator->_prev = NULL ;
- _EntryList = iterator ;
+ iterator->_next = iterator->_prev = NULL;
+ _EntryList = iterator;
} else {
// CONSIDER: finding the tail currently requires a linear-time walk of
// the EntryList. We can make tail access constant-time by converting to
// a CDLL instead of using our current DLL.
- ObjectWaiter * Tail ;
- for (Tail = List ; Tail->_next != NULL ; Tail = Tail->_next) ;
- assert (Tail != NULL && Tail->_next == NULL, "invariant") ;
- Tail->_next = iterator ;
- iterator->_prev = Tail ;
- iterator->_next = NULL ;
+ ObjectWaiter * Tail;
+ for (Tail = List; Tail->_next != NULL; Tail = Tail->_next);
+ assert(Tail != NULL && Tail->_next == NULL, "invariant");
+ Tail->_next = iterator;
+ iterator->_prev = Tail;
+ iterator->_next = NULL;
}
} else
if (Policy == 2) { // prepend to cxq
// prepend to cxq
if (List == NULL) {
- iterator->_next = iterator->_prev = NULL ;
- _EntryList = iterator ;
+ iterator->_next = iterator->_prev = NULL;
+ _EntryList = iterator;
} else {
- iterator->TState = ObjectWaiter::TS_CXQ ;
+ iterator->TState = ObjectWaiter::TS_CXQ;
for (;;) {
- ObjectWaiter * Front = _cxq ;
- iterator->_next = Front ;
+ ObjectWaiter * Front = _cxq;
+ iterator->_next = Front;
if (Atomic::cmpxchg_ptr (iterator, &_cxq, Front) == Front) {
- break ;
+ break;
}
}
}
} else
if (Policy == 3) { // append to cxq
- iterator->TState = ObjectWaiter::TS_CXQ ;
+ iterator->TState = ObjectWaiter::TS_CXQ;
for (;;) {
- ObjectWaiter * Tail ;
- Tail = _cxq ;
+ ObjectWaiter * Tail;
+ Tail = _cxq;
if (Tail == NULL) {
- iterator->_next = NULL ;
+ iterator->_next = NULL;
if (Atomic::cmpxchg_ptr (iterator, &_cxq, NULL) == NULL) {
- break ;
+ break;
}
} else {
- while (Tail->_next != NULL) Tail = Tail->_next ;
- Tail->_next = iterator ;
- iterator->_prev = Tail ;
- iterator->_next = NULL ;
- break ;
+ while (Tail->_next != NULL) Tail = Tail->_next;
+ Tail->_next = iterator;
+ iterator->_prev = Tail;
+ iterator->_next = NULL;
+ break;
}
}
} else {
- ParkEvent * ev = iterator->_event ;
- iterator->TState = ObjectWaiter::TS_RUN ;
- OrderAccess::fence() ;
- ev->unpark() ;
+ ParkEvent * ev = iterator->_event;
+ iterator->TState = ObjectWaiter::TS_RUN;
+ OrderAccess::fence();
+ ev->unpark();
}
if (Policy < 4) {
@@ -1771,10 +1771,10 @@
// critical section.
}
- Thread::SpinRelease (&_WaitSetLock) ;
+ Thread::SpinRelease(&_WaitSetLock);
if (iterator != NULL && ObjectMonitor::_sync_Notifications != NULL) {
- ObjectMonitor::_sync_Notifications->inc() ;
+ ObjectMonitor::_sync_Notifications->inc();
}
}
@@ -1783,103 +1783,103 @@
CHECK_OWNER();
ObjectWaiter* iterator;
if (_WaitSet == NULL) {
- TEVENT (Empty-NotifyAll) ;
- return ;
+ TEVENT(Empty-NotifyAll);
+ return;
}
DTRACE_MONITOR_PROBE(notifyAll, this, object(), THREAD);
- int Policy = Knob_MoveNotifyee ;
- int Tally = 0 ;
- Thread::SpinAcquire (&_WaitSetLock, "WaitSet - notifyall") ;
+ int Policy = Knob_MoveNotifyee;
+ int Tally = 0;
+ Thread::SpinAcquire(&_WaitSetLock, "WaitSet - notifyall");
for (;;) {
- iterator = DequeueWaiter () ;
- if (iterator == NULL) break ;
- TEVENT (NotifyAll - Transfer1) ;
- ++Tally ;
+ iterator = DequeueWaiter();
+ if (iterator == NULL) break;
+ TEVENT(NotifyAll - Transfer1);
+ ++Tally;
// Disposition - what might we do with iterator ?
// a. add it directly to the EntryList - either tail or head.
// b. push it onto the front of the _cxq.
// For now we use (a).
- guarantee (iterator->TState == ObjectWaiter::TS_WAIT, "invariant") ;
- guarantee (iterator->_notified == 0, "invariant") ;
- iterator->_notified = 1 ;
+ guarantee(iterator->TState == ObjectWaiter::TS_WAIT, "invariant");
+ guarantee(iterator->_notified == 0, "invariant");
+ iterator->_notified = 1;
Thread * Self = THREAD;
iterator->_notifier_tid = Self->osthread()->thread_id();
if (Policy != 4) {
- iterator->TState = ObjectWaiter::TS_ENTER ;
+ iterator->TState = ObjectWaiter::TS_ENTER;
}
- ObjectWaiter * List = _EntryList ;
+ ObjectWaiter * List = _EntryList;
if (List != NULL) {
- assert (List->_prev == NULL, "invariant") ;
- assert (List->TState == ObjectWaiter::TS_ENTER, "invariant") ;
- assert (List != iterator, "invariant") ;
+ assert(List->_prev == NULL, "invariant");
+ assert(List->TState == ObjectWaiter::TS_ENTER, "invariant");
+ assert(List != iterator, "invariant");
}
if (Policy == 0) { // prepend to EntryList
if (List == NULL) {
- iterator->_next = iterator->_prev = NULL ;
- _EntryList = iterator ;
+ iterator->_next = iterator->_prev = NULL;
+ _EntryList = iterator;
} else {
- List->_prev = iterator ;
- iterator->_next = List ;
- iterator->_prev = NULL ;
- _EntryList = iterator ;
+ List->_prev = iterator;
+ iterator->_next = List;
+ iterator->_prev = NULL;
+ _EntryList = iterator;
}
} else
if (Policy == 1) { // append to EntryList
if (List == NULL) {
- iterator->_next = iterator->_prev = NULL ;
- _EntryList = iterator ;
+ iterator->_next = iterator->_prev = NULL;
+ _EntryList = iterator;
} else {
// CONSIDER: finding the tail currently requires a linear-time walk of
// the EntryList. We can make tail access constant-time by converting to
// a CDLL instead of using our current DLL.
- ObjectWaiter * Tail ;
- for (Tail = List ; Tail->_next != NULL ; Tail = Tail->_next) ;
- assert (Tail != NULL && Tail->_next == NULL, "invariant") ;
- Tail->_next = iterator ;
- iterator->_prev = Tail ;
- iterator->_next = NULL ;
+ ObjectWaiter * Tail;
+ for (Tail = List; Tail->_next != NULL; Tail = Tail->_next);
+ assert(Tail != NULL && Tail->_next == NULL, "invariant");
+ Tail->_next = iterator;
+ iterator->_prev = Tail;
+ iterator->_next = NULL;
}
} else
if (Policy == 2) { // prepend to cxq
// prepend to cxq
- iterator->TState = ObjectWaiter::TS_CXQ ;
+ iterator->TState = ObjectWaiter::TS_CXQ;
for (;;) {
- ObjectWaiter * Front = _cxq ;
- iterator->_next = Front ;
+ ObjectWaiter * Front = _cxq;
+ iterator->_next = Front;
if (Atomic::cmpxchg_ptr (iterator, &_cxq, Front) == Front) {
- break ;
+ break;
}
}
} else
if (Policy == 3) { // append to cxq
- iterator->TState = ObjectWaiter::TS_CXQ ;
+ iterator->TState = ObjectWaiter::TS_CXQ;
for (;;) {
- ObjectWaiter * Tail ;
- Tail = _cxq ;
+ ObjectWaiter * Tail;
+ Tail = _cxq;
if (Tail == NULL) {
- iterator->_next = NULL ;
+ iterator->_next = NULL;
if (Atomic::cmpxchg_ptr (iterator, &_cxq, NULL) == NULL) {
- break ;
+ break;
}
} else {
- while (Tail->_next != NULL) Tail = Tail->_next ;
- Tail->_next = iterator ;
- iterator->_prev = Tail ;
- iterator->_next = NULL ;
- break ;
+ while (Tail->_next != NULL) Tail = Tail->_next;
+ Tail->_next = iterator;
+ iterator->_prev = Tail;
+ iterator->_next = NULL;
+ break;
}
}
} else {
- ParkEvent * ev = iterator->_event ;
- iterator->TState = ObjectWaiter::TS_RUN ;
- OrderAccess::fence() ;
- ev->unpark() ;
+ ParkEvent * ev = iterator->_event;
+ iterator->TState = ObjectWaiter::TS_RUN;
+ OrderAccess::fence();
+ ev->unpark();
}
if (Policy < 4) {
@@ -1895,10 +1895,10 @@
// critical section.
}
- Thread::SpinRelease (&_WaitSetLock) ;
+ Thread::SpinRelease(&_WaitSetLock);
if (Tally != 0 && ObjectMonitor::_sync_Notifications != NULL) {
- ObjectMonitor::_sync_Notifications->inc(Tally) ;
+ ObjectMonitor::_sync_Notifications->inc(Tally);
}
}
@@ -1968,8 +1968,8 @@
// not spinning.
//
-intptr_t ObjectMonitor::SpinCallbackArgument = 0 ;
-int (*ObjectMonitor::SpinCallbackFunction)(intptr_t, int) = NULL ;
+intptr_t ObjectMonitor::SpinCallbackArgument = 0;
+int (*ObjectMonitor::SpinCallbackFunction)(intptr_t, int) = NULL;
// Spinning: Fixed frequency (100%), vary duration
@@ -1977,28 +1977,28 @@
int ObjectMonitor::TrySpin_VaryDuration (Thread * Self) {
// Dumb, brutal spin. Good for comparative measurements against adaptive spinning.
- int ctr = Knob_FixedSpin ;
+ int ctr = Knob_FixedSpin;
if (ctr != 0) {
while (--ctr >= 0) {
- if (TryLock (Self) > 0) return 1 ;
- SpinPause () ;
+ if (TryLock(Self) > 0) return 1;
+ SpinPause();
}
- return 0 ;
+ return 0;
}
- for (ctr = Knob_PreSpin + 1; --ctr >= 0 ; ) {
+ for (ctr = Knob_PreSpin + 1; --ctr >= 0;) {
if (TryLock(Self) > 0) {
// Increase _SpinDuration ...
// Note that we don't clamp SpinDuration precisely at SpinLimit.
// Raising _SpurDuration to the poverty line is key.
- int x = _SpinDuration ;
+ int x = _SpinDuration;
if (x < Knob_SpinLimit) {
- if (x < Knob_Poverty) x = Knob_Poverty ;
- _SpinDuration = x + Knob_BonusB ;
+ if (x < Knob_Poverty) x = Knob_Poverty;
+ _SpinDuration = x + Knob_BonusB;
}
- return 1 ;
+ return 1;
}
- SpinPause () ;
+ SpinPause();
}
// Admission control - verify preconditions for spinning
@@ -2015,37 +2015,37 @@
// This takes us into the realm of 1-out-of-N spinning, where we
// hold the duration constant but vary the frequency.
- ctr = _SpinDuration ;
- if (ctr < Knob_SpinBase) ctr = Knob_SpinBase ;
- if (ctr <= 0) return 0 ;
+ ctr = _SpinDuration;
+ if (ctr < Knob_SpinBase) ctr = Knob_SpinBase;
+ if (ctr <= 0) return 0;
- if (Knob_SuccRestrict && _succ != NULL) return 0 ;
+ if (Knob_SuccRestrict && _succ != NULL) return 0;
if (Knob_OState && NotRunnable (Self, (Thread *) _owner)) {
- TEVENT (Spin abort - notrunnable [TOP]);
- return 0 ;
+ TEVENT(Spin abort - notrunnable [TOP]);
+ return 0;
}
- int MaxSpin = Knob_MaxSpinners ;
+ int MaxSpin = Knob_MaxSpinners;
if (MaxSpin >= 0) {
if (_Spinner > MaxSpin) {
- TEVENT (Spin abort -- too many spinners) ;
- return 0 ;
+ TEVENT(Spin abort -- too many spinners);
+ return 0;
}
// Slightly racy, but benign ...
- Adjust (&_Spinner, 1) ;
+ Adjust(&_Spinner, 1);
}
// We're good to spin ... spin ingress.
// CONSIDER: use Prefetch::write() to avoid RTS->RTO upgrades
// when preparing to LD...CAS _owner, etc and the CAS is likely
// to succeed.
- int hits = 0 ;
- int msk = 0 ;
- int caspty = Knob_CASPenalty ;
- int oxpty = Knob_OXPenalty ;
- int sss = Knob_SpinSetSucc ;
- if (sss && _succ == NULL ) _succ = Self ;
- Thread * prv = NULL ;
+ int hits = 0;
+ int msk = 0;
+ int caspty = Knob_CASPenalty;
+ int oxpty = Knob_OXPenalty;
+ int sss = Knob_SpinSetSucc;
+ if (sss && _succ == NULL) _succ = Self;
+ Thread * prv = NULL;
// There are three ways to exit the following loop:
// 1. A successful spin where this thread has acquired the lock.
@@ -2065,18 +2065,18 @@
// We periodically check to see if there's a safepoint pending.
if ((ctr & 0xFF) == 0) {
if (SafepointSynchronize::do_call_back()) {
- TEVENT (Spin: safepoint) ;
- goto Abort ; // abrupt spin egress
+ TEVENT(Spin: safepoint);
+ goto Abort; // abrupt spin egress
}
- if (Knob_UsePause & 1) SpinPause () ;
+ if (Knob_UsePause & 1) SpinPause();
- int (*scb)(intptr_t,int) = SpinCallbackFunction ;
+ int (*scb)(intptr_t,int) = SpinCallbackFunction;
if (hits > 50 && scb != NULL) {
- int abend = (*scb)(SpinCallbackArgument, 0) ;
+ int abend = (*scb)(SpinCallbackArgument, 0);
}
}
- if (Knob_UsePause & 2) SpinPause() ;
+ if (Knob_UsePause & 2) SpinPause();
// Exponential back-off ... Stay off the bus to reduce coherency traffic.
// This is useful on classic SMP systems, but is of less utility on
@@ -2093,12 +2093,12 @@
// coherency bandwidth. Relatedly, if we _oversample _owner we
// can inadvertently interfere with the the ST m->owner=null.
// executed by the lock owner.
- if (ctr & msk) continue ;
- ++hits ;
+ if (ctr & msk) continue;
+ ++hits;
if ((hits & 0xF) == 0) {
// The 0xF, above, corresponds to the exponent.
// Consider: (msk+1)|msk
- msk = ((msk << 2)|3) & BackOffMask ;
+ msk = ((msk << 2)|3) & BackOffMask;
}
// Probe _owner with TATAS
@@ -2111,16 +2111,16 @@
// the spin without prejudice or apply a "penalty" to the
// spin count-down variable "ctr", reducing it by 100, say.
- Thread * ox = (Thread *) _owner ;
+ Thread * ox = (Thread *) _owner;
if (ox == NULL) {
- ox = (Thread *) Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
+ ox = (Thread *) Atomic::cmpxchg_ptr(Self, &_owner, NULL);
if (ox == NULL) {
// The CAS succeeded -- this thread acquired ownership
// Take care of some bookkeeping to exit spin state.
if (sss && _succ == Self) {
- _succ = NULL ;
+ _succ = NULL;
}
- if (MaxSpin > 0) Adjust (&_Spinner, -1) ;
+ if (MaxSpin > 0) Adjust(&_Spinner, -1);
// Increase _SpinDuration :
// The spin was successful (profitable) so we tend toward
@@ -2129,12 +2129,12 @@
// If we acquired the lock early in the spin cycle it
// makes sense to increase _SpinDuration proportionally.
// Note that we don't clamp SpinDuration precisely at SpinLimit.
- int x = _SpinDuration ;
+ int x = _SpinDuration;
if (x < Knob_SpinLimit) {
- if (x < Knob_Poverty) x = Knob_Poverty ;
- _SpinDuration = x + Knob_Bonus ;
+ if (x < Knob_Poverty) x = Knob_Poverty;
+ _SpinDuration = x + Knob_Bonus;
}
- return 1 ;
+ return 1;
}
// The CAS failed ... we can take any of the following actions:
@@ -2142,61 +2142,61 @@
// * exit spin with prejudice -- goto Abort;
// * exit spin without prejudice.
// * Since CAS is high-latency, retry again immediately.
- prv = ox ;
- TEVENT (Spin: cas failed) ;
- if (caspty == -2) break ;
- if (caspty == -1) goto Abort ;
- ctr -= caspty ;
- continue ;
+ prv = ox;
+ TEVENT(Spin: cas failed);
+ if (caspty == -2) break;
+ if (caspty == -1) goto Abort;
+ ctr -= caspty;
+ continue;
}
// Did lock ownership change hands ?
- if (ox != prv && prv != NULL ) {
- TEVENT (spin: Owner changed)
- if (oxpty == -2) break ;
- if (oxpty == -1) goto Abort ;
- ctr -= oxpty ;
+ if (ox != prv && prv != NULL) {
+ TEVENT(spin: Owner changed)
+ if (oxpty == -2) break;
+ if (oxpty == -1) goto Abort;
+ ctr -= oxpty;
}
- prv = ox ;
+ prv = ox;
// Abort the spin if the owner is not executing.
// The owner must be executing in order to drop the lock.
// Spinning while the owner is OFFPROC is idiocy.
// Consider: ctr -= RunnablePenalty ;
if (Knob_OState && NotRunnable (Self, ox)) {
- TEVENT (Spin abort - notrunnable);
- goto Abort ;
+ TEVENT(Spin abort - notrunnable);
+ goto Abort;
}
- if (sss && _succ == NULL ) _succ = Self ;
+ if (sss && _succ == NULL) _succ = Self;
}
// Spin failed with prejudice -- reduce _SpinDuration.
// TODO: Use an AIMD-like policy to adjust _SpinDuration.
// AIMD is globally stable.
- TEVENT (Spin failure) ;
+ TEVENT(Spin failure);
{
- int x = _SpinDuration ;
+ int x = _SpinDuration;
if (x > 0) {
// Consider an AIMD scheme like: x -= (x >> 3) + 100
// This is globally sample and tends to damp the response.
- x -= Knob_Penalty ;
- if (x < 0) x = 0 ;
- _SpinDuration = x ;
+ x -= Knob_Penalty;
+ if (x < 0) x = 0;
+ _SpinDuration = x;
}
}
Abort:
- if (MaxSpin >= 0) Adjust (&_Spinner, -1) ;
+ if (MaxSpin >= 0) Adjust(&_Spinner, -1);
if (sss && _succ == Self) {
- _succ = NULL ;
+ _succ = NULL;
// Invariant: after setting succ=null a contending thread
// must recheck-retry _owner before parking. This usually happens
// in the normal usage of TrySpin(), but it's safest
// to make TrySpin() as foolproof as possible.
- OrderAccess::fence() ;
- if (TryLock(Self) > 0) return 1 ;
+ OrderAccess::fence();
+ if (TryLock(Self) > 0) return 1;
}
- return 0 ;
+ return 0;
}
// NotRunnable() -- informed spinning
@@ -2240,9 +2240,9 @@
int ObjectMonitor::NotRunnable (Thread * Self, Thread * ox) {
// Check either OwnerIsThread or ox->TypeTag == 2BAD.
- if (!OwnerIsThread) return 0 ;
+ if (!OwnerIsThread) return 0;
- if (ox == NULL) return 0 ;
+ if (ox == NULL) return 0;
// Avoid transitive spinning ...
// Say T1 spins or blocks trying to acquire L. T1._Stalled is set to L.
@@ -2251,17 +2251,17 @@
// This occurs transiently after T1 acquired L but before
// T1 managed to clear T1.Stalled. T2 does not need to abort
// its spin in this circumstance.
- intptr_t BlockedOn = SafeFetchN ((intptr_t *) &ox->_Stalled, intptr_t(1)) ;
+ intptr_t BlockedOn = SafeFetchN((intptr_t *) &ox->_Stalled, intptr_t(1));
- if (BlockedOn == 1) return 1 ;
+ if (BlockedOn == 1) return 1;
if (BlockedOn != 0) {
- return BlockedOn != intptr_t(this) && _owner == ox ;
+ return BlockedOn != intptr_t(this) && _owner == ox;
}
- assert (sizeof(((JavaThread *)ox)->_thread_state == sizeof(int)), "invariant") ;
- int jst = SafeFetch32 ((int *) &((JavaThread *) ox)->_thread_state, -1) ; ;
+ assert(sizeof(((JavaThread *)ox)->_thread_state == sizeof(int)), "invariant");
+ int jst = SafeFetch32((int *) &((JavaThread *) ox)->_thread_state, -1);;
// consider also: jst != _thread_in_Java -- but that's overspecific.
- return jst == _thread_blocked || jst == _thread_in_native ;
+ return jst == _thread_blocked || jst == _thread_in_native;
}
@@ -2272,11 +2272,11 @@
_next = NULL;
_prev = NULL;
_notified = 0;
- TState = TS_RUN ;
+ TState = TS_RUN;
_thread = thread;
- _event = thread->_ParkEvent ;
+ _event = thread->_ParkEvent;
_active = false;
- assert (_event != NULL, "invariant") ;
+ assert(_event != NULL, "invariant");
}
void ObjectWaiter::wait_reenter_begin(ObjectMonitor *mon) {
@@ -2299,7 +2299,7 @@
node->_prev = node;
node->_next = node;
} else {
- ObjectWaiter* head = _WaitSet ;
+ ObjectWaiter* head = _WaitSet;
ObjectWaiter* tail = head->_prev;
assert(tail->_next == head, "invariant check");
tail->_next = node;
@@ -2345,56 +2345,56 @@
// -----------------------------------------------------------------------------
// PerfData support
-PerfCounter * ObjectMonitor::_sync_ContendedLockAttempts = NULL ;
-PerfCounter * ObjectMonitor::_sync_FutileWakeups = NULL ;
-PerfCounter * ObjectMonitor::_sync_Parks = NULL ;
-PerfCounter * ObjectMonitor::_sync_EmptyNotifications = NULL ;
-PerfCounter * ObjectMonitor::_sync_Notifications = NULL ;
-PerfCounter * ObjectMonitor::_sync_PrivateA = NULL ;
-PerfCounter * ObjectMonitor::_sync_PrivateB = NULL ;
-PerfCounter * ObjectMonitor::_sync_SlowExit = NULL ;
-PerfCounter * ObjectMonitor::_sync_SlowEnter = NULL ;
-PerfCounter * ObjectMonitor::_sync_SlowNotify = NULL ;
-PerfCounter * ObjectMonitor::_sync_SlowNotifyAll = NULL ;
-PerfCounter * ObjectMonitor::_sync_FailedSpins = NULL ;
-PerfCounter * ObjectMonitor::_sync_SuccessfulSpins = NULL ;
-PerfCounter * ObjectMonitor::_sync_MonInCirculation = NULL ;
-PerfCounter * ObjectMonitor::_sync_MonScavenged = NULL ;
-PerfCounter * ObjectMonitor::_sync_Inflations = NULL ;
-PerfCounter * ObjectMonitor::_sync_Deflations = NULL ;
-PerfLongVariable * ObjectMonitor::_sync_MonExtant = NULL ;
+PerfCounter * ObjectMonitor::_sync_ContendedLockAttempts = NULL;
+PerfCounter * ObjectMonitor::_sync_FutileWakeups = NULL;
+PerfCounter * ObjectMonitor::_sync_Parks = NULL;
+PerfCounter * ObjectMonitor::_sync_EmptyNotifications = NULL;
+PerfCounter * ObjectMonitor::_sync_Notifications = NULL;
+PerfCounter * ObjectMonitor::_sync_PrivateA = NULL;
+PerfCounter * ObjectMonitor::_sync_PrivateB = NULL;
+PerfCounter * ObjectMonitor::_sync_SlowExit = NULL;
+PerfCounter * ObjectMonitor::_sync_SlowEnter = NULL;
+PerfCounter * ObjectMonitor::_sync_SlowNotify = NULL;
+PerfCounter * ObjectMonitor::_sync_SlowNotifyAll = NULL;
+PerfCounter * ObjectMonitor::_sync_FailedSpins = NULL;
+PerfCounter * ObjectMonitor::_sync_SuccessfulSpins = NULL;
+PerfCounter * ObjectMonitor::_sync_MonInCirculation = NULL;
+PerfCounter * ObjectMonitor::_sync_MonScavenged = NULL;
+PerfCounter * ObjectMonitor::_sync_Inflations = NULL;
+PerfCounter * ObjectMonitor::_sync_Deflations = NULL;
+PerfLongVariable * ObjectMonitor::_sync_MonExtant = NULL;
// One-shot global initialization for the sync subsystem.
// We could also defer initialization and initialize on-demand
// the first time we call inflate(). Initialization would
// be protected - like so many things - by the MonitorCache_lock.
-void ObjectMonitor::Initialize () {
- static int InitializationCompleted = 0 ;
- assert (InitializationCompleted == 0, "invariant") ;
- InitializationCompleted = 1 ;
+void ObjectMonitor::Initialize() {
+ static int InitializationCompleted = 0;
+ assert(InitializationCompleted == 0, "invariant");
+ InitializationCompleted = 1;
if (UsePerfData) {
- EXCEPTION_MARK ;
+ EXCEPTION_MARK;
#define NEWPERFCOUNTER(n) {n = PerfDataManager::create_counter(SUN_RT, #n, PerfData::U_Events,CHECK); }
#define NEWPERFVARIABLE(n) {n = PerfDataManager::create_variable(SUN_RT, #n, PerfData::U_Events,CHECK); }
- NEWPERFCOUNTER(_sync_Inflations) ;
- NEWPERFCOUNTER(_sync_Deflations) ;
- NEWPERFCOUNTER(_sync_ContendedLockAttempts) ;
- NEWPERFCOUNTER(_sync_FutileWakeups) ;
- NEWPERFCOUNTER(_sync_Parks) ;
- NEWPERFCOUNTER(_sync_EmptyNotifications) ;
- NEWPERFCOUNTER(_sync_Notifications) ;
- NEWPERFCOUNTER(_sync_SlowEnter) ;
- NEWPERFCOUNTER(_sync_SlowExit) ;
- NEWPERFCOUNTER(_sync_SlowNotify) ;
- NEWPERFCOUNTER(_sync_SlowNotifyAll) ;
- NEWPERFCOUNTER(_sync_FailedSpins) ;
- NEWPERFCOUNTER(_sync_SuccessfulSpins) ;
- NEWPERFCOUNTER(_sync_PrivateA) ;
- NEWPERFCOUNTER(_sync_PrivateB) ;
- NEWPERFCOUNTER(_sync_MonInCirculation) ;
- NEWPERFCOUNTER(_sync_MonScavenged) ;
- NEWPERFVARIABLE(_sync_MonExtant) ;
+ NEWPERFCOUNTER(_sync_Inflations);
+ NEWPERFCOUNTER(_sync_Deflations);
+ NEWPERFCOUNTER(_sync_ContendedLockAttempts);
+ NEWPERFCOUNTER(_sync_FutileWakeups);
+ NEWPERFCOUNTER(_sync_Parks);
+ NEWPERFCOUNTER(_sync_EmptyNotifications);
+ NEWPERFCOUNTER(_sync_Notifications);
+ NEWPERFCOUNTER(_sync_SlowEnter);
+ NEWPERFCOUNTER(_sync_SlowExit);
+ NEWPERFCOUNTER(_sync_SlowNotify);
+ NEWPERFCOUNTER(_sync_SlowNotifyAll);
+ NEWPERFCOUNTER(_sync_FailedSpins);
+ NEWPERFCOUNTER(_sync_SuccessfulSpins);
+ NEWPERFCOUNTER(_sync_PrivateA);
+ NEWPERFCOUNTER(_sync_PrivateB);
+ NEWPERFCOUNTER(_sync_MonInCirculation);
+ NEWPERFCOUNTER(_sync_MonScavenged);
+ NEWPERFVARIABLE(_sync_MonExtant);
#undef NEWPERFCOUNTER
}
}
@@ -2414,33 +2414,33 @@
static char * kvGet (char * kvList, const char * Key) {
- if (kvList == NULL) return NULL ;
- size_t n = strlen (Key) ;
- char * Search ;
- for (Search = kvList ; *Search ; Search += strlen(Search) + 1) {
+ if (kvList == NULL) return NULL;
+ size_t n = strlen(Key);
+ char * Search;
+ for (Search = kvList; *Search; Search += strlen(Search) + 1) {
if (strncmp (Search, Key, n) == 0) {
- if (Search[n] == '=') return Search + n + 1 ;
- if (Search[n] == 0) return (char *) "1" ;
+ if (Search[n] == '=') return Search + n + 1;
+ if (Search[n] == 0) return(char *) "1";
}
}
- return NULL ;
+ return NULL;
}
static int kvGetInt (char * kvList, const char * Key, int Default) {
- char * v = kvGet (kvList, Key) ;
- int rslt = v ? ::strtol (v, NULL, 0) : Default ;
+ char * v = kvGet(kvList, Key);
+ int rslt = v ? ::strtol(v, NULL, 0) : Default;
if (Knob_ReportSettings && v != NULL) {
::printf (" SyncKnob: %s %d(%d)\n", Key, rslt, Default) ;
- ::fflush (stdout) ;
+ ::fflush(stdout);
}
- return rslt ;
+ return rslt;
}
-void ObjectMonitor::DeferredInitialize () {
- if (InitDone > 0) return ;
+void ObjectMonitor::DeferredInitialize() {
+ if (InitDone > 0) return;
if (Atomic::cmpxchg (-1, &InitDone, 0) != 0) {
- while (InitDone != 1) ;
- return ;
+ while (InitDone != 1);
+ return;
}
// One-shot global initialization ...
@@ -2449,68 +2449,68 @@
// SyncKnobs consist of <Key>=<Value> pairs in the style
// of environment variables. Start by converting ':' to NUL.
- if (SyncKnobs == NULL) SyncKnobs = "" ;
+ if (SyncKnobs == NULL) SyncKnobs = "";
- size_t sz = strlen (SyncKnobs) ;
- char * knobs = (char *) malloc (sz + 2) ;
+ size_t sz = strlen(SyncKnobs);
+ char * knobs = (char *) malloc(sz + 2);
if (knobs == NULL) {
- vm_exit_out_of_memory (sz + 2, OOM_MALLOC_ERROR, "Parse SyncKnobs") ;
- guarantee (0, "invariant") ;
+ vm_exit_out_of_memory(sz + 2, OOM_MALLOC_ERROR, "Parse SyncKnobs");
+ guarantee(0, "invariant");
}
- strcpy (knobs, SyncKnobs) ;
- knobs[sz+1] = 0 ;
- for (char * p = knobs ; *p ; p++) {
- if (*p == ':') *p = 0 ;
+ strcpy(knobs, SyncKnobs);
+ knobs[sz+1] = 0;
+ for (char * p = knobs; *p; p++) {
+ if (*p == ':') *p = 0;
}
#define SETKNOB(x) { Knob_##x = kvGetInt (knobs, #x, Knob_##x); }
- SETKNOB(ReportSettings) ;
- SETKNOB(Verbose) ;
- SETKNOB(FixedSpin) ;
- SETKNOB(SpinLimit) ;
- SETKNOB(SpinBase) ;
+ SETKNOB(ReportSettings);
+ SETKNOB(Verbose);
+ SETKNOB(FixedSpin);
+ SETKNOB(SpinLimit);
+ SETKNOB(SpinBase);
SETKNOB(SpinBackOff);
- SETKNOB(CASPenalty) ;
- SETKNOB(OXPenalty) ;
- SETKNOB(LogSpins) ;
- SETKNOB(SpinSetSucc) ;
- SETKNOB(SuccEnabled) ;
- SETKNOB(SuccRestrict) ;
- SETKNOB(Penalty) ;
- SETKNOB(Bonus) ;
- SETKNOB(BonusB) ;
- SETKNOB(Poverty) ;
- SETKNOB(SpinAfterFutile) ;
- SETKNOB(UsePause) ;
- SETKNOB(SpinEarly) ;
- SETKNOB(OState) ;
- SETKNOB(MaxSpinners) ;
- SETKNOB(PreSpin) ;
- SETKNOB(ExitPolicy) ;
+ SETKNOB(CASPenalty);
+ SETKNOB(OXPenalty);
+ SETKNOB(LogSpins);
+ SETKNOB(SpinSetSucc);
+ SETKNOB(SuccEnabled);
+ SETKNOB(SuccRestrict);
+ SETKNOB(Penalty);
+ SETKNOB(Bonus);
+ SETKNOB(BonusB);
+ SETKNOB(Poverty);
+ SETKNOB(SpinAfterFutile);
+ SETKNOB(UsePause);
+ SETKNOB(SpinEarly);
+ SETKNOB(OState);
+ SETKNOB(MaxSpinners);
+ SETKNOB(PreSpin);
+ SETKNOB(ExitPolicy);
SETKNOB(QMode);
- SETKNOB(ResetEvent) ;
- SETKNOB(MoveNotifyee) ;
- SETKNOB(FastHSSEC) ;
+ SETKNOB(ResetEvent);
+ SETKNOB(MoveNotifyee);
+ SETKNOB(FastHSSEC);
#undef SETKNOB
if (os::is_MP()) {
- BackOffMask = (1 << Knob_SpinBackOff) - 1 ;
- if (Knob_ReportSettings) ::printf ("BackOffMask=%X\n", BackOffMask) ;
+ BackOffMask = (1 << Knob_SpinBackOff) - 1;
+ if (Knob_ReportSettings) ::printf("BackOffMask=%X\n", BackOffMask);
// CONSIDER: BackOffMask = ROUNDUP_NEXT_POWER2 (ncpus-1)
} else {
- Knob_SpinLimit = 0 ;
- Knob_SpinBase = 0 ;
- Knob_PreSpin = 0 ;
- Knob_FixedSpin = -1 ;
+ Knob_SpinLimit = 0;
+ Knob_SpinBase = 0;
+ Knob_PreSpin = 0;
+ Knob_FixedSpin = -1;
}
if (Knob_LogSpins == 0) {
- ObjectMonitor::_sync_FailedSpins = NULL ;
+ ObjectMonitor::_sync_FailedSpins = NULL;
}
- free (knobs) ;
- OrderAccess::fence() ;
- InitDone = 1 ;
+ free(knobs);
+ OrderAccess::fence();
+ InitDone = 1;
}
#ifndef PRODUCT
--- a/hotspot/src/share/vm/runtime/objectMonitor.hpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/share/vm/runtime/objectMonitor.hpp Tue Jun 17 12:54:01 2014 -0700
@@ -37,17 +37,17 @@
class ObjectWaiter : public StackObj {
public:
- enum TStates { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER, TS_CXQ } ;
- enum Sorted { PREPEND, APPEND, SORTED } ;
+ enum TStates { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER, TS_CXQ };
+ enum Sorted { PREPEND, APPEND, SORTED };
ObjectWaiter * volatile _next;
ObjectWaiter * volatile _prev;
Thread* _thread;
jlong _notifier_tid;
ParkEvent * _event;
- volatile int _notified ;
- volatile TStates TState ;
- Sorted _Sorted ; // List placement disposition
- bool _active ; // Contention monitoring is enabled
+ volatile int _notified;
+ volatile TStates TState;
+ Sorted _Sorted; // List placement disposition
+ bool _active; // Contention monitoring is enabled
public:
ObjectWaiter(Thread* thread);
@@ -92,19 +92,19 @@
static int owner_offset_in_bytes() { return offset_of(ObjectMonitor, _owner); }
static int count_offset_in_bytes() { return offset_of(ObjectMonitor, _count); }
static int recursions_offset_in_bytes() { return offset_of(ObjectMonitor, _recursions); }
- static int cxq_offset_in_bytes() { return offset_of(ObjectMonitor, _cxq) ; }
- static int succ_offset_in_bytes() { return offset_of(ObjectMonitor, _succ) ; }
+ static int cxq_offset_in_bytes() { return offset_of(ObjectMonitor, _cxq); }
+ static int succ_offset_in_bytes() { return offset_of(ObjectMonitor, _succ); }
static int EntryList_offset_in_bytes() { return offset_of(ObjectMonitor, _EntryList); }
static int FreeNext_offset_in_bytes() { return offset_of(ObjectMonitor, FreeNext); }
- static int WaitSet_offset_in_bytes() { return offset_of(ObjectMonitor, _WaitSet) ; }
- static int Responsible_offset_in_bytes() { return offset_of(ObjectMonitor, _Responsible);}
+ static int WaitSet_offset_in_bytes() { return offset_of(ObjectMonitor, _WaitSet); }
+ static int Responsible_offset_in_bytes() { return offset_of(ObjectMonitor, _Responsible); }
static int Spinner_offset_in_bytes() { return offset_of(ObjectMonitor, _Spinner); }
public:
// Eventually we'll make provisions for multiple callbacks, but
// now one will suffice.
- static int (*SpinCallbackFunction)(intptr_t, int) ;
- static intptr_t SpinCallbackArgument ;
+ static int (*SpinCallbackFunction)(intptr_t, int);
+ static intptr_t SpinCallbackArgument;
public:
@@ -115,7 +115,7 @@
// TODO-FIXME: merge _count and _waiters.
// TODO-FIXME: assert _owner == null implies _recursions = 0
// TODO-FIXME: assert _WaitSet != null implies _count > 0
- return _count|_waiters|intptr_t(_owner)|intptr_t(_cxq)|intptr_t(_EntryList ) ;
+ return _count|_waiters|intptr_t(_owner)|intptr_t(_cxq)|intptr_t(_EntryList);
}
intptr_t is_entered(Thread* current) const;
@@ -127,7 +127,7 @@
intptr_t count() const;
void set_count(intptr_t count);
- intptr_t contentions() const ;
+ intptr_t contentions() const;
intptr_t recursions() const { return _recursions; }
// JVM/DI GetMonitorInfo() needs this
@@ -145,15 +145,15 @@
_object = NULL;
_owner = NULL;
_WaitSet = NULL;
- _WaitSetLock = 0 ;
- _Responsible = NULL ;
- _succ = NULL ;
- _cxq = NULL ;
- FreeNext = NULL ;
- _EntryList = NULL ;
- _SpinFreq = 0 ;
- _SpinClock = 0 ;
- OwnerIsThread = 0 ;
+ _WaitSetLock = 0;
+ _Responsible = NULL;
+ _succ = NULL;
+ _cxq = NULL;
+ FreeNext = NULL;
+ _EntryList = NULL;
+ _SpinFreq = 0;
+ _SpinClock = 0;
+ OwnerIsThread = 0;
_previous_owner_tid = 0;
}
@@ -164,20 +164,20 @@
}
private:
- void Recycle () {
+ void Recycle() {
// TODO: add stronger asserts ...
// _cxq == 0 _succ == NULL _owner == NULL _waiters == 0
// _count == 0 EntryList == NULL
// _recursions == 0 _WaitSet == NULL
// TODO: assert (is_busy()|_recursions) == 0
- _succ = NULL ;
- _EntryList = NULL ;
- _cxq = NULL ;
- _WaitSet = NULL ;
- _recursions = 0 ;
- _SpinFreq = 0 ;
- _SpinClock = 0 ;
- OwnerIsThread = 0 ;
+ _succ = NULL;
+ _EntryList = NULL;
+ _cxq = NULL;
+ _WaitSet = NULL;
+ _recursions = 0;
+ _SpinFreq = 0;
+ _SpinClock = 0;
+ OwnerIsThread = 0;
}
public:
@@ -194,7 +194,7 @@
void print();
#endif
- bool try_enter (TRAPS) ;
+ bool try_enter(TRAPS);
void enter(TRAPS);
void exit(bool not_suspended, TRAPS);
void wait(jlong millis, bool interruptable, TRAPS);
@@ -206,22 +206,22 @@
void reenter(intptr_t recursions, TRAPS);
private:
- void AddWaiter (ObjectWaiter * waiter) ;
+ void AddWaiter(ObjectWaiter * waiter);
static void DeferredInitialize();
- ObjectWaiter * DequeueWaiter () ;
- void DequeueSpecificWaiter (ObjectWaiter * waiter) ;
- void EnterI (TRAPS) ;
- void ReenterI (Thread * Self, ObjectWaiter * SelfNode) ;
- void UnlinkAfterAcquire (Thread * Self, ObjectWaiter * SelfNode) ;
- int TryLock (Thread * Self) ;
- int NotRunnable (Thread * Self, Thread * Owner) ;
- int TrySpin_Fixed (Thread * Self) ;
- int TrySpin_VaryFrequency (Thread * Self) ;
- int TrySpin_VaryDuration (Thread * Self) ;
- void ctAsserts () ;
- void ExitEpilog (Thread * Self, ObjectWaiter * Wakee) ;
- bool ExitSuspendEquivalent (JavaThread * Self) ;
+ ObjectWaiter * DequeueWaiter();
+ void DequeueSpecificWaiter(ObjectWaiter * waiter);
+ void EnterI(TRAPS);
+ void ReenterI(Thread * Self, ObjectWaiter * SelfNode);
+ void UnlinkAfterAcquire(Thread * Self, ObjectWaiter * SelfNode);
+ int TryLock(Thread * Self);
+ int NotRunnable(Thread * Self, Thread * Owner);
+ int TrySpin_Fixed(Thread * Self);
+ int TrySpin_VaryFrequency(Thread * Self);
+ int TrySpin_VaryDuration(Thread * Self);
+ void ctAsserts();
+ void ExitEpilog(Thread * Self, ObjectWaiter * Wakee);
+ bool ExitSuspendEquivalent(JavaThread * Self);
void post_monitor_wait_event(EventJavaMonitorWait * event,
jlong notifier_tid,
jlong timeout,
@@ -240,7 +240,7 @@
volatile markOop _header; // displaced object header word - mark
void* volatile _object; // backward object pointer - strong root
- double SharingPad [1] ; // temp to reduce false sharing
+ double SharingPad[1]; // temp to reduce false sharing
// All the following fields must be machine word aligned
// The VM assumes write ordering wrt these fields, which can be
@@ -251,22 +251,22 @@
volatile jlong _previous_owner_tid; // thread id of the previous owner of the monitor
volatile intptr_t _recursions; // recursion count, 0 for first entry
private:
- int OwnerIsThread ; // _owner is (Thread *) vs SP/BasicLock
- ObjectWaiter * volatile _cxq ; // LL of recently-arrived threads blocked on entry.
+ int OwnerIsThread; // _owner is (Thread *) vs SP/BasicLock
+ ObjectWaiter * volatile _cxq; // LL of recently-arrived threads blocked on entry.
// The list is actually composed of WaitNodes, acting
// as proxies for Threads.
protected:
- ObjectWaiter * volatile _EntryList ; // Threads blocked on entry or reentry.
+ ObjectWaiter * volatile _EntryList; // Threads blocked on entry or reentry.
private:
- Thread * volatile _succ ; // Heir presumptive thread - used for futile wakeup throttling
- Thread * volatile _Responsible ;
- int _PromptDrain ; // rqst to drain cxq into EntryList ASAP
+ Thread * volatile _succ; // Heir presumptive thread - used for futile wakeup throttling
+ Thread * volatile _Responsible;
+ int _PromptDrain; // rqst to drain cxq into EntryList ASAP
- volatile int _Spinner ; // for exit->spinner handoff optimization
- volatile int _SpinFreq ; // Spin 1-out-of-N attempts: success rate
- volatile int _SpinClock ;
- volatile int _SpinDuration ;
- volatile intptr_t _SpinState ; // MCS/CLH list of spinners
+ volatile int _Spinner; // for exit->spinner handoff optimization
+ volatile int _SpinFreq; // Spin 1-out-of-N attempts: success rate
+ volatile int _SpinClock;
+ volatile int _SpinDuration;
+ volatile intptr_t _SpinState; // MCS/CLH list of spinners
// TODO-FIXME: _count, _waiters and _recursions should be of
// type int, or int32_t but not intptr_t. There's no reason
@@ -284,30 +284,30 @@
volatile int _WaitSetLock; // protects Wait Queue - simple spinlock
public:
- int _QMix ; // Mixed prepend queue discipline
- ObjectMonitor * FreeNext ; // Free list linkage
- intptr_t StatA, StatsB ;
+ int _QMix; // Mixed prepend queue discipline
+ ObjectMonitor * FreeNext; // Free list linkage
+ intptr_t StatA, StatsB;
public:
- static void Initialize () ;
- static PerfCounter * _sync_ContendedLockAttempts ;
- static PerfCounter * _sync_FutileWakeups ;
- static PerfCounter * _sync_Parks ;
- static PerfCounter * _sync_EmptyNotifications ;
- static PerfCounter * _sync_Notifications ;
- static PerfCounter * _sync_SlowEnter ;
- static PerfCounter * _sync_SlowExit ;
- static PerfCounter * _sync_SlowNotify ;
- static PerfCounter * _sync_SlowNotifyAll ;
- static PerfCounter * _sync_FailedSpins ;
- static PerfCounter * _sync_SuccessfulSpins ;
- static PerfCounter * _sync_PrivateA ;
- static PerfCounter * _sync_PrivateB ;
- static PerfCounter * _sync_MonInCirculation ;
- static PerfCounter * _sync_MonScavenged ;
- static PerfCounter * _sync_Inflations ;
- static PerfCounter * _sync_Deflations ;
- static PerfLongVariable * _sync_MonExtant ;
+ static void Initialize();
+ static PerfCounter * _sync_ContendedLockAttempts;
+ static PerfCounter * _sync_FutileWakeups;
+ static PerfCounter * _sync_Parks;
+ static PerfCounter * _sync_EmptyNotifications;
+ static PerfCounter * _sync_Notifications;
+ static PerfCounter * _sync_SlowEnter;
+ static PerfCounter * _sync_SlowExit;
+ static PerfCounter * _sync_SlowNotify;
+ static PerfCounter * _sync_SlowNotifyAll;
+ static PerfCounter * _sync_FailedSpins;
+ static PerfCounter * _sync_SuccessfulSpins;
+ static PerfCounter * _sync_PrivateA;
+ static PerfCounter * _sync_PrivateB;
+ static PerfCounter * _sync_MonInCirculation;
+ static PerfCounter * _sync_MonScavenged;
+ static PerfCounter * _sync_Inflations;
+ static PerfCounter * _sync_Deflations;
+ static PerfLongVariable * _sync_MonExtant;
public:
static int Knob_Verbose;
@@ -329,7 +329,7 @@
#undef TEVENT
#define TEVENT(nom) {if (SyncVerbose) FEVENT(nom); }
-#define FEVENT(nom) { static volatile int ctr = 0 ; int v = ++ctr ; if ((v & (v-1)) == 0) { ::printf (#nom " : %d \n", v); ::fflush(stdout); }}
+#define FEVENT(nom) { static volatile int ctr = 0; int v = ++ctr; if ((v & (v-1)) == 0) { ::printf (#nom " : %d \n", v); ::fflush(stdout); }}
#undef TEVENT
#define TEVENT(nom) {;}
--- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -198,13 +198,13 @@
void SharedRuntime::print_ic_miss_histogram() {
if (ICMissHistogram) {
- tty->print_cr ("IC Miss Histogram:");
+ tty->print_cr("IC Miss Histogram:");
int tot_misses = 0;
for (int i = 0; i < _ICmiss_index; i++) {
tty->print_cr(" at: " INTPTR_FORMAT " nof: %d", _ICmiss_at[i], _ICmiss_count[i]);
tot_misses += _ICmiss_count[i];
}
- tty->print_cr ("Total IC misses: %7d", tot_misses);
+ tty->print_cr("Total IC misses: %7d", tot_misses);
}
}
#endif // PRODUCT
@@ -266,7 +266,7 @@
xbits.f = x;
ybits.f = y;
// x Mod Infinity == x unless x is infinity
- if ( ((xbits.i & float_sign_mask) != float_infinity) &&
+ if (((xbits.i & float_sign_mask) != float_infinity) &&
((ybits.i & float_sign_mask) == float_infinity) ) {
return x;
}
@@ -281,7 +281,7 @@
xbits.d = x;
ybits.d = y;
// x Mod Infinity == x unless x is infinity
- if ( ((xbits.l & double_sign_mask) != double_infinity) &&
+ if (((xbits.l & double_sign_mask) != double_infinity) &&
((ybits.l & double_sign_mask) == double_infinity) ) {
return x;
}
@@ -537,13 +537,13 @@
CodeBlob *cb = CodeCache::find_blob(pc);
// Should be an nmethod
- assert( cb && cb->is_nmethod(), "safepoint polling: pc must refer to an nmethod" );
+ assert(cb && cb->is_nmethod(), "safepoint polling: pc must refer to an nmethod");
// Look up the relocation information
- assert( ((nmethod*)cb)->is_at_poll_or_poll_return(pc),
- "safepoint polling: type must be poll" );
-
- assert( ((NativeInstruction*)pc)->is_safepoint_poll(),
+ assert(((nmethod*)cb)->is_at_poll_or_poll_return(pc),
+ "safepoint polling: type must be poll");
+
+ assert(((NativeInstruction*)pc)->is_safepoint_poll(),
"Only polling locations are used for safepoint");
bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc);
@@ -562,7 +562,7 @@
stub = SharedRuntime::polling_page_safepoint_handler_blob()->entry_point();
}
#ifndef PRODUCT
- if( TraceSafepoint ) {
+ if (TraceSafepoint) {
char buf[256];
jio_snprintf(buf, sizeof(buf),
"... found polling page %s exception at pc = "
@@ -1474,7 +1474,7 @@
should_be_mono = true;
} else if (inline_cache->is_icholder_call()) {
CompiledICHolder* ic_oop = inline_cache->cached_icholder();
- if ( ic_oop != NULL) {
+ if (ic_oop != NULL) {
if (receiver()->klass() == ic_oop->holder_klass()) {
// This isn't a real miss. We must have seen that compiled code
@@ -1728,7 +1728,7 @@
iter.next();
assert(iter.has_current(), "must have a reloc at java call site");
relocInfo::relocType typ = iter.reloc()->type();
- if ( typ != relocInfo::static_call_type &&
+ if (typ != relocInfo::static_call_type &&
typ != relocInfo::opt_virtual_call_type &&
typ != relocInfo::static_stub_type) {
return;
@@ -1784,7 +1784,7 @@
// The copy_array mechanism is awkward and could be removed, but
// the compilers don't call this function except as a last resort,
// so it probably doesn't matter.
- src->klass()->copy_array((arrayOopDesc*)src, src_pos,
+ src->klass()->copy_array((arrayOopDesc*)src, src_pos,
(arrayOopDesc*)dest, dest_pos,
length, thread);
}
@@ -1891,8 +1891,8 @@
ttyLocker ttyl;
if (xtty != NULL) xtty->head("statistics type='SharedRuntime'");
- if (_monitor_enter_ctr ) tty->print_cr("%5d monitor enter slow", _monitor_enter_ctr);
- if (_monitor_exit_ctr ) tty->print_cr("%5d monitor exit slow", _monitor_exit_ctr);
+ if (_monitor_enter_ctr) tty->print_cr("%5d monitor enter slow", _monitor_enter_ctr);
+ if (_monitor_exit_ctr) tty->print_cr("%5d monitor exit slow", _monitor_exit_ctr);
if (_throw_null_ctr) tty->print_cr("%5d implicit null throw", _throw_null_ctr);
SharedRuntime::print_ic_miss_histogram();
@@ -1905,36 +1905,36 @@
}
// Dump the JRT_ENTRY counters
- if( _new_instance_ctr ) tty->print_cr("%5d new instance requires GC", _new_instance_ctr);
- if( _new_array_ctr ) tty->print_cr("%5d new array requires GC", _new_array_ctr);
- if( _multi1_ctr ) tty->print_cr("%5d multianewarray 1 dim", _multi1_ctr);
- if( _multi2_ctr ) tty->print_cr("%5d multianewarray 2 dim", _multi2_ctr);
- if( _multi3_ctr ) tty->print_cr("%5d multianewarray 3 dim", _multi3_ctr);
- if( _multi4_ctr ) tty->print_cr("%5d multianewarray 4 dim", _multi4_ctr);
- if( _multi5_ctr ) tty->print_cr("%5d multianewarray 5 dim", _multi5_ctr);
-
- tty->print_cr("%5d inline cache miss in compiled", _ic_miss_ctr );
- tty->print_cr("%5d wrong method", _wrong_method_ctr );
- tty->print_cr("%5d unresolved static call site", _resolve_static_ctr );
- tty->print_cr("%5d unresolved virtual call site", _resolve_virtual_ctr );
- tty->print_cr("%5d unresolved opt virtual call site", _resolve_opt_virtual_ctr );
-
- if( _mon_enter_stub_ctr ) tty->print_cr("%5d monitor enter stub", _mon_enter_stub_ctr );
- if( _mon_exit_stub_ctr ) tty->print_cr("%5d monitor exit stub", _mon_exit_stub_ctr );
- if( _mon_enter_ctr ) tty->print_cr("%5d monitor enter slow", _mon_enter_ctr );
- if( _mon_exit_ctr ) tty->print_cr("%5d monitor exit slow", _mon_exit_ctr );
- if( _partial_subtype_ctr) tty->print_cr("%5d slow partial subtype", _partial_subtype_ctr );
- if( _jbyte_array_copy_ctr ) tty->print_cr("%5d byte array copies", _jbyte_array_copy_ctr );
- if( _jshort_array_copy_ctr ) tty->print_cr("%5d short array copies", _jshort_array_copy_ctr );
- if( _jint_array_copy_ctr ) tty->print_cr("%5d int array copies", _jint_array_copy_ctr );
- if( _jlong_array_copy_ctr ) tty->print_cr("%5d long array copies", _jlong_array_copy_ctr );
- if( _oop_array_copy_ctr ) tty->print_cr("%5d oop array copies", _oop_array_copy_ctr );
- if( _checkcast_array_copy_ctr ) tty->print_cr("%5d checkcast array copies", _checkcast_array_copy_ctr );
- if( _unsafe_array_copy_ctr ) tty->print_cr("%5d unsafe array copies", _unsafe_array_copy_ctr );
- if( _generic_array_copy_ctr ) tty->print_cr("%5d generic array copies", _generic_array_copy_ctr );
- if( _slow_array_copy_ctr ) tty->print_cr("%5d slow array copies", _slow_array_copy_ctr );
- if( _find_handler_ctr ) tty->print_cr("%5d find exception handler", _find_handler_ctr );
- if( _rethrow_ctr ) tty->print_cr("%5d rethrow handler", _rethrow_ctr );
+ if (_new_instance_ctr) tty->print_cr("%5d new instance requires GC", _new_instance_ctr);
+ if (_new_array_ctr) tty->print_cr("%5d new array requires GC", _new_array_ctr);
+ if (_multi1_ctr) tty->print_cr("%5d multianewarray 1 dim", _multi1_ctr);
+ if (_multi2_ctr) tty->print_cr("%5d multianewarray 2 dim", _multi2_ctr);
+ if (_multi3_ctr) tty->print_cr("%5d multianewarray 3 dim", _multi3_ctr);
+ if (_multi4_ctr) tty->print_cr("%5d multianewarray 4 dim", _multi4_ctr);
+ if (_multi5_ctr) tty->print_cr("%5d multianewarray 5 dim", _multi5_ctr);
+
+ tty->print_cr("%5d inline cache miss in compiled", _ic_miss_ctr);
+ tty->print_cr("%5d wrong method", _wrong_method_ctr);
+ tty->print_cr("%5d unresolved static call site", _resolve_static_ctr);
+ tty->print_cr("%5d unresolved virtual call site", _resolve_virtual_ctr);
+ tty->print_cr("%5d unresolved opt virtual call site", _resolve_opt_virtual_ctr);
+
+ if (_mon_enter_stub_ctr) tty->print_cr("%5d monitor enter stub", _mon_enter_stub_ctr);
+ if (_mon_exit_stub_ctr) tty->print_cr("%5d monitor exit stub", _mon_exit_stub_ctr);
+ if (_mon_enter_ctr) tty->print_cr("%5d monitor enter slow", _mon_enter_ctr);
+ if (_mon_exit_ctr) tty->print_cr("%5d monitor exit slow", _mon_exit_ctr);
+ if (_partial_subtype_ctr) tty->print_cr("%5d slow partial subtype", _partial_subtype_ctr);
+ if (_jbyte_array_copy_ctr) tty->print_cr("%5d byte array copies", _jbyte_array_copy_ctr);
+ if (_jshort_array_copy_ctr) tty->print_cr("%5d short array copies", _jshort_array_copy_ctr);
+ if (_jint_array_copy_ctr) tty->print_cr("%5d int array copies", _jint_array_copy_ctr);
+ if (_jlong_array_copy_ctr) tty->print_cr("%5d long array copies", _jlong_array_copy_ctr);
+ if (_oop_array_copy_ctr) tty->print_cr("%5d oop array copies", _oop_array_copy_ctr);
+ if (_checkcast_array_copy_ctr) tty->print_cr("%5d checkcast array copies", _checkcast_array_copy_ctr);
+ if (_unsafe_array_copy_ctr) tty->print_cr("%5d unsafe array copies", _unsafe_array_copy_ctr);
+ if (_generic_array_copy_ctr) tty->print_cr("%5d generic array copies", _generic_array_copy_ctr);
+ if (_slow_array_copy_ctr) tty->print_cr("%5d slow array copies", _slow_array_copy_ctr);
+ if (_find_handler_ctr) tty->print_cr("%5d find exception handler", _find_handler_ctr);
+ if (_rethrow_ctr) tty->print_cr("%5d rethrow handler", _rethrow_ctr);
AdapterHandlerLibrary::print_statistics();
@@ -1997,7 +1997,7 @@
MethodArityHistogram() {
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
_max_arity = _max_size = 0;
- for (int i = 0; i < MAX_ARITY; i++) _arity_histogram[i] = _size_histogram [i] = 0;
+ for (int i = 0; i < MAX_ARITY; i++) _arity_histogram[i] = _size_histogram[i] = 0;
CodeCache::nmethods_do(add_method_to_histogram);
print_histogram();
}
@@ -2062,7 +2062,7 @@
// These are correct for the current system but someday it might be
// necessary to make this mapping platform dependent.
static int adapter_encoding(BasicType in) {
- switch(in) {
+ switch (in) {
case T_BOOLEAN:
case T_BYTE:
case T_SHORT:
@@ -2479,7 +2479,7 @@
tty->print_cr("i2c argument handler #%d for: %s %s (%d bytes generated)",
_adapters->number_of_entries(), (method->is_static() ? "static" : "receiver"),
method->signature()->as_C_string(), insts_size);
- tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry());
+ tty->print_cr("c2i argument handler starts at %p", entry->get_c2i_entry());
if (Verbose || PrintStubCode) {
address first_pc = entry->base_address();
if (first_pc != NULL) {
@@ -2504,7 +2504,7 @@
new_adapter->name(),
fingerprint->as_string(),
new_adapter->content_begin());
- Forte::register_stub(blob_id, new_adapter->content_begin(),new_adapter->content_end());
+ Forte::register_stub(blob_id, new_adapter->content_begin(), new_adapter->content_end());
if (JvmtiExport::should_post_dynamic_code_generated()) {
JvmtiExport::post_dynamic_code_generated(blob_id, new_adapter->content_begin(), new_adapter->content_end());
@@ -2605,12 +2605,12 @@
BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
int i=0;
- if( !method->is_static() ) // Pass in receiver first
+ if (!method->is_static()) // Pass in receiver first
sig_bt[i++] = T_OBJECT;
SignatureStream ss(method->signature());
- for( ; !ss.at_return_type(); ss.next()) {
+ for (; !ss.at_return_type(); ss.next()) {
sig_bt[i++] = ss.type(); // Collect remaining bits of signature
- if( ss.type() == T_LONG || ss.type() == T_DOUBLE )
+ if (ss.type() == T_LONG || ss.type() == T_DOUBLE)
sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots
}
assert(i == total_args_passed, "");
@@ -2762,10 +2762,10 @@
case T_SHORT:
case T_INT:
// Convert (bt) to (T_LONG,bt).
- new_in_sig_bt[argcnt ] = T_LONG;
+ new_in_sig_bt[argcnt] = T_LONG;
new_in_sig_bt[argcnt+1] = bt;
assert(reg.first()->is_valid() && !reg.second()->is_valid(), "");
- new_in_regs[argcnt ].set2(reg.first());
+ new_in_regs[argcnt].set2(reg.first());
new_in_regs[argcnt+1].set_bad();
argcnt++;
break;
@@ -2808,17 +2808,17 @@
int len = (int)strlen(s);
s++; len--; // Skip opening paren
char *t = s+len;
- while( *(--t) != ')' ) ; // Find close paren
-
- BasicType *sig_bt = NEW_RESOURCE_ARRAY( BasicType, 256 );
- VMRegPair *regs = NEW_RESOURCE_ARRAY( VMRegPair, 256 );
+ while (*(--t) != ')'); // Find close paren
+
+ BasicType *sig_bt = NEW_RESOURCE_ARRAY(BasicType, 256);
+ VMRegPair *regs = NEW_RESOURCE_ARRAY(VMRegPair, 256);
int cnt = 0;
if (has_receiver) {
sig_bt[cnt++] = T_OBJECT; // Receiver is argument 0; not in signature
}
- while( s < t ) {
- switch( *s++ ) { // Switch on signature character
+ while (s < t) {
+ switch (*s++) { // Switch on signature character
case 'B': sig_bt[cnt++] = T_BYTE; break;
case 'C': sig_bt[cnt++] = T_CHAR; break;
case 'D': sig_bt[cnt++] = T_DOUBLE; sig_bt[cnt++] = T_VOID; break;
@@ -2829,16 +2829,16 @@
case 'Z': sig_bt[cnt++] = T_BOOLEAN; break;
case 'V': sig_bt[cnt++] = T_VOID; break;
case 'L': // Oop
- while( *s++ != ';' ) ; // Skip signature
+ while (*s++ != ';'); // Skip signature
sig_bt[cnt++] = T_OBJECT;
break;
case '[': { // Array
do { // Skip optional size
- while( *s >= '0' && *s <= '9' ) s++;
- } while( *s++ == '[' ); // Nested arrays?
+ while (*s >= '0' && *s <= '9') s++;
+ } while (*s++ == '['); // Nested arrays?
// Skip element type
- if( s[-1] == 'L' )
- while( *s++ != ';' ) ; // Skip signature
+ if (s[-1] == 'L')
+ while (*s++ != ';'); // Skip signature
sig_bt[cnt++] = T_ARRAY;
break;
}
@@ -2850,7 +2850,7 @@
sig_bt[cnt++] = T_OBJECT;
}
- assert( cnt < 256, "grow table size" );
+ assert(cnt < 256, "grow table size");
int comp_args_on_stack;
comp_args_on_stack = java_calling_convention(sig_bt, regs, cnt, true);
@@ -2861,12 +2861,12 @@
if (comp_args_on_stack) {
for (int i = 0; i < cnt; i++) {
VMReg reg1 = regs[i].first();
- if( reg1->is_stack()) {
+ if (reg1->is_stack()) {
// Yuck
reg1 = reg1->bias(out_preserve_stack_slots());
}
VMReg reg2 = regs[i].second();
- if( reg2->is_stack()) {
+ if (reg2->is_stack()) {
// Yuck
reg2 = reg2->bias(out_preserve_stack_slots());
}
@@ -2904,15 +2904,15 @@
// frame accessor methods and be platform independent.
frame fr = thread->last_frame();
- assert( fr.is_interpreted_frame(), "" );
- assert( fr.interpreter_frame_expression_stack_size()==0, "only handle empty stacks" );
+ assert(fr.is_interpreted_frame(), "");
+ assert(fr.interpreter_frame_expression_stack_size()==0, "only handle empty stacks");
// Figure out how many monitors are active.
int active_monitor_count = 0;
- for( BasicObjectLock *kptr = fr.interpreter_frame_monitor_end();
+ for (BasicObjectLock *kptr = fr.interpreter_frame_monitor_end();
kptr < fr.interpreter_frame_monitor_begin();
kptr = fr.next_monitor_in_interpreter_frame(kptr) ) {
- if( kptr->obj() != NULL ) active_monitor_count++;
+ if (kptr->obj() != NULL) active_monitor_count++;
}
// QQQ we could place number of active monitors in the array so that compiled code
@@ -2926,17 +2926,17 @@
// Copy the locals. Order is preserved so that loading of longs works.
// Since there's no GC I can copy the oops blindly.
- assert( sizeof(HeapWord)==sizeof(intptr_t), "fix this code");
+ assert(sizeof(HeapWord)==sizeof(intptr_t), "fix this code");
Copy::disjoint_words((HeapWord*)fr.interpreter_frame_local_at(max_locals-1),
(HeapWord*)&buf[0],
max_locals);
// Inflate locks. Copy the displaced headers. Be careful, there can be holes.
int i = max_locals;
- for( BasicObjectLock *kptr2 = fr.interpreter_frame_monitor_end();
+ for (BasicObjectLock *kptr2 = fr.interpreter_frame_monitor_end();
kptr2 < fr.interpreter_frame_monitor_begin();
kptr2 = fr.next_monitor_in_interpreter_frame(kptr2) ) {
- if( kptr2->obj() != NULL) { // Avoid 'holes' in the monitor array
+ if (kptr2->obj() != NULL) { // Avoid 'holes' in the monitor array
BasicLock *lock = kptr2->lock();
// Inflate so the displaced header becomes position-independent
if (lock->displaced_header()->is_unlocked())
@@ -2946,20 +2946,20 @@
buf[i++] = cast_from_oop<intptr_t>(kptr2->obj());
}
}
- assert( i - max_locals == active_monitor_count*2, "found the expected number of monitors" );
+ assert(i - max_locals == active_monitor_count*2, "found the expected number of monitors");
return buf;
JRT_END
JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) )
- FREE_C_HEAP_ARRAY(intptr_t,buf, mtCode);
+ FREE_C_HEAP_ARRAY(intptr_t, buf, mtCode);
JRT_END
bool AdapterHandlerLibrary::contains(CodeBlob* b) {
AdapterHandlerTableIterator iter(_adapters);
while (iter.has_next()) {
AdapterHandlerEntry* a = iter.next();
- if ( b == CodeCache::find_blob(a->get_i2c_entry()) ) return true;
+ if (b == CodeCache::find_blob(a->get_i2c_entry())) return true;
}
return false;
}
--- a/hotspot/src/share/vm/runtime/synchronizer.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/share/vm/runtime/synchronizer.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -120,15 +120,15 @@
}
#define NINFLATIONLOCKS 256
-static volatile intptr_t InflationLocks [NINFLATIONLOCKS] ;
+static volatile intptr_t InflationLocks[NINFLATIONLOCKS];
-ObjectMonitor * ObjectSynchronizer::gBlockList = NULL ;
-ObjectMonitor * volatile ObjectSynchronizer::gFreeList = NULL ;
-ObjectMonitor * volatile ObjectSynchronizer::gOmInUseList = NULL ;
+ObjectMonitor * ObjectSynchronizer::gBlockList = NULL;
+ObjectMonitor * volatile ObjectSynchronizer::gFreeList = NULL;
+ObjectMonitor * volatile ObjectSynchronizer::gOmInUseList = NULL;
int ObjectSynchronizer::gOmInUseCount = 0;
-static volatile intptr_t ListLock = 0 ; // protects global monitor free-list cache
-static volatile int MonitorFreeCount = 0 ; // # on gFreeList
-static volatile int MonitorPopulation = 0 ; // # Extant -- in circulation
+static volatile intptr_t ListLock = 0; // protects global monitor free-list cache
+static volatile int MonitorFreeCount = 0; // # on gFreeList
+static volatile int MonitorPopulation = 0; // # Extant -- in circulation
#define CHAINMARKER (cast_to_oop<intptr_t>(-1))
// -----------------------------------------------------------------------------
@@ -152,43 +152,43 @@
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
- slow_enter (obj, lock, THREAD) ;
+ slow_enter(obj, lock, THREAD);
}
void ObjectSynchronizer::fast_exit(oop object, BasicLock* lock, TRAPS) {
assert(!object->mark()->has_bias_pattern(), "should not see bias pattern here");
// if displaced header is null, the previous enter is recursive enter, no-op
markOop dhw = lock->displaced_header();
- markOop mark ;
+ markOop mark;
if (dhw == NULL) {
// Recursive stack-lock.
// Diagnostics -- Could be: stack-locked, inflating, inflated.
- mark = object->mark() ;
- assert (!mark->is_neutral(), "invariant") ;
+ mark = object->mark();
+ assert(!mark->is_neutral(), "invariant");
if (mark->has_locker() && mark != markOopDesc::INFLATING()) {
- assert(THREAD->is_lock_owned((address)mark->locker()), "invariant") ;
+ assert(THREAD->is_lock_owned((address)mark->locker()), "invariant");
}
if (mark->has_monitor()) {
- ObjectMonitor * m = mark->monitor() ;
- assert(((oop)(m->object()))->mark() == mark, "invariant") ;
- assert(m->is_entered(THREAD), "invariant") ;
+ ObjectMonitor * m = mark->monitor();
+ assert(((oop)(m->object()))->mark() == mark, "invariant");
+ assert(m->is_entered(THREAD), "invariant");
}
- return ;
+ return;
}
- mark = object->mark() ;
+ mark = object->mark();
// If the object is stack-locked by the current thread, try to
// swing the displaced header from the box back to the mark.
if (mark == (markOop) lock) {
- assert (dhw->is_neutral(), "invariant") ;
+ assert(dhw->is_neutral(), "invariant");
if ((markOop) Atomic::cmpxchg_ptr (dhw, object->mark_addr(), mark) == mark) {
- TEVENT (fast_exit: release stacklock) ;
+ TEVENT(fast_exit: release stacklock);
return;
}
}
- ObjectSynchronizer::inflate(THREAD, object)->exit (true, THREAD) ;
+ ObjectSynchronizer::inflate(THREAD, object)->exit(true, THREAD);
}
// -----------------------------------------------------------------------------
@@ -205,8 +205,8 @@
// be visible <= the ST performed by the CAS.
lock->set_displaced_header(mark);
if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
- TEVENT (slow_enter: release stacklock) ;
- return ;
+ TEVENT(slow_enter: release stacklock);
+ return;
}
// Fall through to inflate() ...
} else
@@ -220,8 +220,8 @@
#if 0
// The following optimization isn't particularly useful.
if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) {
- lock->set_displaced_header (NULL) ;
- return ;
+ lock->set_displaced_header(NULL);
+ return;
}
#endif
@@ -238,7 +238,7 @@
// failed in the interpreter/compiler code. Simply use the heavy
// weight monitor should be ok, unless someone find otherwise.
void ObjectSynchronizer::slow_exit(oop object, BasicLock* lock, TRAPS) {
- fast_exit (object, lock, THREAD) ;
+ fast_exit(object, lock, THREAD);
}
// -----------------------------------------------------------------------------
@@ -254,7 +254,7 @@
// 5) lock lock2
// NOTE: must use heavy weight monitor to handle complete_exit/reenter()
intptr_t ObjectSynchronizer::complete_exit(Handle obj, TRAPS) {
- TEVENT (complete_exit) ;
+ TEVENT(complete_exit);
if (UseBiasedLocking) {
BiasedLocking::revoke_and_rebias(obj, false, THREAD);
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
@@ -267,7 +267,7 @@
// NOTE: must use heavy weight monitor to handle complete_exit/reenter()
void ObjectSynchronizer::reenter(Handle obj, intptr_t recursion, TRAPS) {
- TEVENT (reenter) ;
+ TEVENT(reenter);
if (UseBiasedLocking) {
BiasedLocking::revoke_and_rebias(obj, false, THREAD);
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
@@ -282,7 +282,7 @@
// NOTE: must use heavy weight monitor to handle jni monitor enter
void ObjectSynchronizer::jni_enter(Handle obj, TRAPS) { // possible entry from jni enter
// the current locking is from JNI instead of Java code
- TEVENT (jni_enter) ;
+ TEVENT(jni_enter);
if (UseBiasedLocking) {
BiasedLocking::revoke_and_rebias(obj, false, THREAD);
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
@@ -306,7 +306,7 @@
// NOTE: must use heavy weight monitor to handle jni monitor exit
void ObjectSynchronizer::jni_exit(oop obj, Thread* THREAD) {
- TEVENT (jni_exit) ;
+ TEVENT(jni_exit);
if (UseBiasedLocking) {
Handle h_obj(THREAD, obj);
BiasedLocking::revoke_and_rebias(h_obj, false, THREAD);
@@ -332,7 +332,7 @@
_obj = obj;
if (_dolock) {
- TEVENT (ObjectLocker) ;
+ TEVENT(ObjectLocker);
ObjectSynchronizer::fast_enter(_obj, &_lock, false, _thread);
}
@@ -354,7 +354,7 @@
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
if (millis < 0) {
- TEVENT (wait - throw IAX) ;
+ TEVENT(wait - throw IAX);
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
}
ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj());
@@ -374,10 +374,10 @@
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
if (millis < 0) {
- TEVENT (wait - throw IAX) ;
+ TEVENT(wait - throw IAX);
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
}
- ObjectSynchronizer::inflate(THREAD, obj()) -> wait(millis, false, THREAD) ;
+ ObjectSynchronizer::inflate(THREAD, obj()) -> wait(millis, false, THREAD);
}
void ObjectSynchronizer::notify(Handle obj, TRAPS) {
@@ -428,31 +428,31 @@
struct SharedGlobals {
// These are highly shared mostly-read variables.
// To avoid false-sharing they need to be the sole occupants of a $ line.
- double padPrefix [8];
- volatile int stwRandom ;
- volatile int stwCycle ;
+ double padPrefix[8];
+ volatile int stwRandom;
+ volatile int stwCycle;
// Hot RW variables -- Sequester to avoid false-sharing
- double padSuffix [16];
- volatile int hcSequence ;
- double padFinal [8] ;
-} ;
+ double padSuffix[16];
+ volatile int hcSequence;
+ double padFinal[8];
+};
-static SharedGlobals GVars ;
-static int MonitorScavengeThreshold = 1000000 ;
-static volatile int ForceMonitorScavenge = 0 ; // Scavenge required and pending
+static SharedGlobals GVars;
+static int MonitorScavengeThreshold = 1000000;
+static volatile int ForceMonitorScavenge = 0; // Scavenge required and pending
static markOop ReadStableMark (oop obj) {
- markOop mark = obj->mark() ;
+ markOop mark = obj->mark();
if (!mark->is_being_inflated()) {
- return mark ; // normal fast-path return
+ return mark; // normal fast-path return
}
- int its = 0 ;
+ int its = 0;
for (;;) {
- markOop mark = obj->mark() ;
+ markOop mark = obj->mark();
if (!mark->is_being_inflated()) {
- return mark ; // normal fast-path return
+ return mark; // normal fast-path return
}
// The object is being inflated by some other thread.
@@ -465,11 +465,11 @@
// TODO: add inflation contention performance counters.
// TODO: restrict the aggregate number of spinners.
- ++its ;
+ ++its;
if (its > 10000 || !os::is_MP()) {
if (its & 1) {
- os::NakedYield() ;
- TEVENT (Inflate: INFLATING - yield) ;
+ os::NakedYield();
+ TEVENT(Inflate: INFLATING - yield);
} else {
// Note that the following code attenuates the livelock problem but is not
// a complete remedy. A more complete solution would require that the inflating
@@ -486,26 +486,26 @@
// then for each thread on the list, set the flag and unpark() the thread.
// This is conceptually similar to muxAcquire-muxRelease, except that muxRelease
// wakes at most one thread whereas we need to wake the entire list.
- int ix = (cast_from_oop<intptr_t>(obj) >> 5) & (NINFLATIONLOCKS-1) ;
- int YieldThenBlock = 0 ;
- assert (ix >= 0 && ix < NINFLATIONLOCKS, "invariant") ;
- assert ((NINFLATIONLOCKS & (NINFLATIONLOCKS-1)) == 0, "invariant") ;
- Thread::muxAcquire (InflationLocks + ix, "InflationLock") ;
+ int ix = (cast_from_oop<intptr_t>(obj) >> 5) & (NINFLATIONLOCKS-1);
+ int YieldThenBlock = 0;
+ assert(ix >= 0 && ix < NINFLATIONLOCKS, "invariant");
+ assert((NINFLATIONLOCKS & (NINFLATIONLOCKS-1)) == 0, "invariant");
+ Thread::muxAcquire(InflationLocks + ix, "InflationLock");
while (obj->mark() == markOopDesc::INFLATING()) {
// Beware: NakedYield() is advisory and has almost no effect on some platforms
// so we periodically call Self->_ParkEvent->park(1).
// We use a mixed spin/yield/block mechanism.
if ((YieldThenBlock++) >= 16) {
- Thread::current()->_ParkEvent->park(1) ;
+ Thread::current()->_ParkEvent->park(1);
} else {
- os::NakedYield() ;
+ os::NakedYield();
}
}
- Thread::muxRelease (InflationLocks + ix ) ;
- TEVENT (Inflate: INFLATING - yield/park) ;
+ Thread::muxRelease(InflationLocks + ix);
+ TEVENT(Inflate: INFLATING - yield/park);
}
} else {
- SpinPause() ; // SMP-polite spinning
+ SpinPause(); // SMP-polite spinning
}
}
}
@@ -529,48 +529,48 @@
//
static inline intptr_t get_next_hash(Thread * Self, oop obj) {
- intptr_t value = 0 ;
+ intptr_t value = 0;
if (hashCode == 0) {
// This form uses an unguarded global Park-Miller RNG,
// so it's possible for two threads to race and generate the same RNG.
// On MP system we'll have lots of RW access to a global, so the
// mechanism induces lots of coherency traffic.
- value = os::random() ;
+ value = os::random();
} else
if (hashCode == 1) {
// This variation has the property of being stable (idempotent)
// between STW operations. This can be useful in some of the 1-0
// synchronization schemes.
- intptr_t addrBits = cast_from_oop<intptr_t>(obj) >> 3 ;
- value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
+ intptr_t addrBits = cast_from_oop<intptr_t>(obj) >> 3;
+ value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom;
} else
if (hashCode == 2) {
- value = 1 ; // for sensitivity testing
+ value = 1; // for sensitivity testing
} else
if (hashCode == 3) {
- value = ++GVars.hcSequence ;
+ value = ++GVars.hcSequence;
} else
if (hashCode == 4) {
- value = cast_from_oop<intptr_t>(obj) ;
+ value = cast_from_oop<intptr_t>(obj);
} else {
// Marsaglia's xor-shift scheme with thread-specific state
// This is probably the best overall implementation -- we'll
// likely make this the default in future releases.
- unsigned t = Self->_hashStateX ;
- t ^= (t << 11) ;
- Self->_hashStateX = Self->_hashStateY ;
- Self->_hashStateY = Self->_hashStateZ ;
- Self->_hashStateZ = Self->_hashStateW ;
- unsigned v = Self->_hashStateW ;
- v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
- Self->_hashStateW = v ;
- value = v ;
+ unsigned t = Self->_hashStateX;
+ t ^= (t << 11);
+ Self->_hashStateX = Self->_hashStateY;
+ Self->_hashStateY = Self->_hashStateZ;
+ Self->_hashStateZ = Self->_hashStateW;
+ unsigned v = Self->_hashStateW;
+ v = (v ^ (v >> 19)) ^ (t ^ (t >> 8));
+ Self->_hashStateW = v;
+ value = v;
}
value &= markOopDesc::hash_mask;
- if (value == 0) value = 0xBAD ;
- assert (value != markOopDesc::no_hash, "invariant") ;
- TEVENT (hashCode: GENERATE) ;
+ if (value == 0) value = 0xBAD;
+ assert(value != markOopDesc::no_hash, "invariant");
+ TEVENT(hashCode: GENERATE);
return value;
}
//
@@ -585,25 +585,25 @@
// thread-local storage.
if (obj->mark()->has_bias_pattern()) {
// Box and unbox the raw reference just in case we cause a STW safepoint.
- Handle hobj (Self, obj) ;
+ Handle hobj(Self, obj);
// Relaxing assertion for bug 6320749.
- assert (Universe::verify_in_progress() ||
+ assert(Universe::verify_in_progress() ||
!SafepointSynchronize::is_at_safepoint(),
"biases should not be seen by VM thread here");
BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current());
- obj = hobj() ;
+ obj = hobj();
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
}
// hashCode() is a heap mutator ...
// Relaxing assertion for bug 6320749.
- assert (Universe::verify_in_progress() ||
- !SafepointSynchronize::is_at_safepoint(), "invariant") ;
- assert (Universe::verify_in_progress() ||
- Self->is_Java_thread() , "invariant") ;
- assert (Universe::verify_in_progress() ||
- ((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant") ;
+ assert(Universe::verify_in_progress() ||
+ !SafepointSynchronize::is_at_safepoint(), "invariant");
+ assert(Universe::verify_in_progress() ||
+ Self->is_Java_thread() , "invariant");
+ assert(Universe::verify_in_progress() ||
+ ((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant");
ObjectMonitor* monitor = NULL;
markOop temp, test;
@@ -611,7 +611,7 @@
markOop mark = ReadStableMark (obj);
// object should remain ineligible for biased locking
- assert (!mark->has_bias_pattern(), "invariant") ;
+ assert(!mark->has_bias_pattern(), "invariant");
if (mark->is_neutral()) {
hash = mark->hash(); // this is a normal header
@@ -631,7 +631,7 @@
} else if (mark->has_monitor()) {
monitor = mark->monitor();
temp = monitor->header();
- assert (temp->is_neutral(), "invariant") ;
+ assert(temp->is_neutral(), "invariant");
hash = temp->hash();
if (hash) {
return hash;
@@ -639,7 +639,7 @@
// Skip to the following code to reduce code size
} else if (Self->is_lock_owned((address)mark->locker())) {
temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
- assert (temp->is_neutral(), "invariant") ;
+ assert(temp->is_neutral(), "invariant");
hash = temp->hash(); // by current thread, check if the displaced
if (hash) { // header contains hash code
return hash;
@@ -659,20 +659,20 @@
monitor = ObjectSynchronizer::inflate(Self, obj);
// Load displaced header and check it has hash code
mark = monitor->header();
- assert (mark->is_neutral(), "invariant") ;
+ assert(mark->is_neutral(), "invariant");
hash = mark->hash();
if (hash == 0) {
hash = get_next_hash(Self, obj);
temp = mark->copy_set_hash(hash); // merge hash code into header
- assert (temp->is_neutral(), "invariant") ;
+ assert(temp->is_neutral(), "invariant");
test = (markOop) Atomic::cmpxchg_ptr(temp, monitor, mark);
if (test != mark) {
// The only update to the header in the monitor (outside GC)
// is install the hash code. If someone add new usage of
// displaced header, please update this code
hash = test->hash();
- assert (test->is_neutral(), "invariant") ;
- assert (hash != 0, "Trivial unexpected object/monitor header usage.");
+ assert(test->is_neutral(), "invariant");
+ assert(hash != 0, "Trivial unexpected object/monitor header usage.");
}
}
// We finally get the hash
@@ -682,7 +682,7 @@
// Deprecated -- use FastHashCode() instead.
intptr_t ObjectSynchronizer::identity_hash_value_for(Handle obj) {
- return FastHashCode (Thread::current(), obj()) ;
+ return FastHashCode(Thread::current(), obj());
}
@@ -696,7 +696,7 @@
assert(thread == JavaThread::current(), "Can only be called on current thread");
oop obj = h_obj();
- markOop mark = ReadStableMark (obj) ;
+ markOop mark = ReadStableMark(obj);
// Uncontended case, header points to stack
if (mark->has_locker()) {
@@ -705,7 +705,7 @@
// Contended case, header points to ObjectMonitor (tagged pointer)
if (mark->has_monitor()) {
ObjectMonitor* monitor = mark->monitor();
- return monitor->is_entered(thread) != 0 ;
+ return monitor->is_entered(thread) != 0;
}
// Unlocked case, header in place
assert(mark->is_neutral(), "sanity check");
@@ -721,8 +721,8 @@
(JavaThread *self, Handle h_obj) {
// The caller must beware this method can revoke bias, and
// revocation can result in a safepoint.
- assert (!SafepointSynchronize::is_at_safepoint(), "invariant") ;
- assert (self->thread_state() != _thread_blocked , "invariant") ;
+ assert(!SafepointSynchronize::is_at_safepoint(), "invariant");
+ assert(self->thread_state() != _thread_blocked , "invariant");
// Possible mark states: neutral, biased, stack-locked, inflated
@@ -735,7 +735,7 @@
assert(self == JavaThread::current(), "Can only be called on current thread");
oop obj = h_obj();
- markOop mark = ReadStableMark (obj) ;
+ markOop mark = ReadStableMark(obj);
// CASE: stack-locked. Mark points to a BasicLock on the owner's stack.
if (mark->has_locker()) {
@@ -747,15 +747,15 @@
// The Object:ObjectMonitor relationship is stable as long as we're
// not at a safepoint.
if (mark->has_monitor()) {
- void * owner = mark->monitor()->_owner ;
- if (owner == NULL) return owner_none ;
+ void * owner = mark->monitor()->_owner;
+ if (owner == NULL) return owner_none;
return (owner == self ||
self->is_lock_owned((address)owner)) ? owner_self : owner_other;
}
// CASE: neutral
assert(mark->is_neutral(), "sanity check");
- return owner_none ; // it's unlocked
+ return owner_none; // it's unlocked
}
// FIXME: jvmti should call this
@@ -772,7 +772,7 @@
oop obj = h_obj();
address owner = NULL;
- markOop mark = ReadStableMark (obj) ;
+ markOop mark = ReadStableMark(obj);
// Uncontended case, header points to stack
if (mark->has_locker()) {
@@ -819,7 +819,7 @@
// Get the next block in the block list.
static inline ObjectMonitor* next(ObjectMonitor* block) {
assert(block->object() == CHAINMARKER, "must be a block header");
- block = block->FreeNext ;
+ block = block->FreeNext;
assert(block == NULL || block->object() == CHAINMARKER, "must be a block header");
return block;
}
@@ -887,17 +887,17 @@
if (ForceMonitorScavenge == 0 && Atomic::xchg (1, &ForceMonitorScavenge) == 0) {
if (ObjectMonitor::Knob_Verbose) {
::printf ("Monitor scavenge - Induced STW @%s (%d)\n", Whence, ForceMonitorScavenge) ;
- ::fflush(stdout) ;
+ ::fflush(stdout);
}
// Induce a 'null' safepoint to scavenge monitors
// Must VM_Operation instance be heap allocated as the op will be enqueue and posted
// to the VMthread and have a lifespan longer than that of this activation record.
// The VMThread will delete the op when completed.
- VMThread::execute (new VM_ForceAsyncSafepoint()) ;
+ VMThread::execute(new VM_ForceAsyncSafepoint());
if (ObjectMonitor::Knob_Verbose) {
::printf ("Monitor scavenge - STW posted @%s (%d)\n", Whence, ForceMonitorScavenge) ;
- ::fflush(stdout) ;
+ ::fflush(stdout);
}
}
}
@@ -923,9 +923,9 @@
// number of objectMonitors in circulation as well as the STW
// scavenge costs. As usual, we lean toward time in space-time
// tradeoffs.
- const int MAXPRIVATE = 1024 ;
+ const int MAXPRIVATE = 1024;
for (;;) {
- ObjectMonitor * m ;
+ ObjectMonitor * m;
// 1: try to allocate from the thread's local omFreeList.
// Threads will attempt to allocate first from their local list, then
@@ -933,21 +933,21 @@
// attempt to instantiate new monitors. Thread-local free lists take
// heat off the ListLock and improve allocation latency, as well as reducing
// coherency traffic on the shared global list.
- m = Self->omFreeList ;
+ m = Self->omFreeList;
if (m != NULL) {
- Self->omFreeList = m->FreeNext ;
- Self->omFreeCount -- ;
+ Self->omFreeList = m->FreeNext;
+ Self->omFreeCount--;
// CONSIDER: set m->FreeNext = BAD -- diagnostic hygiene
- guarantee (m->object() == NULL, "invariant") ;
+ guarantee(m->object() == NULL, "invariant");
if (MonitorInUseLists) {
m->FreeNext = Self->omInUseList;
Self->omInUseList = m;
- Self->omInUseCount ++;
+ Self->omInUseCount++;
// verifyInUse(Self);
} else {
m->FreeNext = NULL;
}
- return m ;
+ return m;
}
// 2: try to allocate from the global gFreeList
@@ -959,27 +959,27 @@
// Reprovision the thread's omFreeList.
// Use bulk transfers to reduce the allocation rate and heat
// on various locks.
- Thread::muxAcquire (&ListLock, "omAlloc") ;
- for (int i = Self->omFreeProvision; --i >= 0 && gFreeList != NULL; ) {
- MonitorFreeCount --;
- ObjectMonitor * take = gFreeList ;
- gFreeList = take->FreeNext ;
- guarantee (take->object() == NULL, "invariant") ;
- guarantee (!take->is_busy(), "invariant") ;
- take->Recycle() ;
- omRelease (Self, take, false) ;
+ Thread::muxAcquire(&ListLock, "omAlloc");
+ for (int i = Self->omFreeProvision; --i >= 0 && gFreeList != NULL;) {
+ MonitorFreeCount--;
+ ObjectMonitor * take = gFreeList;
+ gFreeList = take->FreeNext;
+ guarantee(take->object() == NULL, "invariant");
+ guarantee(!take->is_busy(), "invariant");
+ take->Recycle();
+ omRelease(Self, take, false);
}
- Thread::muxRelease (&ListLock) ;
- Self->omFreeProvision += 1 + (Self->omFreeProvision/2) ;
- if (Self->omFreeProvision > MAXPRIVATE ) Self->omFreeProvision = MAXPRIVATE ;
- TEVENT (omFirst - reprovision) ;
+ Thread::muxRelease(&ListLock);
+ Self->omFreeProvision += 1 + (Self->omFreeProvision/2);
+ if (Self->omFreeProvision > MAXPRIVATE) Self->omFreeProvision = MAXPRIVATE;
+ TEVENT(omFirst - reprovision);
- const int mx = MonitorBound ;
+ const int mx = MonitorBound;
if (mx > 0 && (MonitorPopulation-MonitorFreeCount) > mx) {
// We can't safely induce a STW safepoint from omAlloc() as our thread
// state may not be appropriate for such activities and callers may hold
// naked oops, so instead we defer the action.
- InduceScavenge (Self, "omAlloc") ;
+ InduceScavenge(Self, "omAlloc");
}
continue;
}
@@ -987,14 +987,14 @@
// 3: allocate a block of new ObjectMonitors
// Both the local and global free lists are empty -- resort to malloc().
// In the current implementation objectMonitors are TSM - immortal.
- assert (_BLOCKSIZE > 1, "invariant") ;
+ assert(_BLOCKSIZE > 1, "invariant");
ObjectMonitor * temp = new ObjectMonitor[_BLOCKSIZE];
// NOTE: (almost) no way to recover if allocation failed.
// We might be able to induce a STW safepoint and scavenge enough
// objectMonitors to permit progress.
if (temp == NULL) {
- vm_exit_out_of_memory (sizeof (ObjectMonitor[_BLOCKSIZE]), OOM_MALLOC_ERROR,
+ vm_exit_out_of_memory(sizeof (ObjectMonitor[_BLOCKSIZE]), OOM_MALLOC_ERROR,
"Allocate ObjectMonitors");
}
@@ -1006,12 +1006,12 @@
// linkage should be reconsidered. A better implementation would
// look like: class Block { Block * next; int N; ObjectMonitor Body [N] ; }
- for (int i = 1; i < _BLOCKSIZE ; i++) {
+ for (int i = 1; i < _BLOCKSIZE; i++) {
temp[i].FreeNext = &temp[i+1];
}
// terminate the last monitor as the end of list
- temp[_BLOCKSIZE - 1].FreeNext = NULL ;
+ temp[_BLOCKSIZE - 1].FreeNext = NULL;
// Element [0] is reserved for global list linkage
temp[0].set_object(CHAINMARKER);
@@ -1022,7 +1022,7 @@
// Acquire the ListLock to manipulate BlockList and FreeList.
// An Oyama-Taura-Yonezawa scheme might be more efficient.
- Thread::muxAcquire (&ListLock, "omAlloc [2]") ;
+ Thread::muxAcquire(&ListLock, "omAlloc [2]");
MonitorPopulation += _BLOCKSIZE-1;
MonitorFreeCount += _BLOCKSIZE-1;
@@ -1033,10 +1033,10 @@
gBlockList = temp;
// Add the new string of objectMonitors to the global free list
- temp[_BLOCKSIZE - 1].FreeNext = gFreeList ;
+ temp[_BLOCKSIZE - 1].FreeNext = gFreeList;
gFreeList = temp + 1;
- Thread::muxRelease (&ListLock) ;
- TEVENT (Allocate block of monitors) ;
+ Thread::muxRelease(&ListLock);
+ TEVENT(Allocate block of monitors);
}
}
@@ -1049,12 +1049,12 @@
//
void ObjectSynchronizer::omRelease (Thread * Self, ObjectMonitor * m, bool fromPerThreadAlloc) {
- guarantee (m->object() == NULL, "invariant") ;
+ guarantee(m->object() == NULL, "invariant");
// Remove from omInUseList
if (MonitorInUseLists && fromPerThreadAlloc) {
ObjectMonitor* curmidinuse = NULL;
- for (ObjectMonitor* mid = Self->omInUseList; mid != NULL; ) {
+ for (ObjectMonitor* mid = Self->omInUseList; mid != NULL;) {
if (m == mid) {
// extract from per-thread in-use-list
if (mid == Self->omInUseList) {
@@ -1062,7 +1062,7 @@
} else if (curmidinuse != NULL) {
curmidinuse->FreeNext = mid->FreeNext; // maintain the current thread inuselist
}
- Self->omInUseCount --;
+ Self->omInUseCount--;
// verifyInUse(Self);
break;
} else {
@@ -1073,9 +1073,9 @@
}
// FreeNext is used for both onInUseList and omFreeList, so clear old before setting new
- m->FreeNext = Self->omFreeList ;
- Self->omFreeList = m ;
- Self->omFreeCount ++ ;
+ m->FreeNext = Self->omFreeList;
+ Self->omFreeList = m;
+ Self->omFreeCount++;
}
// Return the monitors of a moribund thread's local free list to
@@ -1099,25 +1099,25 @@
// operator.
void ObjectSynchronizer::omFlush (Thread * Self) {
- ObjectMonitor * List = Self->omFreeList ; // Null-terminated SLL
- Self->omFreeList = NULL ;
- ObjectMonitor * Tail = NULL ;
+ ObjectMonitor * List = Self->omFreeList; // Null-terminated SLL
+ Self->omFreeList = NULL;
+ ObjectMonitor * Tail = NULL;
int Tally = 0;
if (List != NULL) {
- ObjectMonitor * s ;
- for (s = List ; s != NULL ; s = s->FreeNext) {
- Tally ++ ;
- Tail = s ;
- guarantee (s->object() == NULL, "invariant") ;
- guarantee (!s->is_busy(), "invariant") ;
- s->set_owner (NULL) ; // redundant but good hygiene
- TEVENT (omFlush - Move one) ;
+ ObjectMonitor * s;
+ for (s = List; s != NULL; s = s->FreeNext) {
+ Tally++;
+ Tail = s;
+ guarantee(s->object() == NULL, "invariant");
+ guarantee(!s->is_busy(), "invariant");
+ s->set_owner(NULL); // redundant but good hygiene
+ TEVENT(omFlush - Move one);
}
- guarantee (Tail != NULL && List != NULL, "invariant") ;
+ guarantee(Tail != NULL && List != NULL, "invariant");
}
ObjectMonitor * InUseList = Self->omInUseList;
- ObjectMonitor * InUseTail = NULL ;
+ ObjectMonitor * InUseTail = NULL;
int InUseTally = 0;
if (InUseList != NULL) {
Self->omInUseList = NULL;
@@ -1129,13 +1129,13 @@
// TODO debug
assert(Self->omInUseCount == InUseTally, "inuse count off");
Self->omInUseCount = 0;
- guarantee (InUseTail != NULL && InUseList != NULL, "invariant");
+ guarantee(InUseTail != NULL && InUseList != NULL, "invariant");
}
- Thread::muxAcquire (&ListLock, "omFlush") ;
+ Thread::muxAcquire(&ListLock, "omFlush");
if (Tail != NULL) {
- Tail->FreeNext = gFreeList ;
- gFreeList = List ;
+ Tail->FreeNext = gFreeList;
+ gFreeList = List;
MonitorFreeCount += Tally;
}
@@ -1145,8 +1145,8 @@
gOmInUseCount += InUseTally;
}
- Thread::muxRelease (&ListLock) ;
- TEVENT (omFlush) ;
+ Thread::muxRelease(&ListLock);
+ TEVENT(omFlush);
}
// Fast path code shared by multiple functions
@@ -1168,12 +1168,12 @@
ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
// Inflate mutates the heap ...
// Relaxing assertion for bug 6320749.
- assert (Universe::verify_in_progress() ||
- !SafepointSynchronize::is_at_safepoint(), "invariant") ;
+ assert(Universe::verify_in_progress() ||
+ !SafepointSynchronize::is_at_safepoint(), "invariant");
for (;;) {
- const markOop mark = object->mark() ;
- assert (!mark->has_bias_pattern(), "invariant") ;
+ const markOop mark = object->mark();
+ assert(!mark->has_bias_pattern(), "invariant");
// The mark can be in one of the following states:
// * Inflated - just return
@@ -1184,11 +1184,11 @@
// CASE: inflated
if (mark->has_monitor()) {
- ObjectMonitor * inf = mark->monitor() ;
- assert (inf->header()->is_neutral(), "invariant");
- assert (inf->object() == object, "invariant") ;
- assert (ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
- return inf ;
+ ObjectMonitor * inf = mark->monitor();
+ assert(inf->header()->is_neutral(), "invariant");
+ assert(inf->object() == object, "invariant");
+ assert(ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
+ return inf;
}
// CASE: inflation in progress - inflating over a stack-lock.
@@ -1198,9 +1198,9 @@
// Currently, we spin/yield/park and poll the markword, waiting for inflation to finish.
// We could always eliminate polling by parking the thread on some auxiliary list.
if (mark == markOopDesc::INFLATING()) {
- TEVENT (Inflate: spin while INFLATING) ;
- ReadStableMark(object) ;
- continue ;
+ TEVENT(Inflate: spin while INFLATING);
+ ReadStableMark(object);
+ continue;
}
// CASE: stack-locked
@@ -1223,20 +1223,20 @@
// See the comments in omAlloc().
if (mark->has_locker()) {
- ObjectMonitor * m = omAlloc (Self) ;
+ ObjectMonitor * m = omAlloc(Self);
// Optimistically prepare the objectmonitor - anticipate successful CAS
// We do this before the CAS in order to minimize the length of time
// in which INFLATING appears in the mark.
m->Recycle();
- m->_Responsible = NULL ;
- m->OwnerIsThread = 0 ;
- m->_recursions = 0 ;
- m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ; // Consider: maintain by type/class
+ m->_Responsible = NULL;
+ m->OwnerIsThread = 0;
+ m->_recursions = 0;
+ m->_SpinDuration = ObjectMonitor::Knob_SpinLimit; // Consider: maintain by type/class
- markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
+ markOop cmp = (markOop) Atomic::cmpxchg_ptr(markOopDesc::INFLATING(), object->mark_addr(), mark);
if (cmp != mark) {
- omRelease (Self, m, true) ;
- continue ; // Interference -- just retry
+ omRelease(Self, m, true);
+ continue; // Interference -- just retry
}
// We've successfully installed INFLATING (0) into the mark-word.
@@ -1269,11 +1269,11 @@
// The owner can't die or unwind past the lock while our INFLATING
// object is in the mark. Furthermore the owner can't complete
// an unlock on the object, either.
- markOop dmw = mark->displaced_mark_helper() ;
- assert (dmw->is_neutral(), "invariant") ;
+ markOop dmw = mark->displaced_mark_helper();
+ assert(dmw->is_neutral(), "invariant");
// Setup monitor fields to proper values -- prepare the monitor
- m->set_header(dmw) ;
+ m->set_header(dmw);
// Optimization: if the mark->locker stack address is associated
// with this thread we could simply set m->_owner = Self and
@@ -1286,13 +1286,13 @@
// Must preserve store ordering. The monitor state must
// be stable at the time of publishing the monitor address.
- guarantee (object->mark() == markOopDesc::INFLATING(), "invariant") ;
+ guarantee(object->mark() == markOopDesc::INFLATING(), "invariant");
object->release_set_mark(markOopDesc::encode(m));
// Hopefully the performance counters are allocated on distinct cache lines
// to avoid false sharing on MP systems ...
- if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
- TEVENT(Inflate: overwrite stacklock) ;
+ if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc();
+ TEVENT(Inflate: overwrite stacklock);
if (TraceMonitorInflation) {
if (object->is_instance()) {
ResourceMark rm;
@@ -1301,7 +1301,7 @@
object->klass()->external_name());
}
}
- return m ;
+ return m;
}
// CASE: neutral
@@ -1314,26 +1314,26 @@
// An inflateTry() method that we could call from fast_enter() and slow_enter()
// would be useful.
- assert (mark->is_neutral(), "invariant");
- ObjectMonitor * m = omAlloc (Self) ;
+ assert(mark->is_neutral(), "invariant");
+ ObjectMonitor * m = omAlloc(Self);
// prepare m for installation - set monitor to initial state
m->Recycle();
m->set_header(mark);
m->set_owner(NULL);
m->set_object(object);
- m->OwnerIsThread = 1 ;
- m->_recursions = 0 ;
- m->_Responsible = NULL ;
- m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ; // consider: keep metastats by type/class
+ m->OwnerIsThread = 1;
+ m->_recursions = 0;
+ m->_Responsible = NULL;
+ m->_SpinDuration = ObjectMonitor::Knob_SpinLimit; // consider: keep metastats by type/class
if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
- m->set_object (NULL) ;
- m->set_owner (NULL) ;
- m->OwnerIsThread = 0 ;
- m->Recycle() ;
- omRelease (Self, m, true) ;
- m = NULL ;
- continue ;
+ m->set_object(NULL);
+ m->set_owner(NULL);
+ m->OwnerIsThread = 0;
+ m->Recycle();
+ omRelease(Self, m, true);
+ m = NULL;
+ continue;
// interference - the markword changed - just retry.
// The state-transitions are one-way, so there's no chance of
// live-lock -- "Inflated" is an absorbing state.
@@ -1341,8 +1341,8 @@
// Hopefully the performance counters are allocated on distinct
// cache lines to avoid false sharing on MP systems ...
- if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
- TEVENT(Inflate: overwrite neutral) ;
+ if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc();
+ TEVENT(Inflate: overwrite neutral);
if (TraceMonitorInflation) {
if (object->is_instance()) {
ResourceMark rm;
@@ -1351,7 +1351,7 @@
object->klass()->external_name());
}
}
- return m ;
+ return m;
}
}
@@ -1391,7 +1391,7 @@
enum ManifestConstants {
ClearResponsibleAtSTW = 0,
MaximumRecheckInterval = 1000
-} ;
+};
// Deflate a single monitor if not in use
// Return true if deflated, false if in use
@@ -1399,18 +1399,18 @@
ObjectMonitor** FreeHeadp, ObjectMonitor** FreeTailp) {
bool deflated;
// Normal case ... The monitor is associated with obj.
- guarantee (obj->mark() == markOopDesc::encode(mid), "invariant") ;
- guarantee (mid == obj->mark()->monitor(), "invariant");
- guarantee (mid->header()->is_neutral(), "invariant");
+ guarantee(obj->mark() == markOopDesc::encode(mid), "invariant");
+ guarantee(mid == obj->mark()->monitor(), "invariant");
+ guarantee(mid->header()->is_neutral(), "invariant");
if (mid->is_busy()) {
- if (ClearResponsibleAtSTW) mid->_Responsible = NULL ;
+ if (ClearResponsibleAtSTW) mid->_Responsible = NULL;
deflated = false;
} else {
// Deflate the monitor if it is no longer being used
// It's idle - scavenge and return to the global free list
// plain old deflation ...
- TEVENT (deflate_idle_monitors - scavenge1) ;
+ TEVENT(deflate_idle_monitors - scavenge1);
if (TraceMonitorInflation) {
if (obj->is_instance()) {
ResourceMark rm;
@@ -1423,7 +1423,7 @@
obj->release_set_mark(mid->header());
mid->clear();
- assert (mid->object() == NULL, "invariant") ;
+ assert(mid->object() == NULL, "invariant");
// Move the object to the working free list defined by FreeHead,FreeTail.
if (*FreeHeadp == NULL) *FreeHeadp = mid;
@@ -1446,7 +1446,7 @@
ObjectMonitor* curmidinuse = NULL;
int deflatedcount = 0;
- for (mid = *listheadp; mid != NULL; ) {
+ for (mid = *listheadp; mid != NULL;) {
oop obj = (oop) mid->object();
bool deflated = false;
if (obj != NULL) {
@@ -1473,19 +1473,19 @@
void ObjectSynchronizer::deflate_idle_monitors() {
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
- int nInuse = 0 ; // currently associated with objects
- int nInCirculation = 0 ; // extant
- int nScavenged = 0 ; // reclaimed
+ int nInuse = 0; // currently associated with objects
+ int nInCirculation = 0; // extant
+ int nScavenged = 0; // reclaimed
bool deflated = false;
- ObjectMonitor * FreeHead = NULL ; // Local SLL of scavenged monitors
- ObjectMonitor * FreeTail = NULL ;
+ ObjectMonitor * FreeHead = NULL; // Local SLL of scavenged monitors
+ ObjectMonitor * FreeTail = NULL;
- TEVENT (deflate_idle_monitors) ;
+ TEVENT(deflate_idle_monitors);
// Prevent omFlush from changing mids in Thread dtor's during deflation
// And in case the vm thread is acquiring a lock during a safepoint
// See e.g. 6320749
- Thread::muxAcquire (&ListLock, "scavenge - return") ;
+ Thread::muxAcquire(&ListLock, "scavenge - return");
if (MonitorInUseLists) {
int inUse = 0;
@@ -1510,8 +1510,8 @@
} else for (ObjectMonitor* block = gBlockList; block != NULL; block = next(block)) {
// Iterate over all extant monitors - Scavenge all idle monitors.
assert(block->object() == CHAINMARKER, "must be a block header");
- nInCirculation += _BLOCKSIZE ;
- for (int i = 1 ; i < _BLOCKSIZE; i++) {
+ nInCirculation += _BLOCKSIZE;
+ for (int i = 1; i < _BLOCKSIZE; i++) {
ObjectMonitor* mid = &block[i];
oop obj = (oop) mid->object();
@@ -1520,16 +1520,16 @@
// The monitor should either be a thread-specific private
// free list or the global free list.
// obj == NULL IMPLIES mid->is_busy() == 0
- guarantee (!mid->is_busy(), "invariant") ;
- continue ;
+ guarantee(!mid->is_busy(), "invariant");
+ continue;
}
deflated = deflate_monitor(mid, obj, &FreeHead, &FreeTail);
if (deflated) {
- mid->FreeNext = NULL ;
- nScavenged ++ ;
+ mid->FreeNext = NULL;
+ nScavenged++;
} else {
- nInuse ++;
+ nInuse++;
}
}
}
@@ -1539,31 +1539,31 @@
// Consider: audit gFreeList to ensure that MonitorFreeCount and list agree.
if (ObjectMonitor::Knob_Verbose) {
- ::printf ("Deflate: InCirc=%d InUse=%d Scavenged=%d ForceMonitorScavenge=%d : pop=%d free=%d\n",
+ ::printf("Deflate: InCirc=%d InUse=%d Scavenged=%d ForceMonitorScavenge=%d : pop=%d free=%d\n",
nInCirculation, nInuse, nScavenged, ForceMonitorScavenge,
- MonitorPopulation, MonitorFreeCount) ;
- ::fflush(stdout) ;
+ MonitorPopulation, MonitorFreeCount);
+ ::fflush(stdout);
}
ForceMonitorScavenge = 0; // Reset
// Move the scavenged monitors back to the global free list.
if (FreeHead != NULL) {
- guarantee (FreeTail != NULL && nScavenged > 0, "invariant") ;
- assert (FreeTail->FreeNext == NULL, "invariant") ;
+ guarantee(FreeTail != NULL && nScavenged > 0, "invariant");
+ assert(FreeTail->FreeNext == NULL, "invariant");
// constant-time list splice - prepend scavenged segment to gFreeList
- FreeTail->FreeNext = gFreeList ;
- gFreeList = FreeHead ;
+ FreeTail->FreeNext = gFreeList;
+ gFreeList = FreeHead;
}
- Thread::muxRelease (&ListLock) ;
+ Thread::muxRelease(&ListLock);
- if (ObjectMonitor::_sync_Deflations != NULL) ObjectMonitor::_sync_Deflations->inc(nScavenged) ;
+ if (ObjectMonitor::_sync_Deflations != NULL) ObjectMonitor::_sync_Deflations->inc(nScavenged);
if (ObjectMonitor::_sync_MonExtant != NULL) ObjectMonitor::_sync_MonExtant ->set_value(nInCirculation);
// TODO: Add objectMonitor leak detection.
// Audit/inventory the objectMonitors -- make sure they're all accounted for.
- GVars.stwRandom = os::random() ;
- GVars.stwCycle ++ ;
+ GVars.stwRandom = os::random();
+ GVars.stwCycle++;
}
// Monitor cleanup on JavaThread::exit
@@ -1601,7 +1601,7 @@
void ObjectSynchronizer::release_monitors_owned_by_thread(TRAPS) {
assert(THREAD == JavaThread::current(), "must be current Java thread");
- No_Safepoint_Verifier nsv ;
+ No_Safepoint_Verifier nsv;
ReleaseJavaMonitorsClosure rjmc(THREAD);
Thread::muxAcquire(&ListLock, "release_monitors_owned_by_thread");
ObjectSynchronizer::monitors_iterate(&rjmc);
--- a/hotspot/src/share/vm/runtime/thread.cpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/share/vm/runtime/thread.cpp Tue Jun 17 12:54:01 2014 -0700
@@ -225,11 +225,11 @@
_current_pending_monitor_is_from_java = true;
_current_waiting_monitor = NULL;
_num_nested_signal = 0;
- omFreeList = NULL ;
- omFreeCount = 0 ;
- omFreeProvision = 32 ;
- omInUseList = NULL ;
- omInUseCount = 0 ;
+ omFreeList = NULL;
+ omFreeCount = 0;
+ omFreeProvision = 32;
+ omInUseList = NULL;
+ omInUseCount = 0;
#ifdef ASSERT
_visited_for_critical_count = false;
@@ -239,15 +239,15 @@
_suspend_flags = 0;
// thread-specific hashCode stream generator state - Marsaglia shift-xor form
- _hashStateX = os::random() ;
- _hashStateY = 842502087 ;
- _hashStateZ = 0x8767 ; // (int)(3579807591LL & 0xffff) ;
- _hashStateW = 273326509 ;
-
- _OnTrap = 0 ;
- _schedctl = NULL ;
- _Stalled = 0 ;
- _TypeTag = 0x2BAD ;
+ _hashStateX = os::random();
+ _hashStateY = 842502087;
+ _hashStateZ = 0x8767; // (int)(3579807591LL & 0xffff) ;
+ _hashStateW = 273326509;
+
+ _OnTrap = 0;
+ _schedctl = NULL;
+ _Stalled = 0;
+ _TypeTag = 0x2BAD;
// Many of the following fields are effectively final - immutable
// Note that nascent threads can't use the Native Monitor-Mutex
@@ -256,10 +256,10 @@
// we might instead use a stack of ParkEvents that we could provision on-demand.
// The stack would act as a cache to avoid calls to ParkEvent::Allocate()
// and ::Release()
- _ParkEvent = ParkEvent::Allocate (this) ;
- _SleepEvent = ParkEvent::Allocate (this) ;
- _MutexEvent = ParkEvent::Allocate (this) ;
- _MuxEvent = ParkEvent::Allocate (this) ;
+ _ParkEvent = ParkEvent::Allocate(this);
+ _SleepEvent = ParkEvent::Allocate(this);
+ _MutexEvent = ParkEvent::Allocate(this);
+ _MuxEvent = ParkEvent::Allocate(this);
#ifdef CHECK_UNHANDLED_OOPS
if (CheckUnhandledOops) {
@@ -314,7 +314,7 @@
Thread::~Thread() {
// Reclaim the objectmonitors from the omFreeList of the moribund thread.
- ObjectSynchronizer::omFlush (this) ;
+ ObjectSynchronizer::omFlush(this);
EVENT_THREAD_DESTRUCT(this);
@@ -342,10 +342,10 @@
// It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.
// We NULL out the fields for good hygiene.
- ParkEvent::Release (_ParkEvent) ; _ParkEvent = NULL ;
- ParkEvent::Release (_SleepEvent) ; _SleepEvent = NULL ;
- ParkEvent::Release (_MutexEvent) ; _MutexEvent = NULL ;
- ParkEvent::Release (_MuxEvent) ; _MuxEvent = NULL ;
+ ParkEvent::Release(_ParkEvent); _ParkEvent = NULL;
+ ParkEvent::Release(_SleepEvent); _SleepEvent = NULL;
+ ParkEvent::Release(_MutexEvent); _MutexEvent = NULL;
+ ParkEvent::Release(_MuxEvent); _MuxEvent = NULL;
delete handle_area();
delete metadata_handles();
@@ -844,7 +844,7 @@
// Thread::print_on_error() is called by fatal error handler. Don't use
// any lock or allocate memory.
void Thread::print_on_error(outputStream* st, char* buf, int buflen) const {
- if (is_VM_thread()) st->print("VMThread");
+ if (is_VM_thread()) st->print("VMThread");
else if (is_Compiler_thread()) st->print("CompilerThread");
else if (is_Java_thread()) st->print("JavaThread");
else if (is_GC_task_thread()) st->print("GCTaskThread");
@@ -867,7 +867,7 @@
st->print(" (no locks) ");
} else {
st->print_cr(" Locks owned:");
- while(cur) {
+ while (cur) {
cur->print_on(st);
cur = cur->next();
}
@@ -877,7 +877,7 @@
static int ref_use_count = 0;
bool Thread::owns_locks_but_compiled_lock() const {
- for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
+ for (Monitor *cur = _owned_locks; cur; cur = cur->next()) {
if (cur != Compile_lock) return true;
}
return false;
@@ -904,12 +904,12 @@
&& !Universe::is_bootstrapping()) {
// Make sure we do not hold any locks that the VM thread also uses.
// This could potentially lead to deadlocks
- for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
+ for (Monitor *cur = _owned_locks; cur; cur = cur->next()) {
// Threads_lock is special, since the safepoint synchronization will not start before this is
// acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
// since it is used to transfer control between JavaThreads and the VMThread
// Do not *exclude* any locks unless you are absolutely sure it is correct. Ask someone else first!
- if ( (cur->allow_vm_block() &&
+ if ((cur->allow_vm_block() &&
cur != Threads_lock &&
cur != Compile_lock && // Temporary: should not be necessary when we get separate compilation
cur != VMOperationRequest_lock &&
@@ -1291,9 +1291,9 @@
this->record_stack_base_and_size();
this->initialize_thread_local_storage();
this->set_active_handles(JNIHandleBlock::allocate_block());
- while(!_should_terminate) {
- assert(watcher_thread() == Thread::current(), "thread consistency check");
- assert(watcher_thread() == this, "thread consistency check");
+ while (!_should_terminate) {
+ assert(watcher_thread() == Thread::current(), "thread consistency check");
+ assert(watcher_thread() == this, "thread consistency check");
// Calculate how long it'll be until the next PeriodicTask work
// should be done, and sleep that amount of time.
@@ -1370,7 +1370,7 @@
// it is ok to take late safepoints here, if needed
MutexLocker mu(Terminator_lock);
- while(watcher_thread() != NULL) {
+ while (watcher_thread() != NULL) {
// This wait should make safepoint checks, wait without a timeout,
// and wait as a suspend-equivalent condition.
//
@@ -1451,11 +1451,11 @@
_pending_jni_exception_check_fn = NULL;
_do_not_unlock_if_synchronized = false;
_cached_monitor_info = NULL;
- _parker = Parker::Allocate(this) ;
+ _parker = Parker::Allocate(this);
#ifndef PRODUCT
_jmp_ring_index = 0;
- for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) {
+ for (int ji = 0; ji < jump_ring_buffer_size; ji++) {
record_jump(NULL, NULL, NULL, 0);
}
#endif /* PRODUCT */
@@ -1592,7 +1592,7 @@
// JSR166 -- return the parker to the free list
Parker::Release(_parker);
- _parker = NULL ;
+ _parker = NULL;
// Free any remaining previous UnrollBlock
vframeArray* old_array = vframe_array_last();
@@ -1718,7 +1718,7 @@
// For any new cleanup additions, please check to see if they need to be applied to
// cleanup_failed_attach_current_thread as well.
void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
- assert(this == JavaThread::current(), "thread consistency check");
+ assert(this == JavaThread::current(), "thread consistency check");
HandleMark hm(this);
Handle uncaught_exception(this, this->pending_exception());
@@ -2058,7 +2058,7 @@
if (TraceExceptions) {
ResourceMark rm;
tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this);
- if (has_last_Java_frame() ) {
+ if (has_last_Java_frame()) {
frame f = last_frame();
tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp());
}
@@ -2302,11 +2302,11 @@
void JavaThread::verify_not_published() {
if (!Threads_lock->owned_by_self()) {
MutexLockerEx ml(Threads_lock, Mutex::_no_safepoint_check_flag);
- assert( !Threads::includes(this),
+ assert(!Threads::includes(this),
"java thread shouldn't have been published yet!");
}
else {
- assert( !Threads::includes(this),
+ assert(!Threads::includes(this),
"java thread shouldn't have been published yet!");
}
}
@@ -2375,7 +2375,7 @@
thread->clear_deopt_suspend();
RegisterMap map(thread, false);
frame f = thread->last_frame();
- while ( f.id() != thread->must_deopt_id() && ! f.is_first_frame()) {
+ while (f.id() != thread->must_deopt_id() && ! f.is_first_frame()) {
f = f.sender(&map);
}
if (f.id() == thread->must_deopt_id()) {
@@ -2499,8 +2499,8 @@
// We need to adjust it to work correctly with guard_memory()
address base = stack_yellow_zone_base() - stack_yellow_zone_size();
- guarantee(base < stack_base(),"Error calculating stack yellow zone");
- guarantee(base < os::current_stack_pointer(),"Error calculating stack yellow zone");
+ guarantee(base < stack_base(), "Error calculating stack yellow zone");
+ guarantee(base < os::current_stack_pointer(), "Error calculating stack yellow zone");
if (os::guard_memory((char *) base, stack_yellow_zone_size())) {
_stack_guard_state = stack_guard_enabled;
@@ -2535,10 +2535,10 @@
assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
address base = stack_red_zone_base() - stack_red_zone_size();
- guarantee(base < stack_base(),"Error calculating stack red zone");
- guarantee(base < os::current_stack_pointer(),"Error calculating stack red zone");
-
- if(!os::guard_memory((char *) base, stack_red_zone_size())) {
+ guarantee(base < stack_base(), "Error calculating stack red zone");
+ guarantee(base < os::current_stack_pointer(), "Error calculating stack red zone");
+
+ if (!os::guard_memory((char *) base, stack_red_zone_size())) {
warning("Attempt to guard stack red zone failed.");
}
}
@@ -2557,7 +2557,7 @@
// ignore is there is no stack
if (!has_last_Java_frame()) return;
// traverse the stack frames. Starts from top frame.
- for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
+ for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
frame* fr = fst.current();
f(fr, fst.register_map());
}
@@ -2573,8 +2573,8 @@
bool deopt = false; // Dump stack only if a deopt actually happens.
bool only_at = strlen(DeoptimizeOnlyAt) > 0;
// Iterate over all frames in the thread and deoptimize
- for(; !fst.is_done(); fst.next()) {
- if(fst.current()->can_be_deoptimized()) {
+ for (; !fst.is_done(); fst.next()) {
+ if (fst.current()->can_be_deoptimized()) {
if (only_at) {
// Deoptimize only at particular bcis. DeoptimizeOnlyAt
@@ -2619,7 +2619,7 @@
// Make zombies
void JavaThread::make_zombies() {
- for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
+ for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
if (fst.current()->can_be_deoptimized()) {
// it is a Java nmethod
nmethod* nm = CodeCache::find_nmethod(fst.current()->pc());
@@ -2634,7 +2634,7 @@
if (!has_last_Java_frame()) return;
// BiasedLocking needs an updated RegisterMap for the revoke monitors pass
StackFrameStream fst(this, UseBiasedLocking);
- for(; !fst.is_done(); fst.next()) {
+ for (; !fst.is_done(); fst.next()) {
if (fst.current()->should_be_deoptimized()) {
if (LogCompilation && xtty != NULL) {
nmethod* nm = fst.current()->cb()->as_nmethod_or_null();
@@ -2694,7 +2694,7 @@
// Traverse the GCHandles
Thread::oops_do(f, cld_f, cf);
- assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
+ assert((!has_last_Java_frame() && java_call_counter() == 0) ||
(has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
if (has_last_Java_frame()) {
@@ -2719,7 +2719,7 @@
}
// Traverse the execution stack
- for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
+ for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
fst.current()->oops_do(f, cld_f, cf, fst.register_map());
}
}
@@ -2754,12 +2754,12 @@
void JavaThread::nmethods_do(CodeBlobClosure* cf) {
Thread::nmethods_do(cf); // (super method is a no-op)
- assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
+ assert((!has_last_Java_frame() && java_call_counter() == 0) ||
(has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
if (has_last_Java_frame()) {
// Traverse the execution stack
- for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
+ for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
fst.current()->nmethods_do(cf);
}
}
@@ -2769,7 +2769,7 @@
Thread::metadata_do(f);
if (has_last_Java_frame()) {
// Traverse the execution stack to call f() on the methods in the stack
- for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
+ for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
fst.current()->metadata_do(f);
}
} else if (is_Compiler_thread()) {
@@ -2832,7 +2832,7 @@
// Called by fatal error handler. The difference between this and
// JavaThread::print() is that we can't grab lock or allocate memory.
void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const {
- st->print("JavaThread \"%s\"", get_thread_name_string(buf, buflen));
+ st->print("JavaThread \"%s\"", get_thread_name_string(buf, buflen));
oop thread_obj = threadObj();
if (thread_obj != NULL) {
if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon");
@@ -3015,7 +3015,7 @@
RegisterMap reg_map(this);
vframe* start_vf = last_java_vframe(®_map);
int count = 0;
- for (vframe* f = start_vf; f; f = f->sender() ) {
+ for (vframe* f = start_vf; f; f = f->sender()) {
if (f->is_java_frame()) {
javaVFrame* jvf = javaVFrame::cast(f);
java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci());
@@ -3071,9 +3071,9 @@
void JavaThread::trace_frames() {
tty->print_cr("[Describe stack]");
int frame_no = 1;
- for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
+ for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
tty->print(" %d. ", frame_no++);
- fst.current()->print_value_on(tty,this);
+ fst.current()->print_value_on(tty, this);
tty->cr();
}
}
@@ -3124,7 +3124,7 @@
PRESERVE_EXCEPTION_MARK;
FrameValues values;
int frame_no = 0;
- for(StackFrameStream fst(this, false); !fst.is_done(); fst.next()) {
+ for (StackFrameStream fst(this, false); !fst.is_done(); fst.next()) {
fst.current()->describe(values, ++frame_no);
if (depth == frame_no) break;
}
@@ -3140,7 +3140,7 @@
void JavaThread::trace_stack_from(vframe* start_vf) {
ResourceMark rm;
int vframe_no = 1;
- for (vframe* f = start_vf; f; f = f->sender() ) {
+ for (vframe* f = start_vf; f; f = f->sender()) {
if (f->is_java_frame()) {
javaVFrame::cast(f)->print_activation(vframe_no++);
} else {
@@ -3169,7 +3169,7 @@
javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) {
assert(reg_map != NULL, "a map must be given");
frame f = last_frame();
- for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender() ) {
+ for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender()) {
if (vf->is_java_frame()) return javaVFrame::cast(vf);
}
return NULL;
@@ -3291,7 +3291,7 @@
// The VM preresolves methods to these classes. Make sure that they get initialized
initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK);
- initialize_class(vmSymbols::java_lang_ref_Finalizer(), CHECK);
+ initialize_class(vmSymbols::java_lang_ref_Finalizer(), CHECK);
call_initializeSystemClass(CHECK);
// get the Java runtime name after java.lang.System is initialized
@@ -3425,7 +3425,7 @@
main_thread->create_stack_guard_pages();
// Initialize Java-Level synchronization subsystem
- ObjectMonitor::Initialize() ;
+ ObjectMonitor::Initialize();
// Second phase of bootstrapping, VM is about entering multi-thread mode
MemTracker::bootstrap_multi_thread();
@@ -3473,7 +3473,7 @@
}
}
- assert (Universe::is_fully_initialized(), "not initialized");
+ assert(Universe::is_fully_initialized(), "not initialized");
if (VerifyDuringStartup) {
// Make sure we're starting with a clean slate.
VM_Verify verify_op;
@@ -3899,7 +3899,7 @@
#endif
// Wait until we are the last non-daemon thread to execute
{ MutexLocker nu(Threads_lock);
- while (Threads::number_of_non_daemon_threads() > 1 )
+ while (Threads::number_of_non_daemon_threads() > 1)
// This wait should make safepoint checks, wait without a timeout,
// and wait as a suspend-equivalent condition.
//
@@ -4078,7 +4078,7 @@
bool Threads::includes(JavaThread* p) {
assert(Threads_lock->is_locked(), "sanity check");
ALL_JAVA_THREADS(q) {
- if (q == p ) {
+ if (q == p) {
return true;
}
}
@@ -4363,43 +4363,43 @@
// cache-coherency traffic.
-typedef volatile int SpinLockT ;
+typedef volatile int SpinLockT;
void Thread::SpinAcquire (volatile int * adr, const char * LockName) {
if (Atomic::cmpxchg (1, adr, 0) == 0) {
- return ; // normal fast-path return
+ return; // normal fast-path return
}
// Slow-path : We've encountered contention -- Spin/Yield/Block strategy.
- TEVENT (SpinAcquire - ctx) ;
- int ctr = 0 ;
- int Yields = 0 ;
+ TEVENT(SpinAcquire - ctx);
+ int ctr = 0;
+ int Yields = 0;
for (;;) {
while (*adr != 0) {
- ++ctr ;
+ ++ctr;
if ((ctr & 0xFFF) == 0 || !os::is_MP()) {
if (Yields > 5) {
os::naked_short_sleep(1);
} else {
- os::NakedYield() ;
- ++Yields ;
+ os::NakedYield();
+ ++Yields;
}
} else {
- SpinPause() ;
+ SpinPause();
}
}
- if (Atomic::cmpxchg (1, adr, 0) == 0) return ;
+ if (Atomic::cmpxchg(1, adr, 0) == 0) return;
}
}
void Thread::SpinRelease (volatile int * adr) {
- assert (*adr != 0, "invariant") ;
- OrderAccess::fence() ; // guarantee at least release consistency.
+ assert(*adr != 0, "invariant");
+ OrderAccess::fence(); // guarantee at least release consistency.
// Roach-motel semantics.
// It's safe if subsequent LDs and STs float "up" into the critical section,
// but prior LDs and STs within the critical section can't be allowed
// to reorder or float past the ST that releases the lock.
- *adr = 0 ;
+ *adr = 0;
}
// muxAcquire and muxRelease:
@@ -4452,111 +4452,111 @@
//
-typedef volatile intptr_t MutexT ; // Mux Lock-word
-enum MuxBits { LOCKBIT = 1 } ;
+typedef volatile intptr_t MutexT; // Mux Lock-word
+enum MuxBits { LOCKBIT = 1 };
void Thread::muxAcquire (volatile intptr_t * Lock, const char * LockName) {
- intptr_t w = Atomic::cmpxchg_ptr (LOCKBIT, Lock, 0) ;
- if (w == 0) return ;
+ intptr_t w = Atomic::cmpxchg_ptr(LOCKBIT, Lock, 0);
+ if (w == 0) return;
if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
- return ;
+ return;
}
- TEVENT (muxAcquire - Contention) ;
- ParkEvent * const Self = Thread::current()->_MuxEvent ;
- assert ((intptr_t(Self) & LOCKBIT) == 0, "invariant") ;
+ TEVENT(muxAcquire - Contention);
+ ParkEvent * const Self = Thread::current()->_MuxEvent;
+ assert((intptr_t(Self) & LOCKBIT) == 0, "invariant");
for (;;) {
- int its = (os::is_MP() ? 100 : 0) + 1 ;
+ int its = (os::is_MP() ? 100 : 0) + 1;
// Optional spin phase: spin-then-park strategy
while (--its >= 0) {
- w = *Lock ;
+ w = *Lock;
if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
- return ;
+ return;
}
}
- Self->reset() ;
- Self->OnList = intptr_t(Lock) ;
+ Self->reset();
+ Self->OnList = intptr_t(Lock);
// The following fence() isn't _strictly necessary as the subsequent
// CAS() both serializes execution and ratifies the fetched *Lock value.
OrderAccess::fence();
for (;;) {
- w = *Lock ;
+ w = *Lock;
if ((w & LOCKBIT) == 0) {
if (Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
- Self->OnList = 0 ; // hygiene - allows stronger asserts
- return ;
+ Self->OnList = 0; // hygiene - allows stronger asserts
+ return;
}
- continue ; // Interference -- *Lock changed -- Just retry
+ continue; // Interference -- *Lock changed -- Just retry
}
- assert (w & LOCKBIT, "invariant") ;
- Self->ListNext = (ParkEvent *) (w & ~LOCKBIT );
- if (Atomic::cmpxchg_ptr (intptr_t(Self)|LOCKBIT, Lock, w) == w) break ;
+ assert(w & LOCKBIT, "invariant");
+ Self->ListNext = (ParkEvent *) (w & ~LOCKBIT);
+ if (Atomic::cmpxchg_ptr(intptr_t(Self)|LOCKBIT, Lock, w) == w) break;
}
while (Self->OnList != 0) {
- Self->park() ;
+ Self->park();
}
}
}
void Thread::muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) {
- intptr_t w = Atomic::cmpxchg_ptr (LOCKBIT, Lock, 0) ;
- if (w == 0) return ;
+ intptr_t w = Atomic::cmpxchg_ptr(LOCKBIT, Lock, 0);
+ if (w == 0) return;
if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
- return ;
+ return;
}
- TEVENT (muxAcquire - Contention) ;
- ParkEvent * ReleaseAfter = NULL ;
+ TEVENT(muxAcquire - Contention);
+ ParkEvent * ReleaseAfter = NULL;
if (ev == NULL) {
- ev = ReleaseAfter = ParkEvent::Allocate (NULL) ;
+ ev = ReleaseAfter = ParkEvent::Allocate(NULL);
}
- assert ((intptr_t(ev) & LOCKBIT) == 0, "invariant") ;
+ assert((intptr_t(ev) & LOCKBIT) == 0, "invariant");
for (;;) {
- guarantee (ev->OnList == 0, "invariant") ;
- int its = (os::is_MP() ? 100 : 0) + 1 ;
+ guarantee(ev->OnList == 0, "invariant");
+ int its = (os::is_MP() ? 100 : 0) + 1;
// Optional spin phase: spin-then-park strategy
while (--its >= 0) {
- w = *Lock ;
+ w = *Lock;
if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
if (ReleaseAfter != NULL) {
- ParkEvent::Release (ReleaseAfter) ;
+ ParkEvent::Release(ReleaseAfter);
}
- return ;
+ return;
}
}
- ev->reset() ;
- ev->OnList = intptr_t(Lock) ;
+ ev->reset();
+ ev->OnList = intptr_t(Lock);
// The following fence() isn't _strictly necessary as the subsequent
// CAS() both serializes execution and ratifies the fetched *Lock value.
OrderAccess::fence();
for (;;) {
- w = *Lock ;
+ w = *Lock;
if ((w & LOCKBIT) == 0) {
if (Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
- ev->OnList = 0 ;
+ ev->OnList = 0;
// We call ::Release while holding the outer lock, thus
// artificially lengthening the critical section.
// Consider deferring the ::Release() until the subsequent unlock(),
// after we've dropped the outer lock.
if (ReleaseAfter != NULL) {
- ParkEvent::Release (ReleaseAfter) ;
+ ParkEvent::Release(ReleaseAfter);
}
- return ;
+ return;
}
- continue ; // Interference -- *Lock changed -- Just retry
+ continue; // Interference -- *Lock changed -- Just retry
}
- assert (w & LOCKBIT, "invariant") ;
- ev->ListNext = (ParkEvent *) (w & ~LOCKBIT );
- if (Atomic::cmpxchg_ptr (intptr_t(ev)|LOCKBIT, Lock, w) == w) break ;
+ assert(w & LOCKBIT, "invariant");
+ ev->ListNext = (ParkEvent *) (w & ~LOCKBIT);
+ if (Atomic::cmpxchg_ptr(intptr_t(ev)|LOCKBIT, Lock, w) == w) break;
}
while (ev->OnList != 0) {
- ev->park() ;
+ ev->park();
}
}
}
@@ -4583,22 +4583,22 @@
void Thread::muxRelease (volatile intptr_t * Lock) {
for (;;) {
- const intptr_t w = Atomic::cmpxchg_ptr (0, Lock, LOCKBIT) ;
- assert (w & LOCKBIT, "invariant") ;
- if (w == LOCKBIT) return ;
- ParkEvent * List = (ParkEvent *) (w & ~LOCKBIT) ;
- assert (List != NULL, "invariant") ;
- assert (List->OnList == intptr_t(Lock), "invariant") ;
- ParkEvent * nxt = List->ListNext ;
+ const intptr_t w = Atomic::cmpxchg_ptr(0, Lock, LOCKBIT);
+ assert(w & LOCKBIT, "invariant");
+ if (w == LOCKBIT) return;
+ ParkEvent * List = (ParkEvent *)(w & ~LOCKBIT);
+ assert(List != NULL, "invariant");
+ assert(List->OnList == intptr_t(Lock), "invariant");
+ ParkEvent * nxt = List->ListNext;
// The following CAS() releases the lock and pops the head element.
if (Atomic::cmpxchg_ptr (intptr_t(nxt), Lock, w) != w) {
- continue ;
+ continue;
}
- List->OnList = 0 ;
- OrderAccess::fence() ;
- List->unpark () ;
- return ;
+ List->OnList = 0;
+ OrderAccess::fence();
+ List->unpark();
+ return;
}
}
--- a/hotspot/src/share/vm/runtime/thread.hpp Fri Jun 13 19:07:11 2014 -0700
+++ b/hotspot/src/share/vm/runtime/thread.hpp Tue Jun 17 12:54:01 2014 -0700
@@ -244,7 +244,7 @@
// The two classes No_Safepoint_Verifier and No_Allocation_Verifier are used to set these counters.
//
NOT_PRODUCT(int _allow_safepoint_count;) // If 0, thread allow a safepoint to happen
- debug_only (int _allow_allocation_count;) // If 0, the thread is allowed to allocate oops.
+ debug_only(int _allow_allocation_count;) // If 0, the thread is allowed to allocate oops.
// Used by SkipGCALot class.
NOT_PRODUCT(bool _skip_gcalot;) // Should we elide gc-a-lot?
@@ -593,12 +593,12 @@
bool is_inside_jvmti_env_iteration() { return _jvmti_env_iteration_count > 0; }
// Code generation
- static ByteSize exception_file_offset() { return byte_offset_of(Thread, _exception_file ); }
- static ByteSize exception_line_offset() { return byte_offset_of(Thread, _exception_line ); }
- static ByteSize active_handles_offset() { return byte_offset_of(Thread, _active_handles ); }
+ static ByteSize exception_file_offset() { return byte_offset_of(Thread, _exception_file); }
+ static ByteSize exception_line_offset() { return byte_offset_of(Thread, _exception_line); }
+ static ByteSize active_handles_offset() { return byte_offset_of(Thread, _active_handles); }
- static ByteSize stack_base_offset() { return byte_offset_of(Thread, _stack_base ); }
- static ByteSize stack_size_offset() { return byte_offset_of(Thread, _stack_size ); }
+ static ByteSize stack_base_offset() { return byte_offset_of(Thread, _stack_base); }
+ static ByteSize stack_size_offset() { return byte_offset_of(Thread, _stack_size); }
#define TLAB_FIELD_OFFSET(name) \
static ByteSize tlab_##name##_offset() { return byte_offset_of(Thread, _tlab) + ThreadLocalAllocBuffer::name##_offset(); }
@@ -615,35 +615,35 @@
#undef TLAB_FIELD_OFFSET
- static ByteSize allocated_bytes_offset() { return byte_offset_of(Thread, _allocated_bytes ); }
+ static ByteSize allocated_bytes_offset() { return byte_offset_of(Thread, _allocated_bytes); }
public:
- volatile intptr_t _Stalled ;
- volatile int _TypeTag ;
- ParkEvent * _ParkEvent ; // for synchronized()
- ParkEvent * _SleepEvent ; // for Thread.sleep
- ParkEvent * _MutexEvent ; // for native internal Mutex/Monitor
- ParkEvent * _MuxEvent ; // for low-level muxAcquire-muxRelease
- int NativeSyncRecursion ; // diagnostic
+ volatile intptr_t _Stalled;
+ volatile int _TypeTag;
+ ParkEvent * _ParkEvent; // for synchronized()
+ ParkEvent * _SleepEvent; // for Thread.sleep
+ ParkEvent * _MutexEvent; // for native internal Mutex/Monitor
+ ParkEvent * _MuxEvent; // for low-level muxAcquire-muxRelease
+ int NativeSyncRecursion; // diagnostic
- volatile int _OnTrap ; // Resume-at IP delta
- jint _hashStateW ; // Marsaglia Shift-XOR thread-local RNG
- jint _hashStateX ; // thread-specific hashCode generator state
- jint _hashStateY ;
- jint _hashStateZ ;
- void * _schedctl ;
+ volatile int _OnTrap; // Resume-at IP delta
+ jint _hashStateW; // Marsaglia Shift-XOR thread-local RNG
+ jint _hashStateX; // thread-specific hashCode generator state
+ jint _hashStateY;
+ jint _hashStateZ;
+ void * _schedctl;
- volatile jint rng [4] ; // RNG for spin loop
+ volatile jint rng[4]; // RNG for spin loop
// Low-level leaf-lock primitives used to implement synchronization
// and native monitor-mutex infrastructure.
// Not for general synchronization use.
- static void SpinAcquire (volatile int * Lock, const char * Name) ;
- static void SpinRelease (volatile int * Lock) ;
- static void muxAcquire (volatile intptr_t * Lock, const char * Name) ;
- static void muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) ;
- static void muxRelease (volatile intptr_t * Lock) ;
+ static void SpinAcquire(volatile int * Lock, const char * Name);
+ static void SpinRelease(volatile int * Lock);
+ static void muxAcquire(volatile intptr_t * Lock, const char * Name);
+ static void muxAcquireW(volatile intptr_t * Lock, ParkEvent * ev);
+ static void muxRelease(volatile intptr_t * Lock);
};
// Inline implementation of Thread::current()
@@ -933,7 +933,7 @@
intptr_t _instruction;
const char* _file;
int _line;
- } _jmp_ring[ jump_ring_buffer_size ];
+ } _jmp_ring[jump_ring_buffer_size];
#endif /* PRODUCT */
#if INCLUDE_ALL_GCS
@@ -1336,34 +1336,34 @@
#endif /* PRODUCT */
// For assembly stub generation
- static ByteSize threadObj_offset() { return byte_offset_of(JavaThread, _threadObj ); }
+ static ByteSize threadObj_offset() { return byte_offset_of(JavaThread, _threadObj); }
#ifndef PRODUCT
- static ByteSize jmp_ring_index_offset() { return byte_offset_of(JavaThread, _jmp_ring_index ); }
- static ByteSize jmp_ring_offset() { return byte_offset_of(JavaThread, _jmp_ring ); }
+ static ByteSize jmp_ring_index_offset() { return byte_offset_of(JavaThread, _jmp_ring_index); }
+ static ByteSize jmp_ring_offset() { return byte_offset_of(JavaThread, _jmp_ring); }
#endif /* PRODUCT */
- static ByteSize jni_environment_offset() { return byte_offset_of(JavaThread, _jni_environment ); }
- static ByteSize last_Java_sp_offset() {
+ static ByteSize jni_environment_offset() { return byte_offset_of(JavaThread, _jni_environment); }
+ static ByteSize last_Java_sp_offset() {
return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_sp_offset();
}
- static ByteSize last_Java_pc_offset() {
+ static ByteSize last_Java_pc_offset() {
return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_pc_offset();
}
- static ByteSize frame_anchor_offset() {
+ static ByteSize frame_anchor_offset() {
return byte_offset_of(JavaThread, _anchor);
}
- static ByteSize callee_target_offset() { return byte_offset_of(JavaThread, _callee_target ); }
- static ByteSize vm_result_offset() { return byte_offset_of(JavaThread, _vm_result ); }
- static ByteSize vm_result_2_offset() { return byte_offset_of(JavaThread, _vm_result_2 ); }
- static ByteSize thread_state_offset() { return byte_offset_of(JavaThread, _thread_state ); }
- static ByteSize saved_exception_pc_offset() { return byte_offset_of(JavaThread, _saved_exception_pc ); }
- static ByteSize osthread_offset() { return byte_offset_of(JavaThread, _osthread ); }
- static ByteSize exception_oop_offset() { return byte_offset_of(JavaThread, _exception_oop ); }
- static ByteSize exception_pc_offset() { return byte_offset_of(JavaThread, _exception_pc ); }
+ static ByteSize callee_target_offset() { return byte_offset_of(JavaThread, _callee_target); }
+ static ByteSize vm_result_offset() { return byte_offset_of(JavaThread, _vm_result); }
+ static ByteSize vm_result_2_offset() { return byte_offset_of(JavaThread, _vm_result_2); }
+ static ByteSize thread_state_offset() { return byte_offset_of(JavaThread, _thread_state); }
+ static ByteSize saved_exception_pc_offset() { return byte_offset_of(JavaThread, _saved_exception_pc); }
+ static ByteSize osthread_offset() { return byte_offset_of(JavaThread, _osthread); }
+ static ByteSize exception_oop_offset() { return byte_offset_of(JavaThread, _exception_oop); }
+ static ByteSize exception_pc_offset() { return byte_offset_of(JavaThread, _exception_pc); }
static ByteSize exception_handler_pc_offset() { return byte_offset_of(JavaThread, _exception_handler_pc); }
static ByteSize stack_overflow_limit_offset() { return byte_offset_of(JavaThread, _stack_overflow_limit); }
static ByteSize is_method_handle_return_offset() { return byte_offset_of(JavaThread, _is_method_handle_return); }
- static ByteSize stack_guard_state_offset() { return byte_offset_of(JavaThread, _stack_guard_state ); }
- static ByteSize suspend_flags_offset() { return byte_offset_of(JavaThread, _suspend_flags ); }
+ static ByteSize stack_guard_state_offset() { return byte_offset_of(JavaThread, _stack_guard_state); }
+ static ByteSize suspend_flags_offset() { return byte_offset_of(JavaThread, _suspend_flags); }
static ByteSize do_not_unlock_if_synchronized_offset() { return byte_offset_of(JavaThread, _do_not_unlock_if_synchronized); }
static ByteSize should_post_on_exceptions_flag_offset() {
@@ -1422,7 +1422,7 @@
void remove_monitor_chunk(MonitorChunk* chunk);
bool in_deopt_handler() const { return _in_deopt_handler > 0; }
void inc_in_deopt_handler() { _in_deopt_handler++; }
- void dec_in_deopt_handler() {
+ void dec_in_deopt_handler() {
assert(_in_deopt_handler > 0, "mismatched deopt nesting");
if (_in_deopt_handler > 0) { // robustness
_in_deopt_handler--;
@@ -1776,7 +1776,7 @@
uint _claimed_par_id;
public:
uint get_claimed_par_id() { return _claimed_par_id; }
- void set_claimed_par_id(uint id) { _claimed_par_id = id;}
+ void set_claimed_par_id(uint id) { _claimed_par_id = id; }
};
// Inline implementation of JavaThread::current
@@ -1811,7 +1811,7 @@
inline size_t JavaThread::stack_available(address cur_sp) {
// This code assumes java stacks grow down
address low_addr; // Limit on the address for deepest stack depth
- if ( _stack_guard_state == stack_guard_unused) {
+ if (_stack_guard_state == stack_guard_unused) {
low_addr = stack_base() - stack_size();
} else {
low_addr = stack_yellow_zone_base();