← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Merge of Jay

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/buf/buf0rea.c
1
 
/******************************************************
2
 
The database buffer read
3
 
 
4
 
(c) 1995 Innobase Oy
5
 
 
6
 
Created 11/5/1995 Heikki Tuuri
7
 
*******************************************************/
8
 
 
9
 
#include "buf0rea.h"
10
 
 
11
 
#include "fil0fil.h"
12
 
#include "mtr0mtr.h"
13
 
 
14
 
#include "buf0buf.h"
15
 
#include "buf0flu.h"
16
 
#include "buf0lru.h"
17
 
#include "ibuf0ibuf.h"
18
 
#include "log0recv.h"
19
 
#include "trx0sys.h"
20
 
#include "os0file.h"
21
 
#include "srv0start.h"
22
 
 
23
 
/* The size in blocks of the area where the random read-ahead algorithm counts
24
 
the accessed pages when deciding whether to read-ahead */
25
 
#define BUF_READ_AHEAD_RANDOM_AREA      BUF_READ_AHEAD_AREA
26
 
 
27
 
/* There must be at least this many pages in buf_pool in the area to start
28
 
a random read-ahead */
29
 
#define BUF_READ_AHEAD_RANDOM_THRESHOLD (5 + BUF_READ_AHEAD_RANDOM_AREA / 8)
30
 
 
31
 
/* The linear read-ahead area size */
32
 
#define BUF_READ_AHEAD_LINEAR_AREA      BUF_READ_AHEAD_AREA
33
 
 
34
 
/* The linear read-ahead threshold */
35
 
#define BUF_READ_AHEAD_LINEAR_THRESHOLD (3 * BUF_READ_AHEAD_LINEAR_AREA / 8)
36
 
 
37
 
/* If there are buf_pool->curr_size per the number below pending reads, then
38
 
read-ahead is not done: this is to prevent flooding the buffer pool with
39
 
i/o-fixed buffer blocks */
40
 
#define BUF_READ_AHEAD_PEND_LIMIT       2
41
 
 
42
 
/************************************************************************
43
 
Low-level function which reads a page asynchronously from a file to the
44
 
buffer buf_pool if it is not already there, in which case does nothing.
45
 
Sets the io_fix flag and sets an exclusive lock on the buffer frame. The
46
 
flag is cleared and the x-lock released by an i/o-handler thread. */
47
 
static
48
 
ulint
49
 
buf_read_page_low(
50
 
/*==============*/
51
 
                        /* out: 1 if a read request was queued, 0 if the page
52
 
                        already resided in buf_pool, or if the page is in
53
 
                        the doublewrite buffer blocks in which case it is never
54
 
                        read into the pool, or if the tablespace does not
55
 
                        exist or is being dropped */
56
 
        ulint*  err,    /* out: DB_SUCCESS or DB_TABLESPACE_DELETED if we are
57
 
                        trying to read from a non-existent tablespace, or a
58
 
                        tablespace which is just now being dropped */
59
 
        ibool   sync,   /* in: TRUE if synchronous aio is desired */
60
 
        ulint   mode,   /* in: BUF_READ_IBUF_PAGES_ONLY, ...,
61
 
                        ORed to OS_AIO_SIMULATED_WAKE_LATER (see below
62
 
                        at read-ahead functions) */
63
 
        ulint   space,  /* in: space id */
64
 
        ib_longlong tablespace_version, /* in: if the space memory object has
65
 
                        this timestamp different from what we are giving here,
66
 
                        treat the tablespace as dropped; this is a timestamp we
67
 
                        use to stop dangling page reads from a tablespace
68
 
                        which we have DISCARDed + IMPORTed back */
69
 
        ulint   offset) /* in: page number */
70
 
