Search  

---

C:/temp/src/j2k/Beta/fast_alloc.c

Go to the documentation of this file.

#ifndef __J2K__FAST_ALLOC_C__
#define __J2K__FAST_ALLOC_C__   1

#include "fast_alloc.h"

/*
  The fast and basic allocation primitive:
  ========================================
  Always round request to something close to a power of two.
  This ensures a bit of padding, which often means that
  buffer increase won't have to realloc. Plus it tends to
  be faster when lots of objects are created and discarded,
  since just about any version of malloc will be faster 
  when it can reuse identically-sized chunks.

  Basically, we use internal memory fragmentation 
  for our own space craving needs, which is a very good thing to do!
  Why bothering realloc() when space is already there for us !?

  We use register and shifting for optimal performance.
*/

/* Calculate the amount of memory needed ideally */
size_t fast_mem_size( register size_t min_size )
{
  register size_t  alloc_size = 1;
  register size_t  curr_size  = min_size;

  curr_size += MALLOC_MIN_OVERHEAD;

  if ( curr_size >= MALLOC_MAX_THRESHOLD ) 
  {
    curr_size >>= MALLOC_MAX_THRESHOLD_BIT;
    curr_size++;
    curr_size <<= MALLOC_MAX_THRESHOLD_BIT;
    alloc_size = curr_size;
  }
  else /* Too small, so exponential growth */
  {
    while( curr_size > 0 ) 
    {
      curr_size  >>= 1;  /* Get the highest power of two + 1 bit */
      alloc_size <<= 1;
    }
  }

#ifdef __J2K__DEBUG_TRACE
  printf( "Wanted space:    [%d]\n", min_size   );
  printf( "Allocated space: [%d]\n", alloc_size );
  printf( "malloc'ed space: [%d]\n", alloc_size - MALLOC_MIN_OVERHEAD );
  fflush( stdout );
#endif

  alloc_size -= MALLOC_MIN_OVERHEAD;
  
  /* Make sure what we allocate is big enough */
  assert( alloc_size >= curr_size );  

  return alloc_size;
}

/* Malloc using the ideal amount of memory */
void* fast_malloc( register size_t min_size )
{
  if ( min_size < 16 ) min_size = 16;

  void* buffer = malloc( fast_mem_size( min_size ) );

  /* Make sure we have some memory allocated ! */
  assert( buffer != NULL );

  return buffer;
}

/* Realloc using the ideal amount of memory for the extra bytes */
void* fast_realloc( register void* buffer, register size_t buf_size, register size_t extra )
{
  if ( extra < 16 ) extra = 16;

  register size_t sz = fast_mem_size( extra ) + buf_size;
  void* buffer = realloc( buffer, sz );

  /* Make sure we have some memory allocated ! */
  assert( buffer != NULL );

  return buffer;
}

/* Same as free, provide for convenience */
void fast_free( void* buffer )
{
  free( buffer );
}

#endif

---