← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/buf0flu.h

  • Committer: Brian Aker
  • Date: 2010-05-27 01:22:55 UTC
  • mto: This revision was merged to the branch mainline in revision 1568.
  • Revision ID: brian@gaz-20100527012255-ssmjt4un8ptpg4jv
Remove dead .opt files. Removed two options from Innodb which do not relate
to drizzle (backwards compatible options for old MySQL). 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/buf0flu.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1995, 2010, 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/buf0flu.h
21
 
The database buffer pool flush algorithm
22
 
 
23
 
Created 11/5/1995 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#ifndef buf0flu_h
27
 
#define buf0flu_h
28
 
 
29
 
#include "univ.i"
30
 
#include "ut0byte.h"
31
 
#ifndef UNIV_HOTBACKUP
32
 
#include "mtr0types.h"
33
 
#include "buf0types.h"
34
 
#include "log0log.h"
35
 
 
36
 
/********************************************************************//**
37
 
Remove a block from the flush list of modified blocks. */
38
 
UNIV_INTERN
39
 
void
40
 
buf_flush_remove(
41
 
/*=============*/
42
 
        buf_page_t*     bpage); /*!< in: pointer to the block in question */
43
 
/*******************************************************************//**
44
 
Relocates a buffer control block on the flush_list.
45
 
Note that it is assumed that the contents of bpage has already been
46
 
copied to dpage. */
47
 
UNIV_INTERN
48
 
void
49
 
buf_flush_relocate_on_flush_list(
50
 
/*=============================*/
51
 
        buf_page_t*     bpage,  /*!< in/out: control block being moved */
52
 
        buf_page_t*     dpage); /*!< in/out: destination block */
53
 
/********************************************************************//**
54
 
Updates the flush system data structures when a write is completed. */
55
 
UNIV_INTERN
56
 
void
57
 
buf_flush_write_complete(
58
 
/*=====================*/
59
 
        buf_page_t*     bpage); /*!< in: pointer to the block in question */
60
 
/*********************************************************************//**
61
 
Flushes pages from the end of the LRU list if there is too small
62
 
a margin of replaceable pages there. If buffer pool is NULL it
63
 
means flush free margin on all buffer pool instances. */
64
 
UNIV_INTERN
65
 
void
66
 
buf_flush_free_margin(
67
 
/*==================*/
68
 
         buf_pool_t*    buf_pool);
69
 
/*********************************************************************//**
70
 
Flushes pages from the end of all the LRU lists. */
71
 
UNIV_INTERN
72
 
void
73
 
buf_flush_free_margins(void);
74
 
/*=========================*/
75
 
#endif /* !UNIV_HOTBACKUP */
76
 
/********************************************************************//**
77
 
Initializes a page for writing to the tablespace. */
78
 
UNIV_INTERN
79
 
void
80
 
buf_flush_init_for_writing(
81
 
/*=======================*/
82
 
        byte*           page,           /*!< in/out: page */
83
 
        void*           page_zip_,      /*!< in/out: compressed page, or NULL */
84
 
        ib_uint64_t     newest_lsn);    /*!< in: newest modification lsn
85
 
                                        to the page */
86
 
#ifndef UNIV_HOTBACKUP
87
 
# if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
88
 
/********************************************************************//**
89
 
Writes a flushable page asynchronously from the buffer pool to a file.
90
 
NOTE: buf_pool->mutex and block->mutex must be held upon entering this
91
 
function, and they will be released by this function after flushing.
92
 
This is loosely based on buf_flush_batch() and buf_flush_page().
93
 
@return TRUE if the page was flushed and the mutexes released */
94
 
UNIV_INTERN
95
 
ibool
96
 
buf_flush_page_try(
97
 
/*===============*/
98
 
        buf_pool_t*     buf_pool,       /*!< in/out: buffer pool instance */
99
 
        buf_block_t*    block)          /*!< in/out: buffer control block */
100
 
        __attribute__((nonnull, warn_unused_result));
101
 
# endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
102
 
/*******************************************************************//**
103
 
This utility flushes dirty blocks from the end of the LRU list.
104
 
NOTE: The calling thread may own latches to pages: to avoid deadlocks,
105
 
this function must be written so that it cannot end up waiting for these
106
 
latches!
107
 
@return number of blocks for which the write request was queued;
108
 
ULINT_UNDEFINED if there was a flush of the same type already running */
109
 
UNIV_INTERN
110
 
ulint
111
 
buf_flush_LRU(
112
 
/*==========*/
113
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
114
 
        ulint           min_n);         /*!< in: wished minimum mumber of blocks
115
 
                                        flushed (it is not guaranteed that the
116
 
                                        actual number is that big, though) */
117
 
/*******************************************************************//**
118
 
This utility flushes dirty blocks from the end of the flush_list of
119
 
all buffer pool instances.
120
 
NOTE: The calling thread is not allowed to own any latches on pages!
121
 
@return number of blocks for which the write request was queued;
122
 
ULINT_UNDEFINED if there was a flush of the same type already running */
123
 
UNIV_INTERN
124
 
ulint
125
 
buf_flush_list(
126
 
/*============*/
127
 
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
128
 
                                        flushed (it is not guaranteed that the
129
 
                                        actual number is that big, though) */
130
 
        ib_uint64_t     lsn_limit);     /*!< in the case BUF_FLUSH_LIST all
131
 
                                        blocks whose oldest_modification is
132
 
                                        smaller than this should be flushed
133
 
                                        (if their number does not exceed
134
 
                                        min_n), otherwise ignored */
