made code clang-format compliant

Author: guptask

cachelib/allocator/CacheAllocator-inl.h

@@ -67,7 +67,8 @@ CacheAllocator<CacheTrait>::CacheAllocator(SharedMemNewT, Config config)
                               config_.accessConfig.getNumBuckets()),
                           nullptr,
                           ShmSegmentOpts(config_.accessConfig.getPageSize(),
-                              false, config_.usePosixShm))
+                                         false,
+                                         config_.usePosixShm))
               .addr,
           compressor_,
           [this](Item* it) -> ItemHandle { return acquire(it); })),
@@ -79,7 +80,8 @@ CacheAllocator<CacheTrait>::CacheAllocator(SharedMemNewT, Config config)
                               config_.chainedItemAccessConfig.getNumBuckets()),
                           nullptr,
                           ShmSegmentOpts(config_.accessConfig.getPageSize(),
-                              false, config_.usePosixShm))
+                                         false,
+                                         config_.usePosixShm))
               .addr,
           compressor_,
           [this](Item* it) -> ItemHandle { return acquire(it); })),
@@ -90,7 +92,7 @@ CacheAllocator<CacheTrait>::CacheAllocator(SharedMemNewT, Config config)
                      config_.isNvmCacheTruncateAllocSizeEnabled()} {
   initCommon(false);
   shmManager_->removeShm(detail::kShmInfoName,
-    PosixSysVSegmentOpts(config_.usePosixShm));
+                         PosixSysVSegmentOpts(config_.usePosixShm));
 }
 
 template <typename CacheTrait>
@@ -108,15 +110,19 @@ CacheAllocator<CacheTrait>::CacheAllocator(SharedMemAttachT, Config config)
       accessContainer_(std::make_unique<AccessContainer>(
           deserializer_->deserialize<AccessSerializationType>(),
           config_.accessConfig,
-          shmManager_->attachShm(detail::kShmHashTableName, nullptr,
-            ShmSegmentOpts(PageSizeT::NORMAL, false, config_.usePosixShm)),
+          shmManager_->attachShm(
+              detail::kShmHashTableName,
+              nullptr,
+              ShmSegmentOpts(PageSizeT::NORMAL, false, config_.usePosixShm)),
           compressor_,
           [this](Item* it) -> ItemHandle { return acquire(it); })),
       chainedItemAccessContainer_(std::make_unique<AccessContainer>(
           deserializer_->deserialize<AccessSerializationType>(),
           config_.chainedItemAccessConfig,
-          shmManager_->attachShm(detail::kShmChainedItemHashTableName, nullptr,
-            ShmSegmentOpts(PageSizeT::NORMAL, false, config_.usePosixShm)),
+          shmManager_->attachShm(
+              detail::kShmChainedItemHashTableName,
+              nullptr,
+              ShmSegmentOpts(PageSizeT::NORMAL, false, config_.usePosixShm)),
           compressor_,
           [this](Item* it) -> ItemHandle { return acquire(it); })),
       chainedItemLocks_(config_.chainedItemsLockPower,
@@ -134,7 +140,7 @@ CacheAllocator<CacheTrait>::CacheAllocator(SharedMemAttachT, Config config)
   // this info shm segment here and the new info shm segment's size is larger
   // than this one, creating new one will fail.
   shmManager_->removeShm(detail::kShmInfoName,
-    PosixSysVSegmentOpts(config_.usePosixShm));
+                         PosixSysVSegmentOpts(config_.usePosixShm));
 }
 
 template <typename CacheTrait>
