truffle: src/os/linux/vm/os_linux.cpp comparison

comparison src/os/linux/vm/os_linux.cpp @ 4137:04b9a2566eec

Merge with hsx23/hotspot.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sat, 17 Dec 2011 21:40:27 +0100
parents	be4ca325525a 36b057451829
children	33df1aeaebbf

comparison

equal deleted inserted replaced

-:9dc19b7d89a3
+:04b9a2566eec
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */
-# define __STDC_FORMAT_MACROS
 // no precompiled headers
 #include "classfile/classLoader.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 sigset_t SR_sigset;
 /* Used to protect dlsym() calls */
 static pthread_mutex_t dl_mutex;
-////////////////////////////////////////////////////////////////////////////////
+#ifdef JAVASE_EMBEDDED
+class MemNotifyThread: public Thread {
+friend class VMStructs;
+public:
+virtual void run();
+private:
+static MemNotifyThread* _memnotify_thread;
+int _fd;
+public:
+// Constructor
+MemNotifyThread(int fd);
+// Tester
+bool is_memnotify_thread() const { return true; }
+// Printing
+char* name() const { return (char*)"Linux MemNotify Thread"; }
+// Returns the single instance of the MemNotifyThread
+static MemNotifyThread* memnotify_thread() { return _memnotify_thread; }
+// Create and start the single instance of MemNotifyThread
+static void start();
+};
+#endif // JAVASE_EMBEDDED
 // utility functions
 static int SR_initialize();
 static int SR_finalize();
 st->print("\n/proc/meminfo:\n");
 _print_ascii_file("/proc/meminfo", st);
 st->cr();
 }
+void os::pd_print_cpu_info(outputStream* st) {
+st->print("\n/proc/cpuinfo:\n");
+if (!_print_ascii_file("/proc/cpuinfo", st)) {
+st->print("  <Not Available>");
+}
+st->cr();
+}
 void os::print_memory_info(outputStream* st) {
 st->print("Memory:");
 st->print(" %dk page", os::vm_page_size()>>10);
 //       problem.
 bool os::commit_memory(char* addr, size_t size, bool exec) {
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,
 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
-return res != (uintptr_t) MAP_FAILED;
+if (res != (uintptr_t) MAP_FAILED) {
+if (UseNUMAInterleaving) {
+numa_make_global(addr, size);
+}
+return true;
+}
+return false;
 }
 // Define MAP_HUGETLB here so we can build HotSpot on old systems.
 #ifndef MAP_HUGETLB
 #define MAP_HUGETLB 0x40000
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 uintptr_t res =
 (uintptr_t) ::mmap(addr, size, prot,
 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS|MAP_HUGETLB,
 -1, 0);
-return res != (uintptr_t) MAP_FAILED;
+if (res != (uintptr_t) MAP_FAILED) {
-}
+if (UseNUMAInterleaving) {
+numa_make_global(addr, size);
-return commit_memory(addr, size, exec);
+}
+return true;
+}
+// Fall through and try to use small pages
+}
+if (commit_memory(addr, size, exec)) {
+realign_memory(addr, size, alignment_hint);
+return true;
+}
+return false;
 }
 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) {
 // We don't check the return value: madvise(MADV_HUGEPAGE) may not
 ::madvise(addr, bytes, MADV_HUGEPAGE);
 }
 }
 void os::free_memory(char *addr, size_t bytes) {
-::madvise(addr, bytes, MADV_DONTNEED);
+commit_memory(addr, bytes, false);
 }
 void os::numa_make_global(char *addr, size_t bytes) {
 Linux::numa_interleave_memory(addr, bytes);
 }
 return false;
 }
 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
 return end;
+}
+int os::Linux::sched_getcpu_syscall(void) {
+unsigned int cpu;
+int retval = -1;
+#if defined(IA32)
+# ifndef SYS_getcpu
+# define SYS_getcpu 318
+# endif
+retval = syscall(SYS_getcpu, &cpu, NULL, NULL);
+#elif defined(AMD64)
+// Unfortunately we have to bring all these macros here from vsyscall.h
+// to be able to compile on old linuxes.
+# define __NR_vgetcpu 2
+# define VSYSCALL_START (-10UL << 20)
+# define VSYSCALL_SIZE 1024
+# define VSYSCALL_ADDR(vsyscall_nr) (VSYSCALL_START+VSYSCALL_SIZE*(vsyscall_nr))
+typedef long (*vgetcpu_t)(unsigned int *cpu, unsigned int *node, unsigned long *tcache);
+vgetcpu_t vgetcpu = (vgetcpu_t)VSYSCALL_ADDR(__NR_vgetcpu);
+retval = vgetcpu(&cpu, NULL, NULL);
+#endif
+return (retval == -1) ? retval : cpu;
 }
 // Something to do with the numa-aware allocator needs these symbols
 extern "C" JNIEXPORT void numa_warn(int number, char *where, ...) { }
 extern "C" JNIEXPORT void numa_error(char *where) { }
 bool os::Linux::libnuma_init() {
 // sched_getcpu() should be in libc.
 set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t,
 dlsym(RTLD_DEFAULT, "sched_getcpu")));
+// If it's not, try a direct syscall.
+if (sched_getcpu() == -1)
+set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t, (void*)&sched_getcpu_syscall));
 if (sched_getcpu() != -1) { // Does it work?
 void *handle = dlopen("libnuma.so.1", RTLD_LAZY);
 if (handle != NULL) {
 set_numa_node_to_cpus(CAST_TO_FN_PTR(numa_node_to_cpus_func_t,
 if (warn_on_failure) {
 jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);
 warning(msg);
 }
 return NULL;
+}
+if ((addr != NULL) && UseNUMAInterleaving) {
+numa_make_global(addr, bytes);
 }
 return addr;
 }
 // Tell libjsig jvm finishes setting signal handlers
 (*end_signal_setting)();
 }
 // We don't activate signal checker if libjsig is in place, we trust ourselves
