← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/mem0mem.h
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (C) 1994, 2010, 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/mem0mem.h
 
21
The memory management
 
22
 
 
23
Created 6/9/1994 Heikki Tuuri
 
24
*******************************************************/
 
25
 
 
26
#ifndef mem0mem_h
 
27
#define mem0mem_h
 
28
 
 
29
#include "univ.i"
 
30
#include "ut0mem.h"
 
31
#include "ut0byte.h"
 
32
#include "ut0rnd.h"
 
33
#ifndef UNIV_HOTBACKUP
 
34
# include "sync0sync.h"
 
35
#endif /* UNIV_HOTBACKUP */
 
36
#include "ut0lst.h"
 
37
#include "mach0data.h"
 
38
 
 
39
/* -------------------- MEMORY HEAPS ----------------------------- */
 
40
 
 
41
/* The info structure stored at the beginning of a heap block */
 
42
typedef struct mem_block_info_struct mem_block_info_t;
 
43
 
 
44
/* A block of a memory heap consists of the info structure
 
45
followed by an area of memory */
 
46
typedef mem_block_info_t        mem_block_t;
 
47
 
 
48
/* A memory heap is a nonempty linear list of memory blocks */
 
49
typedef mem_block_t     mem_heap_t;
 
50
 
 
51
/* Types of allocation for memory heaps: DYNAMIC means allocation from the
 
52
dynamic memory pool of the C compiler, BUFFER means allocation from the
 
53
buffer pool; the latter method is used for very big heaps */
 
54
 
 
55
#define MEM_HEAP_DYNAMIC        0       /* the most common type */
 
56
#define MEM_HEAP_BUFFER         1
 
57
#define MEM_HEAP_BTR_SEARCH     2       /* this flag can optionally be
 
58
                                        ORed to MEM_HEAP_BUFFER, in which
 
59
                                        case heap->free_block is used in
 
60
                                        some cases for memory allocations,
 
61
                                        and if NULL, the memory
 
62
                                        allocation functions can return
 
63
                                        NULL. */
 
64
 
 
65
/* The following start size is used for the first block in the memory heap if
 
66
the size is not specified, i.e., 0 is given as the parameter in the call of
 
67
create. The standard size is the maximum (payload) size of the blocks used for
 
68
allocations of small buffers. */
 
69
 
 
70
#define MEM_BLOCK_START_SIZE            64
 
71
#define MEM_BLOCK_STANDARD_SIZE         \
 
72
        (UNIV_PAGE_SIZE >= 16384 ? 8000 : MEM_MAX_ALLOC_IN_BUF)
 
73
 
 
74
/* If a memory heap is allowed to grow into the buffer pool, the following
 
75
is the maximum size for a single allocated buffer: */
 
76
#define MEM_MAX_ALLOC_IN_BUF            (UNIV_PAGE_SIZE - 200)
 
77
 
 
78
/******************************************************************//**
 
79
Initializes the memory system. */
 
80
UNIV_INTERN
 
81
void
 
82
mem_init(
 
83
/*=====*/
 
84
        ulint   size);  /*!< in: common pool size in bytes */
 
85
/******************************************************************//**
 
86
Closes the memory system. */
 
87
UNIV_INTERN
 
88
void
 
89
mem_close(void);
 
90
/*===========*/
 
91
 
 
92
/**************************************************************//**
 
93
Use this macro instead of the corresponding function! Macro for memory
 
94
heap creation. */
 
95
 
 
96
#define mem_heap_create(N)      mem_heap_create_func(\
 
97
                (N), MEM_HEAP_DYNAMIC, __FILE__, __LINE__)
 
98
/**************************************************************//**
 
99
Use this macro instead of the corresponding function! Macro for memory
 
100
heap creation. */
 
101
 
 
102
#define mem_heap_create_in_buffer(N)    mem_heap_create_func(\
 
103
                (N), MEM_HEAP_BUFFER, __FILE__, __LINE__)
 
104
/**************************************************************//**
 
105
Use this macro instead of the corresponding function! Macro for memory
 
106
heap creation. */
 
107
 
 
108
#define mem_heap_create_in_btr_search(N)        mem_heap_create_func(\
 
109
                (N), MEM_HEAP_BTR_SEARCH | MEM_HEAP_BUFFER,\
 
110
                __FILE__, __LINE__)
 
111
 
 
112
/**************************************************************//**
 
113
Use this macro instead of the corresponding function! Macro for memory
 
114
heap freeing. */
 
115
 
 
116
#define mem_heap_free(heap) mem_heap_free_func(\
 
