← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-01-22 00:53:13 UTC
  • Revision ID: brian@gaz-20100122005313-jmizcbcdi1lt4tcx
Revert db patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/buf/buf0flu.c
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1995, 2009, 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., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/**************************************************//**
 
20
@file buf/buf0flu.c
 
21
The database buffer buf_pool flush algorithm
 
22
 
 
23
Created 11/11/1995 Heikki Tuuri
 
24
*******************************************************/
 
25
 
 
26
#include "buf0flu.h"
 
27
 
 
28
#ifdef UNIV_NONINL
 
29
#include "buf0flu.ic"
 
30
#endif
 
31
 
 
32
#include "buf0buf.h"
 
33
#include "srv0srv.h"
 
34
#include "page0zip.h"
 
35
#ifndef UNIV_HOTBACKUP
 
36
#include "ut0byte.h"
 
37
#include "ut0lst.h"
 
38
#include "page0page.h"
 
39
#include "fil0fil.h"
 
40
#include "buf0lru.h"
 
41
#include "buf0rea.h"
 
42
#include "ibuf0ibuf.h"
 
43
#include "log0log.h"
 
44
#include "os0file.h"
 
45
#include "trx0sys.h"
 
46
 
 
47
/**********************************************************************
 
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 */
 
84
static
 
85
ibool
 
86
buf_flush_validate_low(void);
 
87
/*========================*/
 
88
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
89
 
 
90
/********************************************************************//**
 
91
Inserts a modified block into the flush list. */
 
92
UNIV_INTERN
 
93
void
 
94
buf_flush_insert_into_flush_list(
 
95
/*=============================*/
 
96
        buf_block_t*    block)  /*!< in/out: block which is modified */
 
97
{
 
98
        ut_ad(buf_pool_mutex_own());
 
99
        ut_ad((UT_LIST_GET_FIRST(buf_pool->flush_list) == NULL)
 
100
              || (UT_LIST_GET_FIRST(buf_pool->flush_list)->oldest_modification
 
101
                  <= block->page.oldest_modification));
 
102
 
 
103
        ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 
104
        ut_ad(block->page.in_LRU_list);
 
105
        ut_ad(block->page.in_page_hash);
 
106
        ut_ad(!block->page.in_zip_hash);
 
107
        ut_ad(!block->page.in_flush_list);
 
108
        ut_d(block->page.in_flush_list = TRUE);
 
109
        UT_LIST_ADD_FIRST(list, buf_pool->flush_list, &block->page);
 
110
 
 
111
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 
112
        ut_a(buf_flush_validate_low());
 
113
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
114
}
 
115
 
 
116
/********************************************************************//**
 
117
Inserts a modified block into the flush list in the right sorted position.
 
118
This function is used by recovery, because there the modifications do not
 
119
necessarily come in the order of lsn's. */
 
120
UNIV_INTERN
 
121
void
 
122
buf_flush_insert_sorted_into_flush_list(
 
123
/*====================================*/
 
124
        buf_block_t*    block)  /*!< in/out: block which is modified */
 
125
{
 
126
        buf_page_t*     prev_b;
 
127
        buf_page_t*     b;
 
128
 
 
129
        ut_ad(buf_pool_mutex_own());
 
130
        ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 
131
 
 
132
        ut_ad(block->page.in_LRU_list);
 
133
        ut_ad(block->page.in_page_hash);
 
134
        ut_ad(!block->page.in_zip_hash);
 
135
        ut_ad(!block->page.in_flush_list);
 
136
        ut_d(block->page.in_flush_list = TRUE);
 
137
 
 
138
        prev_b = NULL;
 
139
        b = UT_LIST_GET_FIRST(buf_pool->flush_list);
 
140
 
 
141
        while (b && b->oldest_modification > block->page.oldest_modification) {
 
142
                ut_ad(b->in_flush_list);
 
143
                prev_b = b;
 
144
                b = UT_LIST_GET_NEXT(list, b);
 
145
        }
 
146
 
 
147
        if (prev_b == NULL) {
 
148
                UT_LIST_ADD_FIRST(list, buf_pool->flush_list, &block->page);
 
149
        } else {
 
150
                UT_LIST_INSERT_AFTER(list, buf_pool->flush_list,
 
151
                                     prev_b, &block->page);
 
152
        }
 
153
 
 
154
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 
155
        ut_a(buf_flush_validate_low());
 
156
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
157
}
 
158
 
 
159
/********************************************************************//**
 
160
Returns TRUE if the file page block is immediately suitable for replacement,
 
161
i.e., the transition FILE_PAGE => NOT_USED allowed.
 
162
@return TRUE if can replace immediately */
 
163
UNIV_INTERN
 
164
ibool
 
165
buf_flush_ready_for_replace(
 
166
/*========================*/
 
167
        buf_page_t*     bpage)  /*!< in: buffer control block, must be
 
168
                                buf_page_in_file(bpage) and in the LRU list */
 
169
{
 
170
        ut_ad(buf_pool_mutex_own());
 
171
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 
172
        ut_ad(bpage->in_LRU_list);
 
173
 
 
174
        if (UNIV_LIKELY(buf_page_in_file(bpage))) {
 
175
 
 
176
                return(bpage->oldest_modification == 0
 
177
                       && buf_page_get_io_fix(bpage) == BUF_IO_NONE
 
178
                       && bpage->buf_fix_count == 0);
 
179
        }
 
180
 
 
181
        ut_print_timestamp(stderr);
 
182
        fprintf(stderr,
 
183
                "  InnoDB: Error: buffer block state %lu"
 
184
                " in the LRU list!\n",
 
185
                (ulong) buf_page_get_state(bpage));
 
186
        ut_print_buf(stderr, bpage, sizeof(buf_page_t));
 
187
        putc('\n', stderr);
 
188
 
 
189
        return(FALSE);
 
190
}
 
191
 
 
192
/********************************************************************//**
 
193
Returns TRUE if the block is modified and ready for flushing.
 
194
@return TRUE if can flush immediately */
 
195
UNIV_INLINE
 
196
ibool
 
197
buf_flush_ready_for_flush(
 
198
/*======================*/
 
199
        buf_page_t*     bpage,  /*!< in: buffer control block, must be
 
200
                                buf_page_in_file(bpage) */
 
201
        enum buf_flush  flush_type)/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
 
202
{
 
203
        ut_a(buf_page_in_file(bpage));
 
204
        ut_ad(buf_pool_mutex_own());
 
205
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 
206
        ut_ad(flush_type == BUF_FLUSH_LRU || BUF_FLUSH_LIST);
 
207
 
 
208
        if (bpage->oldest_modification != 0
 
209
            && buf_page_get_io_fix(bpage) == BUF_IO_NONE) {
 
210
                ut_ad(bpage->in_flush_list);
 
211
 
 
212
                if (flush_type != BUF_FLUSH_LRU) {
 
213
 
 
214
                        return(TRUE);
 
215
 
 
216
                } else if (bpage->buf_fix_count == 0) {
 
217
 
 
218
                        /* If we are flushing the LRU list, to avoid deadlocks
 
219
                        we require the block not to be bufferfixed, and hence
 
220
                        not latched. */
 
221
 
 
222
                        return(TRUE);
 
223
                }
 
224
        }
 
225
 
 
226
        return(FALSE);
 
227
}
 
228
 
 
229
/********************************************************************//**
 
230
Remove a block from the flush list of modified blocks. */
 
231
UNIV_INTERN
 
232
void
 
233
buf_flush_remove(
 
234
/*=============*/
 
235
        buf_page_t*     bpage)  /*!< in: pointer to the block in question */
 
236
{
 
237
        ut_ad(buf_pool_mutex_own());
 
238
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
 
239
        ut_ad(bpage->in_flush_list);
 
240
        ut_d(bpage->in_flush_list = FALSE);
 
241
 
 
242
        switch (buf_page_get_state(bpage)) {
 
243
        case BUF_BLOCK_ZIP_PAGE:
 
244
                /* clean compressed pages should not be on the flush list */
 
245
        case BUF_BLOCK_ZIP_FREE:
 
246
        case BUF_BLOCK_NOT_USED:
 
247
        case BUF_BLOCK_READY_FOR_USE:
 
248
        case BUF_BLOCK_MEMORY:
 
249
        case BUF_BLOCK_REMOVE_HASH:
 
250
                ut_error;
 
251
                return;
 
252
        case BUF_BLOCK_ZIP_DIRTY:
 
253
                buf_page_set_state(bpage, BUF_BLOCK_ZIP_PAGE);
 
254
                UT_LIST_REMOVE(list, buf_pool->flush_list, bpage);
 
255
                buf_LRU_insert_zip_clean(bpage);
 
256
                break;
 
257
        case BUF_BLOCK_FILE_PAGE:
 
258
                UT_LIST_REMOVE(list, buf_pool->flush_list, bpage);
 
259
                break;
 
260
        }
 
261
 
 
262
        bpage->oldest_modification = 0;
 
263
 
 
264
        ut_d(UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list,
 
265
                              ut_ad(ut_list_node_313->in_flush_list)));
 
266
}
 
267
 
 
268
/********************************************************************//**
 
269
Updates the flush system data structures when a write is completed. */
 
270
UNIV_INTERN
 
271
void
 
272
buf_flush_write_complete(
 
273
/*=====================*/
 
274
        buf_page_t*     bpage)  /*!< in: pointer to the block in question */
 
275
{
 
276
        enum buf_flush  flush_type;
 
277
 
 
278
        ut_ad(bpage);
 
279
 
 
280
        buf_flush_remove(bpage);
 
281
 
 
282
        flush_type = buf_page_get_flush_type(bpage);
 
283
        buf_pool->n_flush[flush_type]--;
 
284
 
 
285
        if (flush_type == BUF_FLUSH_LRU) {
 
286
                /* Put the block to the end of the LRU list to wait to be
 
287
                moved to the free list */
 
288
 
 
289
                buf_LRU_make_block_old(bpage);
 
290
 
 
291
                buf_pool->LRU_flush_ended++;
 
292
        }
 
293
 
 
294
        /* fprintf(stderr, "n pending flush %lu\n",
 
295
        buf_pool->n_flush[flush_type]); */
 
296
 
 
297
        if ((buf_pool->n_flush[flush_type] == 0)
 
298
            && (buf_pool->init_flush[flush_type] == FALSE)) {
 
299
 
 
300
                /* The running flush batch has ended */
 
301
 
 
302
                os_event_set(buf_pool->no_flush[flush_type]);
 
303
        }
 
304
}
 
305
 
 
306
/********************************************************************//**
 
307
Flushes possible buffered writes from the doublewrite memory buffer to disk,
 
308
and also wakes up the aio thread if simulated aio is used. It is very
 
309
important to call this function after a batch of writes has been posted,
 
310
and also when we may have to wait for a page latch! Otherwise a deadlock
 
311
of threads can occur. */
 
312
static
 
313
void
 
314
buf_flush_buffered_writes(void)
 
315
/*===========================*/
 
