1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
/*-
* Copyright (c) 2014-2015 MongoDB, Inc.
* Copyright (c) 2008-2014 WiredTiger, Inc.
* All rights reserved.
*
* See the file LICENSE for redistribution information.
*/
/*
* __wt_cache_read_gen --
* Get the current read generation number.
*/
static inline uint64_t
__wt_cache_read_gen(WT_SESSION_IMPL *session)
{
return (S2C(session)->cache->read_gen);
}
/*
* __wt_cache_read_gen_incr --
* Increment the current read generation number.
*/
static inline void
__wt_cache_read_gen_incr(WT_SESSION_IMPL *session)
{
++S2C(session)->cache->read_gen;
}
/*
* __wt_cache_read_gen_set --
* Get the read generation to store in a page.
*/
static inline uint64_t
__wt_cache_read_gen_set(WT_SESSION_IMPL *session)
{
/*
* We return read-generations from the future (where "the future" is
* measured by increments of the global read generation). The reason
* is because when acquiring a new hazard pointer for a page, we can
* check its read generation, and if the read generation isn't less
* than the current global generation, we don't bother updating the
* page. In other words, the goal is to avoid some number of updates
* immediately after each update we have to make.
*/
return (__wt_cache_read_gen(session) + WT_READGEN_STEP);
}
/*
* __wt_cache_pages_inuse --
* Return the number of pages in use.
*/
static inline uint64_t
__wt_cache_pages_inuse(WT_CACHE *cache)
{
return (cache->pages_inmem - cache->pages_evict);
}
/*
* __wt_cache_bytes_inuse --
* Return the number of bytes in use.
*/
static inline uint64_t
__wt_cache_bytes_inuse(WT_CACHE *cache)
{
return (cache->bytes_inmem - cache->bytes_evict);
}
/*
* __wt_eviction_check --
* Wake the eviction server if necessary.
*/
static inline int
__wt_eviction_check(WT_SESSION_IMPL *session, int *fullp, int wake)
{
WT_CACHE *cache;
WT_CONNECTION_IMPL *conn;
uint64_t bytes_inuse, bytes_max, dirty_inuse;
conn = S2C(session);
cache = conn->cache;
/*
* If we're over the maximum cache, shut out reads (which include page
* allocations) until we evict to back under the maximum cache.
* Eviction will keep pushing out pages so we don't run on the edge all
* the time. Avoid division by zero if the cache size has not yet been
* in a shared cache.
*/
bytes_inuse = __wt_cache_bytes_inuse(cache);
dirty_inuse = cache->bytes_dirty;
bytes_max = conn->cache_size + 1;
/* Calculate the cache full percentage. */
*fullp = (int)((100 * bytes_inuse) / bytes_max);
/* Wake eviction when we're over the trigger cache size. */
if (wake &&
(bytes_inuse > (cache->eviction_trigger * bytes_max) / 100 ||
dirty_inuse > (cache->eviction_dirty_target * bytes_max) / 100))
WT_RET(__wt_evict_server_wake(session));
return (0);
}
/*
* __wt_session_can_wait --
* Return if a session available for a potentially slow operation.
*/
static inline int
__wt_session_can_wait(WT_SESSION_IMPL *session)
{
/*
* Return if a session available for a potentially slow operation;
* for example, used by the block manager in the case of flushing
* the system cache.
*/
if (!F_ISSET(session, WT_SESSION_CAN_WAIT))
return (0);
/*
* LSM sets the no-cache-check flag when holding the LSM tree lock,
* in that case, or when holding the schema lock, we don't want to
* highjack the thread for eviction.
*/
if (F_ISSET(session,
WT_SESSION_NO_CACHE_CHECK | WT_SESSION_SCHEMA_LOCKED))
return (0);
return (1);
}
/*
* __wt_cache_full_check --
* Wait for there to be space in the cache before a read or update.
*/
static inline int
__wt_cache_full_check(WT_SESSION_IMPL *session)
{
WT_BTREE *btree;
WT_CACHE *cache;
WT_DECL_RET;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *txn_state;
int busy, count, full;
cache = S2C(session)->cache;
/*
* LSM sets the no-cache-check flag when holding the LSM tree lock, in
* that case, or when holding the schema or handle list locks (which
* block eviction), we don't want to highjack the thread for eviction.
*/
if (F_ISSET(session, WT_SESSION_NO_CACHE_CHECK |
WT_SESSION_SCHEMA_LOCKED | WT_SESSION_HANDLE_LIST_LOCKED))
return (0);
/*
* Threads operating on trees that cannot be evicted are ignored,
* mostly because they're not contributing to the problem.
*/
if ((btree = S2BT_SAFE(session)) != NULL &&
F_ISSET(btree, WT_BTREE_NO_EVICTION))
return (0);
/*
* Only wake the eviction server the first time through here (if the
* cache is too full).
*
* If the cache is less than 95% full, no work to be done.
*/
WT_RET(__wt_eviction_check(session, &full, 1));
if (full < 95)
return (0);
/*
* If we are at the API boundary and the cache is more than 95% full,
* try to evict at least one page before we start an operation. This
* helps with some eviction-dominated workloads.
*
* If the current transaction is keeping the oldest ID pinned, it is in
* the middle of an operation. This may prevent the oldest ID from
* moving forward, leading to deadlock, so only evict what we can.
* Otherwise, we are at a transaction boundary and we can work harder
* to make sure there is free space in the cache.
*/
txn_global = &S2C(session)->txn_global;
txn_state = &txn_global->states[session->id];
busy = txn_state->id != WT_TXN_NONE ||
session->nhazard > 0 ||
(txn_state->snap_min != WT_TXN_NONE &&
txn_global->current != txn_global->oldest_id);
if (busy && full < 100)
return (0);
count = busy ? 1 : 10;
for (;;) {
/*
* A pathological case: if we're the oldest transaction in the
* system and the eviction server is stuck trying to find space,
* abort the transaction to give up all hazard pointers before
* trying again.
*/
if (F_ISSET(cache, WT_EVICT_STUCK) &&
__wt_txn_am_oldest(session)) {
F_CLR(cache, WT_EVICT_STUCK);
WT_STAT_FAST_CONN_INCR(session, txn_fail_cache);
return (WT_ROLLBACK);
}
switch (ret = __wt_evict_lru_page(session, 0)) {
case 0:
if (--count == 0)
return (0);
break;
case EBUSY:
continue;
case WT_NOTFOUND:
break;
default:
return (ret);
}
WT_RET(__wt_eviction_check(session, &full, 0));
if (full < 100)
return (0);
else if (ret == 0)
continue;
/*
* The cache is still full and no pages were found in the queue
* to evict. If this transaction is the one holding back the
* oldest ID, we can't wait forever. We'll block next time we
* are not busy.
*/
if (busy) {
__wt_txn_update_oldest(session);
if (txn_state->id == txn_global->oldest_id ||
txn_state->snap_min == txn_global->oldest_id)
return (0);
}
/* Wait for the queue to re-populate before trying again. */
WT_RET(__wt_cond_wait(session,
S2C(session)->cache->evict_waiter_cond, 100000));
/* Check if things have changed so that we are busy. */
if (!busy && txn_state->snap_min != WT_TXN_NONE &&
txn_global->current != txn_global->oldest_id)
busy = count = 1;
}
}
|