{
71
 
        buf_block_t*    block;
72
 
        ulint           wake_later;
73
 
 
74
 
        *err = DB_SUCCESS;
75
 
 
76
 
        wake_later = mode & OS_AIO_SIMULATED_WAKE_LATER;
77
 
        mode = mode & ~OS_AIO_SIMULATED_WAKE_LATER;
78
 
 
79
 
        if (trx_doublewrite && space == TRX_SYS_SPACE
80
 
            && (   (offset >= trx_doublewrite->block1
81
 
                    && offset < trx_doublewrite->block1
82
 
                    + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE)
83
 
                   || (offset >= trx_doublewrite->block2
84
 
                       && offset < trx_doublewrite->block2
85
 
                       + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE))) {
86
 
                ut_print_timestamp(stderr);
87
 
                fprintf(stderr,
88
 
                        "  InnoDB: Warning: trying to read"
89
 
                        " doublewrite buffer page %lu\n",
90
 
                        (ulong) offset);
91
 
 
92
 
                return(0);
93
 
        }
94
 
 
95
 
        if (ibuf_bitmap_page(offset) || trx_sys_hdr_page(space, offset)) {
96
 
 
97
 
                /* Trx sys header is so low in the latching order that we play
98
 
                safe and do not leave the i/o-completion to an asynchronous
99
 
                i/o-thread. Ibuf bitmap pages must always be read with
100
 
                syncronous i/o, to make sure they do not get involved in
101
 
                thread deadlocks. */
102
 
 
103
 
                sync = TRUE;
104
 
        }
105
 
 
106
 
        /* The following call will also check if the tablespace does not exist
107
 
        or is being dropped; if we succeed in initing the page in the buffer
108
 
        pool for read, then DISCARD cannot proceed until the read has
109
 
        completed */
110
 
        block = buf_page_init_for_read(err, mode, space, tablespace_version,
111
 
                                       offset);
112
 
        if (block == NULL) {
113
 
 
114
 
                return(0);
115
 
        }
116
 
 
117
 
#ifdef UNIV_DEBUG
118
 
        if (buf_debug_prints) {
119
 
                fprintf(stderr,
120
 
                        "Posting read request for page %lu, sync %lu\n",
121
 
                        (ulong) offset,
122
 
                        (ulong) sync);
123
 
        }
124
 
#endif
125
 
 
126
 
        ut_a(block->state == BUF_BLOCK_FILE_PAGE);
127
 
 
128
 
        *err = fil_io(OS_FILE_READ | wake_later,
129
 
                      sync, space,
130
 
                      offset, 0, UNIV_PAGE_SIZE,
131
 
                      (void*)block->frame, (void*)block);
132
 
        ut_a(*err == DB_SUCCESS);
133
 
 
134
 
        if (sync) {
135
 
                /* The i/o is already completed when we arrive from
136
 
                fil_read */
137
 
                buf_page_io_complete(block);
138
 
        }
139
 
 
140
 
        return(1);
141
 
}
142
 
 
143
 
/************************************************************************
144
 
Applies a random read-ahead in buf_pool if there are at least a threshold
145
 
value of accessed pages from the random read-ahead area. Does not read any
146
 
page, not even the one at the position (space, offset), if the read-ahead
147
 
mechanism is not activated. NOTE 1: the calling thread may own latches on
148
 
pages: to avoid deadlocks this function must be written such that it cannot
149
 
end up waiting for these latches! NOTE 2: the calling thread must want
150
 
access to the page given: this rule is set to prevent unintended read-aheads
151
 
performed by ibuf routines, a situation which could result in a deadlock if
152
 
the OS does not support asynchronous i/o. */
153
 
static
154
 
ulint
155
 
buf_read_ahead_random(
156
 
/*==================*/
157
 
                        /* out: number of page read requests issued; NOTE
158
 
                        that if we read ibuf pages, it may happen that
159
 
                        the page at the given page number does not get
160
 
                        read even if we return a value > 0! */
161
 
        ulint   space,  /* in: space id */
162
 
        ulint   offset) /* in: page number of a page which the current thread
163
 
                        wants to access */
164
 
