← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/buf/buf0flu.c

  • Committer: Brian Aker
  • Date: 2009-01-24 09:43:35 UTC
  • Revision ID: brian@gir-3.local-20090124094335-6qdtvc35gl5fvivz
Adding in an example singe thread scheduler

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/buf/buf0flu.c
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1995, 2010, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file buf/buf0flu.c
 
1
/******************************************************
21
2
The database buffer buf_pool flush algorithm
22
3
 
 
4
(c) 1995-2001 Innobase Oy
 
5
 
23
6
Created 11/11/1995 Heikki Tuuri
24
7
*******************************************************/
25
8
 
27
10
 
28
11
#ifdef UNIV_NONINL
29
12
#include "buf0flu.ic"
 
13
#include "trx0sys.h"
30
14
#endif
31
15
 
32
 
#include "buf0buf.h"
33
 
#include "srv0srv.h"
34
 
#include "page0zip.h"
35
 
#ifndef UNIV_HOTBACKUP
36
16
#include "ut0byte.h"
37
17
#include "ut0lst.h"
38
18
#include "page0page.h"
 
19
#include "page0zip.h"
39
20
#include "fil0fil.h"
 
21
#include "buf0buf.h"
40
22
#include "buf0lru.h"
41
23
#include "buf0rea.h"
42
24
#include "ibuf0ibuf.h"
43
25
#include "log0log.h"
44
26
#include "os0file.h"
45
27
#include "trx0sys.h"
 
28
#include "srv0srv.h"
46
29
 
 
30
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
47
31
/**********************************************************************
48
 
These statistics are generated for heuristics used in estimating the
49
 
rate at which we should flush the dirty blocks to avoid bursty IO
50
 
activity. Note that the rate of flushing not only depends on how many
51
 
dirty pages we have in the buffer pool but it is also a fucntion of
52
 
how much redo the workload is generating and at what rate. */
53
 
/* @{ */
54
 
 
55
 
/** Number of intervals for which we keep the history of these stats.
56
 
Each interval is 1 second, defined by the rate at which
57
 
srv_error_monitor_thread() calls buf_flush_stat_update(). */
58
 
#define BUF_FLUSH_STAT_N_INTERVAL 20
59
 
 
60
 
/** Sampled values buf_flush_stat_cur.
61
 
Not protected by any mutex.  Updated by buf_flush_stat_update(). */
62
 
static buf_flush_stat_t buf_flush_stat_arr[BUF_FLUSH_STAT_N_INTERVAL];
63
 
 
64
 
/** Cursor to buf_flush_stat_arr[]. Updated in a round-robin fashion. */
65
 
static ulint            buf_flush_stat_arr_ind;
66
 
 
67
 
/** Values at start of the current interval. Reset by
68
 
buf_flush_stat_update(). */
69
 
static buf_flush_stat_t buf_flush_stat_cur;
70
 
 
71
 
/** Running sum of past values of buf_flush_stat_cur.
72
 
Updated by buf_flush_stat_update(). Not protected by any mutex. */
73
 
static buf_flush_stat_t buf_flush_stat_sum;
74
 
 
75
 
/** Number of pages flushed through non flush_list flushes. */
76
 
static ulint buf_lru_flush_page_count = 0;
77
 
 
78
 
/* @} */
79
 
 
80
 
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
81
 
/******************************************************************//**
82
 
Validates the flush list.
83
 
@return TRUE if ok */
 
32
Validates the flush list. */
84
33
static
85
34
ibool
86
 
buf_flush_validate_low(
87
 
/*===================*/
88
 
        buf_pool_t*     buf_pool);      /*!< in: Buffer pool instance */
89
 
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
90
 
 
91
 
/******************************************************************//**
92
 
Insert a block in the flush_rbt and returns a pointer to its
93
 
predecessor or NULL if no predecessor. The ordering is maintained
94
 
on the basis of the <oldest_modification, space, offset> key.
95
 
@return pointer to the predecessor or NULL if no predecessor. */
96
 
static
97
 
buf_page_t*
98
 
buf_flush_insert_in_flush_rbt(
99
 
/*==========================*/
100
 
        buf_page_t*     bpage)  /*!< in: bpage to be inserted. */
101
 
{
102
 
        const ib_rbt_node_t*    c_node;
103
 
        const ib_rbt_node_t*    p_node;
104
 
        buf_page_t*             prev = NULL;
105
 
        buf_pool_t*             buf_pool = buf_pool_from_bpage(bpage);
106
 
 
107
 
        ut_ad(buf_flush_list_mutex_own(buf_pool));
108
 
 
109
 
        /* Insert this buffer into the rbt. */
110
 
        c_node = rbt_insert(buf_pool->flush_rbt, &bpage, &bpage);
111
 
        ut_a(c_node != NULL);
112
 
 
113
 
        /* Get the predecessor. */
114
 
        p_node = rbt_prev(buf_pool->flush_rbt, c_node);
115
 
 
116
 
        if (p_node != NULL) {
117
 
                buf_page_t**    value;
118
 
                value = rbt_value(buf_page_t*, p_node);
119
 
                prev = *value;
120
 
                ut_a(prev != NULL);
121
 
        }
122
 
 
123
 
        return(prev);
124
 
}
125
 
 
126
 
/*********************************************************//**
127
 
Delete a bpage from the flush_rbt. */
128
 
static
129
 
void
130
 
buf_flush_delete_from_flush_rbt(
131
 
/*============================*/
132
 
        buf_page_t*     bpage)  /*!< in: bpage to be removed. */
133
 
{
134
 
#ifdef UNIV_DEBUG
135
 
        ibool           ret = FALSE;
136
 
#endif /* UNIV_DEBUG */
137
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
138
 
 
139
 
        ut_ad(buf_flush_list_mutex_own(buf_pool));
140
 
 
141
 
#ifdef UNIV_DEBUG
142
 
        ret =
143
 
#endif /* UNIV_DEBUG */
144
 
        rbt_delete(buf_pool->flush_rbt, &bpage);
145
 
        ut_ad(ret);
146
 
}
147
 
 
148
 
/*****************************************************************//**
149
 
Compare two modified blocks in the buffer pool. The key for comparison
150
 
is:
151
 
key = <oldest_modification, space, offset>
152
 
This comparison is used to maintian ordering of blocks in the
153
 
buf_pool->flush_rbt.
154
 
Note that for the purpose of flush_rbt, we only need to order blocks
155
 
on the oldest_modification. The other two fields are used to uniquely
156
 
identify the blocks.
157
 
@return  < 0 if b2 < b1, 0 if b2 == b1, > 0 if b2 > b1 */
158
 
static
159
 
int
160
 
buf_flush_block_cmp(
161
 
/*================*/
162
 
        const void*     p1,             /*!< in: block1 */
163
 
        const void*     p2)             /*!< in: block2 */
164
 
{
165
 
        int                     ret;
166
 
        const buf_page_t*       b1 = *(const buf_page_t**) p1;
167
 
        const buf_page_t*       b2 = *(const buf_page_t**) p2;
168
 
#ifdef UNIV_DEBUG
169
 
        buf_pool_t*             buf_pool = buf_pool_from_bpage(b1);
170
 
#endif /* UNIV_DEBUG */
171
 
 
172
 
        ut_ad(b1 != NULL);
173
 
        ut_ad(b2 != NULL);
174
 
 
175
 
        ut_ad(buf_flush_list_mutex_own(buf_pool));
176
 
 
177
 
        ut_ad(b1->in_flush_list);
178
 
        ut_ad(b2->in_flush_list);
179
 
 
180
 
        if (b2->oldest_modification > b1->oldest_modification) {
181
 
                return(1);
182
 
        } else if (b2->oldest_modification < b1->oldest_modification) {
183
 
                return(-1);
184
 
        }
185
 
 
186
 
        /* If oldest_modification is same then decide on the space. */
187
 
        ret = (int)(b2->space - b1->space);
188
 
 
189
 
        /* Or else decide ordering on the offset field. */
190
 
        return(ret ? ret : (int)(b2->offset - b1->offset));
191
 
}
192
 
 
193
 
/********************************************************************//**
194
 
Initialize the red-black tree to speed up insertions into the flush_list
195
 
during recovery process. Should be called at the start of recovery
196
 
process before any page has been read/written. */
197
 
UNIV_INTERN
198
 
void
199
 
buf_flush_init_flush_rbt(void)
200
 
/*==========================*/
201
 
{
202
 
        ulint   i;
203
 
 
204
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
205
 
                buf_pool_t*     buf_pool;
206
 
 
207
 
                buf_pool = buf_pool_from_array(i);
208
 
 
209
 
                buf_flush_list_mutex_enter(buf_pool);
210
 
 
211
 
                /* Create red black tree for speedy insertions in flush list. */
212
 
                buf_pool->flush_rbt = rbt_create(
213
 
                        sizeof(buf_page_t*), buf_flush_block_cmp);
214
 
 
215
 
                buf_flush_list_mutex_exit(buf_pool);
216
 
        }
217
 
}
218
 
 
219
 
/********************************************************************//**
220
 
Frees up the red-black tree. */
221
 
UNIV_INTERN
222
 
void
223
 
buf_flush_free_flush_rbt(void)
224
 
/*==========================*/
225
 
{
226
 
        ulint   i;
227
 
 
228
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
229
 
                buf_pool_t*     buf_pool;
230
 
 
231
 
                buf_pool = buf_pool_from_array(i);
232
 
 
233
 
                buf_flush_list_mutex_enter(buf_pool);
234
 
 
235
 
#ifdef UNIV_DEBUG_VALGRIND
236
 
        {
237
 
                ulint   zip_size = buf_block_get_zip_size(block);
238
 
 
239
 
                if (UNIV_UNLIKELY(zip_size)) {
240
 
                        UNIV_MEM_ASSERT_RW(block->page.zip.data, zip_size);
241
 
                } else {
242
 
                        UNIV_MEM_ASSERT_RW(block->frame, UNIV_PAGE_SIZE);
243
 
                }
244
 
        }
245
 
#endif /* UNIV_DEBUG_VALGRIND */
246
 
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
247
 
                ut_a(buf_flush_validate_low(buf_pool));
248
 
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
249
 
 
250
 
                rbt_free(buf_pool->flush_rbt);
251
 
                buf_pool->flush_rbt = NULL;
252
 
 
253
 
                buf_flush_list_mutex_exit(buf_pool);
254
 
        }
255
 
}
256
 
 
257
 
/********************************************************************//**
 
35
buf_flush_validate_low(void);
 
36
/*========================*/
 
37
                /* out: TRUE if ok */
 
38
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
39
 
 
40
/************************************************************************
258
41
Inserts a modified block into the flush list. */
259
42
UNIV_INTERN
260
43
void
261
44
buf_flush_insert_into_flush_list(
262
45
/*=============================*/
263
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
264
 
        buf_block_t*    block,          /*!< in/out: block which is modified */
265
 
        ib_uint64_t     lsn)            /*!< in: oldest modification */
 
46
        buf_page_t*     bpage)  /* in: block which is modified */
266
47
{
267
 
        ut_ad(!buf_pool_mutex_own(buf_pool));
268
 
        ut_ad(log_flush_order_mutex_own());
269
 
        ut_ad(mutex_own(&block->mutex));
270
 
 
271
 
        buf_flush_list_mutex_enter(buf_pool);
272
 
 
 
48
        ut_ad(buf_pool_mutex_own());
273
49
        ut_ad((UT_LIST_GET_FIRST(buf_pool->flush_list) == NULL)
274
50
              || (UT_LIST_GET_FIRST(buf_pool->flush_list)->oldest_modification
275
 
                  <= lsn));
 
51
                  <= bpage->oldest_modification));
276
52
 
277
 
        /* If we are in the recovery then we need to update the flush
278
 
        red-black tree as well. */
279
 
        if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
280
 
                buf_flush_list_mutex_exit(buf_pool);
281
 
                buf_flush_insert_sorted_into_flush_list(buf_pool, block, lsn);
 
