graal-jvmci-8: src/os/linux/vm/os

comparison src/os/linux/vm/os_linux.cpp @ 17810:62c54fcc0a35

Merge

author	kvn
date	Tue, 25 Mar 2014 17:07:36 -0700
parents	bbfbe9b06038 91dc38ae09f3
children	56e7f5560e60

comparison

equal deleted inserted replaced

-:a433eb716ce1
+:62c54fcc0a35
 /*
-* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #ifndef RUSAGE_THREAD
 #define RUSAGE_THREAD   (1)               /* only the calling thread */
 #endif
 #define MAX_PATH    (2 * K)
+#define MAX_SECS 100000000
 // for timer info max values which include all bits
 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
 #define LARGEPAGES_BIT (1 << 6)
 bool timedwait(unsigned int sec, int nsec);
 private:
 sem_t _semaphore;
 };
 Semaphore::Semaphore() {
 sem_init(&_semaphore, 0, 0);
 }
 Semaphore::~Semaphore() {
 bool Semaphore::trywait() {
 return sem_trywait(&_semaphore) == 0;
 }
 bool Semaphore::timedwait(unsigned int sec, int nsec) {
 struct timespec ts;
-unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
+// Semaphore's are always associated with CLOCK_REALTIME
+os::Linux::clock_gettime(CLOCK_REALTIME, &ts);
+// see unpackTime for discussion on overflow checking
+if (sec >= MAX_SECS) {
+ts.tv_sec += MAX_SECS;
+ts.tv_nsec = 0;
+} else {
+ts.tv_sec += sec;
+ts.tv_nsec += nsec;
+if (ts.tv_nsec >= NANOSECS_PER_SEC) {
+ts.tv_nsec -= NANOSECS_PER_SEC;
+++ts.tv_sec; // note: this must be <= max_secs
+}
+}
 while (1) {
 int result = sem_timedwait(&_semaphore, &ts);
 if (result == 0) {
 return true;
 size_t page_sz = os::vm_page_size();
 unsigned pages = size / page_sz;
 unsigned char vec[1];
 unsigned imin = 1, imax = pages + 1, imid;
-int mincore_return_value;
+int mincore_return_value = 0;
+assert(imin <= imax, "Unexpected page size");
 while (imin < imax) {
 imid = (imax + imin) / 2;
 nbot = ntop - (imid * page_sz);
 }
 return OS_OK ;
 }
 }
-int os::naked_sleep() {
+//
-// %% make the sleep time an integer flag. for now use 1 millisec.
+// Short sleep, direct OS call.
-return os::sleep(Thread::current(), 1, false);
+//
+// Note: certain versions of Linux CFS scheduler (since 2.6.23) do not guarantee
+// sched_yield(2) will actually give up the CPU:
+//
+//   * Alone on this pariticular CPU, keeps running.
+//   * Before the introduction of "skip_buddy" with "compat_yield" disabled
+//     (pre 2.6.39).
+//
+// So calling this with 0 is an alternative.
+//
+void os::naked_short_sleep(jlong ms) {
+struct timespec req;
+assert(ms < 1000, "Un-interruptable sleep, short time use only");
+req.tv_sec = 0;
+if (ms > 0) {
+req.tv_nsec = (ms % 1000) * 1000000;
+}
+else {
+req.tv_nsec = 1;
+}
+nanosleep(&req, NULL);
+return;
 }
 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
 void os::infinite_sleep() {
 while (true) {    // sleep forever ...
 * on the condvar. Contention seen when trying to park implies that someone
 * is unparking you, so don't wait. And spurious returns are fine, so there
 * is no need to track notifications.
 */
-#define MAX_SECS 100000000
 /*
 * This code is common to linux and solaris and will be moved to a
 * common place in dolphin.
 *
 * The passed in time value is either a relative time in nanoseconds

Mercurial > hg > graal-jvmci-8

comparison src/os/linux/vm/os_linux.cpp @ 17810:62c54fcc0a35