root.cc

Go to the documentation of this file.

/* Copyright (C) 2000 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */

#include <config.h>

#include <drizzled/definitions.h>
#include <drizzled/memory/root.h>
#include <drizzled/internal/my_sys.h>
#include <drizzled/internal/m_string.h>
#include <drizzled/sql_string.h>

#include <algorithm>

using namespace std;

namespace drizzled {
namespace memory {

static const unsigned int MAX_BLOCK_TO_DROP= 4096;
static const unsigned int MAX_BLOCK_USAGE_BEFORE_DROP= 10;

void Root::init(size_t block_size_arg)
{
  free= used= pre_alloc= 0;
  min_malloc= 32;
  block_size= block_size_arg - ROOT_MIN_BLOCK_SIZE;
  block_num= 4;     /* We shift this with >>2 */
  first_block_usage= 0;
}

void Root::reset_defaults(size_t block_size_arg, size_t pre_alloc_size)
{
  block_size= block_size_arg - ROOT_MIN_BLOCK_SIZE;
  if (pre_alloc_size)
  {
    size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(internal::UsedMemory));
    if (not pre_alloc || pre_alloc->size != size)
    {
      internal::UsedMemory *mem, **prev= &this->free;
      /*
        Free unused blocks, so that consequent calls
        to reset_root_defaults won't eat away memory.
      */
      while (*prev)
      {
        mem= *prev;
        if (mem->size == size)
        {
          /* We found a suitable block, no need to do anything else */
          pre_alloc= mem;
          return;
        }
        if (mem->left + ALIGN_SIZE(sizeof(internal::UsedMemory)) == mem->size)
        {
          /* remove block from the list and free it */
          *prev= mem->next;
          std::free(mem);
        }
        else
          prev= &mem->next;
      }
      /* Allocate new prealloc block and add it to the end of free list */
      mem= static_cast<internal::UsedMemory *>(malloc(size));
      mem->size= size;
      mem->left= pre_alloc_size;
      mem->next= *prev;
      *prev= pre_alloc= mem;
    }
  }
  else
  {
    pre_alloc= 0;
  }
}

unsigned char* Root::alloc(size_t length)
{
  internal::UsedMemory *next= NULL;
  assert(alloc_root_inited());

  length= ALIGN_SIZE(length);
  internal::UsedMemory **prev= &this->free;
  if (*prev)
  {
    if ((*prev)->left < length &&
  this->first_block_usage++ >= MAX_BLOCK_USAGE_BEFORE_DROP &&
  (*prev)->left < MAX_BLOCK_TO_DROP)
    {
      next= *prev;
      *prev= next->next;      /* Remove block from list */
      next->next= this->used;
      this->used= next;
      this->first_block_usage= 0;
    }
    for (next= *prev; next && next->left < length; next= next->next)
      prev= &next->next;
  }
  if (! next)
  {           /* Time to alloc new block */
    size_t tmp_block_size= this->block_size * (this->block_num >> 2);
    size_t get_size= length+ALIGN_SIZE(sizeof(internal::UsedMemory));
    get_size= max(get_size, tmp_block_size);

    next = static_cast<internal::UsedMemory *>(malloc(get_size));
    this->block_num++;
    next->next= *prev;
    next->size= get_size;
    next->left= get_size-ALIGN_SIZE(sizeof(internal::UsedMemory));
    *prev=next;
  }

  unsigned char* point= (unsigned char*) ((char*) next+ (next->size-next->left));
  if ((next->left-= length) < this->min_malloc)
  {           /* Full block */
    *prev= next->next;        /* Remove block from list */
    next->next= this->used;
    this->used= next;
    this->first_block_usage= 0;
  }

  return point;
}


void* Root::multi_alloc(int unused, ...)
{
  va_list args;
  char* *ptr, *start, *res;
  size_t tot_length, length;

  (void)unused; // For some reason Sun Studio registers unused as not used.
  va_start(args, unused);
  tot_length= 0;
  while ((ptr= va_arg(args, char* *)))
  {
    length= va_arg(args, uint);
    tot_length+= ALIGN_SIZE(length);
  }
  va_end(args);

  start= (char*) this->alloc(tot_length);

  va_start(args, unused);
  res= start;
  while ((ptr= va_arg(args, char* *)))
  {
    *ptr= res;
    length= va_arg(args, uint);
    res+= ALIGN_SIZE(length);
  }
  va_end(args);
  return((void*) start);
}

void Root::mark_blocks_free()
{
  internal::UsedMemory *next;
  internal::UsedMemory **last;

  /* iterate through (partially) free blocks, mark them free */
  last= &free;
  for (next= free; next; next= *(last= &next->next))
  {
    next->left= next->size - ALIGN_SIZE(sizeof(internal::UsedMemory));
  }

  /* Combine the free and the used list */
  *last= next= used;

  /* now go through the used blocks and mark them free */
  for (; next; next= next->next)
  {
    next->left= next->size - ALIGN_SIZE(sizeof(internal::UsedMemory));
  }

  /* Now everything is set; Indicate that nothing is used anymore */
  used= 0;
  first_block_usage= 0;
}

void Root::free_root(myf MyFlags)
{
  if (MyFlags & MARK_BLOCKS_FREE)
  {
    this->mark_blocks_free();
    return;
  }
  if (!(MyFlags & KEEP_PREALLOC))
    this->pre_alloc=0;

  for (internal::UsedMemory* next= this->used; next;)
  {
    internal::UsedMemory* old =next; 
    next= next->next;
    if (old != this->pre_alloc)
      std::free(old);
  }
  for (internal::UsedMemory* next=this->free; next;)
  {
    internal::UsedMemory* old= next; 
    next= next->next;
    if (old != this->pre_alloc)
      std::free(old);
  }
  this->used=this->free=0;
  if (this->pre_alloc)
  {
    this->free=this->pre_alloc;
    this->free->left=this->pre_alloc->size-ALIGN_SIZE(sizeof(internal::UsedMemory));
    this->free->next=0;
  }
  this->block_num= 4;
  this->first_block_usage= 0;
}

char* Root::strdup(const char* str)
{
  return strdup(str, strlen(str));
}

char* Root::strdup(const char* str, size_t len)
{
  char* pos= (char*)alloc(len + 1);
  memcpy(pos, str, len);
  pos[len]= 0;
  return pos;
}

char* Root::strdup(str_ref v)
{
  return strdup(v.data(), v.size());
}

void* Root::memdup(const void* str, size_t len)
{
  void* pos= alloc(len);
  memcpy(pos, str, len);
  return pos;
}

}
} /* namespace drizzled */