/Users/mourrain/Devel/mmx/basix/include/basix/fast_new.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : fast_new.hpp
* DESCRIPTION: Fast memory allocation and new operation
* COPYRIGHT  : (C) 1998-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.
******************************************************************************/

#ifndef __MMX_FAST_NEW_HPP
#define __MMX_FAST_NEW_HPP
#include <basix/basix-config.hpp>
#include <string.h>
#include <cassert>
#include <stdlib.h>
#include <cstdio>

#ifdef BASIX_ENABLE_THREADS
#include <pthread.h>
#endif


#ifdef BASIX_OLD_GNU_COMPILER
inline void* operator new   (register size_t s, void* loc) { return loc; }
inline void* operator new[] (register size_t s, void* loc) { return loc; }
#else
#include <new>
#endif

#define MMX_ENABLE_FAST_ALLOCATORS


/*
#ifdef USE_STANDARD_NEW_DELETE
// Optional check that standard new and delete are never used
inline void* operator new (register size_t s) { assert (false); }
inline void  operator delete (register void* ptr) { assert (false); }
inline void* operator new[] (register size_t s) { assert (false); }
inline void  operator delete[] (register void* ptr) { assert (false); }
#endif
*/

namespace mmx {

typedef unsigned int nat;
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;

#if defined (_CRAY) && ! defined (_CRAYMPP)
typedef int xint;
typedef nat xnat;
#else
typedef long int xint;
typedef unsigned long int xnat;
#endif

/******************************************************************************
* Mutexes support for threads
******************************************************************************/

#ifdef BASIX_ENABLE_THREADS

class mutex {
  pthread_mutex_t rep;
public:
  inline mutex () { pthread_mutex_init (&rep, NULL); }
  inline ~mutex () { pthread_mutex_destroy (&rep); }
  friend class mutex_lock;
};

class mutex_lock {
  pthread_mutex_t* rep;
public:
  inline mutex_lock (mutex& m): rep (&(m.rep)) {
    pthread_mutex_lock (rep); }
  inline ~mutex_lock () {
    pthread_mutex_unlock (rep); }
};

#else

class mutex {};
struct mutex_lock { inline mutex_lock (mutex& m) { (void) m; } };

#endif

extern mutex memory_lock;
#ifdef BASIX_ENABLE_THREADS
extern bool threads_active;
#else
static const bool threads_active= false;
#endif
  
/******************************************************************************
* Allocators and Deallocators
******************************************************************************/

#ifdef MMX_ENABLE_FAST_ALLOCATORS

#define MMX_WORD_LENGTH      sizeof(void*)
#define MMX_WORD_LENGTH_INC (sizeof(void*)-1)
#define MMX_WORD_MASK      (-sizeof(void*))
#define MMX_LAST_FAST  256    // should be a power of two
#define MMX_MAX_FAST   (MMX_LAST_FAST+MMX_WORD_LENGTH)
#define MMX_BLOCK_SIZE 65504  // 32 smaller than power of 2 and >>> MAX_FAST

extern char   alloc_table[MMX_MAX_FAST];
extern char*  alloc_mem;
extern size_t alloc_remains;
extern nat    allocated;
extern nat    fast_chunks;
extern nat    large_uses;

#define MMX_ALLOC_PTR(i) (*((void **) (alloc_table+i)))
#define MMX_IND(ptr)     (*((void **) ptr))

void* safe_malloc (register size_t sz);

inline void
safe_free (register void* ptr) {
  //printf ("Free : %p, %p\n", ptr,
  //        *((void**) ((void*) (((char*) ptr) - sizeof (void*)))));
  free (*((void**) ((void*) (((char*) ptr) - sizeof (void*)))));
}

void* enlarge_malloc (register size_t sz);

void* mmx_malloc_thread_unsafe (register size_t sz);

void mmx_free_thread_unsafe (register void* ptr, register size_t sz);

void* mmx_realloc_thread_unsafe (register void* old_ptr,
                                 register size_t old_sz,
                                 register size_t new_sz);

#else // not MMX_ENABLE_FAST_ALLOCATORS

extern size_t bytes_in_use;

inline void*
mmx_malloc_thread_unsafe (size_t new_size) {
  //if (new_size > 32)
  //  printf ("[+%u]", new_size); fflush (stdout);
  bytes_in_use += new_size;
  void* ptr= malloc (new_size);
  if (ptr == NULL) {
    fprintf (stderr, "Fatal error: out of memory\n");
    exit (1);
  }
  return ptr;
}

inline void*
mmx_realloc_thread_unsafe (void* old_ptr, size_t old_size, size_t new_size) {
  //if (new_size > 32)
  //  printf ("[%u->%u]", old_size, new_size); fflush (stdout);
  bytes_in_use += new_size - old_size;
  void* ptr= realloc (old_ptr, new_size);
  if (ptr == NULL) {
    fprintf (stderr, "Fatal error: out of memory\n");
    exit (1);
  }
  return ptr;
}

inline void
mmx_free_thread_unsafe (void* ptr, size_t old_size) {
  //if (old_size > 32)
  //  printf ("[-%u]", old_size); fflush (stdout);
  bytes_in_use -= old_size;
  free (ptr);
}

#endif // MMX_ENABLE_FAST_ALLOCATORS

inline void*
mmx_malloc_thread_safe (size_t new_size) {
  mutex_lock lock (memory_lock);
  return mmx_malloc_thread_unsafe (new_size); }

inline void*
mmx_realloc_thread_safe (void* ptr, size_t old_size, size_t new_size) {
  mutex_lock lock (memory_lock);
  return mmx_realloc_thread_unsafe (ptr, old_size, new_size); }

inline void
mmx_free_thread_safe (void* ptr, size_t old_size) {
  mutex_lock lock (memory_lock);
  mmx_free_thread_unsafe (ptr, old_size); }

inline void*
mmx_malloc (size_t sz) {
  return threads_active ? mmx_malloc_thread_safe   (sz)
                        : mmx_malloc_thread_unsafe (sz); }

inline void* 
mmx_realloc (void* ptr, size_t old_size, size_t new_size) {
  return threads_active ? mmx_realloc_thread_safe   (ptr, old_size, new_size)
                        : mmx_realloc_thread_unsafe (ptr, old_size, new_size);}
    
inline void 
mmx_free (void* ptr, size_t old_size) {
  threads_active ? mmx_free_thread_safe   (ptr, old_size)
                 : mmx_free_thread_unsafe (ptr, old_size); }

#define MMX_ALLOCATORS                                          \
public:                                                         \
  inline void* operator new (size_t sz) {                       \
    return mmx_malloc (sz); }                                   \
  inline void* operator new (size_t sz, void* where) {          \
    (void) sz; return where; }                                  \
  inline void* operator new[] (size_t sz) {                     \
    return mmx_malloc (sz); }                                   \
  inline void* operator new[] (size_t sz, void* where) {        \
    (void) sz; return where; }                                  \
  inline void operator delete (void* ptr, size_t sz) {          \
    mmx_free (ptr, sz); }                                       \
  inline void operator delete[] (void* ptr, size_t sz) {        \
    mmx_free (ptr, sz); }

/******************************************************************************
* Fast array allocators
******************************************************************************/

#ifdef MMX_ENABLE_FAST_ALLOCATORS

template<typename C> inline C*
mmx_new (nat n) {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= mmx_malloc (n * sizeof (C) + 16);
  *((nat*) ptr)= n;
  //printf ("{+%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) + 16);
  //printf ("{++%p}", ptr); fflush (stdout);
#else
  void* ptr= mmx_malloc (n * sizeof (C));
#endif
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C ();
  return (C*) ptr;
}

template<typename C, typename T1> inline C*
mmx_new (nat n, const T1& a1) {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= mmx_malloc (n * sizeof (C) + 16);
  *((nat*) ptr)= n;
  //printf ("{.+%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) + 16);
  //printf ("{.++%p}", ptr); fflush (stdout);
#else
  void* ptr= mmx_malloc (n * sizeof (C));
#endif
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C (a1);
  return (C*) ptr;
}

template<typename C, typename T1, typename T2> inline C*
mmx_new (nat n, const T1& a1, const T2& a2) {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= mmx_malloc (n * sizeof (C) + 16);
  *((nat*) ptr)= n;
  //printf ("{..+%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) + 16);
  //printf ("{..++%p}", ptr); fflush (stdout);
#else
  void* ptr= mmx_malloc (n * sizeof (C));
#endif
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C (a1, a2);
  return (C*) ptr;
}

template<typename C> inline void
mmx_delete (C* Ptr, nat n) {
#ifdef BASIX_ENABLE_VERIFY
  void* ptr= (void*) Ptr;
  //printf ("{--%p}", ptr); fflush (stdout);
  ptr= (void*) (((char*) ptr) - 16);
  //printf ("{-%p}", ptr); fflush (stdout);
  if (*((nat*) ptr) != n)
    printf ("[%u should be %u]\n", n, *((nat*) ptr));
  assert (*((nat*) ptr) == n);
  C* ctr= Ptr+n-1;
  for (nat i=0; i<n; i++, ctr--) ctr -> ~C();
  mmx_free (ptr, n * sizeof (C) + 16);
#else
  C* ctr= Ptr+n-1;
  for (nat i=0; i<n; i++, ctr--) ctr -> ~C();
  mmx_free ((void*) Ptr, n * sizeof (C));
#endif
}

template<typename C> inline C*
mmx_new_one () {
  return mmx_new<C> (1);
}

template<typename C, typename T1> inline C*
mmx_new_one (const T1& a1) {
  return mmx_new<C> (1, a1);
}

template<typename C> inline void
mmx_delete_one (C* ptr) {
  mmx_delete<C> (ptr, 1);
}

template<typename C> inline C*
mmx_classical_new (nat n) {
  void* ptr= mmx_malloc (n * sizeof (C) + sizeof (nat));
  *((nat*) ptr)= n;
  ptr= (void*) (((nat*) ptr) + 1);
  C* ctr= (C*) ptr;
  for (nat i=0; i<n; i++, ctr++)
    (void) new ((void*) ctr) C ();
  return (C*) ptr;
}

template<typename C> inline void
mmx_classical_delete (C* Ptr) {
  void* ptr= (void*) (((nat*) ((void*) Ptr)) - 1);
  nat n= *((nat*) ptr);
  C* ctr= Ptr+n-1;
  for (nat i=0; i<n; i++, ctr--) ctr -> ~C();
  mmx_free (ptr, n * sizeof (C) + sizeof (nat));
}

/******************************************************************************
* Wrapper for slower default allocators
******************************************************************************/

#else // not MMX_ENABLE_FAST_ALLOCATORS

template<typename C> inline C*
mmx_new (nat n) {
  return new C[n];
}

template<typename C, typename T1> inline C*
mmx_new (nat n, const T1& a1) {
  C* ptr= new C[n];
  for (nat i=0; i<n; i++) ptr[i]= C(a1);
  return ptr;
}

template<typename C> inline void
mmx_delete (C* ptr, nat n) {
  (void) n;
  delete[] ptr;
}

template<typename C> inline C*
mmx_new_one () {
  return new C ();
}

template<typename C, typename T1> inline C*
mmx_new_one (const T1& a1) {
  return new C (a1);}

template<typename C> inline void
mmx_delete_one (C* ptr) {
  delete ptr;
}

template<typename C> inline C*
mmx_classical_new (nat n) {
  return new C[n];
}

template<typename C> inline void
mmx_classical_delete (C* ptr) {
  delete[] ptr;
}

#endif // MMX_ENABLE_FAST_ALLOCATORS

size_t mmx_used_bytes ();

} // namespace mmx
#endif // __MMX_FAST_NEW_HPP