truffle: src/os/bsd/vm/os_bsd.cpp comparison

comparison src/os/bsd/vm/os_bsd.cpp @ 8883:b9a918201d47

Merge with hsx25

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Sat, 06 Apr 2013 20:04:06 +0200
parents	b8f261ba79c6 754c24457b20
children	89e4d67fdd2a

comparison

equal deleted inserted replaced

-:d47b52b0ff68
+:b9a918201d47
 #include "runtime/stubRoutines.hpp"
 #include "runtime/thread.inline.hpp"
 #include "runtime/threadCritical.hpp"
 #include "runtime/timer.hpp"
 #include "services/attachListener.hpp"
+#include "services/memTracker.hpp"
 #include "services/runtimeService.hpp"
 #include "utilities/decoder.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/events.hpp"
 #include "utilities/growableArray.hpp"
 return physical_memory() >> 2;
 }
 julong os::physical_memory() {
 return Bsd::physical_memory();
-}
-julong os::allocatable_physical_memory(julong size) {
-#ifdef _LP64
-return size;
-#else
-julong result = MIN2(size, (julong)3800*M);
-if (!is_allocatable(result)) {
-// See comments under solaris for alignment considerations
-julong reasonable_size = (julong)2*G - 2 * os::vm_page_size();
-result =  MIN2(size, reasonable_size);
-}
-return result;
-#endif // _LP64
 }
 ////////////////////////////////////////////////////////////////////////////////
 // environment support
 warning(msg);
 }
 return NULL;
 }
+// The memory is committed
+address pc = CALLER_PC;
+MemTracker::record_virtual_memory_reserve((address)addr, bytes, pc);
+MemTracker::record_virtual_memory_commit((address)addr, bytes, pc);
 return addr;
 }
 bool os::release_memory_special(char* base, size_t bytes) {
 // detaching the SHM segment will also delete it, see reserve_memory_special()
 int rslt = shmdt(base);
-return rslt == 0;
+if (rslt == 0) {
+MemTracker::record_virtual_memory_uncommit((address)base, bytes);
+MemTracker::record_virtual_memory_release((address)base, bytes);
+return true;
+} else {
+return false;
+}
 }
 size_t os::large_page_size() {
 return _large_page_size;
 }
 Thread* thread = Thread::current();
 OSThread* osthread = thread->osthread();
 assert(thread->is_VM_thread(), "Must be VMThread");
 // read current suspend action
 int action = osthread->sr.suspend_action();
-if (action == SR_SUSPEND) {
+if (action == os::Bsd::SuspendResume::SR_SUSPEND) {
 suspend_save_context(osthread, siginfo, context);
 // Notify the suspend action is about to be completed. do_suspend()
 // waits until SR_SUSPENDED is set and then returns. We will wait
 // here for a resume signal and that completes the suspend-other
 // wait here until we are resumed
 do {
 sigsuspend(&suspend_set);
 // ignore all returns until we get a resume signal
-} while (osthread->sr.suspend_action() != SR_CONTINUE);
+} while (osthread->sr.suspend_action() != os::Bsd::SuspendResume::SR_CONTINUE);
 resume_clear_context(osthread);
 } else {
-assert(action == SR_CONTINUE, "unexpected sr action");
+assert(action == os::Bsd::SuspendResume::SR_CONTINUE, "unexpected sr action");
 // nothing special to do - just leave the handler
 }
 errno = old_errno;
 }
 // returns true on success and false on error - really an error is fatal
 // but this seems the normal response to library errors
 static bool do_suspend(OSThread* osthread) {
 // mark as suspended and send signal
-osthread->sr.set_suspend_action(SR_SUSPEND);
+osthread->sr.set_suspend_action(os::Bsd::SuspendResume::SR_SUSPEND);
 int status = pthread_kill(osthread->pthread_id(), SR_signum);
 assert_status(status == 0, status, "pthread_kill");
 // check status and wait until notified of suspension
 if (status == 0) {
 for (int i = 0; !osthread->sr.is_suspended(); i++) {
 os::yield_all(i);
 }
-osthread->sr.set_suspend_action(SR_NONE);
+osthread->sr.set_suspend_action(os::Bsd::SuspendResume::SR_NONE);
 return true;
 }
 else {
-osthread->sr.set_suspend_action(SR_NONE);
+osthread->sr.set_suspend_action(os::Bsd::SuspendResume::SR_NONE);
 return false;
 }
 }
 static void do_resume(OSThread* osthread) {
 assert(osthread->sr.is_suspended(), "thread should be suspended");
-osthread->sr.set_suspend_action(SR_CONTINUE);
+osthread->sr.set_suspend_action(os::Bsd::SuspendResume::SR_CONTINUE);
 int status = pthread_kill(osthread->pthread_id(), SR_signum);
 assert_status(status == 0, status, "pthread_kill");
 // check status and wait unit notified of resumption
 if (status == 0) {
 for (int i = 0; osthread->sr.is_suspended(); i++) {
 os::yield_all(i);
 }
 }
-osthread->sr.set_suspend_action(SR_NONE);
+osthread->sr.set_suspend_action(os::Bsd::SuspendResume::SR_NONE);
 }
 ////////////////////////////////////////////////////////////////////////////////
 // interrupt support
 // the fast estimate available on the platform.
 jlong os::current_thread_cpu_time() {
 #ifdef __APPLE__
 return os::thread_cpu_time(Thread::current(), true /* user + sys */);
+#else
+Unimplemented();
+return 0;
 #endif
 }
 jlong os::thread_cpu_time(Thread* thread) {
+#ifdef __APPLE__
+return os::thread_cpu_time(thread, true /* user + sys */);
+#else
+Unimplemented();
+return 0;
+#endif
 }
 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
 #ifdef __APPLE__
 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
+#else
+Unimplemented();
+return 0;
 #endif
 }
 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
 #ifdef __APPLE__
 nanos += ((jlong) tinfo.system_time.microseconds + (jlong) tinfo.user_time.microseconds) * (jlong)1000;
 return nanos;
 } else {
 return ((jlong)tinfo.user_time.seconds * 1000000000) + ((jlong)tinfo.user_time.microseconds * (jlong)1000);
 }
+#else
+Unimplemented();
+return 0;
 #endif
 }
 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {

Mercurial > hg > truffle

comparison src/os/bsd/vm/os_bsd.cpp @ 8883:b9a918201d47