--- 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");
}
}