/Users/mourrain/Devel/mmx/basix/src/fast_new.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : Fast memory allocation
* DESCRIPTION: Fast allocations is realized by using a linked list
*              of allocations for each fixed size divisible by
*              a word length up to MMX_MAX_FAST. Otherwise,
*              usual memory allocation is used.
* COPYRIGHT  : (C) 1999-2008  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/port.hpp>
#ifdef BASIX_HAVE_STDINT_H
#include <stdint.h>
using ::uintptr_t;
#endif

namespace mmx {

#ifdef MMX_ENABLE_FAST_ALLOCATORS

char   alloc_table[MMX_MAX_FAST]; // Static declaration initializes with NULL's
char*  alloc_mem= NULL;
size_t alloc_remains= 0;
nat    allocated= 0;
nat    fast_chunks= 0;
nat    large_uses= 0;

void*
safe_malloc (register size_t sz) {
  // Always guarantees 16 byte alignment
  register char* ret;
  register char* ptr= (char*) malloc (sz + 16);
  if (ptr == NULL) {
    fprintf (stderr, "Fatal error: out of memory\n");
    assert (false);
    exit (1);
  }
  ret= ptr + (16 - (((nat) ((uintptr_t) ((void*) ptr))) & 15));
  //printf ("Alloc: %lx, %lx\n",
  //        (uintptr_t) (void*) ret, (uintptr_t) (void*) ptr);
  *((void**) ((void*) (ret - sizeof (void*))))= (void*) ptr;
  return (void*) ret;
}

void*
enlarge_malloc (register size_t sz) {
  if (alloc_remains<sz) {
    alloc_mem    = (char *) safe_malloc (MMX_BLOCK_SIZE);
    alloc_remains= MMX_BLOCK_SIZE - 16;
    fast_chunks++;
  }
  register void* ptr= alloc_mem;
  if ((sz&15) == 0 && (((nat) ((uintptr_t) ptr)) & 15) != 0) {
    // NOTE: force 16 byte alignment for sizes which are multiples of 16
    nat sz2= 16 - (((nat) ((uintptr_t) ptr)) & 15);
    MMX_IND (ptr)       = MMX_ALLOC_PTR (sz2);
    MMX_ALLOC_PTR (sz2) = ptr;
    alloc_mem      += sz2;
    alloc_remains  -= sz2;
    ptr             = alloc_mem;
  }
  alloc_mem    += sz;
  alloc_remains-= sz;
  return ptr;
}

void*
mmx_malloc_thread_unsafe (register size_t sz) {
  if (sz == 0) return NULL;
  sz= (sz+MMX_WORD_LENGTH_INC)&MMX_WORD_MASK;
  if (sz<MMX_MAX_FAST) {
    register void *ptr= MMX_ALLOC_PTR (sz);
    if (ptr==NULL) return enlarge_malloc (sz);
    //assert (((nat) ptr) != 2);
    //assert (((nat) (MMX_IND (ptr))) != 2);
    MMX_ALLOC_PTR (sz)= MMX_IND (ptr);
    return ptr;
  }
  else {
    //printf ("Big alloc of %d bytes", (int) sz);
    //printf ("Memory used: %d bytes", (int) mmx_used_bytes ());
    large_uses += sz;
    return safe_malloc (sz);
  }
}

void
mmx_free_thread_unsafe (register void* ptr, register size_t sz) {
  if (sz == 0) return;
  sz=(sz+MMX_WORD_LENGTH_INC)&MMX_WORD_MASK;
  if (sz<MMX_MAX_FAST) {
    MMX_IND (ptr)     = MMX_ALLOC_PTR (sz);
    MMX_ALLOC_PTR (sz)= ptr;
  }
  else {
    large_uses -= sz;
    safe_free (ptr);
    //printf ("Big free of %d bytes", (int) sz);
    //printf ("Memory used: %d bytes", (int) mmx_used_bytes ());
  }
}

void*
mmx_realloc_thread_unsafe (register void* old_ptr, register size_t old_sz,
                           register size_t new_sz) {
  void* new_ptr= mmx_malloc_thread_unsafe (new_sz);
  memcpy (new_ptr, old_ptr, new_sz < old_sz ? new_sz: old_sz);
  mmx_free_thread_unsafe (old_ptr, old_sz);
  return new_ptr;
}

size_t
mmx_compute_free (void* ptr) {
  nat i= (nat) -1;
  while (ptr!=NULL) {
    i++;
    ptr= MMX_IND (ptr);
  }
  return i;
}

size_t
mmx_used_bytes () {
  size_t free_bytes= alloc_remains;
  size_t chunks_use= MMX_BLOCK_SIZE*fast_chunks;
  for (nat i=MMX_WORD_LENGTH; i<MMX_MAX_FAST; i+=MMX_WORD_LENGTH)
    free_bytes += i*mmx_compute_free (alloc_table+i);
  size_t small_uses= chunks_use- free_bytes;
  return small_uses+ large_uses;
}

void
mmx_mem_info () {
  mmout << "\n---------------- memory statistics ----------------\n";
  size_t free_bytes= alloc_remains;
  size_t chunks_use= MMX_BLOCK_SIZE*fast_chunks;
  for (nat i=MMX_WORD_LENGTH; i<MMX_MAX_FAST; i+=MMX_WORD_LENGTH)
    free_bytes += i*mmx_compute_free (alloc_table+i);
  size_t small_uses= chunks_use- free_bytes;
  size_t total_uses= small_uses+ large_uses;
  // mmout << "Fast chunks   : " << chunks_use << " bytes\n";
  // mmout << "Free on chunks: " << alloc_remains << " bytes\n";
  mmout << "User          : " << total_uses << " bytes\n";
  mmout << "Allocator     : " << chunks_use+ large_uses << " bytes\n";
  mmout << "Small mallocs : "
        << ((100*((float) small_uses))/((float) total_uses)) << "%\n";
}

#else // not MMX_ENABLE_FAST_ALLOCATORS

extern size_t bytes_in_use= 0;

size_t
mmx_used_bytes () {
  return bytes_in_use;
}

#endif // MMX_ENABLE_FAST_ALLOCATORS

} // namespace mmx