← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: lbieber
  • Date: 2010-10-01 12:16:18 UTC
  • mfrom: (1802.1.1 fix-bug-651256)
  • Revision ID: lbieber@orisndriz08-20101001121618-uqcboygpjwbiglem
Merge Vijay - fix bug 651256 - Remove --help-extended

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/buf/buf0flu.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
11
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
12
 
13
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
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
16
16
 
17
17
*****************************************************************************/
18
18
 
83
83
@return TRUE if ok */
84
84
static
85
85
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
 
}
 
86
buf_flush_validate_low(void);
 
87
/*========================*/
 
88
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
256
89
 
257
90
/********************************************************************//**
258
91
Inserts a modified block into the flush list. */
260
93
void
261
94
buf_flush_insert_into_flush_list(
262
95
/*=============================*/
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 */
 
96
        buf_block_t*    block)  /*!< in/out: block which is modified */
266
97
{
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
 
 
 
98
        ut_ad(buf_pool_mutex_own());
273
99
        ut_ad((UT_LIST_GET_FIRST(buf_pool->flush_list) == NULL)
274
100
              || (UT_LIST_GET_FIRST(buf_pool->flush_list)->oldest_modification
275
 
                  <= lsn));
276
 
 
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);
282
 
                return;
283
 
        }
 
101
                  <= block->page.oldest_modification));
284
102
 
285
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);
286
107
        ut_ad(!block->page.in_flush_list);
287
 
 
288
108
        ut_d(block->page.in_flush_list = TRUE);
289
 
        block->page.oldest_modification = lsn;
290
109
        UT_LIST_ADD_FIRST(list, buf_pool->flush_list, &block->page);
291
110
 
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
111
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
304
 
        ut_a(buf_flush_validate_low(buf_pool));
 
112
        ut_a(buf_flush_validate_low());
305
113
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
306
 
 
307
 
        buf_flush_list_mutex_exit(buf_pool);
308
114
}
309
115
 
310
116
/********************************************************************//**
315
121
void
316
122
buf_flush_insert_sorted_into_flush_list(
317
123
/*====================================*/
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 */
 
124
        buf_block_t*    block)  /*!< in/out: block which is modified */
321
125
{
322
126
        buf_page_t*     prev_b;
323
127
        buf_page_t*     b;
324
128
 
325
 
        ut_ad(!buf_pool_mutex_own(buf_pool));
326
 
        ut_ad(log_flush_order_mutex_own());
327
 
        ut_ad(mutex_own(&block->mutex));
 
129
        ut_ad(buf_pool_mutex_own());
328
130
        ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
329
131
 
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
132
        ut_ad(block->page.in_LRU_list);
343
133
        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
134
        ut_ad(!block->page.in_zip_hash);
347
 
 
348
135
        ut_ad(!block->page.in_flush_list);
349
136
        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 */
375
137
 
376
138
        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
 
                }
 
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);
398
145
        }
399
146
 
400
147
        if (prev_b == NULL) {
405
152
        }
406
153
 
407
154
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
408
 
        ut_a(buf_flush_validate_low(buf_pool));
 
155
        ut_a(buf_flush_validate_low());
409
156
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
410
 
 
411
 
        buf_flush_list_mutex_exit(buf_pool);
412
157
}
413
158
 
414
159
/********************************************************************//**
422
167
        buf_page_t*     bpage)  /*!< in: buffer control block, must be
423
168
                                buf_page_in_file(bpage) and in the LRU list */
424
169
{
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
 
170
        ut_ad(buf_pool_mutex_own());
429
171
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
430
172
        ut_ad(bpage->in_LRU_list);
431
173
 
458
200
                                buf_page_in_file(bpage) */
459
201
        enum buf_flush  flush_type)/*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
460
202
{
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
203
        ut_a(buf_page_in_file(bpage));
 
204
        ut_ad(buf_pool_mutex_own());
466
205
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
467
206
        ut_ad(flush_type == BUF_FLUSH_LRU || BUF_FLUSH_LIST);
468
207
 
495
234
/*=============*/
496
235
        buf_page_t*     bpage)  /*!< in: pointer to the block in question */
497
236
{
498
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
499
 
 
500
 
        ut_ad(buf_pool_mutex_own(buf_pool));
 
237
        ut_ad(buf_pool_mutex_own());
501
238
        ut_ad(mutex_own(buf_page_get_mutex(bpage)));
502
239
        ut_ad(bpage->in_flush_list);
503
 
 
504
 
        buf_flush_list_mutex_enter(buf_pool);
 
240
        ut_d(bpage->in_flush_list = FALSE);
505
241
 
506
242
        switch (buf_page_get_state(bpage)) {
507
243
        case BUF_BLOCK_ZIP_PAGE:
508
 
                /* Clean compressed pages should not be on the flush list */
 
244
                /* clean compressed pages should not be on the flush list */
509
245
        case BUF_BLOCK_ZIP_FREE:
510
246
        case BUF_BLOCK_NOT_USED:
511
247
        case BUF_BLOCK_READY_FOR_USE:
523
259
                break;
524
260
        }
525
261
 
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
262
        bpage->oldest_modification = 0;
536
263
 
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);
 
264
        ut_d(UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list,
 
265
                              ut_ad(ut_list_node_313->in_flush_list)));
620
266
}
621
267
 
622
268
/********************************************************************//**
628
274
        buf_page_t*     bpage)  /*!< in: pointer to the block in question */
629
275
{
630
276
        enum buf_flush  flush_type;
631
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
632
277
 
633
278
        ut_ad(bpage);
634
279
 
649
294
        /* fprintf(stderr, "n pending flush %lu\n",
650
295
        buf_pool->n_flush[flush_type]); */
651
296
 
652
 
        if (buf_pool->n_flush[flush_type] == 0
653
 
            && buf_pool->init_flush[flush_type] == FALSE) {
 
297
        if ((buf_pool->n_flush[flush_type] == 0)
 
298
            && (buf_pool->init_flush[flush_type] == FALSE)) {
654
299
 
655
300
                /* The running flush batch has ended */
656
301
 
659
304
}
660
305
 
661
306
/********************************************************************//**
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
 
/********************************************************************//**
684
307
Flushes possible buffered writes from the doublewrite memory buffer to disk,
685
308
and also wakes up the aio thread if simulated aio is used. It is very
686
309
important to call this function after a batch of writes has been posted,
697
320
        ulint           i;
698
321
 
699
322
        if (!srv_use_doublewrite_buf || trx_doublewrite == NULL) {
700
 
                /* Sync the writes to the disk. */
701
 
                buf_flush_sync_datafiles();
 
323
                os_aio_simulated_wake_handler_threads();
 
324
 
702
325
                return;
703
326
        }
704
327
 
906
529
                buf_LRU_stat_inc_io();
907
530
        }
