← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_alloc.c

  • Committer: Brian Aker
  • Date: 2008-07-01 07:17:30 UTC
  • Revision ID: brian@tangent.org-20080701071730-y843dzfwz1nbca79
More mysys removal

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_alloc.c
15
15
 
16
16
/* Routines to handle mallocing of results which will be freed the same time */
17
17
 
18
 
#include "mysys/mysys_priv.h"
19
 
#include <mystrings/m_string.h>
20
 
 
21
 
#include <algorithm>
22
 
 
23
 
using namespace std;
 
18
#include <my_global.h>
 
19
#include <my_sys.h>
 
20
#include <m_string.h>
 
21
#undef EXTRA_DEBUG
 
22
#define EXTRA_DEBUG
 
23
 
24
24
 
25
25
/*
26
26
  Initialize memory root
44
44
*/
45
45
 
46
46
void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
47
 
                     size_t )
 
47
                     size_t pre_alloc_size __attribute__((unused)))
48
48
{
 
49
  DBUG_ENTER("init_alloc_root");
 
50
  DBUG_PRINT("enter",("root: 0x%lx", (long) mem_root));
 
51
 
49
52
  mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
50
53
  mem_root->min_malloc= 32;
51
54
  mem_root->block_size= block_size - ALLOC_ROOT_MIN_BLOCK_SIZE;
53
56
  mem_root->block_num= 4;                       /* We shift this with >>2 */
54
57
  mem_root->first_block_usage= 0;
55
58
 
56
 
  return;
 
59
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
 
60
  if (pre_alloc_size)
 
61
  {
 
62
    if ((mem_root->free= mem_root->pre_alloc=
 
63
         (USED_MEM*) my_malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(USED_MEM)),
 
64
                               MYF(0))))
 
65
    {
 
66
      mem_root->free->size= pre_alloc_size+ALIGN_SIZE(sizeof(USED_MEM));
 
67
      mem_root->free->left= pre_alloc_size;
 
68
      mem_root->free->next= 0;
 
69
    }
 
70
  }
 
71
#endif
 
72
  DBUG_VOID_RETURN;
57
73
}
58
74
 
59
75
 
75
91
*/
76
92
 
77
93
void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
78
 
                         size_t pre_alloc_size)
 
94
                         size_t pre_alloc_size __attribute__((unused)))
79
95
{
80
 
  assert(alloc_root_inited(mem_root));
 
96
  DBUG_ASSERT(alloc_root_inited(mem_root));
81
97
 
82
98
  mem_root->block_size= block_size - ALLOC_ROOT_MIN_BLOCK_SIZE;
 
99
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
83
100
  if (pre_alloc_size)
84
101
  {
85
102
    size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
103
120
        {
104
121
          /* remove block from the list and free it */
105
122
          *prev= mem->next;
106
 
          free(mem);
 
123
          my_free(mem, MYF(0));
107
124
        }
108
125
        else
109
126
          prev= &mem->next;
110
127
      }
111
128
      /* Allocate new prealloc block and add it to the end of free list */
112
 
      if ((mem= (USED_MEM *) malloc(size)))
 
129
      if ((mem= (USED_MEM *) my_malloc(size, MYF(0))))
113
130
      {
114
 
        mem->size= size;
 
131
        mem->size= size; 
115
132
        mem->left= pre_alloc_size;
116
133
        mem->next= *prev;
117
 
        *prev= mem_root->pre_alloc= mem;
 
134
        *prev= mem_root->pre_alloc= mem; 
118
135
      }
119
136
      else
120
137
      {
123
140
    }
124
141
  }
125
142
  else
126
 
  {
 
143
#endif
127
144
    mem_root->pre_alloc= 0;
128
 
  }
129
145
}
130
146
 
131
147
 
132
148
void *alloc_root(MEM_ROOT *mem_root, size_t length)
133
149
{
 
150
#if defined(HAVE_purify) && defined(EXTRA_DEBUG)
 
151
  register USED_MEM *next;
 
152
  DBUG_ENTER("alloc_root");
 
153
  DBUG_PRINT("enter",("root: 0x%lx", (long) mem_root));
 
154
 
 
155
  DBUG_ASSERT(alloc_root_inited(mem_root));
 
156
 
 
157
  length+=ALIGN_SIZE(sizeof(USED_MEM));
 
158
  if (!(next = (USED_MEM*) my_malloc(length,MYF(MY_WME | ME_FATALERROR))))
 
159
  {
 
160
    if (mem_root->error_handler)
 
161
      (*mem_root->error_handler)();
 
162
    DBUG_RETURN((uchar*) 0);                    /* purecov: inspected */
 
163
  }
 
164
  next->next= mem_root->used;
 
165
  next->size= length;
 
166
  mem_root->used= next;
 
167
  DBUG_PRINT("exit",("ptr: 0x%lx", (long) (((char*) next)+
 
168
                                           ALIGN_SIZE(sizeof(USED_MEM)))));
 
169
  DBUG_RETURN((uchar*) (((char*) next)+ALIGN_SIZE(sizeof(USED_MEM))));
 
170
#else
134
171
  size_t get_size, block_size;
135
 
  unsigned char* point;
 
172
  uchar* point;
136
173
  register USED_MEM *next= 0;
137
174
  register USED_MEM **prev;
138
 
  assert(alloc_root_inited(mem_root));
 
175
  DBUG_ENTER("alloc_root");
 
176
  DBUG_PRINT("enter",("root: 0x%lx", (long) mem_root));
 
177
  DBUG_ASSERT(alloc_root_inited(mem_root));
139
178
 
140
179
  length= ALIGN_SIZE(length);
141
180
  if ((*(prev= &mem_root->free)) != NULL)
159
198
    get_size= length+ALIGN_SIZE(sizeof(USED_MEM));
160
199
    get_size= max(get_size, block_size);
161
200
 
162
 
    if (!(next = (USED_MEM*) malloc(get_size)))
 
201
    if (!(next = (USED_MEM*) my_malloc(get_size,MYF(MY_WME | ME_FATALERROR))))
163
202
    {
164
203
      if (mem_root->error_handler)
165
204
        (*mem_root->error_handler)();
166
 
      return((void*) 0);                      /* purecov: inspected */
 
205
      DBUG_RETURN((void*) 0);                      /* purecov: inspected */
167
206
    }
168
207
    mem_root->block_num++;
169
208
    next->next= *prev;
172
211
    *prev=next;
173
212
  }