316
{
 
317
        byte*           write_buf;
 
318
        ulint           len;
 
319
        ulint           len2;
 
320
        ulint           i;
 
321
 
 
322
        if (!srv_use_doublewrite_buf || trx_doublewrite == NULL) {
 
323
                os_aio_simulated_wake_handler_threads();
 
324
 
 
325
                return;
 
326
        }
 
327
 
 
328
        mutex_enter(&(trx_doublewrite->mutex));
 
329
 
 
330
        /* Write first to doublewrite buffer blocks. We use synchronous
 
331
        aio and thus know that file write has been completed when the
 
332
        control returns. */
 
333
 
 
334
        if (trx_doublewrite->first_free == 0) {
 
335
 
 
336
                mutex_exit(&(trx_doublewrite->mutex));
 
337
 
 
338
                return;
 
339
        }
 
340
 
 
341
        for (i = 0; i < trx_doublewrite->first_free; i++) {
 
342
 
 
343
                const buf_block_t*      block;
 
344
 
 
345
                block = (buf_block_t*) trx_doublewrite->buf_block_arr[i];
 
346
 
 
347
                if (buf_block_get_state(block) != BUF_BLOCK_FILE_PAGE
 
348
                    || block->page.zip.data) {
 
349
                        /* No simple validate for compressed pages exists. */
 
350
                        continue;
 
351
                }
 
352
 
 
353
                if (UNIV_UNLIKELY
 
354
                    (memcmp(block->frame + (FIL_PAGE_LSN + 4),
 
355
                            block->frame + (UNIV_PAGE_SIZE
 
356
                                            - FIL_PAGE_END_LSN_OLD_CHKSUM + 4),
 
357
                            4))) {
 
358
                        ut_print_timestamp(stderr);
 
359
                        fprintf(stderr,
 
360
                                "  InnoDB: ERROR: The page to be written"
 
361
                                " seems corrupt!\n"
 
362
                                "InnoDB: The lsn fields do not match!"
 
363
                                " Noticed in the buffer pool\n"
 
364
                                "InnoDB: before posting to the"
 
365
                                " doublewrite buffer.\n");
 
366
                }
 
367
 
 
368
                if (!block->check_index_page_at_flush) {
 
369
                } else if (page_is_comp(block->frame)) {
 
370
                        if (UNIV_UNLIKELY
 
371
                            (!page_simple_validate_new(block->frame))) {
 
372
corrupted_page:
 
373
                                buf_page_print(block->frame, 0);
 
374
 
 
375
                                ut_print_timestamp(stderr);
 
376
                                fprintf(stderr,
 
377
                                        "  InnoDB: Apparent corruption of an"
 
378
                                        " index page n:o %lu in space %lu\n"
 
379
                                        "InnoDB: to be written to data file."
 
380
                                        " We intentionally crash server\n"
 
381
                                        "InnoDB: to prevent corrupt data"
 
382
                                        " from ending up in data\n"
 
383
                                        "InnoDB: files.\n",
 
384
                                        (ulong) buf_block_get_page_no(block),
 
385
                                        (ulong) buf_block_get_space(block));
 
386
 
 
387
                                ut_error;
 
388
                        }
 
389
                } else if (UNIV_UNLIKELY
 
390
                           (!page_simple_validate_old(block->frame))) {
 
391
 
 
392
                        goto corrupted_page;
 
393
                }
 
394
        }
 
395
 
 
396
        /* increment the doublewrite flushed pages counter */
 
397
        srv_dblwr_pages_written+= trx_doublewrite->first_free;
 
398
        srv_dblwr_writes++;
 
399
 
 
400
        len = ut_min(TRX_SYS_DOUBLEWRITE_BLOCK_SIZE,
 
401
                     trx_doublewrite->first_free) * UNIV_PAGE_SIZE;
 
402
 
 
403
        write_buf = trx_doublewrite->write_buf;
 
404
        i = 0;
 
405
 
 
406
        fil_io(OS_FILE_WRITE, TRUE, TRX_SYS_SPACE, 0,
 
407
               trx_doublewrite->block1, 0, len,
 
408
               (void*) write_buf, NULL);
 
409
 
 
410
        for (len2 = 0; len2 + UNIV_PAGE_SIZE <= len;
 
411
             len2 += UNIV_PAGE_SIZE, i++) {
 
412
                const buf_block_t* block = (buf_block_t*)
 
413
                        trx_doublewrite->buf_block_arr[i];
 
414
 
 
415
                if (UNIV_LIKELY(!block->page.zip.data)
 
416
                    && UNIV_LIKELY(buf_block_get_state(block)
 
417
                                   == BUF_BLOCK_FILE_PAGE)
 
418
                    && UNIV_UNLIKELY
 
419
                    (memcmp(write_buf + len2 + (FIL_PAGE_LSN + 4),
 
420
                            write_buf + len2
 
421
                            + (UNIV_PAGE_SIZE
 
422
                               - FIL_PAGE_END_LSN_OLD_CHKSUM + 4), 4))) {
 
423
                        ut_print_timestamp(stderr);
 
424
                        fprintf(stderr,
 
425
                                "  InnoDB: ERROR: The page to be written"
 
426
                                " seems corrupt!\n"
 
427
                                "InnoDB: The lsn fields do not match!"
 
428
                                " Noticed in the doublewrite block1.\n");
 
429
                }
 
430
        }
 
431
 
 
432
        if (trx_doublewrite->first_free <= TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) {
 
433
                goto flush;
 
434
        }
 
435
 
 
436
        len = (trx_doublewrite->first_free - TRX_SYS_DOUBLEWRITE_BLOCK_SIZE)
 
437
                * UNIV_PAGE_SIZE;
 
438
 
 
439
        write_buf = trx_doublewrite->write_buf
 
440
                + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE;
 
441
        ut_ad(i == TRX_SYS_DOUBLEWRITE_BLOCK_SIZE);
 
442
 
 
443
        fil_io(OS_FILE_WRITE, TRUE, TRX_SYS_SPACE, 0,
 
444
               trx_doublewrite->block2, 0, len,
 
445
               (void*) write_buf, NULL);
 
446
 
 
447
        for (len2 = 0; len2 + UNIV_PAGE_SIZE <= len;
 
448
             len2 += UNIV_PAGE_SIZE, i++) {
 
449
                const buf_block_t* block = (buf_block_t*)
 
450
                        trx_doublewrite->buf_block_arr[i];
 
451
 
 
452
                if (UNIV_LIKELY(!block->page.zip.data)
 
453
                    && UNIV_LIKELY(buf_block_get_state(block)
 
454
                                   == BUF_BLOCK_FILE_PAGE)
 
455
                    && UNIV_UNLIKELY
 
456
                    (memcmp(write_buf + len2 + (FIL_PAGE_LSN + 4),
 
457
                            write_buf + len2
 
458
                            + (UNIV_PAGE_SIZE
 
459
                               - FIL_PAGE_END_LSN_OLD_CHKSUM + 4), 4))) {
 
460
                        ut_print_timestamp(stderr);
 
461
                        fprintf(stderr,
 
462
                                "  InnoDB: ERROR: The page to be"
 
463
                                " written seems corrupt!\n"
 
464
                                "InnoDB: The lsn fields do not match!"
 
465
                                " Noticed in"
 
466
                                " the doublewrite block2.\n");
 
467
                }
 
468
        }
 
469
 
 
470
flush:
 
471
        /* Now flush the doublewrite buffer data to disk */
 
472
 
 
473
        fil_flush(TRX_SYS_SPACE);
 
474
 
 
475
        /* We know that the writes have been flushed to disk now
 
476
        and in recovery we will find them in the doublewrite buffer
 
477
        blocks. Next do the writes to the intended positions. */
 
478
 
 
479
        for (i = 0; i < trx_doublewrite->first_free; i++) {
 
480
                const buf_block_t* block = (buf_block_t*)
 
481
                        trx_doublewrite->buf_block_arr[i];
 
482
 
 
483
                ut_a(buf_page_in_file(&block->page));
 
484
                if (UNIV_LIKELY_NULL(block->page.zip.data)) {
 
485
                        fil_io(OS_FILE_WRITE | OS_AIO_SIMULATED_WAKE_LATER,
 
486
                               FALSE, buf_page_get_space(&block->page),
 
487
                               buf_page_get_zip_size(&block->page),
 
488
                               buf_page_get_page_no(&block->page), 0,
 
489
                               buf_page_get_zip_size(&block->page),
 
490
                               (void*)block->page.zip.data,
 
491
                               (void*)block);
 
492
 
 
493
                        /* Increment the counter of I/O operations used
 
494
                        for selecting LRU policy. */
 
495
                        buf_LRU_stat_inc_io();
 
496
 
 
497
                        continue;
 
498
                }
 
499
 
 
500
                ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
 
501
 
 
502
                if (UNIV_UNLIKELY(memcmp(block->frame + (FIL_PAGE_LSN + 4),
 
503
                                         block->frame
 
504
                                         + (UNIV_PAGE_SIZE
 
505
                                            - FIL_PAGE_END_LSN_OLD_CHKSUM + 4),
 
506
                                         4))) {
 
507
                        ut_print_timestamp(stderr);
 
508
                        fprintf(stderr,
 
509
                                "  InnoDB: ERROR: The page to be written"
 
510
                                " seems corrupt!\n"
 
511
                                "InnoDB: The lsn fields do not match!"
 
512
                                " Noticed in the buffer pool\n"
 
513
                                "InnoDB: after posting and flushing"
 
514
                                " the doublewrite buffer.\n"
 
515
                                "InnoDB: Page buf fix count %lu,"
 
516
                                " io fix %lu, state %lu\n",
 
517
                                (ulong)block->page.buf_fix_count,
 
518
                                (ulong)buf_block_get_io_fix(block),
 
519
                                (ulong)buf_block_get_state(block));
 
520
                }
 
521
 
 
522
                fil_io(OS_FILE_WRITE | OS_AIO_SIMULATED_WAKE_LATER,
 
523
                       FALSE, buf_block_get_space(block), 0,
 
524
                       buf_block_get_page_no(block), 0, UNIV_PAGE_SIZE,
 
525
                       (void*)block->frame, (void*)block);
 
526
 
 
527
                /* Increment the counter of I/O operations used
 
528
                for selecting LRU policy. */
 
529
                buf_LRU_stat_inc_io();
 
530
        }
 
531
 
 
532
        /* Wake possible simulated aio thread to actually post the
 
533
        writes to the operating system */
 
534
 
 
535
        os_aio_simulated_wake_handler_threads();
 
536
 
 
537
        /* Wait that all async writes to tablespaces have been posted to
 
538
        the OS */
 
539
 
 
540
        os_aio_wait_until_no_pending_writes();
 
541
 
 
542
        /* Now we flush the data to disk (for example, with fsync) */
 
543
 
 
544
        fil_flush_file_spaces(FIL_TABLESPACE);
 
545
 
 
546
        /* We can now reuse the doublewrite memory buffer: */
 
547
 
 
548
        trx_doublewrite->first_free = 0;
 
549
 
 
550
        mutex_exit(&(trx_doublewrite->mutex));
 
551
}
 
552
 
 
553
/********************************************************************//**
 
554
Posts a buffer page for writing. If the doublewrite memory buffer is
 
555
full, calls buf_flush_buffered_writes and waits for for free space to
 
556
appear. */
 
557
static
 
558
void
 
559
buf_flush_post_to_doublewrite_buf(
 
560
/*==============================*/
 
561
        buf_page_t*     bpage)  /*!< in: buffer block to write */
 