53
        switch (buf_page_get_state(bpage)) {
 
54
        case BUF_BLOCK_ZIP_PAGE:
 
55
                mutex_enter(&buf_pool_zip_mutex);
 
56
                buf_page_set_state(bpage, BUF_BLOCK_ZIP_DIRTY);
 
57
                mutex_exit(&buf_pool_zip_mutex);
 
58
                UT_LIST_REMOVE(list, buf_pool->zip_clean, bpage);
 
59
                /* fall through */
 
60
        case BUF_BLOCK_ZIP_DIRTY:
 
61
        case BUF_BLOCK_FILE_PAGE:
 
62
                ut_ad(bpage->in_LRU_list);
 
63
                ut_ad(bpage->in_page_hash);
 
64
                ut_ad(!bpage->in_zip_hash);
 
65
                ut_ad(!bpage->in_flush_list);
 
66
                ut_d(bpage->in_flush_list = TRUE);
 
67
                UT_LIST_ADD_FIRST(list, buf_pool->flush_list, bpage);
 
68
                break;
 
69
        case BUF_BLOCK_ZIP_FREE:
 
70
        case BUF_BLOCK_NOT_USED:
 
71
        case BUF_BLOCK_READY_FOR_USE:
 
72
        case BUF_BLOCK_MEMORY:
 
73
        case BUF_BLOCK_REMOVE_HASH:
 
74
                ut_error;
282
75
                return;
283
76
        }
284
77
 
285
 
        ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
286
 
        ut_ad(!block->page.in_flush_list);
287
 
 
288
 
        ut_d(block->page.in_flush_list = TRUE);
289
 
        block->page.oldest_modification = lsn;
290
 
        UT_LIST_ADD_FIRST(list, buf_pool->flush_list, &block->page);
291
 
 
292
 
#ifdef UNIV_DEBUG_VALGRIND
293
 
        {
294
 
                ulint   zip_size = buf_block_get_zip_size(block);
295
 
 
296
 
                if (UNIV_UNLIKELY(zip_size)) {
297
 
                        UNIV_MEM_ASSERT_RW(block->page.zip.data, zip_size);
298
 
                } else {
299
 
                        UNIV_MEM_ASSERT_RW(block->frame, UNIV_PAGE_SIZE);
300
 
                }
301
 
        }
302
 
#endif /* UNIV_DEBUG_VALGRIND */
303
78
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
304
 
        ut_a(buf_flush_validate_low(buf_pool));
 
79
        ut_a(buf_flush_validate_low());
305
80
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
306
 
 
307
 
        buf_flush_list_mutex_exit(buf_pool);
308
81
}
309
82
 
310
 
/********************************************************************//**
 
83
/************************************************************************
311
84
Inserts a modified block into the flush list in the right sorted position.
312
85
This function is used by recovery, because there the modifications do not
313
86
necessarily come in the order of lsn's. */
315
88
void
316
89
buf_flush_insert_sorted_into_flush_list(
317
90
/*====================================*/
318
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
319
 
        buf_block_t*    block,          /*!< in/out: block which is modified */
320
 
        ib_uint64_t     lsn)            /*!< in: oldest modification */
 
91
        buf_page_t*     bpage)  /* in: block which is modified */
321
92
{
322
93
        buf_page_t*     prev_b;
323
94
        buf_page_t*     b;
324
95
 
325
 
        ut_ad(!buf_pool_mutex_own(buf_pool));
326
 
        ut_ad(log_flush_order_mutex_own());
327
 
        ut_ad(mutex_own(&block->mutex));
328
 
        ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
329
 
 
330
 
        buf_flush_list_mutex_enter(buf_pool);
331
 
 
332
 
        /* The field in_LRU_list is protected by buf_pool_mutex, which
333
 
        we are not holding.  However, while a block is in the flush
334
 
        list, it is dirty and cannot be discarded, not from the
335
 
        page_hash or from the LRU list.  At most, the uncompressed
336
 
        page frame of a compressed block may be discarded or created
337
 
        (copying the block->page to or from a buf_page_t that is
338
 
        dynamically allocated from buf_buddy_alloc()).  Because those
339
 
        transitions hold block->mutex and the flush list mutex (via
340
 
        buf_flush_relocate_on_flush_list()), there is no possibility
341
 
        of a race condition in the assertions below. */
342
 
        ut_ad(block->page.in_LRU_list);
343
 
        ut_ad(block->page.in_page_hash);
344
 
        /* buf_buddy_block_register() will take a block in the
345
 
        BUF_BLOCK_MEMORY state, not a file page. */
346
 
        ut_ad(!block->page.in_zip_hash);
347
 
 
348
 
        ut_ad(!block->page.in_flush_list);
349
 
        ut_d(block->page.in_flush_list = TRUE);
350
 
        block->page.oldest_modification = lsn;
351
 
 
352
 
#ifdef UNIV_DEBUG_VALGRIND
353
 
        {
354
 
                ulint   zip_size = buf_block_get_zip_size(block);
355
 
 
356
 
                if (UNIV_UNLIKELY(zip_size)) {
357
 
                        UNIV_MEM_ASSERT_RW(block->page.zip.data, zip_size);
358
 
                } else {
359
 
                        UNIV_MEM_ASSERT_RW(block->frame, UNIV_PAGE_SIZE);
360
 
                }
361
 
        }
362
 
#endif /* UNIV_DEBUG_VALGRIND */
363
 
 
364
 
#ifdef UNIV_DEBUG_VALGRIND
365
 
        {
366
 
                ulint   zip_size = buf_block_get_zip_size(block);
367
 
 
368
 
                if (UNIV_UNLIKELY(zip_size)) {
369
 
                        UNIV_MEM_ASSERT_RW(block->page.zip.data, zip_size);
370
 
                } else {
371
 
                        UNIV_MEM_ASSERT_RW(block->frame, UNIV_PAGE_SIZE);
372
 
                }
373
 
        }
374
 
#endif /* UNIV_DEBUG_VALGRIND */
 
96
        ut_ad(buf_pool_mutex_own());
 
97
 
 
98
        switch (buf_page_get_state(bpage)) {
 
99
        case BUF_BLOCK_ZIP_PAGE:
 
100
                mutex_enter(&buf_pool_zip_mutex);
 
101
                buf_page_set_state(bpage, BUF_BLOCK_ZIP_DIRTY);
 
102
                mutex_exit(&buf_pool_zip_mutex);
 
103
                UT_LIST_REMOVE(list, buf_pool->zip_clean, bpage);
 
104
                /* fall through */
 
105
        case BUF_BLOCK_ZIP_DIRTY:
 
106
        case BUF_BLOCK_FILE_PAGE:
 
107
                ut_ad(bpage->in_LRU_list);
 
108
                ut_ad(bpage->in_page_hash);
 
109
                ut_ad(!bpage->in_zip_hash);
 
110
                ut_ad(!bpage->in_flush_list);
 
111
                ut_d(bpage->in_flush_list = TRUE);
 
112
                break;
 
113
        case BUF_BLOCK_ZIP_FREE:
 
114
        case BUF_BLOCK_NOT_USED:
 
115
        case BUF_BLOCK_READY_FOR_USE:
 
116
        case BUF_BLOCK_MEMORY:
 
117
        case BUF_BLOCK_REMOVE_HASH:
 
118
                ut_error;
 
119
                return;
 
120
        }
375
121
 
376
122
        prev_b = NULL;
377
 
 
378
 
        /* For the most part when this function is called the flush_rbt
379
 
        should not be NULL. In a very rare boundary case it is possible
380
 
        that the flush_rbt has already been freed by the recovery thread
381
 
        before the last page was hooked up in the flush_list by the
382
 
        io-handler thread. In that case we'll  just do a simple
383
 
        linear search in the else block. */
384
 
        if (buf_pool->flush_rbt) {
385
 
 
386
 
                prev_b = buf_flush_insert_in_flush_rbt(&block->page);
387
 
 
388
 
        } else {
389
 
 
390
 
                b = UT_LIST_GET_FIRST(buf_pool->flush_list);
391
 
 
392
 
                while (b && b->oldest_modification
393
 
                       > block->page.oldest_modification) {
394
 
                        ut_ad(b->in_flush_list);
395
 
                        prev_b = b;
396
 
                        b = UT_LIST_GET_NEXT(list, b);
397
 
                }
 
123
        b = UT_LIST_GET_FIRST(buf_pool->flush_list);
 
124
 
 
125
        while (b && b->oldest_modification > bpage->oldest_modification) {
 
126
                ut_ad(b->in_flush_list);
 
127
                prev_b = b;
 
128
                b = UT_LIST_GET_NEXT(list, b);
398
129
        }
399
130
 
400
131
        if (prev_b == NULL) {
401
 
                UT_LIST_ADD_FIRST(list, buf_pool->flush_list, &block->page);
 
132
                UT_LIST_ADD_FIRST(list, buf_pool->flush_list, bpage);
402
133
        } else {
403
134
                UT_LIST_INSERT_AFTER(list, buf_pool->flush_list,
404
 
                                     prev_b, &block->page);
 
135
                                     prev_b, bpage);
405
136
        }
406
137
 
407
138
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
408
 
        ut_a(buf_flush_validate_low(buf_pool));
 
139
        ut_a(buf_flush_validate_low());
409
140
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
410
 
 
411
 
        buf_flush_list_mutex_exit(buf_pool);
412
141
}
413
142
 
414
 
/********************************************************************//**
 
143
/************************************************************************
415
144
Returns TRUE if the file page block is immediately suitable for replacement,
416
 
i.e., the transition FILE_PAGE => NOT_USED allowed.
417
 
@return TRUE if can replace immediately */
 
145
i.e., the transition FILE_PAGE => NOT_USED allowed. */
418
146
UNIV_INTERN
419
147
ibool
420
148
buf_flush_ready_for_replace(
421
149
/*========================*/
422
 
        buf_page_t*     bpage)  /*!< in: buffer control block, must be
 
150
                                /* out: TRUE if can replace immediately */
 
151
        buf_page_t*     bpage)  /* in: buffer control block, must be
423
152
                                buf_page_in_file(bpage) and in the LRU list */
424
153
{
425
 
#ifdef UNIV_DEBUG
426
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
427
 
        ut_ad(buf_pool_mutex_own(buf_pool));
428
 
#endif
 
154
        ut_ad(buf_pool_mutex_own());
429
155
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
430
156
        ut_ad(bpage->in_LRU_list);
431
157
 
447
173
        return(FALSE);
448
174
}
449
175
 
450
 
/********************************************************************//**
451
 
Returns TRUE if the block is modified and ready for flushing.
452
 
@return TRUE if can flush immediately */
 
176
/************************************************************************
 
177
Returns TRUE if the block is modified and ready for flushing. */
453
178
UNIV_INLINE
454
179
ibool
455
180
buf_flush_ready_for_flush(
456
181
/*======================*/
457
 
        buf_page_t*     bpage,  /*!< in: buffer control block, must be
 
182
                                /* out: TRUE if can flush immediately */
 
183
        buf_page_t*     bpage,  /* in: buffer control block, must be
458
184
                                buf_page_in_file(bpage) */
459
 
        enum buf_flush  flush_type)/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
 
185
        enum buf_flush  flush_type)/* in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
460
186
{
461
 
#ifdef UNIV_DEBUG
462
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
463
 
        ut_ad(buf_pool_mutex_own(buf_pool));
464
 
#endif
465
187
        ut_a(buf_page_in_file(bpage));
 
188
        ut_ad(buf_pool_mutex_own());
466
189
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
467
 
        ut_ad(flush_type == BUF_FLUSH_LRU || BUF_FLUSH_LIST);
468
190
 
469
191
        if (bpage->oldest_modification != 0
470
192
            && buf_page_get_io_fix(bpage) == BUF_IO_NONE) {
487
209
        return(FALSE);
488
210
}
489
211
 
490
 
/********************************************************************//**
 
212
/************************************************************************
491
213
Remove a block from the flush list of modified blocks. */
492
214
UNIV_INTERN
493
215
void
494
216
buf_flush_remove(
495
217
/*=============*/
496
 
        buf_page_t*     bpage)  /*!< in: pointer to the block in question */
 
218
        buf_page_t*     bpage)  /* in: pointer to the block in question */
