← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Merge Joe, plus I updated the tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/buf0buf.h
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
11
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
12
 
13
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
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
16
16
 
17
17
*****************************************************************************/
18
18
 
34
34
#include "ut0byte.h"
35
35
#include "page0types.h"
36
36
#ifndef UNIV_HOTBACKUP
37
 
#include "ut0rbt.h"
38
37
#include "os0proc.h"
39
38
 
40
39
/** @name Modes for buf_page_get_gen */
47
46
                                        it is error-prone programming
48
47
                                        not to set a latch, and it
49
48
                                        should be used with care */
50
 
#define BUF_GET_IF_IN_POOL_OR_WATCH     15
51
 
                                        /*!< Get the page only if it's in the
52
 
                                        buffer pool, if not then set a watch
53
 
                                        on the page. */
54
49
/* @} */
55
50
/** @name Modes for buf_page_get_known_nowait */
56
51
/* @{ */
63
58
                                        position of the block. */
64
59
/* @} */
65
60
 
66
 
#define MAX_BUFFER_POOLS 64             /*!< The maximum number of buffer
67
 
                                        pools that can be defined */
68
 
 
69
 
#define BUF_POOL_WATCH_SIZE 1           /*!< Maximum number of concurrent
70
 
                                        buffer pool watches */
71
 
 
72
 
extern  buf_pool_t*     buf_pool_ptr;   /*!< The buffer pools
73
 
                                        of the database */
 
61
extern buf_pool_t*      buf_pool;       /*!< The buffer pool of the database */
74
62
#ifdef UNIV_DEBUG
75
63
extern ibool            buf_debug_prints;/*!< If this is set TRUE, the program
76
64
                                        prints info whenever read or flush
91
79
enum buf_page_state {
92
80
        BUF_BLOCK_ZIP_FREE = 0,         /*!< contains a free
93
81
                                        compressed page */
94
 
        BUF_BLOCK_POOL_WATCH = 0,       /*!< a sentinel for the buffer pool
95
 
                                        watch, element of buf_pool->watch[] */
96
82
        BUF_BLOCK_ZIP_PAGE,             /*!< contains a clean
97
83
                                        compressed page */
98
84
        BUF_BLOCK_ZIP_DIRTY,            /*!< contains a compressed
114
100
 
115
101
#ifndef UNIV_HOTBACKUP
116
102
/********************************************************************//**
117
 
Acquire mutex on all buffer pool instances */
118
 
UNIV_INLINE
119
 
void
120
 
buf_pool_mutex_enter_all(void);
121
 
/*===========================*/
122
 
 
123
 
/********************************************************************//**
124
 
Release mutex on all buffer pool instances */
125
 
UNIV_INLINE
126
 
void
127
 
buf_pool_mutex_exit_all(void);
128
 
/*==========================*/
129
 
 
130
 
/********************************************************************//**
131
103
Creates the buffer pool.
132
104
@return own: buf_pool object, NULL if not enough memory or error */
133
105
UNIV_INTERN
134
 
ulint
135
 
buf_pool_init(
136
 
/*=========*/
137
 
        ulint   size,           /*!< in: Size of the total pool in bytes */
138
 
        ulint   n_instances);   /*!< in: Number of instances */
 
106
buf_pool_t*
 
107
buf_pool_init(void);
 
108
/*===============*/
139
109
/********************************************************************//**
140
110
Frees the buffer pool at shutdown.  This must not be invoked before
141
111
freeing all mutexes. */
142
112
UNIV_INTERN
143
113
void
144
 
buf_pool_free(
145
 
/*==========*/
146
 
        ulint   n_instances);   /*!< in: numbere of instances to free */
 
114
buf_pool_free(void);
 
115
/*===============*/
147
116
 
148
117
/********************************************************************//**
149
118
Drops the adaptive hash index.  To prevent a livelock, this function
180
149
ulint
181
150
buf_pool_get_curr_size(void);
182
151
/*========================*/
183
 
/*********************************************************************//**
184
 
Gets the current size of buffer buf_pool in frames.
185
 
@return size in pages */
186
 
UNIV_INLINE
187
 
ulint
188
 
buf_pool_get_n_pages(void);
189
 
/*=======================*/
190
152
/********************************************************************//**
191
153
Gets the smallest oldest_modification lsn for any page in the pool. Returns
192
154
zero if all modified pages have been flushed to disk.
193
155
@return oldest modification in pool, zero if none */
194
 
UNIV_INTERN
 
156
UNIV_INLINE
195
157
ib_uint64_t
196
158
buf_pool_get_oldest_modification(void);
197
159
/*==================================*/
198
160
/********************************************************************//**
199
161
Allocates a buffer block.
200
162
@return own: the allocated block, in state BUF_BLOCK_MEMORY */
201
 
UNIV_INTERN
 
163
UNIV_INLINE
202
164
buf_block_t*
203
165
buf_block_alloc(
204
166
/*============*/
205
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
206
 
        ulint           zip_size);      /*!< in: compressed page size in bytes,
207
 
                                        or 0 if uncompressed tablespace */
 
167
        ulint   zip_size);      /*!< in: compressed page size in bytes,
 
168
                                or 0 if uncompressed tablespace */
208
169
/********************************************************************//**
209
170
Frees a buffer block which does not contain a file page. */
210
171
UNIV_INLINE
239
200
#define buf_page_get_with_no_latch(SP, ZS, OF, MTR)        buf_page_get_gen(\
240
201
                                SP, ZS, OF, RW_NO_LATCH, NULL,\
241
202
                                BUF_GET_NO_LATCH, __FILE__, __LINE__, MTR)
 
