← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/buf0rea.h

  • Committer: Brian Aker
  • Date: 2009-01-09 22:07:54 UTC
  • Revision ID: brian@tangent.org-20090109220754-1y50h7lqi9i1ifcs
Dead test/wrong test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/buf0rea.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/buf0rea.h
 
1
/******************************************************
21
2
The database buffer read
22
3
 
 
4
(c) 1995 Innobase Oy
 
5
 
23
6
Created 11/5/1995 Heikki Tuuri
24
7
*******************************************************/
25
8
 
29
12
#include "univ.i"
30
13
#include "buf0types.h"
31
14
 
32
 
/********************************************************************//**
 
15
/************************************************************************
33
16
High-level function which reads a page asynchronously from a file to the
34
17
buffer buf_pool if it is not already there. Sets the io_fix flag and sets
35
18
an exclusive lock on the buffer frame. The flag is cleared and the x-lock
36
 
released by the i/o-handler thread.
37
 
@return TRUE if page has been read in, FALSE in case of failure */
 
19
released by the i/o-handler thread. Does a random read-ahead if it seems
 
20
sensible. */
38
21
UNIV_INTERN
39
 
ibool
 
22
ulint
40
23
buf_read_page(
41
24
/*==========*/
42
 
        ulint   space,  /*!< in: space id */
43
 
        ulint   zip_size,/*!< in: compressed page size in bytes, or 0 */
44
 
        ulint   offset);/*!< in: page number */
45
 
/********************************************************************//**
 
25
                        /* out: number of page read requests issued: this can
 
26
                        be > 1 if read-ahead occurred */
 
27
        ulint   space,  /* in: space id */
 
28
        ulint   zip_size,/* in: compressed page size in bytes, or 0 */
 
29
        ulint   offset);/* in: page number */
 
30
/************************************************************************
46
31
Applies linear read-ahead if in the buf_pool the page is a border page of
47
32
a linear read-ahead area and all the pages in the area have been accessed.
48
33
Does not read any page if the read-ahead mechanism is not activated. Note
64
49
latches!
65
50
NOTE 3: the calling thread must want access to the page given: this rule is
66
51
set to prevent unintended read-aheads performed by ibuf routines, a situation
67
 
which could result in a deadlock if the OS does not support asynchronous io.
68
 
@return number of page read requests issued */
 
52
which could result in a deadlock if the OS does not support asynchronous io. */
69
53
UNIV_INTERN
70
54
ulint
71
55
buf_read_ahead_linear(
72
56
/*==================*/
73
 
        ulint   space,  /*!< in: space id */
74
 
        ulint   zip_size,/*!< in: compressed page size in bytes, or 0 */
75
 
        ulint   offset);/*!< in: page number of a page; NOTE: the current thread
 
57
                        /* out: number of page read requests issued */
 
58
        ulint   space,  /* in: space id */
 
59
        ulint   zip_size,/* in: compressed page size in bytes, or 0 */
 
60
        ulint   offset);/* in: page number of a page; NOTE: the current thread
76
61
                        must want access to this page (see NOTE 3 above) */
77
 
/********************************************************************//**
 
62
/************************************************************************
78
63
Issues read requests for pages which the ibuf module wants to read in, in
79
64
order to contract the insert buffer tree. Technically, this function is like
80
65
a read-ahead function. */
82
67
void
83
68
buf_read_ibuf_merge_pages(
84
69
/*======================*/
85
 
        ibool           sync,           /*!< in: TRUE if the caller
 
70
        ibool           sync,           /* in: TRUE if the caller
86
71
                                        wants this function to wait
87
72
                                        for the highest address page
88
73
                                        to get read in, before this
89
74
                                        function returns */
90
 
        const ulint*    space_ids,      /*!< in: array of space ids */
91
 
        const ib_int64_t* space_versions,/*!< in: the spaces must have
 
75
        const ulint*    space_ids,      /* in: array of space ids */
 
76
        const ib_int64_t* space_versions,/* in: the spaces must have
92
77
                                        this version number
93
78
                                        (timestamp), otherwise we
94
79
                                        discard the read; we use this
95
80
                                        to cancel reads if DISCARD +
96
81
                                        IMPORT may have changed the
97
82
                                        tablespace size */
98
 
        const ulint*    page_nos,       /*!< in: array of page numbers
 
83
        const ulint*    page_nos,       /* in: array of page numbers
99
84
                                        to read, with the highest page
100
85
                                        number the last in the
101
86
                                        array */
102
 
        ulint           n_stored);      /*!< in: number of elements
 
87
        ulint           n_stored);      /* in: number of elements
103
88
                                        in the arrays */
104
 
/********************************************************************//**
 
89
/************************************************************************
105
90
Issues read requests for pages which recovery wants to read in. */
106
91
UNIV_INTERN
107
92
void
108
93
buf_read_recv_pages(
109
94
/*================*/
110
 
        ibool           sync,           /*!< in: TRUE if the caller
 
95
        ibool           sync,           /* in: TRUE if the caller
111
96
                                        wants this function to wait
112
97
                                        for the highest address page
113
98
                                        to get read in, before this
114
99
                                        function returns */
115
 
        ulint           space,          /*!< in: space id */
116
 
        ulint           zip_size,       /*!< in: compressed page size in
 
100
        ulint           space,          /* in: space id */
 
101
        ulint           zip_size,       /* in: compressed page size in
117
102
                                        bytes, or 0 */
118
 
        const ulint*    page_nos,       /*!< in: array of page numbers
 
103
        const ulint*    page_nos,       /* in: array of page numbers
119
104
                                        to read, with the highest page
120
105
                                        number the last in the
121
106
                                        array */
122
 
        ulint           n_stored);      /*!< in: number of page numbers
 
107
        ulint           n_stored);      /* in: number of page numbers
123
108
                                        in the array */
124
109
 
125
 
/** The size in pages of the area which the read-ahead algorithms read if
 
110
/* The size in pages of the area which the read-ahead algorithms read if
126
111
invoked */
127
 
#define BUF_READ_AHEAD_AREA(b)                                  \
128
 
        ut_min(64, ut_2_power_up((b)->curr_size / 32))
129
 
 
130
 
/** @name Modes used in read-ahead @{ */
131
 
/** read only pages belonging to the insert buffer tree */
 
112
 
 
113
#define BUF_READ_AHEAD_AREA                                     \
 
114
        ut_min(64, ut_2_power_up(buf_pool->curr_size / 32))
 
115
 
 
116
/* Modes used in read-ahead */
132
117
#define BUF_READ_IBUF_PAGES_ONLY        131
133
 
/** read any page */
134
118
#define BUF_READ_ANY_PAGE               132
135
 
/* @} */
136
119
 
137
120
#endif