← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/mem0pool.h

  • Committer: Jay Pipes
  • Date: 2009-02-21 16:00:06 UTC
  • mto: (907.1.1 trunk-with-temporal)
  • mto: This revision was merged to the branch mainline in revision 908.
  • Revision ID: jpipes@serialcoder-20090221160006-vnk3wt4qbcz62eru
Removes the TIME column type and related time functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/mem0pool.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1994, 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., 59 Temple
15
 
Place, Suite 330, Boston, MA 02111-1307 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/mem0pool.h
 
1
/******************************************************
21
2
The lowest-level memory management
22
3
 
 
4
(c) 1994, 1995 Innobase Oy
 
5
 
23
6
Created 6/9/1994 Heikki Tuuri
24
7
*******************************************************/
25
8
 
30
13
#include "os0file.h"
31
14
#include "ut0lst.h"
32
15
 
33
 
/** Memory area header */
34
16
typedef struct mem_area_struct  mem_area_t;
35
 
/** Memory pool */
36
17
typedef struct mem_pool_struct  mem_pool_t;
37
18
 
38
 
/** The common memory pool */
 
19
/* The common memory pool */
39
20
extern mem_pool_t*      mem_comm_pool;
40
21
 
41
 
/** Memory area header */
 
22
/* Memory area header */
42
23
 
43
24
struct mem_area_struct{
44
 
        ulint           size_and_free;  /*!< memory area size is obtained by
 
25
        ulint           size_and_free;  /* memory area size is obtained by
45
26
                                        anding with ~MEM_AREA_FREE; area in
46
27
                                        a free list if ANDing with
47
28
                                        MEM_AREA_FREE results in nonzero */
48
29
        UT_LIST_NODE_T(mem_area_t)
49
 
                        free_list;      /*!< free list node */
 
30
                        free_list;      /* free list node */
50
31
};
51
32
 
52
 
/** Each memory area takes this many extra bytes for control information */
 
33
/* Each memory area takes this many extra bytes for control information */
53
34
#define MEM_AREA_EXTRA_SIZE     (ut_calc_align(sizeof(struct mem_area_struct),\
54
35
                        UNIV_MEM_ALIGNMENT))
55
36
 
56
 
/********************************************************************//**
57
 
Creates a memory pool.
58
 
@return memory pool */
 
37
/************************************************************************
 
38
Creates a memory pool. */
59
39
UNIV_INTERN
60
40
mem_pool_t*
61
41
mem_pool_create(
62
42
/*============*/
63
 
        ulint   size);  /*!< in: pool size in bytes */
64
 
/********************************************************************//**
 
43
                        /* out: memory pool */
 
44
        ulint   size);  /* in: pool size in bytes */
 
45
/************************************************************************
65
46
Allocates memory from a pool. NOTE: This low-level function should only be
66
 
used in mem0mem.*!
67
 
@return own: allocated memory buffer */
 
47
used in mem0mem.*! */
68
48
UNIV_INTERN
69
49
void*
70
50
mem_area_alloc(
71
51
/*===========*/
72
 
        ulint*          psize,  /*!< in: requested size in bytes; for optimum
 
52
                                /* out, own: allocated memory buffer */
 
53
        ulint*          psize,  /* in: requested size in bytes; for optimum
73
54
                                space usage, the size should be a power of 2
74
55
                                minus MEM_AREA_EXTRA_SIZE;
75
56
                                out: allocated size in bytes (greater than
76
57
                                or equal to the requested size) */
77
 
        mem_pool_t*     pool);  /*!< in: memory pool */
78
 
/********************************************************************//**
 
58
        mem_pool_t*     pool);  /* in: memory pool */
 
59
/************************************************************************
79
60
Frees memory to a pool. */
80
61
UNIV_INTERN
81
62
void
82
63
mem_area_free(
83
64
/*==========*/
84
 
        void*           ptr,    /*!< in, own: pointer to allocated memory
 
65
        void*           ptr,    /* in, own: pointer to allocated memory
85
66
                                buffer */
86
 
        mem_pool_t*     pool);  /*!< in: memory pool */
87
 
/********************************************************************//**
88
 
Returns the amount of reserved memory.
89
 
@return reserved mmeory in bytes */
 
67
        mem_pool_t*     pool);  /* in: memory pool */
 
68
/************************************************************************
 
69
Returns the amount of reserved memory. */
90
70
UNIV_INTERN
91
71
ulint
92
72
mem_pool_get_reserved(
93
73
/*==================*/
94
 
        mem_pool_t*     pool);  /*!< in: memory pool */
95
 
/********************************************************************//**
 
74
                                /* out: reserved mmeory in bytes */
 
75
        mem_pool_t*     pool);  /* in: memory pool */
 
76
/************************************************************************
96
77
Reserves the mem pool mutex. */
97
78
UNIV_INTERN
98
79
void
99
80
mem_pool_mutex_enter(void);
100
81
/*======================*/
101
 
/********************************************************************//**
 
82
/************************************************************************
102
83
Releases the mem pool mutex. */
103
84
UNIV_INTERN
104
85
void
105
86
mem_pool_mutex_exit(void);
106
87
/*=====================*/
107
 
/********************************************************************//**
108
 
Validates a memory pool.
109
 
@return TRUE if ok */
 
88
/************************************************************************
 
89
Validates a memory pool. */
110
90
UNIV_INTERN
111
91
ibool
112
92
mem_pool_validate(
113
93
/*==============*/
114
 
        mem_pool_t*     pool);  /*!< in: memory pool */
115
 
/********************************************************************//**
 
94
                                /* out: TRUE if ok */
 
95
        mem_pool_t*     pool);  /* in: memory pool */
 
96
/************************************************************************
116
97
Prints info of a memory pool. */
117
98
UNIV_INTERN
118
99
void
119
100
mem_pool_print_info(
120
101
/*================*/
121
 
        FILE*           outfile,/*!< in: output file to write to */
122
 
        mem_pool_t*     pool);  /*!< in: memory pool */
 
102
        FILE*           outfile,/* in: output file to write to */
 
103
        mem_pool_t*     pool);  /* in: memory pool */
123
104
 
124
105
 
125
106
#ifndef UNIV_NONINL