203
/**************************************************************//**
 
204
NOTE! The following macros should be used instead of
 
205
buf_page_optimistic_get_func, to improve debugging. Only values RW_S_LATCH and
 
206
RW_X_LATCH are allowed as LA! */
 
207
#define buf_page_optimistic_get(LA, BL, MC, MTR)                             \
 
208
        buf_page_optimistic_get_func(LA, BL, MC, __FILE__, __LINE__, MTR)
242
209
/********************************************************************//**
243
210
This is the general function used to get optimistic access to a database
244
211
page.
245
212
@return TRUE if success */
246
213
UNIV_INTERN
247
214
ibool
248
 
buf_page_optimistic_get(
249
 
/*====================*/
 
215
buf_page_optimistic_get_func(
 
216
/*=========================*/
250
217
        ulint           rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH */
251
218
        buf_block_t*    block,  /*!< in: guessed block */
252
219
        ib_uint64_t     modify_clock,/*!< in: modify clock value if mode is
322
289
        ulint           rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
323
290
        buf_block_t*    guess,  /*!< in: guessed block or NULL */
324
291
        ulint           mode,   /*!< in: BUF_GET, BUF_GET_IF_IN_POOL,
325
 
                                BUF_GET_NO_LATCH or
326
 
                                BUF_GET_IF_IN_POOL_OR_WATCH */
 
292
                                BUF_GET_NO_LATCH */
327
293
        const char*     file,   /*!< in: file name */
328
294
        ulint           line,   /*!< in: line where called */
329
295
        mtr_t*          mtr);   /*!< in: mini-transaction */
373
339
buf_page_release(
374
340
/*=============*/
375
341
        buf_block_t*    block,          /*!< in: buffer block */
376
 
        ulint           rw_latch);      /*!< in: RW_S_LATCH, RW_X_LATCH,
 
342
        ulint           rw_latch,       /*!< in: RW_S_LATCH, RW_X_LATCH,
377
343
                                        RW_NO_LATCH */
 
344
        mtr_t*          mtr);           /*!< in: mtr */
378
345
/********************************************************************//**
379
346
Moves a page to the start of the buffer pool LRU list. This high-level
380
 
function can be used to prevent an important page from slipping out of
 
347
function can be used to prevent an important page from from slipping out of
381
348
the buffer pool. */
382
349
UNIV_INTERN
383
350
void
484
451
                                        page frame */
485
452
/********************************************************************//**
486
453
Increments the modify clock of a frame by 1. The caller must (1) own the
487
 
buf_pool->mutex and block bufferfix count has to be zero, (2) or own an x-lock
 
454
buf_pool mutex and block bufferfix count has to be zero, (2) or own an x-lock
488
455
on the block. */
489
456
UNIV_INLINE
490
457
void
566
533
buf_block_t*
567
534
buf_pool_contains_zip(
568
535
/*==================*/
569
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
570
 
        const void*     data);          /*!< in: pointer to compressed page */
 
536
        const void*     data);  /*!< in: pointer to compressed page */
571
537
#endif /* UNIV_DEBUG */
572
538
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
573
539
/*********************************************************************//**
641
607
Refreshes the statistics used to print per-second averages. */
642
608
UNIV_INTERN
643
609
void
644
 
buf_refresh_io_stats(
645
 
/*=================*/
646
 
        buf_pool_t*     buf_pool);      /*!< buffer pool instance */
647
 
/**********************************************************************//**
648
 
Refreshes the statistics used to print per-second averages. */
649
 
UNIV_INTERN
650
 
void
651
 
buf_refresh_io_stats_all(void);
652
 
/*=================*/
 
610
buf_refresh_io_stats(void);
 
611
/*======================*/
653
612
/*********************************************************************//**
654
613
Asserts that all file pages in the buffer are in a replaceable state.
655
614
@return TRUE */
746
705
/*==========================*/
747
706
        const buf_page_t*       bpage)  /*!< in: pointer to control block */
748
707
        __attribute__((pure));
 
708
/*********************************************************************//**
 
709
Determine the approximate LRU list position of a block.
 
710
@return LRU list position */
 
711
UNIV_INLINE
 
712
ulint
 
713
buf_page_get_LRU_position(
 
714
/*======================*/
 
715
        const buf_page_t*       bpage)  /*!< in: control block */
 
716
        __attribute__((pure));
749
717
 
750
718
/*********************************************************************//**
751
719
Gets the mutex of a block.
846
814
        buf_page_t*     bpage,  /*!< in/out: control block */
847
815
        ibool           old);   /*!< in: old */
848
816
/*********************************************************************//**
849
 
Determine the time of first access of a block in the buffer pool.
850
 
@return ut_time_ms() at the time of first access, 0 if not accessed */
 
817
Determine if a block has been accessed in the buffer pool.
 
818
@return TRUE if accessed */
851
819
UNIV_INLINE
852
 
unsigned
 
820
ibool
853
821
buf_page_is_accessed(
854
822
/*=================*/
855
823
        const buf_page_t*       bpage)  /*!< in: control block */
856
 
        __attribute__((nonnull, pure));
 
824
        __attribute__((pure));
857
825
/*********************************************************************//**
858
826
Flag a block accessed. */
859
827
UNIV_INLINE
861
829
buf_page_set_accessed(
862
830
/*==================*/
863
831
        buf_page_t*     bpage,          /*!< in/out: control block */
864
 
        ulint           time_ms)        /*!< in: ut_time_ms() */
865
 
        __attribute__((nonnull));
 
832
        ibool           accessed);      /*!< in: accessed */