@@ -275,8 +281,9 @@ void CacheAllocator<CacheTrait>::initWorkers() {
 
 template <typename CacheTrait>
 std::unique_ptr<Deserializer> CacheAllocator<CacheTrait>::createDeserializer() {
-  auto infoAddr = shmManager_->attachShm(detail::kShmInfoName, nullptr,
-            ShmSegmentOpts(PageSizeT::NORMAL, false, config_.usePosixShm));
+  auto infoAddr = shmManager_->attachShm(
+      detail::kShmInfoName, nullptr,
+      ShmSegmentOpts(PageSizeT::NORMAL, false, config_.usePosixShm));
   return std::make_unique<Deserializer>(
       reinterpret_cast<uint8_t*>(infoAddr.addr),
       reinterpret_cast<uint8_t*>(infoAddr.addr) + infoAddr.size);
@@ -3141,8 +3148,10 @@ void CacheAllocator<CacheTrait>::saveRamCache() {
   ShmSegmentOpts opts;
   opts.typeOpts = PosixSysVSegmentOpts(config_.usePosixShm);
 
-  void* infoAddr = shmManager_->createShm(detail::kShmInfoName, ioBuf->length(),
-      nullptr, opts).addr;
+  void* infoAddr =
+      shmManager_
+          ->createShm(detail::kShmInfoName, ioBuf->length(), nullptr, opts)
+          .addr;
   Serializer serializer(reinterpret_cast<uint8_t*>(infoAddr),
                         reinterpret_cast<uint8_t*>(infoAddr) + ioBuf->length());
   serializer.writeToBuffer(std::move(ioBuf));
@@ -3492,8 +3501,8 @@ bool CacheAllocator<CacheTrait>::stopReaper(std::chrono::seconds timeout) {
 }
 
 template <typename CacheTrait>
-bool CacheAllocator<CacheTrait>::cleanupStrayShmSegments(
-    const std::string& cacheDir, bool posix /*TODO(SHM_FILE): const std::vector<CacheMemoryTierConfig>& config */) {
+bool CacheAllocator<
+    CacheTrait>::cleanupStrayShmSegments(const std::string& cacheDir, bool posix /*TODO(SHM_FILE): const std::vector<CacheMemoryTierConfig>& config */) {
   if (util::getStatIfExists(cacheDir, nullptr) && util::isDir(cacheDir)) {
     try {
       // cache dir exists. clean up only if there are no other processes
@@ -3516,7 +3525,8 @@ bool CacheAllocator<CacheTrait>::cleanupStrayShmSegments(
     // TODO(SHM_FILE): try to nuke segments of differente types (which require
     // extra info)
     // for (auto &tier : config) {
-    //   ShmManager::removeByName(cacheDir, tierShmName, config_.memoryTiers[i].opts);
+    //   ShmManager::removeByName(cacheDir, tierShmName,
+    //   config_.memoryTiers[i].opts);
     // }
   }
   return true;

cachelib/allocator/CacheAllocator.h

@@ -1191,8 +1191,9 @@ class CacheAllocator : public CacheBase {
   // returns true if there was no error in trying to cleanup the segment
   // because another process was attached. False if the user tried to clean up
   // and the cache was actually attached.
-  static bool cleanupStrayShmSegments(const std::string& cacheDir, bool posix
-    /*TODO: const std::vector<CacheMemoryTierConfig>& config = {} */);
+  static bool cleanupStrayShmSegments(
+      const std::string& cacheDir, bool posix
+      /*TODO: const std::vector<CacheMemoryTierConfig>& config = {} */);
 
   // gives a relative offset to a pointer within the cache.
   uint64_t getItemPtrAsOffset(const void* ptr);

cachelib/allocator/TempShmMapping.cpp

@@ -35,7 +35,7 @@ TempShmMapping::~TempShmMapping() {
   try {
     if (addr_) {
       shmManager_->removeShm(detail::kTempShmCacheName.str(),
-        PosixSysVSegmentOpts(false /* posix */));
+                             PosixSysVSegmentOpts(false /* posix */));
     }
     if (shmManager_) {
       shmManager_.reset();
@@ -79,7 +79,7 @@ void* TempShmMapping::createShmMapping(ShmManager& shmManager,
   } catch (...) {
     if (shmAddr) {
       shmManager.removeShm(detail::kTempShmCacheName.str(),
-        PosixSysVSegmentOpts(false /* posix */));
+                           PosixSysVSegmentOpts(false /* posix */));
     } else {
       munmap(addr, size);
     }

cachelib/shm/FileShmSegment.cpp

@@ -28,21 +28,19 @@ namespace facebook {
 namespace cachelib {
 
 FileShmSegment::FileShmSegment(ShmAttachT,
-                                 const std::string& name,
-                                 ShmSegmentOpts opts)
-    : ShmBase(std::move(opts), name),
-      fd_(getExisting(getPath(), opts_)) {
+                               const std::string& name,
+                               ShmSegmentOpts opts)
+    : ShmBase(std::move(opts), name), fd_(getExisting(getPath(), opts_)) {
   XDCHECK_NE(fd_, kInvalidFD);
   markActive();
   createReferenceMapping();
 }
 
 FileShmSegment::FileShmSegment(ShmNewT,
-                                 const std::string& name,
-                                 size_t size,
-                                 ShmSegmentOpts opts)
-    : ShmBase(std::move(opts), name),
-      fd_(createNewSegment(getPath())) {
+                               const std::string& name,
+                               size_t size,
+                               ShmSegmentOpts opts)
+    : ShmBase(std::move(opts), name), fd_(createNewSegment(getPath())) {
   markActive();
   resize(size);
   XDCHECK(isActive());
@@ -79,7 +77,7 @@ int FileShmSegment::createNewSegment(const std::string& name) {
 }
 
 int FileShmSegment::getExisting(const std::string& name,
-                                 const ShmSegmentOpts& opts) {
+                                const ShmSegmentOpts& opts) {
   int flags = opts.readOnly ? O_RDONLY : O_RDWR;
   detail::open_func_t open_func = std::bind(open, name.c_str(), flags);
   return detail::openImpl(open_func, flags);

cachelib/shm/FileShmSegment.h

@@ -47,18 +47,16 @@ class FileShmSegment : public ShmBase {
   //
   // @param name  Name of the segment
   // @param opts  the options for attaching to the segment.
-  FileShmSegment(ShmAttachT,
-                  const std::string& name,
-                  ShmSegmentOpts opts = {});
+  FileShmSegment(ShmAttachT, const std::string& name, ShmSegmentOpts opts = {});
 
   // create a new segment
   // @param name  The name of the segment
   // @param size  The size of the segment. This will be rounded up to the
   //              nearest page size.
   FileShmSegment(ShmNewT,
-                  const std::string& name,
-                  size_t size,
-                  ShmSegmentOpts opts = {});
+                 const std::string& name,
+                 size_t size,
+                 ShmSegmentOpts opts = {});
 
   // destructor
   ~FileShmSegment() override;

cachelib/shm/PosixShmSegment.cpp

@@ -76,14 +76,16 @@ PosixShmSegment::~PosixShmSegment() {
 
 int PosixShmSegment::createNewSegment(const std::string& name) {
   constexpr static int createFlags = O_RDWR | O_CREAT | O_EXCL;
-  detail::open_func_t open_func = std::bind(shm_open, name.c_str(), createFlags, kRWMode);
+  detail::open_func_t open_func =
+      std::bind(shm_open, name.c_str(), createFlags, kRWMode);
   return detail::openImpl(open_func, createFlags);
 }
 
 int PosixShmSegment::getExisting(const std::string& name,
                                  const ShmSegmentOpts& opts) {
   int flags = opts.readOnly ? O_RDONLY : O_RDWR;
-  detail::open_func_t open_func = std::bind(shm_open, name.c_str(), flags, kRWMode);
+  detail::open_func_t open_func =
+      std::bind(shm_open, name.c_str(), flags, kRWMode);
   return detail::openImpl(open_func, flags);
 }
 

cachelib/shm/Shm.h

@@ -48,39 +48,34 @@ class ShmSegment {
   // @param name   name of the segment
   // @param size   size of the segment.
   // @param opts   the options for the segment.
-  ShmSegment(ShmNewT,
-             std::string name,
-             size_t size,
-             ShmSegmentOpts opts = {}) {
-    if (auto *v = std::get_if<FileShmSegmentOpts>(&opts.typeOpts)) {
-      segment_ = std::make_unique<FileShmSegment>(
-        ShmNew, std::move(name), size, opts);
-    } else if (auto *v = std::get_if<PosixSysVSegmentOpts>(&opts.typeOpts)) {
+  ShmSegment(ShmNewT, std::string name, size_t size, ShmSegmentOpts opts = {}) {
+    if (auto* v = std::get_if<FileShmSegmentOpts>(&opts.typeOpts)) {
+      segment_ =
+          std::make_unique<FileShmSegment>(ShmNew, std::move(name), size, opts);
+    } else if (auto* v = std::get_if<PosixSysVSegmentOpts>(&opts.typeOpts)) {
       if (v->usePosix)
-        segment_ = std::make_unique<PosixShmSegment>(
-          ShmNew, std::move(name), size, opts);
+        segment_ = std::make_unique<PosixShmSegment>(ShmNew, std::move(name),
+                                                     size, opts);
       else
-        segment_ = std::make_unique<SysVShmSegment>(
-          ShmNew, std::move(name), size, opts);
+        segment_ = std::make_unique<SysVShmSegment>(ShmNew, std::move(name),
+                                                    size, opts);
     }
   }
 
   // attach to an existing segment with the given key
   // @param name   name of the segment
   // @param opts   the options for the segment.
-  ShmSegment(ShmAttachT,
-             std::string name,
-             ShmSegmentOpts opts = {}) {
+  ShmSegment(ShmAttachT, std::string name, ShmSegmentOpts opts = {}) {
     if (std::get_if<FileShmSegmentOpts>(&opts.typeOpts)) {
-      segment_ = std::make_unique<FileShmSegment>(
-        ShmAttach, std::move(name), opts);
-    } else if (auto *v = std::get_if<PosixSysVSegmentOpts>(&opts.typeOpts)) {
+      segment_ =
+          std::make_unique<FileShmSegment>(ShmAttach, std::move(name), opts);
+    } else if (auto* v = std::get_if<PosixSysVSegmentOpts>(&opts.typeOpts)) {
       if (v->usePosix)
-        segment_ = std::make_unique<PosixShmSegment>(
-          ShmAttach, std::move(name), opts);
+        segment_ =
+            std::make_unique<PosixShmSegment>(ShmAttach, std::move(name), opts);
       else
-        segment_ = std::make_unique<SysVShmSegment>(
-          ShmAttach, std::move(name), opts);
+        segment_ =
+            std::make_unique<SysVShmSegment>(ShmAttach, std::move(name), opts);
     }
   }
 

cachelib/shm/ShmCommon.cpp

@@ -21,8 +21,8 @@
 #include <folly/Range.h>
 #include <folly/String.h>
 #include <folly/logging/xlog.h>
-#include <sys/types.h>
 #include <sys/mman.h>
+#include <sys/types.h>
 
 namespace facebook {
 namespace cachelib {
@@ -245,7 +245,8 @@ void fstatImpl(int fd, stat_t* buf) {
   }
 }
 
-void* mmapImpl(void* addr, size_t length, int prot, int flags, int fd, off_t offset) {
+void* mmapImpl(
+    void* addr, size_t length, int prot, int flags, int fd, off_t offset) {
   void* ret = mmap(addr, length, prot, flags, fd, offset);
   if (ret != MAP_FAILED) {
     return ret;

cachelib/shm/ShmCommon.h

@@ -78,12 +78,12 @@ enum PageSizeT {
 };
 
 struct FileShmSegmentOpts {
-  FileShmSegmentOpts(std::string path = ""): path(path) {}
+  FileShmSegmentOpts(std::string path = "") : path(path) {}
   std::string path;
 };
 
 struct PosixSysVSegmentOpts {
-  PosixSysVSegmentOpts(bool usePosix = false): usePosix(usePosix) {}
+  PosixSysVSegmentOpts(bool usePosix = false) : usePosix(usePosix) {}
   bool usePosix;
 };
 
@@ -92,17 +92,15 @@ using ShmTypeOpts = std::variant<FileShmSegmentOpts, PosixSysVSegmentOpts>;
 struct ShmSegmentOpts {
   PageSizeT pageSize{PageSizeT::NORMAL};
   bool readOnly{false};
-  size_t alignment{1}; // alignment for mapping.
+  size_t alignment{1};    // alignment for mapping.
   ShmTypeOpts typeOpts{}; // opts specific to segment type
 
   explicit ShmSegmentOpts(PageSizeT p) : pageSize(p) {}
   explicit ShmSegmentOpts(PageSizeT p, bool ro) : pageSize(p), readOnly(ro) {}
-  explicit ShmSegmentOpts(PageSizeT p, bool ro, const std::string& path) :
-                                       pageSize(p), readOnly(ro),
-                                       typeOpts(path) {}
-  explicit ShmSegmentOpts(PageSizeT p, bool ro, bool posix) :
-                                       pageSize(p), readOnly(ro),
-                                       typeOpts(posix) {}
+  explicit ShmSegmentOpts(PageSizeT p, bool ro, const std::string& path)
+      : pageSize(p), readOnly(ro), typeOpts(path) {}
+  explicit ShmSegmentOpts(PageSizeT p, bool ro, bool posix)
+      : pageSize(p), readOnly(ro), typeOpts(posix) {}
   ShmSegmentOpts() : pageSize(PageSizeT::NORMAL) {}
 };
 
@@ -195,7 +193,8 @@ void ftruncateImpl(int fd, size_t size);
 void fstatImpl(int fd, stat_t* buf);
 
 // @throw  std::invalid_argument if there is an error
-void* mmapImpl(void* addr, size_t length, int prot, int flags, int fd, off_t offset);
+void* mmapImpl(
+    void* addr, size_t length, int prot, int flags, int fd, off_t offset);
 
 // @throw  std::invalid_argument if there is an error
 void munmapImpl(void* addr, size_t length);