graal-compiler: src/os/linux/vm/os

comparison src/os/linux/vm/os_linux.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	897b7d18bebc 65906dc96aa1
children	e522a00b91aa

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 //
 // Important note: if the location of libjvm.so changes this
 // code needs to be changed accordingly.
 // The next few definitions allow the code to be verbatim:
-#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))
+#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal)
 #define getenv(n) ::getenv(n)
 /*
 * See ld(1):
 *      The linker uses the following search paths to locate required
 # define _CS_GNU_LIBPTHREAD_VERSION 3
 # endif
 size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0);
 if (n > 0) {
-char *str = (char *)malloc(n);
+char *str = (char *)malloc(n, mtInternal);
 confstr(_CS_GNU_LIBC_VERSION, str, n);
 os::Linux::set_glibc_version(str);
 } else {
 // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()
 static char _gnu_libc_version[32];
 os::Linux::set_glibc_version(_gnu_libc_version);
 }
 n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
 if (n > 0) {
-char *str = (char *)malloc(n);
+char *str = (char *)malloc(n, mtInternal);
 confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n);
 // Vanilla RH-9 (glibc 2.3.2) has a bug that confstr() always tells
 // us "NPTL-0.29" even we are running with LinuxThreads. Check if this
 // is the case. LinuxThreads has a hard limit on max number of threads.
 // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.
 }
 }
 // release the storage
 for (int i = 0 ; i < n ; i++) {
 if (pelements[i] != NULL) {
-FREE_C_HEAP_ARRAY(char, pelements[i]);
+FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
 }
 }
 if (pelements != NULL) {
-FREE_C_HEAP_ARRAY(char*, pelements);
+FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);
 }
 } else {
 snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
 }
 }
 if (!_print_ascii_file(fname, st)) {
 st->print("Can not get library information for pid = %d\n", pid);
 }
 }
+void os::print_os_info_brief(outputStream* st) {
+os::Linux::print_distro_info(st);
+os::Posix::print_uname_info(st);
+os::Linux::print_libversion_info(st);
+}
 void os::print_os_info(outputStream* st) {
 st->print("OS:");
-// Try to identify popular distros.
+os::Linux::print_distro_info(st);
-// Most Linux distributions have /etc/XXX-release file, which contains
-// the OS version string. Some have more than one /etc/XXX-release file
+os::Posix::print_uname_info(st);
-// (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.),
-// so the order is important.
+// Print warning if unsafe chroot environment detected
+if (unsafe_chroot_detected) {
+st->print("WARNING!! ");
+st->print_cr(unstable_chroot_error);
+}
+os::Linux::print_libversion_info(st);
+os::Posix::print_rlimit_info(st);
+os::Posix::print_load_average(st);
+os::Linux::print_full_memory_info(st);
+}
+// Try to identify popular distros.
+// Most Linux distributions have /etc/XXX-release file, which contains
+// the OS version string. Some have more than one /etc/XXX-release file
+// (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.),
+// so the order is important.
+void os::Linux::print_distro_info(outputStream* st) {
 if (!_print_ascii_file("/etc/mandrake-release", st) &&
 !_print_ascii_file("/etc/sun-release", st) &&
 !_print_ascii_file("/etc/redhat-release", st) &&
 !_print_ascii_file("/etc/SuSE-release", st) &&
 !_print_ascii_file("/etc/turbolinux-release", st) &&
 !_print_ascii_file("/etc/ltib-release", st) &&
 !_print_ascii_file("/etc/angstrom-version", st)) {
 st->print("Linux");
 }
 st->cr();
+}
-// kernel
-st->print("uname:");
+void os::Linux::print_libversion_info(outputStream* st) {
-struct utsname name;
-uname(&name);
-st->print(name.sysname); st->print(" ");
-st->print(name.release); st->print(" ");
-st->print(name.version); st->print(" ");
-st->print(name.machine);
-st->cr();
-// Print warning if unsafe chroot environment detected
-if (unsafe_chroot_detected) {
-st->print("WARNING!! ");
-st->print_cr(unstable_chroot_error);
-}
 // libc, pthread
 st->print("libc:");
 st->print(os::Linux::glibc_version()); st->print(" ");
 st->print(os::Linux::libpthread_version()); st->print(" ");
 if (os::Linux::is_LinuxThreads()) {
 st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed");
 }
 st->cr();
+}
-// rlimit
-st->print("rlimit:");
+void os::Linux::print_full_memory_info(outputStream* st) {
-struct rlimit rlim;
+st->print("\n/proc/meminfo:\n");
+_print_ascii_file("/proc/meminfo", st);
-st->print(" STACK ");
+st->cr();
-getrlimit(RLIMIT_STACK, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%uk", rlim.rlim_cur >> 10);
-st->print(", CORE ");
-getrlimit(RLIMIT_CORE, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%uk", rlim.rlim_cur >> 10);
-st->print(", NPROC ");
-getrlimit(RLIMIT_NPROC, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%d", rlim.rlim_cur);
-st->print(", NOFILE ");
-getrlimit(RLIMIT_NOFILE, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%d", rlim.rlim_cur);
-st->print(", AS ");
-getrlimit(RLIMIT_AS, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%uk", rlim.rlim_cur >> 10);
-st->cr();
-// load average
-st->print("load average:");
-double loadavg[3];
-os::loadavg(loadavg, 3);
-st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
-st->cr();
-// meminfo
-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:");
 os::available_memory() >> 10);
 st->print(", swap " UINT64_FORMAT "k",
 ((jlong)si.totalswap * si.mem_unit) >> 10);
 st->print("(" UINT64_FORMAT "k free)",
 ((jlong)si.freeswap * si.mem_unit) >> 10);
+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();
 }
 // Taken from /usr/include/bits/siginfo.h  Supposed to be architecture specific
 // but they're the same for all the linux arch that we support
 // NOTE: Linux kernel does not really reserve the pages for us.
 //       All it does is to check if there are enough free pages
 //       left at the time of mmap(). This could be a potential
 //       problem.
-bool os::commit_memory(char* addr, size_t size, bool exec) {
+bool os::pd_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);
 if (res != (uintptr_t) MAP_FAILED) {
 if (UseNUMAInterleaving) {
 // Define MADV_HUGEPAGE here so we can build HotSpot on old systems.
 #ifndef MADV_HUGEPAGE
 #define MADV_HUGEPAGE 14
 #endif
-bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
+bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
 bool exec) {
 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) {
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 uintptr_t res =
 (uintptr_t) ::mmap(addr, size, prot,
 return true;
 }
 return false;
 }
-void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
+void os::pd_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
 // be supported or the memory may already be backed by huge pages.
 ::madvise(addr, bytes, MADV_HUGEPAGE);
 }
 }
-void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {
+void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
-commit_memory(addr, bytes, alignment_hint, false);
+// This method works by doing an mmap over an existing mmaping and effectively discarding
+// the existing pages. However it won't work for SHM-based large pages that cannot be
+// uncommitted at all. We don't do anything in this case to avoid creating a segment with
+// small pages on top of the SHM segment. This method always works for small pages, so we
+// allow that in any case.
+if (alignment_hint <= (size_t)os::vm_page_size() || !UseSHM) {
+commit_memory(addr, bytes, alignment_hint, false);
+}
 }
 void os::numa_make_global(char *addr, size_t bytes) {
 Linux::numa_interleave_memory(addr, bytes);
 }
 if (numa_available() != -1) {
 set_numa_all_nodes((unsigned long*)libnuma_dlsym(handle, "numa_all_nodes"));
 // Create a cpu -> node mapping
-_cpu_to_node = new (ResourceObj::C_HEAP) GrowableArray<int>(0, true);
+_cpu_to_node = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<int>(0, true);
 rebuild_cpu_to_node_map();
 return true;
 }
 }
 }
 cpu_to_node()->clear();
 cpu_to_node()->at_grow(cpu_num - 1);
 size_t node_num = numa_get_groups_num();
-unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size);
+unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size, mtInternal);
 for (size_t i = 0; i < node_num; i++) {
 if (numa_node_to_cpus(i, cpu_map, cpu_map_size * sizeof(unsigned long)) != -1) {
 for (size_t j = 0; j < cpu_map_valid_size; j++) {
 if (cpu_map[j] != 0) {
 for (size_t k = 0; k < BitsPerCLong; k++) {
 }
 }
 }
 }
 }
-FREE_C_HEAP_ARRAY(unsigned long, cpu_map);
+FREE_C_HEAP_ARRAY(unsigned long, cpu_map, mtInternal);
 }
 int os::Linux::get_node_by_cpu(int cpu_id) {
 if (cpu_to_node() != NULL && cpu_id >= 0 && cpu_id < cpu_to_node()->length()) {
 return cpu_to_node()->at(cpu_id);
 os::Linux::numa_available_func_t os::Linux::_numa_available;
 os::Linux::numa_tonode_memory_func_t os::Linux::_numa_tonode_memory;
 os::Linux::numa_interleave_memory_func_t os::Linux::_numa_interleave_memory;
 unsigned long* os::Linux::_numa_all_nodes;
-bool os::uncommit_memory(char* addr, size_t size) {
+bool os::pd_uncommit_memory(char* addr, size_t size) {
 uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE,
 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0);
 return res  != (uintptr_t) MAP_FAILED;
 }
 // where we're going to put our guard pages, truncate the mapping at
 // that point by munmap()ping it.  This ensures that when we later
 // munmap() the guard pages we don't leave a hole in the stack
 // mapping. This only affects the main/initial thread, but guard
 // against future OS changes
-bool os::create_stack_guard_pages(char* addr, size_t size) {
+bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
 uintptr_t stack_extent, stack_base;
 bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
 if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {
 assert(os::Linux::is_initial_thread(),
 "growable stack in non-initial thread");
 //
 static int anon_munmap(char * addr, size_t size) {
 return ::munmap(addr, size) == 0;
 }
-char* os::reserve_memory(size_t bytes, char* requested_addr,
+char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
 size_t alignment_hint) {
 return anon_mmap(requested_addr, bytes, (requested_addr != NULL));
 }
-bool os::release_memory(char* addr, size_t size) {
+bool os::pd_release_memory(char* addr, size_t size) {
 return anon_munmap(addr, size);
 }
 static address highest_vm_reserved_address() {
 return _highest_vm_reserved_address;
 }
 // Reserve memory at an arbitrary address, only if that area is
 // available (and not reserved for something else).
-char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
+char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
 const int max_tries = 10;
 char* base[max_tries];
 size_t size[max_tries];
 const size_t gap = 0x000000;
 // is expected to return 0 on failure and 1 on success to the jdk.
 return (ret < 0) ? 0 : 1;
 }
 // Map a block of memory.
-char* os::map_memory(int fd, const char* file_name, size_t file_offset,
+char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 int prot;
-int flags;
+int flags = MAP_PRIVATE;
 if (read_only) {
 prot = PROT_READ;
-flags = MAP_SHARED;
 } else {
 prot = PROT_READ | PROT_WRITE;
-flags = MAP_PRIVATE;
 }
 if (allow_exec) {
 prot |= PROT_EXEC;
 }
 return mapped_address;
 }
 // Remap a block of memory.
-char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
+char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 // same as map_memory() on this OS
 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
 allow_exec);
 }
 // Unmap a block of memory.
-bool os::unmap_memory(char* addr, size_t bytes) {
+bool os::pd_unmap_memory(char* addr, size_t bytes) {
 return munmap(addr, bytes) == 0;
 }
 static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time);
 if (::stat(libmawtpath, &statbuf) == 0) return false;
 return true;
 }
+// Get the default path to the core file
+// Returns the length of the string
+int os::get_core_path(char* buffer, size_t bufferSize) {
+const char* p = get_current_directory(buffer, bufferSize);
+if (p == NULL) {
+assert(p != NULL, "failed to get current directory");
+return 0;
+}
+return strlen(buffer);
+}
 #ifdef JAVASE_EMBEDDED
 //
 // A thread to watch the '/dev/mem_notify' device, which will tell us when the OS is running low on memory.
 //

Mercurial > hg > graal-compiler

comparison src/os/linux/vm/os_linux.cpp @ 6275:957c266d8bc5