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/Baton.h>
  20 #include <folly/portability/GMock.h>
  21 #include <folly/portability/GTest.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 }}
 104
 105 TEST(MemoryIdler, futexWaitValueChangedEarly) {
 106   StrictMock<Futex<MockAtom>> fut;
 107   auto clock = MockClock::setup();
 108   auto begin = MockClock::time_point(std::chrono::seconds(100));
 109   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 110
 111   EXPECT_CALL(*clock, nowImpl())
 112       .WillOnce(Return(begin));
 113   EXPECT_CALL(fut, futexWaitUntil(1, AllOf(Ge(begin + idleTimeout),
 114                                            Lt(begin + 2 * idleTimeout)), -1))
 115       .WillOnce(Return(FutexResult::VALUE_CHANGED));
 116   EXPECT_FALSE((MemoryIdler::futexWait<MockAtom, MockClock>(fut, 1)));
 117 }
 118
 119 TEST(MemoryIdler, futexWaitValueChangedLate) {
 120   StrictMock<Futex<MockAtom>> fut;
 121   auto clock = MockClock::setup();
 122   auto begin = MockClock::time_point(std::chrono::seconds(100));
 123   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 124
 125   EXPECT_CALL(*clock, nowImpl())
 126       .WillOnce(Return(begin));
 127   EXPECT_CALL(fut, futexWaitUntil(1, AllOf(Ge(begin + idleTimeout),
 128                                            Lt(begin + 2 * idleTimeout)), -1))
 129       .WillOnce(Return(FutexResult::TIMEDOUT));
 130   EXPECT_CALL(fut, futexWait(1, -1))
 131       .WillOnce(Return(false));
 132   EXPECT_FALSE((MemoryIdler::futexWait<MockAtom, MockClock>(fut, 1)));
 133 }
 134
 135 TEST(MemoryIdler, futexWaitAwokenEarly) {
 136   StrictMock<Futex<MockAtom>> fut;
 137   auto clock = MockClock::setup();
 138   auto begin = MockClock::time_point(std::chrono::seconds(100));
 139   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 140
 141   EXPECT_CALL(*clock, nowImpl())
 142       .WillOnce(Return(begin));
 143   EXPECT_CALL(fut, futexWaitUntil(1, Ge(begin + idleTimeout), -1))
 144       .WillOnce(Return(FutexResult::AWOKEN));
 145   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(fut, 1)));
 146 }
 147
 148 TEST(MemoryIdler, futexWaitAwokenLate) {
 149   StrictMock<Futex<MockAtom>> fut;
 150   auto clock = MockClock::setup();
 151   auto begin = MockClock::time_point(std::chrono::seconds(100));
 152   auto idleTimeout = MemoryIdler::defaultIdleTimeout.load();
 153
 154   EXPECT_CALL(*clock, nowImpl())
 155       .WillOnce(Return(begin));
 156   EXPECT_CALL(fut, futexWaitUntil(1, begin + idleTimeout, -1))
 157       .WillOnce(Return(FutexResult::TIMEDOUT));
 158   EXPECT_CALL(fut, futexWait(1, -1))
 159       .WillOnce(Return(true));
 160   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(
 161       fut, 1, -1, idleTimeout, 100, 0.0f)));
 162 }
 163
 164 TEST(MemoryIdler, futexWaitImmediateFlush) {
 165   StrictMock<Futex<MockAtom>> fut;
 166   auto clock = MockClock::setup();
 167
 168   EXPECT_CALL(fut, futexWait(2, 0xff))
 169       .WillOnce(Return(true));
 170   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(
 171       fut, 2, 0xff, std::chrono::seconds(0))));
 172 }
 173
 174 TEST(MemoryIdler, futexWaitNeverFlush) {
 175   StrictMock<Futex<MockAtom>> fut;
 176   auto clock = MockClock::setup();
 177
 178   EXPECT_CALL(fut, futexWait(1, -1))
 179       .WillOnce(Return(true));
 180   EXPECT_TRUE((MemoryIdler::futexWait<MockAtom, MockClock>(
 181       fut, 1, -1, MockClock::duration::max())));
 182 }