866
833
/*********************************************************************//**
867
834
Gets the buf_block_t handle of a buffered file block if an uncompressed
868
 
page frame exists, or NULL. Note: even though bpage is not declared a
869
 
const we don't update its value. It is safe to make this pure.
 
835
page frame exists, or NULL.
870
836
@return control block, or NULL */
871
837
UNIV_INLINE
872
838
buf_block_t*
1030
996
        ulint   space,  /*!< in: space id */
1031
997
        ulint   offset) /*!< in: offset of the page within space */
1032
998
        __attribute__((const));
1033
 
/********************************************************************//**
1034
 
Calculates the index of a buffer pool to the buf_pool[] array.
1035
 
@return the position of the buffer pool in buf_pool[] */
1036
 
UNIV_INLINE
1037
 
ulint
1038
 
buf_pool_index(
1039
 
/*===========*/
1040
 
        const buf_pool_t*       buf_pool)       /*!< in: buffer pool */
1041
 
        __attribute__((nonnull, const));
1042
 
/******************************************************************//**
1043
 
Returns the buffer pool instance given a page instance
1044
 
@return buf_pool */
1045
 
UNIV_INLINE
1046
 
buf_pool_t*
1047
 
buf_pool_from_bpage(
1048
 
/*================*/
1049
 
        const buf_page_t*       bpage); /*!< in: buffer pool page */
1050
 
/******************************************************************//**
1051
 
Returns the buffer pool instance given a block instance
1052
 
@return buf_pool */
1053
 
UNIV_INLINE
1054
 
buf_pool_t*
1055
 
buf_pool_from_block(
1056
 
/*================*/
1057
 
        const buf_block_t*      block); /*!< in: block */
1058
 
/******************************************************************//**
1059
 
Returns the buffer pool instance given space and offset of page
1060
 
@return buffer pool */
1061
 
UNIV_INLINE
1062
 
buf_pool_t*
1063
 
buf_pool_get(
1064
 
/*==========*/
1065
 
        ulint   space,  /*!< in: space id */
1066
 
        ulint   offset);/*!< in: offset of the page within space */
1067
 
/******************************************************************//**
1068
 
Returns the buffer pool instance given its array index
1069
 
@return buffer pool */
1070
 
UNIV_INLINE
1071
 
buf_pool_t*
1072
 
buf_pool_from_array(
1073
 
/*================*/
1074
 
        ulint   index);         /*!< in: array index to get
1075
 
                                buffer pool instance from */
1076
999
/******************************************************************//**
1077
1000
Returns the control block of a file page, NULL if not found.
1078
1001
@return block, NULL if not found */
1079
1002
UNIV_INLINE
1080
1003
buf_page_t*
1081
 
buf_page_hash_get_low(
1082
 
/*==================*/
1083
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1084
 
        ulint           space,          /*!< in: space id */
1085
 
        ulint           offset,         /*!< in: offset of the page
1086
 
                                        within space */
1087
 
        ulint           fold);          /*!< in: buf_page_address_fold(
1088
 
                                        space, offset) */
1089
 
/******************************************************************//**
1090
 
Returns the control block of a file page, NULL if not found.
1091
 
@return block, NULL if not found or not a real control block */
1092
 
UNIV_INLINE
1093
 
buf_page_t*
1094
1004
buf_page_hash_get(
1095
1005
/*==============*/
1096
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1097
 
        ulint           space,          /*!< in: space id */
1098
 
        ulint           offset);        /*!< in: offset of the page
1099
 
                                        within space */
 
1006
        ulint   space,  /*!< in: space id */
 
1007
        ulint   offset);/*!< in: offset of the page within space */
1100
1008
/******************************************************************//**
1101
1009
Returns the control block of a file page, NULL if not found
1102
1010
or an uncompressed page frame does not exist.
1105
1013
buf_block_t*
1106
1014
buf_block_hash_get(
1107
1015
/*===============*/
1108
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1109
 
        ulint           space,          /*!< in: space id */
1110
 
        ulint           offset);        /*!< in: offset of the page
1111
 
                                        within space */
 
1016
        ulint   space,  /*!< in: space id */
 
1017
        ulint   offset);/*!< in: offset of the page within space */
 
1018
/*******************************************************************//**
 
1019
Increments the pool clock by one and returns its new value. Remember that
 
1020
in the 32 bit version the clock wraps around at 4 billion!
 
1021
@return new clock value */
 
1022
UNIV_INLINE
 
1023
ulint
 
1024
buf_pool_clock_tic(void);
 
1025
/*====================*/
1112
1026
/*********************************************************************//**
1113
1027
Gets the current length of the free list of buffer blocks.
1114
1028
@return length of the free list */
1116
1030
ulint
1117
1031
buf_get_free_list_len(void);
1118
1032
/*=======================*/
1119
 
 
1120
 
/********************************************************************
1121
 
Determine if a block is a sentinel for a buffer pool watch.
1122
 
@return TRUE if a sentinel for a buffer pool watch, FALSE if not */
1123
 
UNIV_INTERN
1124
 
ibool
1125
 
buf_pool_watch_is_sentinel(
1126
 
/*=======================*/
1127
 
        buf_pool_t*             buf_pool,       /*!< buffer pool instance */
1128
 
        const buf_page_t*       bpage)          /*!< in: block */
1129
 
  UNIV_WARN_UNUSED_RESULT;
1130
 
/****************************************************************//**
1131
 
Add watch for the given page to be read in. Caller must have the buffer pool
1132
 
@return NULL if watch set, block if the page is in the buffer pool */
1133
 
UNIV_INTERN
1134
 
buf_page_t*
1135
 