497
219
{
498
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
499
 
 
500
 
        ut_ad(buf_pool_mutex_own(buf_pool));
 
220
        ut_ad(buf_pool_mutex_own());
501
221
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
502
222
        ut_ad(bpage->in_flush_list);
503
 
 
504
 
        buf_flush_list_mutex_enter(buf_pool);
 
223
        ut_d(bpage->in_flush_list = FALSE);
505
224
 
506
225
        switch (buf_page_get_state(bpage)) {
507
226
        case BUF_BLOCK_ZIP_PAGE:
508
 
                /* Clean compressed pages should not be on the flush list */
 
227
                /* clean compressed pages should not be on the flush list */
509
228
        case BUF_BLOCK_ZIP_FREE:
510
229
        case BUF_BLOCK_NOT_USED:
511
230
        case BUF_BLOCK_READY_FOR_USE:
523
242
                break;
524
243
        }
525
244
 
526
 
        /* If the flush_rbt is active then delete from there as well. */
527
 
        if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
528
 
                buf_flush_delete_from_flush_rbt(bpage);
529
 
        }
530
 
 
531
 
        /* Must be done after we have removed it from the flush_rbt
532
 
        because we assert on in_flush_list in comparison function. */
533
 
        ut_d(bpage->in_flush_list = FALSE);
534
 
 
535
245
        bpage->oldest_modification = 0;
536
246
 
537
 
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
538
 
        ut_a(buf_flush_validate_low(buf_pool));
539
 
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
540
 
 
541
 
        buf_flush_list_mutex_exit(buf_pool);
542
 
}
543
 
 
544
 
/*******************************************************************//**
545
 
Relocates a buffer control block on the flush_list.
546
 
Note that it is assumed that the contents of bpage have already been
547
 
copied to dpage.
548
 
IMPORTANT: When this function is called bpage and dpage are not
549
 
exact copies of each other. For example, they both will have different
550
 
::state. Also the ::list pointers in dpage may be stale. We need to
551
 
use the current list node (bpage) to do the list manipulation because
552
 
the list pointers could have changed between the time that we copied
553
 
the contents of bpage to the dpage and the flush list manipulation
554
 
below. */
555
 
UNIV_INTERN
556
 
void
557
 
buf_flush_relocate_on_flush_list(
558
 
/*=============================*/
559
 
        buf_page_t*     bpage,  /*!< in/out: control block being moved */
560
 
        buf_page_t*     dpage)  /*!< in/out: destination block */
561
 
{
562
 
        buf_page_t*     prev;
563
 
        buf_page_t*     prev_b = NULL;
564
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
565
 
 
566
 
        ut_ad(buf_pool_mutex_own(buf_pool));
567
 
        /* Must reside in the same buffer pool. */
568
 
        ut_ad(buf_pool == buf_pool_from_bpage(dpage));
569
 
 
570
 
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
571
 
 
572
 
        buf_flush_list_mutex_enter(buf_pool);
573
 
 
574
 
        /* FIXME: At this point we have both buf_pool and flush_list
575
 
        mutexes. Theoretically removal of a block from flush list is
576
 
        only covered by flush_list mutex but currently we do
577
 
        have buf_pool mutex in buf_flush_remove() therefore this block
578
 
        is guaranteed to be in the flush list. We need to check if
579
 
        this will work without the assumption of block removing code
580
 
        having the buf_pool mutex. */
581
 
        ut_ad(bpage->in_flush_list);
582
 
        ut_ad(dpage->in_flush_list);
583
 
 
584
 
        /* If recovery is active we must swap the control blocks in
585
 
        the flush_rbt as well. */
586
 
        if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
587
 
                buf_flush_delete_from_flush_rbt(bpage);
588
 
                prev_b = buf_flush_insert_in_flush_rbt(dpage);
589
 
        }
590
 
 
591
 
        /* Must be done after we have removed it from the flush_rbt
592
 
        because we assert on in_flush_list in comparison function. */
593
 
        ut_d(bpage->in_flush_list = FALSE);
594
 
 
595
 
        prev = UT_LIST_GET_PREV(list, bpage);
596
 
        UT_LIST_REMOVE(list, buf_pool->flush_list, bpage);
597
 
 
598
 
        if (prev) {
599
 
                ut_ad(prev->in_flush_list);
600
 
                UT_LIST_INSERT_AFTER(
601
 
                        list,
602
 
                        buf_pool->flush_list,
603
 
                        prev, dpage);
604
 
        } else {
605
 
                UT_LIST_ADD_FIRST(
606
 
                        list,
607
 
                        buf_pool->flush_list,
608
 
                        dpage);
609
 
        }
610
 
 
611
 
        /* Just an extra check. Previous in flush_list
612
 
        should be the same control block as in flush_rbt. */
613
 
        ut_a(!buf_pool->flush_rbt || prev_b == prev);
614
 
 
615
 
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
616
 
        ut_a(buf_flush_validate_low(buf_pool));
617
 
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
618
 
 
619
 
        buf_flush_list_mutex_exit(buf_pool);
620
 
}
621
 
 
622
 
/********************************************************************//**
 
247
        ut_d(UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list));
 
248
}
 
249
 
 
250
/************************************************************************
623
251
Updates the flush system data structures when a write is completed. */
624
252
UNIV_INTERN
625
253
void
626
254
buf_flush_write_complete(
627
255
/*=====================*/
628
 
        buf_page_t*     bpage)  /*!< in: pointer to the block in question */
 
256
        buf_page_t*     bpage)  /* in: pointer to the block in question */
629
257
{
630
258
        enum buf_flush  flush_type;
631
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
632
259
 
633
260
        ut_ad(bpage);
634
261
 
649
276
        /* fprintf(stderr, "n pending flush %lu\n",
650
277
        buf_pool->n_flush[flush_type]); */
651
278
 
652
 
        if (buf_pool->n_flush[flush_type] == 0
653
 
            && buf_pool->init_flush[flush_type] == FALSE) {
 
279
        if ((buf_pool->n_flush[flush_type] == 0)
 
280
            && (buf_pool->init_flush[flush_type] == FALSE)) {
654
281
 
655
282
                /* The running flush batch has ended */
656
283
 
658
285
        }
659
286
}
660
287
 
661
 
/********************************************************************//**
662
 
Flush a batch of writes to the datafiles that have already been
663
 
written by the OS. */
664
 
static
665
 
void
666
 
buf_flush_sync_datafiles(void)
667
 
/*==========================*/
668
 
{
669
 
        /* Wake possible simulated aio thread to actually post the
670
 
        writes to the operating system */
671
 
        os_aio_simulated_wake_handler_threads();
672
 
 
673
 
        /* Wait that all async writes to tablespaces have been posted to
674
 
        the OS */
675
 
        os_aio_wait_until_no_pending_writes();
676
 
 
677
 
        /* Now we flush the data to disk (for example, with fsync) */
678
 
        fil_flush_file_spaces(FIL_TABLESPACE);
679
 
 
680
 
        return;
681
 
}
682
 
 
683
 
/********************************************************************//**
 
288
/************************************************************************
684
289
Flushes possible buffered writes from the doublewrite memory buffer to disk,
685
290
and also wakes up the aio thread if simulated aio is used. It is very
686
291
important to call this function after a batch of writes has been posted,
697
302
        ulint           i;
698
303
 
699
304
        if (!srv_use_doublewrite_buf || trx_doublewrite == NULL) {
700
 
                /* Sync the writes to the disk. */
701
 
                buf_flush_sync_datafiles();
 
305
                os_aio_simulated_wake_handler_threads();
 
306
 
702
307
                return;
703
308
        }
704
309
 
906
511
                buf_LRU_stat_inc_io();
907
512
        }
908
513
 
909
 
        /* Sync the writes to the disk. */
910
 
        buf_flush_sync_datafiles();
 
514
        /* Wake possible simulated aio thread to actually post the
 
515
        writes to the operating system */
 
516
 
 
517
        os_aio_simulated_wake_handler_threads();
 
518
 
 
519
        /* Wait that all async writes to tablespaces have been posted to
 
520
        the OS */
 
521
 
 
522
        os_aio_wait_until_no_pending_writes();
 
523
 
 
524
        /* Now we flush the data to disk (for example, with fsync) */
 
525
 
 
526
        fil_flush_file_spaces(FIL_TABLESPACE);
911
527
 
912
528
        /* We can now reuse the doublewrite memory buffer: */
 
529
 
913
530
        trx_doublewrite->first_free = 0;
914
531
 
915
532
        mutex_exit(&(trx_doublewrite->mutex));
916
533
}
917
534
 
918
 
/********************************************************************//**
 
535
/************************************************************************
919
536
Posts a buffer page for writing. If the doublewrite memory buffer is
920
537
full, calls buf_flush_buffered_writes and waits for for free space to
921
538
appear. */
923
540
void
924
541
buf_flush_post_to_doublewrite_buf(
925
542
/*==============================*/
926
 
        buf_page_t*     bpage)  /*!< in: buffer block to write */
 
543
        buf_page_t*     bpage)  /* in: buffer block to write */
927
544
{
928
545
        ulint   zip_size;
929
546
try_again:
943
560
        zip_size = buf_page_get_zip_size(bpage);
944
561
 
945
562
        if (UNIV_UNLIKELY(zip_size)) {
946
 
                UNIV_MEM_ASSERT_RW(bpage->zip.data, zip_size);
947
563
                /* Copy the compressed page and clear the rest. */
948
564
                memcpy(trx_doublewrite->write_buf
949
565
                       + UNIV_PAGE_SIZE * trx_doublewrite->first_free,
953
569
                       + zip_size, 0, UNIV_PAGE_SIZE - zip_size);
954
570
        } else {
955
571
                ut_a(buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
956
 
                UNIV_MEM_ASSERT_RW(((buf_block_t*) bpage)->frame,
957
 
                                   UNIV_PAGE_SIZE);
958
572
 
959
573
                memcpy(trx_doublewrite->write_buf
960
574
                       + UNIV_PAGE_SIZE * trx_doublewrite->first_free,
976
590
 
977
591
        mutex_exit(&(trx_doublewrite->mutex));
978
592
}
979
 
#endif /* !UNIV_HOTBACKUP */
980
593
 
981
 
/********************************************************************//**
 
594
/************************************************************************
982
595
Initializes a page for writing to the tablespace. */
983
596
UNIV_INTERN
984
597
void
985
598
buf_flush_init_for_writing(
986
599
/*=======================*/
987
 
        byte*           page,           /*!< in/out: page */
988
 
        void*           page_zip_,      /*!< in/out: compressed page, or NULL */
989
 
        ib_uint64_t     newest_lsn)     /*!< in: newest modification lsn
 
600
        byte*           page,           /* in/out: page */
 
601
        void*           page_zip_,      /* in/out: compressed page, or NULL */
 
602
        ib_uint64_t     newest_lsn)     /* in: newest modification lsn
990
603
                                        to the page */
991
604
{
992
605
        ut_ad(page);
1010
623
                case FIL_PAGE_TYPE_ZBLOB:
1011
624
                case FIL_PAGE_TYPE_ZBLOB2:
1012
625
                case FIL_PAGE_INDEX:
1013
 
                        mach_write_to_8(page_zip->data
1014
 
                                        + FIL_PAGE_LSN, newest_lsn);
 
626
                        mach_write_ull(page_zip->data
 
627
                                       + FIL_PAGE_LSN, newest_lsn);
1015
628
                        memset(page_zip->data + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
1016
629
                        mach_write_to_4(page_zip->data
1017
630
                                        + FIL_PAGE_SPACE_OR_CHKSUM,
1033
646
        }
1034
647
 
1035
648
        /* Write the newest modification lsn to the page header and trailer */
1036
 
        mach_write_to_8(page + FIL_PAGE_LSN, newest_lsn);
 
649
        mach_write_ull(page + FIL_PAGE_LSN, newest_lsn);
1037
650
 
1038
 
        mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
1039
 
                        newest_lsn);
 
651
        mach_write_ull(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
 
652
                       newest_lsn);
1040
653
 
1041
654
        /* Store the new formula checksum */
1042
655
 
1056
669
                        : BUF_NO_CHECKSUM_MAGIC);
1057
670
}
1058
671
 
1059
 
#ifndef UNIV_HOTBACKUP
1060
 
/********************************************************************//**
 
672
/************************************************************************
1061
673
Does an asynchronous write of a buffer page. NOTE: in simulated aio and
1062
674
also when the doublewrite buffer is used, we must call
1063
675
buf_flush_buffered_writes after we have posted a batch of writes! */
1065
677
void
1066
678
buf_flush_write_block_low(
1067
679
/*======================*/
1068
 
        buf_page_t*     bpage)  /*!< in: buffer block to write */
 
680
        buf_page_t*     bpage)  /* in: buffer block to write */
1069
681
{
1070
682
        ulint   zip_size        = buf_page_get_zip_size(bpage);
1071
683
        page_t* frame           = NULL;
1072
 
 
1073
 
#ifdef UNIV_DEBUG
1074
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
1075
 
        ut_ad(!buf_pool_mutex_own(buf_pool));
1076
 
#endif
1077
 
 
1078
684
#ifdef UNIV_LOG_DEBUG
1079
685
        static ibool univ_log_debug_warned;
1080
686
#endif /* UNIV_LOG_DEBUG */
1081
687
 
1082
688
        ut_ad(buf_page_in_file(bpage));
1083
689
 
1084
 
        /* We are not holding buf_pool_mutex or block_mutex here.
1085
 
        Nevertheless, it is safe to access bpage, because it is
1086
 
        io_fixed and oldest_modification != 0.  Thus, it cannot be
1087
 
        relocated in the buffer pool or removed from flush_list or
1088
 
        LRU_list. */
1089
 
        ut_ad(!buf_pool_mutex_own(buf_pool));
1090
 
        ut_ad(!buf_flush_list_mutex_own(buf_pool));
1091
 
        ut_ad(!mutex_own(buf_page_get_mutex(bpage)));
1092
 
        ut_ad(buf_page_get_io_fix(bpage) == BUF_IO_WRITE);
1093
 
        ut_ad(bpage->oldest_modification != 0);
1094
 
 
1095
690
#ifdef UNIV_IBUF_COUNT_DEBUG
1096
691
        ut_a(ibuf_count_get(bpage->space, bpage->offset) == 0);
1097
692
#endif
1124
719
                        ut_a(mach_read_from_4(frame + FIL_PAGE_SPACE_OR_CHKSUM)
1125
720
                             == page_zip_calc_checksum(frame, zip_size));
1126
721
                }
1127
 
                mach_write_to_8(frame + FIL_PAGE_LSN,
1128
 
                                bpage->newest_modification);
 
722
                mach_write_ull(frame + FIL_PAGE_LSN,
 
723
                               bpage->newest_modification);
1129
724
                memset(frame + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
1130
725
                break;
1131
726
        case BUF_BLOCK_FILE_PAGE:
1152
747
        }
1153
748
}
1154
749
 
1155
 
/********************************************************************//**
1156
 
Writes a flushable page asynchronously from the buffer pool to a file.
1157
 
NOTE: in simulated aio we must call
1158
 
os_aio_simulated_wake_handler_threads after we have posted a batch of
1159
 
writes! NOTE: buf_pool->mutex and buf_page_get_mutex(bpage) must be
1160
 
held upon entering this function, and they will be released by this
1161
 
function. */
 
750
/************************************************************************
 
751
Writes a page asynchronously from the buffer buf_pool to a file, if it can be
 
752
found in the buf_pool and it is in a flushable state. NOTE: in simulated aio
 
753
we must call os_aio_simulated_wake_handler_threads after we have posted a batch
 
754
of writes! */
1162
755
static
1163
 
void
1164
 
buf_flush_page(
1165
 
/*===========*/
1166
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1167
 
        buf_page_t*     bpage,          /*!< in: buffer control block */
1168
 
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU
1169
 
                                        or BUF_FLUSH_LIST */
 
756
ulint
 
757
buf_flush_try_page(
 
758
/*===============*/
 
759
                                        /* out: 1 if a page was
 
760
                                        flushed, 0 otherwise */
 
761
        ulint           space,          /* in: space id */
 
762
        ulint           offset,         /* in: page offset */
 
763
        enum buf_flush  flush_type)     /* in: BUF_FLUSH_LRU, BUF_FLUSH_LIST,
 
764
                                        or BUF_FLUSH_SINGLE_PAGE */
1170
765
{
 
766
        buf_page_t*     bpage;
1171
767
        mutex_t*        block_mutex;
1172
 
        ibool           is_uncompressed;
1173
 
 
1174
 
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
1175
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1176
 
        ut_ad(buf_page_in_file(bpage));
1177
 
 
 
768
        ibool           locked;
 
769
 
 
770
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST
 
771
              || flush_type == BUF_FLUSH_SINGLE_PAGE);
 
772
 
 
773
        buf_pool_mutex_enter();
 
774
 
 
775
        bpage = buf_page_hash_get(space, offset);
 
776
 
 
777
        if (!bpage) {
 
778
                buf_pool_mutex_exit();
 
779
                return(0);
 
780
        }
 
781
 
 
782
        ut_a(buf_page_in_file(bpage));
1178
783
        block_mutex = buf_page_get_mutex(bpage);
1179
 
        ut_ad(mutex_own(block_mutex));
1180
 
 
1181
 
        ut_ad(buf_flush_ready_for_flush(bpage, flush_type));
1182
 
 
1183
 
        buf_page_set_io_fix(bpage, BUF_IO_WRITE);
1184
 
 
1185
 
        buf_page_set_flush_type(bpage, flush_type);
1186
 
 
1187
 
        if (buf_pool->n_flush[flush_type] == 0) {
1188
 
 
1189
 
                os_event_reset(buf_pool->no_flush[flush_type]);
 
784
 
 
785
        mutex_enter(block_mutex);
 
786
 
 
787
        if (!buf_flush_ready_for_flush(bpage, flush_type)) {
 
788
                mutex_exit(block_mutex);
 
789
                buf_pool_mutex_exit();
 
790
                return(0);
1190
791
        }
1191
792
 
1192
 
        buf_pool->n_flush[flush_type]++;
1193
 
 
1194
 
        is_uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
1195
 
        ut_ad(is_uncompressed == (block_mutex != &buf_pool->zip_mutex));
1196
 
 
1197
793
        switch (flush_type) {
1198
 
                ibool   is_s_latched;
1199
794
        case BUF_FLUSH_LIST:
 
795
                buf_page_set_io_fix(bpage, BUF_IO_WRITE);
 
796
 
 
797
                buf_page_set_flush_type(bpage, flush_type);
 
798
 
 
799
                if (buf_pool->n_flush[flush_type] == 0) {
 
800
 
 
801
                        os_event_reset(buf_pool->no_flush[flush_type]);
 
802
                }
 
803
 
 
804
                buf_pool->n_flush[flush_type]++;
 
805
 
1200
806
                /* If the simulated aio thread is not running, we must
1201
807
                not wait for any latch, as we may end up in a deadlock:
1202
808
                if buf_fix_count == 0, then we know we need not wait */
1203
809
 
1204
 
                is_s_latched = (bpage->buf_fix_count == 0);
1205
 
                if (is_s_latched && is_uncompressed) {
 
810
                locked = bpage->buf_fix_count == 0;
 
811
                if (locked
 
812
                    && buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE) {
1206
813
                        rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock,
1207
814
                                           BUF_IO_WRITE);
1208
815
                }
1209
816
 
1210
817
                mutex_exit(block_mutex);
1211
 
                buf_pool_mutex_exit(buf_pool);
1212
 
 
1213
 
                /* Even though bpage is not protected by any mutex at
1214
 
                this point, it is safe to access bpage, because it is
1215
 
                io_fixed and oldest_modification != 0.  Thus, it
1216
 
                cannot be relocated in the buffer pool or removed from
1217
 
                flush_list or LRU_list. */
1218
 
 
1219
 
                if (!is_s_latched) {
 
818
                buf_pool_mutex_exit();
 
819
 
 
820
                if (!locked) {
1220
821
                        buf_flush_buffered_writes();
1221
822
 
1222
 
                        if (is_uncompressed) {
 
823
                        if (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE) {
1223
824
                                rw_lock_s_lock_gen(&((buf_block_t*) bpage)
1224
825
                                                   ->lock, BUF_IO_WRITE);
1225
826
                        }
1232
833
                Because any thread may call the LRU flush, even when owning
1233
834
                locks on pages, to avoid deadlocks, we must make sure that the
1234
835
                s-lock is acquired on the page without waiting: this is
1235
 
                accomplished because buf_flush_ready_for_flush() must hold,
1236
 
                and that requires the page not to be bufferfixed. */
1237
 
 
1238
 
                if (is_uncompressed) {
 
836
                accomplished because in the if-condition above we require
 
837
                the page not to be bufferfixed (in function
 
838
                ..._ready_for_flush). */
 
839
 
 
840
                buf_page_set_io_fix(bpage, BUF_IO_WRITE);
 
841
 
 
842
                buf_page_set_flush_type(bpage, flush_type);
 
843
 
 
844
                if (buf_pool->n_flush[flush_type] == 0) {
 
845
 
 
846
                        os_event_reset(buf_pool->no_flush[flush_type]);
 
847
                }
 
848
 
 
849
                buf_pool->n_flush[flush_type]++;
 
850
 
 
851
                if (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE) {
1239
852
                        rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock,
1240
853
                                           BUF_IO_WRITE);
1241
854
                }
1245
858
                immediately. */
1246
859
 
1247
860
                mutex_exit(block_mutex);
1248
 
                buf_pool_mutex_exit(buf_pool);
 
861
                buf_pool_mutex_exit();
 
862
                break;
 
863
 
 
864
        case BUF_FLUSH_SINGLE_PAGE:
 
865
                buf_page_set_io_fix(bpage, BUF_IO_WRITE);
 
866
 
 
867
                buf_page_set_flush_type(bpage, flush_type);
 
868
 
 
869
                if (buf_pool->n_flush[flush_type] == 0) {
 
870
 
 
871
                        os_event_reset(buf_pool->no_flush[flush_type]);
 
872
                }
 
873
 
 
874
                buf_pool->n_flush[flush_type]++;
 
875
 
 
876
                mutex_exit(block_mutex);
 
877
                buf_pool_mutex_exit();
 
878
 
 
879
                if (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE) {
 
880
                        rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock,
 
881
                                           BUF_IO_WRITE);
 
882
                }
1249
883
                break;
1250
884
 
1251
885
        default:
1252
886
                ut_error;
1253
887
        }
1254
888
 
1255
 
        /* Even though bpage is not protected by any mutex at this
1256
 
        point, it is safe to access bpage, because it is io_fixed and
1257
 
        oldest_modification != 0.  Thus, it cannot be relocated in the
1258
 
        buffer pool or removed from flush_list or LRU_list. */
1259
 
 
1260
889
#ifdef UNIV_DEBUG
1261
890
        if (buf_debug_prints) {
1262
891
                fprintf(stderr,
1265
894
        }
1266
895
#endif /* UNIV_DEBUG */
1267
896
        buf_flush_write_block_low(bpage);
 
897
 
 
898
        return(1);
1268
899
}
1269
900
 
1270
 
/***********************************************************//**
1271
 
Flushes to disk all flushable pages within the flush area.
1272
 
@return number of pages flushed */
 
901
/***************************************************************
 
902
Flushes to disk all flushable pages within the flush area. */
1273
903
static
1274
904
ulint
1275
905
buf_flush_try_neighbors(
1276
906
/*====================*/
1277
 
        ulint           space,          /*!< in: space id */
1278
 
        ulint           offset,         /*!< in: page offset */
1279
 
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU or
 
907
                                        /* out: number of pages flushed */
 
908
        ulint           space,          /* in: space id */
 
909
        ulint           offset,         /* in: page offset */
 
910
        enum buf_flush  flush_type)     /* in: BUF_FLUSH_LRU or
1280
911
                                        BUF_FLUSH_LIST */
1281
 
        ulint           n_flushed,      /*!< in: number of pages
1282
 
                                        flushed so far in this batch */
1283
 
        ulint           n_to_flush)     /*!< in: maximum number of pages
1284
 
                                        we are allowed to flush */
1285
912
{
 
913
        buf_page_t*     bpage;
 
914
        ulint           low, high;
 
915
        ulint           count           = 0;
1286
916
        ulint           i;
1287
 
        ulint           low;
1288
 
        ulint           high;
1289
 
        ulint           count = 0;
1290
 
        buf_pool_t*     buf_pool = buf_pool_get(space, offset);
1291
917
 
1292
918
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
1293
919
 
1294
920
        if (UT_LIST_GET_LEN(buf_pool->LRU) < BUF_LRU_OLD_MIN_LEN) {
1295
 
                /* If there is little space, it is better not to flush
1296
 
                any block except from the end of the LRU list */
 
921
                /* If there is little space, it is better not to flush any
 
922
                block except from the end of the LRU list */
1297
923
 
1298
924
                low = offset;
1299
925
                high = offset + 1;
1300
926
        } else {
1301
 
                /* When flushed, dirty blocks are searched in
1302
 
                neighborhoods of this size, and flushed along with the
1303
 
                original page. */
 
927
                /* When flushed, dirty blocks are searched in neighborhoods of
 
928
                this size, and flushed along with the original page. */
1304
929
 
1305
 
                ulint   buf_flush_area;
1306
 
        
1307
 
                buf_flush_area  = ut_min(
1308
 
                        BUF_READ_AHEAD_AREA(buf_pool),
1309
 
                        buf_pool->curr_size / 16);
 
930
                ulint   buf_flush_area  = ut_min(BUF_READ_AHEAD_AREA,
 
931
                                                 buf_pool->curr_size / 16);
1310
932
 
1311
933
                low = (offset / buf_flush_area) * buf_flush_area;
1312
934
                high = (offset / buf_flush_area + 1) * buf_flush_area;
1318
940
                high = fil_space_get_size(space);
1319
941
        }
1320
942
 
 
943
        buf_pool_mutex_enter();
 
944
 
1321
945
        for (i = low; i < high; i++) {
1322
946
 
1323
 
                buf_page_t*     bpage;
1324
 
 
1325
 
                if ((count + n_flushed) >= n_to_flush) {
1326
 
 
1327
 
                        /* We have already flushed enough pages and
1328
 
                        should call it a day. There is, however, one
1329
 
                        exception. If the page whose neighbors we
1330
 
                        are flushing has not been flushed yet then
1331
 
                        we'll try to flush the victim that we
1332
 
                        selected originally. */
1333
 
                        if (i <= offset) {
1334
 
                                i = offset;
1335
 
                        } else {
1336
 
                                break;
1337
 
                        }
1338
 
                }
1339
 
 
1340
 
                buf_pool = buf_pool_get(space, i);
1341
 
 
1342
 
                buf_pool_mutex_enter(buf_pool);
1343
 
 
1344
 
                /* We only want to flush pages from this buffer pool. */
1345
 
                bpage = buf_page_hash_get(buf_pool, space, i);
 
947
                bpage = buf_page_hash_get(space, i);
 
948
                ut_a(!bpage || buf_page_in_file(bpage));
1346
949
 
1347
950
                if (!bpage) {
1348
951
 
1349
 
                        buf_pool_mutex_exit(buf_pool);
1350
 
                        continue;
1351
 
                }
1352
 
 
1353
 
                ut_a(buf_page_in_file(bpage));
1354
 
 
1355
 
                /* We avoid flushing 'non-old' blocks in an LRU flush,
1356
 
                because the flushed blocks are soon freed */
1357
 
 
1358
 
                if (flush_type != BUF_FLUSH_LRU
1359
 
                    || i == offset
1360
 
                    || buf_page_is_old(bpage)) {
 
952
                        continue;
 
953
 
 
954
                } else if (flush_type == BUF_FLUSH_LRU && i != offset
 
955
                           && !buf_page_is_old(bpage)) {
 
956
 
 
957
                        /* We avoid flushing 'non-old' blocks in an LRU flush,
 
958
                        because the flushed blocks are soon freed */
 
959
 
 
960
                        continue;
 
961
                } else {
 
962
 
1361
963
                        mutex_t* block_mutex = buf_page_get_mutex(bpage);
1362
964
 
1363
965
                        mutex_enter(block_mutex);
1365
967
                        if (buf_flush_ready_for_flush(bpage, flush_type)
1366
968
                            && (i == offset || !bpage->buf_fix_count)) {
1367
969
                                /* We only try to flush those
1368
 
                                neighbors != offset where the buf fix
1369
 
                                count is zero, as we then know that we
1370
 
                                probably can latch the page without a
1371
 
                                semaphore wait. Semaphore waits are
1372
 
                                expensive because we must flush the
1373
 
                                doublewrite buffer before we start
 
970
                                neighbors != offset where the buf fix count is
 
971
                                zero, as we then know that we probably can
 
972
                                latch the page without a semaphore wait.
 
973
                                Semaphore waits are expensive because we must
 
974
                                flush the doublewrite buffer before we start
1374
975
                                waiting. */
1375
976
 
1376
 
                                buf_flush_page(buf_pool, bpage, flush_type);
1377
 
                                ut_ad(!mutex_own(block_mutex));
1378
 
                                ut_ad(!buf_pool_mutex_own(buf_pool));
1379
 
                                count++;
1380
 
                                continue;
 
977
                                buf_pool_mutex_exit();
 
978
 
 
979
                                mutex_exit(block_mutex);
 
980
 
 
981
                                /* Note: as we release the buf_pool mutex
 
982
                                above, in buf_flush_try_page we cannot be sure
 
983
                                the page is still in a flushable state:
 
984
                                therefore we check it again inside that
 
985
                                function. */
 
986
 
 
987
                                count += buf_flush_try_page(space, i,
 
988
                                                            flush_type);
 
989
 
 
990
                                buf_pool_mutex_enter();
1381
991
                        } else {
1382
992
                                mutex_exit(block_mutex);
1383
993
                        }
1384
994
                }
1385
 
                buf_pool_mutex_exit(buf_pool);
1386
 
        }
1387
 
 
1388
 
        return(count);
1389
 
}
1390
 
 
1391
 
/********************************************************************//**
1392
 
Check if the block is modified and ready for flushing. If the the block
1393
 
is ready to flush then flush the page and try o flush its neighbors.
1394
 
 
1395
 
@return TRUE if buf_pool mutex was not released during this function.
1396
 
This does not guarantee that some pages were written as well.
1397
 
Number of pages written are incremented to the count. */
1398
 
static
1399
 
ibool
1400
 
buf_flush_page_and_try_neighbors(
1401
 
/*=============================*/
1402
 
        buf_page_t*     bpage,          /*!< in: buffer control block,
1403
 
                                        must be
1404
 
                                        buf_page_in_file(bpage) */
1405
 
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU
1406
 
                                        or BUF_FLUSH_LIST */
1407
 
        ulint           n_to_flush,     /*!< in: number of pages to
1408
 
                                        flush */
1409
 
        ulint*          count)          /*!< in/out: number of pages
1410
 
                                        flushed */
1411
 
{
1412
 
        mutex_t*        block_mutex;
1413
 
        ibool           flushed = FALSE;
1414
 
#ifdef UNIV_DEBUG
1415
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
1416
 
#endif /* UNIV_DEBUG */
1417
 
 
1418
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1419
 
 
1420
 
        block_mutex = buf_page_get_mutex(bpage);
1421
 
        mutex_enter(block_mutex);
1422
 
 
1423
 
        ut_a(buf_page_in_file(bpage));
1424
 
 
1425
 
        if (buf_flush_ready_for_flush(bpage, flush_type)) {
1426
 
                ulint           space;
1427
 
                ulint           offset;
1428
 
                buf_pool_t*     buf_pool;
1429
 
 
1430
 
                buf_pool = buf_pool_from_bpage(bpage);
1431
 
 
1432
 
                buf_pool_mutex_exit(buf_pool);
1433
 
 
1434
 
                /* These fields are protected by both the
1435
 
                buffer pool mutex and block mutex. */
1436
 
                space = buf_page_get_space(bpage);
1437
 
                offset = buf_page_get_page_no(bpage);
1438
 
 
1439
 
                mutex_exit(block_mutex);
1440
 
 
1441
 
                /* Try to flush also all the neighbors */
1442
 
                *count += buf_flush_try_neighbors(space,
1443
 
                                                  offset,
1444
 
                                                  flush_type,
1445
 
                                                  *count,
1446
 
                                                  n_to_flush);
1447
 
 
1448
 
                buf_pool_mutex_enter(buf_pool);
1449
 
                flushed = TRUE;
1450
 
        } else {
1451
 
                mutex_exit(block_mutex);
1452
 
        }
1453
 
 
1454
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1455
 
 
1456
 
        return(flushed);
1457
 
}
1458
 
 
1459
 
/*******************************************************************//**
1460
 
This utility flushes dirty blocks from the end of the LRU list.
1461
 
In the case of an LRU flush the calling thread may own latches to
1462
 
pages: to avoid deadlocks, this function must be written so that it
1463
 
cannot end up waiting for these latches!
1464
 
@return number of blocks for which the write request was queued. */
1465
 
static
1466
 
ulint
1467
 
buf_flush_LRU_list_batch(
1468
 
/*=====================*/
1469
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1470
 
        ulint           max)            /*!< in: max of blocks to flush */
1471
 
{
1472
 
        buf_page_t*     bpage;
1473
 
        ulint           count = 0;
1474
 
 
1475
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1476
 
 
1477
 
        do {
1478
 
                /* Start from the end of the list looking for a
1479
 
                suitable block to be flushed. */
1480
 
                bpage = UT_LIST_GET_LAST(buf_pool->LRU);
1481
 
 
1482
 
                /* Iterate backwards over the flush list till we find
1483
 
                a page that isn't ready for flushing. */
1484
 
                while (bpage != NULL
1485
 
                       && !buf_flush_page_and_try_neighbors(
1486
 
                                bpage, BUF_FLUSH_LRU, max, &count)) {
1487
 
 
1488
 
                        bpage = UT_LIST_GET_PREV(LRU, bpage);
1489
 
                }
1490
 
        } while (bpage != NULL && count < max);
1491
 
 
1492
 
        /* We keep track of all flushes happening as part of LRU
1493
 
        flush. When estimating the desired rate at which flush_list
1494
 
        should be flushed, we factor in this value. */
1495
 
        buf_lru_flush_page_count += count;
1496
 
 
1497
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1498
 
 
1499
 
        return(count);
1500
 
}
1501
 
 
1502
 
/*******************************************************************//**
1503
 
This utility flushes dirty blocks from the end of the flush_list.
1504
 
the calling thread is not allowed to own any latches on pages!
1505
 
@return number of blocks for which the write request was queued;
1506
 
ULINT_UNDEFINED if there was a flush of the same type already
1507
 
running */
1508
 
static
1509
 
ulint
1510
 
buf_flush_flush_list_batch(
1511
 
/*=======================*/
1512
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1513
 
        ulint           min_n,          /*!< in: wished minimum mumber
1514
 
                                        of blocks flushed (it is not
1515
 
                                        guaranteed that the actual
1516
 
                                        number is that big, though) */
1517
 
        ib_uint64_t     lsn_limit)      /*!< all blocks whose
1518
 
                                        oldest_modification is smaller
1519
 
                                        than this should be flushed (if
1520
 
                                        their number does not exceed
1521
 
                                        min_n) */
1522
 
{
1523
 
        ulint           len;
1524
 
        buf_page_t*     bpage;
1525
 
        ulint           count = 0;
1526
 
 
1527
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1528
 
 
1529
 
        /* If we have flushed enough, leave the loop */
1530
 
        do {
1531
 
                /* Start from the end of the list looking for a suitable
1532
 
                block to be flushed. */
1533
 
 
1534
 
                buf_flush_list_mutex_enter(buf_pool);
1535
 
 
1536
 
                /* We use len here because theoretically insertions can
1537
 
                happen in the flush_list below while we are traversing
1538
 
                it for a suitable candidate for flushing. We'd like to
1539
 
                set a limit on how farther we are willing to traverse
1540
 
                the list. */
1541
 
                len = UT_LIST_GET_LEN(buf_pool->flush_list);
1542
 
                bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
1543
 
 
1544
 
                if (bpage) {
1545
 
                        ut_a(bpage->oldest_modification > 0);
1546
 
                }
1547
 
 
1548
 
                if (!bpage || bpage->oldest_modification >= lsn_limit) {
1549
 
 
1550
 
                        /* We have flushed enough */
1551
 
                        buf_flush_list_mutex_exit(buf_pool);
1552
 
                        break;
1553
 
                }
1554
 
 
1555
 
                ut_a(bpage->oldest_modification > 0);
1556
 
 
1557
 
                ut_ad(bpage->in_flush_list);
1558
 
 
1559
 
                buf_flush_list_mutex_exit(buf_pool);
1560
 
 
1561
 
                /* The list may change during the flushing and we cannot
1562
 
                safely preserve within this function a pointer to a
1563
 
                block in the list! */
1564
 
                while (bpage != NULL
1565
 
                       && len > 0
1566
 
                       && !buf_flush_page_and_try_neighbors(
1567
 
                                bpage, BUF_FLUSH_LIST, min_n, &count)) {
1568
 
 
1569
 
                        buf_flush_list_mutex_enter(buf_pool);
1570
 
 
1571
 
                        /* If we are here that means that buf_pool->mutex
1572
 
                         was not released in buf_flush_page_and_try_neighbors()
1573
 
                        above and this guarantees that bpage didn't get
1574
 
                        relocated since we released the flush_list
1575
 
                        mutex above. There is a chance, however, that
1576
 
                        the bpage got removed from flush_list (not
1577
 
                        currently possible because flush_list_remove()
1578
 
                        also obtains buf_pool mutex but that may change
1579
 
                        in future). To avoid this scenario we check
1580
 
                        the oldest_modification and if it is zero
1581
 
                        we start all over again. */
1582
 
                        if (bpage->oldest_modification == 0) {
1583
 
                                buf_flush_list_mutex_exit(buf_pool);
1584
 
                                break;
1585
 
                        }
1586
 
 
1587
 
                        bpage = UT_LIST_GET_PREV(list, bpage);
1588
 
 
1589
 
                        ut_ad(!bpage || bpage->in_flush_list);
1590
 
 
1591
 
                        buf_flush_list_mutex_exit(buf_pool);
1592
 
 
1593
 
                        --len;
1594
 
                }
1595
 
 
1596
 
        } while (count < min_n && bpage != NULL && len > 0);
1597
 
 
1598
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1599
 
 
1600
 
        return(count);
1601
 
}
1602
 
 
1603
 
/*******************************************************************//**
 
995
        }
 
996
 
 
997
        buf_pool_mutex_exit();
 
998
 
 
999
        return(count);
 
1000
}
 
1001
 
 
1002
/***********************************************************************
1604
1003
This utility flushes dirty blocks from the end of the LRU list or flush_list.
1605
1004
NOTE 1: in the case of an LRU flush the calling thread may own latches to
1606
1005
pages: to avoid deadlocks, this function must be written so that it cannot
1607
1006
end up waiting for these latches! NOTE 2: in the case of a flush list flush,
1608
 
the calling thread is not allowed to own any latches on pages!
1609
 
@return number of blocks for which the write request was queued;
1610
 
ULINT_UNDEFINED if there was a flush of the same type already running */
1611
 
static
 
1007
the calling thread is not allowed to own any latches on pages! */
 
1008
UNIV_INTERN
1612
1009
ulint
1613
1010
buf_flush_batch(
1614
1011
/*============*/
1615
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1616
 
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU or
 
1012
                                        /* out: number of blocks for which the
 
1013
                                        write request was queued;
 
1014
                                        ULINT_UNDEFINED if there was a flush
 
1015
                                        of the same type already running */
 
1016
        enum buf_flush  flush_type,     /* in: BUF_FLUSH_LRU or
1617
1017
                                        BUF_FLUSH_LIST; if BUF_FLUSH_LIST,
1618
1018
                                        then the caller must not own any
1619
1019
                                        latches on pages */
1620
 
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
 
1020
        ulint           min_n,          /* in: wished minimum mumber of blocks
1621
1021
                                        flushed (it is not guaranteed that the
1622
1022
                                        actual number is that big, though) */
1623
 
        ib_uint64_t     lsn_limit)      /*!< in: in the case of BUF_FLUSH_LIST
1624
 
                                        all blocks whose oldest_modification is
 
1023
        ib_uint64_t     lsn_limit)      /* in the case BUF_FLUSH_LIST all
 
1024
                                        blocks whose oldest_modification is
1625
1025
                                        smaller than this should be flushed
1626
1026
                                        (if their number does not exceed
1627
1027
                                        min_n), otherwise ignored */
1628
1028
{
1629
 
        ulint           count   = 0;
 
1029
        buf_page_t*     bpage;
 
1030
        ulint           page_count      = 0;
 
1031
        ulint           old_page_count;
 
1032
        ulint           space;
 
1033
        ulint           offset;
1630
1034
 
1631
 
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 
1035
        ut_ad((flush_type == BUF_FLUSH_LRU)
 
1036
              || (flush_type == BUF_FLUSH_LIST));
1632
1037
#ifdef UNIV_SYNC_DEBUG
1633
1038
        ut_ad((flush_type != BUF_FLUSH_LIST)
1634
1039
              || sync_thread_levels_empty_gen(TRUE));
1635
1040
#endif /* UNIV_SYNC_DEBUG */
1636
 
 
1637
 
        buf_pool_mutex_enter(buf_pool);
1638
 
 
1639
 
        /* Note: The buffer pool mutex is released and reacquired within
1640
 
        the flush functions. */
1641
 
        switch(flush_type) {
1642
 
        case BUF_FLUSH_LRU:
1643
 
                count = buf_flush_LRU_list_batch(buf_pool, min_n);
1644
 
                break;
1645
 
        case BUF_FLUSH_LIST:
1646
 
                count = buf_flush_flush_list_batch(buf_pool, min_n, lsn_limit);
1647
 
                break;
1648
 
        default:
1649
 
                ut_error;
1650
 
        }
1651
 
 
1652
 
        buf_pool_mutex_exit(buf_pool);
1653
 
 
1654
 
        buf_flush_buffered_writes();
1655
 
 
1656
 
#ifdef UNIV_DEBUG
1657
 
        if (buf_debug_prints && count > 0) {
1658
 
                fprintf(stderr, flush_type == BUF_FLUSH_LRU
1659
 
                        ? "Flushed %lu pages in LRU flush\n"
1660
 
                        : "Flushed %lu pages in flush list flush\n",
1661
 
                        (ulong) count);
1662
 
        }
1663
 
#endif /* UNIV_DEBUG */
1664
 
 
1665
 
        srv_buf_pool_flushed += count;
1666
 
 
1667
 
        return(count);
1668
 
}
1669
 
 
1670
 
/******************************************************************//**
1671
 
Gather the aggregated stats for both flush list and LRU list flushing */
1672
 
static
1673
 
void
1674
 
buf_flush_common(
1675
 
/*=============*/
1676
 
        enum buf_flush  flush_type,     /*!< in: type of flush */
1677
 
        ulint           page_count)     /*!< in: number of pages flushed */
1678
 
{
1679
 
        buf_flush_buffered_writes();
1680
 
 
1681
 
        ut_a(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 
1041
        buf_pool_mutex_enter();
 
1042
 
 
1043
        if ((buf_pool->n_flush[flush_type] > 0)
 
1044
            || (buf_pool->init_flush[flush_type] == TRUE)) {
 
1045
 
 
1046
                /* There is already a flush batch of the same type running */
 
1047
 
 
1048
                buf_pool_mutex_exit();
 
1049
 
 
1050
                return(ULINT_UNDEFINED);
 
1051
        }
 
1052
 
 
1053
        buf_pool->init_flush[flush_type] = TRUE;
 
1054
 
 
1055
        for (;;) {
 
1056
flush_next:
 
1057
                /* If we have flushed enough, leave the loop */
 
1058
                if (page_count >= min_n) {
 
1059
 
 
1060
                        break;
 
1061
                }
 
1062
 
 
1063
                /* Start from the end of the list looking for a suitable
 
1064
                block to be flushed. */
 
1065
 
 
1066
                if (flush_type == BUF_FLUSH_LRU) {
 
1067
                        bpage = UT_LIST_GET_LAST(buf_pool->LRU);
 
1068
                } else {
 
1069
                        ut_ad(flush_type == BUF_FLUSH_LIST);
 
1070
 
 
1071
                        bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
 
1072
                        if (!bpage
 
1073
                            || bpage->oldest_modification >= lsn_limit) {
 
1074
                                /* We have flushed enough */
 
1075
 
 
1076
                                break;
 
1077
                        }
 
1078
                        ut_ad(bpage->in_flush_list);
 
1079
                }
 
1080
 
 
1081
                /* Note that after finding a single flushable page, we try to
 
1082
                flush also all its neighbors, and after that start from the
 
1083
                END of the LRU list or flush list again: the list may change
 
1084
                during the flushing and we cannot safely preserve within this
 
1085
                function a pointer to a block in the list! */
 
1086
 
 
1087
                do {
 
1088
                        mutex_t* block_mutex = buf_page_get_mutex(bpage);
 
1089
 
 
1090
                        ut_a(buf_page_in_file(bpage));
 
1091
 
 
1092
                        mutex_enter(block_mutex);
 
1093
 
 
1094
                        if (buf_flush_ready_for_flush(bpage, flush_type)) {
 
1095
 
 
1096
                                space = buf_page_get_space(bpage);
 
1097
                                offset = buf_page_get_page_no(bpage);
 
1098
 
 
1099
                                buf_pool_mutex_exit();
 
1100
                                mutex_exit(block_mutex);
 
1101
 
 
1102
                                old_page_count = page_count;
 
1103
 
 
1104
                                /* Try to flush also all the neighbors */
 
1105
                                page_count += buf_flush_try_neighbors(
 
1106
                                        space, offset, flush_type);
 
1107
                                /* fprintf(stderr,
 
1108
                                "Flush type %lu, page no %lu, neighb %lu\n",
 
1109
                                flush_type, offset,
 
1110
                                page_count - old_page_count); */
 
1111
 
 
1112
                                buf_pool_mutex_enter();
 
1113
                                goto flush_next;
 
1114
 
 
1115
                        } else if (flush_type == BUF_FLUSH_LRU) {
 
1116
 
 
1117
                                mutex_exit(block_mutex);
 
1118
 
 
1119
                                bpage = UT_LIST_GET_PREV(LRU, bpage);
 
1120
                        } else {
 
1121
                                ut_ad(flush_type == BUF_FLUSH_LIST);
 
1122
 
 
1123
                                mutex_exit(block_mutex);
 
1124
 
 
1125
                                bpage = UT_LIST_GET_PREV(list, bpage);
 
1126
                                ut_ad(!bpage || bpage->in_flush_list);
 
1127
                        }
 
1128
                } while (bpage != NULL);
 
1129
 
 
1130
                /* If we could not find anything to flush, leave the loop */
 
1131
 
 
1132
                break;
 
1133
        }
 
1134
 
 
1135
        buf_pool->init_flush[flush_type] = FALSE;
 
1136
 
 
1137
        if ((buf_pool->n_flush[flush_type] == 0)
 
1138
            && (buf_pool->init_flush[flush_type] == FALSE)) {
 
1139
 
 
1140
                /* The running flush batch has ended */
 
1141
 
 
1142
                os_event_set(buf_pool->no_flush[flush_type]);
 
1143
        }
 
1144
 
 
1145
        buf_pool_mutex_exit();
 
1146
 
 
1147
        buf_flush_buffered_writes();
1682
1148
 
1683
1149
#ifdef UNIV_DEBUG
1684
1150
        if (buf_debug_prints && page_count > 0) {
 
1151
                ut_a(flush_type == BUF_FLUSH_LRU
 
1152
                     || flush_type == BUF_FLUSH_LIST);
1685
1153
                fprintf(stderr, flush_type == BUF_FLUSH_LRU
1686
1154
                        ? "Flushed %lu pages in LRU flush\n"
1687
1155
                        : "Flushed %lu pages in flush list flush\n",
1691
1159
 
1692
1160
        srv_buf_pool_flushed += page_count;
1693
1161
 
1694
 
        if (flush_type == BUF_FLUSH_LRU) {
1695
 
                /* We keep track of all flushes happening as part of LRU
1696
 
                flush. When estimating the desired rate at which flush_list
1697
 
                should be flushed we factor in this value. */
1698
 
                buf_lru_flush_page_count += page_count;
1699
 
        }
1700
 
}
1701
 
 
1702
 
/******************************************************************//**
1703
 
Start a buffer flush batch for LRU or flush list */
1704
 
static
1705
 
ibool
1706
 
buf_flush_start(
1707
 
/*============*/
1708
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1709
 
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU
1710
 
                                        or BUF_FLUSH_LIST */
1711
 
{
1712
 
        buf_pool_mutex_enter(buf_pool);
1713
 
 
1714
 
        if (buf_pool->n_flush[flush_type] > 0
1715
 
           || buf_pool->init_flush[flush_type] == TRUE) {
1716
 
 
1717
 
                /* There is already a flush batch of the same type running */
1718
 
 
1719
 
                buf_pool_mutex_exit(buf_pool);
1720
 
 
1721
 
                return(FALSE);
1722
 
        }
1723
 
 
1724
 
        buf_pool->init_flush[flush_type] = TRUE;
1725
 
 
1726
 
        buf_pool_mutex_exit(buf_pool);
1727
 
 
1728
 
        return(TRUE);
1729
 
}
1730
 
 
1731
 
/******************************************************************//**
1732
 
End a buffer flush batch for LRU or flush list */
1733
 
static
1734
 
void
1735
 
buf_flush_end(
1736
 
/*==========*/
1737
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1738
 
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU
1739
 
                                        or BUF_FLUSH_LIST */
1740
 
{
1741
 
        buf_pool_mutex_enter(buf_pool);
1742
 
 
1743
 
        buf_pool->init_flush[flush_type] = FALSE;
1744
 
 
1745
 
        if (buf_pool->n_flush[flush_type] == 0) {
1746
 
 
1747
 
                /* The running flush batch has ended */
1748
 
 
1749
 
                os_event_set(buf_pool->no_flush[flush_type]);
1750
 
        }
1751
 
 
1752
 
        buf_pool_mutex_exit(buf_pool);
1753
 
}
1754
 
 
1755
 
/******************************************************************//**
 
1162
        return(page_count);
 
1163
}
 
1164
 
 
1165
/**********************************************************************
1756
1166
Waits until a flush batch of the given type ends */
1757
1167
UNIV_INTERN
1758
1168
void
1759
1169
buf_flush_wait_batch_end(
1760
1170
/*=====================*/
1761
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1762
 
        enum buf_flush  type)           /*!< in: BUF_FLUSH_LRU
1763
 
                                        or BUF_FLUSH_LIST */
1764
 
{
1765
 
        ut_ad(type == BUF_FLUSH_LRU || type == BUF_FLUSH_LIST);
1766
 
 
1767
 
        if (buf_pool == NULL) {
1768
 
                ulint   i;
1769
 
 
1770
 
                for (i = 0; i < srv_buf_pool_instances; ++i) {
1771
 
                        buf_pool_t*     buf_pool;
1772
 
 
1773
 
                        buf_pool = buf_pool_from_array(i);
1774
 
 
1775
 
                        os_event_wait(buf_pool->no_flush[type]);
1776
 
                }
1777
 
        } else {
1778
 
                os_event_wait(buf_pool->no_flush[type]);
1779
 
        }
1780
 
}
1781
 
 
1782
 
/*******************************************************************//**
1783
 
This utility flushes dirty blocks from the end of the LRU list.
1784
 
NOTE: The calling thread may own latches to pages: to avoid deadlocks,
1785
 
this function must be written so that it cannot end up waiting for these
1786
 
latches!
1787
 
@return number of blocks for which the write request was queued;
1788
 
ULINT_UNDEFINED if there was a flush of the same type already running */
1789
 
UNIV_INTERN
1790
 
ulint
1791
 
buf_flush_LRU(
1792
 
/*==========*/
1793
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1794
 
        ulint           min_n)          /*!< in: wished minimum mumber of blocks
1795
 
                                        flushed (it is not guaranteed that the
1796
 
                                        actual number is that big, though) */
1797
 
{
1798
 
        ulint           page_count;
1799
 
 
1800
 
        if (!buf_flush_start(buf_pool, BUF_FLUSH_LRU)) {
1801
 
                return(ULINT_UNDEFINED);
1802
 
        }
1803
 
 
1804
 
        page_count = buf_flush_batch(buf_pool, BUF_FLUSH_LRU, min_n, 0);
1805
 
 
1806
 
        buf_flush_end(buf_pool, BUF_FLUSH_LRU);
1807
 
 
1808
 
        buf_flush_common(BUF_FLUSH_LRU, page_count);
1809
 
 
1810
 
        return(page_count);
1811
 
}
1812
 
 
1813
 
/*******************************************************************//**
1814
 
This utility flushes dirty blocks from the end of the flush list of
1815
 
all buffer pool instances.
1816
 
NOTE: The calling thread is not allowed to own any latches on pages!
1817
 
@return number of blocks for which the write request was queued;
1818
 
ULINT_UNDEFINED if there was a flush of the same type already running */
1819
 
UNIV_INTERN
1820
 
ulint
1821
 
buf_flush_list(
1822
 
/*===========*/
1823
 
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
1824
 
                                        flushed (it is not guaranteed that the
1825
 
                                        actual number is that big, though) */
1826
 
        ib_uint64_t     lsn_limit)      /*!< in the case BUF_FLUSH_LIST all
1827
 
                                        blocks whose oldest_modification is
1828
 
                                        smaller than this should be flushed
1829
 
                                        (if their number does not exceed
1830
 
                                        min_n), otherwise ignored */
1831
 
{
1832
 
        ulint           i;
1833
 
        ulint           total_page_count = 0;
1834
 
        ibool           skipped = FALSE;
1835
 
 
1836
 
        if (min_n != ULINT_MAX) {
1837
 
                /* Ensure that flushing is spread evenly amongst the
1838
 
                buffer pool instances. When min_n is ULINT_MAX
1839
 
                we need to flush everything up to the lsn limit
1840
 
                so no limit here. */
1841
 
                min_n = (min_n + srv_buf_pool_instances - 1)
1842
 
                         / srv_buf_pool_instances;
1843
 
        }
1844
 
 
1845
 
        /* Flush to lsn_limit in all buffer pool instances */
1846
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
1847
 
                buf_pool_t*     buf_pool;
1848
 
                ulint           page_count = 0;
1849
 
 
1850
 
                buf_pool = buf_pool_from_array(i);
1851
 
 
1852
 
                if (!buf_flush_start(buf_pool, BUF_FLUSH_LIST)) {
1853
 
                        /* We have two choices here. If lsn_limit was
1854
 
                        specified then skipping an instance of buffer
1855
 
                        pool means we cannot guarantee that all pages
1856
 
                        up to lsn_limit has been flushed. We can
1857
 
                        return right now with failure or we can try
1858
 
                        to flush remaining buffer pools up to the
1859
 
                        lsn_limit. We attempt to flush other buffer
1860
 
                        pools based on the assumption that it will
1861
 
                        help in the retry which will follow the
1862
 
                        failure. */
1863
 
                        skipped = TRUE;
1864
 
 
1865
 
                        continue;
1866
 
                }
1867
 
 
1868
 
                page_count = buf_flush_batch(
1869
 
                        buf_pool, BUF_FLUSH_LIST, min_n, lsn_limit);
1870
 
 
1871
 
                buf_flush_end(buf_pool, BUF_FLUSH_LIST);
1872
 
 
1873
 
                buf_flush_common(BUF_FLUSH_LIST, page_count);
1874
 
 
1875
 
                total_page_count += page_count;
1876
 
        }
1877
 
 
1878
 
        return(lsn_limit != IB_ULONGLONG_MAX && skipped
1879
 
               ? ULINT_UNDEFINED : total_page_count);
1880
 
}
1881
 
 
1882
 
/******************************************************************//**
 
1171
        enum buf_flush  type)   /* in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
 
1172
{
 
1173
        ut_ad((type == BUF_FLUSH_LRU) || (type == BUF_FLUSH_LIST));
 
1174
 
 
1175
        os_event_wait(buf_pool->no_flush[type]);
 
1176
}
 
1177
 
 
1178
/**********************************************************************
1883
1179
Gives a recommendation of how many blocks should be flushed to establish
1884
1180
a big enough margin of replaceable blocks near the end of the LRU list
1885
 
and in the free list.
1886
 
@return number of blocks which should be flushed from the end of the
1887
 
LRU list */
 
1181
and in the free list. */
1888
1182
static
1889
1183
ulint
1890
 
buf_flush_LRU_recommendation(
1891
 
/*=========================*/
1892
 
        buf_pool_t*     buf_pool)               /*!< in: Buffer pool instance */
 
1184
buf_flush_LRU_recommendation(void)
 
1185
/*==============================*/
 
1186
                        /* out: number of blocks which should be flushed
 
1187
                        from the end of the LRU list */
1893
1188
{
1894
1189
        buf_page_t*     bpage;
1895
1190
        ulint           n_replaceable;
1896
1191
        ulint           distance        = 0;
1897
1192
 
1898
 
        buf_pool_mutex_enter(buf_pool);
 
1193
        buf_pool_mutex_enter();
1899
1194
 
1900
1195
        n_replaceable = UT_LIST_GET_LEN(buf_pool->free);
1901
1196
 
1902
1197
        bpage = UT_LIST_GET_LAST(buf_pool->LRU);
1903
1198
 
1904
1199
        while ((bpage != NULL)
1905
 
               && (n_replaceable < BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)
1906
 
                   + BUF_FLUSH_EXTRA_MARGIN(buf_pool))
1907
 
               && (distance < BUF_LRU_FREE_SEARCH_LEN(buf_pool))) {
 
1200
               && (n_replaceable < BUF_FLUSH_FREE_BLOCK_MARGIN
 
1201
                   + BUF_FLUSH_EXTRA_MARGIN)
 
1202
               && (distance < BUF_LRU_FREE_SEARCH_LEN)) {
1908
1203
 
1909
1204
                mutex_t* block_mutex = buf_page_get_mutex(bpage);
1910
1205
 
1921
1216
                bpage = UT_LIST_GET_PREV(LRU, bpage);
1922
1217
        }
1923
1218
 
1924
 
        buf_pool_mutex_exit(buf_pool);
 
1219
        buf_pool_mutex_exit();
1925
1220
 
1926
 
        if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)) {
 
1221
        if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN) {
1927
1222
 
1928
1223
                return(0);
1929
1224
        }
1930
1225
 
1931
 
        return(BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)
1932
 
               + BUF_FLUSH_EXTRA_MARGIN(buf_pool)
 
1226
        return(BUF_FLUSH_FREE_BLOCK_MARGIN + BUF_FLUSH_EXTRA_MARGIN
1933
1227
               - n_replaceable);
1934
1228
}
1935
1229
 
1936
 
/*********************************************************************//**
 
1230
/*************************************************************************
1937
1231
Flushes pages from the end of the LRU list if there is too small a margin
1938
1232
of replaceable pages there or in the free list. VERY IMPORTANT: this function
1939
1233
is called also by threads which have locks on pages. To avoid deadlocks, we
1941
1235
immediately, without waiting. */
1942
1236
UNIV_INTERN
1943
1237
void
1944
 
buf_flush_free_margin(
1945
 
/*==================*/
1946
 
        buf_pool_t*     buf_pool)               /*!< in: Buffer pool instance */
 
1238
buf_flush_free_margin(void)
 
1239
/*=======================*/
1947
1240
{
1948
1241
        ulint   n_to_flush;
 
1242
        ulint   n_flushed;
1949
1243
 
1950
 
        n_to_flush = buf_flush_LRU_recommendation(buf_pool);
 
1244
        n_to_flush = buf_flush_LRU_recommendation();
1951
1245
 
1952
1246
        if (n_to_flush > 0) {
1953
 
                ulint   n_flushed;
1954
 
 
1955
 
                n_flushed = buf_flush_LRU(buf_pool, n_to_flush);
1956
 
 
 
1247
                n_flushed = buf_flush_batch(BUF_FLUSH_LRU, n_to_flush, 0);
1957
1248
                if (n_flushed == ULINT_UNDEFINED) {
1958
1249
                        /* There was an LRU type flush batch already running;
1959
1250
                        let us wait for it to end */
1960
1251
 
1961
 
                        buf_flush_wait_batch_end(buf_pool, BUF_FLUSH_LRU);
 
1252
                        buf_flush_wait_batch_end(BUF_FLUSH_LRU);
1962
1253
                }
1963
1254
        }
1964
1255
}
1965
1256
 
1966
 
/*********************************************************************//**
1967
 
Flushes pages from the end of all the LRU lists. */
1968
 
UNIV_INTERN
1969
 
void
1970
 
buf_flush_free_margins(void)
1971
 
/*========================*/
1972
 
{
1973
 
        ulint   i;
1974
 
 
1975
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
1976
 
                buf_pool_t*     buf_pool;
1977
 
 
1978
 
                buf_pool = buf_pool_from_array(i);
1979
 
 
1980
 
                buf_flush_free_margin(buf_pool);
1981
 
        }
1982
 
}
1983
 
 
1984
 
/*********************************************************************
1985
 
Update the historical stats that we are collecting for flush rate
1986
 
heuristics at the end of each interval.
1987
 
Flush rate heuristic depends on (a) rate of redo log generation and
1988
 
(b) the rate at which LRU flush is happening. */
1989
 
UNIV_INTERN
1990
 
void
1991
 
buf_flush_stat_update(void)
1992
 
/*=======================*/
1993
 
{
1994
 
        buf_flush_stat_t*       item;
1995
 
        ib_uint64_t             lsn_diff;
1996
 
        ib_uint64_t             lsn;
1997
 
        ulint                   n_flushed;
1998
 
 
1999
 
        lsn = log_get_lsn();
2000
 
        if (buf_flush_stat_cur.redo == 0) {
2001
 
                /* First time around. Just update the current LSN
2002
 
                and return. */
2003
 
                buf_flush_stat_cur.redo = lsn;
2004
 
                return;
2005
 
        }
2006
 
 
2007
 
        item = &buf_flush_stat_arr[buf_flush_stat_arr_ind];
2008
 
 
2009
 
        /* values for this interval */
2010
 
        lsn_diff = lsn - buf_flush_stat_cur.redo;
2011
 
        n_flushed = buf_lru_flush_page_count
2012
 
                    - buf_flush_stat_cur.n_flushed;
2013
 
 
2014
 
        /* add the current value and subtract the obsolete entry. */
2015
 
        buf_flush_stat_sum.redo += lsn_diff - item->redo;
2016
 
        buf_flush_stat_sum.n_flushed += n_flushed - item->n_flushed;
2017
 
 
2018
 
        /* put current entry in the array. */
2019
 
        item->redo = lsn_diff;
2020
 
        item->n_flushed = n_flushed;
2021
 
 
2022
 
        /* update the index */
2023
 
        buf_flush_stat_arr_ind++;
2024
 
        buf_flush_stat_arr_ind %= BUF_FLUSH_STAT_N_INTERVAL;
2025
 
 
2026
 
        /* reset the current entry. */
2027
 
        buf_flush_stat_cur.redo = lsn;
2028
 
        buf_flush_stat_cur.n_flushed = buf_lru_flush_page_count;
2029
 
}
2030
 
 
2031
 
/*********************************************************************
2032
 
Determines the fraction of dirty pages that need to be flushed based
2033
 
on the speed at which we generate redo log. Note that if redo log
2034
 
is generated at a significant rate without corresponding increase
2035
 
in the number of dirty pages (for example, an in-memory workload)
2036
 
it can cause IO bursts of flushing. This function implements heuristics
2037
 
to avoid this burstiness.
2038
 
@return number of dirty pages to be flushed / second */
2039
 
UNIV_INTERN
2040
 
ulint
2041
 
buf_flush_get_desired_flush_rate(void)
2042
 
/*==================================*/
2043
 
{
2044
 
        ulint           i;
2045
 
        lint            rate;
2046
 
        ulint           redo_avg;
2047
 
        ulint           n_dirty = 0;
2048
 
        ulint           n_flush_req;
2049
 
        ulint           lru_flush_avg;
2050
 
        ib_uint64_t     lsn = log_get_lsn();
2051
 
        ulint           log_capacity = log_get_capacity();
2052
 
 
2053
 
        /* log_capacity should never be zero after the initialization
2054
 
        of log subsystem. */
2055
 
        ut_ad(log_capacity != 0);
2056
 
 
2057
 
        /* Get total number of dirty pages. It is OK to access
2058
 
        flush_list without holding any mutex as we are using this
2059
 
        only for heuristics. */
2060
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
2061
 
                buf_pool_t*     buf_pool;
2062
 
 
2063
 
                buf_pool = buf_pool_from_array(i);
2064
 
                n_dirty += UT_LIST_GET_LEN(buf_pool->flush_list);
2065
 
        }
2066
 
 
2067
 
        /* An overflow can happen if we generate more than 2^32 bytes
2068
 
        of redo in this interval i.e.: 4G of redo in 1 second. We can
2069
 
        safely consider this as infinity because if we ever come close
2070
 
        to 4G we'll start a synchronous flush of dirty pages. */
2071
 
        /* redo_avg below is average at which redo is generated in
2072
 
        past BUF_FLUSH_STAT_N_INTERVAL + redo generated in the current
2073
 
        interval. */
2074
 
        redo_avg = (ulint) (buf_flush_stat_sum.redo
2075
 
                            / BUF_FLUSH_STAT_N_INTERVAL
2076
 
                            + (lsn - buf_flush_stat_cur.redo));
2077
 
 
2078
 
        /* An overflow can happen possibly if we flush more than 2^32
2079
 
        pages in BUF_FLUSH_STAT_N_INTERVAL. This is a very very
2080
 
        unlikely scenario. Even when this happens it means that our
2081
 
        flush rate will be off the mark. It won't affect correctness
2082
 
        of any subsystem. */
2083
 
        /* lru_flush_avg below is rate at which pages are flushed as
2084
 
        part of LRU flush in past BUF_FLUSH_STAT_N_INTERVAL + the
2085
 
        number of pages flushed in the current interval. */
2086
 
        lru_flush_avg = buf_flush_stat_sum.n_flushed
2087
 
                        / BUF_FLUSH_STAT_N_INTERVAL
2088
 
                        + (buf_lru_flush_page_count
2089
 
                           - buf_flush_stat_cur.n_flushed);
2090
 
 
2091
 
        n_flush_req = (n_dirty * redo_avg) / log_capacity;
2092
 
 
2093
 
        /* The number of pages that we want to flush from the flush
2094
 
        list is the difference between the required rate and the
2095
 
        number of pages that we are historically flushing from the
2096
 
        LRU list */
2097
 
        rate = n_flush_req - lru_flush_avg;
2098
 
        return(rate > 0 ? (ulint) rate : 0);
2099
 
}
2100
 
 
2101
1257
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2102
 
/******************************************************************//**
2103
 
Validates the flush list.
2104
 
@return TRUE if ok */
 
1258
/**********************************************************************
 
1259
Validates the flush list. */
2105
1260
static
2106
1261
ibool
2107
 
buf_flush_validate_low(
2108
 
/*===================*/
2109
 
        buf_pool_t*     buf_pool)               /*!< in: Buffer pool instance */
 
1262
buf_flush_validate_low(void)
 
1263
/*========================*/
 
1264
                /* out: TRUE if ok */
2110
1265
{
2111
 
        buf_page_t*             bpage;
2112
 
        const ib_rbt_node_t*    rnode = NULL;
2113
 
 
2114
 
        ut_ad(buf_flush_list_mutex_own(buf_pool));
2115
 
 
2116
 
        UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list,
2117
 
                         ut_ad(ut_list_node_313->in_flush_list));
 
1266
        buf_page_t*     bpage;
 
1267
 
 
1268
        UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list);
2118
1269
 
2119
1270
        bpage = UT_LIST_GET_FIRST(buf_pool->flush_list);
2120
1271
 
2121
 
        /* If we are in recovery mode i.e.: flush_rbt != NULL
2122
 
        then each block in the flush_list must also be present
2123
 
        in the flush_rbt. */
2124
 
        if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
2125
 
                rnode = rbt_first(buf_pool->flush_rbt);
2126
 
        }