{
165
 
        ib_longlong     tablespace_version;
166
 
        buf_block_t*    block;
167
 
        ulint           recent_blocks   = 0;
168
 
        ulint           count;
169
 
        ulint           LRU_recent_limit;
170
 
        ulint           ibuf_mode;
171
 
        ulint           low, high;
172
 
        ulint           err;
173
 
        ulint           i;
174
 
 
175
 
        if (srv_startup_is_before_trx_rollback_phase) {
176
 
                /* No read-ahead to avoid thread deadlocks */
177
 
                return(0);
178
 
        }
179
 
 
180
 
        if (ibuf_bitmap_page(offset) || trx_sys_hdr_page(space, offset)) {
181
 
 
182
 
                /* If it is an ibuf bitmap page or trx sys hdr, we do
183
 
                no read-ahead, as that could break the ibuf page access
184
 
                order */
185
 
 
186
 
                return(0);
187
 
        }
188
 
 
189
 
        /* Remember the tablespace version before we ask te tablespace size
190
 
        below: if DISCARD + IMPORT changes the actual .ibd file meanwhile, we
191
 
        do not try to read outside the bounds of the tablespace! */
192
 
 
193
 
        tablespace_version = fil_space_get_version(space);
194
 
 
195
 
        low  = (offset / BUF_READ_AHEAD_RANDOM_AREA)
196
 
                * BUF_READ_AHEAD_RANDOM_AREA;
197
 
        high = (offset / BUF_READ_AHEAD_RANDOM_AREA + 1)
198
 
                * BUF_READ_AHEAD_RANDOM_AREA;
199
 
        if (high > fil_space_get_size(space)) {
200
 
 
201
 
                high = fil_space_get_size(space);
202
 
        }
203
 
 
204
 
        /* Get the minimum LRU_position field value for an initial segment
205
 
        of the LRU list, to determine which blocks have recently been added
206
 
        to the start of the list. */
207
 
 
208
 
        LRU_recent_limit = buf_LRU_get_recent_limit();
209
 
 
210
 
        mutex_enter(&(buf_pool->mutex));
211
 
 
212
 
        if (buf_pool->n_pend_reads
213
 
            > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
214
 
                mutex_exit(&(buf_pool->mutex));
215
 
 
216
 
                return(0);
217
 
        }
218
 
 
219
 
        /* Count how many blocks in the area have been recently accessed,
220
 
        that is, reside near the start of the LRU list. */
221
 
 
222
 
        for (i = low; i < high; i++) {
223
 
                block = buf_page_hash_get(space, i);
224
 
 
225
 
                if ((block)
226
 
                    && (block->LRU_position > LRU_recent_limit)
227
 
                    && block->accessed) {
228
 
 
229
 
                        recent_blocks++;
230
 
                }
231
 
        }
232
 
 
233
 
        mutex_exit(&(buf_pool->mutex));
234
 
 
235
 
        if (recent_blocks < BUF_READ_AHEAD_RANDOM_THRESHOLD) {
236
 
                /* Do nothing */
237
 
 
238
 
                return(0);
239
 
        }
240
 
 
241
 
        /* Read all the suitable blocks within the area */
242
 
 
243
 
        if (ibuf_inside()) {
244
 
                ibuf_mode = BUF_READ_IBUF_PAGES_ONLY;
245
 
        } else {
246
 
                ibuf_mode = BUF_READ_ANY_PAGE;
247
 
        }
248
 
 
249
 
        count = 0;
250
 
 
251
 
        for (i = low; i < high; i++) {
252
 
                /* It is only sensible to do read-ahead in the non-sync aio
253
 
                mode: hence FALSE as the first parameter */
254
 
 
255
 
                if (!ibuf_bitmap_page(i)) {
256
 
                        count += buf_read_page_low(
257
 
                                &err, FALSE,
258
 
                                ibuf_mode | OS_AIO_SIMULATED_WAKE_LATER,
259
 
                                space, tablespace_version, i);
260
 
                        if (err == DB_TABLESPACE_DELETED) {
261
 
                                ut_print_timestamp(stderr);
262
 
                                fprintf(stderr,
263
 
                                        "  InnoDB: Warning: in random"
264
 
                                        " readahead trying to access\n"
265
 
                                        "InnoDB: tablespace %lu page %lu,\n"
266
 
                                        "InnoDB: but the tablespace does not"
267
 
                                        " exist or is just being dropped.\n",
268
 
                                        (ulong) space, (ulong) i);
269
 
                        }
270
 
                }
271
 
        }
272
 
 
273
 
        /* In simulated aio we wake the aio handler threads only after
274
 
        queuing all aio requests, in native aio the following call does
275
 
        nothing: */
276
 
 
277
 
        os_aio_simulated_wake_handler_threads();
278
 
 
279
 
#ifdef UNIV_DEBUG
280
 
        if (buf_debug_prints && (count > 0)) {
281
 
                fprintf(stderr,
282
 
                        "Random read-ahead space %lu offset %lu pages %lu\n",
283
 
                        (ulong) space, (ulong) offset,
284
 
                        (ulong) count);
285
 
        }
286
 
#endif /* UNIV_DEBUG */
287
 
 
288
 
        ++srv_read_ahead_rnd;
289
 
        return(count);
290
 
}
291
 
 
292
 