-// and if UserSignalHandler is installed all bets are off
+// and if UserSignalHandler is installed all bets are off.
+// Log that signal checking is off only if -verbose:jni is specified.
 if (CheckJNICalls) {
 if (libjsig_is_loaded) {
-tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
+if (PrintJNIResolving) {
+tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
+}
 check_signals = false;
 }
 if (AllowUserSignalHandlers) {
-tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
+if (PrintJNIResolving) {
+tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
+}
 check_signals = false;
 }
 }
 }
 }
 return JNI_OK;
 }
 // this is called at the end of vm_initialization
-void os::init_3(void) { }
+void os::init_3(void)
+{
+#ifdef JAVASE_EMBEDDED
+// Start the MemNotifyThread
+if (LowMemoryProtection) {
+MemNotifyThread::start();
+}
+return;
+#endif
+}
 // Mark the polling page as unreadable
 void os::make_polling_page_unreadable(void) {
 if( !guard_memory((char*)_polling_page, Linux::page_size()) )
 fatal("Could not disable polling page");
 // Linux doesn't yet have a (official) notion of processor sets,
 // so just return the number of online processors.
 int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
 assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
 return online_cpus;
+}
+void os::set_native_thread_name(const char *name) {
+// Not yet implemented.
+return;
 }
 bool os::distribute_processes(uint length, uint* distribution) {
 // Not yet implemented.
 return false;
 }
 }
 // is_headless_jre()
 //
-// Test for the existence of libmawt in motif21 or xawt directories
+// Test for the existence of xawt/libmawt.so or libawt_xawt.so
 // in order to report if we are running in a headless jre
+//
+// Since JDK8 xawt/libmawt.so was moved into the same directory
+// as libawt.so, and renamed libawt_xawt.so
 //
 bool os::is_headless_jre() {
 struct stat statbuf;
 char buf[MAXPATHLEN];
 char libmawtpath[MAXPATHLEN];
 const char *xawtstr  = "/xawt/libmawt.so";
-const char *motifstr = "/motif21/libmawt.so";
+const char *new_xawtstr = "/libawt_xawt.so";
 char *p;
 // Get path to libjvm.so
 os::jvm_path(buf, sizeof(buf));
 // check xawt/libmawt.so
 strcpy(libmawtpath, buf);
 strcat(libmawtpath, xawtstr);
 if (::stat(libmawtpath, &statbuf) == 0) return false;
-// check motif21/libmawt.so
+// check libawt_xawt.so
 strcpy(libmawtpath, buf);
-strcat(libmawtpath, motifstr);
+strcat(libmawtpath, new_xawtstr);
 if (::stat(libmawtpath, &statbuf) == 0) return false;
 return true;
 }
+#ifdef JAVASE_EMBEDDED
+//
+// A thread to watch the '/dev/mem_notify' device, which will tell us when the OS is running low on memory.
+//
+MemNotifyThread* MemNotifyThread::_memnotify_thread = NULL;
+// ctor
+//
+MemNotifyThread::MemNotifyThread(int fd): Thread() {
+assert(memnotify_thread() == NULL, "we can only allocate one MemNotifyThread");
+_fd = fd;
+if (os::create_thread(this, os::os_thread)) {
+_memnotify_thread = this;
+os::set_priority(this, NearMaxPriority);
+os::start_thread(this);
+}
+}
+// Where all the work gets done
+//
+void MemNotifyThread::run() {
+assert(this == memnotify_thread(), "expected the singleton MemNotifyThread");
+// Set up the select arguments
+fd_set rfds;
+if (_fd != -1) {
+FD_ZERO(&rfds);
+FD_SET(_fd, &rfds);
+}
+// Now wait for the mem_notify device to wake up
+while (1) {
+// Wait for the mem_notify device to signal us..
+int rc = select(_fd+1, _fd != -1 ? &rfds : NULL, NULL, NULL, NULL);
+if (rc == -1) {
+perror("select!\n");
+break;
+} else if (rc) {
+//ssize_t free_before = os::available_memory();
+//tty->print ("Notified: Free: %dK \n",os::available_memory()/1024);
+// The kernel is telling us there is not much memory left...
+// try to do something about that
+// If we are not already in a GC, try one.
+if (!Universe::heap()->is_gc_active()) {
+Universe::heap()->collect(GCCause::_allocation_failure);
+//ssize_t free_after = os::available_memory();
+//tty->print ("Post-Notify: Free: %dK\n",free_after/1024);
+//tty->print ("GC freed: %dK\n", (free_after - free_before)/1024);
+}
+// We might want to do something like the following if we find the GC's are not helping...
+// Universe::heap()->size_policy()->set_gc_time_limit_exceeded(true);
+}
+}
+}
+//
+// See if the /dev/mem_notify device exists, and if so, start a thread to monitor it.
+//
+void MemNotifyThread::start() {
+int    fd;
+fd = open ("/dev/mem_notify", O_RDONLY, 0);
+if (fd < 0) {
+return;
+}
+if (memnotify_thread() == NULL) {
+new MemNotifyThread(fd);
+}
+}
+#endif // JAVASE_EMBEDDED

Mercurial > hg > truffle

comparison src/os/linux/vm/os_linux.cpp @ 4137:04b9a2566eec