2127
 
 
2128
1272
        while (bpage != NULL) {
2129
1273
                const ib_uint64_t om = bpage->oldest_modification;
2130
 
 
2131
 
                ut_ad(buf_pool_from_bpage(bpage) == buf_pool);
2132
 
 
2133
1274
                ut_ad(bpage->in_flush_list);
2134
 
 
2135
 
                /* A page in flush_list can be in BUF_BLOCK_REMOVE_HASH
2136
 
                state. This happens when a page is in the middle of
2137
 
                being relocated. In that case the original descriptor
2138
 
                can have this state and still be in the flush list
2139
 
                waiting to acquire the flush_list_mutex to complete
2140
 
                the relocation. */
2141
 
                ut_a(buf_page_in_file(bpage)
2142
 
                     || buf_page_get_state(bpage) == BUF_BLOCK_REMOVE_HASH);
 
1275
                ut_a(buf_page_in_file(bpage));
2143
1276
                ut_a(om > 0);
2144
1277
 
2145
 
                if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
2146
 
                        buf_page_t** prpage;
2147
 
 
2148
 
                        ut_a(rnode);
2149
 
                        prpage = rbt_value(buf_page_t*, rnode);
2150
 
 
2151
 
                        ut_a(*prpage);
2152
 
                        ut_a(*prpage == bpage);
2153
 
                        rnode = rbt_next(buf_pool->flush_rbt, rnode);
2154
 
                }
