← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2008-08-04 19:37:18 UTC
  • mto: (261.2.2 codestyle)
  • mto: This revision was merged to the branch mainline in revision 262.
  • Revision ID: monty@inaugust.com-20080804193718-f0rz13uli4429ozb
Changed gettext_noop() to N_()

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/buf0rea.h
18
18
an exclusive lock on the buffer frame. The flag is cleared and the x-lock
19
19
released by the i/o-handler thread. Does a random read-ahead if it seems
20
20
sensible. */
21
 
UNIV_INTERN
 
21
 
22
22
ulint
23
23
buf_read_page(
24
24
/*==========*/
25
25
                        /* out: number of page read requests issued: this can
26
26
                        be > 1 if read-ahead occurred */
27
27
        ulint   space,  /* in: space id */
28
 
        ulint   zip_size,/* in: compressed page size in bytes, or 0 */
29
28
        ulint   offset);/* in: page number */
30
29
/************************************************************************
31
30
Applies linear read-ahead if in the buf_pool the page is a border page of
50
49
NOTE 3: the calling thread must want access to the page given: this rule is
51
50
set to prevent unintended read-aheads performed by ibuf routines, a situation
52
51
which could result in a deadlock if the OS does not support asynchronous io. */
53
 
UNIV_INTERN
 
52
 
54
53
ulint
55
54
buf_read_ahead_linear(
56
55
/*==================*/
57
56
                        /* out: number of page read requests issued */
58
57
        ulint   space,  /* in: space id */
59
 
        ulint   zip_size,/* in: compressed page size in bytes, or 0 */
60
58
        ulint   offset);/* in: page number of a page; NOTE: the current thread
61
59
                        must want access to this page (see NOTE 3 above) */
62
60
/************************************************************************
63
61
Issues read requests for pages which the ibuf module wants to read in, in
64
62
order to contract the insert buffer tree. Technically, this function is like
65
63
a read-ahead function. */
66
 
UNIV_INTERN
 
64
 
67
65
void
68
66
buf_read_ibuf_merge_pages(
69
67
/*======================*/
70
 
        ibool           sync,           /* in: TRUE if the caller
71
 
                                        wants this function to wait
72
 
                                        for the highest address page
73
 
                                        to get read in, before this
74
 
                                        function returns */
75
 
        const ulint*    space_ids,      /* in: array of space ids */
76
 
        const ib_int64_t* space_versions,/* in: the spaces must have
77
 
                                        this version number
78
 
                                        (timestamp), otherwise we
79
 
                                        discard the read; we use this
80
 
                                        to cancel reads if DISCARD +
81
 
                                        IMPORT may have changed the
82
 
                                        tablespace size */
83
 
        const ulint*    page_nos,       /* in: array of page numbers
84
 
                                        to read, with the highest page
85
 
                                        number the last in the
86
 
                                        array */
87
 
        ulint           n_stored);      /* in: number of elements
88
 
                                        in the arrays */
 
68
        ibool   sync,           /* in: TRUE if the caller wants this function
 
69
                                to wait for the highest address page to get
 
70
                                read in, before this function returns */
 
71
        ulint*  space_ids,      /* in: array of space ids */
 
72
        ib_longlong* space_versions,/* in: the spaces must have this version
 
73
                                number (timestamp), otherwise we discard the
 
74
                                read; we use this to cancel reads if
 
75
                                DISCARD + IMPORT may have changed the
 
76
                                tablespace size */
 
77
        ulint*  page_nos,       /* in: array of page numbers to read, with the
 
78
                                highest page number the last in the array */
 
79
        ulint   n_stored);      /* in: number of page numbers in the array */
89
80
/************************************************************************
90
81
Issues read requests for pages which recovery wants to read in. */
91
 
UNIV_INTERN
 
82
 
92
83
void
93
84
buf_read_recv_pages(
94
85
/*================*/
95
 
        ibool           sync,           /* in: TRUE if the caller
96
 
                                        wants this function to wait
97
 
                                        for the highest address page
98
 
                                        to get read in, before this
99
 
                                        function returns */
100
 
        ulint           space,          /* in: space id */
101
 
        ulint           zip_size,       /* in: compressed page size in
102
 
                                        bytes, or 0 */
103
 
        const ulint*    page_nos,       /* in: array of page numbers
104
 
                                        to read, with the highest page
105
 
                                        number the last in the
106
 
                                        array */
107
 
        ulint           n_stored);      /* in: number of page numbers
108
 
                                        in the array */
 
86
        ibool   sync,           /* in: TRUE if the caller wants this function
 
87
                                to wait for the highest address page to get
 
88
                                read in, before this function returns */
 
89
        ulint   space,          /* in: space id */
 
90
        ulint*  page_nos,       /* in: array of page numbers to read, with the
 
91
                                highest page number the last in the array */
 
92
        ulint   n_stored);      /* in: number of page numbers in the array */
109
93
 
110
94
/* The size in pages of the area which the read-ahead algorithms read if
111
95
invoked */