folly::detail::MemoryIdler Struct Reference

#include <MemoryIdler.h>

Public Types
enum	{ kDefaultStackToRetain = 1024 }

Static Public Member Functions
static void	flushLocalMallocCaches ()
static void	unmapUnusedStack (size_t retain=kDefaultStackToRetain)
template<typename IdleTime = std::chrono::steady_clock::duration>
static IdleTime	getVariationTimeout (IdleTime const &idleTimeout=defaultIdleTimeout.load(std::memory_order_acquire), float timeoutVariationFrac=0.5)
template<typename Futex , typename IdleTime = std::chrono::steady_clock::duration>
static FutexResult	futexWait (Futex &fut, uint32_t expected, uint32_t waitMask=-1, IdleTime const &idleTimeout=defaultIdleTimeout.load(std::memory_order_acquire), size_t stackToRetain=kDefaultStackToRetain, float timeoutVariationFrac=0.5)
template<typename Futex , typename Deadline , typename IdleTime = std::chrono::steady_clock::duration>
static FutexResult	futexWaitUntil (Futex &fut, uint32_t expected, Deadline const &deadline, uint32_t waitMask=-1, IdleTime const &idleTimeout=defaultIdleTimeout.load(std::memory_order_acquire), size_t stackToRetain=kDefaultStackToRetain, float timeoutVariationFrac=0.5)

Static Public Attributes
static AtomicStruct< std::chrono::steady_clock::duration >	defaultIdleTimeout

Static Private Member Functions
template<typename Futex , typename Deadline , typename IdleTime >
static bool	futexWaitPreIdle (FutexResult &_ret, Futex &fut, uint32_t expected, Deadline const &deadline, uint32_t waitMask, IdleTime idleTimeout, size_t stackToRetain, float timeoutVariationFrac)

Detailed Description