buf_pool_watch_set(
1136
 
/*===============*/
1137
 
        ulint   space,  /*!< in: space id */
1138
 
        ulint   offset, /*!< in: page number */
1139
 
        ulint   fold)   /*!< in: buf_page_address_fold(space, offset) */
1140
 
  UNIV_WARN_UNUSED_RESULT;
1141
 
/****************************************************************//**
1142
 
Stop watching if the page has been read in.
1143
 
buf_pool_watch_set(space,offset) must have returned NULL before. */
1144
 
UNIV_INTERN
1145
 
void
1146
 
buf_pool_watch_unset(
1147
 
/*=================*/
1148
 
        ulint   space,  /*!< in: space id */
1149
 
        ulint   offset);/*!< in: page number */
1150
 
/****************************************************************//**
1151
 
Check if the page has been read in.
1152
 
This may only be called after buf_pool_watch_set(space,offset)
1153
 
has returned NULL and before invoking buf_pool_watch_unset(space,offset).
1154
 
@return FALSE if the given page was not read in, TRUE if it was */
1155
 
UNIV_INTERN
1156
 
ibool
1157
 
buf_pool_watch_occurred(
1158
 
/*====================*/
1159
 
        ulint   space,  /*!< in: space id */
1160
 
        ulint   offset) /*!< in: page number */
1161
 
  UNIV_WARN_UNUSED_RESULT;
1162
 
/********************************************************************//**
1163
 
Get total buffer pool statistics. */
1164
 
UNIV_INTERN
1165
 
void
1166
 
buf_get_total_list_len(
1167
 
/*===================*/
1168
 
        ulint*          LRU_len,        /*!< out: length of all LRU lists */
1169
 
        ulint*          free_len,       /*!< out: length of all free lists */
1170
 
        ulint*          flush_list_len);/*!< out: length of all flush lists */
1171
 
/********************************************************************//**
1172
 
Get total buffer pool statistics. */
1173
 
UNIV_INTERN
1174
 
void
1175
 
buf_get_total_stat(
1176
 
/*===============*/
1177
 
        buf_pool_stat_t*tot_stat);      /*!< out: buffer pool stats */
1178
 
 
1179
1033
#endif /* !UNIV_HOTBACKUP */
1180
1034
 
 
1035
 
1181
1036
/** The common buffer control block structure
1182
1037
for compressed and uncompressed frames */
1183
1038
 
1185
1040
        /** @name General fields
1186
1041
        None of these bit-fields must be modified without holding
1187
1042
        buf_page_get_mutex() [buf_block_struct::mutex or
1188
 
        buf_pool->zip_mutex], since they can be stored in the same
 
1043
        buf_pool_zip_mutex], since they can be stored in the same
1189
1044
        machine word.  Some of these fields are additionally protected
1190
 
        by buf_pool->mutex. */
 
1045
        by buf_pool_mutex. */
1191
1046
        /* @{ */
1192
1047
 
1193
1048
        unsigned        space:32;       /*!< tablespace id; also protected
1194
 
                                        by buf_pool->mutex. */
 
1049
                                        by buf_pool_mutex. */
1195
1050
        unsigned        offset:32;      /*!< page number; also protected
1196
 
                                        by buf_pool->mutex. */
 
1051
                                        by buf_pool_mutex. */
1197
1052
 
1198
1053
        unsigned        state:3;        /*!< state of the control block; also
1199
 
                                        protected by buf_pool->mutex.
 
1054
                                        protected by buf_pool_mutex.
1200
1055
                                        State transitions from
1201
1056
                                        BUF_BLOCK_READY_FOR_USE to
1202
1057
                                        BUF_BLOCK_MEMORY need not be
1207
1062
                                        flushed to disk, this tells the
1208
1063
                                        flush_type.
1209
1064
                                        @see enum buf_flush */
 
1065
        unsigned        accessed:1;     /*!< TRUE if the page has been accessed
 
1066
                                        while in the buffer pool: read-ahead
 
1067
                                        may read in pages which have not been
 
1068
                                        accessed yet; a thread is allowed to
 
1069
                                        read this for heuristic purposes
 
1070
                                        without holding any mutex or latch */
1210
1071
        unsigned        io_fix:2;       /*!< type of pending I/O operation;
1211
 
                                        also protected by buf_pool->mutex
 
1072
                                        also protected by buf_pool_mutex
1212
1073
                                        @see enum buf_io_fix */
1213
 
        unsigned        buf_fix_count:19;/*!< count of how manyfold this block
 
1074
        unsigned        buf_fix_count:24;/*!< count of how manyfold this block
1214
1075
                                        is currently bufferfixed */
1215
 
        unsigned        buf_pool_index:6;/*!< index number of the buffer pool
1216
 
                                        that this block belongs to */
1217
 
# if MAX_BUFFER_POOLS > 64
1218
 
#  error "MAX_BUFFER_POOLS > 64; redefine buf_pool_index:6"
1219
 
# endif
1220
1076
        /* @} */
1221
1077
#endif /* !UNIV_HOTBACKUP */
1222
1078
        page_zip_des_t  zip;            /*!< compressed page; zip.data
1223
1079
                                        (but not the data it points to) is
1224
 
                                        also protected by buf_pool->mutex;
1225
 
                                        state == BUF_BLOCK_ZIP_PAGE and
1226
 
                                        zip.data == NULL means an active
1227
 
                                        buf_pool->watch */
 
1080
                                        also protected by buf_pool_mutex */
1228
1081
#ifndef UNIV_HOTBACKUP
1229
1082
        buf_page_t*     hash;           /*!< node used in chaining to
1230
1083
                                        buf_pool->page_hash or
1235
1088
#endif /* UNIV_DEBUG */
1236
1089
 
