Support for all clock types in Futex
[folly.git] / folly / test / MemoryIdlerTest.cpp
1 /*
2  * Copyright 2014-present 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 }