908
531
 
909
 
        /* Sync the writes to the disk. */
910
 
        buf_flush_sync_datafiles();
 
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);
911
545
 
912
546
        /* We can now reuse the doublewrite memory buffer: */
 
547
 
913
548
        trx_doublewrite->first_free = 0;
914
549
 
915
550
        mutex_exit(&(trx_doublewrite->mutex));
943
578
        zip_size = buf_page_get_zip_size(bpage);
944
579
 
945
580
        if (UNIV_UNLIKELY(zip_size)) {
946
 
                UNIV_MEM_ASSERT_RW(bpage->zip.data, zip_size);
947
581
                /* Copy the compressed page and clear the rest. */
948
582
                memcpy(trx_doublewrite->write_buf
949
583
                       + UNIV_PAGE_SIZE * trx_doublewrite->first_free,
953
587
                       + zip_size, 0, UNIV_PAGE_SIZE - zip_size);
954
588
        } else {
955
589
                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
590
 
959
591
                memcpy(trx_doublewrite->write_buf
960
592
                       + UNIV_PAGE_SIZE * trx_doublewrite->first_free,
992
624
        ut_ad(page);
993
625
 
994
626
        if (page_zip_) {
995
 
                page_zip_des_t* page_zip = static_cast<page_zip_des_t *>(page_zip_);
 
627
                page_zip_des_t* page_zip = page_zip_;
996
628
                ulint           zip_size = page_zip_get_size(page_zip);
997
629
                ut_ad(zip_size);
998
630
                ut_ad(ut_is_2pow(zip_size));
1010
642
                case FIL_PAGE_TYPE_ZBLOB:
1011
643
                case FIL_PAGE_TYPE_ZBLOB2:
1012
644
                case FIL_PAGE_INDEX:
1013
 
                        mach_write_to_8(page_zip->data
1014
 
                                        + FIL_PAGE_LSN, newest_lsn);
 
645
                        mach_write_ull(page_zip->data
 
646
                                       + FIL_PAGE_LSN, newest_lsn);
1015
647
                        memset(page_zip->data + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
1016
648
                        mach_write_to_4(page_zip->data
1017
649
                                        + FIL_PAGE_SPACE_OR_CHKSUM,
1033
665
        }
1034
666
 
1035
667
        /* Write the newest modification lsn to the page header and trailer */
1036
 
        mach_write_to_8(page + FIL_PAGE_LSN, newest_lsn);
 
668
        mach_write_ull(page + FIL_PAGE_LSN, newest_lsn);
1037
669
 
1038
 
        mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
1039
 
                        newest_lsn);
 
670
        mach_write_ull(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
 
671
                       newest_lsn);
1040
672
 
1041
673
        /* Store the new formula checksum */
1042
674
 
1069
701
{
1070
702
        ulint   zip_size        = buf_page_get_zip_size(bpage);
1071
703
        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
704
#ifdef UNIV_LOG_DEBUG
1079
705
        static ibool univ_log_debug_warned;
1080
706
#endif /* UNIV_LOG_DEBUG */
1081
707
 
1082
708
        ut_ad(buf_page_in_file(bpage));
1083
709
 
1084
 
        /* We are not holding buf_pool->mutex or block_mutex here.
 
710
        /* We are not holding buf_pool_mutex or block_mutex here.
1085
711
        Nevertheless, it is safe to access bpage, because it is
1086
712
        io_fixed and oldest_modification != 0.  Thus, it cannot be
1087
713
        relocated in the buffer pool or removed from flush_list or
1088
714
        LRU_list. */
1089
 
        ut_ad(!buf_pool_mutex_own(buf_pool));
1090
 
        ut_ad(!buf_flush_list_mutex_own(buf_pool));
 
715
        ut_ad(!buf_pool_mutex_own());
1091
716
        ut_ad(!mutex_own(buf_page_get_mutex(bpage)));
1092
717
        ut_ad(buf_page_get_io_fix(bpage) == BUF_IO_WRITE);
1093
718
        ut_ad(bpage->oldest_modification != 0);
1124
749
                        ut_a(mach_read_from_4(frame + FIL_PAGE_SPACE_OR_CHKSUM)
1125
750
                             == page_zip_calc_checksum(frame, zip_size));
1126
751
                }
1127
 
                mach_write_to_8(frame + FIL_PAGE_LSN,
1128
 
                                bpage->newest_modification);
 
752
                mach_write_ull(frame + FIL_PAGE_LSN,
 
753
                               bpage->newest_modification);
1129
754
                memset(frame + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
1130
755
                break;
1131
756
        case BUF_BLOCK_FILE_PAGE:
1152
777
        }
1153
778
}
1154
779
 
1155
 
# if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
1156
 
/********************************************************************//**
1157
 
Writes a flushable page asynchronously from the buffer pool to a file.
1158
 
NOTE: buf_pool->mutex and block->mutex must be held upon entering this
1159
 
function, and they will be released by this function after flushing.
1160
 
This is loosely based on buf_flush_batch() and buf_flush_page().
1161
 
@return TRUE if the page was flushed and the mutexes released */
1162
 
UNIV_INTERN
1163
 
ibool
1164
 
buf_flush_page_try(
1165
 
/*===============*/
1166
 
        buf_pool_t*     buf_pool,       /*!< in/out: buffer pool instance */
1167
 
        buf_block_t*    block)          /*!< in/out: buffer control block */
1168
 
{
1169
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1170
 
        ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
1171
 
        ut_ad(mutex_own(&block->mutex));
1172
 
 
1173
 
        if (!buf_flush_ready_for_flush(&block->page, BUF_FLUSH_LRU)) {
1174
 
                return(FALSE);
1175
 
        }
1176
 
 
1177
 
        if (buf_pool->n_flush[BUF_FLUSH_LRU] > 0
1178
 
            || buf_pool->init_flush[BUF_FLUSH_LRU]) {
1179
 
                /* There is already a flush batch of the same type running */
1180
 
                return(FALSE);
1181
 
        }
1182
 
 
1183
 
        buf_pool->init_flush[BUF_FLUSH_LRU] = TRUE;
1184
 
 
1185
 
        buf_page_set_io_fix(&block->page, BUF_IO_WRITE);
1186
 
 
1187
 
        buf_page_set_flush_type(&block->page, BUF_FLUSH_LRU);
1188
 
 
1189
 
        if (buf_pool->n_flush[BUF_FLUSH_LRU]++ == 0) {
1190
 
 
1191
 
                os_event_reset(buf_pool->no_flush[BUF_FLUSH_LRU]);
1192
 
        }
1193
 
 
1194
 
        /* VERY IMPORTANT:
1195
 
        Because any thread may call the LRU flush, even when owning
1196
 
        locks on pages, to avoid deadlocks, we must make sure that the
1197
 
        s-lock is acquired on the page without waiting: this is
1198
 
        accomplished because buf_flush_ready_for_flush() must hold,
1199
 
        and that requires the page not to be bufferfixed. */
1200
 
 
1201
 
        rw_lock_s_lock_gen(&block->lock, BUF_IO_WRITE);
1202
 
 
1203
 
        /* Note that the s-latch is acquired before releasing the
1204
 
        buf_pool mutex: this ensures that the latch is acquired
1205
 
        immediately. */
1206
 
 
1207
 
        mutex_exit(&block->mutex);
1208
 
        buf_pool_mutex_exit(buf_pool);
1209
 
 
1210
 
        /* Even though block is not protected by any mutex at this
1211
 
        point, it is safe to access block, because it is io_fixed and
1212
 
        oldest_modification != 0.  Thus, it cannot be relocated in the
1213
 
        buffer pool or removed from flush_list or LRU_list. */
1214
 
 
1215
 
        buf_flush_write_block_low(&block->page);
1216
 
 
1217
 
        buf_pool_mutex_enter(buf_pool);
1218
 
        buf_pool->init_flush[BUF_FLUSH_LRU] = FALSE;
1219
 
 
1220
 
        if (buf_pool->n_flush[BUF_FLUSH_LRU] == 0) {
1221
 
                /* The running flush batch has ended */
1222
 
                os_event_set(buf_pool->no_flush[BUF_FLUSH_LRU]);
1223
 
        }
1224
 
 
1225
 
        buf_pool_mutex_exit(buf_pool);
1226
 
        buf_flush_buffered_writes();
1227
 
 
1228
 
        return(TRUE);
1229
 
}
1230
 
# endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
1231
 
 
1232
780
/********************************************************************//**
1233
781
Writes a flushable page asynchronously from the buffer pool to a file.
1234
782
NOTE: in simulated aio we must call
1235
783
os_aio_simulated_wake_handler_threads after we have posted a batch of
1236
 
writes! NOTE: buf_pool->mutex and buf_page_get_mutex(bpage) must be
 
784
writes! NOTE: buf_pool_mutex and buf_page_get_mutex(bpage) must be
1237
785
held upon entering this function, and they will be released by this
1238
786
function. */
1239
787
static
1240
788
void
1241
789
buf_flush_page(
1242
790
/*===========*/
1243
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1244
791
        buf_page_t*     bpage,          /*!< in: buffer control block */
1245
792
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU
1246
793
                                        or BUF_FLUSH_LIST */
1249
796
        ibool           is_uncompressed;
1250
797
 
1251
798
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
1252
 
        ut_ad(buf_pool_mutex_own(buf_pool));
 
799
        ut_ad(buf_pool_mutex_own());
1253
800
        ut_ad(buf_page_in_file(bpage));
1254
801
 
1255
802
        block_mutex = buf_page_get_mutex(bpage);
1269
816
        buf_pool->n_flush[flush_type]++;
1270
817
 
1271
818
        is_uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
1272
 
        ut_ad(is_uncompressed == (block_mutex != &buf_pool->zip_mutex));
 
819
        ut_ad(is_uncompressed == (block_mutex != &buf_pool_zip_mutex));
1273
820
 
1274
821
        switch (flush_type) {
1275
822
                ibool   is_s_latched;
1285
832
                }
1286
833
 
1287
834
                mutex_exit(block_mutex);
1288
 
                buf_pool_mutex_exit(buf_pool);
 
835
                buf_pool_mutex_exit();
1289
836
 
1290
837
                /* Even though bpage is not protected by any mutex at
1291
838
                this point, it is safe to access bpage, because it is
1322
869
                immediately. */
1323
870
 
1324
871
                mutex_exit(block_mutex);
1325
 
                buf_pool_mutex_exit(buf_pool);
 
872
                buf_pool_mutex_exit();
1326
873
                break;
1327
874
 
1328
875
        default:
1353
900
/*====================*/
1354
901
        ulint           space,          /*!< in: space id */
1355
902
        ulint           offset,         /*!< in: page offset */
1356
 
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU or
 
903
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU or
1357
904
                                        BUF_FLUSH_LIST */
1358
 
        ulint           n_flushed,      /*!< in: number of pages
1359
 
                                        flushed so far in this batch */
1360
 
        ulint           n_to_flush)     /*!< in: maximum number of pages
1361
 
                                        we are allowed to flush */
1362
905
{
 
906
        buf_page_t*     bpage;
 
907
        ulint           low, high;
 
908
        ulint           count           = 0;
1363
909
        ulint           i;
1364
 
        ulint           low;
1365
 
        ulint           high;
1366
 
        ulint           count = 0;
1367
 
        buf_pool_t*     buf_pool = buf_pool_get(space, offset);
1368
910
 
1369
911
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
1370
912
 
1371
913
        if (UT_LIST_GET_LEN(buf_pool->LRU) < BUF_LRU_OLD_MIN_LEN) {
1372
 
                /* If there is little space, it is better not to flush
1373
 
                any block except from the end of the LRU list */
 
914
                /* If there is little space, it is better not to flush any
 
915
                block except from the end of the LRU list */
1374
916
 
1375
917
                low = offset;
1376
918
                high = offset + 1;
1377
919
        } else {
1378
 
                /* When flushed, dirty blocks are searched in
1379
 
                neighborhoods of this size, and flushed along with the
1380
 
                original page. */
 
920
                /* When flushed, dirty blocks are searched in neighborhoods of
 
921
                this size, and flushed along with the original page. */
1381
922
 
1382
 
                ulint   buf_flush_area;
1383
 
        
1384
 
                buf_flush_area  = ut_min(
1385
 
                        BUF_READ_AHEAD_AREA(buf_pool),
1386
 
                        buf_pool->curr_size / 16);
 
923
                ulint   buf_flush_area  = ut_min(BUF_READ_AHEAD_AREA,
 
924
                                                 buf_pool->curr_size / 16);
1387
925
 
1388
926
                low = (offset / buf_flush_area) * buf_flush_area;
1389
927
                high = (offset / buf_flush_area + 1) * buf_flush_area;
1395
933
                high = fil_space_get_size(space);
1396
934
        }
1397
935
 
 
936
        buf_pool_mutex_enter();
 
937
 
1398
938
        for (i = low; i < high; i++) {
1399
939
 
1400
 
                buf_page_t*     bpage;
1401
 
 
1402
 
                if ((count + n_flushed) >= n_to_flush) {
1403
 
 
1404
 
                        /* We have already flushed enough pages and
1405
 
                        should call it a day. There is, however, one
1406
 
                        exception. If the page whose neighbors we
1407
 
                        are flushing has not been flushed yet then
1408
 
                        we'll try to flush the victim that we
1409
 
                        selected originally. */
1410
 
                        if (i <= offset) {
1411
 
                                i = offset;
1412
 
                        } else {
1413
 
                                break;
1414
 
                        }
1415
 
                }
1416
 
 
1417
 
                buf_pool = buf_pool_get(space, i);
1418
 
 
1419
 
                buf_pool_mutex_enter(buf_pool);
1420
 
 
1421
 
                /* We only want to flush pages from this buffer pool. */
1422
 
                bpage = buf_page_hash_get(buf_pool, space, i);
 
940
                bpage = buf_page_hash_get(space, i);
1423
941
 
1424
942
                if (!bpage) {
1425
943
 
1426
 
                        buf_pool_mutex_exit(buf_pool);
1427
944
                        continue;
1428
945
                }
1429
946
 
1442
959
                        if (buf_flush_ready_for_flush(bpage, flush_type)
1443
960
                            && (i == offset || !bpage->buf_fix_count)) {
1444
961
                                /* We only try to flush those
1445
 
                                neighbors != offset where the buf fix
1446
 
                                count is zero, as we then know that we
1447
 
                                probably can latch the page without a
1448
 
                                semaphore wait. Semaphore waits are
1449
 
                                expensive because we must flush the
1450
 
                                doublewrite buffer before we start
 
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
1451
967
                                waiting. */
1452
968
 
1453
 
                                buf_flush_page(buf_pool, bpage, flush_type);
 
969
                                buf_flush_page(bpage, flush_type);
1454
970
                                ut_ad(!mutex_own(block_mutex));
1455
 
                                ut_ad(!buf_pool_mutex_own(buf_pool));
1456
971
                                count++;
1457
 
                                continue;
 
972
 
 
973
                                buf_pool_mutex_enter();
1458
974
                        } else {
1459
975
                                mutex_exit(block_mutex);
1460
976
                        }
1461
977
                }
1462
 
                buf_pool_mutex_exit(buf_pool);
1463
 
        }
1464
 
 
1465
 
        return(count);
1466
 
}
1467
 
 
1468
 
/********************************************************************//**
1469
 
Check if the block is modified and ready for flushing. If the the block
1470
 
is ready to flush then flush the page and try o flush its neighbors.
1471
 
 
1472
 
@return TRUE if buf_pool mutex was not released during this function.
1473
 
This does not guarantee that some pages were written as well.
1474
 
Number of pages written are incremented to the count. */
1475
 
static
1476
 
ibool
1477
 
buf_flush_page_and_try_neighbors(
1478
 
/*=============================*/
1479
 
        buf_page_t*     bpage,          /*!< in: buffer control block,
1480
 
                                        must be
1481
 
                                        buf_page_in_file(bpage) */
1482
 
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU
1483
 
                                        or BUF_FLUSH_LIST */
1484
 
        ulint           n_to_flush,     /*!< in: number of pages to
1485
 
                                        flush */
1486
 
        ulint*          count)          /*!< in/out: number of pages
1487
 
                                        flushed */
1488
 
{
1489
 
        mutex_t*        block_mutex;
1490
 
        ibool           flushed = FALSE;
1491
 
#ifdef UNIV_DEBUG
1492
 
        buf_pool_t*     buf_pool = buf_pool_from_bpage(bpage);
1493
 
#endif /* UNIV_DEBUG */
1494
 
 
1495
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1496
 
 
1497
 
        block_mutex = buf_page_get_mutex(bpage);
1498
 
        mutex_enter(block_mutex);
1499
 
 
1500
 
        ut_a(buf_page_in_file(bpage));
1501
 
 
1502
 
        if (buf_flush_ready_for_flush(bpage, flush_type)) {
1503
 
                ulint           space;
1504
 
                ulint           offset;
1505
 
                buf_pool_t*     buf_pool;
1506
 
 
1507
 
                buf_pool = buf_pool_from_bpage(bpage);
1508
 
 
1509
 
                buf_pool_mutex_exit(buf_pool);
1510
 
 
1511
 
                /* These fields are protected by both the
1512
 
                buffer pool mutex and block mutex. */
1513
 
                space = buf_page_get_space(bpage);
1514
 
                offset = buf_page_get_page_no(bpage);
1515
 
 
1516
 
                mutex_exit(block_mutex);
1517
 
 
1518
 
                /* Try to flush also all the neighbors */
1519
 
                *count += buf_flush_try_neighbors(space,
1520
 
                                                  offset,
1521
 
                                                  flush_type,
1522
 
                                                  *count,
1523
 
                                                  n_to_flush);
1524
 
 
1525
 
                buf_pool_mutex_enter(buf_pool);
1526
 
                flushed = TRUE;
1527
 
        } else {
1528
 
                mutex_exit(block_mutex);
1529
 
        }
1530
 
 
1531
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1532
 
 
1533
 
        return(flushed);
1534
 
}
1535
 
 
1536
 
/*******************************************************************//**
1537
 
This utility flushes dirty blocks from the end of the LRU list.
1538
 
In the case of an LRU flush the calling thread may own latches to
1539
 
pages: to avoid deadlocks, this function must be written so that it
1540
 
cannot end up waiting for these latches!
1541
 
@return number of blocks for which the write request was queued. */
1542
 
static
1543
 
ulint
1544
 
buf_flush_LRU_list_batch(
1545
 
/*=====================*/
1546
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1547
 
        ulint           max)            /*!< in: max of blocks to flush */
1548
 
{
1549
 
        buf_page_t*     bpage;
1550
 
        ulint           count = 0;
1551
 
 
1552
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1553
 
 
1554
 
        do {
1555
 
                /* Start from the end of the list looking for a
1556
 
                suitable block to be flushed. */
1557
 
                bpage = UT_LIST_GET_LAST(buf_pool->LRU);
1558
 
 
1559
 
                /* Iterate backwards over the flush list till we find
1560
 
                a page that isn't ready for flushing. */
1561
 
                while (bpage != NULL
1562
 
                       && !buf_flush_page_and_try_neighbors(
1563
 
                                bpage, BUF_FLUSH_LRU, max, &count)) {
1564
 
 
1565
 
                        bpage = UT_LIST_GET_PREV(LRU, bpage);
1566
 
                }
1567
 
        } while (bpage != NULL && count < max);
1568
 
 
1569
 
        /* We keep track of all flushes happening as part of LRU
1570
 
        flush. When estimating the desired rate at which flush_list
1571
 
        should be flushed, we factor in this value. */
1572
 
        buf_lru_flush_page_count += count;
1573
 
 
1574
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1575
 
 
1576
 
        return(count);
1577
 
}
1578
 
 
1579
 
/*******************************************************************//**
1580
 
This utility flushes dirty blocks from the end of the flush_list.
1581
 
the calling thread is not allowed to own any latches on pages!
1582
 
@return number of blocks for which the write request was queued;
1583
 
ULINT_UNDEFINED if there was a flush of the same type already
1584
 
running */
1585
 
static
1586
 
ulint
1587
 
buf_flush_flush_list_batch(
1588
 
/*=======================*/
1589
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1590
 
        ulint           min_n,          /*!< in: wished minimum mumber
1591
 
                                        of blocks flushed (it is not
1592
 
                                        guaranteed that the actual
1593
 
                                        number is that big, though) */
1594
 
        ib_uint64_t     lsn_limit)      /*!< all blocks whose
1595
 
                                        oldest_modification is smaller
1596
 
                                        than this should be flushed (if
1597
 
                                        their number does not exceed
1598
 
                                        min_n) */
1599
 
{
1600
 
        ulint           len;
1601
 
        buf_page_t*     bpage;
1602
 
        ulint           count = 0;
1603
 
 
1604
 
        ut_ad(buf_pool_mutex_own(buf_pool));
1605
 
 
1606
 
        /* If we have flushed enough, leave the loop */
1607
 
        do {
1608
 
                /* Start from the end of the list looking for a suitable
1609
 
                block to be flushed. */
1610
 
 
1611
 
                buf_flush_list_mutex_enter(buf_pool);
1612
 
 
1613
 
                /* We use len here because theoretically insertions can
1614
 
                happen in the flush_list below while we are traversing
1615
 
                it for a suitable candidate for flushing. We'd like to
1616
 
                set a limit on how farther we are willing to traverse
1617
 
                the list. */
1618
 
                len = UT_LIST_GET_LEN(buf_pool->flush_list);
1619
 
                bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
1620
 
 
1621
 
                if (bpage) {
1622
 
                        ut_a(bpage->oldest_modification > 0);
1623
 
                }
1624
 
 
1625
 
                if (!bpage || bpage->oldest_modification >= lsn_limit) {
1626
 
 
1627
 
                        /* We have flushed enough */
1628
 
                        buf_flush_list_mutex_exit(buf_pool);
1629
 
                        break;
1630
 
                }
1631
 
 
1632
 
                ut_a(bpage->oldest_modification > 0);
1633
 
 
1634
 
                ut_ad(bpage->in_flush_list);
1635
 
 
1636
 
                buf_flush_list_mutex_exit(buf_pool);
1637
 
 
1638
 
                /* The list may change during the flushing and we cannot
1639
 
                safely preserve within this function a pointer to a
1640
 
                block in the list! */
1641
 
                while (bpage != NULL
1642
 
                       && len > 0
1643
 
                       && !buf_flush_page_and_try_neighbors(
1644
 
                                bpage, BUF_FLUSH_LIST, min_n, &count)) {
1645
 
 
1646
 
                        buf_flush_list_mutex_enter(buf_pool);
1647
 
 
1648
 
                        /* If we are here that means that buf_pool->mutex
1649
 
                         was not released in buf_flush_page_and_try_neighbors()
1650
 
                        above and this guarantees that bpage didn't get
1651
 
                        relocated since we released the flush_list
1652
 
                        mutex above. There is a chance, however, that
1653
 
                        the bpage got removed from flush_list (not
1654
 
                        currently possible because flush_list_remove()
1655
 
                        also obtains buf_pool mutex but that may change
1656
 
                        in future). To avoid this scenario we check
1657
 
                        the oldest_modification and if it is zero
1658
 
                        we start all over again. */
1659
 
                        if (bpage->oldest_modification == 0) {
1660
 
                                buf_flush_list_mutex_exit(buf_pool);
1661
 
                                break;
1662
 
                        }
1663
 
 
1664
 
                        bpage = UT_LIST_GET_PREV(list, bpage);
1665
 
 
1666
 
                        ut_ad(!bpage || bpage->in_flush_list);
1667
 
 
1668
 
                        buf_flush_list_mutex_exit(buf_pool);
1669
 
 
1670
 
                        --len;
1671
 
                }
1672
 
 
1673
 
        } while (count < min_n && bpage != NULL && len > 0);
1674
 
 
1675
 
        ut_ad(buf_pool_mutex_own(buf_pool));
 
978
        }
 
979
 
 
980
        buf_pool_mutex_exit();
1676
981
 
1677
982
        return(count);
1678
983
}
1685
990
the calling thread is not allowed to own any latches on pages!
1686
991
@return number of blocks for which the write request was queued;
1687
992
ULINT_UNDEFINED if there was a flush of the same type already running */
1688
 