1237
1090
        /** @name Page flushing fields
1238
 
        All these are protected by buf_pool->mutex. */
 
1091
        All these are protected by buf_pool_mutex. */
1239
1092
        /* @{ */
1240
1093
 
1241
1094
        UT_LIST_NODE_T(buf_page_t) list;
1242
1095
                                        /*!< based on state, this is a
1243
 
                                        list node, protected either by
1244
 
                                        buf_pool->mutex or by
1245
 
                                        buf_pool->flush_list_mutex,
1246
 
                                        in one of the following lists in
1247
 
                                        buf_pool:
 
1096
                                        list node, protected only by
 
1097
                                        buf_pool_mutex, in one of the
 
1098
                                        following lists in buf_pool:
1248
1099
 
1249
1100
                                        - BUF_BLOCK_NOT_USED:   free
1250
1101
                                        - BUF_BLOCK_FILE_PAGE:  flush_list
1251
1102
                                        - BUF_BLOCK_ZIP_DIRTY:  flush_list
1252
1103
                                        - BUF_BLOCK_ZIP_PAGE:   zip_clean
1253
 
                                        - BUF_BLOCK_ZIP_FREE:   zip_free[]
1254
 
 
1255
 
                                        If bpage is part of flush_list
1256
 
                                        then the node pointers are
1257
 
                                        covered by buf_pool->flush_list_mutex.
1258
 
                                        Otherwise these pointers are
1259
 
                                        protected by buf_pool->mutex.
1260
 
 
1261
 
                                        The contents of the list node
1262
 
                                        is undefined if !in_flush_list
1263
 
                                        && state == BUF_BLOCK_FILE_PAGE,
1264
 
                                        or if state is one of
1265
 
                                        BUF_BLOCK_MEMORY,
1266
 
                                        BUF_BLOCK_REMOVE_HASH or
1267
 
                                        BUF_BLOCK_READY_IN_USE. */
1268
 
 
 
1104
                                        - BUF_BLOCK_ZIP_FREE:   zip_free[] */
1269
1105
#ifdef UNIV_DEBUG
1270
1106
        ibool           in_flush_list;  /*!< TRUE if in buf_pool->flush_list;
1271
 
                                        when buf_pool->flush_list_mutex is
1272
 
                                        free, the following should hold:
1273
 
                                        in_flush_list
 
1107
                                        when buf_pool_mutex is free, the
 
1108
                                        following should hold: in_flush_list
1274
1109
                                        == (state == BUF_BLOCK_FILE_PAGE
1275
 
                                            || state == BUF_BLOCK_ZIP_DIRTY)
1276
 
                                        Writes to this field must be
1277
 
                                        covered by both block->mutex
1278
 
                                        and buf_pool->flush_list_mutex. Hence
1279
 
                                        reads can happen while holding
1280
 
                                        any one of the two mutexes */
 
1110
                                            || state == BUF_BLOCK_ZIP_DIRTY) */
1281
1111
        ibool           in_free_list;   /*!< TRUE if in buf_pool->free; when
1282
 
                                        buf_pool->mutex is free, the following
 
1112
                                        buf_pool_mutex is free, the following
1283
1113
                                        should hold: in_free_list
1284
1114
                                        == (state == BUF_BLOCK_NOT_USED) */
1285
1115
#endif /* UNIV_DEBUG */
1287
1117
                                        /*!< log sequence number of
1288
1118
                                        the youngest modification to
1289
1119
                                        this block, zero if not
1290
 
                                        modified. Protected by block
1291
 
                                        mutex */
 
1120
                                        modified */
1292
1121
        ib_uint64_t     oldest_modification;
1293
1122
                                        /*!< log sequence number of
1294
1123
                                        the START of the log entry
1296
1125
                                        modification to this block
1297
1126
                                        which has not yet been flushed
1298
1127
                                        on disk; zero if all
1299
 
                                        modifications are on disk.
1300
 
                                        Writes to this field must be
1301
 
                                        covered by both block->mutex
1302
 
                                        and buf_pool->flush_list_mutex. Hence
1303
 
                                        reads can happen while holding
1304
 
                                        any one of the two mutexes */
 
1128
                                        modifications are on disk */
1305
1129
        /* @} */
1306
1130
        /** @name LRU replacement algorithm fields
1307
 
        These fields are protected by buf_pool->mutex only (not
1308
 
        buf_pool->zip_mutex or buf_block_struct::mutex). */
 
1131
        These fields are protected by buf_pool_mutex only (not
 
1132
        buf_pool_zip_mutex or buf_block_struct::mutex). */
1309
1133
        /* @{ */
1310
1134
 
1311
1135
        UT_LIST_NODE_T(buf_page_t) LRU;
1316
1140
                                        debugging */
1317
1141
#endif /* UNIV_DEBUG */
1318
1142
        unsigned        old:1;          /*!< TRUE if the block is in the old
1319
 
                                        blocks in buf_pool->LRU_old */
1320
 
        unsigned        freed_page_clock:31;/*!< the value of
 
1143
                                        blocks in the LRU list */
 
1144
        unsigned        LRU_position:31;/*!< value which monotonically
 
1145
                                        decreases (or may stay
 
1146
                                        constant if old==TRUE) toward
 
1147
                                        the end of the LRU list, if
 
1148
                                        buf_pool->ulint_clock has not
 
1149
                                        wrapped around: NOTE that this
 
1150
                                        value can only be used in
 
1151
                                        heuristic algorithms, because
 
1152
                                        of the possibility of a
 
1153
                                        wrap-around! */
 
