← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/memory/root.h

  • Committer: Brian Aker
  • Date: 2010-02-07 01:33:54 UTC
  • Revision ID: brian@gaz-20100207013354-d2pg1n68u5c09pgo
Remove giant include header to its own file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/memory/root.h
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
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
 
#define ALLOC_MAX_BLOCK_TO_DROP                 4096
24
 
#define ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP       10
25
 
 
26
 
typedef struct st_used_mem
27
 
{                                  /* struct for once_alloc (block) */
28
 
  struct st_used_mem *next;        /* Next block in use */
29
 
  unsigned int  left;              /* memory left in block  */
30
 
  unsigned int  size;              /* size of block */
31
 
} USED_MEM;
32
 
 
33
 
 
34
 
typedef struct st_mem_root
35
 
{
36
 
  USED_MEM *free;                  /* blocks with free memory in it */
37
 
  USED_MEM *used;                  /* blocks almost without free memory */
38
 
  USED_MEM *pre_alloc;             /* preallocated block */
 
16
 
 
17
#ifndef DRIZZLED_MEMORY_ROOT_H
 
18
#define DRIZZLED_MEMORY_ROOT_H
 
19
 
 
20
#include <cstddef>
 
21
 
 
22
#include <drizzled/definitions.h>
 
23
 
 
24
namespace drizzled
 
25
{
 
26
namespace memory
 
27
{
 
28
 
 
29
static const int KEEP_PREALLOC= 1;
 
30
/* move used to free list and reuse them */
 
31
static const int MARK_BLOCKS_FREE= 2;
 
32
 
 
33
namespace internal
 
34
{
 
35
 
 
36
class UsedMemory
 
37
{                          /* struct for once_alloc (block) */
 
38
public:
 
39
  UsedMemory *next;        /* Next block in use */
 
40
  size_t left;             /* memory left in block  */            
 
41
  size_t size;             /* size of block */
 
42
};
 
43
 
 
44
}
 
45
 
 
46
static const size_t ROOT_MIN_BLOCK_SIZE= (MALLOC_OVERHEAD + sizeof(internal::UsedMemory) + 8);
 
47
 
 
48
 
 
49
 
 
50
class Root
 
51
{
 
52
public:
 
53
  /* blocks with free memory in it */
 
54
  internal::UsedMemory *free;
 
55
 
 
56
  /* blocks almost without free memory */
 
57
  internal::UsedMemory *used;
 
58
 
 
59
  /* preallocated block */
 
60
  internal::UsedMemory *pre_alloc;
 
61
 
39
62
  /* if block have less memory it will be put in 'used' list */
40
63
  size_t min_malloc;
41
64
  size_t block_size;               /* initial block size */
42
65
  unsigned int block_num;          /* allocated blocks counter */
43
 
  /* 
44
 
     first free block in queue test counter (if it exceed 
 
66
  /*
 
67
     first free block in queue test counter (if it exceed
45
68
     MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
46
69
  */
47
70
  unsigned int first_block_usage;
48
71
 
49
72
  void (*error_handler)(void);
50
 
} MEM_ROOT;
51
 
#endif
 
73
};
 
74
 
 
75
inline static bool alloc_root_inited(Root *root)
 
76
{
 
77
  return root->min_malloc != 0;
 
78
}
 
79
 
 
80
void init_alloc_root(Root *mem_root,
 
81
                     size_t block_size= ROOT_MIN_BLOCK_SIZE);
 
82
void *alloc_root(Root *mem_root, size_t Size);
 
83
void *multi_alloc_root(Root *mem_root, ...);
 
84
void free_root(Root *root, myf MyFLAGS);
 
85
void set_prealloc_root(Root *root, char *ptr);
 
86
void reset_root_defaults(Root *mem_root, size_t block_size,
 
87
                         size_t prealloc_size);
 
88
char *strdup_root(Root *root,const char *str);
 
89
char *strmake_root(Root *root,const char *str,size_t len);
 
90
void *memdup_root(Root *root,const void *str, size_t len);
 
91
 
 
92
} /* namespace memory */
 
93
} /* namespace drizzled */
 
94
 
 
95
#endif /* DRIZZLED_MEMORY_ROOT_H */