2 * Copyright 2017 Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include <folly/detail/MemoryIdler.h>
19 #include <folly/Logging.h>
20 #include <folly/Portability.h>
21 #include <folly/ScopeGuard.h>
22 #include <folly/concurrency/CacheLocality.h>
23 #include <folly/memory/MallctlHelper.h>
24 #include <folly/memory/Malloc.h>
25 #include <folly/portability/PThread.h>
26 #include <folly/portability/SysMman.h>
27 #include <folly/portability/Unistd.h>
28 #include <folly/synchronization/CallOnce.h>
35 namespace folly { namespace detail {
37 AtomicStruct<std::chrono::steady_clock::duration>
38 MemoryIdler::defaultIdleTimeout(std::chrono::seconds(5));
40 void MemoryIdler::flushLocalMallocCaches() {
41 if (!usingJEMalloc()) {
44 if (!mallctl || !mallctlnametomib || !mallctlbymib) {
45 FB_LOG_EVERY_MS(ERROR, 10000) << "mallctl* weak link failed";
50 // Not using mallctlCall as this will fail if tcache is disabled.
51 mallctl("thread.tcache.flush", nullptr, nullptr, nullptr, 0);
53 // By default jemalloc has 4 arenas per cpu, and then assigns each
54 // thread to one of those arenas. This means that in any service
55 // that doesn't perform a lot of context switching, the chances that
56 // another thread will be using the current thread's arena (and hence
57 // doing the appropriate dirty-page purging) are low. Some good
58 // tuned configurations (such as that used by hhvm) use fewer arenas
59 // and then pin threads to avoid contended access. In that case,
60 // purging the arenas is counter-productive. We use the heuristic
61 // that if narenas <= 2 * num_cpus then we shouldn't do anything here,
62 // which detects when the narenas has been reduced from the default
64 unsigned arenaForCurrent;
68 mallctlRead("opt.narenas", &narenas);
69 mallctlRead("thread.arena", &arenaForCurrent);
70 if (narenas > 2 * CacheLocality::system().numCpus &&
71 mallctlnametomib("arena.0.purge", mib, &miblen) == 0) {
72 mib[1] = static_cast<size_t>(arenaForCurrent);
73 mallctlbymib(mib, miblen, nullptr, nullptr, nullptr, 0);
75 } catch (const std::runtime_error& ex) {
76 FB_LOG_EVERY_MS(WARNING, 10000) << ex.what();
81 // Stack madvise isn't Linux or glibc specific, but the system calls
82 // and arithmetic (and bug compatibility) are not portable. The set of
83 // platforms could be increased if it was useful.
84 #if (FOLLY_X64 || FOLLY_PPC64) && defined(_GNU_SOURCE) && \
85 defined(__linux__) && !FOLLY_MOBILE && !FOLLY_SANITIZE_ADDRESS
87 static FOLLY_TLS uintptr_t tls_stackLimit;
88 static FOLLY_TLS size_t tls_stackSize;
90 static size_t pageSize() {
91 static const size_t s_pageSize = sysconf(_SC_PAGESIZE);
95 static void fetchStackLimits() {
98 if ((err = pthread_getattr_np(pthread_self(), &attr))) {
99 // some restricted environments can't access /proc
100 static folly::once_flag flag;
101 folly::call_once(flag, [err]() {
102 LOG(WARNING) << "pthread_getaddr_np failed errno=" << err;
108 SCOPE_EXIT { pthread_attr_destroy(&attr); };
112 if ((err = pthread_attr_getstack(&attr, &addr, &rawSize))) {
113 // unexpected, but it is better to continue in prod than do nothing
114 FB_LOG_EVERY_MS(ERROR, 10000) << "pthread_attr_getstack error " << err;
119 assert(addr != nullptr);
120 assert(rawSize >= PTHREAD_STACK_MIN);
122 // glibc subtracts guard page from stack size, even though pthread docs
123 // seem to imply the opposite
125 if (pthread_attr_getguardsize(&attr, &guardSize) != 0) {
128 assert(rawSize > guardSize);
130 // stack goes down, so guard page adds to the base addr
131 tls_stackLimit = reinterpret_cast<uintptr_t>(addr) + guardSize;
132 tls_stackSize = rawSize - guardSize;
134 assert((tls_stackLimit & (pageSize() - 1)) == 0);
137 FOLLY_NOINLINE static uintptr_t getStackPtr() {
139 auto rv = reinterpret_cast<uintptr_t>(&marker);
143 void MemoryIdler::unmapUnusedStack(size_t retain) {
144 if (tls_stackSize == 0) {
147 if (tls_stackSize <= std::max(static_cast<size_t>(1), retain)) {
148 // covers both missing stack info, and impossibly large retain
152 auto sp = getStackPtr();
153 assert(sp >= tls_stackLimit);
154 assert(sp - tls_stackLimit < tls_stackSize);
156 auto end = (sp - retain) & ~(pageSize() - 1);
157 if (end <= tls_stackLimit) {
158 // no pages are eligible for unmapping
162 size_t len = end - tls_stackLimit;
163 assert((len & (pageSize() - 1)) == 0);
164 if (madvise((void*)tls_stackLimit, len, MADV_DONTNEED) != 0) {
165 // It is likely that the stack vma hasn't been fully grown. In this
166 // case madvise will apply dontneed to the present vmas, then return
167 // errno of ENOMEM. We can also get an EAGAIN, theoretically.
168 // EINVAL means either an invalid alignment or length, or that some
169 // of the pages are locked or shared. Neither should occur.
170 assert(errno == EAGAIN || errno == ENOMEM);
176 void MemoryIdler::unmapUnusedStack(size_t /* retain */) {}
180 } // namespace detail