1154
        unsigned        freed_page_clock:32;/*!< the value of
1321
1155
                                        buf_pool->freed_page_clock
1322
1156
                                        when this block was the last
1323
1157
                                        time put to the head of the
1325
1159
                                        to read this for heuristic
1326
1160
                                        purposes without holding any
1327
1161
                                        mutex or latch */
1328
 
        unsigned        access_time:32; /*!< time of first access, or
1329
 
                                        0 if the block was never accessed
1330
 
                                        in the buffer pool */
1331
1162
        /* @} */
1332
1163
# ifdef UNIV_DEBUG_FILE_ACCESSES
1333
1164
        ibool           file_page_was_freed;
1372
1203
        rw_lock_t       lock;           /*!< read-write lock of the buffer
1373
1204
                                        frame */
1374
1205
        unsigned        lock_hash_val:32;/*!< hashed value of the page address
1375
 
                                        in the record lock hash table;
1376
 
                                        protected by buf_block_t::lock
1377
 
                                        (or buf_block_t::mutex, buf_pool->mutex
1378
 
                                        in buf_page_get_gen(),
1379
 
                                        buf_page_init_for_read()
1380
 
                                        and buf_page_create()) */
1381
 
        ibool           check_index_page_at_flush;
 
1206
                                        in the record lock hash table */
 
1207
        unsigned        check_index_page_at_flush:1;
1382
1208
                                        /*!< TRUE if we know that this is
1383
1209
                                        an index page, and want the database
1384
1210
                                        to check its consistency before flush;
1385
1211
                                        note that there may be pages in the
1386
1212
                                        buffer pool which are index pages,
1387
1213
                                        but this flag is not set because
1388
 
                                        we do not keep track of all pages;
1389
 
                                        NOT protected by any mutex */
 
1214
                                        we do not keep track of all pages */
1390
1215
        /* @} */
1391
1216
        /** @name Optimistic search field */
1392
1217
        /* @{ */
1478
1303
#define BUF_POOL_ZIP_FOLD_BPAGE(b) BUF_POOL_ZIP_FOLD((buf_block_t*) (b))
1479
1304
/* @} */
1480
1305
 
1481
 
/** @brief The buffer pool statistics structure. */
1482
 
struct buf_pool_stat_struct{
1483
 
        ulint   n_page_gets;    /*!< number of page gets performed;
1484
 
                                also successful searches through
1485
 
                                the adaptive hash index are
1486
 
                                counted as page gets; this field
1487
 
                                is NOT protected by the buffer
1488
 
                                pool mutex */
1489
 
        ulint   n_pages_read;   /*!< number read operations */
1490
 
        ulint   n_pages_written;/*!< number write operations */
1491
 
        ulint   n_pages_created;/*!< number of pages created
1492
 
                                in the pool with no read */
1493
 
        ulint   n_ra_pages_read;/*!< number of pages read in
1494
 
                                as part of read ahead */
1495
 
        ulint   n_ra_pages_evicted;/*!< number of read ahead
1496
 
                                pages that are evicted without
1497
 
                                being accessed */
1498
 
        ulint   n_pages_made_young; /*!< number of pages made young, in
1499
 
                                calls to buf_LRU_make_block_young() */
1500
 
        ulint   n_pages_not_made_young; /*!< number of pages not made
1501
 
                                young because the first access
1502
 
                                was not long enough ago, in
1503
 
                                buf_page_peek_if_too_old() */
1504
 
};
1505
 
 
1506
 
/** Statistics of buddy blocks of a given size. */
1507
 
struct buf_buddy_stat_struct {
1508
 
        /** Number of blocks allocated from the buddy system. */
1509
 
        ulint           used;
1510
 
        /** Number of blocks relocated by the buddy system. */
1511
 
        ib_uint64_t     relocated;
1512
 
        /** Total duration of block relocations, in microseconds. */
1513
 
        ib_uint64_t     relocated_usec;
1514
 
};
1515
 
 
1516
1306
/** @brief The buffer pool structure.
1517
1307
 
1518
1308
NOTE! The definition appears here only for other modules of this
1522
1312
 
1523
1313
        /** @name General fields */
1524
1314
        /* @{ */
1525
 
        mutex_t         mutex;          /*!< Buffer pool mutex of this
1526
 
                                        instance */
1527
 
        mutex_t         zip_mutex;      /*!< Zip mutex of this buffer
1528
 
                                        pool instance, protects compressed
1529
 
                                        only pages (of type buf_page_t, not
1530
 
                                        buf_block_t */
1531
 
        ulint           instance_no;    /*!< Array index of this buffer
1532
 
                                        pool instance */
1533
 
        ulint           old_pool_size;  /*!< Old pool size in bytes */
1534
 
        ulint           curr_pool_size; /*!< Current pool size in bytes */
1535
 
        ulint           LRU_old_ratio;  /*!< Reserve this much of the buffer
1536
 
                                        pool for "old" blocks */
1537
 
#ifdef UNIV_DEBUG
1538
 
        ulint           buddy_n_frames; /*!< Number of frames allocated from
1539
 
                                        the buffer pool to the buddy system */
1540
 
#endif
1541
 
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
1542
 
        ulint           mutex_exit_forbidden; /*!< Forbid release mutex */
1543
 
#endif
 
1315
 
1544
1316
        ulint           n_chunks;       /*!< number of buffer pool chunks */
1545
1317
        buf_chunk_t*    chunks;         /*!< buffer pool chunks */
1546
1318
        ulint           curr_size;      /*!< current pool size in pages */
1552
1324
                                        whose frames are allocated to the
1553
1325
                                        zip buddy system,
1554
1326
                                        indexed by block->frame */
1555
 
        ulint           n_pend_reads;   /*!< number of pending read
1556
 
                                        operations */
 