117
                                          (heap), __FILE__, __LINE__)
 
118
/*****************************************************************//**
 
119
NOTE: Use the corresponding macros instead of this function. Creates a
 
120
memory heap. For debugging purposes, takes also the file name and line as
 
121
arguments.
 
122
@return own: memory heap, NULL if did not succeed (only possible for
 
123
MEM_HEAP_BTR_SEARCH type heaps) */
 
124
UNIV_INLINE
 
125
mem_heap_t*
 
126
mem_heap_create_func(
 
127
/*=================*/
 
128
        ulint           n,              /*!< in: desired start block size,
 
129
                                        this means that a single user buffer
 
130
                                        of size n will fit in the block,
 
131
                                        0 creates a default size block */
 
132
        ulint           type,           /*!< in: heap type */
 
133
        const char*     file_name,      /*!< in: file name where created */
 
134
        ulint           line);          /*!< in: line where created */
 
135
/*****************************************************************//**
 
136
NOTE: Use the corresponding macro instead of this function. Frees the space
 
137
occupied by a memory heap. In the debug version erases the heap memory
 
138
blocks. */
 
139
UNIV_INLINE
 
140
void
 
141
mem_heap_free_func(
 
142
/*===============*/
 
143
        mem_heap_t*     heap,           /*!< in, own: heap to be freed */
 
144
        const char*     file_name,      /*!< in: file name where freed */
 
145
        ulint           line);          /*!< in: line where freed */
 
146
/***************************************************************//**
 
147
Allocates and zero-fills n bytes of memory from a memory heap.
 
148
@return allocated, zero-filled storage */
 
149
UNIV_INLINE
 
150
void*
 
151
mem_heap_zalloc(
 
152
/*============*/
 
153
        mem_heap_t*     heap,   /*!< in: memory heap */
 
154
        ulint           n);     /*!< in: number of bytes; if the heap is allowed
 
155
                                to grow into the buffer pool, this must be
 
156
                                <= MEM_MAX_ALLOC_IN_BUF */
 
157
/***************************************************************//**
 
158
Allocates n bytes of memory from a memory heap.
 
159
@return allocated storage, NULL if did not succeed (only possible for
 
160
MEM_HEAP_BTR_SEARCH type heaps) */
 
161
UNIV_INLINE
 
162
void*
 
163
mem_heap_alloc(
 
164
/*===========*/
 
165
        mem_heap_t*     heap,   /*!< in: memory heap */
 
166
        ulint           n);     /*!< in: number of bytes; if the heap is allowed
 
167
                                to grow into the buffer pool, this must be
 
168
                                <= MEM_MAX_ALLOC_IN_BUF */
 
169
/*****************************************************************//**
 
170
Returns a pointer to the heap top.
 
171
@return pointer to the heap top */
 
172
UNIV_INLINE
 
173
byte*
 
174
mem_heap_get_heap_top(
 
175
/*==================*/
 
176
        mem_heap_t*     heap);  /*!< in: memory heap */
 
177
/*****************************************************************//**
 
178
Frees the space in a memory heap exceeding the pointer given. The
 
179
pointer must have been acquired from mem_heap_get_heap_top. The first
 
180
memory block of the heap is not freed. */
 
181
UNIV_INLINE
 
182
void
 
183
mem_heap_free_heap_top(
 
184
/*===================*/
 
185
        mem_heap_t*     heap,   /*!< in: heap from which to free */
 
186
        byte*           old_top);/*!< in: pointer to old top of heap */
 
187
/*****************************************************************//**
 
188
Empties a memory heap. The first memory block of the heap is not freed. */
 
189
UNIV_INLINE
 
190
void
 
191
mem_heap_empty(
 
192
/*===========*/
 
193
        mem_heap_t*     heap);  /*!< in: heap to empty */
 
194
/*****************************************************************//**
 
195
Returns a pointer to the topmost element in a memory heap.
 
196
The size of the element must be given.
 
197
@return pointer to the topmost element */
 
198
UNIV_INLINE
 
199
void*
 
200
mem_heap_get_top(
 
201
/*=============*/
 
202
        mem_heap_t*     heap,   /*!< in: memory heap */
 
203
        ulint           n);     /*!< in: size of the topmost element */
 
204
/*****************************************************************//**
 
205
Frees the topmost element in a memory heap.
 
206
The size of the element must be given. */
 
207
UNIV_INLINE
 
208
void
 
209
mem_heap_free_top(
 
210
/*==============*/
 
211
        mem_heap_t*     heap,   /*!< in: memory heap */
 
212
        ulint           n);     /*!< in: size of the topmost element */
 
