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

comparison src/os/linux/vm/os_linux.cpp @ 3464:be4ca325525a

Merge.

author	Thomas Wuerthinger <thomas@wuerthinger.net>
date	Wed, 27 Jul 2011 17:32:44 -0700
parents	0654ee04b214 97b64f73103b
children	04b9a2566eec

comparison

equal deleted inserted replaced

-:7c4b4daac19b
+:be4ca325525a
 uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,
 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
 return res != (uintptr_t) MAP_FAILED;
 }
+// Define MAP_HUGETLB here so we can build HotSpot on old systems.
+#ifndef MAP_HUGETLB
+#define MAP_HUGETLB 0x40000
+#endif
+// 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 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,
+MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS|MAP_HUGETLB,
+-1, 0);
+return res != (uintptr_t) MAP_FAILED;
+}
 return commit_memory(addr, size, exec);
 }
-void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
+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
+// 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) {
-::mmap(addr, bytes, PROT_READ | PROT_WRITE,
+::madvise(addr, bytes, MADV_DONTNEED);
-MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
 }
 void os::numa_make_global(char *addr, size_t bytes) {
 Linux::numa_interleave_memory(addr, bytes);
 }
 return linux_mprotect(addr, size, PROT_NONE);
 }
 bool os::unguard_memory(char* addr, size_t size) {
 return linux_mprotect(addr, size, PROT_READ|PROT_WRITE);
+}
+bool os::Linux::hugetlbfs_sanity_check(bool warn, size_t page_size) {
+bool result = false;
+void *p = mmap (NULL, page_size, PROT_READ|PROT_WRITE,
+MAP_ANONYMOUS|MAP_PRIVATE|MAP_HUGETLB,
+-1, 0);
+if (p != (void *) -1) {
+// We don't know if this really is a huge page or not.
+FILE *fp = fopen("/proc/self/maps", "r");
+if (fp) {
+while (!feof(fp)) {
+char chars[257];
+long x = 0;
+if (fgets(chars, sizeof(chars), fp)) {
+if (sscanf(chars, "%lx-%*x", &x) == 1
+&& x == (long)p) {
+if (strstr (chars, "hugepage")) {
+result = true;
+break;
+}
+}
+}
+}
+fclose(fp);
+}
+munmap (p, page_size);
+if (result)
+return true;
+}
+if (warn) {
+warning("HugeTLBFS is not supported by the operating system.");
+}
+return result;
 }
 /*
 * Set the coredump_filter bits to include largepages in core dump (bit 6)
 *
 // Large page support
 static size_t _large_page_size = 0;
-bool os::large_page_init() {
+void os::large_page_init() {
-if (!UseLargePages) return false;
+if (!UseLargePages) {
+UseHugeTLBFS = false;
+UseSHM = false;
+return;
+}
+if (FLAG_IS_DEFAULT(UseHugeTLBFS) && FLAG_IS_DEFAULT(UseSHM)) {
+// If UseLargePages is specified on the command line try both methods,
+// if it's default, then try only HugeTLBFS.
+if (FLAG_IS_DEFAULT(UseLargePages)) {
+UseHugeTLBFS = true;
+} else {
+UseHugeTLBFS = UseSHM = true;
+}
+}
 if (LargePageSizeInBytes) {
 _large_page_size = LargePageSizeInBytes;
 } else {
 // large_page_size on Linux is used to round up heap size. x86 uses either
 }
 fclose(fp);
 }
 }
+// print a warning if any large page related flag is specified on command line
+bool warn_on_failure = !FLAG_IS_DEFAULT(UseHugeTLBFS);
 const size_t default_page_size = (size_t)Linux::page_size();
 if (_large_page_size > default_page_size) {
 _page_sizes[0] = _large_page_size;
 _page_sizes[1] = default_page_size;
 _page_sizes[2] = 0;
 }
+UseHugeTLBFS = UseHugeTLBFS &&
+Linux::hugetlbfs_sanity_check(warn_on_failure, _large_page_size);
+if (UseHugeTLBFS)
+UseSHM = false;
+UseLargePages = UseHugeTLBFS || UseSHM;
 set_coredump_filter();
-// Large page support is available on 2.6 or newer kernel, some vendors
-// (e.g. Redhat) have backported it to their 2.4 based distributions.
-// We optimistically assume the support is available. If later it turns out
-// not true, VM will automatically switch to use regular page size.
-return true;
 }
 #ifndef SHM_HUGETLB
 #define SHM_HUGETLB 04000
 #endif
 char* os::reserve_memory_special(size_t bytes, char* req_addr, bool exec) {
 // "exec" is passed in but not used.  Creating the shared image for
 // the code cache doesn't have an SHM_X executable permission to check.
-assert(UseLargePages, "only for large pages");
+assert(UseLargePages && UseSHM, "only for SHM large pages");
 key_t key = IPC_PRIVATE;
 char *addr;
 bool warn_on_failure = UseLargePages &&
 size_t os::large_page_size() {
 return _large_page_size;
 }
-// Linux does not support anonymous mmap with large page memory. The only way
+// HugeTLBFS allows application to commit large page memory on demand;
-// to reserve large page memory without file backing is through SysV shared
+// with SysV SHM the entire memory region must be allocated as shared
-// memory API. The entire memory region is committed and pinned upfront.
+// memory.
-// Hopefully this will change in the future...
 bool os::can_commit_large_page_memory() {
-return false;
+return UseHugeTLBFS;
 }
 bool os::can_execute_large_page_memory() {
-return false;
+return UseHugeTLBFS;
 }
 // Reserve memory at an arbitrary address, only if that area is
 // available (and not reserved for something else).
 if(Verbose && PrintMiscellaneous)
 tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
 #endif
 }
-FLAG_SET_DEFAULT(UseLargePages, os::large_page_init());
+os::large_page_init();
 // initialize suspend/resume support - must do this before signal_sets_init()
 if (SR_initialize() != 0) {
 perror("SR_initialize failed");
 return JNI_ERR;
 if (!Linux::libnuma_init()) {
 UseNUMA = false;
 } else {
 if ((Linux::numa_max_node() < 1)) {
 // There's only one node(they start from 0), disable NUMA.
+UseNUMA = false;
+}
+}
+// With SHM large pages we cannot uncommit a page, so there's not way
+// we can make the adaptive lgrp chunk resizing work. If the user specified
+// both UseNUMA and UseLargePages (or UseSHM) on the command line - warn and
+// disable adaptive resizing.
+if (UseNUMA && UseLargePages && UseSHM) {
+if (!FLAG_IS_DEFAULT(UseNUMA)) {
+if (FLAG_IS_DEFAULT(UseLargePages) && FLAG_IS_DEFAULT(UseSHM)) {
+UseLargePages = false;
+} else {
+warning("UseNUMA is not fully compatible with SHM large pages, disabling adaptive resizing");
+UseAdaptiveSizePolicy = false;
+UseAdaptiveNUMAChunkSizing = false;
+}
+} else {
 UseNUMA = false;
 }
 }
 if (!UseNUMA && ForceNUMA) {
 UseNUMA = true;

Mercurial > hg > graal-compiler

comparison src/os/linux/vm/os_linux.cpp @ 3464:be4ca325525a