folly/test/MemoryIdlerTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   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
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <folly/detail/MemoryIdler.h>
  18
  19 #include <folly/portability/GMock.h>
  20 #include <folly/portability/GTest.h>
  21 #include <folly/synchronization/Baton.h>
  22
  23 #include <memory>
  24 #include <thread>
  25
  26 using namespace folly;
  27 using namespace folly::detail;
  28 using namespace testing;
  29
  30 TEST(MemoryIdler, releaseStack) {
  31   MemoryIdler::unmapUnusedStack();
  32 }
  33
  34 TEST(MemoryIdler, releaseStackMinExtra) {
  35   MemoryIdler::unmapUnusedStack(0);
  36 }
  37
  38 TEST(MemoryIdler, releaseStackLargeExtra) {
  39   MemoryIdler::unmapUnusedStack(30000000);
  40 }
  41
  42 TEST(MemoryIdler, releaseMallocTLS) {
  43   auto p = new int[4];
  44   MemoryIdler::flushLocalMallocCaches();
  45   delete[] p;
  46   MemoryIdler::flushLocalMallocCaches();
  47   p = new int[4];
  48   MemoryIdler::flushLocalMallocCaches();
  49   delete[] p;
  50 }
  51
  52
  53 /// MockedAtom gives us a way to select a mocked Futex implementation
  54 /// inside Baton, even though the atom itself isn't exercised by the
  55 /// mocked futex
  56 template <typename T>
  57 struct MockAtom : public std::atomic<T> {
  58   explicit MockAtom(T init = 0) : std::atomic<T>(init) {}
  59 };
  60
  61
  62 /// MockClock is a bit tricky because we are mocking a static function
  63 /// (now()), so we need to find the corresponding mock instance without
  64 /// extending its scope beyond that of the test.  I generally avoid
  65 /// shared_ptr, but a weak_ptr is just the ticket here
  66 struct MockClock {
  67   typedef std::chrono::steady_clock::duration duration;
  68   typedef std::chrono::steady_clock::time_point time_point;
  69
  70   MOCK_METHOD0(nowImpl, time_point(void));
  71
  72   /// Hold on to the returned shared_ptr until the end of the test
  73   static std::shared_ptr<StrictMock<MockClock>> setup() {
  74     auto rv = std::make_shared<StrictMock<MockClock>>();
  75     s_mockClockInstance = rv;
  76     return rv;
  77   }
  78
  79   static time_point now() {
  80     return s_mockClockInstance.lock()->nowImpl();
  81   }
  82
  83   static std::weak_ptr<StrictMock<MockClock>> s_mockClockInstance;
  84 };
  85
  86 std::weak_ptr<StrictMock<MockClock>> MockClock::s_mockClockInstance;
  87
  88
  89
  90 namespace folly { namespace detail {
  91
  92 /// Futex<MockAtom> is our mocked futex implementation.  Note that the
  93 /// method signatures differ from the real Futex because we have elided
  94 /// unused default params and collapsed templated methods into the
  95 /// used type
  96 template <>
  97 struct Futex<MockAtom> {
  98   MOCK_METHOD2(futexWait, bool(uint32_t, uint32_t));
  99   MOCK_METHOD3(futexWaitUntil,
 100                FutexResult(uint32_t, const MockClock::time_point&, uint32_t));
 101 };
 102
 103 } // namespace detail
 104 } // namespace folly
 105
 106 TEST(MemoryIdler, futexWaitValueChangedEarly) {
 107   StrictMock<Futex<MockAtom>> fut;
 108   auto clock = MockClock::setup();
 109   auto begin = MockClock::time_point(std::chrono::seconds(100));
 110   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 111
 112   EXPECT_CALL(*clock, nowImpl())
 113       .WillOnce(Return(begin));
 114   EXPECT_CALL(fut, futexWaitUntil(1, AllOf(Ge(begin + idleTimeout),
 115                                            Lt(begin + 2 * idleTimeout)), -1))
 116       .WillOnce(Return(FutexResult::VALUE_CHANGED));
 117   EXPECT_FALSE((MemoryIdler::futexWait<MockAtom, MockClock>(fut, 1)));
 118 }
 119
 120 TEST(MemoryIdler, futexWaitValueChangedLate) {
 121   StrictMock<Futex<MockAtom>> fut;
 122   auto clock = MockClock::setup();
 123   auto begin = MockClock::time_point(std::chrono::seconds(100));
 124   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 125
 126   EXPECT_CALL(*clock, nowImpl())
 127       .WillOnce(Return(begin));
 128   EXPECT_CALL(fut, futexWaitUntil(1, AllOf(Ge(begin + idleTimeout),
 129                                            Lt(begin + 2 * idleTimeout)), -1))
 130       .WillOnce(Return(FutexResult::TIMEDOUT));
 131   EXPECT_CALL(fut, futexWait(1, -1))
 132       .WillOnce(Return(false));
 133   EXPECT_FALSE((MemoryIdler::futexWait<MockAtom, MockClock>(fut, 1)));
 134 }
 135
 136 TEST(MemoryIdler, futexWaitAwokenEarly) {
 137   StrictMock<Futex<MockAtom>> fut;
 138   auto clock = MockClock::setup();
 139   auto begin = MockClock::time_point(std::chrono::seconds(100));
 140   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 141
 142   EXPECT_CALL(*clock, nowImpl())
 143       .WillOnce(Return(begin));
 144   EXPECT_CALL(fut, futexWaitUntil(1, Ge(begin + idleTimeout), -1))
 145       .WillOnce(Return(FutexResult::AWOKEN));
 146   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(fut, 1)));
 147 }
 148
 149 TEST(MemoryIdler, futexWaitAwokenLate) {
 150   StrictMock<Futex<MockAtom>> fut;
 151   auto clock = MockClock::setup();
 152   auto begin = MockClock::time_point(std::chrono::seconds(100));
 153   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 154
 155   EXPECT_CALL(*clock, nowImpl())
 156       .WillOnce(Return(begin));
 157   EXPECT_CALL(fut, futexWaitUntil(1, begin + idleTimeout, -1))
 158       .WillOnce(Return(FutexResult::TIMEDOUT));
 159   EXPECT_CALL(fut, futexWait(1, -1))
 160       .WillOnce(Return(true));
 161   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(
 162       fut, 1, -1, idleTimeout, 100, 0.0f)));
 163 }
 164
 165 TEST(MemoryIdler, futexWaitImmediateFlush) {
 166   StrictMock<Futex<MockAtom>> fut;
 167   auto clock = MockClock::setup();
 168
 169   EXPECT_CALL(fut, futexWait(2, 0xff))
 170       .WillOnce(Return(true));
 171   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(
 172       fut, 2, 0xff, std::chrono::seconds(0))));
 173 }
 174
 175 TEST(MemoryIdler, futexWaitNeverFlush) {
 176   StrictMock<Futex<MockAtom>> fut;
 177   auto clock = MockClock::setup();
 178
 179   EXPECT_CALL(fut, futexWait(1, -1))
 180       .WillOnce(Return(true));
 181   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(
 182       fut, 1, -1, MockClock::duration::max())));
 183 }