Support huge pages for the temp shm mapping

Summary: ^

Reviewed By: AlnisM

Differential Revision: D113626413

fbshipit-source-id: 851439097c0374002f7eca50a58697828f61c4c4

Author: rlyerly

cachelib/allocator/CacheAllocator.h

@@ -2760,7 +2760,8 @@ CacheAllocator<CacheTrait>::CacheAllocator(
                                           : config.memMonitoringEnabled()},
       config_(config.validate()),
       tempShm_(type == InitMemType::kNone && isOnShm_
-                   ? std::make_unique<TempShmMapping>(config_.getCacheSize())
+                   ? std::make_unique<TempShmMapping>(config_.getCacheSize(),
+                                                      config_.hugePageSize)
                    : nullptr),
       shmManager_(type != InitMemType::kNone
                       ? std::make_unique<ShmManager>(config_.cacheDir,

cachelib/allocator/TempShmMapping.cpp

@@ -19,16 +19,18 @@
 #include <folly/logging/xlog.h>
 #include <sys/mman.h>
 
+#include <algorithm>
+
 #include "cachelib/allocator/memory/Slab.h"
 #include "cachelib/common/Utils.h"
 
 namespace facebook::cachelib {
 
-TempShmMapping::TempShmMapping(size_t size)
-    : size_(size),
-      tempCacheDir_(util::getUniqueTempDir("cachedir")),
+TempShmMapping::TempShmMapping(size_t size, PageSize hugePageSize)
+    : tempCacheDir_(util::getUniqueTempDir("cachedir")),
       shmManager_(createShmManager(tempCacheDir_)),
-      addr_(createShmMapping(*shmManager_.get(), size, tempCacheDir_)) {}
+      addr_(createShmMapping(
+          *shmManager_.get(), size, tempCacheDir_, hugePageSize)) {}
 
 TempShmMapping::~TempShmMapping() {
   try {
@@ -61,14 +63,22 @@ std::unique_ptr<ShmManager> TempShmMapping::createShmManager(
 
 void* TempShmMapping::createShmMapping(ShmManager& shmManager,
                                        size_t size,
-                                       const std::string& cacheDir) {
+                                       const std::string& cacheDir,
+                                       const PageSize& hugePageSize) {
   void* addr = nullptr;
   void* shmAddr = nullptr;
   try {
-    addr =
-        util::mmapAlignedZeroedMemory(sizeof(Slab), size, true /* readOnly */);
+    PageSize ps(hugePageSize);
+    size = ps.getPageAlignedSize(size);
+    const size_t alignment = std::max(sizeof(Slab), hugePageSize.getPageSize());
+    addr = util::mmapAlignedZeroedMemory(alignment, size, true /* readOnly */);
+    ShmSegmentOpts opts;
+    opts.pageSize = PageSize(hugePageSize);
     shmAddr =
-        shmManager.createShm(detail::kTempShmCacheName.str(), size, addr).addr;
+        shmManager
+            .createShm(
+                detail::kTempShmCacheName.str(), size, addr, std::move(opts))
+            .addr;
     // Mark the shared memory segment to be removed on exit. This will ensure
     // that the segment is dropped on exit.
     auto& shm = shmManager.getShmByName(detail::kTempShmCacheName.str());

cachelib/allocator/TempShmMapping.h

@@ -41,7 +41,7 @@ constexpr folly::StringPiece kTempShmCacheName = "temp_shm_cache";
 // the cache is on a shared memory segment.
 class TempShmMapping {
  public:
-  explicit TempShmMapping(size_t size);
+  explicit TempShmMapping(size_t size, PageSize hugePageSize = PageSize());
   ~TempShmMapping();
   // get the start of addrress.
   void* getAddr() const { return addr_; }
@@ -51,9 +51,9 @@ class TempShmMapping {
       const std::string& cacheDir);
   static void* createShmMapping(ShmManager& shmManager,
                                 size_t size,
-                                const std::string& cacheDir);
+                                const std::string& cacheDir,
+                                const PageSize& hugePageSize);
 
-  size_t size_{0};
   std::string tempCacheDir_;
   std::unique_ptr<ShmManager> shmManager_;
   void* addr_{nullptr};