2155
 
 
2156
1278
                bpage = UT_LIST_GET_NEXT(list, bpage);
2157
1279
 
2158
1280
                ut_a(!bpage || om >= bpage->oldest_modification);
2159
1281
        }
2160
1282
 
2161
 
        /* By this time we must have exhausted the traversal of
2162
 
        flush_rbt (if active) as well. */
2163
 
        ut_a(rnode == NULL);
2164
 
 
2165
1283
        return(TRUE);
2166
1284
}
2167
1285
 
2168
 
/******************************************************************//**
2169
 
Validates the flush list.
2170
 
@return TRUE if ok */
 
1286
/**********************************************************************
 
1287
Validates the flush list. */
2171
1288
UNIV_INTERN
2172
1289
ibool
2173
 
buf_flush_validate(
2174
 
/*===============*/
2175
 
        buf_pool_t*     buf_pool)       /*!< buffer pool instance */
 
1290
buf_flush_validate(void)
 
1291
/*====================*/
 
1292
                /* out: TRUE if ok */
2176
1293
{
2177
1294
        ibool   ret;
2178
1295
 
2179
 
        buf_flush_list_mutex_enter(buf_pool);
2180
 
 
2181
 
        ret = buf_flush_validate_low(buf_pool);
2182
 
 
2183
 
        buf_flush_list_mutex_exit(buf_pool);
 
1296
        buf_pool_mutex_enter();
 
1297
 
 
1298
        ret = buf_flush_validate_low();
 
1299
 
 
1300
        buf_pool_mutex_exit();
2184
1301
 
2185
1302
        return(ret);
2186
1303
}
2187
1304
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
2188
 
#endif /* !UNIV_HOTBACKUP */