/************************************************************************
293
 
High-level function which reads a page asynchronously from a file to the
294
 
buffer buf_pool if it is not already there. Sets the io_fix flag and sets
295
 
an exclusive lock on the buffer frame. The flag is cleared and the x-lock
296
 
released by the i/o-handler thread. Does a random read-ahead if it seems
297
 
sensible. */
298
 
 
299
 
ulint
300
 
buf_read_page(
301
 
/*==========*/
302
 
                        /* out: number of page read requests issued: this can
303
 
                        be > 1 if read-ahead occurred */
304
 
        ulint   space,  /* in: space id */
305
 
        ulint   offset) /* in: page number */
306
 
{
307
 
        ib_longlong     tablespace_version;
308
 
        ulint           count;
309
 
        ulint           count2;
310
 
        ulint           err;
311
 
 
312
 
        tablespace_version = fil_space_get_version(space);
313
 
 
314
 
        count = buf_read_ahead_random(space, offset);
315
 
 
316
 
        /* We do the i/o in the synchronous aio mode to save thread
317
 
        switches: hence TRUE */
318
 
 
319
 
        count2 = buf_read_page_low(&err, TRUE, BUF_READ_ANY_PAGE, space,
320
 
                                   tablespace_version, offset);
321
 
        srv_buf_pool_reads+= count2;
322
 
        if (err == DB_TABLESPACE_DELETED) {
323
 
                ut_print_timestamp(stderr);
324
 
                fprintf(stderr,
325
 
                        "  InnoDB: Error: trying to access"
326
 
                        " tablespace %lu page no. %lu,\n"
327
 
                        "InnoDB: but the tablespace does not exist"
328
 
                        " or is just being dropped.\n",
329
 
                        (ulong) space, (ulong) offset);
330
 
        }
331
 
 
332
 
        /* Flush pages from the end of the LRU list if necessary */
333
 
        buf_flush_free_margin();
334
 
 
335
 
        return(count + count2);
336
 
}
337
 
 
338
 
/************************************************************************
339
 
Applies linear read-ahead if in the buf_pool the page is a border page of
340
 
a linear read-ahead area and all the pages in the area have been accessed.
341
 
Does not read any page if the read-ahead mechanism is not activated. Note
342
 
that the the algorithm looks at the 'natural' adjacent successor and
343
 
predecessor of the page, which on the leaf level of a B-tree are the next
344
 
and previous page in the chain of leaves. To know these, the page specified
345
 
in (space, offset) must already be present in the buf_pool. Thus, the
346
 
natural way to use this function is to call it when a page in the buf_pool
347
 
is accessed the first time, calling this function just after it has been
348
 
bufferfixed.
349
 
NOTE 1: as this function looks at the natural predecessor and successor
350
 
fields on the page, what happens, if these are not initialized to any
351
 
sensible value? No problem, before applying read-ahead we check that the
352
 
area to read is within the span of the space, if not, read-ahead is not
353
 
applied. An uninitialized value may result in a useless read operation, but
354
 
only very improbably.
355
 
NOTE 2: the calling thread may own latches on pages: to avoid deadlocks this
356
 
function must be written such that it cannot end up waiting for these
357
 
latches!
358
 
NOTE 3: the calling thread must want access to the page given: this rule is
359
 
set to prevent unintended read-aheads performed by ibuf routines, a situation
360
 
which could result in a deadlock if the OS does not support asynchronous io. */
361
 
 
362
 