MemoryIdler provides helper routines that allow routines to return some assigned memory resources back to the system. The intended use is that when a thread is waiting for a long time (perhaps it is in a LIFO thread pool and hasn't been needed for a long time) it should release its thread-local malloc caches (both jemalloc and tcmalloc use these for better performance) and unmap the stack pages that contain no useful data.

Definition at line 38 of file MemoryIdler.h.

Member Enumeration Documentation

anonymous enum

Enumerator
kDefaultStackToRetain	This value is a tradeoff between reclaiming memory and triggering a page fault immediately on wakeup. Note that the actual unit of idling for the stack is pages, so the actual stack that will be available on wakeup without a page fault is between kDefaultStackToRetain and kDefaultStackToRetain + PageSize - 1 bytes.

Definition at line 44 of file MemoryIdler.h.

       {
    kDefaultStackToRetain = 1024,
  };

Member Function Documentation

void folly::detail::MemoryIdler::flushLocalMallocCaches ( )

static

Returns memory from thread-local allocation pools to the global pool, if we know how to for the current malloc implementation. jemalloc is supported.

Definition at line 41 of file MemoryIdler.cpp.

References addr, folly::call_once(), folly::test::end(), FB_LOG_EVERY_MS, flag, FOLLY_NOINLINE, folly::kIsDebug, mallctl, mallctlbymib, mallctlnametomib, folly::mallctlRead(), max, SCOPE_EXIT, folly::CacheLocality::system(), unmapUnusedStack(), folly::usingJEMalloc(), and folly::WARNING.

Referenced by BENCHMARK(), futexWaitPreIdle(), folly::MemoryIdlerTimeout::runLoopCallback(), and TEST().

                                         {
  if (!usingJEMalloc()) {
    return;
  }
  if (!mallctl || !mallctlnametomib || !mallctlbymib) {
    FB_LOG_EVERY_MS(ERROR, 10000) << "mallctl* weak link failed";
    return;
  }

  try {
    // Not using mallctlCall as this will fail if tcache is disabled.
    mallctl("thread.tcache.flush", nullptr, nullptr, nullptr, 0);

    // By default jemalloc has 4 arenas per cpu, and then assigns each
    // thread to one of those arenas.  This means that in any service
    // that doesn't perform a lot of context switching, the chances that
    // another thread will be using the current thread's arena (and hence
    // doing the appropriate dirty-page purging) are low.  Some good
    // tuned configurations (such as that used by hhvm) use fewer arenas
    // and then pin threads to avoid contended access.  In that case,
    // purging the arenas is counter-productive.  We use the heuristic
    // that if narenas <= 2 * num_cpus then we shouldn't do anything here,
    // which detects when the narenas has been reduced from the default
    unsigned narenas;
    unsigned arenaForCurrent;
    size_t mib[3];
    size_t miblen = 3;

    mallctlRead("opt.narenas", &narenas);
    mallctlRead("thread.arena", &arenaForCurrent);
    if (narenas > 2 * CacheLocality::system().numCpus &&
        mallctlnametomib("arena.0.purge", mib, &miblen) == 0) {
      mib[1] = static_cast<size_t>(arenaForCurrent);
      mallctlbymib(mib, miblen, nullptr, nullptr, nullptr, 0);
    }
  } catch (const std::runtime_error& ex) {
    FB_LOG_EVERY_MS(WARNING, 10000) << ex.what();
  }
}

template<typename Futex , typename IdleTime = std::chrono::steady_clock::duration>

static FutexResult folly::detail::MemoryIdler::futexWait ( Futex &  fut, uint32_t  expected, uint32_t  waitMask = -1, IdleTime const &  idleTimeout = defaultIdleTimeout.load(std::memory_order_acquire), size_t  stackToRetain = kDefaultStackToRetain, float  timeoutVariationFrac = 0.5  )

inlinestatic

Equivalent to fut.futexWait(expected, waitMask), but calls flushLocalMallocCaches() and unmapUnusedStack(stackToRetain) after idleTimeout has passed (if it has passed). Internally uses fut.futexWait and fut.futexWaitUntil. The actual timeout will be pseudo-randomly chosen to be between idleTimeout and idleTimeout * (1 + timeoutVariationFraction), to smooth out the behavior in a system with bursty requests. The default is to wait up to 50% extra, so on average 25% extra.

Definition at line 102 of file MemoryIdler.h.

References folly::detail::futexWait(), futexWaitPreIdle(), and max.

Referenced by folly::fibers::Baton::waitThread().

                                        {
    FutexResult pre;
    if (futexWaitPreIdle(
            pre,
            fut,
            expected,
            std::chrono::steady_clock::time_point::max(),
            waitMask,
            idleTimeout,
            stackToRetain,
            timeoutVariationFrac)) {
      return pre;
    }

    using folly::detail::futexWait;
    return futexWait(&fut, expected, waitMask);
  }

template<typename Futex , typename Deadline , typename IdleTime >

static bool folly::detail::MemoryIdler::futexWaitPreIdle ( FutexResult &  _ret, Futex &  fut, uint32_t  expected, Deadline const &  deadline, uint32_t  waitMask, IdleTime  idleTimeout, size_t  stackToRetain, float  timeoutVariationFrac  )

inlinestaticprivate

Definition at line 167 of file MemoryIdler.h.

References flushLocalMallocCaches(), folly::detail::futexWaitUntil(), futexWaitUntil(), getVariationTimeout(), max, now(), folly::detail::TIMEDOUT, and unmapUnusedStack().

Referenced by futexWait(), and futexWaitUntil().

                                  {
    // idleTimeout < 0 means no flush behavior
    if (idleTimeout < IdleTime::zero()) {
      return false;
    }

    // idleTimeout == 0 means flush immediately, without variation
    // idleTimeout > 0 means flush after delay, with variation
    if (idleTimeout > IdleTime::zero()) {
      idleTimeout = std::max(
          IdleTime::zero(),
          getVariationTimeout(idleTimeout, timeoutVariationFrac));
    }
    if (idleTimeout > IdleTime::zero()) {
      auto idleDeadline = Deadline::clock::now() + idleTimeout;
      if (idleDeadline < deadline) {
        using folly::detail::futexWaitUntil;
        auto rv = futexWaitUntil(&fut, expected, idleDeadline, waitMask);
        if (rv != FutexResult::TIMEDOUT) {
          // finished before timeout hit, no flush
          _ret = rv;
          return true;
        }
      }
    }

    // flush, then wait
    flushLocalMallocCaches();
    unmapUnusedStack(stackToRetain);
    return false;
  }

template<typename Futex , typename Deadline , typename IdleTime = std::chrono::steady_clock::duration>

static FutexResult folly::detail::MemoryIdler::futexWaitUntil ( Futex &  fut, uint32_t  expected, Deadline const &  deadline, uint32_t  waitMask = -1, IdleTime const &  idleTimeout = defaultIdleTimeout.load(std::memory_order_acquire), size_t  stackToRetain = kDefaultStackToRetain, float  timeoutVariationFrac = 0.5  )

inlinestatic

Equivalent to fut.futexWaitUntil(expected, deadline, waitMask), but calls flushLocalMallocCaches() and unmapUnusedStack(stackToRetain) after idleTimeout has passed (if it has passed). Internally uses fut.futexWaitUntil. The actual timeout will be pseudo-randomly chosen to be between idleTimeout and idleTimeout * (1 + timeoutVariationFraction), to smooth out the behavior in a system with bursty requests. The default is to wait up to 50% extra, so on average 25% extra.

Definition at line 139 of file MemoryIdler.h.

References futexWaitPreIdle(), and folly::detail::futexWaitUntil().

Referenced by futexWaitPreIdle(), TEST(), folly::Baton< MayBlock, Atom >::tryWaitSlow(), and folly::SaturatingSemaphore< MayBlock, Atom >::tryWaitSlow().

                                        {
    FutexResult pre;
    if (futexWaitPreIdle(
            pre,
            fut,
            expected,
            deadline,
            waitMask,
            idleTimeout,
            stackToRetain,
            timeoutVariationFrac)) {
      return pre;
    }

    using folly::detail::futexWaitUntil;
    return futexWaitUntil(&fut, expected, deadline, waitMask);
  }

template<typename IdleTime = std::chrono::steady_clock::duration>

static IdleTime folly::detail::MemoryIdler::getVariationTimeout ( IdleTime const &  idleTimeout = defaultIdleTimeout.load(std::memory_order_acquire), float  timeoutVariationFrac = 0.5  )

inlinestatic

Selects a timeout pseudo-randomly chosen to be between idleTimeout and idleTimeout * (1 + timeoutVariationFraction), to smooth out the behavior in a bursty system

Definition at line 70 of file MemoryIdler.h.

References count, folly::getCurrentThreadID(), h, folly::hash::hash_combine(), max, now(), folly::hash::twang_mix64(), and uint64_t.

Referenced by futexWaitPreIdle(), and folly::MemoryIdlerTimeout::runLoopCallback().

                                        {
    if (idleTimeout <= IdleTime::zero() || timeoutVariationFrac <= 0) {
      return idleTimeout;
    }

    // hash the pthread_t and the time to get the adjustment
    // Standard hash func isn't very good, so bit mix the result
    uint64_t h = folly::hash::twang_mix64(folly::hash::hash_combine(
        getCurrentThreadID(),
        std::chrono::system_clock::now().time_since_epoch().count()));

    // multiplying the duration by a floating point doesn't work, grr
    auto extraFrac = timeoutVariationFrac /
        static_cast<float>(std::numeric_limits<uint64_t>::max()) * h;
    auto tics = uint64_t(idleTimeout.count() * (1 + extraFrac));
    return IdleTime(tics);
  }

void folly::detail::MemoryIdler::unmapUnusedStack ( size_t  retain = kDefaultStackToRetain )

static

Uses madvise to discard the portion of the thread's stack that currently doesn't hold any data, trying to ensure that no page faults will occur during the next retain bytes of stack allocation

Definition at line 199 of file MemoryIdler.cpp.

Referenced by BENCHMARK(), flushLocalMallocCaches(), futexWaitPreIdle(), folly::MemoryIdlerTimeout::runLoopCallback(), and TEST().

{}

Member Data Documentation

AtomicStruct< std::chrono::steady_clock::duration > folly::detail::MemoryIdler::defaultIdleTimeout

static

The system-wide default for the amount of time a blocking thread should wait before reclaiming idle memory. Set this to Duration::max() to never wait. The default value is 5 seconds. Endpoints using this idle timeout might randomly wait longer to avoid synchronizing their flushes.

Definition at line 64 of file MemoryIdler.h.

Referenced by folly::MemoryIdlerTimeout::runLoopCallback(), and TEST().

---

The documentation for this struct was generated from the following files:

• proxygen/folly/folly/detail/MemoryIdler.h
• proxygen/folly/folly/detail/MemoryIdler.cpp