← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/memory/root.cc

  • Committer: Brian Aker
  • Date: 2010-04-19 17:51:52 UTC
  • Revision ID: brian@gaz-20100419175152-lar9fncw9vhhav0d
Updates to confine memroot

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/memory/root.cc
59
59
  mem_root->error_handler= 0;
60
60
  mem_root->block_num= 4;                       /* We shift this with >>2 */
61
61
  mem_root->first_block_usage= 0;
62
 
 
63
 
  return;
64
62
}
65
63
 
66
64
 
79
77
 *                        must be equal to or greater than block size,
80
78
 *                        otherwise means 'no prealloc'.
81
79
 */
82
 
void memory::reset_root_defaults(memory::Root *mem_root, size_t block_size,
83
 
                                 size_t pre_alloc_size)
 
80
void memory::Root::reset_root_defaults(size_t block_size_arg, size_t pre_alloc_size)
84
81
{
85
 
  assert(alloc_root_inited(mem_root));
86
 
 
87
 
  mem_root->block_size= block_size - memory::ROOT_MIN_BLOCK_SIZE;
 
82
  block_size= block_size_arg - memory::ROOT_MIN_BLOCK_SIZE;
88
83
  if (pre_alloc_size)
89
84
  {
90
85
    size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(memory::internal::UsedMemory));
91
 
    if (!mem_root->pre_alloc || mem_root->pre_alloc->size != size)
 
86
    if (not pre_alloc || pre_alloc->size != size)
92
87
    {
93
 
      memory::internal::UsedMemory *mem, **prev= &mem_root->free;
 
88
      memory::internal::UsedMemory *mem, **prev= &this->free;
94
89
      /*
95
90
        Free unused blocks, so that consequent calls
96
91
        to reset_root_defaults won't eat away memory.
101
96
        if (mem->size == size)
102
97
        {
103
98
          /* We found a suitable block, no need to do anything else */
104
 
          mem_root->pre_alloc= mem;
 
99
          pre_alloc= mem;
105
100
          return;
106
101
        }
107
102
        if (mem->left + ALIGN_SIZE(sizeof(memory::internal::UsedMemory)) == mem->size)
108
103
        {
109
104
          /* remove block from the list and free it */
110
105
          *prev= mem->next;
111
 
          free(mem);
 
106
          std::free(mem);
112
107
        }
113
108
        else
114
109
          prev= &mem->next;
119
114
        mem->size= size;
120
115
        mem->left= pre_alloc_size;
121
116
        mem->next= *prev;
122
 
        *prev= mem_root->pre_alloc= mem;
 
117
        *prev= pre_alloc= mem;
123
118
      }
124
119
      else
125
120
      {
126
 
        mem_root->pre_alloc= 0;
 
121
        pre_alloc= 0;
127
122
      }
128
123
    }
129
124
  }
130
125
  else
131
126
  {
132
 
    mem_root->pre_alloc= 0;
 
127
    pre_alloc= 0;
133
128
  }
134
129
}
135
130
 
147
142
 * @todo Would this be more suitable as a member function on the
148
143
 * Root class?
149
144
 */
 
145
void *memory::Root::alloc_root(size_t length)
 
146
{
 
147
  return memory::alloc_root(this, length);
 
148
}
 
149
 
150
150
void *memory::alloc_root(memory::Root *mem_root, size_t length)
151
151
{
152
152
  size_t get_size, block_size;
241
241
  }
242
242
  va_end(args);
243
243
 
244
 
  if (!(start= (char*) memory::alloc_root(root, tot_length)))
 
244
  if (!(start= (char*) root->alloc_root(tot_length)))
245
245
    return(0);
246
246
 
247
247
  va_start(args, root);
262
262
 * @brief
263
263
 * Mark all data in blocks free for reusage 
264
264
 */
265
 
static inline void mark_blocks_free(memory::Root* root)
 
265
void memory::Root::mark_blocks_free()
266
266
{
267
267
  memory::internal::UsedMemory *next;
268
268
  memory::internal::UsedMemory **last;
269
269
 
270
270
  /* iterate through (partially) free blocks, mark them free */
271
 
  last= &root->free;
272
 
  for (next= root->free; next; next= *(last= &next->next))
 
271
  last= &free;
 
272
  for (next= free; next; next= *(last= &next->next))
273
273
  {
274
274
    next->left= next->size - ALIGN_SIZE(sizeof(memory::internal::UsedMemory));
275
275
    TRASH_MEM(next);
276
276
  }
277
277
 
278
278
  /* Combine the free and the used list */
279
 
  *last= next=root->used;
 
279
  *last= next= used;
280
280
 
281
281
  /* now go through the used blocks and mark them free */
282
282
  for (; next; next= next->next)
286
286
  }
287
287
 
288
288
  /* Now everything is set; Indicate that nothing is used anymore */
289
 
  root->used= 0;
290
 
  root->first_block_usage= 0;
 
289
  used= 0;
 
290
  first_block_usage= 0;
291
291
}
292
292
 
293
293
/**
312
312
 
313
313
  if (MyFlags & memory::MARK_BLOCKS_FREE)
314
314
  {
315
 
    mark_blocks_free(root);
 
315
    root->mark_blocks_free();
316
316
    return;
317
317
  }
318
318
  if (!(MyFlags & memory::KEEP_PREALLOC))
340
340
  }
341
341
  root->block_num= 4;
342
342
  root->first_block_usage= 0;
343
 
  return;
344
 
}
345
 
 
346
 
/**
347
 
 * @brief
348
 
 * Find block that contains an object and set the pre_alloc to it
349
 
 */
350
 
void memory::set_prealloc_root(memory::Root *root, char *ptr)
351
 
{
352
 
  memory::internal::UsedMemory *next;
353
 
  for (next=root->used; next ; next=next->next)
354
 
  {
355
 
    if ((char*) next <= ptr && (char*) next + next->size > ptr)
356
 
    {
357
 
      root->pre_alloc=next;
358
 
      return;
359
 
    }
360
 
  }
361
 
  for (next=root->free ; next ; next=next->next)
362
 
  {
363
 
    if ((char*) next <= ptr && (char*) next + next->size > ptr)
364
 
    {
365
 
      root->pre_alloc=next;
366
 
      return;
367
 
    }
368
 
  }
369
343
}
370
344
 
371
345
/**