configurable alignment for Arena

Summary: Allow specifying custom alignment.

Test Plan: fbconfig -r folly/test && fbmake opt -j32

@override-unit-failures

Reviewed By: lucian@fb.com

FB internal diff: D1264851

folly/Arena-inl.h

@@ -31,7 +31,6 @@ Arena<Alloc>::Block::allocate(Alloc& alloc, size_t size, bool allowSlack) {
   }
 
   void* mem = alloc.allocate(allocSize);
-  assert(isAligned(mem));
   return std::make_pair(new (mem) Block(), allocSize - sizeof(Block));
 }
 
@@ -46,9 +45,9 @@ void* Arena<Alloc>::allocateSlow(size_t size) {
   std::pair<Block*, size_t> p;
   char* start;
 
-
   size_t allocSize = std::max(size, minBlockSize()) + sizeof(Block);
-  if(sizeLimit_ && allocSize > sizeLimit_ - totalAllocatedSize_) {
+  if (sizeLimit_ != kNoSizeLimit &&
+      allocSize > sizeLimit_ - totalAllocatedSize_) {
     throw std::bad_alloc();
   }
 

folly/Arena.h

@@ -19,9 +19,11 @@
 
 #include <cassert>
 #include <limits>
+#include <stdexcept>
 #include <utility>
 #include <boost/intrusive/slist.hpp>
 
+#include "folly/Conv.h"
 #include "folly/Likely.h"
 #include "folly/Malloc.h"
 #include "folly/Memory.h"
@@ -61,13 +63,19 @@ class Arena {
  public:
   explicit Arena(const Alloc& alloc,
                  size_t minBlockSize = kDefaultMinBlockSize,
-                 size_t sizeLimit = 0)
+                 size_t sizeLimit = kNoSizeLimit,
+                 size_t maxAlign = kDefaultMaxAlign)
     : allocAndSize_(alloc, minBlockSize)
     , ptr_(nullptr)
     , end_(nullptr)
     , totalAllocatedSize_(0)
     , bytesUsed_(0)
-    , sizeLimit_(sizeLimit) {
+    , sizeLimit_(sizeLimit)
+    , maxAlign_(maxAlign) {
+    if ((maxAlign_ & (maxAlign_ - 1)) || maxAlign_ > alignof(Block)) {
+      throw std::invalid_argument(
+          folly::to<std::string>("Invalid maxAlign: ", maxAlign_));
+    }
   }
 
   ~Arena();
@@ -147,19 +155,20 @@ class Arena {
 
  public:
   static constexpr size_t kDefaultMinBlockSize = 4096 - sizeof(Block);
+  static constexpr size_t kNoSizeLimit = 0;
+  static constexpr size_t kDefaultMaxAlign = alignof(Block);
 
  private:
-  static constexpr size_t maxAlign = alignof(Block);
-  static constexpr bool isAligned(uintptr_t address) {
-    return (address & (maxAlign - 1)) == 0;
+  bool isAligned(uintptr_t address) const {
+    return (address & (maxAlign_ - 1)) == 0;
   }
-  static bool isAligned(void* p) {
+  bool isAligned(void* p) const {
     return isAligned(reinterpret_cast<uintptr_t>(p));
   }
 
   // Round up size so it's properly aligned
-  static constexpr size_t roundUp(size_t size) {
-    return (size + maxAlign - 1) & ~(maxAlign - 1);
+  size_t roundUp(size_t size) const {
+    return (size + maxAlign_ - 1) & ~(maxAlign_ - 1);
   }
 
   // cache_last<true> makes the list keep a pointer to the last element, so we
@@ -194,7 +203,8 @@ class Arena {
   char* end_;
   size_t totalAllocatedSize_;
   size_t bytesUsed_;
-  size_t sizeLimit_;
+  const size_t sizeLimit_;
+  const size_t maxAlign_;
 };
 
 template <class Alloc>
@@ -223,8 +233,9 @@ struct ArenaAllocatorTraits<SysAlloc> {
 class SysArena : public Arena<SysAlloc> {
  public:
   explicit SysArena(size_t minBlockSize = kDefaultMinBlockSize,
-                    size_t sizeLimit = 0)
-    : Arena<SysAlloc>(SysAlloc(), minBlockSize, sizeLimit) {
+                    size_t sizeLimit = kNoSizeLimit,
+                    size_t maxAlign = kDefaultMaxAlign)
+    : Arena<SysAlloc>(SysAlloc(), minBlockSize, sizeLimit, maxAlign) {
   }
 };
 

folly/ThreadCachedArena.cpp

@@ -18,12 +18,13 @@
 
 namespace folly {
 
-ThreadCachedArena::ThreadCachedArena(size_t minBlockSize)
-  : minBlockSize_(minBlockSize) {
+ThreadCachedArena::ThreadCachedArena(size_t minBlockSize, size_t maxAlign)
+  : minBlockSize_(minBlockSize), maxAlign_(maxAlign) {
 }
 
 SysArena* ThreadCachedArena::allocateThreadLocalArena() {
-  SysArena* arena = new SysArena(minBlockSize_);
+  SysArena* arena =
+    new SysArena(minBlockSize_, SysArena::kNoSizeLimit, maxAlign_);
   auto disposer = [this] (SysArena* t, TLPDestructionMode mode) {
     std::unique_ptr<SysArena> tp(t);  // ensure it gets deleted
     if (mode == TLPDestructionMode::THIS_THREAD) {

folly/ThreadCachedArena.h

@@ -42,7 +42,8 @@ namespace folly {
 class ThreadCachedArena {
  public:
   explicit ThreadCachedArena(
-      size_t minBlockSize = SysArena::kDefaultMinBlockSize);
+      size_t minBlockSize = SysArena::kDefaultMinBlockSize,
+      size_t maxAlign = SysArena::kDefaultMaxAlign);
 
   void* allocate(size_t size) {
     SysArena* arena = arena_.get();
@@ -69,12 +70,16 @@ class ThreadCachedArena {
   // the ThreadCachedArena is destroyed.
   void zombify(SysArena&& arena);
 
-  size_t minBlockSize_;
+  const size_t minBlockSize_;
+  const size_t maxAlign_;
   SysArena zombies_;  // allocated from threads that are now dead
   std::mutex zombiesMutex_;
   ThreadLocalPtr<SysArena> arena_;  // per-thread arena
 };
 
+template <>
+struct IsArenaAllocator<ThreadCachedArena> : std::true_type { };
+
 }  // namespace folly
 
 #endif /* FOLLY_THREADCACHEDARENA_H_ */