Revert of Make text section 2MB aligned for hugepages.

chromeos/hugepage_text/hugepage_text.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 // Author: Ken Chen <kenchen@google.com>
 //
 // hugepage text library to remap process executable segment with hugepages.
 
 #include "chromeos/hugepage_text/hugepage_text.h"
 
 #include <link.h>
@@ skipping 18 matching lines @@
 
 const int kHpageShift = 21;
 const int kHpageSize = (1 << kHpageShift);
 const int kHpageMask = (~(kHpageSize - 1));
 
 const int kProtection = (PROT_READ | PROT_WRITE);
 const int kMmapFlags = (MAP_ANONYMOUS | MAP_SHARED);
 const int kMmapHtlbFlags = (kMmapFlags | MAP_HUGETLB);
 const int kMremapFlags = (MREMAP_MAYMOVE | MREMAP_FIXED);
 
+// The number of hugepages we want to use to map chrome text section
+// to hugepages. With the help of AutoFDO, the hot functions are grouped
+// in to a small area of the binary.
+const int kNumHugePages = 15;
+
 // mremap syscall is always supported for small page segment on all kernels.
 // However, it is not the case for hugepage.
 // If not used carefully, mremap() a hugepage segment directly onto small page
 // text segment will cause irreversible damage to the existing text mapping
 // and cause process to segfault. This function will dynamically at run time
 // determine whether a process can safely execute mremap on a hugepage segment
 // without taking the process down.
 //
 // Inputs: none
 // Return: true if mremap on hugepage segment is supported on the host OS.
@@ skipping 68 matching lines @@
 // Remaps text segment at address "vaddr" to hugepage backed mapping via mremap
 // syscall.  The virtual address does not change.  When this call returns, the
 // backing physical memory will be changed from small page to hugetlb page.
 //
 // Inputs: vaddr, the starting virtual address to remap to hugepage
 //         hsize, size of the memory segment to remap in bytes
 // Return: none
 // Effect: physical backing page changed from small page to hugepage. If there
 //         are error condition, the remapping operation is aborted.
 static void MremapHugetlbText(void* vaddr, const size_t hsize) {
-  DCHECK_EQ(0ul, reinterpret_cast<uintptr_t>(vaddr) & ~kHpageMask);
   void* haddr = MAP_FAILED;
-  if (HugetlbMremapSupported()) {
+
+  if ((reinterpret_cast<intptr_t>(vaddr) & ~kHpageMask) == 0 &&
+      HugetlbMremapSupported()) {
     // Try anon hugepage from static hugepage pool only if the source address
     // is hugepage aligned, otherwise, mremap below has non-recoverable error.
     haddr = mmap(NULL, hsize, kProtection, kMmapHtlbFlags, 0, 0);
   }
 
   if (haddr == MAP_FAILED) {
     PLOG(INFO) << "static hugepage not available, trying transparent hugepage";
     haddr = GetTransparentHugepageMapping(hsize);
     if (haddr == NULL)
       return;
@@ skipping 19 matching lines @@
 }
 
 // Top level text remapping function.
 //
 // Inputs: vaddr, the starting virtual address to remap to hugepage
 //         hsize, size of the memory segment to remap in bytes
 // Return: none
 // Effect: physical backing page changed from small page to hugepage. If there
 //         are error condition, the remaping operation is aborted.
 static void RemapHugetlbText(void* vaddr, const size_t segsize) {
-  // remove unaligned head regions
-  size_t head_gap = (kHpageSize - reinterpret_cast<size_t>(vaddr) % kHpageSize)
-                    % kHpageSize;
-  size_t addr = reinterpret_cast<size_t>(vaddr) + head_gap;
-
-  int hsize = segsize - head_gap;
+  int hsize = segsize;
+  if (segsize > kHpageSize * kNumHugePages)
+    hsize = kHpageSize * kNumHugePages;
   hsize = hsize & kHpageMask;
 
   if (hsize == 0)
     return;
 
-  MremapHugetlbText(reinterpret_cast<void *>(addr), hsize);
+  MremapHugetlbText(vaddr, hsize);
 }
 
 // For a given ELF program header descriptor, iterates over all segments within
 // it and find the first segment that has PT_LOAD and is executable, call
 // RemapHugetlbText().
 //
 // Inputs: info: pointer to a struct dl_phdr_info that describes the DSO.
 //         size: size of the above structure (not used in this function).
 //         data: user param (not used in this function).
 // Return: always return true.  The value is propagated by dl_iterate_phdr().
@@ skipping 18 matching lines @@
 
 // Main library function.  This function will iterate all ELF segments and
 // attempt to remap text segment from small page to hugepage.
 // If remapping is successful.  All error conditions are soft fail such that
 // effect will be rolled back and remap operation will be aborted.
 void ReloadElfTextInHugePages(void) {
   dl_iterate_phdr(FilterElfHeader, 0);
 }
 
 }  // namespace chromeos