ulint
363
 
buf_read_ahead_linear(
364
 
/*==================*/
365
 
                        /* out: number of page read requests issued */
366
 
        ulint   space,  /* in: space id */
367
 
        ulint   offset) /* in: page number of a page; NOTE: the current thread
368
 
                        must want access to this page (see NOTE 3 above) */
369
 
{
370
 
        ib_longlong     tablespace_version;
371
 
        buf_block_t*    block;
372
 
        buf_frame_t*    frame;
373
 
        buf_block_t*    pred_block      = NULL;
374
 
        ulint           pred_offset;
375
 
        ulint           succ_offset;
376
 
        ulint           count;
377
 
        int             asc_or_desc;
378
 
        ulint           new_offset;
379
 
        ulint           fail_count;
380
 
        ulint           ibuf_mode;
381
 
        ulint           low, high;
382
 
        ulint           err;
383
 
        ulint           i;
384
 
 
385
 
        if (srv_startup_is_before_trx_rollback_phase) {
386
 
                /* No read-ahead to avoid thread deadlocks */
387
 
                return(0);
388
 
        }
389
 
 
390
 
        if (ibuf_bitmap_page(offset) || trx_sys_hdr_page(space, offset)) {
391
 
 
392
 
                /* If it is an ibuf bitmap page or trx sys hdr, we do
393
 
                no read-ahead, as that could break the ibuf page access
394
 
                order */
395
 
 
396
 
                return(0);
397
 
        }
398
 
 
399
 
        low  = (offset / BUF_READ_AHEAD_LINEAR_AREA)
400
 
                * BUF_READ_AHEAD_LINEAR_AREA;
401
 
        high = (offset / BUF_READ_AHEAD_LINEAR_AREA + 1)
402
 
                * BUF_READ_AHEAD_LINEAR_AREA;
403
 
 
404
 
        if ((offset != low) && (offset != high - 1)) {
405
 
                /* This is not a border page of the area: return */
406
 
 
407
 
                return(0);
408
 
        }
409
 
 
410
 
        /* Remember the tablespace version before we ask te tablespace size
411
 
        below: if DISCARD + IMPORT changes the actual .ibd file meanwhile, we
412
 
        do not try to read outside the bounds of the tablespace! */
413
 
 
414
 
        tablespace_version = fil_space_get_version(space);
415
 
 
416
 
        mutex_enter(&(buf_pool->mutex));
417
 
 
418
 
        if (high > fil_space_get_size(space)) {
419
 
                mutex_exit(&(buf_pool->mutex));
420
 
                /* The area is not whole, return */
421
 
 
422
 
                return(0);
423
 
        }
424
 
 
425
 
        if (buf_pool->n_pend_reads
426
 
            > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
427
 
                mutex_exit(&(buf_pool->mutex));
428
 
 
429
 
                return(0);
430
 
        }
431
 
 
432
 
        /* Check that almost all pages in the area have been accessed; if
433
 
        offset == low, the accesses must be in a descending order, otherwise,
434
 
        in an ascending order. */
435
 
 
436
 
        asc_or_desc = 1;
437
 
 
438
 
        if (offset == low) {
439
 
                asc_or_desc = -1;
440
 
        }
441
 
 
442
 
        fail_count = 0;
443
 
 
444
 
        for (i = low; i < high; i++) {
445
 
                block = buf_page_hash_get(space, i);
446
 
 
447
 
                if ((block == NULL) || !block->accessed) {
448
 
                        /* Not accessed */
449
 
                        fail_count++;
450
 
 
451
 
                } else if (pred_block
452
 
                           && (ut_ulint_cmp(block->LRU_position,
453
 
                                            pred_block->LRU_position)
454
 
                               != asc_or_desc)) {
455
 
                        /* Accesses not in the right order */
456
 
 
457
 
                        fail_count++;
458
 
                        pred_block = block;
459
 
                }
460
 
        }
461
 
 
462
 
        if (fail_count > BUF_READ_AHEAD_LINEAR_AREA
463
 
            - BUF_READ_AHEAD_LINEAR_THRESHOLD) {
464
 
                /* Too many failures: return */
465
 
 
466
 
                mutex_exit(&(buf_pool->mutex));
467
 
 
468
 
                return(0);
469
 
        }
470
 
 
471
 
        /* If we got this far, we know that enough pages in the area have
472
 
        been accessed in the right order: linear read-ahead can be sensible */
473
 
 
474
 
        block = buf_page_hash_get(space, offset);
475
 
 
476
 
        if (block == NULL) {
477
 
                mutex_exit(&(buf_pool->mutex));
478
 
 
479
 
                return(0);
480
 
        }
481
 
 
482
 
        frame = block->frame;
483
 
 
484
 
        /* Read the natural predecessor and successor page addresses from
485
 
        the page; NOTE that because the calling thread may have an x-latch
486
 
        on the page, we do not acquire an s-latch on the page, this is to
487
 
        prevent deadlocks. Even if we read values which are nonsense, the
488
 
        algorithm will work. */
489
 
 
490
 
        pred_offset = fil_page_get_prev(frame);
491
 
        succ_offset = fil_page_get_next(frame);
492
 
 
493
 
        mutex_exit(&(buf_pool->mutex));
494
 
 
495
 
        if ((offset == low) && (succ_offset == offset + 1)) {
496
 
 
497
 
                /* This is ok, we can continue */
498
 
                new_offset = pred_offset;
499
 
 
500
 
        } else if ((offset == high - 1) && (pred_offset == offset - 1)) {
501
 
 
502
 
                /* This is ok, we can continue */
503
 
                new_offset = succ_offset;
504
 
        } else {
505
 
                /* Successor or predecessor not in the right order */
506
 
 
507
 
                return(0);
508
 
        }
509
 
 
510
 
        low  = (new_offset / BUF_READ_AHEAD_LINEAR_AREA)
511
 
                * BUF_READ_AHEAD_LINEAR_AREA;
512
 
        high = (new_offset / BUF_READ_AHEAD_LINEAR_AREA + 1)
513
 
                * BUF_READ_AHEAD_LINEAR_AREA;
514
 
 
515
 
        if ((new_offset != low) && (new_offset != high - 1)) {
516
 
                /* This is not a border page of the area: return */
517
 
 
518
 
                return(0);
519
 
        }
520
 
 
521
 
        if (high > fil_space_get_size(space)) {
522
 
                /* The area is not whole, return */
523
 
 
524
 
                return(0);
525
 
        }
526
 
 
527
 
        /* If we got this far, read-ahead can be sensible: do it */
528
 
 
529
 
        if (ibuf_inside()) {
530
 
                ibuf_mode = BUF_READ_IBUF_PAGES_ONLY;
531
 
        } else {
532
 
                ibuf_mode = BUF_READ_ANY_PAGE;
533
 
        }
534
 
 
535
 
        count = 0;
536
 
 
537
 
        /* Since Windows XP seems to schedule the i/o handler thread
538
 
        very eagerly, and consequently it does not wait for the
539
 
        full read batch to be posted, we use special heuristics here */
540
 
 
541
 
        os_aio_simulated_put_read_threads_to_sleep();
542
 
 
543
 
        for (i = low; i < high; i++) {
544
 
                /* It is only sensible to do read-ahead in the non-sync
545
 
                aio mode: hence FALSE as the first parameter */
546
 
 
547
 
                if (!ibuf_bitmap_page(i)) {
548
 
                        count += buf_read_page_low(
549
 
                                &err, FALSE,
550
 
                                ibuf_mode | OS_AIO_SIMULATED_WAKE_LATER,
551
 
                                space, tablespace_version, i);
552
 
                        if (err == DB_TABLESPACE_DELETED) {
553
 
                                ut_print_timestamp(stderr);
554
 
                                fprintf(stderr,
555
 
                                        "  InnoDB: Warning: in"
556
 
                                        " linear readahead trying to access\n"
557
 
                                        "InnoDB: tablespace %lu page %lu,\n"
558
 
                                        "InnoDB: but the tablespace does not"
559
 
                                        " exist or is just being dropped.\n",
560
 
                                        (ulong) space, (ulong) i);
561
 
                        }
562
 
                }
563
 
        }
564
 
 
565
 
        /* In simulated aio we wake the aio handler threads only after
566
 
        queuing all aio requests, in native aio the following call does
567
 
        nothing: */
568
 
 
569
 
        os_aio_simulated_wake_handler_threads();
570
 
 
571
 
        /* Flush pages from the end of the LRU list if necessary */
572
 
        buf_flush_free_margin();
573
 
 
574
 
#ifdef UNIV_DEBUG
575
 
        if (buf_debug_prints && (count > 0)) {
576
 
                fprintf(stderr,
577
 
                        "LINEAR read-ahead space %lu offset %lu pages %lu\n",
578
 
                        (ulong) space, (ulong) offset, (ulong) count);
579
 
        }
580
 
#endif /* UNIV_DEBUG */
581
 
 
582
 
        ++srv_read_ahead_seq;
583
 
        return(count);
584
 
}
585
 
 
586
 