213
/*****************************************************************//**
 
214
Returns the space in bytes occupied by a memory heap. */
 
215
UNIV_INLINE
 
216
ulint
 
217
mem_heap_get_size(
 
218
/*==============*/
 
219
        mem_heap_t*     heap);          /*!< in: heap */
 
220
/**************************************************************//**
 
221
Use this macro instead of the corresponding function!
 
222
Macro for memory buffer allocation */
 
223
 
 
224
#define mem_zalloc(N)   memset(mem_alloc(N), 0, (N));
 
225
 
 
226
#define mem_alloc(N)    mem_alloc_func((N), NULL, __FILE__, __LINE__)
 
227
#define mem_alloc2(N,S) mem_alloc_func((N), (S), __FILE__, __LINE__)
 
228
/***************************************************************//**
 
229
NOTE: Use the corresponding macro instead of this function.
 
230
Allocates a single buffer of memory from the dynamic memory of
 
231
the C compiler. Is like malloc of C. The buffer must be freed
 
232
with mem_free.
 
233
@return own: free storage */
 
234
UNIV_INLINE
 
235
void*
 
236
mem_alloc_func(
 
237
/*===========*/
 
238
        ulint           n,              /*!< in: requested size in bytes */
 
239
        ulint*          size,           /*!< out: allocated size in bytes,
 
240
                                        or NULL */
 
241
        const char*     file_name,      /*!< in: file name where created */
 
242
        ulint           line);          /*!< in: line where created */
 
243
 
 
244
/**************************************************************//**
 
245
Use this macro instead of the corresponding function!
 
246
Macro for memory buffer freeing */
 
247
 
 
248
#define mem_free(PTR)   mem_free_func((PTR), __FILE__, __LINE__)
 
249
/***************************************************************//**
 
250
NOTE: Use the corresponding macro instead of this function.
 
251
Frees a single buffer of storage from
 
252
the dynamic memory of C compiler. Similar to free of C. */
 
253
UNIV_INLINE
 
254
void
 
255
mem_free_func(
 
256
/*==========*/
 
257
        void*           ptr,            /*!< in, own: buffer to be freed */
 
258
        const char*     file_name,      /*!< in: file name where created */
 
259
        ulint           line);          /*!< in: line where created */
 
260
 
 
261
/**********************************************************************//**
 
262
Duplicates a NUL-terminated string.
 
263
@return own: a copy of the string, must be deallocated with mem_free */
 
264
UNIV_INLINE
 
265
char*
 
266
mem_strdup(
 
267
/*=======*/
 
268
        const char*     str);   /*!< in: string to be copied */
 
269
/**********************************************************************//**
 
270
Makes a NUL-terminated copy of a nonterminated string.
 
271
@return own: a copy of the string, must be deallocated with mem_free */
 
272
UNIV_INLINE
 
273
char*
 
274
mem_strdupl(
 
275
/*========*/
 
276
        const char*     str,    /*!< in: string to be copied */
 
277
        ulint           len);   /*!< in: length of str, in bytes */
 
278
 
 
279
/**********************************************************************//**
 
280
Duplicates a NUL-terminated string, allocated from a memory heap.
 
281
@return own: a copy of the string */
 
282
UNIV_INTERN
 
283
char*
 
284
mem_heap_strdup(
 
285
/*============*/
 
286
        mem_heap_t*     heap,   /*!< in: memory heap where string is allocated */
 
287
        const char*     str);   /*!< in: string to be copied */
 
288
/**********************************************************************//**
 
289
Makes a NUL-terminated copy of a nonterminated string,
 
290
allocated from a memory heap.
 
291
@return own: a copy of the string */
 
292
UNIV_INLINE
 
293
char*
 
294
mem_heap_strdupl(
 
295
/*=============*/
 
296
        mem_heap_t*     heap,   /*!< in: memory heap where string is allocated */
 
297
        const char*     str,    /*!< in: string to be copied */
 
298
        ulint           len);   /*!< in: length of str, in bytes */
 
299
 
 
300
/**********************************************************************//**
 
301
Concatenate two strings and return the result, using a memory heap.
 
302
@return own: the result */
 
303
UNIV_INTERN
 
304
char*
 
305
mem_heap_strcat(
 
306
/*============*/
 
307
        mem_heap_t*     heap,   /*!< in: memory heap where string is allocated */
 
308
        const char*     s1,     /*!< in: string 1 */
 
309
        const char*     s2);    /*!< in: string 2 */
 
