folly::fibers::StackCache Class Reference

Public Member Functions
	StackCache (size_t stackSize)
unsigned char *	borrow (size_t size)
bool	giveBack (unsigned char *limit, size_t size)
	~StackCache ()

Static Public Member Functions
static bool	isProtected (intptr_t addr)

Static Private Member Functions
static size_t	pagesize ()
static size_t	allocSize (size_t size)
static folly::Synchronized< std::unordered_set< intptr_t > > &	protectedPages ()

Private Attributes
folly::SpinLock	lock_
unsigned char *	storage_ {nullptr}
size_t	allocSize_ {0}
std::vector< std::pair< unsigned char *, bool > >	freeList_

Detailed Description

A cache for kNumGuarded stacks of a given size

Thread safe.

Definition at line 60 of file GuardPageAllocator.cpp.

Constructor & Destructor Documentation

folly::fibers::StackCache::StackCache ( size_t  stackSize )

inlineexplicit

Definition at line 62 of file GuardPageAllocator.cpp.

References allocSize_, freeList_, i, folly::fibers::kNumGuarded, and storage_.

                                        : allocSize_(allocSize(stackSize)) {
    auto p = ::mmap(
        nullptr,
        allocSize_ * kNumGuarded,
        PROT_READ | PROT_WRITE,
        MAP_PRIVATE | MAP_ANONYMOUS,
        -1,
        0);
    PCHECK(p != (void*)(-1));
    storage_ = reinterpret_cast<unsigned char*>(p);

    /* Protect the bottommost page of every stack allocation */
    for (size_t i = 0; i < kNumGuarded; ++i) {
      auto allocBegin = storage_ + allocSize_ * i;
      freeList_.emplace_back(allocBegin, /* protected= */ false);
    }
  }

folly::fibers::StackCache::~StackCache ( )

inline

Definition at line 132 of file GuardPageAllocator.cpp.

References allocSize_, freeList_, protectedPages(), and storage_.

                {
    assert(storage_);
    protectedPages().withWLock([&](auto& pages) {
      for (const auto& item : freeList_) {
        pages.erase(reinterpret_cast<intptr_t>(item.first));
      }
    });
    PCHECK(0 == ::munmap(storage_, allocSize_ * kNumGuarded));
  }

Member Function Documentation

static size_t folly::fibers::StackCache::allocSize ( size_t  size )

inlinestaticprivate

Definition at line 171 of file GuardPageAllocator.cpp.

References pagesize().

Referenced by borrow(), and giveBack().

                                       {
    return pagesize() * ((size + pagesize() - 1) / pagesize() + 1);
  }

unsigned char* folly::fibers::StackCache::borrow ( size_t  size )

inline

Definition at line 80 of file GuardPageAllocator.cpp.

References allocSize(), allocSize_, folly::gen::as(), freeList_, lock_, pagesize(), protectedPages(), folly::size(), and storage_.

                                     {
    std::lock_guard<folly::SpinLock> lg(lock_);

    assert(storage_);

    auto as = allocSize(size);
    if (as != allocSize_ || freeList_.empty()) {
      return nullptr;
    }

    auto p = freeList_.back().first;
    if (!freeList_.back().second) {
      PCHECK(0 == ::mprotect(p, pagesize(), PROT_NONE));
      protectedPages().wlock()->insert(reinterpret_cast<intptr_t>(p));
    }
    freeList_.pop_back();

    /* We allocate minimum number of pages required, plus a guard page.
       Since we use this for stack storage, requested allocation is aligned
       at the top of the allocated pages, while the guard page is at the bottom.

               -- increasing addresses -->
             Guard page     Normal pages
            |xxxxxxxxxx|..........|..........|
            <- allocSize_ ------------------->
         p -^                <- size -------->
                      limit -^
    */
    auto limit = p + allocSize_ - size;
    assert(limit >= p + pagesize());
    return limit;
  }

bool folly::fibers::StackCache::giveBack ( unsigned char *  limit, size_t  size  )

inline

Definition at line 113 of file GuardPageAllocator.cpp.

References allocSize(), allocSize_, folly::gen::as(), freeList_, folly::fibers::kNumGuarded, lock_, and storage_.

                                                   {
    std::lock_guard<folly::SpinLock> lg(lock_);

    assert(storage_);

    auto as = allocSize(size);
    if (std::less_equal<void*>{}(limit, storage_) ||
        std::less_equal<void*>{}(storage_ + allocSize_ * kNumGuarded, limit)) {
      /* not mine */
      return false;
    }

    auto p = limit + size - as;
    assert(as == allocSize_);
    assert((p - storage_) % allocSize_ == 0);
    freeList_.emplace_back(p, /* protected= */ true);
    return true;
  }

static bool folly::fibers::StackCache::isProtected ( intptr_t  addr )

inlinestatic

Definition at line 142 of file GuardPageAllocator.cpp.

References pagesize(), and protectedPages().

Referenced by protectedPages().

                                         {
    // Use a read lock for reading.
    return protectedPages().withRLock([&](auto const& pages) {
      for (const auto& page : pages) {
        intptr_t pageEnd = intptr_t(page + pagesize());
        if (page <= addr && addr < pageEnd) {
          return true;
        }
      }
      return false;
    });
  }

static size_t folly::fibers::StackCache::pagesize ( )

inlinestaticprivate

Definition at line 165 of file GuardPageAllocator.cpp.

Referenced by allocSize(), borrow(), and isProtected().

                           {
    static const size_t pagesize = size_t(sysconf(_SC_PAGESIZE));
    return pagesize;
  }

static folly::Synchronized<std::unordered_set<intptr_t> >& folly::fibers::StackCache::protectedPages ( )

inlinestaticprivate

Definition at line 175 of file GuardPageAllocator.cpp.

References folly::call_once(), deadlock::info(), and isProtected().

Referenced by borrow(), isProtected(), and ~StackCache().

                                                                         {
    static auto instance =
        new folly::Synchronized<std::unordered_set<intptr_t>>();
    return *instance;
  }

Member Data Documentation

size_t folly::fibers::StackCache::allocSize_ {0}

private

Definition at line 158 of file GuardPageAllocator.cpp.

Referenced by borrow(), giveBack(), StackCache(), and ~StackCache().

std::vector<std::pair<unsigned char*, bool> > folly::fibers::StackCache::freeList_

private

LIFO free list. Each pair contains stack pointer and protected flag.

Definition at line 163 of file GuardPageAllocator.cpp.

Referenced by borrow(), giveBack(), StackCache(), and ~StackCache().

folly::SpinLock folly::fibers::StackCache::lock_

private

Definition at line 156 of file GuardPageAllocator.cpp.

Referenced by borrow(), folly::fibers::CacheManager::getStackCache(), and giveBack().

unsigned char* folly::fibers::StackCache::storage_ {nullptr}

private

Definition at line 157 of file GuardPageAllocator.cpp.

Referenced by borrow(), giveBack(), StackCache(), and ~StackCache().

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/fibers/GuardPageAllocator.cpp