174
213
 
175
 
  point= (unsigned char*) ((char*) next+ (next->size-next->left));
 
214
  point= (uchar*) ((char*) next+ (next->size-next->left));
176
215
  /*TODO: next part may be unneded due to mem_root->first_block_usage counter*/
177
216
  if ((next->left-= length) < mem_root->min_malloc)
178
217
  {                                             /* Full block */
181
220
    mem_root->used= next;
182
221
    mem_root->first_block_usage= 0;
183
222
  }
184
 
  return((void*) point);
 
223
  DBUG_PRINT("exit",("ptr: 0x%lx", (ulong) point));
 
224
  DBUG_RETURN((void*) point);
 
225
#endif
185
226
}
186
227
 
187
228
 
209
250
  va_list args;
210
251
  char **ptr, *start, *res;
211
252
  size_t tot_length, length;
 
253
  DBUG_ENTER("multi_alloc_root");
212
254
 
213
255
  va_start(args, root);
214
256
  tot_length= 0;
220
262
  va_end(args);
221
263
 
222
264
  if (!(start= (char*) alloc_root(root, tot_length)))
223
 
    return(0);                            /* purecov: inspected */
 
265
    DBUG_RETURN(0);                            /* purecov: inspected */
224
266
 
225
267
  va_start(args, root);
226
268
  res= start;
231
273
    res+= ALIGN_SIZE(length);
232
274
  }
233
275
  va_end(args);
234
 
  return((void*) start);
 
276
  DBUG_RETURN((void*) start);
235
277
}
236
278
 
237
279
#define TRASH_MEM(X) TRASH(((char*)(X) + ((X)->size-(X)->left)), (X)->left)
282
324
 
283
325
  NOTES
284
326
    One can call this function either with root block initialised with
285
 
    init_alloc_root() or with a zero:ed block.
 
327
    init_alloc_root() or with a bzero()-ed block.
286
328
    It's also safe to call this multiple times with the same mem_root.
287
329
*/
288
330
 
289
331
void free_root(MEM_ROOT *root, myf MyFlags)
290
332
{
291
333
  register USED_MEM *next,*old;
 
334
  DBUG_ENTER("free_root");
 
335
  DBUG_PRINT("enter",("root: 0x%lx  flags: %u", (long) root, (uint) MyFlags));
292
336
 
293
337
  if (MyFlags & MY_MARK_BLOCKS_FREE)
294
338
  {
295
339
    mark_blocks_free(root);
296
 
    return;
 
340
    DBUG_VOID_RETURN;
297
341
  }
298
342
  if (!(MyFlags & MY_KEEP_PREALLOC))
299
343
    root->pre_alloc=0;
302
346
  {
303
347
    old=next; next= next->next ;
304
348
    if (old != root->pre_alloc)
305
 
      free(old);
 
349
      my_free(old,MYF(0));
306
350
  }
307
351
  for (next=root->free ; next ;)
308
352
  {
309
353
    old=next; next= next->next;
310
354
    if (old != root->pre_alloc)
311
 
      free(old);
 
355
      my_free(old,MYF(0));
312
356
  }
313
357
  root->used=root->free=0;
314
358
  if (root->pre_alloc)
320
364
  }
321
365
  root->block_num= 4;
322
366
  root->first_block_usage= 0;
323
 
  return;
 
367
  DBUG_VOID_RETURN;
324
368
}
325
369
 
326
370
/*
358
402
char *strmake_root(MEM_ROOT *root, const char *str, size_t len)
359
403
{
360
404
  char *pos;
361
 
  if ((pos=(char *)alloc_root(root,len+1)))
 
405
  if ((pos=alloc_root(root,len+1)))
362
406
  {
363
407
    memcpy(pos,str,len);
364
408
    pos[len]=0;
369
413
 
370
414
void *memdup_root(MEM_ROOT *root, const void *str, size_t len)
371
415
{
372
 
  void *pos;
 
416
  char *pos;
373
417
  if ((pos=alloc_root(root,len)))
374
418
    memcpy(pos,str,len);
375
419
  return pos;