135
 
/******************************************************************//**
136
 
Waits until a flush batch of the given type ends */
137
 
UNIV_INTERN
138
 
void
139
 
buf_flush_wait_batch_end(
140
 
/*=====================*/
141
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
142
 
        enum buf_flush  type);          /*!< in: BUF_FLUSH_LRU
143
 
                                        or BUF_FLUSH_LIST */
144
 
/********************************************************************//**
145
 
This function should be called at a mini-transaction commit, if a page was
146
 
modified in it. Puts the block to the list of modified blocks, if it not
147
 
already in it. */
148
 
UNIV_INLINE
149
 
void
150
 
buf_flush_note_modification(
151
 
/*========================*/
152
 
        buf_block_t*    block,  /*!< in: block which is modified */
153
 
        mtr_t*          mtr);   /*!< in: mtr */
154
 
/********************************************************************//**
155
 
This function should be called when recovery has modified a buffer page. */
156
 
UNIV_INLINE
157
 
void
158
 
buf_flush_recv_note_modification(
159
 
/*=============================*/
160
 
        buf_block_t*    block,          /*!< in: block which is modified */
161
 
        ib_uint64_t     start_lsn,      /*!< in: start lsn of the first mtr in a
162
 
                                        set of mtr's */
163
 
        ib_uint64_t     end_lsn);       /*!< in: end lsn of the last mtr in the
164
 
                                        set of mtr's */
165
 
/********************************************************************//**
166
 
Returns TRUE if the file page block is immediately suitable for replacement,
167
 
i.e., transition FILE_PAGE => NOT_USED allowed.
168
 
@return TRUE if can replace immediately */
169
 
UNIV_INTERN
170
 
ibool
171
 
buf_flush_ready_for_replace(
172
 
/*========================*/
173
 
        buf_page_t*     bpage); /*!< in: buffer control block, must be
174
 
                                buf_page_in_file(bpage) and in the LRU list */
175
 
 
176
 
/** @brief Statistics for selecting flush rate based on redo log
177
 
generation speed.
178
 
 
179
 
These statistics are generated for heuristics used in estimating the
180
 
rate at which we should flush the dirty blocks to avoid bursty IO
181
 
activity. Note that the rate of flushing not only depends on how many
182
 
dirty pages we have in the buffer pool but it is also a fucntion of
183
 
how much redo the workload is generating and at what rate. */
184
 
 
185
 
struct buf_flush_stat_struct
186
 
{
187
 
        ib_uint64_t     redo;           /**< amount of redo generated. */
188
 
        ulint           n_flushed;      /**< number of pages flushed. */
189
 
};
190
 
 
191
 
/** Statistics for selecting flush rate of dirty pages. */
192
 
typedef struct buf_flush_stat_struct buf_flush_stat_t;
193
 
/*********************************************************************
194
 
Update the historical stats that we are collecting for flush rate
195
 
heuristics at the end of each interval. */
196
 
UNIV_INTERN
197
 
void
198
 
buf_flush_stat_update(void);
199
 
/*=======================*/
200
 
/*********************************************************************
201
 
Determines the fraction of dirty pages that need to be flushed based
202
 
on the speed at which we generate redo log. Note that if redo log
203
 
is generated at significant rate without a corresponding increase
204
 
in the number of dirty pages (for example, an in-memory workload)
205
 
it can cause IO bursts of flushing. This function implements heuristics
206
 
to avoid this burstiness.
207
 
@return number of dirty pages to be flushed / second */
208
 
UNIV_INTERN
209
 
ulint
210
 
buf_flush_get_desired_flush_rate(void);
211
 
/*==================================*/
212
 
 
213
 
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
214
 
/******************************************************************//**
215
 
Validates the flush list.
216
 
@return TRUE if ok */
217
 
UNIV_INTERN
218
 
ibool
219
 
buf_flush_validate(
220
 
/*===============*/
221
 
        buf_pool_t*     buf_pool);
222
 
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
223
 
 
224
 
/********************************************************************//**
225
 
Initialize the red-black tree to speed up insertions into the flush_list
226
 
during recovery process. Should be called at the start of recovery
227
 
process before any page has been read/written. */
228
 
UNIV_INTERN
229
 
void
230
 
buf_flush_init_flush_rbt(void);
231
 
/*==========================*/
232
 
 
233
 
/********************************************************************//**
234
 
Frees up the red-black tree. */
235
 
UNIV_INTERN
236
 
void
237
 
buf_flush_free_flush_rbt(void);
238
 
/*==========================*/
239
 
 
240
 
/** When buf_flush_free_margin is called, it tries to make this many blocks
241
 
available to replacement in the free list and at the end of the LRU list (to
242
 
make sure that a read-ahead batch can be read efficiently in a single
243
 
sweep). */
244
 
#define BUF_FLUSH_FREE_BLOCK_MARGIN(b)  (5 + BUF_READ_AHEAD_AREA(b))
245
 
/** Extra margin to apply above BUF_FLUSH_FREE_BLOCK_MARGIN */
246
 
#define BUF_FLUSH_EXTRA_MARGIN(b)       ((BUF_FLUSH_FREE_BLOCK_MARGIN(b) / 4 \
247
 
                                        + 100) / srv_buf_pool_instances)
248
 
#endif /* !UNIV_HOTBACKUP */
249
 
 
250
 
#ifndef UNIV_NONINL
251
 
#include "buf0flu.ic"
252
 
#endif
253
 
 
254
 
#endif