mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-25 22:04:51 +02:00
8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
Checkpoint do_space_filter.ksh cleanups for Contended Locking. Reviewed-by: sspitsyn, coleenp
This commit is contained in:
Daniel D. Daugherty
parent
57113f7d70
commit
7d153c461e
10 changed files with 1595 additions and 1595 deletions
|
|
@ -862,7 +862,7 @@ bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
|
|||
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 @@ static bool find_vma(address addr, address* vma_low, address* vma_high) {
|
|||
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 @@ void os::Linux::fast_thread_clock_init() {
|
|||
// 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 @@ bool os::dll_build_name(char* buffer, size_t buflen,
|
|||
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 @@ bool os::dll_build_name(char* buffer, size_t buflen,
|
|||
}
|
||||
}
|
||||
// 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 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
|
|||
|
||||
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 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
|
|||
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 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
|
|||
#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 @@ void os::yield() {
|
|||
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 @@ static int prio_init() {
|
|||
}
|
||||
|
||||
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 @@ bool os::Linux::chained_handler(int sig, siginfo_t* siginfo, void* context) {
|
|||
}
|
||||
|
||||
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 @@ static void print_signal_handler(outputStream* st, int sig,
|
|||
|
||||
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 @@ static void print_signal_handler(outputStream* st, int sig,
|
|||
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 @@ void os::Linux::check_signal_handler(int sig) {
|
|||
|
||||
address thisHandler = (act.sa_flags & SA_SIGINFO)
|
||||
? CAST_FROM_FN_PTR(address, act.sa_sigaction)
|
||||
: CAST_FROM_FN_PTR(address, act.sa_handler) ;
|
||||
: CAST_FROM_FN_PTR(address, act.sa_handler);
|
||||
|
||||
|
||||
switch(sig) {
|
||||
switch (sig) {
|
||||
case SIGSEGV:
|
||||
case SIGBUS:
|
||||
case SIGFPE:
|
||||
|
|
@ -4662,22 +4662,22 @@ jint os::init_2(void)
|
|||
|
||||
// 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" );
|
||||
guarantee(polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page");
|
||||
|
||||
os::set_polling_page( 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 @@ void os::init_3(void) {
|
|||
|
||||
// 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 @@ static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
|
|||
|
||||
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 @@ static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
|
|||
// 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 @@ static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
|
|||
&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 @@ static struct timespec* compute_abstime(timespec* abstime, jlong millis) {
|
|||
|
||||
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 @@ void os::PlatformEvent::park() { // AKA "down()"
|
|||
// 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 ...
|
||||
|
|
@ -5497,28 +5497,28 @@ void os::PlatformEvent::park() { // AKA "down()"
|
|||
if (status == ETIME) { status = EINTR; }
|
||||
assert_status(status == 0 || status == EINTR, status, "cond_wait");
|
||||
}
|
||||
-- _nParked ;
|
||||
--_nParked;
|
||||
|
||||
_Event = 0 ;
|
||||
_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") ;
|
||||
guarantee(_nParked == 0, "invariant");
|
||||
|
||||
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") ;
|
||||
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.
|
||||
|
|
@ -5528,8 +5528,8 @@ int os::PlatformEvent::park(jlong millis) {
|
|||
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 @@ int os::PlatformEvent::park(jlong millis) {
|
|||
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 @@ void os::PlatformEvent::unpark() {
|
|||
*/
|
||||
|
||||
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 @@ void Parker::park(bool isAbsolute, jlong time) {
|
|||
|
||||
// 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 @@ void Parker::park(bool isAbsolute, jlong time) {
|
|||
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 @@ void Parker::park(bool isAbsolute, jlong time) {
|
|||
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 @@ void Parker::park(bool isAbsolute, jlong time) {
|
|||
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::park(bool isAbsolute, jlong time) {
|
|||
}
|
||||
|
||||
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 @@ void Parker::unpark() {
|
|||
// 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");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue