← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_alloc.h

  • Committer: Brian Aker
  • Date: 2009-10-15 00:22:33 UTC
  • mto: (1183.1.11 merge)
  • mto: This revision was merged to the branch mainline in revision 1198.
  • Revision ID: brian@gaz-20091015002233-fa4ao2mbc67wls91
First pass of information engine. OMG, ponies... is it so much easier to
deal with creating and engine.

The list table iterator though... its ass, needs to go. We should also
abstract out share. Very few engines need a custom one. Just say'in

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_alloc.h
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
/**
17
 
 * @file
18
 
 * @brief Memory root declarations
19
 
 */
20
 
 
21
 
#ifndef DRIZZLED_MEMORY_ROOT_H
22
 
#define DRIZZLED_MEMORY_ROOT_H
23
 
 
24
 
#include <cstddef>
25
 
 
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
/*
 
17
   Data structures for mysys/my_alloc.c (root memory allocator)
 
18
*/
 
19
 
 
20
#ifndef _my_alloc_h
 
21
#define _my_alloc_h
 
22
 
 
23
#include <stddef.h>
26
24
#include <drizzled/definitions.h>
27
25
 
28
 
namespace drizzled
29
 
{
30
 
 
31
 
/**
32
 
 * @namespace drizzled::memory
33
 
 * Memory allocation utils
34
 
 *
35
 
 * NB: This namespace documentation may not seem very useful, but without a
36
 
 * comment on the namespace Doxygen won't extract any documentation for
37
 
 * namespace members.
38
 
 */
39
 
namespace memory
40
 
{
41
 
 
42
 
static const int KEEP_PREALLOC= 1;
43
 
/* move used to free list and reuse them */
44
 
static const int MARK_BLOCKS_FREE= 2;
45
 
 
46
 
namespace internal
47
 
{
48
 
 
49
 
class UsedMemory
50
 
{                          /* struct for once_alloc (block) */
51
 
public:
52
 
  UsedMemory *next;        /* Next block in use */
53
 
  size_t left;             /* memory left in block  */            
54
 
  size_t size;             /* size of block */
55
 
};
56
 
 
57
 
}
58
 
 
59
 
static const size_t ROOT_MIN_BLOCK_SIZE= (MALLOC_OVERHEAD + sizeof(internal::UsedMemory) + 8);
60
 
 
61
 
 
62
 
 
63
 
class Root
64
 
{
65
 
public:
66
 
 
67
 
  Root() :
68
 
    free(0),
69
 
    used(0),
70
 
    pre_alloc(0),
71
 
    min_malloc(0),
72
 
    block_size(0),
73
 
    block_num(0),
74
 
    first_block_usage(0),
75
 
    error_handler(0)
76
 
  { }
77
 
 
78
 
  Root(size_t block_size_arg)
79
 
  {
80
 
    free= used= pre_alloc= 0;
81
 
    min_malloc= 32;
82
 
    block_size= block_size_arg - memory::ROOT_MIN_BLOCK_SIZE;
83
 
    block_num= 4;                       /* We shift this with >>2 */
84
 
    first_block_usage= 0;
85
 
    error_handler= 0;
86
 
  }
87
 
 
88
 
  ~Root();
89
 
 
90
 
  /**
91
 
   * blocks with free memory in it 
92
 
   */
93
 
  internal::UsedMemory *free;
94
 
 
95
 
  /**
96
 
   * blocks almost without free memory 
97
 
   */
98
 
  internal::UsedMemory *used;
99
 
 
100
 
  /**
101
 
   * preallocated block 
102
 
   */
103
 
  internal::UsedMemory *pre_alloc;
104
 
 
105
 
  /**
106
 
   * if block have less memory it will be put in 'used' list 
107
 
   */
 
26
#if defined(__cplusplus)
 
27
extern "C" {
 
28
#endif
 
29
 
 
30
#define ALLOC_MAX_BLOCK_TO_DROP                 4096
 
31
#define ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP       10
 
32
 
 
33
typedef struct st_used_mem
 
34
{                                  /* struct for once_alloc (block) */
 
35
  struct st_used_mem *next;        /* Next block in use */
 
36
  size_t left;                     /* memory left in block  */            
 
37
  size_t size;                     /* size of block */
 
38
} USED_MEM;
 
39
 
 
40
 
 
41
typedef struct st_mem_root
 
42
{
 
43
  USED_MEM *free;                  /* blocks with free memory in it */
 
44
  USED_MEM *used;                  /* blocks almost without free memory */
 
45
  USED_MEM *pre_alloc;             /* preallocated block */
 
46
  /* if block have less memory it will be put in 'used' list */
108
47
  size_t min_malloc;
109
 
 
110
 
  size_t block_size;         ///< initial block size
111
 
  unsigned int block_num;    ///< allocated blocks counter 
112
 
 
113
 
  /**
114
 
   * first free block in queue test counter (if it exceed
115
 
   * MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
116
 
   */
 
48
  size_t block_size;               /* initial block size */
 
49
  unsigned int block_num;          /* allocated blocks counter */
 
50
  /*
 
51
     first free block in queue test counter (if it exceed
 
52
     MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
 
53
  */
117
54
  unsigned int first_block_usage;
118
55
 
119
56
  void (*error_handler)(void);
120
 
  void reset_root_defaults(size_t block_size, size_t prealloc_size);
121
 
  void *alloc_root(size_t Size);
122
 
  void mark_blocks_free();
123
 
  void *memdup_root(const void *str, size_t len);
124
 
  char *strdup_root(const char *str);
125
 
  char *strmake_root(const char *str,size_t len);
126
 
  void init_alloc_root(size_t block_size= ROOT_MIN_BLOCK_SIZE);
127
 
 
128
 
  inline bool alloc_root_inited()
129
 
  {
130
 
    return min_malloc != 0;
131
 
  }
132
 
  void free_root(myf MyFLAGS);
133
 
  void *multi_alloc_root(int unused, ...);
134
 
};
135
 
 
136
 
} /* namespace memory */
137
 
} /* namespace drizzled */
138
 
 
139
 
#endif /* DRIZZLED_MEMORY_ROOT_H */
 
57
} MEM_ROOT;
 
58
 
 
59
void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
 
60
                     size_t pre_alloc_size);
 
61
void *alloc_root(MEM_ROOT *mem_root, size_t Size);
 
62
void *multi_alloc_root(MEM_ROOT *mem_root, ...);
 
63
void free_root(MEM_ROOT *root, myf MyFLAGS);
 
64
void set_prealloc_root(MEM_ROOT *root, char *ptr);
 
65
void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
 
66
                         size_t prealloc_size);
 
67
char *strdup_root(MEM_ROOT *root,const char *str);
 
68
char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
 
69
void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
 
70
 
 
71
#if defined(__cplusplus)
 
72
}
 
73
#endif
 
74
#endif