static
 
993
UNIV_INTERN
1689
994
ulint
1690
995
buf_flush_batch(
1691
996
/*============*/
1692
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1693
997
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU or
1694
998
                                        BUF_FLUSH_LIST; if BUF_FLUSH_LIST,
1695
999
                                        then the caller must not own any
1697
1001
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
1698
1002
                                        flushed (it is not guaranteed that the
1699
1003
                                        actual number is that big, though) */
1700
 
        ib_uint64_t     lsn_limit)      /*!< in: in the case of BUF_FLUSH_LIST
1701
 
                                        all blocks whose oldest_modification is
 
1004
        ib_uint64_t     lsn_limit)      /*!< in the case BUF_FLUSH_LIST all
 
1005
                                        blocks whose oldest_modification is
1702
1006
                                        smaller than this should be flushed
1703
1007
                                        (if their number does not exceed
1704
1008
                                        min_n), otherwise ignored */
1705
1009
{
1706
 
        ulint           count   = 0;
 
1010
        buf_page_t*     bpage;
 
1011
        ulint           page_count      = 0;
 
1012
        ulint           old_page_count;
 
1013
        ulint           space;
 
1014
        ulint           offset;
1707
1015
 
1708
 
        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 
1016
        ut_ad((flush_type == BUF_FLUSH_LRU)
 
1017
              || (flush_type == BUF_FLUSH_LIST));
1709
1018
#ifdef UNIV_SYNC_DEBUG
1710
1019
        ut_ad((flush_type != BUF_FLUSH_LIST)
1711
1020
              || sync_thread_levels_empty_gen(TRUE));
1712
1021
#endif /* UNIV_SYNC_DEBUG */
1713
 
 
1714
 
        buf_pool_mutex_enter(buf_pool);
1715
 
 
1716
 
        /* Note: The buffer pool mutex is released and reacquired within
1717
 
        the flush functions. */
1718
 
        switch(flush_type) {
1719
 
        case BUF_FLUSH_LRU:
1720
 
                count = buf_flush_LRU_list_batch(buf_pool, min_n);
1721
 
                break;
1722
 
        case BUF_FLUSH_LIST:
1723
 
                count = buf_flush_flush_list_batch(buf_pool, min_n, lsn_limit);
1724
 
                break;
1725
 
        default:
1726
 
                ut_error;
1727
 
        }
1728
 
 
1729
 
        buf_pool_mutex_exit(buf_pool);
1730
 
 
1731
 
        buf_flush_buffered_writes();
1732
 
 
1733
 
#ifdef UNIV_DEBUG
1734
 
        if (buf_debug_prints && count > 0) {
1735
 
                fprintf(stderr, flush_type == BUF_FLUSH_LRU
1736
 
                        ? "Flushed %lu pages in LRU flush\n"
1737
 
                        : "Flushed %lu pages in flush list flush\n",
1738
 
                        (ulong) count);
1739
 
        }
1740
 
#endif /* UNIV_DEBUG */
1741
 
 
1742
 
        srv_buf_pool_flushed += count;
1743
 
 
1744
 
        return(count);
1745
 
}
1746
 
 
1747
 