1327
        ulint           n_pend_reads;   /*!< number of pending read operations */
1557
1328
        ulint           n_pend_unzip;   /*!< number of pending decompressions */
1558
1329
 
1559
 
        time_t          last_printout_time;
1560
 
                                        /*!< when buf_print_io was last time
 
1330
        time_t          last_printout_time; /*!< when buf_print was last time
1561
1331
                                        called */
1562
 
        buf_buddy_stat_t buddy_stat[BUF_BUDDY_SIZES + 1];
1563
 
                                        /*!< Statistics of buddy system,
1564
 
                                        indexed by block size */
1565
 
        buf_pool_stat_t stat;           /*!< current statistics */
1566
 
        buf_pool_stat_t old_stat;       /*!< old statistics */
1567
 
 
 
1332
        ulint           n_pages_read;   /*!< number read operations */
 
1333
        ulint           n_pages_written;/*!< number write operations */
 
1334
        ulint           n_pages_created;/*!< number of pages created
 
1335
                                        in the pool with no read */
 
1336
        ulint           n_page_gets;    /*!< number of page gets performed;
 
1337
                                        also successful searches through
 
1338
                                        the adaptive hash index are
 
1339
                                        counted as page gets; this field
 
1340
                                        is NOT protected by the buffer
 
1341
                                        pool mutex */
 
1342
        ulint           n_page_gets_old;/*!< n_page_gets when buf_print was
 
1343
                                        last time called: used to calculate
 
1344
                                        hit rate */
 
1345
        ulint           n_pages_read_old;/*!< n_pages_read when buf_print was
 
1346
                                        last time called */
 
1347
        ulint           n_pages_written_old;/*!< number write operations */
 
1348
        ulint           n_pages_created_old;/*!< number of pages created in
 
1349
                                        the pool with no read */
1568
1350
        /* @} */
1569
 
 
1570
1351
        /** @name Page flushing algorithm fields */
1571
 
 
1572
1352
        /* @{ */
1573
1353
 
1574
 
        mutex_t         flush_list_mutex;/*!< mutex protecting the
1575
 
                                        flush list access. This mutex
1576
 
                                        protects flush_list, flush_rbt
1577
 
                                        and bpage::list pointers when
1578
 
                                        the bpage is on flush_list. It
1579
 
                                        also protects writes to
1580
 
                                        bpage::oldest_modification */
1581
1354
        UT_LIST_BASE_NODE_T(buf_page_t) flush_list;
1582
1355
                                        /*!< base node of the modified block
1583
1356
                                        list */
1591
1364
                                        /*!< this is in the set state
1592
1365
                                        when there is no flush batch
1593
1366
                                        of the given type running */
1594
 
        ib_rbt_t*       flush_rbt;      /*!< a red-black tree is used
1595
 
                                        exclusively during recovery to
1596
 
                                        speed up insertions in the
1597
 
                                        flush_list. This tree contains
1598
 
                                        blocks in order of
1599
 
                                        oldest_modification LSN and is
1600
 
                                        kept in sync with the
1601
 
                                        flush_list.
1602
 
                                        Each member of the tree MUST
1603
 
                                        also be on the flush_list.
1604
 
                                        This tree is relevant only in
1605
 
                                        recovery and is set to NULL
1606
 
                                        once the recovery is over.
1607
 
                                        Protected by flush_list_mutex */
 
1367
        ulint           ulint_clock;    /*!< a sequence number used to count
 
1368
                                        time. NOTE! This counter wraps
 
1369
                                        around at 4 billion (if ulint ==
 
1370
                                        32 bits)! */
1608
1371
        ulint           freed_page_clock;/*!< a sequence number used
1609
1372
                                        to count the number of buffer
1610
1373
                                        blocks removed from the end of
1618
1381
                                        this is incremented by one; this is
1619
1382
                                        set to zero when a buffer block is
1620
1383
                                        allocated */
 
1384
 
1621
1385
        /* @} */
1622
 
 
1623
1386
        /** @name LRU replacement algorithm fields */
1624
1387
        /* @{ */
1625
1388
 
1628
1391
                                        block list */
1629
1392
        UT_LIST_BASE_NODE_T(buf_page_t) LRU;
1630
1393
                                        /*!< base node of the LRU list */
1631
 
        buf_page_t*     LRU_old;        /*!< pointer to the about
1632
 
                                        buf_LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV
1633
 
                                        oldest blocks in the LRU list;
1634
 
                                        NULL if LRU length less than
1635
 
                                        BUF_LRU_OLD_MIN_LEN;
 
1394
        buf_page_t*     LRU_old;        /*!< pointer to the about 3/8 oldest
 
1395
                                        blocks in the LRU list; NULL if LRU
 
1396
                                        length less than BUF_LRU_OLD_MIN_LEN;
1636
1397
                                        NOTE: when LRU_old != NULL, its length
1637
1398
                                        should always equal LRU_old_len */
1638
1399
        ulint           LRU_old_len;    /*!< length of the LRU list from
1639
1400
                                        the block to which LRU_old points
1640
1401
                                        onward, including that block;
1641
1402
                                        see buf0lru.c for the restrictions
1642
 
                                        on this value; 0 if LRU_old == NULL;
 
1403
                                        on this value; not defined if
 
1404
                                        LRU_old == NULL;
1643
1405
                                        NOTE: LRU_old_len must be adjusted
1644
1406
                                        whenever LRU_old shrinks or grows! */
1645
1407
 
1657
1419
                                        /*!< unmodified compressed pages */
1658
1420
        UT_LIST_BASE_NODE_T(buf_page_t) zip_free[BUF_BUDDY_SIZES];
