← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/buf0buddy.ic

  • Committer: Daniel Nichter
  • Date: 2011-10-23 16:01:37 UTC
  • mto: This revision was merged to the branch mainline in revision 2448.
  • Revision ID: daniel@percona.com-20111023160137-7ac3blgz8z4tf8za
Add Administration Getting Started and Logging.  Capitalize SQL clause keywords.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/buf0buddy.ic
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (C) 2006, 2009, Innobase Oy. All Rights Reserved.
 
4
 
 
5
This program is free software; you can redistribute it and/or modify it under
 
6
the terms of the GNU General Public License as published by the Free Software
 
7
Foundation; version 2 of the License.
 
8
 
 
9
This program is distributed in the hope that it will be useful, but WITHOUT
 
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
12
 
 
13
You should have received a copy of the GNU General Public License along with
 
14
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
 
15
St, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/**************************************************//**
 
20
@file include/buf0buddy.ic
 
21
Binary buddy allocator for compressed pages
 
22
 
 
23
Created December 2006 by Marko Makela
 
24
*******************************************************/
 
25
 
 
26
#ifdef UNIV_MATERIALIZE
 
27
# undef UNIV_INLINE
 
28
# define UNIV_INLINE
 
29
#endif
 
30
 
 
31
#include "buf0buf.h"
 
32
#include "buf0buddy.h"
 
33
#include "ut0ut.h"
 
34
#include "sync0sync.h"
 
35
 
 
36
/**********************************************************************//**
 
37
Allocate a block.  The thread calling this function must hold
 
38
buf_pool->mutex and must not hold buf_pool->zip_mutex or any block->mutex.
 
39
The buf_pool->mutex may only be released and reacquired if lru != NULL.
 
40
@return allocated block, possibly NULL if lru==NULL */
 
41
UNIV_INTERN
 
42
void*
 
43
buf_buddy_alloc_low(
 
44
/*================*/
 
45
        buf_pool_t*     buf_pool,
 
46
                        /*!< in: buffer pool in which the page resides */
 
47
        ulint   i,      /*!< in: index of buf_pool->zip_free[],
 
48
                        or BUF_BUDDY_SIZES */
 
49
        ibool*  lru)    /*!< in: pointer to a variable that will be assigned
 
50
                        TRUE if storage was allocated from the LRU list
 
51
                        and buf_pool->mutex was temporarily released,
 
52
                        or NULL if the LRU list should not be used */
 
53
        __attribute__((malloc));
 
54
 
 
55
/**********************************************************************//**
 
56
Deallocate a block. */
 
57
UNIV_INTERN
 
58
void
 
59
buf_buddy_free_low(
 
60
/*===============*/
 
61
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
 
62
        void*           buf,            /*!< in: block to be freed, must not be
 
63
                                        pointed to by the buffer pool */
 
64
        ulint           i)              /*!< in: index of buf_pool->zip_free[],
 
65
                                        or BUF_BUDDY_SIZES */
 
66
        __attribute__((nonnull));
 
67
 
 
68
/**********************************************************************//**
 
69
Get the index of buf_pool->zip_free[] for a given block size.
 
70
@return index of buf_pool->zip_free[], or BUF_BUDDY_SIZES */
 
71
UNIV_INLINE
 
72
ulint
 
73
buf_buddy_get_slot(
 
74
/*===============*/
 
75
        ulint   size)   /*!< in: block size */
 
76
{
 
77
        ulint   i;
 
78
        ulint   s;
 
79
 
 
80
        for (i = 0, s = BUF_BUDDY_LOW; s < size; i++, s <<= 1) {
 
81
        }
 
82
 
 
83
        ut_ad(i <= BUF_BUDDY_SIZES);
 
84
        return(i);
 
85
}
 
86
 
 
87
/**********************************************************************//**
 
88
Allocate a block.  The thread calling this function must hold
 
89
buf_pool->mutex and must not hold buf_pool->zip_mutex or any
 
90
block->mutex.  The buf_pool->mutex may only be released and reacquired
 
91
if lru != NULL.  This function should only be used for allocating
 
92
compressed page frames or control blocks (buf_page_t).  Allocated
 
93
control blocks must be properly initialized immediately after
 
94
buf_buddy_alloc() has returned the memory, before releasing
 
95
buf_pool->mutex.
 
96
@return allocated block, possibly NULL if lru == NULL */
 
97
UNIV_INLINE
 
98
void*
 
99
buf_buddy_alloc(
 
100
/*============*/
 
101
        buf_pool_t*     buf_pool,       /*!< in: buffer pool in which
 
102
                                        the page resides */
 
103
        ulint           size,           /*!< in: block size, up to
 
104
                                        UNIV_PAGE_SIZE */
 
105
        ibool*          lru)            /*!< in: pointer to a variable
 
106
                                        that will be assigned TRUE if
 
107
                                        storage was allocated from the
 
108
                                        LRU list and buf_pool->mutex was
 
109
                                        temporarily released, or NULL if
 
110
                                        the LRU list should not be used */
 
111
{
 
112
        ut_ad(buf_pool_mutex_own(buf_pool));
 
113
 
 
114
        return(buf_buddy_alloc_low(buf_pool, buf_buddy_get_slot(size), lru));
 
115
}
 
116
 
 
117
/**********************************************************************//**
 
118
Deallocate a block. */
 
119
UNIV_INLINE
 
120
void
 
121
buf_buddy_free(
 
122
/*===========*/
 
123
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
 
124
        void*           buf,            /*!< in: block to be freed, must not be
 
125
                                        pointed to by the buffer pool */
 
126
        ulint           size)           /*!< in: block size, up to
 
127
                                        UNIV_PAGE_SIZE */
 
128
{
 
129
        ut_ad(buf_pool_mutex_own(buf_pool));
 
130
 
 
131
        buf_buddy_free_low(buf_pool, buf, buf_buddy_get_slot(size));
 
132
}
 
133
 
 
134
#ifdef UNIV_MATERIALIZE
 
135
# undef UNIV_INLINE
 
136
# define UNIV_INLINE    UNIV_INLINE_ORIGINAL
 
137
#endif