/******************************************************************//**
1748
 
Gather the aggregated stats for both flush list and LRU list flushing */
1749
 
static
1750
 
void
1751
 
buf_flush_common(
1752
 
/*=============*/
1753
 
        enum buf_flush  flush_type,     /*!< in: type of flush */
1754
 
        ulint           page_count)     /*!< in: number of pages flushed */
1755
 
{
1756
 
        buf_flush_buffered_writes();
1757
 
 
1758
 
        ut_a(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);
 
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();
1759
1126
 
1760
1127
#ifdef UNIV_DEBUG
1761
1128
        if (buf_debug_prints && page_count > 0) {
 
1129
                ut_a(flush_type == BUF_FLUSH_LRU
 
1130
                     || flush_type == BUF_FLUSH_LIST);
1762
1131
                fprintf(stderr, flush_type == BUF_FLUSH_LRU
1763
1132
                        ? "Flushed %lu pages in LRU flush\n"
1764
1133
                        : "Flushed %lu pages in flush list flush\n",
1768
1137
 
1769
1138
        srv_buf_pool_flushed += page_count;
1770
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. */
1771
1143
        if (flush_type == BUF_FLUSH_LRU) {
1772
 
                /* We keep track of all flushes happening as part of LRU
1773
 
                flush. When estimating the desired rate at which flush_list
1774
 
                should be flushed we factor in this value. */
1775
1144
                buf_lru_flush_page_count += page_count;
1776
1145
        }
1777
 
}
1778
 
 
1779
 
/******************************************************************//**
1780
 
Start a buffer flush batch for LRU or flush list */
1781
 
static
1782
 
ibool
1783
 
buf_flush_start(
1784
 
/*============*/
1785
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1786
 
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU
1787
 
                                        or BUF_FLUSH_LIST */
1788
 
{
1789
 
        buf_pool_mutex_enter(buf_pool);
1790
 
 
1791
 
        if (buf_pool->n_flush[flush_type] > 0
1792
 
           || buf_pool->init_flush[flush_type] == TRUE) {
1793
 
 
1794
 
                /* There is already a flush batch of the same type running */
1795
 
 
1796
 
                buf_pool_mutex_exit(buf_pool);
1797
 
 
1798
 
                return(FALSE);
1799
 
        }
1800
 
 
1801
 
        buf_pool->init_flush[flush_type] = TRUE;
1802
 
 
1803
 
        buf_pool_mutex_exit(buf_pool);
1804
 
 
1805
 
        return(TRUE);
1806
 
}
1807
 
 
1808
 
/******************************************************************//**
1809
 
End a buffer flush batch for LRU or flush list */
1810
 
static
1811
 
void
1812
 
buf_flush_end(
1813
 
/*==========*/
1814
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1815
 
        enum buf_flush  flush_type)     /*!< in: BUF_FLUSH_LRU
1816
 
                                        or BUF_FLUSH_LIST */
1817
 
{
1818
 
        buf_pool_mutex_enter(buf_pool);
1819
 
 
1820
 
        buf_pool->init_flush[flush_type] = FALSE;
1821
 
 
1822
 
        if (buf_pool->n_flush[flush_type] == 0) {
1823
 
 
1824
 
                /* The running flush batch has ended */
1825
 
 
1826
 
                os_event_set(buf_pool->no_flush[flush_type]);
1827
 
        }
1828
 
 
1829
 
        buf_pool_mutex_exit(buf_pool);
 
1146
 
 
1147
        return(page_count);
1830
1148
}
1831
1149
 
1832
1150
/******************************************************************//**
1835
1153
void
1836
1154
buf_flush_wait_batch_end(
1837
1155
/*=====================*/
1838
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1839
 
        enum buf_flush  type)           /*!< in: BUF_FLUSH_LRU
1840
 
                                        or BUF_FLUSH_LIST */
1841
 
{
1842
 
        ut_ad(type == BUF_FLUSH_LRU || type == BUF_FLUSH_LIST);
1843
 
 
1844
 
        if (buf_pool == NULL) {
1845
 
                ulint   i;
1846
 
 
1847
 
                for (i = 0; i < srv_buf_pool_instances; ++i) {
1848
 
                        buf_pool_t*     i_buf_pool = buf_pool_from_array(i);
1849
 
 
1850
 
                        os_event_wait(i_buf_pool->no_flush[type]);
1851
 
                }
1852
 
        } else {
1853
 
                os_event_wait(buf_pool->no_flush[type]);
1854
 
        }
1855
 
}
1856
 
 
1857
 
/*******************************************************************//**
1858
 
This utility flushes dirty blocks from the end of the LRU list.
1859
 
NOTE: The calling thread may own latches to pages: to avoid deadlocks,
1860
 
this function must be written so that it cannot end up waiting for these
1861
 
latches!
1862
 
@return number of blocks for which the write request was queued;
1863
 
ULINT_UNDEFINED if there was a flush of the same type already running */
1864
 
UNIV_INTERN
1865
 
ulint
1866
 
buf_flush_LRU(
1867
 
/*==========*/
1868
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1869
 
        ulint           min_n)          /*!< in: wished minimum mumber of blocks
1870
 
                                        flushed (it is not guaranteed that the
1871
 
                                        actual number is that big, though) */
1872
 
{
1873
 
        ulint           page_count;
1874
 
 
1875
 
        if (!buf_flush_start(buf_pool, BUF_FLUSH_LRU)) {
1876
 
                return(ULINT_UNDEFINED);
1877
 
        }
1878
 
 
1879
 
        page_count = buf_flush_batch(buf_pool, BUF_FLUSH_LRU, min_n, 0);
1880
 
 
1881
 
        buf_flush_end(buf_pool, BUF_FLUSH_LRU);
1882
 
 
1883
 
        buf_flush_common(BUF_FLUSH_LRU, page_count);
1884
 
 
1885
 
        return(page_count);
1886
 
}
1887
 
 
1888
 
/*******************************************************************//**
1889
 
This utility flushes dirty blocks from the end of the flush list of
1890
 
all buffer pool instances.
1891
 
NOTE: The calling thread is not allowed to own any latches on pages!
1892
 
@return number of blocks for which the write request was queued;
1893
 
ULINT_UNDEFINED if there was a flush of the same type already running */
1894
 
UNIV_INTERN
1895
 
ulint
1896
 
buf_flush_list(
1897
 
/*===========*/
1898
 
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
1899
 
                                        flushed (it is not guaranteed that the
1900
 
                                        actual number is that big, though) */
1901
 
        ib_uint64_t     lsn_limit)      /*!< in the case BUF_FLUSH_LIST all
1902
 
                                        blocks whose oldest_modification is
1903
 
                                        smaller than this should be flushed
1904
 
                                        (if their number does not exceed
1905
 
                                        min_n), otherwise ignored */
1906
 
{
1907
 
        ulint           i;
1908
 
        ulint           total_page_count = 0;
1909
 
        ibool           skipped = FALSE;
1910
 
 
1911
 
        if (min_n != ULINT_MAX) {
1912
 
                /* Ensure that flushing is spread evenly amongst the
1913
 
                buffer pool instances. When min_n is ULINT_MAX
1914
 
                we need to flush everything up to the lsn limit
1915
 
                so no limit here. */
1916
 
                min_n = (min_n + srv_buf_pool_instances - 1)
1917
 
                         / srv_buf_pool_instances;
1918
 
        }
1919
 
 
1920
 
        /* Flush to lsn_limit in all buffer pool instances */
1921
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
1922
 
                buf_pool_t*     buf_pool;
1923
 
                ulint           page_count = 0;
1924
 
 
1925
 
                buf_pool = buf_pool_from_array(i);
1926
 
 
1927
 
                if (!buf_flush_start(buf_pool, BUF_FLUSH_LIST)) {
1928
 
                        /* We have two choices here. If lsn_limit was
1929
 
                        specified then skipping an instance of buffer
1930
 
                        pool means we cannot guarantee that all pages
1931
 
                        up to lsn_limit has been flushed. We can
1932
 
                        return right now with failure or we can try
1933
 
                        to flush remaining buffer pools up to the
1934
 
                        lsn_limit. We attempt to flush other buffer
1935
 
                        pools based on the assumption that it will
1936
 
                        help in the retry which will follow the
1937
 
                        failure. */
1938
 
                        skipped = TRUE;
1939
 
 
1940
 
                        continue;
1941
 
                }
1942
 
 
1943
 
                page_count = buf_flush_batch(
1944
 
                        buf_pool, BUF_FLUSH_LIST, min_n, lsn_limit);
1945
 
 
1946
 
                buf_flush_end(buf_pool, BUF_FLUSH_LIST);
1947
 
 
1948
 
                buf_flush_common(BUF_FLUSH_LIST, page_count);
1949
 
 
1950
 
                total_page_count += page_count;
1951
 
        }
1952
 
 
1953
 
        return(lsn_limit != IB_ULONGLONG_MAX && skipped
1954
 
               ? ULINT_UNDEFINED : total_page_count);
1955
 
}
1956
 
 
 
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
 
1957
1163
/******************************************************************//**
1958
1164
Gives a recommendation of how many blocks should be flushed to establish
1959
1165
a big enough margin of replaceable blocks near the end of the LRU list
1962
1168
LRU list */
1963
1169
static
1964
1170
ulint
1965
 
buf_flush_LRU_recommendation(
1966
 
/*=========================*/
1967
 
        buf_pool_t*     buf_pool)               /*!< in: Buffer pool instance */
 
1171
buf_flush_LRU_recommendation(void)
 
1172
/*==============================*/
1968
1173
{
1969
1174
        buf_page_t*     bpage;
1970
1175
        ulint           n_replaceable;
1971
1176
        ulint           distance        = 0;
1972
1177
 
1973
 
        buf_pool_mutex_enter(buf_pool);
 
1178
        buf_pool_mutex_enter();
1974
1179
 
1975
1180
        n_replaceable = UT_LIST_GET_LEN(buf_pool->free);
1976
1181
 
1977
1182
        bpage = UT_LIST_GET_LAST(buf_pool->LRU);
1978
1183
 
1979
1184
        while ((bpage != NULL)
1980
 
               && (n_replaceable < BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)
1981
 
                   + BUF_FLUSH_EXTRA_MARGIN(buf_pool))
1982
 
               && (distance < BUF_LRU_FREE_SEARCH_LEN(buf_pool))) {
 
1185
               && (n_replaceable < BUF_FLUSH_FREE_BLOCK_MARGIN
 
1186
                   + BUF_FLUSH_EXTRA_MARGIN)
 
1187
               && (distance < BUF_LRU_FREE_SEARCH_LEN)) {
1983
1188
 
1984
1189
                mutex_t* block_mutex = buf_page_get_mutex(bpage);
1985
1190
 
1996
1201
                bpage = UT_LIST_GET_PREV(LRU, bpage);
1997
1202
        }
1998
1203
 
1999
 
        buf_pool_mutex_exit(buf_pool);
 
1204
        buf_pool_mutex_exit();
2000
1205
 
2001
 
        if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)) {
 
1206
        if (n_replaceable >= BUF_FLUSH_FREE_BLOCK_MARGIN) {
2002
1207
 
2003
1208
                return(0);
2004
1209
        }
2005
1210
 
2006
 
        return(BUF_FLUSH_FREE_BLOCK_MARGIN(buf_pool)
2007
 
               + BUF_FLUSH_EXTRA_MARGIN(buf_pool)
 
1211
        return(BUF_FLUSH_FREE_BLOCK_MARGIN + BUF_FLUSH_EXTRA_MARGIN
2008
1212
               - n_replaceable);
2009
1213
}
2010
1214
 
2016
1220
immediately, without waiting. */
2017
1221
UNIV_INTERN
2018
1222
void
2019
 
buf_flush_free_margin(
2020
 
/*==================*/
2021
 
        buf_pool_t*     buf_pool)               /*!< in: Buffer pool instance */
 
1223
buf_flush_free_margin(void)
 
1224
/*=======================*/
2022
1225
{
2023
1226
        ulint   n_to_flush;
 
1227
        ulint   n_flushed;
2024
1228
 
2025
 
        n_to_flush = buf_flush_LRU_recommendation(buf_pool);
 
1229
        n_to_flush = buf_flush_LRU_recommendation();
2026
1230
 
2027
1231
        if (n_to_flush > 0) {
2028
 
                ulint   n_flushed;
2029
 
 
2030
 
                n_flushed = buf_flush_LRU(buf_pool, n_to_flush);
2031
 
 
 
1232
                n_flushed = buf_flush_batch(BUF_FLUSH_LRU, n_to_flush, 0);
2032
1233
                if (n_flushed == ULINT_UNDEFINED) {
2033
1234
                        /* There was an LRU type flush batch already running;
2034
1235
                        let us wait for it to end */
2035
1236
 
2036
 
                        buf_flush_wait_batch_end(buf_pool, BUF_FLUSH_LRU);
 
1237
                        buf_flush_wait_batch_end(BUF_FLUSH_LRU);
2037
1238
                }
2038
1239
        }
2039
1240
}
2040
1241
 
2041
 
/*********************************************************************//**
2042
 
Flushes pages from the end of all the LRU lists. */
2043
 
UNIV_INTERN
2044
 
void
2045
 
buf_flush_free_margins(void)
2046
 
/*========================*/
2047
 
{
2048
 
        ulint   i;
2049
 
 
2050
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
2051
 
                buf_pool_t*     buf_pool;
2052
 
 
2053
 
                buf_pool = buf_pool_from_array(i);
2054
 
 
2055
 
                buf_flush_free_margin(buf_pool);
2056
 
        }
2057
 
}
2058
 
 
2059
1242
/*********************************************************************
2060
1243
Update the historical stats that we are collecting for flush rate
2061
1244
heuristics at the end of each interval.
2116
1299
buf_flush_get_desired_flush_rate(void)
2117
1300
/*==================================*/
2118
1301
{
2119
 
        ulint           i;
2120
 
        lint            rate;
2121
 
        ulint           redo_avg;
2122
 
        ulint           n_dirty = 0;
2123
 
        ulint           n_flush_req;
2124
 
        ulint           lru_flush_avg;
2125
 
        ib_uint64_t     lsn = log_get_lsn();
2126
 
        ulint           log_capacity = log_get_capacity();
 
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();
2127
1309
 
2128
1310
        /* log_capacity should never be zero after the initialization
2129
1311
        of log subsystem. */
2130
1312
        ut_ad(log_capacity != 0);
2131
1313
 
2132
1314
        /* Get total number of dirty pages. It is OK to access
2133
 
        flush_list without holding any mutex as we are using this
 
1315
        flush_list without holding any mtex as we are using this
2134
1316
        only for heuristics. */
2135
 
        for (i = 0; i < srv_buf_pool_instances; i++) {
2136
 
                buf_pool_t*     buf_pool;
2137
 
 
2138
 
                buf_pool = buf_pool_from_array(i);
2139
 
                n_dirty += UT_LIST_GET_LEN(buf_pool->flush_list);
2140
 
        }
 
1317
        n_dirty = UT_LIST_GET_LEN(buf_pool->flush_list);
2141
1318
 
2142
1319
        /* An overflow can happen if we generate more than 2^32 bytes
2143
1320
        of redo in this interval i.e.: 4G of redo in 1 second. We can
2179
1356
@return TRUE if ok */
2180
1357
static
2181
1358
ibool
2182
 
buf_flush_validate_low(
2183
 
/*===================*/
2184
 
        buf_pool_t*     buf_pool)               /*!< in: Buffer pool instance */
 
1359
buf_flush_validate_low(void)
 
1360
/*========================*/
2185
1361
{
2186
 
        buf_page_t*             bpage;
2187
 
        const ib_rbt_node_t*    rnode = NULL;
2188
 
 
2189
 
        ut_ad(buf_flush_list_mutex_own(buf_pool));
 
1362
        buf_page_t*     bpage;
2190
1363
 
2191
1364
        UT_LIST_VALIDATE(list, buf_page_t, buf_pool->flush_list,
2192
1365
                         ut_ad(ut_list_node_313->in_flush_list));
2193
1366
 
2194
1367
        bpage = UT_LIST_GET_FIRST(buf_pool->flush_list);
2195
1368
 
2196
 
        /* If we are in recovery mode i.e.: flush_rbt != NULL
2197
 
        then each block in the flush_list must also be present
2198
 
        in the flush_rbt. */
2199
 
        if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
2200
 
                rnode = rbt_first(buf_pool->flush_rbt);
2201
 
        }
2202
 
 
2203
1369
        while (bpage != NULL) {
2204
1370
                const ib_uint64_t om = bpage->oldest_modification;
2205
 
 
2206
 
                ut_ad(buf_pool_from_bpage(bpage) == buf_pool);
2207
 
 
2208
1371
                ut_ad(bpage->in_flush_list);
2209
 
 
2210
 
                /* A page in buf_pool->flush_list can be in
2211
 
                BUF_BLOCK_REMOVE_HASH state. This happens when a page
2212
 
                is in the middle of being relocated. In that case the
2213
 
                original descriptor can have this state and still be
2214
 
                in the flush list waiting to acquire the
2215
 
                buf_pool->flush_list_mutex to complete the relocation. */
2216
 
                ut_a(buf_page_in_file(bpage)
2217
 
                     || buf_page_get_state(bpage) == BUF_BLOCK_REMOVE_HASH);
 
1372
                ut_a(buf_page_in_file(bpage));
2218
1373
                ut_a(om > 0);
2219
1374
 
2220
 
                if (UNIV_LIKELY_NULL(buf_pool->flush_rbt)) {
2221
 
                        buf_page_t** prpage;
2222
 
 
2223
 
                        ut_a(rnode);
2224
 
                        prpage = rbt_value(buf_page_t*, rnode);
2225
 
 
2226
 
                        ut_a(*prpage);
2227
 
                        ut_a(*prpage == bpage);
2228
 
                        rnode = rbt_next(buf_pool->flush_rbt, rnode);
2229
 
                }
2230
 
 
2231
1375
                bpage = UT_LIST_GET_NEXT(list, bpage);
2232
1376
 
2233
1377
                ut_a(!bpage || om >= bpage->oldest_modification);
2234
1378
        }
2235
1379
 
2236
 
        /* By this time we must have exhausted the traversal of
2237
 
        flush_rbt (if active) as well. */
2238
 
        ut_a(rnode == NULL);
2239
 
 
2240
1380
        return(TRUE);
2241
1381
}
2242
1382
 
2245
1385
@return TRUE if ok */
2246
1386
UNIV_INTERN
2247
1387
ibool
2248
 
buf_flush_validate(
2249
 
/*===============*/
2250
 
        buf_pool_t*     buf_pool)       /*!< buffer pool instance */
 
1388
buf_flush_validate(void)
 
1389
/*====================*/
2251
1390
{
2252
1391
        ibool   ret;
2253
1392
 
2254
 
        buf_flush_list_mutex_enter(buf_pool);
2255
 
 
2256
 
        ret = buf_flush_validate_low(buf_pool);
2257
 
 
2258
 
        buf_flush_list_mutex_exit(buf_pool);
 
1393
        buf_pool_mutex_enter();
 
1394
 
 
1395
        ret = buf_flush_validate_low();
 
1396
 
 
1397
        buf_pool_mutex_exit();
2259
1398
 
2260
1399
        return(ret);
2261
1400
}