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
246
245
/** Number of attemtps made to read in a page in the buffer pool */
247
246
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;
248
/** The buffer buf_pool of the database */
249
UNIV_INTERN buf_pool_t* buf_pool = NULL;
251
/** mutex protecting the buffer pool struct and control blocks, except the
252
read-write lock in them */
253
UNIV_INTERN mutex_t buf_pool_mutex;
254
/** mutex protecting the control blocks of compressed-only pages
255
(of type buf_page_t, not buf_block_t) */
256
UNIV_INTERN mutex_t buf_pool_zip_mutex;
252
258
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
253
259
static ulint buf_dbg_counter = 0; /*!< This is used to insert validation
254
operations in execution in the
260
operations in excution in the
262
/** Flag to forbid the release of the buffer pool mutex.
263
Protected by buf_pool_mutex. */
264
UNIV_INTERN ulint buf_pool_mutex_exit_forbidden = 0;
256
265
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
257
266
#ifdef UNIV_DEBUG
258
267
/** If this is set TRUE, the program prints info whenever
260
269
UNIV_INTERN ibool buf_debug_prints = FALSE;
261
270
#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
272
/** A chunk of buffers. The buffer pool is allocated in chunks. */
298
273
struct buf_chunk_struct{
299
274
ulint mem_size; /*!< allocated size of the chunk */
305
280
#endif /* !UNIV_HOTBACKUP */
307
282
/********************************************************************//**
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
283
Calculates a page checksum which is stored to the page when it is written
443
284
to a file. Note that we must be careful to calculate the same value on
444
285
32-bit and 64-bit architectures.
799
640
#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
641
/********************************************************************//**
848
642
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 */
647
buf_block_t* block, /*!< in: pointer to control block */
648
byte* frame) /*!< in: pointer to buffer frame */
857
650
UNIV_MEM_DESC(frame, UNIV_PAGE_SIZE, block);
859
652
block->frame = frame;
861
block->page.buf_pool_index = buf_pool_index(buf_pool);
862
654
block->page.state = BUF_BLOCK_NOT_USED;
863
655
block->page.buf_fix_count = 0;
864
656
block->page.io_fix = BUF_IO_NONE;
887
677
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
888
678
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 */
680
mutex_create(&block->mutex, SYNC_BUF_BLOCK);
682
rw_lock_create(&block->lock, SYNC_LEVEL_VARYING);
904
683
ut_ad(rw_lock_validate(&(block->lock)));
906
685
#ifdef UNIV_SYNC_DEBUG
907
rw_lock_create(buf_block_debug_latch_key,
908
&block->debug_latch, SYNC_NO_ORDER_CHECK);
686
rw_lock_create(&block->debug_latch, SYNC_NO_ORDER_CHECK);
909
687
#endif /* UNIV_SYNC_DEBUG */
1166
942
/********************************************************************//**
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 */
943
Creates the buffer pool.
944
@return own: buf_pool object, NULL if not enough memory or error */
953
buf_pool = mem_zalloc(sizeof(buf_pool_t));
1205
955
/* 1. Initialize general fields
1206
956
------------------------------- */
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();
957
mutex_create(&buf_pool_mutex, SYNC_BUF_POOL);
958
mutex_create(&buf_pool_zip_mutex, SYNC_BUF_BLOCK);
960
buf_pool_mutex_enter();
962
buf_pool->n_chunks = 1;
963
buf_pool->chunks = chunk = mem_alloc(sizeof *chunk);
965
UT_LIST_INIT(buf_pool->free);
967
if (!buf_chunk_init(chunk, srv_buf_pool_size)) {
974
srv_buf_pool_old_size = srv_buf_pool_size;
975
buf_pool->curr_size = chunk->size;
976
srv_buf_pool_curr_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
978
buf_pool->page_hash = hash_create(2 * buf_pool->curr_size);
979
buf_pool->zip_hash = hash_create(2 * buf_pool->curr_size);
981
buf_pool->last_printout_time = time(NULL);
1240
983
/* 2. Initialize flushing fields
1241
984
-------------------------------- */
1243
mutex_create(flush_list_mutex_key, &buf_pool->flush_list_mutex,
1244
SYNC_BUF_FLUSH_LIST);
1246
986
for (i = BUF_FLUSH_LRU; i < BUF_FLUSH_N_TYPES; i++) {
1247
987
buf_pool->no_flush[i] = os_event_create(NULL);
1250
990
/* 3. Initialize LRU fields
1251
991
--------------------------- */
1253
/* All fields are initialized by mem_zalloc(). */
1255
buf_pool_mutex_exit(buf_pool);
992
/* All fields are initialized by mem_zalloc(). */
994
buf_pool_mutex_exit();
996
btr_search_sys_create(buf_pool->curr_size
997
* UNIV_PAGE_SIZE / sizeof(void*) / 64);
999
/* 4. Initialize the buddy allocator fields */
1000
/* All fields are initialized by mem_zalloc(). */
1260
1005
/********************************************************************//**
1261
free one buffer pool instance */
1006
Frees the buffer pool at shutdown. This must not be invoked before
1007
freeing all mutexes. */
1264
buf_pool_free_instance(
1265
/*===================*/
1266
buf_pool_t* buf_pool) /* in,own: buffer pool instance
1269
1013
buf_chunk_t* chunk;
1270
1014
buf_chunk_t* chunks;
1281
1025
mem_free(buf_pool->chunks);
1282
1026
hash_table_free(buf_pool->page_hash);
1283
1027
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
1032
/********************************************************************//**
1421
1033
Drops the adaptive hash index. To prevent a livelock, this function
1422
1034
is only to be called while holding btr_search_latch and while
1434
1046
ut_ad(!btr_search_enabled);
1049
buf_chunk_t* chunks = buf_pool->chunks;
1050
buf_chunk_t* chunk = chunks + buf_pool->n_chunks;
1439
1052
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);
1054
while (--chunk >= chunks) {
1055
buf_block_t* block = chunk->blocks;
1056
ulint i = chunk->size;
1058
for (; i--; block++) {
1059
/* block->is_hashed cannot be modified
1060
when we have an x-latch on btr_search_latch;
1061
see the comment in buf0buf.h */
1063
if (buf_block_get_state(block)
1064
!= BUF_BLOCK_FILE_PAGE
1065
|| !block->is_hashed) {
1069
/* To follow the latching order, we
1070
have to release btr_search_latch
1071
before acquiring block->latch. */
1072
rw_lock_x_unlock(&btr_search_latch);
1073
/* When we release the search latch,
1074
we must rescan all blocks, because
1075
some may become hashed again. */
1076
released_search_latch = TRUE;
1078
rw_lock_x_lock(&block->lock);
1080
/* This should be guaranteed by the
1081
callers, which will be holding
1082
btr_search_enabled_mutex. */
1083
ut_ad(!btr_search_enabled);
1085
/* Because we did not buffer-fix the
1086
block by calling buf_block_get_gen(),
1087
it is possible that the block has been
1088
allocated for some other use after
1089
btr_search_latch was released above.
1090
We do not care which file page the
1091
block is mapped to. All we want to do
1092
is to drop any hash entries referring
1095
/* It is possible that
1096
block->page.state != BUF_FILE_PAGE.
1097
Even that does not matter, because
1098
btr_search_drop_page_hash_index() will
1099
check block->is_hashed before doing
1100
anything. block->is_hashed can only
1101
be set on uncompressed file pages. */
1103
btr_search_drop_page_hash_index(block);
1105
rw_lock_x_unlock(&block->lock);
1107
rw_lock_x_lock(&btr_search_latch);
1109
ut_ad(!btr_search_enabled);
1450
1112
} while (released_search_latch);
1679
1337
goto shrink_again;
1684
buf_pool->old_pool_size = buf_pool->curr_pool_size;
1341
srv_buf_pool_old_size = srv_buf_pool_size;
1686
buf_pool_mutex_exit(buf_pool);
1343
buf_pool_mutex_exit();
1687
1344
btr_search_enable();
1690
1347
/********************************************************************//**
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 */
1348
Rebuild buf_pool->page_hash. */
1351
buf_pool_page_hash_rebuild(void)
1352
/*============================*/
1723
1355
ulint n_chunks;
1357
hash_table_t* page_hash;
1724
1358
hash_table_t* zip_hash;
1725
hash_table_t* page_hash;
1727
buf_pool_mutex_enter(buf_pool);
1361
buf_pool_mutex_enter();
1729
1363
/* Free, create, and populate the hash table. */
1730
1364
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();
1441
buf_pool_mutex_exit();
1984
1444
/********************************************************************//**
1988
1448
buf_pool_resize(void)
1989
1449
/*=================*/
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();
1451
buf_pool_mutex_enter();
1453
if (srv_buf_pool_old_size == srv_buf_pool_size) {
1455
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);
1459
if (srv_buf_pool_curr_size + 1048576 > srv_buf_pool_size) {
1461
buf_pool_mutex_exit();
1463
/* Disable adaptive hash indexes and empty the index
1464
in order to free up memory in the buffer pool chunks. */
1465
buf_pool_shrink((srv_buf_pool_curr_size - srv_buf_pool_size)
1467
} else if (srv_buf_pool_curr_size + 1048576 < srv_buf_pool_size) {
1469
/* Enlarge the buffer pool by at least one megabyte */
1472
= srv_buf_pool_size - srv_buf_pool_curr_size;
1473
buf_chunk_t* chunks;
1476
chunks = mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks);
1478
memcpy(chunks, buf_pool->chunks, buf_pool->n_chunks
1481
chunk = &chunks[buf_pool->n_chunks];
1483
if (!buf_chunk_init(chunk, mem_size)) {
1486
buf_pool->curr_size += chunk->size;
1487
srv_buf_pool_curr_size = buf_pool->curr_size
1489
mem_free(buf_pool->chunks);
1490
buf_pool->chunks = chunks;
1491
buf_pool->n_chunks++;
1494
srv_buf_pool_old_size = srv_buf_pool_size;
1495
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);
1498
buf_pool_page_hash_rebuild();
2124
1501
/********************************************************************//**
2663
1996
/********************************************************************//**
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
1997
Find out if a buffer block was created by buf_chunk_init().
2690
1998
@return TRUE if "block" has been added to buf_pool->free by buf_chunk_init() */
2693
2001
buf_block_is_uncompressed(
2694
2002
/*======================*/
2695
buf_pool_t* buf_pool, /*!< in: buffer pool instance */
2696
const buf_block_t* block) /*!< in: pointer to block,
2003
const buf_block_t* block) /*!< in: pointer to block,
2699
ut_ad(buf_pool_mutex_own(buf_pool));
2006
ut_ad(buf_pool_mutex_own());
2701
2008
if (UNIV_UNLIKELY((((ulint) block) % sizeof *block) != 0)) {
2702
2009
/* The pointer should be aligned. */
2706
return(buf_pointer_is_block_field_instance(buf_pool, (void *)block));
2013
return(buf_pointer_is_block_field((void *)block));
2709
2016
/********************************************************************//**
2740
2044
|| (rw_latch == RW_X_LATCH)
2741
2045
|| (rw_latch == RW_NO_LATCH));
2742
2046
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);
2047
ut_ad((mode == BUF_GET) || (mode == BUF_GET_IF_IN_POOL)
2048
|| (mode == BUF_GET_NO_LATCH));
2747
2049
ut_ad(zip_size == fil_space_get_zip_size(space));
2748
2050
ut_ad(ut_is_2pow(zip_size));
2749
2051
#ifndef UNIV_LOG_DEBUG
2750
2052
ut_ad(!ibuf_inside() || ibuf_page(space, zip_size, offset, NULL));
2752
2054
buf_pool->stat.n_page_gets++;
2753
fold = buf_page_address_fold(space, offset);
2756
buf_pool_mutex_enter(buf_pool);
2057
buf_pool_mutex_enter();
2759
2060
/* If the guess is a compressed page descriptor that
2863
2144
case BUF_BLOCK_ZIP_DIRTY:
2864
2145
bpage = &block->page;
2865
2146
/* Protect bpage->buf_fix_count. */
2866
mutex_enter(&buf_pool->zip_mutex);
2147
mutex_enter(&buf_pool_zip_mutex);
2868
2149
if (bpage->buf_fix_count
2869
2150
|| buf_page_get_io_fix(bpage) != BUF_IO_NONE) {
2870
2151
/* This condition often occurs when the buffer
2871
2152
is not buffer-fixed, but I/O-fixed by
2872
2153
buf_page_init_for_read(). */
2873
mutex_exit(&buf_pool->zip_mutex);
2154
mutex_exit(&buf_pool_zip_mutex);
2874
2155
wait_until_unfixed:
2875
2156
/* The block is buffer-fixed or I/O-fixed.
2876
2157
Try again later. */
2877
buf_pool_mutex_exit(buf_pool);
2158
buf_pool_mutex_exit();
2878
2159
os_thread_sleep(WAIT_FOR_READ);
2883
2164
/* Allocate an uncompressed page. */
2884
buf_pool_mutex_exit(buf_pool);
2885
mutex_exit(&buf_pool->zip_mutex);
2165
buf_pool_mutex_exit();
2166
mutex_exit(&buf_pool_zip_mutex);
2887
block = buf_LRU_get_free_block(buf_pool, 0);
2168
block = buf_LRU_get_free_block(0);
2890
buf_pool_mutex_enter(buf_pool);
2171
buf_pool_mutex_enter();
2891
2172
mutex_enter(&block->mutex);
2894
buf_page_t* hash_bpage;
2896
hash_bpage = buf_page_hash_get_low(
2897
buf_pool, space, offset, fold);
2175
buf_page_t* hash_bpage
2176
= buf_page_hash_get(space, offset);
2899
2178
if (UNIV_UNLIKELY(bpage != hash_bpage)) {
2900
2179
/* The buf_pool->page_hash was modified
2901
while buf_pool->mutex was released.
2180
while buf_pool_mutex was released.
2902
2181
Free the block that was allocated. */
2904
2183
buf_LRU_block_free_non_file_page(block);
2958
2237
block->page.buf_fix_count = 1;
2959
2238
buf_block_set_io_fix(block, BUF_IO_READ);
2960
rw_lock_x_lock_func(&block->lock, 0, file, line);
2239
rw_lock_x_lock(&block->lock);
2962
2241
UNIV_MEM_INVALID(bpage, sizeof *bpage);
2964
2243
mutex_exit(&block->mutex);
2965
mutex_exit(&buf_pool->zip_mutex);
2244
mutex_exit(&buf_pool_zip_mutex);
2966
2245
buf_pool->n_pend_unzip++;
2968
buf_buddy_free(buf_pool, bpage, sizeof *bpage);
2247
buf_buddy_free(bpage, sizeof *bpage);
2970
buf_pool_mutex_exit(buf_pool);
2249
buf_pool_mutex_exit();
2972
2251
/* Decompress the page and apply buffered operations
2973
while not holding buf_pool->mutex or block->mutex. */
2252
while not holding buf_pool_mutex or block->mutex. */
2974
2253
success = buf_zip_decompress(block, srv_use_checksums);
3009
2287
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
2290
buf_block_buf_fix_inc(block, file, line);
3488
2716
buf_block_init_low(block);
3490
block->lock_hash_val = lock_rec_hash(space, offset);
3492
buf_page_init_low(&block->page);
2718
block->lock_hash_val = lock_rec_hash(space, offset);
3494
2720
/* 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);
2722
hash_page = buf_page_hash_get(space, offset);
2724
if (UNIV_LIKELY_NULL(hash_page)) {
3507
2725
fprintf(stderr,
3508
2726
"InnoDB: Error: page %lu %lu already found"
3509
2727
" in the hash table: %p, %p\n",
3648
2856
if (UNIV_UNLIKELY(zip_size)) {
3649
2857
page_zip_set_size(&block->page.zip, zip_size);
3651
/* buf_pool->mutex may be released and
2859
/* buf_pool_mutex may be released and
3652
2860
reacquired by buf_buddy_alloc(). Thus, we
3653
2861
must release block->mutex in order not to
3654
2862
break the latching order in the reacquisition
3655
of buf_pool->mutex. We also must defer this
2863
of buf_pool_mutex. We also must defer this
3656
2864
operation until after the block descriptor has
3657
2865
been added to buf_pool->LRU and
3658
2866
buf_pool->page_hash. */
3659
2867
mutex_exit(&block->mutex);
3660
data = buf_buddy_alloc(buf_pool, zip_size, &lru);
2868
data = buf_buddy_alloc(zip_size, &lru);
3661
2869
mutex_enter(&block->mutex);
3662
block->page.zip.data = static_cast<unsigned char *>(data);
2870
block->page.zip.data = data;
3664
2872
/* To maintain the invariant
3665
2873
block->in_unzip_LRU_list
3681
2889
control block (bpage), in order to avoid the
3682
2890
invocation of buf_buddy_relocate_block() on
3683
2891
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);
2892
data = buf_buddy_alloc(zip_size, &lru);
2893
bpage = buf_buddy_alloc(sizeof *bpage, &lru);
3690
2895
/* If buf_buddy_alloc() allocated storage from the LRU list,
3691
it released and reacquired buf_pool->mutex. Thus, we must
2896
it released and reacquired buf_pool_mutex. Thus, we must
3692
2897
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);
2898
if (UNIV_UNLIKELY(lru)
2899
&& UNIV_LIKELY_NULL(buf_page_hash_get(space, offset))) {
2901
/* The block was added by some other thread. */
2902
buf_buddy_free(bpage, sizeof *bpage);
2903
buf_buddy_free(data, zip_size);
3712
2909
page_zip_des_init(&bpage->zip);
3713
2910
page_zip_set_size(&bpage->zip, zip_size);
3714
bpage->zip.data = static_cast<unsigned char *>(data);
2911
bpage->zip.data = data;
3716
mutex_enter(&buf_pool->zip_mutex);
2913
mutex_enter(&buf_pool_zip_mutex);
3717
2914
UNIV_MEM_DESC(bpage->zip.data,
3718
2915
page_zip_get_size(&bpage->zip), bpage);
3720
2916
buf_page_init_low(bpage);
3722
2917
bpage->state = BUF_BLOCK_ZIP_PAGE;
3723
2918
bpage->space = space;
3724
2919
bpage->offset = offset;
3727
2921
#ifdef UNIV_DEBUG
3728
2922
bpage->in_page_hash = FALSE;
3729
2923
bpage->in_zip_hash = FALSE;
3733
2927
#endif /* UNIV_DEBUG */
3735
2929
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,
2930
HASH_INSERT(buf_page_t, hash, buf_pool->page_hash,
2931
buf_page_address_fold(space, offset), bpage);
3749
2933
/* The block must be put to the LRU list, to the old blocks */
3750
2934
buf_LRU_add_block(bpage, TRUE/* to old blocks */);
3787
2971
buf_frame_t* frame;
3788
2972
buf_block_t* block;
3790
2973
buf_block_t* free_block = NULL;
3791
2974
ulint time_ms = ut_time_ms();
3792
buf_pool_t* buf_pool = buf_pool_get(space, offset);
3795
2977
ut_ad(mtr->state == MTR_ACTIVE);
3796
2978
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)) {
2980
free_block = buf_LRU_get_free_block(0);
2982
buf_pool_mutex_enter();
2984
block = (buf_block_t*) buf_page_hash_get(space, offset);
2986
if (block && buf_page_in_file(&block->page)) {
3810
2987
#ifdef UNIV_IBUF_COUNT_DEBUG
3811
2988
ut_a(ibuf_count_get(space, offset) == 0);
3858
3035
page_zip_set_size(&block->page.zip, zip_size);
3859
3036
mutex_exit(&block->mutex);
3860
/* buf_pool->mutex may be released and reacquired by
3037
/* buf_pool_mutex may be released and reacquired by
3861
3038
buf_buddy_alloc(). Thus, we must release block->mutex
3862
3039
in order not to break the latching order in
3863
the reacquisition of buf_pool->mutex. We also must
3040
the reacquisition of buf_pool_mutex. We also must
3864
3041
defer this operation until after the block descriptor
3865
3042
has been added to buf_pool->LRU and buf_pool->page_hash. */
3866
data = buf_buddy_alloc(buf_pool, zip_size, &lru);
3043
data = buf_buddy_alloc(zip_size, &lru);
3867
3044
mutex_enter(&block->mutex);
3868
block->page.zip.data = static_cast<unsigned char *>(data);
3045
block->page.zip.data = data;
3870
3047
/* To maintain the invariant
3871
3048
block->in_unzip_LRU_list
4129
3305
#endif /* UNIV_DEBUG */
4131
3307
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 */
3308
buf_pool_mutex_exit();
3311
/*********************************************************************//**
3312
Invalidates the file pages in the buffer pool when an archive recovery is
3313
completed. All the file pages buffered must be in a replaceable state when
3314
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 */
3317
buf_pool_invalidate(void)
3318
/*=====================*/
4182
buf_pool_mutex_enter(buf_pool);
3323
buf_pool_mutex_enter();
4184
3325
for (i = BUF_FLUSH_LRU; i < BUF_FLUSH_N_TYPES; i++) {
4222
3363
buf_pool->LRU_flush_ended = 0;
4224
3365
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));
3366
buf_refresh_io_stats();
3368
buf_pool_mutex_exit();
4246
3371
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
4247
3372
/*********************************************************************//**
4248
Validates data in one buffer pool instance
3373
Validates the buffer buf_pool data structure.
4249
3374
@return TRUE */
4252
buf_pool_validate_instance(
4253
/*=======================*/
4254
buf_pool_t* buf_pool) /*!< in: buffer pool instance */
4257
3381
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
3508
ut_a(!b->oldest_modification);
4385
ut_a(buf_page_hash_get(buf_pool, b->space, b->offset) == b);
3509
ut_a(buf_page_hash_get(b->space, b->offset) == b);
4391
/* Check dirty blocks. */
3515
/* Check dirty compressed-only blocks. */
4393
buf_flush_list_mutex_enter(buf_pool);
4394
3517
for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
4395
3518
b = UT_LIST_GET_NEXT(list, b)) {
4396
3519
ut_ad(b->in_flush_list);
4397
ut_a(b->oldest_modification);
4400
3521
switch (buf_page_get_state(b)) {
4401
3522
case BUF_BLOCK_ZIP_DIRTY:
3523
ut_a(b->oldest_modification);
4404
3527
switch (buf_page_get_io_fix(b)) {
4405
3528
case BUF_IO_NONE:
4406
3529
case BUF_IO_READ:
4408
3532
case BUF_IO_WRITE:
4409
3533
switch (buf_page_get_flush_type(b)) {
4410
3534
case BUF_FLUSH_LRU:
4457
3577
(ulong) n_free);
3580
ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush);
4461
3582
ut_a(buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE] == n_single_flush);
4462
3583
ut_a(buf_pool->n_flush[BUF_FLUSH_LIST] == n_list_flush);
4463
3584
ut_a(buf_pool->n_flush[BUF_FLUSH_LRU] == n_lru_flush);
4465
buf_pool_mutex_exit(buf_pool);
3586
buf_pool_mutex_exit();
4467
3588
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);
3589
ut_a(buf_flush_validate());
4493
3593
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
4495
3595
#if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
4496
3596
/*********************************************************************//**
4497
Prints info of the buffer buf_pool data structure for one instance. */
3597
Prints info of the buffer buf_pool data structure. */
4502
buf_pool_t* buf_pool)
4504
index_id_t* index_ids;
4511
3610
buf_chunk_t* chunk;
4512
3611
dict_index_t* index;
4906
3943
"LRU len: %lu, unzip_LRU len: %lu\n"
4907
3944
"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)),
3945
UT_LIST_GET_LEN(buf_pool->LRU),
3946
UT_LIST_GET_LEN(buf_pool->unzip_LRU),
4910
3947
buf_LRU_stat_sum.io, buf_LRU_stat_cur.io,
4911
3948
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);
3950
buf_refresh_io_stats();
3951
buf_pool_mutex_exit();
4935
3954
/**********************************************************************//**
4936
3955
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 */
3958
buf_refresh_io_stats(void)
3959
/*======================*/
4943
buf_pool->last_printout_time = ut_time();
3961
buf_pool->last_printout_time = time(NULL);
4944
3962
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 */
3965
/*********************************************************************//**
3966
Asserts that all file pages in the buffer are in a replaceable state.
4970
3970
buf_all_freed(void)
4971
3971
/*===============*/
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)) {
3978
buf_pool_mutex_enter();
3980
chunk = buf_pool->chunks;
3982
for (i = buf_pool->n_chunks; i--; chunk++) {
3984
const buf_block_t* block = buf_chunk_not_freed(chunk);
3986
if (UNIV_LIKELY_NULL(block)) {
3988
"Page %lu %lu still fixed or dirty\n",
3989
(ulong) block->page.space,
3990
(ulong) block->page.offset);
3995
buf_pool_mutex_exit();
4988
4000
/*********************************************************************//**
4989
4001
Checks that there currently are no pending i/o-operations for the buffer
4994
4006
buf_pool_check_no_pending_io(void)
4995
4007
/*==============================*/
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]) {
4011
buf_pool_mutex_enter();
4013
if (buf_pool->n_pend_reads + buf_pool->n_flush[BUF_FLUSH_LRU]
4014
+ buf_pool->n_flush[BUF_FLUSH_LIST]
4015
+ buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
5016
buf_pool_mutex_exit_all();
4021
buf_pool_mutex_exit();
5022
Code currently not used
5023
4026
/*********************************************************************//**
5024
4027
Gets the current length of the free list of buffer blocks.
5025
4028
@return length of the free list */
added
removed
plugin/innobase/buf/buf0buf.c
