WIP

Author: jsikstro

src/hotspot/os/linux/gc/z/zPhysicalMemoryBacking_linux.cpp

@@ -411,7 +411,27 @@ bool ZPhysicalMemoryBacking::tmpfs_supports_transparent_huge_pages() const {
   return access(ZFILENAME_SHMEM_ENABLED, R_OK) == 0;
 }
 
-ZErrno ZPhysicalMemoryBacking::fallocate_compat_mmap_hugetlbfs(zbacking_offset offset, size_t length, bool touch) const {
+static bool safe_touch_mapping(void* addr, size_t length, size_t page_size) {
+  char* const start = (char*)addr;
+  char* const end = start + length;
+
+  // Touching a mapping that can't be backed by memory will generate a
+  // SIGBUS. By using SafeFetch32 any SIGBUS will be safely caught and
+  // handled. On tmpfs, doing a fetch (rather than a store) is enough
+  // to cause backing pages to be allocated (there's no zero-page to
+  // worry about).
+  for (char *p = start; p < end; p += page_size) {
+    if (SafeFetch32((int*)p, -1) == -1) {
+      // Failed
+      return false;
+    }
+  }
+
+  // Success
+  return true;
+}
+
+ZErrno ZPhysicalMemoryBacking::fallocate_compat_mmap_hugetlbfs(zbacking_offset offset, size_t length) const {
   // On hugetlbfs, mapping a file segment will fail immediately, without
   // the need to touch the mapped pages first, if there aren't enough huge
   // pages available to back the mapping.
@@ -424,11 +444,9 @@ ZErrno ZPhysicalMemoryBacking::fallocate_compat_mmap_hugetlbfs(zbacking_offset o
   // Once mapped, the huge pages are only reserved. We need to touch them
   // to associate them with the file segment. Note that we can not punch
   // hole in file segments which only have reserved pages.
-  if (touch) {
-    char* const start = (char*)addr;
-    char* const end = start + length;
-    os::pretouch_memory(start, end, _block_size);
-  }
+
+  // Touch the mapping (safely) to make sure it's backed by memory
+  const bool backed = safe_touch_mapping(addr, length, _block_size);
 
   // Unmap again. From now on, the huge pages that were mapped are allocated
   // to this file. There's no risk of getting a SIGBUS when mapping and
@@ -438,28 +456,8 @@ ZErrno ZPhysicalMemoryBacking::fallocate_compat_mmap_hugetlbfs(zbacking_offset o
     return errno;
   }
 
-  // Success
-  return 0;
-}
-
-static bool safe_touch_mapping(void* addr, size_t length, size_t page_size) {
-  char* const start = (char*)addr;
-  char* const end = start + length;
-
-  // Touching a mapping that can't be backed by memory will generate a
-  // SIGBUS. By using SafeFetch32 any SIGBUS will be safely caught and
-  // handled. On tmpfs, doing a fetch (rather than a store) is enough
-  // to cause backing pages to be allocated (there's no zero-page to
-  // worry about).
-  for (char *p = start; p < end; p += page_size) {
-    if (SafeFetch32((int*)p, -1) == -1) {
-      // Failed
-      return false;
-    }
-  }
-
-  // Success
-  return true;
+  // Success?
+  return backed ? 0 : ENOMEM;
 }
 
 ZErrno ZPhysicalMemoryBacking::fallocate_compat_mmap_tmpfs(zbacking_offset offset, size_t length) const {
@@ -487,7 +485,7 @@ ZErrno ZPhysicalMemoryBacking::fallocate_compat_mmap_tmpfs(zbacking_offset offse
     return errno;
   }
 
-  // Success
+  // Success?
   return backed ? 0 : ENOMEM;
 }
 
@@ -512,7 +510,7 @@ ZErrno ZPhysicalMemoryBacking::fallocate_fill_hole_compat(zbacking_offset offset
   // mmap/munmap (for hugetlbfs and tmpfs with transparent huge pages) or pwrite
   // (for tmpfs without transparent huge pages and other filesystem types).
   if (ZLargePages::is_explicit()) {
-    return fallocate_compat_mmap_hugetlbfs(offset, length, false /* touch */);
+    return fallocate_compat_mmap_hugetlbfs(offset, length);
   } else if (ZLargePages::is_transparent()) {
     return fallocate_compat_mmap_tmpfs(offset, length);
   } else {
@@ -560,18 +558,6 @@ ZErrno ZPhysicalMemoryBacking::fallocate_fill_hole(zbacking_offset offset, size_
 }
 
 ZErrno ZPhysicalMemoryBacking::fallocate_punch_hole(zbacking_offset offset, size_t length) const {
-  if (ZLargePages::is_explicit()) {
-    // We can only punch hole in pages that have been touched. Non-touched
-    // pages are only reserved, and not associated with any specific file
-    // segment. We don't know which pages have been previously touched, so
-    // we always touch them here to guarantee that we can punch hole.
-    const ZErrno err = fallocate_compat_mmap_hugetlbfs(offset, length, true /* touch */);
-    if (err) {
-      // Failed
-      return err;
-    }
-  }
-
   const int mode = FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE;
   if (ZSyscall::fallocate(_fd, mode, untype(offset), length) == -1) {
     // Failed
@@ -695,9 +681,7 @@ size_t ZPhysicalMemoryBacking::commit_default(zbacking_offset offset, size_t len
 }
 
 size_t ZPhysicalMemoryBacking::commit(zbacking_offset offset, size_t length, uint32_t numa_id) const {
-  if (ZNUMA::is_enabled() && !ZLargePages::is_explicit()) {
-    // The memory is required to be preferred at the time it is paged in. As a
-    // consequence we must prefer the memory when committing non-large pages.
+  if (ZNUMA::is_enabled()) {
     return commit_numa_preferred(offset, length, numa_id);
   }
 

src/hotspot/os/linux/gc/z/zPhysicalMemoryBacking_linux.hpp

@@ -48,7 +48,7 @@ class ZPhysicalMemoryBacking {
   bool is_hugetlbfs() const;
   bool tmpfs_supports_transparent_huge_pages() const;
 
-  ZErrno fallocate_compat_mmap_hugetlbfs(zbacking_offset offset, size_t length, bool touch) const;
+  ZErrno fallocate_compat_mmap_hugetlbfs(zbacking_offset offset, size_t length) const;
   ZErrno fallocate_compat_mmap_tmpfs(zbacking_offset offset, size_t length) const;
   ZErrno fallocate_compat_pwrite(zbacking_offset offset, size_t length) const;
   ZErrno fallocate_fill_hole_compat(zbacking_offset offset, size_t length) const;

src/hotspot/share/gc/z/zPhysicalMemoryManager.cpp

@@ -289,11 +289,6 @@ void ZPhysicalMemoryManager::map(const ZVirtualMemory& vmem, uint32_t numa_id) c
   });
 
   postcond(mapped == size);
-
-  // Setup NUMA preferred for large pages
-  if (ZNUMA::is_enabled() && ZLargePages::is_explicit()) {
-    os::numa_make_local((char*)addr, size, ZNUMA::numa_id_to_node(numa_id));
-  }
 }
 
 // Unmap virtual memory from physical memory