/************************************************************************
587
 
Issues read requests for pages which the ibuf module wants to read in, in
588
 
order to contract the insert buffer tree. Technically, this function is like
589
 
a read-ahead function. */
590
 
 
591
 
void
592
 
buf_read_ibuf_merge_pages(
593
 
/*======================*/
594
 
        ibool   sync,           /* in: TRUE if the caller wants this function
595
 
                                to wait for the highest address page to get
596
 
                                read in, before this function returns */
597
 
        ulint*  space_ids,      /* in: array of space ids */
598
 
        ib_longlong* space_versions,/* in: the spaces must have this version
599
 
                                number (timestamp), otherwise we discard the
600
 
                                read; we use this to cancel reads if
601
 
                                DISCARD + IMPORT may have changed the
602
 
                                tablespace size */
603
 
        ulint*  page_nos,       /* in: array of page numbers to read, with the
604
 
                                highest page number the last in the array */
605
 
        ulint   n_stored)       /* in: number of page numbers in the array */
606
 
{
607
 
        ulint   err;
608
 
        ulint   i;
609
 
 
610
 
        ut_ad(!ibuf_inside());
611
 
#ifdef UNIV_IBUF_DEBUG
612
 
        ut_a(n_stored < UNIV_PAGE_SIZE);
613
 
#endif
614
 
        while (buf_pool->n_pend_reads
615
 
               > buf_pool->curr_size / BUF_READ_AHEAD_PEND_LIMIT) {
616
 
                os_thread_sleep(500000);
617
 
        }
618
 
 
619
 
        for (i = 0; i < n_stored; i++) {
620
 
                buf_read_page_low(&err,
621
 
                                  (i + 1 == n_stored) && sync,
622
 
                                  BUF_READ_ANY_PAGE,
623
 
                                  space_ids[i], space_versions[i],
624
 
                                  page_nos[i]);
625
 
 
626
 
                if (err == DB_TABLESPACE_DELETED) {
627
 
                        /* We have deleted or are deleting the single-table
628
 
                        tablespace: remove the entries for that page */
629
 
 
630
 
                        ibuf_merge_or_delete_for_page(NULL, space_ids[i],
631
 
                                                      page_nos[i], FALSE);
632
 
                }
633
 
        }
634
 
 
635
 
        os_aio_simulated_wake_handler_threads();
636
 
 
637
 
        /* Flush pages from the end of the LRU list if necessary */
638
 
        buf_flush_free_margin();
639
 
 
640
 
#ifdef UNIV_DEBUG
641
 
        if (buf_debug_prints) {
642
 
                fprintf(stderr,
643
 
                        "Ibuf merge read-ahead space %lu pages %lu\n",
644
 
                        (ulong) space_ids[0], (ulong) n_stored);
645
 
        }
646
 
#endif /* UNIV_DEBUG */
647
 
}
648
 
 
649
 
