Percona Server moved to https://jira.percona.com/projects/PS

Merge lp:~percona-dev/percona-server/5.1.57-remove_zip_clean into lp:percona-server/5.1

  1. 5.1.57-remove_zip_clean
  2. Merge into 5.1
Proposed by Yasufumi Kinoshita
Status: Merged
Approved by: Stewart Smith
Approved revision: no longer in the source branch.
Merged at revision: 247
Proposed branch: lp:~percona-dev/percona-server/5.1.57-remove_zip_clean
Merge into: lp:percona-server/5.1
Diff against target: 628 lines (+540/-5)
1 file modified
innodb_fix_misc.patch (+540/-5)
To merge this branch: bzr merge lp:~percona-dev/percona-server/5.1.57-remove_zip_clean
Reviewer Review Type Date Requested Status
Stewart Smith Pending
Review via email: mp+65632@code.launchpad.net

Description of the change

fix for
http://bugs.mysql.com/bug.php?id=61341
is added innodb_fix_misc.patch

To post a comment you must log in.
Revision history for this message
Stewart Smith (stewart) wrote :

running this branch merged with trunk through param build: http://jenkins.percona.com/view/Percona%20Server%205.1/job/percona-server-5.1-param/31/

(to have extra check of my conflict resolution)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'innodb_fix_misc.patch'
2--- innodb_fix_misc.patch 2011-05-10 07:31:20 +0000
3+++ innodb_fix_misc.patch 2011-06-23 09:16:34 +0000
4@@ -5,15 +5,466 @@
5 # Bug fix for
6 # http://bugs.mysql.com/56433 (always: because good for all users, and safe)
7 # and http://bugs.mysql.com/51325 (optional: innodb_lazy_drop_table)
8+# and http://bugs.mysql.com/61341 (always for not-debug build)
9 # were added. They may be removed in the future when will be fixed officially.
10 #
11 #!!! notice !!!
12 # Any small change to this file in the main branch
13 # should be done or reviewed by the maintainer!
14+diff -ruN a/storage/innodb_plugin/buf/buf0buddy.c b/storage/innodb_plugin/buf/buf0buddy.c
15+--- a/storage/innodb_plugin/buf/buf0buddy.c 2011-06-23 17:58:32.811788353 +0900
16++++ b/storage/innodb_plugin/buf/buf0buddy.c 2011-06-23 17:59:22.291827133 +0900
17+@@ -377,7 +377,9 @@
18+ buf_page_t* bpage, /*!< in: block to relocate */
19+ buf_page_t* dpage) /*!< in: free block to relocate to */
20+ {
21++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
22+ buf_page_t* b;
23++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
24+
25+ //ut_ad(buf_pool_mutex_own());
26+ #ifdef UNIV_SYNC_DEBUG
27+@@ -418,6 +420,7 @@
28+ buf_relocate(bpage, dpage);
29+ ut_d(bpage->state = BUF_BLOCK_ZIP_FREE);
30+
31++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
32+ /* relocate buf_pool->zip_clean */
33+ mutex_enter(&flush_list_mutex);
34+ b = UT_LIST_GET_PREV(zip_list, dpage);
35+@@ -429,6 +432,7 @@
36+ UT_LIST_ADD_FIRST(zip_list, buf_pool->zip_clean, dpage);
37+ }
38+ mutex_exit(&flush_list_mutex);
39++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
40+
41+ UNIV_MEM_INVALID(bpage, sizeof *bpage);
42+
43 diff -ruN a/storage/innodb_plugin/buf/buf0buf.c b/storage/innodb_plugin/buf/buf0buf.c
44 --- a/storage/innodb_plugin/buf/buf0buf.c 2011-02-21 20:31:57.781983359 +0900
45 +++ b/storage/innodb_plugin/buf/buf0buf.c 2011-02-21 20:32:39.523946003 +0900
46-@@ -3243,6 +3243,7 @@
47+@@ -949,74 +949,6 @@
48+ return(NULL);
49+ }
50+
51+-/*********************************************************************//**
52+-Checks that all blocks in the buffer chunk are in BUF_BLOCK_NOT_USED state.
53+-@return TRUE if all freed */
54+-static
55+-ibool
56+-buf_chunk_all_free(
57+-/*===============*/
58+- const buf_chunk_t* chunk) /*!< in: chunk being checked */
59+-{
60+- const buf_block_t* block;
61+- ulint i;
62+-
63+- ut_ad(buf_pool);
64+- ut_ad(buf_pool_mutex_own()); /* but we need all mutex here */
65+-
66+- block = chunk->blocks;
67+-
68+- for (i = chunk->size; i--; block++) {
69+-
70+- if (buf_block_get_state(block) != BUF_BLOCK_NOT_USED) {
71+-
72+- return(FALSE);
73+- }
74+- }
75+-
76+- return(TRUE);
77+-}
78+-
79+-/********************************************************************//**
80+-Frees a chunk of buffer frames. */
81+-static
82+-void
83+-buf_chunk_free(
84+-/*===========*/
85+- buf_chunk_t* chunk) /*!< out: chunk of buffers */
86+-{
87+- buf_block_t* block;
88+- const buf_block_t* block_end;
89+-
90+- ut_ad(buf_pool_mutex_own()); /* but we need all mutex here */
91+-
92+- block_end = chunk->blocks + chunk->size;
93+-
94+- for (block = chunk->blocks; block < block_end; block++) {
95+- ut_a(buf_block_get_state(block) == BUF_BLOCK_NOT_USED);
96+- ut_a(!block->page.zip.data);
97+-
98+- ut_ad(!block->page.in_LRU_list);
99+- ut_ad(!block->in_unzip_LRU_list);
100+- ut_ad(!block->page.in_flush_list);
101+- /* Remove the block from the free list. */
102+- mutex_enter(&free_list_mutex);
103+- ut_ad(block->page.in_free_list);
104+- UT_LIST_REMOVE(free, buf_pool->free, (&block->page));
105+- mutex_exit(&free_list_mutex);
106+-
107+- /* Free the latches. */
108+- mutex_free(&block->mutex);
109+- rw_lock_free(&block->lock);
110+-#ifdef UNIV_SYNC_DEBUG
111+- rw_lock_free(&block->debug_latch);
112+-#endif /* UNIV_SYNC_DEBUG */
113+- UNIV_MEM_UNDESC(block);
114+- }
115+-
116+- os_mem_free_large(chunk->mem, chunk->mem_size);
117+-}
118+-
119+ /********************************************************************//**
120+ Creates the buffer pool.
121+ @return own: buf_pool object, NULL if not enough memory or error */
122+@@ -1106,8 +1038,6 @@
123+ chunk = chunks + buf_pool->n_chunks;
124+
125+ while (--chunk >= chunks) {
126+- /* Bypass the checks of buf_chunk_free(), since they
127+- would fail at shutdown. */
128+ os_mem_free_large(chunk->mem, chunk->mem_size);
129+ }
130+
131+@@ -1287,325 +1217,6 @@
132+ }
133+
134+ /********************************************************************//**
135+-Shrinks the buffer pool. */
136+-static
137+-void
138+-buf_pool_shrink(
139+-/*============*/
140+- ulint chunk_size) /*!< in: number of pages to remove */
141+-{
142+- buf_chunk_t* chunks;
143+- buf_chunk_t* chunk;
144+- ulint max_size;
145+- ulint max_free_size;
146+- buf_chunk_t* max_chunk;
147+- buf_chunk_t* max_free_chunk;
148+-
149+- ut_ad(!buf_pool_mutex_own());
150+-
151+-try_again:
152+- btr_search_disable(); /* Empty the adaptive hash index again */
153+- //buf_pool_mutex_enter();
154+- mutex_enter(&LRU_list_mutex);
155+-
156+-shrink_again:
157+- if (buf_pool->n_chunks <= 1) {
158+-
159+- /* Cannot shrink if there is only one chunk */
160+- goto func_done;
161+- }
162+-
163+- /* Search for the largest free chunk
164+- not larger than the size difference */
165+- chunks = buf_pool->chunks;
166+- chunk = chunks + buf_pool->n_chunks;
167+- max_size = max_free_size = 0;
168+- max_chunk = max_free_chunk = NULL;
169+-
170+- while (--chunk >= chunks) {
171+- if (chunk->size <= chunk_size
172+- && chunk->size > max_free_size) {
173+- if (chunk->size > max_size) {
174+- max_size = chunk->size;
175+- max_chunk = chunk;
176+- }
177+-
178+- if (buf_chunk_all_free(chunk)) {
179+- max_free_size = chunk->size;
180+- max_free_chunk = chunk;
181+- }
182+- }
183+- }
184+-
185+- if (!max_free_size) {
186+-
187+- ulint dirty = 0;
188+- ulint nonfree = 0;
189+- buf_block_t* block;
190+- buf_block_t* bend;
191+-
192+- /* Cannot shrink: try again later
193+- (do not assign srv_buf_pool_old_size) */
194+- if (!max_chunk) {
195+-
196+- goto func_exit;
197+- }
198+-
199+- block = max_chunk->blocks;
200+- bend = block + max_chunk->size;
201+-
202+- /* Move the blocks of chunk to the end of the
203+- LRU list and try to flush them. */
204+- for (; block < bend; block++) {
205+- switch (buf_block_get_state(block)) {
206+- case BUF_BLOCK_NOT_USED:
207+- continue;
208+- case BUF_BLOCK_FILE_PAGE:
209+- break;
210+- default:
211+- nonfree++;
212+- continue;
213+- }
214+-
215+- mutex_enter(&block->mutex);
216+- /* The following calls will temporarily
217+- release block->mutex and buf_pool_mutex.
218+- Therefore, we have to always retry,
219+- even if !dirty && !nonfree. */
220+-
221+- if (!buf_flush_ready_for_replace(&block->page)) {
222+-
223+- buf_LRU_make_block_old(&block->page);
224+- dirty++;
225+- } else if (buf_LRU_free_block(&block->page, TRUE, FALSE)
226+- != BUF_LRU_FREED) {
227+- nonfree++;
228+- }
229+-
230+- mutex_exit(&block->mutex);
231+- }
232+-
233+- //buf_pool_mutex_exit();
234+- mutex_exit(&LRU_list_mutex);
235+-
236+- /* Request for a flush of the chunk if it helps.
237+- Do not flush if there are non-free blocks, since
238+- flushing will not make the chunk freeable. */
239+- if (nonfree) {
240+- /* Avoid busy-waiting. */
241+- os_thread_sleep(100000);
242+- } else if (dirty
243+- && buf_flush_batch(BUF_FLUSH_LRU, dirty, 0)
244+- == ULINT_UNDEFINED) {
245+-
246+- buf_flush_wait_batch_end(BUF_FLUSH_LRU);
247+- }
248+-
249+- goto try_again;
250+- }
251+-
252+- max_size = max_free_size;
253+- max_chunk = max_free_chunk;
254+-
255+- srv_buf_pool_old_size = srv_buf_pool_size;
256+-
257+- /* Rewrite buf_pool->chunks. Copy everything but max_chunk. */
258+- chunks = mem_alloc((buf_pool->n_chunks - 1) * sizeof *chunks);
259+- memcpy(chunks, buf_pool->chunks,
260+- (max_chunk - buf_pool->chunks) * sizeof *chunks);
261+- memcpy(chunks + (max_chunk - buf_pool->chunks),
262+- max_chunk + 1,
263+- buf_pool->chunks + buf_pool->n_chunks
264+- - (max_chunk + 1));
265+- ut_a(buf_pool->curr_size > max_chunk->size);
266+- buf_pool->curr_size -= max_chunk->size;
267+- srv_buf_pool_curr_size = buf_pool->curr_size * UNIV_PAGE_SIZE;
268+- chunk_size -= max_chunk->size;
269+- buf_chunk_free(max_chunk);
270+- mem_free(buf_pool->chunks);
271+- buf_pool->chunks = chunks;
272+- buf_pool->n_chunks--;
273+-
274+- /* Allow a slack of one megabyte. */
275+- if (chunk_size > 1048576 / UNIV_PAGE_SIZE) {
276+-
277+- goto shrink_again;
278+- }
279+-
280+-func_done:
281+- srv_buf_pool_old_size = srv_buf_pool_size;
282+-func_exit:
283+- //buf_pool_mutex_exit();
284+- mutex_exit(&LRU_list_mutex);
285+- btr_search_enable();
286+-}
287+-
288+-/********************************************************************//**
289+-Rebuild buf_pool->page_hash. */
290+-static
291+-void
292+-buf_pool_page_hash_rebuild(void)
293+-/*============================*/
294+-{
295+- ulint i;
296+- ulint n_chunks;
297+- buf_chunk_t* chunk;
298+- hash_table_t* page_hash;
299+- hash_table_t* zip_hash;
300+- buf_page_t* b;
301+-
302+- //buf_pool_mutex_enter();
303+- mutex_enter(&LRU_list_mutex);
304+- rw_lock_x_lock(&page_hash_latch);
305+- mutex_enter(&flush_list_mutex);
306+-
307+-
308+- /* Free, create, and populate the hash table. */
309+- hash_table_free(buf_pool->page_hash);
310+- buf_pool->page_hash = page_hash = hash_create(2 * buf_pool->curr_size);
311+- zip_hash = hash_create(2 * buf_pool->curr_size);
312+-
313+- HASH_MIGRATE(buf_pool->zip_hash, zip_hash, buf_page_t, hash,
314+- BUF_POOL_ZIP_FOLD_BPAGE);
315+-
316+- hash_table_free(buf_pool->zip_hash);
317+- buf_pool->zip_hash = zip_hash;
318+-
319+- /* Insert the uncompressed file pages to buf_pool->page_hash. */
320+-
321+- chunk = buf_pool->chunks;
322+- n_chunks = buf_pool->n_chunks;
323+-
324+- for (i = 0; i < n_chunks; i++, chunk++) {
325+- ulint j;
326+- buf_block_t* block = chunk->blocks;
327+-
328+- for (j = 0; j < chunk->size; j++, block++) {
329+- if (buf_block_get_state(block)
330+- == BUF_BLOCK_FILE_PAGE) {
331+- ut_ad(!block->page.in_zip_hash);
332+- ut_ad(block->page.in_page_hash);
333+-
334+- HASH_INSERT(buf_page_t, hash, page_hash,
335+- buf_page_address_fold(
336+- block->page.space,
337+- block->page.offset),
338+- &block->page);
339+- }
340+- }
341+- }
342+-
343+- /* Insert the compressed-only pages to buf_pool->page_hash.
344+- All such blocks are either in buf_pool->zip_clean or
345+- in buf_pool->flush_list. */
346+-
347+- for (b = UT_LIST_GET_FIRST(buf_pool->zip_clean); b;
348+- b = UT_LIST_GET_NEXT(zip_list, b)) {
349+- ut_a(buf_page_get_state(b) == BUF_BLOCK_ZIP_PAGE);
350+- ut_ad(!b->in_flush_list);
351+- ut_ad(b->in_LRU_list);
352+- ut_ad(b->in_page_hash);
353+- ut_ad(!b->in_zip_hash);
354+-
355+- HASH_INSERT(buf_page_t, hash, page_hash,
356+- buf_page_address_fold(b->space, b->offset), b);
357+- }
358+-
359+- for (b = UT_LIST_GET_FIRST(buf_pool->flush_list); b;
360+- b = UT_LIST_GET_NEXT(flush_list, b)) {
361+- ut_ad(b->in_flush_list);
362+- ut_ad(b->in_LRU_list);
363+- ut_ad(b->in_page_hash);
364+- ut_ad(!b->in_zip_hash);
365+-
366+- switch (buf_page_get_state(b)) {
367+- case BUF_BLOCK_ZIP_DIRTY:
368+- HASH_INSERT(buf_page_t, hash, page_hash,
369+- buf_page_address_fold(b->space,
370+- b->offset), b);
371+- break;
372+- case BUF_BLOCK_FILE_PAGE:
373+- /* uncompressed page */
374+- break;
375+- case BUF_BLOCK_ZIP_FREE:
376+- case BUF_BLOCK_ZIP_PAGE:
377+- case BUF_BLOCK_NOT_USED:
378+- case BUF_BLOCK_READY_FOR_USE:
379+- case BUF_BLOCK_MEMORY:
380+- case BUF_BLOCK_REMOVE_HASH:
381+- ut_error;
382+- break;
383+- }
384+- }
385+-
386+- //buf_pool_mutex_exit();
387+- mutex_exit(&LRU_list_mutex);
388+- rw_lock_x_unlock(&page_hash_latch);
389+- mutex_exit(&flush_list_mutex);
390+-}
391+-
392+-/********************************************************************//**
393+-Resizes the buffer pool. */
394+-UNIV_INTERN
395+-void
396+-buf_pool_resize(void)
397+-/*=================*/
398+-{
399+- //buf_pool_mutex_enter();
400+- mutex_enter(&LRU_list_mutex);
401+-
402+- if (srv_buf_pool_old_size == srv_buf_pool_size) {
403+-
404+- //buf_pool_mutex_exit();
405+- mutex_exit(&LRU_list_mutex);
406+- return;
407+- }
408+-
409+- if (srv_buf_pool_curr_size + 1048576 > srv_buf_pool_size) {
410+-
411+- //buf_pool_mutex_exit();
412+- mutex_exit(&LRU_list_mutex);
413+-
414+- /* Disable adaptive hash indexes and empty the index
415+- in order to free up memory in the buffer pool chunks. */
416+- buf_pool_shrink((srv_buf_pool_curr_size - srv_buf_pool_size)
417+- / UNIV_PAGE_SIZE);
418+- } else if (srv_buf_pool_curr_size + 1048576 < srv_buf_pool_size) {
419+-
420+- /* Enlarge the buffer pool by at least one megabyte */
421+-
422+- ulint mem_size
423+- = srv_buf_pool_size - srv_buf_pool_curr_size;
424+- buf_chunk_t* chunks;
425+- buf_chunk_t* chunk;
426+-
427+- chunks = mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks);
428+-
429+- memcpy(chunks, buf_pool->chunks, buf_pool->n_chunks
430+- * sizeof *chunks);
431+-
432+- chunk = &chunks[buf_pool->n_chunks];
433+-
434+- if (!buf_chunk_init(chunk, mem_size)) {
435+- mem_free(chunks);
436+- } else {
437+- buf_pool->curr_size += chunk->size;
438+- srv_buf_pool_curr_size = buf_pool->curr_size
439+- * UNIV_PAGE_SIZE;
440+- mem_free(buf_pool->chunks);
441+- buf_pool->chunks = chunks;
442+- buf_pool->n_chunks++;
443+- }
444+-
445+- srv_buf_pool_old_size = srv_buf_pool_size;
446+- //buf_pool_mutex_exit();
447+- mutex_exit(&LRU_list_mutex);
448+- }
449+-
450+- buf_pool_page_hash_rebuild();
451+-}
452+-
453+-/********************************************************************//**
454+ Moves a page to the start of the buffer pool LRU list. This high-level
455+ function can be used to prevent an important page from slipping out of
456+ the buffer pool. */
457+@@ -2448,8 +2059,10 @@
458+
459+ if (buf_page_get_state(&block->page)
460+ == BUF_BLOCK_ZIP_PAGE) {
461++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
462+ UT_LIST_REMOVE(zip_list, buf_pool->zip_clean,
463+ &block->page);
464++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
465+ ut_ad(!block->page.in_flush_list);
466+ } else {
467+ /* Relocate buf_pool->flush_list. */
468+@@ -3243,6 +2856,7 @@
469 bpage->state = BUF_BLOCK_ZIP_PAGE;
470 bpage->space = space;
471 bpage->offset = offset;
472@@ -21,6 +472,18 @@
473
474 #ifdef UNIV_DEBUG
475 bpage->in_page_hash = FALSE;
476+@@ -3260,9 +2874,11 @@
477+
478+ /* The block must be put to the LRU list, to the old blocks */
479+ buf_LRU_add_block(bpage, TRUE/* to old blocks */);
480++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
481+ mutex_enter(&flush_list_mutex);
482+ buf_LRU_insert_zip_clean(bpage);
483+ mutex_exit(&flush_list_mutex);
484++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
485+
486+ mutex_exit(&LRU_list_mutex);
487+
488 diff -ruN a/storage/innodb_plugin/buf/buf0flu.c b/storage/innodb_plugin/buf/buf0flu.c
489 --- a/storage/innodb_plugin/buf/buf0flu.c 2011-02-21 20:31:57.784983260 +0900
490 +++ b/storage/innodb_plugin/buf/buf0flu.c 2011-02-21 20:32:39.524915732 +0900
491@@ -47,10 +510,20 @@
492 if (flush_type != BUF_FLUSH_LRU) {
493
494 return(TRUE);
495+@@ -452,7 +459,9 @@
496+ case BUF_BLOCK_ZIP_DIRTY:
497+ buf_page_set_state(bpage, BUF_BLOCK_ZIP_PAGE);
498+ UT_LIST_REMOVE(flush_list, buf_pool->flush_list, bpage);
499++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
500+ buf_LRU_insert_zip_clean(bpage);
501++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
502+ break;
503+ case BUF_BLOCK_FILE_PAGE:
504+ UT_LIST_REMOVE(flush_list, buf_pool->flush_list, bpage);
505 diff -ruN a/storage/innodb_plugin/buf/buf0lru.c b/storage/innodb_plugin/buf/buf0lru.c
506 --- a/storage/innodb_plugin/buf/buf0lru.c 2011-02-21 20:31:57.451983310 +0900
507 +++ b/storage/innodb_plugin/buf/buf0lru.c 2011-02-21 20:32:39.526949096 +0900
508-@@ -550,6 +550,30 @@
509+@@ -550,6 +550,31 @@
510 }
511 }
512
513@@ -78,10 +551,19 @@
514 + mutex_exit(&LRU_list_mutex);
515 +}
516 +
517++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
518 /********************************************************************//**
519 Insert a compressed block into buf_pool->zip_clean in the LRU order. */
520 UNIV_INTERN
521-@@ -1492,6 +1516,10 @@
522+@@ -583,6 +608,7 @@
523+ UT_LIST_ADD_FIRST(zip_list, buf_pool->zip_clean, bpage);
524+ }
525+ }
526++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
527+
528+ /******************************************************************//**
529+ Try to free an uncompressed page of a compressed block from the unzip
530+@@ -1492,6 +1518,10 @@
531 return(BUF_LRU_NOT_FREED);
532 }
533
534@@ -92,6 +574,26 @@
535 #ifdef UNIV_IBUF_COUNT_DEBUG
536 ut_a(ibuf_count_get(bpage->space, bpage->offset) == 0);
537 #endif /* UNIV_IBUF_COUNT_DEBUG */
538+@@ -1662,7 +1692,9 @@
539+
540+ mutex_enter(&flush_list_mutex);
541+ if (b->state == BUF_BLOCK_ZIP_PAGE) {
542++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
543+ buf_LRU_insert_zip_clean(b);
544++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
545+ } else {
546+ /* Relocate on buf_pool->flush_list. */
547+ buf_flush_relocate_on_flush_list(bpage, b);
548+@@ -1959,7 +1991,9 @@
549+ ut_a(bpage->zip.data);
550+ ut_a(buf_page_get_zip_size(bpage));
551+
552++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
553+ UT_LIST_REMOVE(zip_list, buf_pool->zip_clean, bpage);
554++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
555+
556+ mutex_exit(&buf_pool_zip_mutex);
557+ //buf_pool_mutex_exit_forbid();
558 diff -ruN a/storage/innodb_plugin/fil/fil0fil.c b/storage/innodb_plugin/fil/fil0fil.c
559 --- a/storage/innodb_plugin/fil/fil0fil.c 2011-02-21 20:31:57.838984412 +0900
560 +++ b/storage/innodb_plugin/fil/fil0fil.c 2011-02-21 20:32:39.528914782 +0900
561@@ -324,7 +826,20 @@
562 diff -ruN a/storage/innodb_plugin/include/buf0buf.h b/storage/innodb_plugin/include/buf0buf.h
563 --- a/storage/innodb_plugin/include/buf0buf.h 2011-02-21 20:31:57.863983187 +0900
564 +++ b/storage/innodb_plugin/include/buf0buf.h 2011-02-21 20:32:39.537912716 +0900
565-@@ -1156,6 +1156,7 @@
566+@@ -141,12 +141,6 @@
567+ BUF_BLOCK_ZIP_DIRTY or BUF_BLOCK_ZIP_PAGE */
568+ buf_page_t* dpage) /*!< in/out: destination control block */
569+ __attribute__((nonnull));
570+-/********************************************************************//**
571+-Resizes the buffer pool. */
572+-UNIV_INTERN
573+-void
574+-buf_pool_resize(void);
575+-/*=================*/
576+ /*********************************************************************//**
577+ Gets the current size of buffer buf_pool in bytes.
578+ @return size in bytes */
579+@@ -1156,6 +1150,7 @@
580 0 if the block was never accessed
581 in the buffer pool */
582 /* @} */
583@@ -332,6 +847,17 @@
584 ibool is_corrupt;
585 # if defined UNIV_DEBUG_FILE_ACCESSES || defined UNIV_DEBUG
586 ibool file_page_was_freed;
587+@@ -1450,8 +1445,10 @@
588+ frames and buf_page_t descriptors of blocks that exist
589+ in the buffer pool only in compressed form. */
590+ /* @{ */
591++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
592+ UT_LIST_BASE_NODE_T(buf_page_t) zip_clean;
593+ /*!< unmodified compressed pages */
594++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
595+ UT_LIST_BASE_NODE_T(buf_page_t) zip_free[BUF_BUDDY_SIZES_MAX];
596+ /*!< buddy free lists */
597+ //#if BUF_BUDDY_HIGH != UNIV_PAGE_SIZE
598 diff -ruN a/storage/innodb_plugin/include/buf0buf.ic b/storage/innodb_plugin/include/buf0buf.ic
599 --- a/storage/innodb_plugin/include/buf0buf.ic 2011-02-21 20:31:57.725983812 +0900
600 +++ b/storage/innodb_plugin/include/buf0buf.ic 2011-02-21 20:32:39.538913061 +0900
601@@ -346,7 +872,7 @@
602 diff -ruN a/storage/innodb_plugin/include/buf0lru.h b/storage/innodb_plugin/include/buf0lru.h
603 --- a/storage/innodb_plugin/include/buf0lru.h 2011-02-21 20:31:57.480924269 +0900
604 +++ b/storage/innodb_plugin/include/buf0lru.h 2011-02-21 20:32:39.539912965 +0900
605-@@ -84,6 +84,13 @@
606+@@ -84,6 +84,14 @@
607 buf_LRU_invalidate_tablespace(
608 /*==========================*/
609 ulint id); /*!< in: space id */
610@@ -357,9 +883,18 @@
611 +buf_LRU_mark_space_was_deleted(
612 +/*===========================*/
613 + ulint id); /*!< in: space id */
614++#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
615 /********************************************************************//**
616 Insert a compressed block into buf_pool->zip_clean in the LRU order. */
617 UNIV_INTERN
618+@@ -91,6 +99,7 @@
619+ buf_LRU_insert_zip_clean(
620+ /*=====================*/
621+ buf_page_t* bpage); /*!< in: pointer to the block in question */
622++#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
623+
624+ /******************************************************************//**
625+ Try to free a block. If bpage is a descriptor of a compressed-only
626 diff -ruN a/storage/innodb_plugin/include/os0file.h b/storage/innodb_plugin/include/os0file.h
627 --- a/storage/innodb_plugin/include/os0file.h 2011-02-21 20:31:57.870987755 +0900
628 +++ b/storage/innodb_plugin/include/os0file.h 2011-02-21 20:32:39.540912738 +0900

Subscribers

People subscribed via source and target branches