310
 
 
311
/**********************************************************************//**
 
312
Duplicate a block of data, allocated from a memory heap.
 
313
@return own: a copy of the data */
 
314
UNIV_INTERN
 
315
void*
 
316
mem_heap_dup(
 
317
/*=========*/
 
318
        mem_heap_t*     heap,   /*!< in: memory heap where copy is allocated */
 
319
        const void*     data,   /*!< in: data to be copied */
 
320
        ulint           len);   /*!< in: length of data, in bytes */
 
321
 
 
322
/****************************************************************//**
 
323
A simple (s)printf replacement that dynamically allocates the space for the
 
324
formatted string from the given heap. This supports a very limited set of
 
325
the printf syntax: types 's' and 'u' and length modifier 'l' (which is
 
326
required for the 'u' type).
 
327
@return heap-allocated formatted string */
 
328
UNIV_INTERN
 
329
char*
 
330
mem_heap_printf(
 
331
/*============*/
 
332
        mem_heap_t*     heap,   /*!< in: memory heap */
 
333
        const char*     format, /*!< in: format string */
 
334
        ...) __attribute__ ((format (printf, 2, 3)));
 
335
 
 
336
#ifdef MEM_PERIODIC_CHECK
 
337
/******************************************************************//**
 
338
Goes through the list of all allocated mem blocks, checks their magic
 
339
numbers, and reports possible corruption. */
 
340
UNIV_INTERN
 
341
void
 
342
mem_validate_all_blocks(void);
 
343
/*=========================*/
 
344
#endif
 
345
 
 
346
/*#######################################################################*/
 
347
 
 
348
/* The info header of a block in a memory heap */
 
349
 
 
350
struct mem_block_info_struct {
 
351
        ulint   magic_n;/* magic number for debugging */
 
352
        char    file_name[8];/* file name where the mem heap was created */
 
353
        ulint   line;   /*!< line number where the mem heap was created */
 
354
        UT_LIST_BASE_NODE_T(mem_block_t) base; /* In the first block in the
 
355
                        the list this is the base node of the list of blocks;
 
356
                        in subsequent blocks this is undefined */
 
357
        UT_LIST_NODE_T(mem_block_t) list; /* This contains pointers to next
 
358
                        and prev in the list. The first block allocated
 
359
                        to the heap is also the first block in this list,
 
360
                        though it also contains the base node of the list. */
 
361
        ulint   len;    /*!< physical length of this block in bytes */
 
362
        ulint   total_size; /*!< physical length in bytes of all blocks
 
363
                        in the heap. This is defined only in the base
 
364
                        node and is set to ULINT_UNDEFINED in others. */
 
365
        ulint   type;   /*!< type of heap: MEM_HEAP_DYNAMIC, or
 
366
                        MEM_HEAP_BUF possibly ORed to MEM_HEAP_BTR_SEARCH */
 
367
        ulint   free;   /*!< offset in bytes of the first free position for
 
368
                        user data in the block */
 
369
        ulint   start;  /*!< the value of the struct field 'free' at the
 
370
                        creation of the block */
 
371
#ifndef UNIV_HOTBACKUP
 
372
        void*   free_block;
 
373
                        /* if the MEM_HEAP_BTR_SEARCH bit is set in type,
 
374
                        and this is the heap root, this can contain an
 
375
                        allocated buffer frame, which can be appended as a
 
376
                        free block to the heap, if we need more space;
 
377
                        otherwise, this is NULL */
 
378
        void*   buf_block;
 
379
                        /* if this block has been allocated from the buffer
 
380
                        pool, this contains the buf_block_t handle;
 
381
                        otherwise, this is NULL */
 
382
#endif /* !UNIV_HOTBACKUP */
 
383
#ifdef MEM_PERIODIC_CHECK
 
384
        UT_LIST_NODE_T(mem_block_t) mem_block_list;
 
385
                        /* List of all mem blocks allocated; protected
 
386
                        by the mem_comm_pool mutex */
 
387
#endif
 
388
};
 
389
 
 
390
#define MEM_BLOCK_MAGIC_N       764741555
 
391
#define MEM_FREED_BLOCK_MAGIC_N 547711122
 
392
 
 
393
/* Header size for a memory heap block */
 
394
#define MEM_BLOCK_HEADER_SIZE   ut_calc_align(sizeof(mem_block_info_t),\
 
395
                                                        UNIV_MEM_ALIGNMENT)
 
396
#include "mem0dbg.h"
 
397
 
 
398
#ifndef UNIV_NONINL
 
399
#include "mem0mem.ic"
 
400
#endif
 
401
 
 
402
#endif