1659
1421
                                        /*!< buddy free lists */
1660
 
 
1661
 
        buf_page_t                      watch[BUF_POOL_WATCH_SIZE];
1662
 
                                        /*!< Sentinel records for buffer
1663
 
                                        pool watches. Protected by
1664
 
                                        buf_pool->mutex. */
1665
 
 
1666
1422
#if BUF_BUDDY_HIGH != UNIV_PAGE_SIZE
1667
1423
# error "BUF_BUDDY_HIGH != UNIV_PAGE_SIZE"
1668
1424
#endif
1672
1428
        /* @} */
1673
1429
};
1674
1430
 
1675
 
/** @name Accessors for buf_pool->mutex.
1676
 
Use these instead of accessing buf_pool->mutex directly. */
 
1431
/** mutex protecting the buffer pool struct and control blocks, except the
 
1432
read-write lock in them */
 
1433
extern mutex_t  buf_pool_mutex;
 
1434
/** mutex protecting the control blocks of compressed-only pages
 
1435
(of type buf_page_t, not buf_block_t) */
 
1436
extern mutex_t  buf_pool_zip_mutex;
 
1437
 
 
1438
/** @name Accessors for buf_pool_mutex.
 
1439
Use these instead of accessing buf_pool_mutex directly. */
1677
1440
/* @{ */
1678
1441
 
1679
 
/** Test if a buffer pool mutex is owned. */
1680
 
#define buf_pool_mutex_own(b) mutex_own(&b->mutex)
1681
 
/** Acquire a buffer pool mutex. */
1682
 
#define buf_pool_mutex_enter(b) do {            \
1683
 
        ut_ad(!mutex_own(&b->zip_mutex));       \
1684
 
        mutex_enter(&b->mutex);         \
1685
 
} while (0)
1686
 
 
1687
 
/** Test if flush list mutex is owned. */
1688
 
#define buf_flush_list_mutex_own(b) mutex_own(&b->flush_list_mutex)
1689
 
 
1690
 
/** Acquire the flush list mutex. */
1691
 
#define buf_flush_list_mutex_enter(b) do {      \
1692
 
        mutex_enter(&b->flush_list_mutex);      \
1693
 
} while (0)
1694
 
/** Release the flush list mutex. */
1695
 
# define buf_flush_list_mutex_exit(b) do {      \
1696
 
        mutex_exit(&b->flush_list_mutex);       \
1697
 
} while (0)
1698
 
 
1699
 
 
 
1442
/** Test if buf_pool_mutex is owned. */
 
1443
#define buf_pool_mutex_own() mutex_own(&buf_pool_mutex)
 
1444
/** Acquire the buffer pool mutex. */
 
1445
#define buf_pool_mutex_enter() do {             \
 
1446
        ut_ad(!mutex_own(&buf_pool_zip_mutex)); \
 
1447
        mutex_enter(&buf_pool_mutex);           \
 
1448
} while (0)
1700
1449
 
1701
1450
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
 
1451
/** Flag to forbid the release of the buffer pool mutex.
 
1452
Protected by buf_pool_mutex. */
 
1453
extern ulint    buf_pool_mutex_exit_forbidden;
1702
1454
/** Forbid the release of the buffer pool mutex. */
1703
 
# define buf_pool_mutex_exit_forbid(b) do {     \
1704
 
        ut_ad(buf_pool_mutex_own(b));           \
1705
 
        b->mutex_exit_forbidden++;              \
 
1455
# define buf_pool_mutex_exit_forbid() do {      \
 
1456
        ut_ad(buf_pool_mutex_own());            \
 
1457
        buf_pool_mutex_exit_forbidden++;        \
1706
1458
} while (0)
1707
1459
/** Allow the release of the buffer pool mutex. */
1708
 
# define buf_pool_mutex_exit_allow(b) do {      \
1709
 
        ut_ad(buf_pool_mutex_own(b));           \
1710
 
        ut_a(b->mutex_exit_forbidden);  \
1711
 
        b->mutex_exit_forbidden--;              \
 
1460
# define buf_pool_mutex_exit_allow() do {       \
 
1461
        ut_ad(buf_pool_mutex_own());            \
 
1462
        ut_a(buf_pool_mutex_exit_forbidden);    \
 
1463
        buf_pool_mutex_exit_forbidden--;        \
1712
1464
} while (0)
1713
1465
/** Release the buffer pool mutex. */
1714
 
# define buf_pool_mutex_exit(b) do {            \
1715
 
        ut_a(!b->mutex_exit_forbidden);         \
1716
 
        mutex_exit(&b->mutex);                  \
 
1466
# define buf_pool_mutex_exit() do {             \
 
1467
        ut_a(!buf_pool_mutex_exit_forbidden);   \
 
1468
        mutex_exit(&buf_pool_mutex);            \
1717
1469
} while (0)
1718
1470
#else
1719
1471
/** Forbid the release of the buffer pool mutex. */
1720
 
# define buf_pool_mutex_exit_forbid(b) ((void) 0)
 
1472
# define buf_pool_mutex_exit_forbid() ((void) 0)
1721
1473
/** Allow the release of the buffer pool mutex. */
1722
 
# define buf_pool_mutex_exit_allow(b) ((void) 0)
 
1474
# define buf_pool_mutex_exit_allow() ((void) 0)
1723
1475
/** Release the buffer pool mutex. */
1724
 
# define buf_pool_mutex_exit(b) mutex_exit(&b->mutex)
 
1476
# define buf_pool_mutex_exit() mutex_exit(&buf_pool_mutex)
1725
1477
#endif
1726
1478
#endif /* !UNIV_HOTBACKUP */
1727
1479
/* @} */