84
84
The buffer buf_pool contains a single mutex which protects all the
85
85
control data structures of the buf_pool. The content of a buffer frame is
86
86
protected by a separate read-write lock in its control block, though.
87
These locks can be locked and unlocked without owning the buf_pool->mutex.
87
These locks can be locked and unlocked without owning the buf_pool mutex.
88
88
The OS events in the buf_pool struct can be waited for without owning the
91
The buf_pool->mutex is a hot-spot in main memory, causing a lot of
91
The buf_pool mutex is a hot-spot in main memory, causing a lot of
92
92
memory bus traffic on multiprocessor systems when processors
93
93
alternately access the mutex. On our Pentium, the mutex is accessed
94
94
maybe every 10 microseconds. We gave up the solution to have mutexes
95
95
for each control block, for instance, because it seemed to be
98
A solution to reduce mutex contention of the buf_pool->mutex is to
98
A solution to reduce mutex contention of the buf_pool mutex is to
99
99
create a separate mutex for the page hash table. On Pentium,
100
100
accessing the hash table takes 2 microseconds, about half
101
of the total buf_pool->mutex hold time.
101
of the total buf_pool mutex hold time.
153
153
which we can use when we want to artificially age a page in the
154
154
buf_pool. This is used if we know that some page is not needed
155
155
again for some time: we insert the block right after the pointer,
156
causing it to be replaced sooner than would normally be the case.
156
causing it to be replaced sooner than would noramlly be the case.
157
157
Currently this aging mechanism is used for read-ahead mechanism
158
158
of pages, and it can also be used when there is a scan of a full
159
159
table which cannot fit in the memory. Putting the pages near the
160
end of the LRU list, we make sure that most of the buf_pool stays
161
in the main memory, undisturbed.
160
of the LRU list, we make sure that most of the buf_pool stays in the
161
main memory, undisturbed.
163
163
The unzip_LRU list contains a subset of the common LRU list. The
164
164
blocks on the unzip_LRU list hold a compressed file page and the
243
242
#ifndef UNIV_HOTBACKUP
244
243
/** Value in microseconds */
245
244
static const int WAIT_FOR_READ = 5000;
246
/** Number of attemtps made to read in a page in the buffer pool */
247
static const ulint BUF_PAGE_READ_MAX_RETRIES = 100;
249
/** The buffer pools of the database */
250
UNIV_INTERN buf_pool_t* buf_pool_ptr;
246
/** The buffer buf_pool of the database */
247
UNIV_INTERN buf_pool_t* buf_pool = NULL;
249
/** mutex protecting the buffer pool struct and control blocks, except the
250
read-write lock in them */
251
UNIV_INTERN mutex_t buf_pool_mutex;
252
/** mutex protecting the control blocks of compressed-only pages
253
(of type buf_page_t, not buf_block_t) */
254
UNIV_INTERN mutex_t buf_pool_zip_mutex;
252
256
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
253
257
static ulint buf_dbg_counter = 0; /*!< This is used to insert validation
254
operations in execution in the
258
operations in excution in the
260
/** Flag to forbid the release of the buffer pool mutex.
261
Protected by buf_pool_mutex. */
262
UNIV_INTERN ulint buf_pool_mutex_exit_forbidden = 0;
256
263
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
257
264
#ifdef UNIV_DEBUG
258
265
/** If this is set TRUE, the program prints info whenever
260
267
UNIV_INTERN ibool buf_debug_prints = FALSE;
261
268
#endif /* UNIV_DEBUG */
263
#ifdef UNIV_PFS_RWLOCK
264
/* Keys to register buffer block related rwlocks and mutexes with
265
performance schema */
266
UNIV_INTERN mysql_pfs_key_t buf_block_lock_key;
267
# ifdef UNIV_SYNC_DEBUG
268
UNIV_INTERN mysql_pfs_key_t buf_block_debug_latch_key;
269
# endif /* UNIV_SYNC_DEBUG */
270
#endif /* UNIV_PFS_RWLOCK */
272
#ifdef UNIV_PFS_MUTEX
273
UNIV_INTERN mysql_pfs_key_t buffer_block_mutex_key;
274
UNIV_INTERN mysql_pfs_key_t buf_pool_mutex_key;
275
UNIV_INTERN mysql_pfs_key_t buf_pool_zip_mutex_key;
276
UNIV_INTERN mysql_pfs_key_t flush_list_mutex_key;
277
#endif /* UNIV_PFS_MUTEX */
279
#if defined UNIV_PFS_MUTEX || defined UNIV_PFS_RWLOCK
280
# ifndef PFS_SKIP_BUFFER_MUTEX_RWLOCK
282
/* Buffer block mutexes and rwlocks can be registered
283
in one group rather than individually. If PFS_GROUP_BUFFER_SYNC
284
is defined, register buffer block mutex and rwlock
285
in one group after their initialization. */
286
# define PFS_GROUP_BUFFER_SYNC
288
/* This define caps the number of mutexes/rwlocks can
289
be registered with performance schema. Developers can
290
modify this define if necessary. Please note, this would
291
be effective only if PFS_GROUP_BUFFER_SYNC is defined. */
292
# define PFS_MAX_BUFFER_MUTEX_LOCK_REGISTER ULINT_MAX
294
# endif /* !PFS_SKIP_BUFFER_MUTEX_RWLOCK */
295
#endif /* UNIV_PFS_MUTEX || UNIV_PFS_RWLOCK */
297
270
/** A chunk of buffers. The buffer pool is allocated in chunks. */
298
271
struct buf_chunk_struct{
299
272
ulint mem_size; /*!< allocated size of the chunk */
305
278
#endif /* !UNIV_HOTBACKUP */
307
280
/********************************************************************//**
308
Gets the smallest oldest_modification lsn for any page in the pool. Returns
309
zero if all modified pages have been flushed to disk.
310
@return oldest modification in pool, zero if none */
313
buf_pool_get_oldest_modification(void)
314
/*==================================*/
319
ib_uint64_t oldest_lsn = 0;
321
/* When we traverse all the flush lists we don't want another
322
thread to add a dirty page to any flush list. */
323
log_flush_order_mutex_enter();
325
for (i = 0; i < srv_buf_pool_instances; i++) {
326
buf_pool_t* buf_pool;
328
buf_pool = buf_pool_from_array(i);
330
buf_flush_list_mutex_enter(buf_pool);
332
bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
335
ut_ad(bpage->in_flush_list);
336
lsn = bpage->oldest_modification;
339
buf_flush_list_mutex_exit(buf_pool);
341
if (!oldest_lsn || oldest_lsn > lsn) {
346
log_flush_order_mutex_exit();
348
/* The returned answer may be out of date: the flush_list can
349
change after the mutex has been released. */
354
/********************************************************************//**
355
Get total buffer pool statistics. */
358
buf_get_total_list_len(
359
/*===================*/
360
ulint* LRU_len, /*!< out: length of all LRU lists */
361
ulint* free_len, /*!< out: length of all free lists */
362
ulint* flush_list_len) /*!< out: length of all flush lists */
370
for (i = 0; i < srv_buf_pool_instances; i++) {
371
buf_pool_t* buf_pool;
373
buf_pool = buf_pool_from_array(i);
374
*LRU_len += UT_LIST_GET_LEN(buf_pool->LRU);
375
*free_len += UT_LIST_GET_LEN(buf_pool->free);
376
*flush_list_len += UT_LIST_GET_LEN(buf_pool->flush_list);
380
/********************************************************************//**
381
Get total buffer pool statistics. */
386
buf_pool_stat_t* tot_stat) /*!< out: buffer pool stats */
390
memset(tot_stat, 0, sizeof(*tot_stat));
392
for (i = 0; i < srv_buf_pool_instances; i++) {
393
buf_pool_stat_t*buf_stat;
394
buf_pool_t* buf_pool;
396
buf_pool = buf_pool_from_array(i);
398
buf_stat = &buf_pool->stat;
399
tot_stat->n_page_gets += buf_stat->n_page_gets;
400
tot_stat->n_pages_read += buf_stat->n_pages_read;
401
tot_stat->n_pages_written += buf_stat->n_pages_written;
402
tot_stat->n_pages_created += buf_stat->n_pages_created;
403
tot_stat->n_ra_pages_read += buf_stat->n_ra_pages_read;
404
tot_stat->n_ra_pages_evicted += buf_stat->n_ra_pages_evicted;
405
tot_stat->n_pages_made_young += buf_stat->n_pages_made_young;
407
tot_stat->n_pages_not_made_young +=
408
buf_stat->n_pages_not_made_young;
412
/********************************************************************//**
413
Allocates a buffer block.
414
@return own: the allocated block, in state BUF_BLOCK_MEMORY */
419
buf_pool_t* buf_pool, /*!< in: buffer pool instance */
420
ulint zip_size) /*!< in: compressed page size in bytes,
421
or 0 if uncompressed tablespace */
425
static ulint buf_pool_index;
427
if (buf_pool == NULL) {
428
/* We are allocating memory from any buffer pool, ensure
429
we spread the grace on all buffer pool instances. */
430
index = buf_pool_index++ % srv_buf_pool_instances;
431
buf_pool = buf_pool_from_array(index);
434
block = buf_LRU_get_free_block(buf_pool, zip_size);
436
buf_block_set_state(block, BUF_BLOCK_MEMORY);
441
/********************************************************************//**
442
281
Calculates a page checksum which is stored to the page when it is written
443
282
to a file. Note that we must be careful to calculate the same value on
444
283
32-bit and 64-bit architectures.
799
638
#ifndef UNIV_HOTBACKUP
801
# ifdef PFS_GROUP_BUFFER_SYNC
802
/********************************************************************//**
803
This function registers mutexes and rwlocks in buffer blocks with
804
performance schema. If PFS_MAX_BUFFER_MUTEX_LOCK_REGISTER is
805
defined to be a value less than chunk->size, then only mutexes
806
and rwlocks in the first PFS_MAX_BUFFER_MUTEX_LOCK_REGISTER
807
blocks are registered. */
810
pfs_register_buffer_block(
811
/*======================*/
812
buf_chunk_t* chunk) /*!< in/out: chunk of buffers */
815
ulint num_to_register;
818
block = chunk->blocks;
820
num_to_register = ut_min(chunk->size,
821
PFS_MAX_BUFFER_MUTEX_LOCK_REGISTER);
823
for (i = 0; i < num_to_register; i++) {
827
# ifdef UNIV_PFS_MUTEX
828
mutex = &block->mutex;
829
ut_a(!mutex->pfs_psi);
830
mutex->pfs_psi = (PSI_server)
831
? PSI_server->init_mutex(buffer_block_mutex_key, mutex)
833
# endif /* UNIV_PFS_MUTEX */
835
# ifdef UNIV_PFS_RWLOCK
836
rwlock = &block->lock;
837
ut_a(!rwlock->pfs_psi);
838
rwlock->pfs_psi = (PSI_server)
839
? PSI_server->init_rwlock(buf_block_lock_key, rwlock)
841
# endif /* UNIV_PFS_RWLOCK */
845
# endif /* PFS_GROUP_BUFFER_SYNC */
847
639
/********************************************************************//**
848
640
Initializes a buffer control block when the buf_pool is created. */
853
buf_pool_t* buf_pool, /*!< in: buffer pool instance */
854
buf_block_t* block, /*!< in: pointer to control block */
855
byte* frame) /*!< in: pointer to buffer frame */
645
buf_block_t* block, /*!< in: pointer to control block */
646
byte* frame) /*!< in: pointer to buffer frame */
857
648
UNIV_MEM_DESC(frame, UNIV_PAGE_SIZE, block);
859
650
block->frame = frame;
861
block->page.buf_pool_index = buf_pool_index(buf_pool);
862
652
block->page.state = BUF_BLOCK_NOT_USED;
863
653
block->page.buf_fix_count = 0;
864
654
block->page.io_fix = BUF_IO_NONE;
887
675
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
888
676
page_zip_des_init(&block->page.zip);
890
#if defined PFS_SKIP_BUFFER_MUTEX_RWLOCK || defined PFS_GROUP_BUFFER_SYNC
891
/* If PFS_SKIP_BUFFER_MUTEX_RWLOCK is defined, skip registration
892
of buffer block mutex/rwlock with performance schema. If
893
PFS_GROUP_BUFFER_SYNC is defined, skip the registration
894
since buffer block mutex/rwlock will be registered later in
895
pfs_register_buffer_block() */
897
mutex_create(PFS_NOT_INSTRUMENTED, &block->mutex, SYNC_BUF_BLOCK);
898
rw_lock_create(PFS_NOT_INSTRUMENTED, &block->lock, SYNC_LEVEL_VARYING);
899
#else /* PFS_SKIP_BUFFER_MUTEX_RWLOCK || PFS_GROUP_BUFFER_SYNC */
900
mutex_create(buffer_block_mutex_key, &block->mutex, SYNC_BUF_BLOCK);
901
rw_lock_create(buf_block_lock_key, &block->lock, SYNC_LEVEL_VARYING);
902
#endif /* PFS_SKIP_BUFFER_MUTEX_RWLOCK || PFS_GROUP_BUFFER_SYNC */
678
mutex_create(&block->mutex, SYNC_BUF_BLOCK);
680
rw_lock_create(&block->lock, SYNC_LEVEL_VARYING);
904
681
ut_ad(rw_lock_validate(&(block->lock)));
906
683
#ifdef UNIV_SYNC_DEBUG
907
rw_lock_create(buf_block_debug_latch_key,
908
&block->debug_latch, SYNC_NO_ORDER_CHECK);
684
rw_lock_create(&block->debug_latch, SYNC_NO_ORDER_CHECK);
909
685
#endif /* UNIV_SYNC_DEBUG */
1166
940
/********************************************************************//**
1167
Set buffer pool size variables after resizing it */
1170
buf_pool_set_sizes(void)
1171
/*====================*/
1174
ulint curr_size = 0;
1176
buf_pool_mutex_enter_all();
1178
for (i = 0; i < srv_buf_pool_instances; i++) {
1179
buf_pool_t* buf_pool;
1181
buf_pool = buf_pool_from_array(i);
1182
curr_size += buf_pool->curr_pool_size;
1185
srv_buf_pool_curr_size = curr_size;
1186
srv_buf_pool_old_size = srv_buf_pool_size;
1188
buf_pool_mutex_exit_all();
1191
/********************************************************************//**
1192
Initialize a buffer pool instance.
1193
@return DB_SUCCESS if all goes well. */
1196
buf_pool_init_instance(
1197
/*===================*/
1198
buf_pool_t* buf_pool, /*!< in: buffer pool instance */
1199
ulint buf_pool_size, /*!< in: size in bytes */
1200
ulint instance_no) /*!< in: id of the instance */
941
Creates the buffer pool.
942
@return own: buf_pool object, NULL if not enough memory or error */
951
buf_pool = mem_zalloc(sizeof(buf_pool_t));
1205
953
/* 1. Initialize general fields
1206
954
------------------------------- */
1207
mutex_create(buf_pool_mutex_key,
1208
&buf_pool->mutex, SYNC_BUF_POOL);
1209
mutex_create(buf_pool_zip_mutex_key,
1210
&buf_pool->zip_mutex, SYNC_BUF_BLOCK);
1212
buf_pool_mutex_enter(buf_pool);
1214
if (buf_pool_size > 0) {
1215
buf_pool->n_chunks = 1;
1216
void *chunk_ptr= mem_zalloc((sizeof *chunk));
1217
buf_pool->chunks = chunk = static_cast<buf_chunk_t *>(chunk_ptr);
1219
UT_LIST_INIT(buf_pool->free);
1221
if (!buf_chunk_init(buf_pool, chunk, buf_pool_size)) {
1225
buf_pool_mutex_exit(buf_pool);
1230
buf_pool->instance_no = instance_no;
1231
buf_pool->old_pool_size = buf_pool_size;
1232
buf_pool->curr_size = chunk->size;
1233
buf_pool->curr_pool_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
1235
buf_pool->page_hash = hash_create(2 * buf_pool->curr_size);
1236
buf_pool->zip_hash = hash_create(2 * buf_pool->curr_size);
1238
buf_pool->last_printout_time = ut_time();
955
mutex_create(&buf_pool_mutex, SYNC_BUF_POOL);
956
mutex_create(&buf_pool_zip_mutex, SYNC_BUF_BLOCK);
958
buf_pool_mutex_enter();
960
buf_pool->n_chunks = 1;
961
buf_pool->chunks = chunk = mem_alloc(sizeof *chunk);
963
UT_LIST_INIT(buf_pool->free);
965
if (!buf_chunk_init(chunk, srv_buf_pool_size)) {
972
srv_buf_pool_old_size = srv_buf_pool_size;
973
buf_pool->curr_size = chunk->size;
974
srv_buf_pool_curr_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
976
buf_pool->page_hash = hash_create(2 * buf_pool->curr_size);
977
buf_pool->zip_hash = hash_create(2 * buf_pool->curr_size);
979
buf_pool->last_printout_time = time(NULL);
1240
981
/* 2. Initialize flushing fields
1241
982
-------------------------------- */
1243
mutex_create(flush_list_mutex_key, &buf_pool->flush_list_mutex,
1244
SYNC_BUF_FLUSH_LIST);
1246
984
for (i = BUF_FLUSH_LRU; i < BUF_FLUSH_N_TYPES; i++) {
1247
985
buf_pool->no_flush[i] = os_event_create(NULL);
1250
988
/* 3. Initialize LRU fields
1251
989
--------------------------- */
1253
/* All fields are initialized by mem_zalloc(). */
1255
buf_pool_mutex_exit(buf_pool);
990
/* All fields are initialized by mem_zalloc(). */
992
buf_pool_mutex_exit();
994
btr_search_sys_create(buf_pool->curr_size
995
* UNIV_PAGE_SIZE / sizeof(void*) / 64);
997
/* 4. Initialize the buddy allocator fields */
998
/* All fields are initialized by mem_zalloc(). */
1260
1003
/********************************************************************//**
1261
free one buffer pool instance */
1004
Frees the buffer pool at shutdown. This must not be invoked before
1005
freeing all mutexes. */
1264
buf_pool_free_instance(
1265
/*===================*/
1266
buf_pool_t* buf_pool) /* in,own: buffer pool instance
1269
1011
buf_chunk_t* chunk;
1270
1012
buf_chunk_t* chunks;
1281
1023
mem_free(buf_pool->chunks);
1282
1024
hash_table_free(buf_pool->page_hash);
1283
1025
hash_table_free(buf_pool->zip_hash);
1286
/********************************************************************//**
1287
Creates the buffer pool.
1288
@return DB_SUCCESS if success, DB_ERROR if not enough memory or error */
1293
ulint total_size, /*!< in: size of the total pool in bytes */
1294
ulint n_instances) /*!< in: number of instances */
1297
const ulint size = total_size / n_instances;
1299
ut_ad(n_instances > 0);
1300
ut_ad(n_instances <= MAX_BUFFER_POOLS);
1301
ut_ad(n_instances == srv_buf_pool_instances);
1303
/* We create an extra buffer pool instance, this instance is used
1304
for flushing the flush lists, to keep track of n_flush for all
1305
the buffer pools and also used as a waiting object during flushing. */
1306
void *buf_pool_void_ptr= mem_zalloc(n_instances * sizeof *buf_pool_ptr);
1307
buf_pool_ptr = static_cast<buf_pool_struct *>(buf_pool_void_ptr);
1309
for (i = 0; i < n_instances; i++) {
1310
buf_pool_t* ptr = &buf_pool_ptr[i];
1312
if (buf_pool_init_instance(ptr, size, i) != DB_SUCCESS) {
1314
/* Free all the instances created so far. */
1321
buf_pool_set_sizes();
1322
buf_LRU_old_ratio_update(100 * 3/ 8, FALSE);
1324
btr_search_sys_create(buf_pool_get_curr_size() / sizeof(void*) / 64);
1329
/********************************************************************//**
1330
Frees the buffer pool at shutdown. This must not be invoked before
1331
freeing all mutexes. */
1336
ulint n_instances) /*!< in: numbere of instances to free */
1340
for (i = 0; i < n_instances; i++) {
1341
buf_pool_free_instance(buf_pool_from_array(i));
1344
mem_free(buf_pool_ptr);
1345
buf_pool_ptr = NULL;
1348
/********************************************************************//**
1349
Drops adaptive hash index for a buffer pool instance. */
1352
buf_pool_drop_hash_index_instance(
1353
/*==============================*/
1354
buf_pool_t* buf_pool, /*!< in: buffer pool instance */
1355
ibool* released_search_latch) /*!< out: flag for signalling
1356
whether the search latch was
1359
buf_chunk_t* chunks = buf_pool->chunks;
1360
buf_chunk_t* chunk = chunks + buf_pool->n_chunks;
1362
while (--chunk >= chunks) {
1364
buf_block_t* block = chunk->blocks;
1366
for (i = chunk->size; i--; block++) {
1367
/* block->is_hashed cannot be modified
1368
when we have an x-latch on btr_search_latch;
1369
see the comment in buf0buf.h */
1371
if (!block->is_hashed) {
1375
/* To follow the latching order, we
1376
have to release btr_search_latch
1377
before acquiring block->latch. */
1378
rw_lock_x_unlock(&btr_search_latch);
1379
/* When we release the search latch,
1380
we must rescan all blocks, because
1381
some may become hashed again. */
1382
*released_search_latch = TRUE;
1384
rw_lock_x_lock(&block->lock);
1386
/* This should be guaranteed by the
1387
callers, which will be holding
1388
btr_search_enabled_mutex. */
1389
ut_ad(!btr_search_enabled);
1391
/* Because we did not buffer-fix the
1392
block by calling buf_block_get_gen(),
1393
it is possible that the block has been
1394
allocated for some other use after
1395
btr_search_latch was released above.
1396
We do not care which file page the
1397
block is mapped to. All we want to do
1398
is to drop any hash entries referring
1401
/* It is possible that
1402
block->page.state != BUF_FILE_PAGE.
1403
Even that does not matter, because
1404
btr_search_drop_page_hash_index() will
1405
check block->is_hashed before doing
1406
anything. block->is_hashed can only
1407
be set on uncompressed file pages. */
1409
btr_search_drop_page_hash_index(block);
1411
rw_lock_x_unlock(&block->lock);
1413
rw_lock_x_lock(&btr_search_latch);
1415
ut_ad(!btr_search_enabled);
1420
1030
/********************************************************************//**
1421
1031
Drops the adaptive hash index. To prevent a livelock, this function
1422
1032
is only to be called while holding btr_search_latch and while
1434
1044
ut_ad(!btr_search_enabled);
1047
buf_chunk_t* chunks = buf_pool->chunks;
1048
buf_chunk_t* chunk = chunks + buf_pool->n_chunks;
1439
1050
released_search_latch = FALSE;
1441
for (i = 0; i < srv_buf_pool_instances; i++) {
1442
buf_pool_t* buf_pool;
1444
buf_pool = buf_pool_from_array(i);
1446
buf_pool_drop_hash_index_instance(
1447
buf_pool, &released_search_latch);
1052
while (--chunk >= chunks) {
1053
buf_block_t* block = chunk->blocks;
1054
ulint i = chunk->size;
1056
for (; i--; block++) {
1057
/* block->is_hashed cannot be modified
1058
when we have an x-latch on btr_search_latch;
1059
see the comment in buf0buf.h */
1061
if (!block->is_hashed) {
1065
/* To follow the latching order, we
1066
have to release btr_search_latch
1067
before acquiring block->latch. */
1068
rw_lock_x_unlock(&btr_search_latch);
1069
/* When we release the search latch,
1070
we must rescan all blocks, because
1071
some may become hashed again. */
1072
released_search_latch = TRUE;
1074
rw_lock_x_lock(&block->lock);
1076
/* This should be guaranteed by the
1077
callers, which will be holding
1078
btr_search_enabled_mutex. */
1079
ut_ad(!btr_search_enabled);
1081
/* Because we did not buffer-fix the
1082
block by calling buf_block_get_gen(),
1083
it is possible that the block has been
1084
allocated for some other use after
1085
btr_search_latch was released above.
1086
We do not care which file page the
1087
block is mapped to. All we want to do
1088
is to drop any hash entries referring
1091
/* It is possible that
1092
block->page.state != BUF_FILE_PAGE.
1093
Even that does not matter, because
1094
btr_search_drop_page_hash_index() will
1095
check block->is_hashed before doing
1096
anything. block->is_hashed can only
1097
be set on uncompressed file pages. */
1099
btr_search_drop_page_hash_index(block);
1101
rw_lock_x_unlock(&block->lock);
1103
rw_lock_x_lock(&btr_search_latch);
1105
ut_ad(!btr_search_enabled);
1450
1108
} while (released_search_latch);
1679
1335
goto shrink_again;
1684
buf_pool->old_pool_size = buf_pool->curr_pool_size;
1339
srv_buf_pool_old_size = srv_buf_pool_size;
1686
buf_pool_mutex_exit(buf_pool);
1341
buf_pool_mutex_exit();
1687
1342
btr_search_enable();
1690
1345
/********************************************************************//**
1691
Shrinks the buffer pool. */
1696
ulint chunk_size) /*!< in: number of pages to remove */
1700
for (i = 0; i < srv_buf_pool_instances; i++) {
1701
buf_pool_t* buf_pool;
1702
ulint instance_chunk_size;
1704
instance_chunk_size = chunk_size / srv_buf_pool_instances;
1705
buf_pool = buf_pool_from_array(i);
1706
buf_pool_shrink_instance(buf_pool, instance_chunk_size);
1709
buf_pool_set_sizes();
1712
/********************************************************************//**
1713
Rebuild buf_pool->page_hash for a buffer pool instance. */
1716
buf_pool_page_hash_rebuild_instance(
1717
/*================================*/
1718
buf_pool_t* buf_pool) /*!< in: buffer pool instance */
1346
Rebuild buf_pool->page_hash. */
1349
buf_pool_page_hash_rebuild(void)
1350
/*============================*/
1723
1353
ulint n_chunks;
1355
hash_table_t* page_hash;
1724
1356
hash_table_t* zip_hash;
1725
hash_table_t* page_hash;
1727
buf_pool_mutex_enter(buf_pool);
1359
buf_pool_mutex_enter();
1729
1361
/* Free, create, and populate the hash table. */
1730
1362
hash_table_free(buf_pool->page_hash);
1808
buf_flush_list_mutex_exit(buf_pool);
1809
buf_pool_mutex_exit(buf_pool);
1812
/********************************************************************
1813
Determine if a block is a sentinel for a buffer pool watch.
1814
@return TRUE if a sentinel for a buffer pool watch, FALSE if not */
1817
buf_pool_watch_is_sentinel(
1818
/*=======================*/
1819
buf_pool_t* buf_pool, /*!< buffer pool instance */
1820
const buf_page_t* bpage) /*!< in: block */
1822
ut_ad(buf_page_in_file(bpage));
1824
if (bpage < &buf_pool->watch[0]
1825
|| bpage >= &buf_pool->watch[BUF_POOL_WATCH_SIZE]) {
1827
ut_ad(buf_page_get_state(bpage) != BUF_BLOCK_ZIP_PAGE
1828
|| bpage->zip.data != NULL);
1833
ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_PAGE);
1834
ut_ad(!bpage->in_zip_hash);
1835
ut_ad(bpage->in_page_hash);
1836
ut_ad(bpage->zip.data == NULL);
1837
ut_ad(bpage->buf_fix_count > 0);
1841
/****************************************************************//**
1842
Add watch for the given page to be read in. Caller must have the buffer pool
1844
@return NULL if watch set, block if the page is in the buffer pool */
1849
ulint space, /*!< in: space id */
1850
ulint offset, /*!< in: page number */
1851
ulint fold) /*!< in: buf_page_address_fold(space, offset) */
1855
buf_pool_t* buf_pool = buf_pool_get(space, offset);
1857
ut_ad(buf_pool_mutex_own(buf_pool));
1859
bpage = buf_page_hash_get_low(buf_pool, space, offset, fold);
1861
if (UNIV_LIKELY_NULL(bpage)) {
1862
if (!buf_pool_watch_is_sentinel(buf_pool, bpage)) {
1863
/* The page was loaded meanwhile. */
1866
/* Add to an existing watch. */
1867
bpage->buf_fix_count++;
1871
for (i = 0; i < BUF_POOL_WATCH_SIZE; i++) {
1872
bpage = &buf_pool->watch[i];
1874
ut_ad(bpage->access_time == 0);
1875
ut_ad(bpage->newest_modification == 0);
1876
ut_ad(bpage->oldest_modification == 0);
1877
ut_ad(bpage->zip.data == NULL);
1878
ut_ad(!bpage->in_zip_hash);
1880
switch (bpage->state) {
1881
case BUF_BLOCK_POOL_WATCH:
1882
ut_ad(!bpage->in_page_hash);
1883
ut_ad(bpage->buf_fix_count == 0);
1885
/* bpage is pointing to buf_pool->watch[],
1886
which is protected by buf_pool->mutex.
1887
Normally, buf_page_t objects are protected by
1888
buf_block_t::mutex or buf_pool->zip_mutex or both. */
1890
bpage->state = BUF_BLOCK_ZIP_PAGE;
1891
bpage->space = space;
1892
bpage->offset = offset;
1893
bpage->buf_fix_count = 1;
1895
ut_d(bpage->in_page_hash = TRUE);
1896
HASH_INSERT(buf_page_t, hash, buf_pool->page_hash,
1899
case BUF_BLOCK_ZIP_PAGE:
1900
ut_ad(bpage->in_page_hash);
1901
ut_ad(bpage->buf_fix_count > 0);
1908
/* Allocation failed. Either the maximum number of purge
1909
threads should never exceed BUF_POOL_WATCH_SIZE, or this code
1910
should be modified to return a special non-NULL value and the
1911
caller should purge the record directly. */
1914
/* Fix compiler warning */
1918
/********************************************************************//**
1919
Rebuild buf_pool->page_hash. */
1922
buf_pool_page_hash_rebuild(void)
1923
/*============================*/
1927
for (i = 0; i < srv_buf_pool_instances; i++) {
1928
buf_pool_page_hash_rebuild_instance(buf_pool_from_array(i));
1932
/********************************************************************//**
1933
Increase the buffer pool size of one buffer pool instance. */
1936
buf_pool_increase_instance(
1937
/*=======================*/
1938
buf_pool_t* buf_pool, /*!< in: buffer pool instane */
1939
ulint change_size) /*!< in: new size of the pool */
1941
buf_chunk_t* chunks;
1944
buf_pool_mutex_enter(buf_pool);
1945
chunks = static_cast<buf_chunk_t *>(mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks));
1947
memcpy(chunks, buf_pool->chunks, buf_pool->n_chunks * sizeof *chunks);
1949
chunk = &chunks[buf_pool->n_chunks];
1951
if (!buf_chunk_init(buf_pool, chunk, change_size)) {
1954
buf_pool->old_pool_size = buf_pool->curr_pool_size;
1955
buf_pool->curr_size += chunk->size;
1956
buf_pool->curr_pool_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
1957
mem_free(buf_pool->chunks);
1958
buf_pool->chunks = chunks;
1959
buf_pool->n_chunks++;
1962
buf_pool_mutex_exit(buf_pool);
1965
/********************************************************************//**
1966
Increase the buffer pool size. */
1975
for (i = 0; i < srv_buf_pool_instances; i++) {
1976
buf_pool_increase_instance(
1977
buf_pool_from_array(i),
1978
change_size / srv_buf_pool_instances);
1981
buf_pool_set_sizes();
1439
buf_pool_mutex_exit();
1984
1442
/********************************************************************//**
1988
1446
buf_pool_resize(void)
1989
1447
/*=================*/
1992
ulint min_change_size = 1048576 * srv_buf_pool_instances;
1994
buf_pool_mutex_enter_all();
1996
if (srv_buf_pool_old_size == srv_buf_pool_size) {
1998
buf_pool_mutex_exit_all();
2002
} else if (srv_buf_pool_curr_size + min_change_size
2003
> srv_buf_pool_size) {
2005
change_size = (srv_buf_pool_curr_size - srv_buf_pool_size)
2008
buf_pool_mutex_exit_all();
2010
/* Disable adaptive hash indexes and empty the index
2011
in order to free up memory in the buffer pool chunks. */
2012
buf_pool_shrink(change_size);
2014
} else if (srv_buf_pool_curr_size + min_change_size
2015
< srv_buf_pool_size) {
2017
/* Enlarge the buffer pool by at least one megabyte */
2019
change_size = srv_buf_pool_size - srv_buf_pool_curr_size;
2021
buf_pool_mutex_exit_all();
2023
buf_pool_increase(change_size);
2025
srv_buf_pool_size = srv_buf_pool_old_size;
2027
buf_pool_mutex_exit_all();
1449
buf_pool_mutex_enter();
1451
if (srv_buf_pool_old_size == srv_buf_pool_size) {
1453
buf_pool_mutex_exit();
2032
buf_pool_page_hash_rebuild();
2035
/****************************************************************//**
2036
Remove the sentinel block for the watch before replacing it with a real block.
2037
buf_page_watch_clear() or buf_page_watch_occurred() will notice that
2038
the block has been replaced with the real block.
2039
@return reference count, to be added to the replacement block */
2042
buf_pool_watch_remove(
2043
/*==================*/
2044
buf_pool_t* buf_pool, /*!< buffer pool instance */
2045
ulint fold, /*!< in: buf_page_address_fold(
2047
buf_page_t* watch) /*!< in/out: sentinel for watch */
2049
ut_ad(buf_pool_mutex_own(buf_pool));
2051
HASH_DELETE(buf_page_t, hash, buf_pool->page_hash, fold, watch);
2052
ut_d(watch->in_page_hash = FALSE);
2053
watch->buf_fix_count = 0;
2054
watch->state = BUF_BLOCK_POOL_WATCH;
2057
/****************************************************************//**
2058
Stop watching if the page has been read in.
2059
buf_pool_watch_set(space,offset) must have returned NULL before. */
2062
buf_pool_watch_unset(
2063
/*=================*/
2064
ulint space, /*!< in: space id */
2065
ulint offset) /*!< in: page number */
2068
buf_pool_t* buf_pool = buf_pool_get(space, offset);
2069
ulint fold = buf_page_address_fold(space, offset);
2071
buf_pool_mutex_enter(buf_pool);
2072
bpage = buf_page_hash_get_low(buf_pool, space, offset, fold);
2073
/* The page must exist because buf_pool_watch_set()
2074
increments buf_fix_count. */
2077
if (UNIV_UNLIKELY(!buf_pool_watch_is_sentinel(buf_pool, bpage))) {
2078
mutex_t* mutex = buf_page_get_mutex(bpage);
2081
ut_a(bpage->buf_fix_count > 0);
2082
bpage->buf_fix_count--;
2085
ut_a(bpage->buf_fix_count > 0);
2087
if (UNIV_LIKELY(!--bpage->buf_fix_count)) {
2088
buf_pool_watch_remove(buf_pool, fold, bpage);
1457
if (srv_buf_pool_curr_size + 1048576 > srv_buf_pool_size) {
1459
buf_pool_mutex_exit();
1461
/* Disable adaptive hash indexes and empty the index
1462
in order to free up memory in the buffer pool chunks. */
1463
buf_pool_shrink((srv_buf_pool_curr_size - srv_buf_pool_size)
1465
} else if (srv_buf_pool_curr_size + 1048576 < srv_buf_pool_size) {
1467
/* Enlarge the buffer pool by at least one megabyte */
1470
= srv_buf_pool_size - srv_buf_pool_curr_size;
1471
buf_chunk_t* chunks;
1474
chunks = mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks);
1476
memcpy(chunks, buf_pool->chunks, buf_pool->n_chunks
1479
chunk = &chunks[buf_pool->n_chunks];
1481
if (!buf_chunk_init(chunk, mem_size)) {
1484
buf_pool->curr_size += chunk->size;
1485
srv_buf_pool_curr_size = buf_pool->curr_size
1487
mem_free(buf_pool->chunks);
1488
buf_pool->chunks = chunks;
1489
buf_pool->n_chunks++;
1492
srv_buf_pool_old_size = srv_buf_pool_size;
1493
buf_pool_mutex_exit();
2092
buf_pool_mutex_exit(buf_pool);
2095
/****************************************************************//**
2096
Check if the page has been read in.
2097
This may only be called after buf_pool_watch_set(space,offset)
2098
has returned NULL and before invoking buf_pool_watch_unset(space,offset).
2099
@return FALSE if the given page was not read in, TRUE if it was */
2102
buf_pool_watch_occurred(
2103
/*====================*/
2104
ulint space, /*!< in: space id */
2105
ulint offset) /*!< in: page number */
2109
buf_pool_t* buf_pool = buf_pool_get(space, offset);
2110
ulint fold = buf_page_address_fold(space, offset);
2112
buf_pool_mutex_enter(buf_pool);
2114
bpage = buf_page_hash_get_low(buf_pool, space, offset, fold);
2115
/* The page must exist because buf_pool_watch_set()
2116
increments buf_fix_count. */
2118
ret = !buf_pool_watch_is_sentinel(buf_pool, bpage);
2119
buf_pool_mutex_exit(buf_pool);
1496
buf_pool_page_hash_rebuild();
2124
1499
/********************************************************************//**
2663
1994
/********************************************************************//**
2664
Find out if a pointer belongs to a buf_block_t. It can be a pointer to
2665
the buf_block_t itself or a member of it
2666
@return TRUE if ptr belongs to a buf_block_t struct */
2669
buf_pointer_is_block_field(
2670
/*=======================*/
2671
const void* ptr) /*!< in: pointer not dereferenced */
2675
for (i = 0; i < srv_buf_pool_instances; i++) {
2678
found = buf_pointer_is_block_field_instance(
2679
buf_pool_from_array(i), ptr);
2688
/********************************************************************//**
2689
1995
Find out if a buffer block was created by buf_chunk_init().
2690
1996
@return TRUE if "block" has been added to buf_pool->free by buf_chunk_init() */
2693
1999
buf_block_is_uncompressed(
2694
2000
/*======================*/
2695
buf_pool_t* buf_pool, /*!< in: buffer pool instance */
2696
const buf_block_t* block) /*!< in: pointer to block,
2001
const buf_block_t* block) /*!< in: pointer to block,
2699
ut_ad(buf_pool_mutex_own(buf_pool));
2004
ut_ad(buf_pool_mutex_own());
2701
2006
if (UNIV_UNLIKELY((((ulint) block) % sizeof *block) != 0)) {
2702
2007
/* The pointer should be aligned. */
2706
return(buf_pointer_is_block_field_instance(buf_pool, (void *)block));
2011
return(buf_pointer_is_block_field((void *)block));
2709
2014
/********************************************************************//**
2720
2025
ulint rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
2721
2026
buf_block_t* guess, /*!< in: guessed block or NULL */
2722
2027
ulint mode, /*!< in: BUF_GET, BUF_GET_IF_IN_POOL,
2723
BUF_GET_NO_LATCH, or
2724
BUF_GET_IF_IN_POOL_OR_WATCH */
2725
2029
const char* file, /*!< in: file name */
2726
2030
ulint line, /*!< in: line where called */
2727
2031
mtr_t* mtr) /*!< in: mini-transaction */
2729
2033
buf_block_t* block;
2731
2034
unsigned access_time;
2732
2035
ulint fix_type;
2733
2036
ibool must_read;
2735
buf_pool_t* buf_pool = buf_pool_get(space, offset);
2738
ut_ad(mtr->state == MTR_ACTIVE);
2739
2039
ut_ad((rw_latch == RW_S_LATCH)
2740
2040
|| (rw_latch == RW_X_LATCH)
2741
2041
|| (rw_latch == RW_NO_LATCH));
2742
2042
ut_ad((mode != BUF_GET_NO_LATCH) || (rw_latch == RW_NO_LATCH));
2743
ut_ad(mode == BUF_GET
2744
|| mode == BUF_GET_IF_IN_POOL
2745
|| mode == BUF_GET_NO_LATCH
2746
|| mode == BUF_GET_IF_IN_POOL_OR_WATCH);
2043
ut_ad((mode == BUF_GET) || (mode == BUF_GET_IF_IN_POOL)
2044
|| (mode == BUF_GET_NO_LATCH));
2747
2045
ut_ad(zip_size == fil_space_get_zip_size(space));
2748
2046
ut_ad(ut_is_2pow(zip_size));
2749
2047
#ifndef UNIV_LOG_DEBUG
2750
2048
ut_ad(!ibuf_inside() || ibuf_page(space, zip_size, offset, NULL));
2752
2050
buf_pool->stat.n_page_gets++;
2753
fold = buf_page_address_fold(space, offset);
2756
buf_pool_mutex_enter(buf_pool);
2053
buf_pool_mutex_enter();
2759
2056
/* If the guess is a compressed page descriptor that
2779
2076
if (block == NULL) {
2780
block = (buf_block_t*) buf_page_hash_get_low(
2781
buf_pool, space, offset, fold);
2077
block = (buf_block_t*) buf_page_hash_get(space, offset);
2785
if (block && buf_pool_watch_is_sentinel(buf_pool, &block->page)) {
2789
2081
if (block == NULL) {
2790
2082
/* Page not in buf_pool: needs to be read from file */
2792
if (mode == BUF_GET_IF_IN_POOL_OR_WATCH) {
2793
block = (buf_block_t*) buf_pool_watch_set(
2794
space, offset, fold);
2796
if (UNIV_LIKELY_NULL(block)) {
2802
buf_pool_mutex_exit(buf_pool);
2804
if (mode == BUF_GET_IF_IN_POOL
2805
|| mode == BUF_GET_IF_IN_POOL_OR_WATCH) {
2084
buf_pool_mutex_exit();
2086
if (mode == BUF_GET_IF_IN_POOL) {
2810
if (buf_read_page(space, zip_size, offset)) {
2812
} else if (retries < BUF_PAGE_READ_MAX_RETRIES) {
2815
fprintf(stderr, "InnoDB: Error: Unable"
2816
" to read tablespace %lu page no"
2817
" %lu into the buffer pool after"
2819
"InnoDB: The most probable cause"
2820
" of this error may be that the"
2821
" table has been corrupted.\n"
2822
"InnoDB: You can try to fix this"
2824
" innodb_force_recovery.\n"
2825
"InnoDB: Please see reference manual"
2826
" for more details.\n"
2827
"InnoDB: Aborting...\n",
2829
BUF_PAGE_READ_MAX_RETRIES);
2091
buf_read_page(space, zip_size, offset);
2834
2093
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2835
2094
ut_a(++buf_dbg_counter % 37 || buf_validate());
2863
2118
case BUF_BLOCK_ZIP_DIRTY:
2864
2119
bpage = &block->page;
2865
2120
/* Protect bpage->buf_fix_count. */
2866
mutex_enter(&buf_pool->zip_mutex);
2121
mutex_enter(&buf_pool_zip_mutex);
2868
2123
if (bpage->buf_fix_count
2869
2124
|| buf_page_get_io_fix(bpage) != BUF_IO_NONE) {
2870
2125
/* This condition often occurs when the buffer
2871
2126
is not buffer-fixed, but I/O-fixed by
2872
2127
buf_page_init_for_read(). */
2873
mutex_exit(&buf_pool->zip_mutex);
2128
mutex_exit(&buf_pool_zip_mutex);
2874
2129
wait_until_unfixed:
2875
2130
/* The block is buffer-fixed or I/O-fixed.
2876
2131
Try again later. */
2877
buf_pool_mutex_exit(buf_pool);
2132
buf_pool_mutex_exit();
2878
2133
os_thread_sleep(WAIT_FOR_READ);
2883
2138
/* Allocate an uncompressed page. */
2884
buf_pool_mutex_exit(buf_pool);
2885
mutex_exit(&buf_pool->zip_mutex);
2139
buf_pool_mutex_exit();
2140
mutex_exit(&buf_pool_zip_mutex);
2887
block = buf_LRU_get_free_block(buf_pool, 0);
2142
block = buf_LRU_get_free_block(0);
2890
buf_pool_mutex_enter(buf_pool);
2145
buf_pool_mutex_enter();
2891
2146
mutex_enter(&block->mutex);
2894
buf_page_t* hash_bpage;
2896
hash_bpage = buf_page_hash_get_low(
2897
buf_pool, space, offset, fold);
2149
buf_page_t* hash_bpage
2150
= buf_page_hash_get(space, offset);
2899
2152
if (UNIV_UNLIKELY(bpage != hash_bpage)) {
2900
2153
/* The buf_pool->page_hash was modified
2901
while buf_pool->mutex was released.
2154
while buf_pool_mutex was released.
2902
2155
Free the block that was allocated. */
2904
2157
buf_LRU_block_free_non_file_page(block);
2958
2225
block->page.buf_fix_count = 1;
2959
2226
buf_block_set_io_fix(block, BUF_IO_READ);
2960
rw_lock_x_lock_func(&block->lock, 0, file, line);
2962
UNIV_MEM_INVALID(bpage, sizeof *bpage);
2227
rw_lock_x_lock(&block->lock);
2964
2228
mutex_exit(&block->mutex);
2965
mutex_exit(&buf_pool->zip_mutex);
2229
mutex_exit(&buf_pool_zip_mutex);
2966
2230
buf_pool->n_pend_unzip++;
2968
buf_buddy_free(buf_pool, bpage, sizeof *bpage);
2232
buf_buddy_free(bpage, sizeof *bpage);
2970
buf_pool_mutex_exit(buf_pool);
2234
buf_pool_mutex_exit();
2972
2236
/* Decompress the page and apply buffered operations
2973
while not holding buf_pool->mutex or block->mutex. */
2237
while not holding buf_pool_mutex or block->mutex. */
2974
2238
success = buf_zip_decompress(block, srv_use_checksums);
2977
if (UNIV_LIKELY(!recv_no_ibuf_operations)) {
2240
if (UNIV_LIKELY(success)) {
2978
2241
ibuf_merge_or_delete_for_page(block, space, offset,
2979
2242
zip_size, TRUE);
2982
2245
/* Unfix and unlatch the block. */
2983
buf_pool_mutex_enter(buf_pool);
2246
buf_pool_mutex_enter();
2984
2247
mutex_enter(&block->mutex);
2985
2248
block->page.buf_fix_count--;
2986
2249
buf_block_set_io_fix(block, BUF_IO_NONE);
3002
2271
ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE);
3004
2273
mutex_enter(&block->mutex);
3005
#if UNIV_WORD_SIZE == 4
3006
/* On 32-bit systems, there is no padding in buf_page_t. On
3007
other systems, Valgrind could complain about uninitialized pad
3009
2274
UNIV_MEM_ASSERT_RW(&block->page, sizeof block->page);
3011
#if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
3012
if ((mode == BUF_GET_IF_IN_POOL || mode == BUF_GET_IF_IN_POOL_OR_WATCH)
3014
/* Try to evict the block from the buffer pool, to use the
3015
insert buffer (change buffer) as much as possible. */
3017
if (buf_LRU_free_block(&block->page, TRUE, NULL)
3019
mutex_exit(&block->mutex);
3020
if (mode == BUF_GET_IF_IN_POOL_OR_WATCH) {
3021
/* Set the watch, as it would have
3022
been set if the page were not in the
3023
buffer pool in the first place. */
3024
block = (buf_block_t*) buf_pool_watch_set(
3025
space, offset, fold);
3027
if (UNIV_LIKELY_NULL(block)) {
3029
/* The page entered the buffer
3030
pool for some reason. Try to
3035
buf_pool_mutex_exit(buf_pool);
3037
"innodb_change_buffering_debug evict %u %u\n",
3038
(unsigned) space, (unsigned) offset);
3040
} else if (buf_flush_page_try(buf_pool, block)) {
3042
"innodb_change_buffering_debug flush %u %u\n",
3043
(unsigned) space, (unsigned) offset);
3048
/* Failed to evict the page; change it directly */
3050
#endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
3052
2276
buf_block_buf_fix_inc(block, file, line);
3488
2696
buf_block_init_low(block);
3490
block->lock_hash_val = lock_rec_hash(space, offset);
3492
buf_page_init_low(&block->page);
2698
block->lock_hash_val = lock_rec_hash(space, offset);
3494
2700
/* Insert into the hash table of file pages */
3496
hash_page = buf_page_hash_get_low(buf_pool, space, offset, fold);
3498
if (UNIV_LIKELY(!hash_page)) {
3499
} else if (buf_pool_watch_is_sentinel(buf_pool, hash_page)) {
3500
/* Preserve the reference count. */
3501
ulint buf_fix_count = hash_page->buf_fix_count;
3503
ut_a(buf_fix_count > 0);
3504
block->page.buf_fix_count += buf_fix_count;
3505
buf_pool_watch_remove(buf_pool, fold, hash_page);
2702
hash_page = buf_page_hash_get(space, offset);
2704
if (UNIV_LIKELY_NULL(hash_page)) {
3507
2705
fprintf(stderr,
3508
2706
"InnoDB: Error: page %lu %lu already found"
3509
2707
" in the hash table: %p, %p\n",
3648
2836
if (UNIV_UNLIKELY(zip_size)) {
3649
2837
page_zip_set_size(&block->page.zip, zip_size);
3651
/* buf_pool->mutex may be released and
2839
/* buf_pool_mutex may be released and
3652
2840
reacquired by buf_buddy_alloc(). Thus, we
3653
2841
must release block->mutex in order not to
3654
2842
break the latching order in the reacquisition
3655
of buf_pool->mutex. We also must defer this
2843
of buf_pool_mutex. We also must defer this
3656
2844
operation until after the block descriptor has
3657
2845
been added to buf_pool->LRU and
3658
2846
buf_pool->page_hash. */
3659
2847
mutex_exit(&block->mutex);
3660
data = buf_buddy_alloc(buf_pool, zip_size, &lru);
2848
data = buf_buddy_alloc(zip_size, &lru);
3661
2849
mutex_enter(&block->mutex);
3662
block->page.zip.data = static_cast<unsigned char *>(data);
2850
block->page.zip.data = data;
3664
2852
/* To maintain the invariant
3665
2853
block->in_unzip_LRU_list
3681
2869
control block (bpage), in order to avoid the
3682
2870
invocation of buf_buddy_relocate_block() on
3683
2871
uninitialized data. */
3684
data = buf_buddy_alloc(buf_pool, zip_size, &lru);
3685
bpage = static_cast<buf_page_struct *>(buf_buddy_alloc(buf_pool, sizeof *bpage, &lru));
3687
/* Initialize the buf_pool pointer. */
3688
bpage->buf_pool_index = buf_pool_index(buf_pool);
2872
data = buf_buddy_alloc(zip_size, &lru);
2873
bpage = buf_buddy_alloc(sizeof *bpage, &lru);
3690
2875
/* If buf_buddy_alloc() allocated storage from the LRU list,
3691
it released and reacquired buf_pool->mutex. Thus, we must
2876
it released and reacquired buf_pool_mutex. Thus, we must
3692
2877
check the page_hash again, as it may have been modified. */
3693
if (UNIV_UNLIKELY(lru)) {
3695
watch_page = buf_page_hash_get_low(
3696
buf_pool, space, offset, fold);
3699
&& !buf_pool_watch_is_sentinel(buf_pool,
3702
/* The block was added by some other thread. */
3704
buf_buddy_free(buf_pool, bpage, sizeof *bpage);
3705
buf_buddy_free(buf_pool, data, zip_size);
2878
if (UNIV_UNLIKELY(lru)
2879
&& UNIV_LIKELY_NULL(buf_page_hash_get(space, offset))) {
2881
/* The block was added by some other thread. */
2882
buf_buddy_free(bpage, sizeof *bpage);
2883
buf_buddy_free(data, zip_size);
3712
2889
page_zip_des_init(&bpage->zip);
3713
2890
page_zip_set_size(&bpage->zip, zip_size);
3714
bpage->zip.data = static_cast<unsigned char *>(data);
2891
bpage->zip.data = data;
3716
mutex_enter(&buf_pool->zip_mutex);
2893
mutex_enter(&buf_pool_zip_mutex);
3717
2894
UNIV_MEM_DESC(bpage->zip.data,
3718
2895
page_zip_get_size(&bpage->zip), bpage);
3720
2896
buf_page_init_low(bpage);
3722
2897
bpage->state = BUF_BLOCK_ZIP_PAGE;
3723
2898
bpage->space = space;
3724
2899
bpage->offset = offset;
3727
2901
#ifdef UNIV_DEBUG
3728
2902
bpage->in_page_hash = FALSE;
3729
2903
bpage->in_zip_hash = FALSE;
3733
2907
#endif /* UNIV_DEBUG */
3735
2909
ut_d(bpage->in_page_hash = TRUE);
3737
if (UNIV_LIKELY_NULL(watch_page)) {
3738
/* Preserve the reference count. */
3739
ulint buf_fix_count = watch_page->buf_fix_count;
3740
ut_a(buf_fix_count > 0);
3741
bpage->buf_fix_count += buf_fix_count;
3742
ut_ad(buf_pool_watch_is_sentinel(buf_pool, watch_page));
3743
buf_pool_watch_remove(buf_pool, fold, watch_page);
3746
HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, fold,
2910
HASH_INSERT(buf_page_t, hash, buf_pool->page_hash,
2911
buf_page_address_fold(space, offset), bpage);
3749
2913
/* The block must be put to the LRU list, to the old blocks */
3750
2914
buf_LRU_add_block(bpage, TRUE/* to old blocks */);
3787
2951
buf_frame_t* frame;
3788
2952
buf_block_t* block;
3790
2953
buf_block_t* free_block = NULL;
3791
2954
ulint time_ms = ut_time_ms();
3792
buf_pool_t* buf_pool = buf_pool_get(space, offset);
3795
ut_ad(mtr->state == MTR_ACTIVE);
3796
2957
ut_ad(space || !zip_size);
3798
free_block = buf_LRU_get_free_block(buf_pool, 0);
3800
fold = buf_page_address_fold(space, offset);
3802
buf_pool_mutex_enter(buf_pool);
3804
block = (buf_block_t*) buf_page_hash_get_low(
3805
buf_pool, space, offset, fold);
3808
&& buf_page_in_file(&block->page)
3809
&& !buf_pool_watch_is_sentinel(buf_pool, &block->page)) {
2959
free_block = buf_LRU_get_free_block(0);
2961
buf_pool_mutex_enter();
2963
block = (buf_block_t*) buf_page_hash_get(space, offset);
2965
if (block && buf_page_in_file(&block->page)) {
3810
2966
#ifdef UNIV_IBUF_COUNT_DEBUG
3811
2967
ut_a(ibuf_count_get(space, offset) == 0);
3858
3014
page_zip_set_size(&block->page.zip, zip_size);
3859
3015
mutex_exit(&block->mutex);
3860
/* buf_pool->mutex may be released and reacquired by
3016
/* buf_pool_mutex may be released and reacquired by
3861
3017
buf_buddy_alloc(). Thus, we must release block->mutex
3862
3018
in order not to break the latching order in
3863
the reacquisition of buf_pool->mutex. We also must
3019
the reacquisition of buf_pool_mutex. We also must
3864
3020
defer this operation until after the block descriptor
3865
3021
has been added to buf_pool->LRU and buf_pool->page_hash. */
3866
data = buf_buddy_alloc(buf_pool, zip_size, &lru);
3022
data = buf_buddy_alloc(zip_size, &lru);
3867
3023
mutex_enter(&block->mutex);
3868
block->page.zip.data = static_cast<unsigned char *>(data);
3024
block->page.zip.data = data;
3870
3026
/* To maintain the invariant
3871
3027
block->in_unzip_LRU_list
4129
3284
#endif /* UNIV_DEBUG */
4131
3286
mutex_exit(buf_page_get_mutex(bpage));
4132
buf_pool_mutex_exit(buf_pool);
4135
/*********************************************************************//**
4136
Asserts that all file pages in the buffer are in a replaceable state.
4140
buf_all_freed_instance(
4141
/*===================*/
4142
buf_pool_t* buf_pool) /*!< in: buffer pool instancce */
4149
buf_pool_mutex_enter(buf_pool);
4151
chunk = buf_pool->chunks;
4153
for (i = buf_pool->n_chunks; i--; chunk++) {
4155
const buf_block_t* block = buf_chunk_not_freed(chunk);
4157
if (UNIV_LIKELY_NULL(block)) {
4159
"Page %lu %lu still fixed or dirty\n",
4160
(ulong) block->page.space,
4161
(ulong) block->page.offset);
4166
buf_pool_mutex_exit(buf_pool);
4171
/*********************************************************************//**
4172
Invalidates file pages in one buffer pool instance */
3287
buf_pool_mutex_exit();
3290
/*********************************************************************//**
3291
Invalidates the file pages in the buffer pool when an archive recovery is
3292
completed. All the file pages buffered must be in a replaceable state when
3293
this function is called: not latched and not modified. */
4175
buf_pool_invalidate_instance(
4176
/*=========================*/
4177
buf_pool_t* buf_pool) /*!< in: buffer pool instance */
3296
buf_pool_invalidate(void)
3297
/*=====================*/
4182
buf_pool_mutex_enter(buf_pool);
3302
buf_pool_mutex_enter();
4184
3304
for (i = BUF_FLUSH_LRU; i < BUF_FLUSH_N_TYPES; i++) {
4222
3342
buf_pool->LRU_flush_ended = 0;
4224
3344
memset(&buf_pool->stat, 0x00, sizeof(buf_pool->stat));
4225
buf_refresh_io_stats(buf_pool);
4227
buf_pool_mutex_exit(buf_pool);
4230
/*********************************************************************//**
4231
Invalidates the file pages in the buffer pool when an archive recovery is
4232
completed. All the file pages buffered must be in a replaceable state when
4233
this function is called: not latched and not modified. */
4236
buf_pool_invalidate(void)
4237
/*=====================*/
4241
for (i = 0; i < srv_buf_pool_instances; i++) {
4242
buf_pool_invalidate_instance(buf_pool_from_array(i));
3345
buf_refresh_io_stats();
3347
buf_pool_mutex_exit();
4246
3350
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
4247
3351
/*********************************************************************//**
4248
Validates data in one buffer pool instance
3352
Validates the buffer buf_pool data structure.
4249
3353
@return TRUE */
4252
buf_pool_validate_instance(
4253
/*=======================*/
4254
buf_pool_t* buf_pool) /*!< in: buffer pool instance */
4257
3360
buf_chunk_t* chunk;
4381
/* It is OK to read oldest_modification here because
4382
we have acquired buf_pool->zip_mutex above which acts
4383
as the 'block->mutex' for these bpages. */
4384
3487
ut_a(!b->oldest_modification);
4385
ut_a(buf_page_hash_get(buf_pool, b->space, b->offset) == b);
3488
ut_a(buf_page_hash_get(b->space, b->offset) == b);
4391
/* Check dirty blocks. */
3494
/* Check dirty compressed-only blocks. */
4393
buf_flush_list_mutex_enter(buf_pool);
4394
3496
for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
4395
3497
b = UT_LIST_GET_NEXT(list, b)) {
4396
3498
ut_ad(b->in_flush_list);
4397
ut_a(b->oldest_modification);
4400
3500
switch (buf_page_get_state(b)) {
4401
3501
case BUF_BLOCK_ZIP_DIRTY:
3502
ut_a(b->oldest_modification);
4404
3506
switch (buf_page_get_io_fix(b)) {
4405
3507
case BUF_IO_NONE:
4406
3508
case BUF_IO_READ:
4408
3511
case BUF_IO_WRITE:
4409
3512
switch (buf_page_get_flush_type(b)) {
4410
3513
case BUF_FLUSH_LRU:
4457
3556
(ulong) n_free);
3559
ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush);
4461
3561
ut_a(buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE] == n_single_flush);
4462
3562
ut_a(buf_pool->n_flush[BUF_FLUSH_LIST] == n_list_flush);
4463
3563
ut_a(buf_pool->n_flush[BUF_FLUSH_LRU] == n_lru_flush);
4465
buf_pool_mutex_exit(buf_pool);
3565
buf_pool_mutex_exit();
4467
3567
ut_a(buf_LRU_validate());
4468
ut_a(buf_flush_validate(buf_pool));
4473
/*********************************************************************//**
4474
Validates the buffer buf_pool data structure.
4483
for (i = 0; i < srv_buf_pool_instances; i++) {
4484
buf_pool_t* buf_pool;
4486
buf_pool = buf_pool_from_array(i);
4488
buf_pool_validate_instance(buf_pool);
3568
ut_a(buf_flush_validate());
4493
3572
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
4495
3574
#if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
4496
3575
/*********************************************************************//**
4497
Prints info of the buffer buf_pool data structure for one instance. */
3576
Prints info of the buffer buf_pool data structure. */
4502
buf_pool_t* buf_pool)
4504
index_id_t* index_ids;
4511
3589
buf_chunk_t* chunk;
4512
3590
dict_index_t* index;
4906
3922
"LRU len: %lu, unzip_LRU len: %lu\n"
4907
3923
"I/O sum[%lu]:cur[%lu], unzip sum[%lu]:cur[%lu]\n",
4908
static_cast<ulint>(UT_LIST_GET_LEN(buf_pool->LRU)),
4909
static_cast<ulint>(UT_LIST_GET_LEN(buf_pool->unzip_LRU)),
3924
UT_LIST_GET_LEN(buf_pool->LRU),
3925
UT_LIST_GET_LEN(buf_pool->unzip_LRU),
4910
3926
buf_LRU_stat_sum.io, buf_LRU_stat_cur.io,
4911
3927
buf_LRU_stat_sum.unzip, buf_LRU_stat_cur.unzip);
4913
buf_refresh_io_stats(buf_pool);
4914
buf_pool_mutex_exit(buf_pool);
4917
/*********************************************************************//**
4918
Prints info of the buffer i/o. */
4923
FILE* file) /*!< in/out: buffer where to print */
4927
for (i = 0; i < srv_buf_pool_instances; i++) {
4928
buf_pool_t* buf_pool;
4930
buf_pool = buf_pool_from_array(i);
4931
buf_print_io_instance(buf_pool, file);
3929
buf_refresh_io_stats();
3930
buf_pool_mutex_exit();
4935
3933
/**********************************************************************//**
4936
3934
Refreshes the statistics used to print per-second averages. */
4939
buf_refresh_io_stats(
4940
/*=================*/
4941
buf_pool_t* buf_pool) /*!< in: buffer pool instance */
3937
buf_refresh_io_stats(void)
3938
/*======================*/
4943
buf_pool->last_printout_time = ut_time();
3940
buf_pool->last_printout_time = time(NULL);
4944
3941
buf_pool->old_stat = buf_pool->stat;
4947
/**********************************************************************//**
4948
Refreshes the statistics used to print per-second averages. */
4951
buf_refresh_io_stats_all(void)
4952
/*==========================*/
4956
for (i = 0; i < srv_buf_pool_instances; i++) {
4957
buf_pool_t* buf_pool;
4959
buf_pool = buf_pool_from_array(i);
4961
buf_refresh_io_stats(buf_pool);
4965
/**********************************************************************//**
4966
Check if all pages in all buffer pools are in a replacable state.
4967
@return FALSE if not */
3944
/*********************************************************************//**
3945
Asserts that all file pages in the buffer are in a replaceable state.
4970
3949
buf_all_freed(void)
4971
3950
/*===============*/
4975
for (i = 0; i < srv_buf_pool_instances; i++) {
4976
buf_pool_t* buf_pool;
4978
buf_pool = buf_pool_from_array(i);
4980
if (!buf_all_freed_instance(buf_pool)) {
3957
buf_pool_mutex_enter();
3959
chunk = buf_pool->chunks;
3961
for (i = buf_pool->n_chunks; i--; chunk++) {
3963
const buf_block_t* block = buf_chunk_not_freed(chunk);
3965
if (UNIV_LIKELY_NULL(block)) {
3967
"Page %lu %lu still fixed or dirty\n",
3968
(ulong) block->page.space,
3969
(ulong) block->page.offset);
3974
buf_pool_mutex_exit();
4988
3979
/*********************************************************************//**
4989
3980
Checks that there currently are no pending i/o-operations for the buffer
4994
3985
buf_pool_check_no_pending_io(void)
4995
3986
/*==============================*/
5000
buf_pool_mutex_enter_all();
5002
for (i = 0; i < srv_buf_pool_instances && ret; i++) {
5003
const buf_pool_t* buf_pool;
5005
buf_pool = buf_pool_from_array(i);
5007
if (buf_pool->n_pend_reads
5008
+ buf_pool->n_flush[BUF_FLUSH_LRU]
5009
+ buf_pool->n_flush[BUF_FLUSH_LIST]
5010
+ buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
3990
buf_pool_mutex_enter();
3992
if (buf_pool->n_pend_reads + buf_pool->n_flush[BUF_FLUSH_LRU]
3993
+ buf_pool->n_flush[BUF_FLUSH_LIST]
3994
+ buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
5016
buf_pool_mutex_exit_all();
4000
buf_pool_mutex_exit();
5022
Code currently not used
5023
4005
/*********************************************************************//**
5024
4006
Gets the current length of the free list of buffer blocks.
5025
4007
@return length of the free list */
added
removed
plugin/innobase/buf/buf0buf.c
