← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2010-10-15 17:18:02 UTC
  • mto: (1859.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1860.
  • Revision ID: mordred@inaugust.com-20101015171802-qhk6zyfhrkvprr1n
Added support for registering regular sys_var instances via module::Context.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/buf0flu.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/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
 
 
35
/********************************************************************//**
 
36
Remove a block from the flush list of modified blocks. */
 
37
UNIV_INTERN
 
38
void
 
39
buf_flush_remove(
 
40
/*=============*/
 
41
        buf_page_t*     bpage); /*!< in: pointer to the block in question */
 
42
/********************************************************************//**
 
43
Updates the flush system data structures when a write is completed. */
 
44
UNIV_INTERN
 
45
void
 
46
buf_flush_write_complete(
 
47
/*=====================*/
 
48
        buf_page_t*     bpage); /*!< in: pointer to the block in question */
 
49
/*********************************************************************//**
 
50
Flushes pages from the end of the LRU list if there is too small
 
51
a margin of replaceable pages there. */
 
52
UNIV_INTERN
 
53
void
 
54
buf_flush_free_margin(void);
 
55
/*=======================*/
 
56
#endif /* !UNIV_HOTBACKUP */
 
57
/********************************************************************//**
 
58
Initializes a page for writing to the tablespace. */
 
59
UNIV_INTERN
 
60
void
 
61
buf_flush_init_for_writing(
 
62
/*=======================*/
 
63
        byte*           page,           /*!< in/out: page */
 
64
        void*           page_zip_,      /*!< in/out: compressed page, or NULL */
 
65
        ib_uint64_t     newest_lsn);    /*!< in: newest modification lsn
 
66
                                        to the page */
 
67
#ifndef UNIV_HOTBACKUP
 
68
/*******************************************************************//**
 
69
This utility flushes dirty blocks from the end of the LRU list or flush_list.
 
70
NOTE 1: in the case of an LRU flush the calling thread may own latches to
 
71
pages: to avoid deadlocks, this function must be written so that it cannot
 
72
end up waiting for these latches! NOTE 2: in the case of a flush list flush,
 
73
the calling thread is not allowed to own any latches on pages!
 
74
@return number of blocks for which the write request was queued;
 
75
ULINT_UNDEFINED if there was a flush of the same type already running */
 
76
UNIV_INTERN
 
77
ulint
 
78
buf_flush_batch(
 
79
/*============*/
 
80
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU or
 
81
                                        BUF_FLUSH_LIST; if BUF_FLUSH_LIST,
 
82
                                        then the caller must not own any
 
83
                                        latches on pages */
 
84
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
 
85
                                        flushed (it is not guaranteed that the
 
86
                                        actual number is that big, though) */
 
87
        ib_uint64_t     lsn_limit);     /*!< in the case BUF_FLUSH_LIST all
 
88
                                        blocks whose oldest_modification is
 
89
                                        smaller than this should be flushed
 
90
                                        (if their number does not exceed
 
91
                                        min_n), otherwise ignored */
 
92
/******************************************************************//**
 
93
Waits until a flush batch of the given type ends */
 
94
UNIV_INTERN
 
95
void
 
96
buf_flush_wait_batch_end(
 
97
/*=====================*/
 
98
        enum buf_flush  type);  /*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
 
99
/********************************************************************//**
 
100
This function should be called at a mini-transaction commit, if a page was
 
101
modified in it. Puts the block to the list of modified blocks, if it not
 
102
already in it. */
 
103
UNIV_INLINE
 
104
void
 
105
buf_flush_note_modification(
 
106
/*========================*/
 
107
        buf_block_t*    block,  /*!< in: block which is modified */
 
108
        mtr_t*          mtr);   /*!< in: mtr */
 
109
/********************************************************************//**
 
110
This function should be called when recovery has modified a buffer page. */
 
111
UNIV_INLINE
 
112
void
 
113
buf_flush_recv_note_modification(
 
114
/*=============================*/
 
115
        buf_block_t*    block,          /*!< in: block which is modified */
 
116
        ib_uint64_t     start_lsn,      /*!< in: start lsn of the first mtr in a
 
117
                                        set of mtr's */
 
118
        ib_uint64_t     end_lsn);       /*!< in: end lsn of the last mtr in the
 
119
                                        set of mtr's */
 
120
/********************************************************************//**
 
121
Returns TRUE if the file page block is immediately suitable for replacement,
 
122
i.e., transition FILE_PAGE => NOT_USED allowed.
 
123
@return TRUE if can replace immediately */
 
124
UNIV_INTERN
 
125
ibool
 
126
buf_flush_ready_for_replace(
 
127
/*========================*/
 
128
        buf_page_t*     bpage); /*!< in: buffer control block, must be
 
129
                                buf_page_in_file(bpage) and in the LRU list */
 
130
 
 
131
/** @brief Statistics for selecting flush rate based on redo log
 
132
generation speed.
 
133
 
 
134
These statistics are generated for heuristics used in estimating the
 
135
rate at which we should flush the dirty blocks to avoid bursty IO
 
136
activity. Note that the rate of flushing not only depends on how many
 
137
dirty pages we have in the buffer pool but it is also a fucntion of
 
138
how much redo the workload is generating and at what rate. */
 
139
 
 
140
struct buf_flush_stat_struct
 
141
{
 
142
        ib_uint64_t     redo;           /**< amount of redo generated. */
 
143
        ulint           n_flushed;      /**< number of pages flushed. */
 
144
};
 
145
 
 
146
/** Statistics for selecting flush rate of dirty pages. */
 
147
typedef struct buf_flush_stat_struct buf_flush_stat_t;
 
148
/*********************************************************************
 
149
Update the historical stats that we are collecting for flush rate
 
150
heuristics at the end of each interval. */
 
151
UNIV_INTERN
 
152
void
 
153
buf_flush_stat_update(void);
 
154
/*=======================*/
 
155
/*********************************************************************
 
156
Determines the fraction of dirty pages that need to be flushed based
 
157
on the speed at which we generate redo log. Note that if redo log
 
158
is generated at significant rate without a corresponding increase
 
159
in the number of dirty pages (for example, an in-memory workload)
 
160
it can cause IO bursts of flushing. This function implements heuristics
 
161
to avoid this burstiness.
 
162
@return number of dirty pages to be flushed / second */
 
163
UNIV_INTERN
 
164
ulint
 
165
buf_flush_get_desired_flush_rate(void);
 
166
/*==================================*/
 
167
 
 
168
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 
169
/******************************************************************//**
 
170
Validates the flush list.
 
171
@return TRUE if ok */
 
172
UNIV_INTERN
 
173
ibool
 
174
buf_flush_validate(void);
 
175
/*====================*/
 
176
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
177
 
 
178
/** When buf_flush_free_margin is called, it tries to make this many blocks
 
179
available to replacement in the free list and at the end of the LRU list (to
 
180
make sure that a read-ahead batch can be read efficiently in a single
 
181
sweep). */
 
182
#define BUF_FLUSH_FREE_BLOCK_MARGIN     (5 + BUF_READ_AHEAD_AREA)
 
183
/** Extra margin to apply above BUF_FLUSH_FREE_BLOCK_MARGIN */
 
184
#define BUF_FLUSH_EXTRA_MARGIN          (BUF_FLUSH_FREE_BLOCK_MARGIN / 4 + 100)
 
185
#endif /* !UNIV_HOTBACKUP */
 
186
 
 
187
#ifndef UNIV_NONINL
 
188
#include "buf0flu.ic"
 
189
#endif
 
190
 
 
191
#endif