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

comparison src/os/linux/vm/os_linux.cpp @ 3290:7f3faf7159fd

Merge

author	jmasa
date	Fri, 22 Apr 2011 09:26:09 -0700
parents	677234770800 139667d9836a
children	c303b3532d4a

comparison

equal deleted inserted replaced

-:732454aaf5cb
+:7f3faf7159fd
 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-%*lx", &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() {
-if (!UseLargePages) return false;
+if (!UseLargePages) {
+UseHugeTLBFS = false;
+UseSHM = false;
+return false;
+}
+if (FLAG_IS_DEFAULT(UseHugeTLBFS) && FLAG_IS_DEFAULT(UseSHM)) {
+// Our user has not expressed a preference, so we'll try both.
+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
 #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).

Mercurial > hg > graal-jvmci-8

comparison src/os/linux/vm/os_linux.cpp @ 3290:7f3faf7159fd