562
{
 
563
        ulint   zip_size;
 
564
try_again:
 
565
        mutex_enter(&(trx_doublewrite->mutex));
 
566
 
 
567
        ut_a(buf_page_in_file(bpage));
 
568
 
 
569
        if (trx_doublewrite->first_free
 
570
            >= 2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) {
 
571
                mutex_exit(&(trx_doublewrite->mutex));
 
572
 
 
573
                buf_flush_buffered_writes();
 
574
 
 
575
                goto try_again;
 
576
        }
 
577
 
 
578
        zip_size = buf_page_get_zip_size(bpage);
 
579
 
 
580
        if (UNIV_UNLIKELY(zip_size)) {
 
581
                /* Copy the compressed page and clear the rest. */
 
582
                memcpy(trx_doublewrite->write_buf
 
583
                       + UNIV_PAGE_SIZE * trx_doublewrite->first_free,
 
584
                       bpage->zip.data, zip_size);
 
585
                memset(trx_doublewrite->write_buf
 
586
                       + UNIV_PAGE_SIZE * trx_doublewrite->first_free
 
587
                       + zip_size, 0, UNIV_PAGE_SIZE - zip_size);
 
588
        } else {
 
589
                ut_a(buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
 
590
 
 
591
                memcpy(trx_doublewrite->write_buf
 
592
                       + UNIV_PAGE_SIZE * trx_doublewrite->first_free,
 
593
                       ((buf_block_t*) bpage)->frame, UNIV_PAGE_SIZE);
 
594
        }
 
595
 
 
596
        trx_doublewrite->buf_block_arr[trx_doublewrite->first_free] = bpage;
 
597
 
 
598
        trx_doublewrite->first_free++;
 
599
 
 
600
        if (trx_doublewrite->first_free
 
601
            >= 2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) {
 
602
                mutex_exit(&(trx_doublewrite->mutex));
 
603
 
 
604
                buf_flush_buffered_writes();
 
605
 
 
606
                return;
 
607
        }
 
608
 
 
609
        mutex_exit(&(trx_doublewrite->mutex));
 
610
}
 
611
#endif /* !UNIV_HOTBACKUP */
 
612
 
 
613
/********************************************************************//**
 
614
Initializes a page for writing to the tablespace. */
 
615
UNIV_INTERN
 
616
void
 
617
buf_flush_init_for_writing(
 
618
/*=======================*/
 
619
        byte*           page,           /*!< in/out: page */
 
620
        void*           page_zip_,      /*!< in/out: compressed page, or NULL */
 
621
        ib_uint64_t     newest_lsn)     /*!< in: newest modification lsn
 
622
                                        to the page */
 
623
{
 
624
        ut_ad(page);
 
625
 
 
626
        if (page_zip_) {
 
627
                page_zip_des_t* page_zip = page_zip_;
 
628
                ulint           zip_size = page_zip_get_size(page_zip);
 
629
                ut_ad(zip_size);
 
630
                ut_ad(ut_is_2pow(zip_size));
 
631
                ut_ad(zip_size <= UNIV_PAGE_SIZE);
 
632
 
 
633
                switch (UNIV_EXPECT(fil_page_get_type(page), FIL_PAGE_INDEX)) {
 
634
                case FIL_PAGE_TYPE_ALLOCATED:
 
635
                case FIL_PAGE_INODE:
 
636
                case FIL_PAGE_IBUF_BITMAP:
 
637
                case FIL_PAGE_TYPE_FSP_HDR:
 
638
                case FIL_PAGE_TYPE_XDES:
 
639
                        /* These are essentially uncompressed pages. */
 
640
                        memcpy(page_zip->data, page, zip_size);
 
641
                        /* fall through */
 
642
                case FIL_PAGE_TYPE_ZBLOB:
 
643
                case FIL_PAGE_TYPE_ZBLOB2:
 
644
                case FIL_PAGE_INDEX:
 
645
                        mach_write_ull(page_zip->data
 
646
                                       + FIL_PAGE_LSN, newest_lsn);
 
647
                        memset(page_zip->data + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
 
648
                        mach_write_to_4(page_zip->data
 
649
                                        + FIL_PAGE_SPACE_OR_CHKSUM,
 
650
                                        srv_use_checksums
 
651
                                        ? page_zip_calc_checksum(
 
652
                                                page_zip->data, zip_size)
 
653
                                        : BUF_NO_CHECKSUM_MAGIC);
 
654
                        return;
 
655
                }
 
656
 
 
657
                ut_print_timestamp(stderr);
 
658
                fputs("  InnoDB: ERROR: The compressed page to be written"
 
659
                      " seems corrupt:", stderr);
 
660
                ut_print_buf(stderr, page, zip_size);
 
661
                fputs("\nInnoDB: Possibly older version of the page:", stderr);
 
662
                ut_print_buf(stderr, page_zip->data, zip_size);
 
663
                putc('\n', stderr);
 
664
                ut_error;
 
665
        }
 
666
 
 
667
        /* Write the newest modification lsn to the page header and trailer */
 
668
        mach_write_ull(page + FIL_PAGE_LSN, newest_lsn);
 
669
 
 
670
        mach_write_ull(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
 
671
                       newest_lsn);
 
672
 
 
673
        /* Store the new formula checksum */
 
674
 
 
675
        mach_write_to_4(page + FIL_PAGE_SPACE_OR_CHKSUM,
 
676
                        srv_use_checksums
 
677
                        ? buf_calc_page_new_checksum(page)
 
678
                        : BUF_NO_CHECKSUM_MAGIC);
 
679
 
 
680
        /* We overwrite the first 4 bytes of the end lsn field to store
 
681
        the old formula checksum. Since it depends also on the field
 
682
        FIL_PAGE_SPACE_OR_CHKSUM, it has to be calculated after storing the
 
683
        new formula checksum. */
 
684
 
 
685
        mach_write_to_4(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
 
686
                        srv_use_checksums
 
687
                        ? buf_calc_page_old_checksum(page)
 
688
                        : BUF_NO_CHECKSUM_MAGIC);
 
689
}
 
690
 
 
691
#ifndef UNIV_HOTBACKUP
 
692
/********************************************************************//**
 
693
Does an asynchronous write of a buffer page. NOTE: in simulated aio and
 
694
also when the doublewrite buffer is used, we must call
 
695
buf_flush_buffered_writes after we have posted a batch of writes! */
 
696
static
 
697
void
 
698
buf_flush_write_block_low(
 
699
/*======================*/
 
700
        buf_page_t*     bpage)  /*!< in: buffer block to write */
 
701
{
 
702
        ulint   zip_size        = buf_page_get_zip_size(bpage);
 
703
        page_t* frame           = NULL;
 
704
#ifdef UNIV_LOG_DEBUG
 
705
        static ibool univ_log_debug_warned;
 
706
#endif /* UNIV_LOG_DEBUG */
 
707
 
 
708
        ut_ad(buf_page_in_file(bpage));
 
709
 
 
710
        /* We are not holding buf_pool_mutex or block_mutex here.
 
711
        Nevertheless, it is safe to access bpage, because it is
 
712
        io_fixed and oldest_modification != 0.  Thus, it cannot be
 
713
        relocated in the buffer pool or removed from flush_list or
 
714
        LRU_list. */
 
715
        ut_ad(!buf_pool_mutex_own());
 
716
        ut_ad(!mutex_own(buf_page_get_mutex(bpage)));
 
717
        ut_ad(buf_page_get_io_fix(bpage) == BUF_IO_WRITE);
 
718
        ut_ad(bpage->oldest_modification != 0);
 
719
 
 
720
#ifdef UNIV_IBUF_COUNT_DEBUG
 
721
        ut_a(ibuf_count_get(bpage->space, bpage->offset) == 0);
 
722
#endif
 
723
        ut_ad(bpage->newest_modification != 0);
 
724
 
 
725
#ifdef UNIV_LOG_DEBUG
 
726
        if (!univ_log_debug_warned) {
 
727
                univ_log_debug_warned = TRUE;
 
728
                fputs("Warning: cannot force log to disk if"
 
729
                      " UNIV_LOG_DEBUG is defined!\n"
 
730
                      "Crash recovery will not work!\n",
 
731
                      stderr);
 
732
        }
 
733
#else
 
734
        /* Force the log to the disk before writing the modified block */
 
735
        log_write_up_to(bpage->newest_modification, LOG_WAIT_ALL_GROUPS, TRUE);
 
736
#endif
 
737
        switch (buf_page_get_state(bpage)) {
 
738
        case BUF_BLOCK_ZIP_FREE:
 
739
        case BUF_BLOCK_ZIP_PAGE: /* The page should be dirty. */
 
740
        case BUF_BLOCK_NOT_USED:
 
741
        case BUF_BLOCK_READY_FOR_USE:
 
742
        case BUF_BLOCK_MEMORY:
 
743
        case BUF_BLOCK_REMOVE_HASH:
 
744
                ut_error;
 
745
                break;
 
746
        case BUF_BLOCK_ZIP_DIRTY:
 
747
                frame = bpage->zip.data;
 
748
                if (UNIV_LIKELY(srv_use_checksums)) {
 
749
                        ut_a(mach_read_from_4(frame + FIL_PAGE_SPACE_OR_CHKSUM)
 
750
                             == page_zip_calc_checksum(frame, zip_size));
 
751
                }
 
752
                mach_write_ull(frame + FIL_PAGE_LSN,
 
753
                               bpage->newest_modification);
 
754
                memset(frame + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
 
755
                break;
 
756
        case BUF_BLOCK_FILE_PAGE:
 
757
                frame = bpage->zip.data;
 
758
                if (!frame) {
 
759
                        frame = ((buf_block_t*) bpage)->frame;
 
760
                }
 
761
 
 
762
                buf_flush_init_for_writing(((buf_block_t*) bpage)->frame,
 
763
                                           bpage->zip.data
 
764
                                           ? &bpage->zip : NULL,
 
765
                                           bpage->newest_modification);
 
766
                break;
 
767
        }
 
768
 
 
769
        if (!srv_use_doublewrite_buf || !trx_doublewrite) {
 
770
                fil_io(OS_FILE_WRITE | OS_AIO_SIMULATED_WAKE_LATER,
 
771
                       FALSE, buf_page_get_space(bpage), zip_size,
 
772
                       buf_page_get_page_no(bpage), 0,
 
773
                       zip_size ? zip_size : UNIV_PAGE_SIZE,
 
774
                       frame, bpage);
 
775
        } else {
 
776
                buf_flush_post_to_doublewrite_buf(bpage);
 
777
        }
 
778
}
 
779
 
 
780
/********************************************************************//**
 
781
Writes a flushable page asynchronously from the buffer pool to a file.
 
782
NOTE: in simulated aio we must call
 
783
os_aio_simulated_wake_handler_threads after we have posted a batch of
 
784
writes! NOTE: buf_pool_mutex and buf_page_get_mutex(bpage) must be
 
785
held upon entering this function, and they will be released by this
 
786
function. */
 
787
static
 
788
void
 
789
buf_flush_page(
 
790
/*===========*/
 
791
        buf_page_t*     bpage,          /*!< in: buffer control block */
 
792
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU
 
793
                                        or BUF_FLUSH_LIST */
 
794
{
 
795
        mutex_t*        block_mutex;
 
796
        ibool           is_uncompressed;
 
797
 
 
798
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 
799
        ut_ad(buf_pool_mutex_own());
 
800
        ut_ad(buf_page_in_file(bpage));
 
801
 
 
802
        block_mutex = buf_page_get_mutex(bpage);
 
803
        ut_ad(mutex_own(block_mutex));
 
804
 
 
805
        ut_ad(buf_flush_ready_for_flush(bpage, flush_type));
 
806
 
 
807
        buf_page_set_io_fix(bpage, BUF_IO_WRITE);
 
808
 
 
809
        buf_page_set_flush_type(bpage, flush_type);
 
810
 
 
811
        if (buf_pool->n_flush[flush_type] == 0) {
 
812
 
 
813
                os_event_reset(buf_pool->no_flush[flush_type]);
 
814
        }
 
815
 
 
816
        buf_pool->n_flush[flush_type]++;
 
817
 
 
818
        is_uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
 
819
        ut_ad(is_uncompressed == (block_mutex != &buf_pool_zip_mutex));
 
820
 
 
821
        switch (flush_type) {
 
822
                ibool   is_s_latched;
 
823
        case BUF_FLUSH_LIST:
 
824
                /* If the simulated aio thread is not running, we must
 
825
                not wait for any latch, as we may end up in a deadlock:
 
826
                if buf_fix_count == 0, then we know we need not wait */
 
827
 
 
828
                is_s_latched = (bpage->buf_fix_count == 0);
 
829
                if (is_s_latched && is_uncompressed) {
 
830
                        rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock,
 
831
                                           BUF_IO_WRITE);
 
832
                }
 
833
 
 
834
                mutex_exit(block_mutex);
 
835
                buf_pool_mutex_exit();
 
836
 
 
837
                /* Even though bpage is not protected by any mutex at
 
838
                this point, it is safe to access bpage, because it is
 
839
                io_fixed and oldest_modification != 0.  Thus, it
 
840
                cannot be relocated in the buffer pool or removed from
 
841
                flush_list or LRU_list. */
 
842
 
 
843
                if (!is_s_latched) {
 
844
                        buf_flush_buffered_writes();
 
845
 
 
846
                        if (is_uncompressed) {
 
847
                                rw_lock_s_lock_gen(&((buf_block_t*) bpage)
 
848
                                                   ->lock, BUF_IO_WRITE);
 
849
                        }
 
850
                }
 
851
 
 
852
                break;
 
853
 
 
854
        case BUF_FLUSH_LRU:
 
855
                /* VERY IMPORTANT:
 
856
                Because any thread may call the LRU flush, even when owning
 
857
                locks on pages, to avoid deadlocks, we must make sure that the
 
858
                s-lock is acquired on the page without waiting: this is
 
859
                accomplished because buf_flush_ready_for_flush() must hold,
 
860
                and that requires the page not to be bufferfixed. */
 
861
 
 
862
                if (is_uncompressed) {
 
863
                        rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock,
 
864
                                           BUF_IO_WRITE);
 
865
                }
 
866
 
 
867
                /* Note that the s-latch is acquired before releasing the
 
868
                buf_pool mutex: this ensures that the latch is acquired
 
869
                immediately. */
 
870
 
 
871
                mutex_exit(block_mutex);
 
872
                buf_pool_mutex_exit();
 
873
                break;
 
874
 
 
875
        default:
 
876
                ut_error;
 
877
        }
 
878
 
 
879
        /* Even though bpage is not protected by any mutex at this
 
880
        point, it is safe to access bpage, because it is io_fixed and
 
881
        oldest_modification != 0.  Thus, it cannot be relocated in the
 
882
        buffer pool or removed from flush_list or LRU_list. */
 
883
 
 
884
#ifdef UNIV_DEBUG
 
885
        if (buf_debug_prints) {
 
886
                fprintf(stderr,
 
887
                        "Flushing %u space %u page %u\n",
 
888
                        flush_type, bpage->space, bpage->offset);
 
889
        }
 
890
#endif /* UNIV_DEBUG */
 
891
        buf_flush_write_block_low(bpage);
 
892
}
 
893
 
 
894
/***********************************************************//**
 
895
Flushes to disk all flushable pages within the flush area.
 
896
@return number of pages flushed */
 
897
static
 
898
ulint
 
899
buf_flush_try_neighbors(
 
900
/*====================*/
 
901
        ulint           space,          /*!< in: space id */
 
902
        ulint           offset,         /*!< in: page offset */
 
903
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU or
 
904
                                        BUF_FLUSH_LIST */
 
905
{
 
906
        buf_page_t*     bpage;
 
907
        ulint           low, high;
 
908
        ulint           count           = 0;
 
909
        ulint           i;
 
910
 
 
911
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 
912
 
 
913
        if (UT_LIST_GET_LEN(buf_pool->LRU) < BUF_LRU_OLD_MIN_LEN) {
 
914
                /* If there is little space, it is better not to flush any
 
915
                block except from the end of the LRU list */
 
916
 
 
917
                low = offset;
 
918
                high = offset + 1;
 
919
        } else {
 
920
                /* When flushed, dirty blocks are searched in neighborhoods of
 
921
                this size, and flushed along with the original page. */
 
922
 
 
923
                ulint   buf_flush_area  = ut_min(BUF_READ_AHEAD_AREA,
 
924
                                                 buf_pool->curr_size / 16);
 
925
 
 
926
                low = (offset / buf_flush_area) * buf_flush_area;
 
927
                high = (offset / buf_flush_area + 1) * buf_flush_area;
 
928
        }
 
929
 
 
930
        /* fprintf(stderr, "Flush area: low %lu high %lu\n", low, high); */
 
931
 
 
932
        if (high > fil_space_get_size(space)) {
 
933
                high = fil_space_get_size(space);
 
934
        }
 
935
 
 
936
        buf_pool_mutex_enter();
 
937
 
 
938
        for (i = low; i < high; i++) {
 
939
 
 
940
                bpage = buf_page_hash_get(space, i);
 
941
 
 
942
                if (!bpage) {
 
943
 
 
944
                        continue;
 
945
                }
 
946
 
 
947
                ut_a(buf_page_in_file(bpage));
 
948
 
 
949
                /* We avoid flushing 'non-old' blocks in an LRU flush,
 
950
                because the flushed blocks are soon freed */
 
951
 
 
952
                if (flush_type != BUF_FLUSH_LRU
 
953
                    || i == offset
 
954
                    || buf_page_is_old(bpage)) {
 
955
                        mutex_t* block_mutex = buf_page_get_mutex(bpage);
 
956
 
 
957
                        mutex_enter(block_mutex);
 
958
 
 
959
                        if (buf_flush_ready_for_flush(bpage, flush_type)
 
960
                            && (i == offset || !bpage->buf_fix_count)) {
 
961
                                /* We only try to flush those
 
962
                                neighbors != offset where the buf fix count is
 
963
                                zero, as we then know that we probably can
 
964
                                latch the page without a semaphore wait.
 
965
                                Semaphore waits are expensive because we must
 
966
                                flush the doublewrite buffer before we start
 
967
                                waiting. */
 
968
 
 
969
                                buf_flush_page(bpage, flush_type);
 
970
                                ut_ad(!mutex_own(block_mutex));
 
971
                                count++;
 
972
 
 
973
                                buf_pool_mutex_enter();
 
974
                        } else {
 
975
                                mutex_exit(block_mutex);
 
976
                        }
 
977
                }
 
978
        }
 
979
 
 
980
        buf_pool_mutex_exit();
 
981
 
 
982
        return(count);
 
983
}
 
984
 
 
985
/*******************************************************************//**
 
986
This utility flushes dirty blocks from the end of the LRU list or flush_list.
 
987
NOTE 1: in the case of an LRU flush the calling thread may own latches to
 
988
pages: to avoid deadlocks, this function must be written so that it cannot
 
989
end up waiting for these latches! NOTE 2: in the case of a flush list flush,
 
990
the calling thread is not allowed to own any latches on pages!
 
991
@return number of blocks for which the write request was queued;
 
992
ULINT_UNDEFINED if there was a flush of the same type already running */
 
993
UNIV_INTERN
 
994
ulint
 
995
buf_flush_batch(
 
996
/*============*/
 
997
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU or
 
998
                                        BUF_FLUSH_LIST; if BUF_FLUSH_LIST,
 
999
                                        then the caller must not own any
 
1000
                                        latches on pages */
 
1001
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
 
1002
                                        flushed (it is not guaranteed that the
 
1003
                                        actual number is that big, though) */
 
1004
        ib_uint64_t     lsn_limit)      /*!< in the case BUF_FLUSH_LIST all
 
1005
                                        blocks whose oldest_modification is
 
1006
                                        smaller than this should be flushed
 
1007
                                        (if their number does not exceed
 
1008
                                        min_n), otherwise ignored */
 
1009
{
 
1010
        buf_page_t*     bpage;
 
1011
        ulint           page_count      = 0;
 
1012
        ulint           old_page_count;
 
1013
        ulint           space;
 
1014
        ulint           offset;
 
1015
 
 
1016
        ut_ad((flush_type == BUF_FLUSH_LRU)
 
1017
              || (flush_type == BUF_FLUSH_LIST));
 
1018
#ifdef UNIV_SYNC_DEBUG
 
1019
        ut_ad((flush_type != BUF_FLUSH_LIST)
 
1020
              || sync_thread_levels_empty_gen(TRUE));
 
1021
#endif /* UNIV_SYNC_DEBUG */
 
1022
        buf_pool_mutex_enter();
 
1023
 
 
1024
        if ((buf_pool->n_flush[flush_type] > 0)
 
1025
            || (buf_pool->init_flush[flush_type] == TRUE)) {
 
1026
 
 
1027
                /* There is already a flush batch of the same type running */
 
1028
 
 
1029
                buf_pool_mutex_exit();
 
1030
 
 
1031
                return(ULINT_UNDEFINED);
 
1032
        }
 
1033
 
 
1034
        buf_pool->init_flush[flush_type] = TRUE;
 
1035
 
 
1036
        bool done_with_loop= false;
 
1037
        for (;done_with_loop != true;) {
 
1038
flush_next:
 
1039
                /* If we have flushed enough, leave the loop */
 
1040
                if (page_count >= min_n) {
 
1041
 
 
1042
                        break;
 
1043
                }
 
1044
 
 
1045
                /* Start from the end of the list looking for a suitable
 
1046
                block to be flushed. */
 
1047
 
 
1048
                if (flush_type == BUF_FLUSH_LRU) {
 
1049
                        bpage = UT_LIST_GET_LAST(buf_pool->LRU);
 
1050
                } else {
 
1051
                        ut_ad(flush_type == BUF_FLUSH_LIST);
 
1052
 
 
1053
                        bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
 
1054
                        if (!bpage
 
1055
                            || bpage->oldest_modification >= lsn_limit) {
 
1056
                                /* We have flushed enough */
 
1057
 
 
1058
                                break;
 
1059
                        }
 
1060
                        ut_ad(bpage->in_flush_list);
 
1061
                }
 
1062
 
 
1063
                /* Note that after finding a single flushable page, we try to
 
1064
                flush also all its neighbors, and after that start from the
 
1065
                END of the LRU list or flush list again: the list may change
 
1066
                during the flushing and we cannot safely preserve within this
 
1067
                function a pointer to a block in the list! */
 
1068
 
 
1069
                do {
 
1070
                        mutex_t*block_mutex = buf_page_get_mutex(bpage);
 
1071
                        ibool   ready;
 
1072
 
 
1073
                        ut_a(buf_page_in_file(bpage));
 
1074
 
 
1075
                        mutex_enter(block_mutex);
 
1076
                        ready = buf_flush_ready_for_flush(bpage, flush_type);
 
1077
                        mutex_exit(block_mutex);
 
1078
 
 
1079
                        if (ready) {
 
1080
                                space = buf_page_get_space(bpage);
 
1081
                                offset = buf_page_get_page_no(bpage);
 
1082
 
 
1083
                                buf_pool_mutex_exit();
 
1084
 
 
1085
                                old_page_count = page_count;
 
1086
 
 
1087
                                /* Try to flush also all the neighbors */
 
1088
                                page_count += buf_flush_try_neighbors(
 
1089
                                        space, offset, flush_type);
 
1090
                                /* fprintf(stderr,
 
1091
                                "Flush type %lu, page no %lu, neighb %lu\n",
 
1092
                                flush_type, offset,
 
1093
                                page_count - old_page_count); */
 
1094
 
 
1095
                                buf_pool_mutex_enter();
 
1096
                                goto flush_next;
 
1097
 
 
1098
                        } else if (flush_type == BUF_FLUSH_LRU) {
 
1099
                                bpage = UT_LIST_GET_PREV(LRU, bpage);
 
1100
                        } else {
 
1101
                                ut_ad(flush_type == BUF_FLUSH_LIST);
 
1102
 
 
1103
                                bpage = UT_LIST_GET_PREV(list, bpage);
 
1104
                                ut_ad(!bpage || bpage->in_flush_list);
 
1105
                        }
 
1106
                } while (bpage != NULL);
 
1107
 
 
1108
                /* If we could not find anything to flush, leave the loop */
 
1109
 
 
1110
                done_with_loop= true;
 
1111
 
 
1112
        }
 
1113
 
 
1114
        buf_pool->init_flush[flush_type] = FALSE;
 
1115
 
 
1116
        if (buf_pool->n_flush[flush_type] == 0) {
 
1117
 
 
1118
                /* The running flush batch has ended */
 
1119
 
 
1120
                os_event_set(buf_pool->no_flush[flush_type]);
 
1121
        }
 
1122
 
 
1123
        buf_pool_mutex_exit();
 
1124
 
 
1125
        buf_flush_buffered_writes();
 
1126
 
 
1127
#ifdef UNIV_DEBUG
 
1128
        if (buf_debug_prints && page_count > 0) {
 
1129
                ut_a(flush_type == BUF_FLUSH_LRU
 
1130
                     || flush_type == BUF_FLUSH_LIST);
 
1131
                fprintf(stderr, flush_type == BUF_FLUSH_LRU
 
1132
                        ? "Flushed %lu pages in LRU flush\n"
 
1133
                        : "Flushed %lu pages in flush list flush\n",
 
1134
                        (ulong) page_count);
 
1135
        }
 
1136
#endif /* UNIV_DEBUG */
 
1137
 
 
1138
        srv_buf_pool_flushed += page_count;
 
1139
 
 
1140
        /* We keep track of all flushes happening as part of LRU
 
1141
        flush. When estimating the desired rate at which flush_list
 
1142
        should be flushed we factor in this value. */
 
1143
        if (flush_type == BUF_FLUSH_LRU) {
 
1144
                buf_lru_flush_page_count += page_count;
 
1145
        }
 
1146
 
 
1147
        return(page_count);
 
1148
}
 
1149
 
 
1150
/******************************************************************//**
 
1151
Waits until a flush batch of the given type ends */
 
1152
UNIV_INTERN
 
1153
void
 
1154
buf_flush_wait_batch_end(
 
1155
/*=====================*/
 
1156
        enum buf_flush  type)   /*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
 
1157
{
 
1158
        ut_ad((type == BUF_FLUSH_LRU) || (type == BUF_FLUSH_LIST));
 
1159
 
 
1160
        os_event_wait(buf_pool->no_flush[type]);
 
1161
}
 
1162
 
 
1163
/******************************************************************//**
 
1164
Gives a recommendation of how many blocks should be flushed to establish
 
1165
a big enough margin of replaceable blocks near the end of the LRU list
 
1166
and in the free list.
 
1167
@return number of blocks which should be flushed from the end of the
 
1168
LRU list */
 
1169
static
 
1170
ulint
 
1171
buf_flush_LRU_recommendation(void)
 
1172
/*==============================*/
 
1173
{
 
1174
        buf_page_t*     bpage;
 
1175
        ulint           n_replaceable;
 
1176
        ulint           distance        = 0;
 
1177
 
 
1178
        buf_pool_mutex_enter();
 
1179
 
 
1180
        n_replaceable = UT_LIST_GET_LEN(buf_pool->free);
 
1181
 
 
1182
        bpage = UT_LIST_GET_LAST(buf_pool->LRU);
 
1183
 
 
1184
        while ((bpage != NULL)
 
1185
               && (n_replaceable < BUF_FLUSH_FREE_BLOCK_MARGIN
 
1186
                   + BUF_FLUSH_EXTRA_MARGIN)
 
1187
               && (distance < BUF_LRU_FREE_SEARCH_LEN)) {
 
1188
 
 
1189
                mutex_t* block_mutex = buf_page_get_mutex(bpage);
 
1190
 
 
1191
                mutex_enter(block_mutex);
 
1192
 
 
1193
                if (buf_flush_ready_for_replace(bpage)) {
 
1194
                        n_replaceable++;
 
1195
                }
 
1196
 
 
1197
                mutex_exit(block_mutex);
 
1198
 
 
1199
                distance++;
 
1200
 
 
1201
                bpage = UT_LIST_GET_PREV(LRU, bpage);
 
1202
        }
 
1203
 
 
1204
        buf_pool_mutex_exit();
 
1205
 
 
1206
        if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN) {
 
1207
 
 
1208
                return(0);
 
1209
        }
 
1210
 
 
1211
        return(BUF_FLUSH_FREE_BLOCK_MARGIN + BUF_FLUSH_EXTRA_MARGIN
 
1212
               - n_replaceable);
 
1213
}
 
1214
 
 
1215
/*********************************************************************//**
 
1216
Flushes pages from the end of the LRU list if there is too small a margin
 
1217
of replaceable pages there or in the free list. VERY IMPORTANT: this function
 
1218
is called also by threads which have locks on pages. To avoid deadlocks, we
 
1219
flush only pages such that the s-lock required for flushing can be acquired
 
1220
immediately, without waiting. */
 
1221
UNIV_INTERN
 
1222
void
 
1223
buf_flush_free_margin(void)
 
1224
/*=======================*/
 
1225
{
 
1226
        ulint   n_to_flush;
 
1227
        ulint   n_flushed;
 
1228
 
 
1229
        n_to_flush = buf_flush_LRU_recommendation();
 
1230
 
 
1231
        if (n_to_flush > 0) {
 
1232
                n_flushed = buf_flush_batch(BUF_FLUSH_LRU, n_to_flush, 0);
 
1233
                if (n_flushed == ULINT_UNDEFINED) {
 
1234
                        /* There was an LRU type flush batch already running;
 
1235
                        let us wait for it to end */
 
1236
 
 
1237
                        buf_flush_wait_batch_end(BUF_FLUSH_LRU);
 
1238
                }
 
1239
        }
 
1240
}
 
1241
 
 
1242
/*********************************************************************
 
1243
Update the historical stats that we are collecting for flush rate
 
1244
heuristics at the end of each interval.
 
1245
Flush rate heuristic depends on (a) rate of redo log generation and
 
1246
(b) the rate at which LRU flush is happening. */
 
1247
UNIV_INTERN
 
1248
void
 
1249
buf_flush_stat_update(void)
 
1250
/*=======================*/
 
1251
{
 
1252
        buf_flush_stat_t*       item;
 
1253
        ib_uint64_t             lsn_diff;
 
1254
        ib_uint64_t             lsn;
 
1255
        ulint                   n_flushed;
 
1256
 
 
1257
        lsn = log_get_lsn();
 
1258
        if (buf_flush_stat_cur.redo == 0) {
 
1259
                /* First time around. Just update the current LSN
 
1260
                and return. */
 
1261
                buf_flush_stat_cur.redo = lsn;
 
1262
                return;
 
1263
        }
 
1264
 
 
1265
        item = &buf_flush_stat_arr[buf_flush_stat_arr_ind];
 
1266
 
 
1267
        /* values for this interval */
 
1268
        lsn_diff = lsn - buf_flush_stat_cur.redo;
 
1269
        n_flushed = buf_lru_flush_page_count
 
1270
                    - buf_flush_stat_cur.n_flushed;
 
1271
 
 
1272
        /* add the current value and subtract the obsolete entry. */
 
1273
        buf_flush_stat_sum.redo += lsn_diff - item->redo;
 
1274
        buf_flush_stat_sum.n_flushed += n_flushed - item->n_flushed;
 
1275
 
 
1276
        /* put current entry in the array. */
 
1277
        item->redo = lsn_diff;
 
1278
        item->n_flushed = n_flushed;
 
1279
 
 
1280
        /* update the index */
 
1281
        buf_flush_stat_arr_ind++;
 
1282
        buf_flush_stat_arr_ind %= BUF_FLUSH_STAT_N_INTERVAL;
 
1283
 
 
1284
        /* reset the current entry. */
 
1285
        buf_flush_stat_cur.redo = lsn;
 
1286
        buf_flush_stat_cur.n_flushed = buf_lru_flush_page_count;
 
1287
}
 
1288
 
 
1289
/*********************************************************************
 
1290
Determines the fraction of dirty pages that need to be flushed based
 
1291
on the speed at which we generate redo log. Note that if redo log
 
1292
is generated at a significant rate without corresponding increase
 
1293
in the number of dirty pages (for example, an in-memory workload)
 
1294
it can cause IO bursts of flushing. This function implements heuristics
 
1295
to avoid this burstiness.
 
1296
@return number of dirty pages to be flushed / second */
 
1297
UNIV_INTERN
 
1298
ulint
 
1299
buf_flush_get_desired_flush_rate(void)
 
1300
/*==================================*/
 
1301
{
 
1302
        ulint                   redo_avg;
 
1303
        ulint                   lru_flush_avg;
 
1304
        ulint                   n_dirty;
 
1305
        ulint                   n_flush_req;
 
1306
        lint                    rate;
 
1307
        ib_uint64_t             lsn = log_get_lsn();
 
1308
        ulint                   log_capacity = log_get_capacity();
 
1309
 
 
1310
        /* log_capacity should never be zero after the initialization
 
1311
        of log subsystem. */
 
1312
        ut_ad(log_capacity != 0);
 
1313
 
 
1314
        /* Get total number of dirty pages. It is OK to access
 
1315
        flush_list without holding any mtex as we are using this
 
1316
        only for heuristics. */
 
1317
        n_dirty = UT_LIST_GET_LEN(buf_pool->flush_list);
 
1318
 
 
1319
        /* An overflow can happen if we generate more than 2^32 bytes
 
1320
        of redo in this interval i.e.: 4G of redo in 1 second. We can
 
1321
        safely consider this as infinity because if we ever come close
 
1322
        to 4G we'll start a synchronous flush of dirty pages. */
 
1323
        /* redo_avg below is average at which redo is generated in
 
1324
        past BUF_FLUSH_STAT_N_INTERVAL + redo generated in the current
 
1325
        interval. */
 
1326
        redo_avg = (ulint) (buf_flush_stat_sum.redo
 
1327
                            / BUF_FLUSH_STAT_N_INTERVAL
 
1328
                            + (lsn - buf_flush_stat_cur.redo));
 
1329
 
 
1330
        /* An overflow can happen possibly if we flush more than 2^32
 
1331
        pages in BUF_FLUSH_STAT_N_INTERVAL. This is a very very
 
1332
        unlikely scenario. Even when this happens it means that our
 
1333
        flush rate will be off the mark. It won't affect correctness
 
1334
        of any subsystem. */
 
1335
        /* lru_flush_avg below is rate at which pages are flushed as
 
1336
        part of LRU flush in past BUF_FLUSH_STAT_N_INTERVAL + the
 
1337
        number of pages flushed in the current interval. */
 
1338
        lru_flush_avg = buf_flush_stat_sum.n_flushed
 
1339
                        / BUF_FLUSH_STAT_N_INTERVAL
 
1340
                        + (buf_lru_flush_page_count
 
1341
                           - buf_flush_stat_cur.n_flushed);
 
1342
 
 
1343
        n_flush_req = (n_dirty * redo_avg) / log_capacity;
 
1344
 
 
1345
        /* The number of pages that we want to flush from the flush
 
1346
        list is the difference between the required rate and the
 
1347
        number of pages that we are historically flushing from the
 
1348
        LRU list */
 
1349
        rate = n_flush_req - lru_flush_avg;
 
1350
        return(rate > 0 ? (ulint) rate : 0);
 
1351
}
 
1352
 
 
1353
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 
1354
/******************************************************************//**
 
1355
Validates the flush list.
 
1356
@return TRUE if ok */
 
1357
static
 
1358
ibool
 
1359
buf_flush_validate_low(void)
 
1360
/*========================*/
 
1361
{
 
1362
        buf_page_t*     bpage;
 
1363
 
 
1364
        UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list,
 
1365
                         ut_ad(ut_list_node_313->in_flush_list));
 
1366
 
 
1367
        bpage = UT_LIST_GET_FIRST(buf_pool->flush_list);
 
1368
 
 
1369
        while (bpage != NULL) {
 
1370
                const ib_uint64_t om = bpage->oldest_modification;
 
1371
                ut_ad(bpage->in_flush_list);
 
1372
                ut_a(buf_page_in_file(bpage));
 
1373
                ut_a(om > 0);
 
1374
 
 
1375
                bpage = UT_LIST_GET_NEXT(list, bpage);
 
1376
 
 
1377
                ut_a(!bpage || om >= bpage->oldest_modification);
 
1378
        }
 
1379
 
 
1380
        return(TRUE);
 
1381
}
 
1382
 
 
1383
/******************************************************************//**
 
1384
Validates the flush list.
 
1385
@return TRUE if ok */
 
1386
UNIV_INTERN
 
1387
ibool
 
1388
buf_flush_validate(void)
 
1389
/*====================*/
 
1390
{
 
1391
        ibool   ret;
 
1392
 
 
1393
        buf_pool_mutex_enter();
 
1394
 
 
1395
        ret = buf_flush_validate_low();
 
1396
 
 
1397
        buf_pool_mutex_exit();
 
1398
 
 
1399
        return(ret);
 
1400
}
 
1401
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
1402
#endif /* !UNIV_HOTBACKUP */