/************************************************************************
650
 
Issues read requests for pages which recovery wants to read in. */
651
 
 
652
 
void
653
 
buf_read_recv_pages(
654
 
/*================*/
655
 
        ibool   sync,           /* in: TRUE if the caller wants this function
656
 
                                to wait for the highest address page to get
657
 
                                read in, before this function returns */
658
 
        ulint   space,          /* in: space id */
659
 
        ulint*  page_nos,       /* in: array of page numbers to read, with the
660
 
                                highest page number the last in the array */
661
 
        ulint   n_stored)       /* in: number of page numbers in the array */
662
 
{
663
 
        ib_longlong     tablespace_version;
664
 
        ulint           count;
665
 
        ulint           err;
666
 
        ulint           i;
667
 
 
668
 
        tablespace_version = fil_space_get_version(space);
669
 
 
670
 
        for (i = 0; i < n_stored; i++) {
671
 
 
672
 
                count = 0;
673
 
 
674
 
                os_aio_print_debug = FALSE;
675
 
 
676
 
                while (buf_pool->n_pend_reads >= recv_n_pool_free_frames / 2) {
677
 
 
678
 
                        os_aio_simulated_wake_handler_threads();
679
 
                        os_thread_sleep(500000);
680
 
 
681
 
                        count++;
682
 
 
683
 
                        if (count > 100) {
684
 
                                fprintf(stderr,
685
 
                                        "InnoDB: Error: InnoDB has waited for"
686
 
                                        " 50 seconds for pending\n"
687
 
                                        "InnoDB: reads to the buffer pool to"
688
 
                                        " be finished.\n"
689
 
                                        "InnoDB: Number of pending reads %lu,"
690
 
                                        " pending pread calls %lu\n",
691
 
                                        (ulong) buf_pool->n_pend_reads,
692
 
                                        (ulong)os_file_n_pending_preads);
693
 
 
694
 
                                os_aio_print_debug = TRUE;
695
 
                        }
696
 
                }
697
 
 
698
 
                os_aio_print_debug = FALSE;
699
 
 
700
 
                if ((i + 1 == n_stored) && sync) {
701
 
                        buf_read_page_low(&err, TRUE, BUF_READ_ANY_PAGE,
702
 
                                          space, tablespace_version,
703
 
                                          page_nos[i]);
704
 
                } else {
705
 
                        buf_read_page_low(&err, FALSE, BUF_READ_ANY_PAGE
706
 
                                          | OS_AIO_SIMULATED_WAKE_LATER,
707
 
                                          space, tablespace_version,
708
 
                                          page_nos[i]);
709
 
                }
710
 
        }
711
 
 
712
 
        os_aio_simulated_wake_handler_threads();
713
 
 
714
 
        /* Flush pages from the end of the LRU list if necessary */
715
 
        buf_flush_free_margin();
716
 
 
717
 
#ifdef UNIV_DEBUG
718
 
        if (buf_debug_prints) {
719
 
                fprintf(stderr,
720
 
                        "Recovery applies read-ahead pages %lu\n",
721
 
                        (ulong) n_stored);
722
 
        }
723
 
#endif /* UNIV_DEBUG */
724
 
}