fast_alloc.hpp File Reference

#include <stdlib.h>
#include <new>

Include dependency graph for fast_alloc.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	WORD_LENGTH   8
#define	WORD_LENGTH_INC   7
#define	WORD_MASK   0xfffffffffffffff8
#define	MAX_FAST   264
#define	BLOCK_SIZE   65536

Functions
void *	fast_alloc (size_t s)
void	fast_free (void *ptr, size_t s)
void *	fast_realloc (void *ptr, size_t old_size, size_t new_size)
void *	fast_new (size_t s)
void	fast_delete (void *ptr)
int	mem_used ()
void	mem_info ()
void	mem_init ()
void *	alloc_check (const char *msg, void *ptr, size_t *sp)
template<typename C >
C *	tm_new ()
template<typename C , typename A1 >
C *	tm_new (const A1 &a1)
template<typename C , typename A1 , typename A2 >
C *	tm_new (const A1 &a1, const A2 &a2)
template<typename C , typename A1 , typename A2 >
C *	tm_new (const A1 &a1, A2 &a2)
template<typename C , typename A1 , typename A2 >
C *	tm_new (A1 &a1, const A2 &a2)
template<typename C , typename A1 , typename A2 >
C *	tm_new (A1 &a1, A2 &a2)
template<typename C , typename A1 , typename A2 , typename A3 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3)
template<typename C , typename A1 , typename A2 , typename A3 >
C *	tm_new (const A1 &a1, A2 &a2, A3 &a3)
template<typename C , typename A1 , typename A2 , typename A3 >
C *	tm_new (A1 &a1, A2 &a2, const A3 &a3)
template<typename C , typename A1 , typename A2 , typename A3 >
C *	tm_new (A1 &a1, A2 &a2, A3 &a3)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 >
C *	tm_new (const A1 &a1, A2 &a2, A3 &a3, A4 &a4)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
C *	tm_new (const A1 &a1, A2 &a2, A3 &a3, A4 &a4, A5 &a5)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
C *	tm_new (A1 &a1, A2 &a2, A3 &a3, A4 &a4, A5 &a5)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
C *	tm_new (A1 &a1, const A2 &a2, A3 &a3, A4 &a4, A5 &a5, A6 &a6)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
C *	tm_new (A1 &a1, const A2 &a2, A3 &a3, A4 &a4, A5 &a5, A6 &a6, A7 &a7, A8 &a8)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10, const A11 &a11)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10, const A11 &a11, const A12 &a12)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10, const A11 &a11, const A12 &a12, const A13 &a13)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10, const A11 &a11, const A12 &a12, const A13 &a13, const A14 &a14)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10, const A11 &a11, const A12 &a12, const A13 &a13, const A14 &a14, const A15 &a15)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10, const A11 &a11, const A12 &a12, const A13 &a13, const A14 &a14, const A15 &a15, const A16 &a16, const A17 &a17)
template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 >
C *	tm_new (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10, const A11 &a11, const A12 &a12, const A13 &a13, const A14 &a14, const A15 &a15, const A16 &a16, const A17 &a17, const A18 &a18, const A19 &a19, const A20 &a20, const A21 &a21)
template<typename C >
void	tm_delete (C *ptr)
template<typename C >
C *	tm_new_array (int n)
template<typename C >
C *	tm_resize_array (int new_num, C *Ptr)
template<typename C >
void	tm_delete_array (C *Ptr)

Macro Definition Documentation

WORD_LENGTH

#define WORD_LENGTH   8

Definition at line 16 of file fast_alloc.hpp.

WORD_LENGTH_INC

#define WORD_LENGTH_INC   7

Definition at line 17 of file fast_alloc.hpp.

WORD_MASK

#define WORD_MASK   0xfffffffffffffff8

Definition at line 18 of file fast_alloc.hpp.

MAX_FAST

#define MAX_FAST   264

Definition at line 20 of file fast_alloc.hpp.

BLOCK_SIZE

#define BLOCK_SIZE   65536

Definition at line 21 of file fast_alloc.hpp.

Function Documentation

fast_alloc()

void * fast_alloc ( size_t s )

extern

Definition at line 82 of file fast_alloc.cpp.

                       {
  sz= (sz + WORD_LENGTH_INC) & WORD_MASK;
  if (sz < MAX_FAST) {
    void* ptr= alloc_ptr (sz);
    if (ptr == NULL) return enlarge_malloc (sz);
    alloc_ptr (sz)= ind (ptr);
#ifdef DEBUG_ON
    break_stub (ptr);
#endif
    return ptr;
  }
  else {
    if (MEM_DEBUG >= 3) cout << "Big alloc of " << sz << " bytes\n";
    if (MEM_DEBUG >= 3) cout << "Memory used: " << mem_used () << " bytes\n";
    large_uses+= sz;
    return safe_malloc (sz);
  }
}

fast_free()

void fast_free ( void * ptr, size_t s )

extern

Definition at line 102 of file fast_alloc.cpp.

                                 {
  sz= (sz + WORD_LENGTH_INC) & WORD_MASK;
  if (sz < MAX_FAST) {
#ifdef DEBUG_ON
    break_stub (ptr);
    break_stub (alloc_ptr (sz));
#endif
    ind (ptr)     = alloc_ptr (sz);
    alloc_ptr (sz)= ptr;
  }
  else {
    if (MEM_DEBUG >= 3) cout << "Big free of " << sz << " bytes\n";
    large_uses-= sz;
    free (ptr);
    if (MEM_DEBUG >= 3) cout << "Memory used: " << mem_used () << " bytes\n";
  }
}

fast_realloc()

void * fast_realloc ( void * ptr, size_t old_size, size_t new_size )

extern

Definition at line 121 of file fast_alloc.cpp.

                                                           {
  size_t old_size_plus_pointer= (old_size + WORD_LENGTH_INC) & WORD_MASK;
  size_t new_size_plus_pointer= (new_size + WORD_LENGTH_INC) & WORD_MASK;
  if (old_size_plus_pointer >= MAX_FAST && new_size_plus_pointer >= MAX_FAST) {
    if (MEM_DEBUG >= 3)
      cout << "Big realloc from " << old_size << " to " << new_size
           << " bytes\n";
    large_uses+= new_size - old_size;
    if (MEM_DEBUG >= 3) cout << "Memory used: " << mem_used () << " bytes\n";
    return realloc (ptr, new_size);
  }
  else {
    void* newptr= fast_alloc (new_size);
    memcpy (newptr, ptr, (old_size < new_size ? old_size : new_size));
    fast_free (ptr, old_size);
    return newptr;
  }
}

fast_new()

void * fast_new ( size_t s )

extern

Definition at line 141 of file fast_alloc.cpp.

                    {
  void* ptr;
#ifdef DEBUG_ON
  s= (s + (4 * WORD_LENGTH) + WORD_LENGTH_INC) & WORD_MASK;
#else
  s               = (s + WORD_LENGTH + WORD_LENGTH_INC) & WORD_MASK;
#endif
  if (s < MAX_FAST) {
    ptr= alloc_ptr (s);
    if (ptr == NULL) ptr= enlarge_malloc (s);
    else alloc_ptr (s)= ind (ptr);
#ifdef DEBUG_ON
    break_stub (ptr);
#endif
  }
  else {
    if (MEM_DEBUG >= 3) cout << "Big alloc of " << s << " bytes\n";
    if (MEM_DEBUG >= 3) cout << "Memory used: " << mem_used () << " bytes\n";
    ptr= safe_malloc (s);
    // if ((((int) ptr) & 15) != 0) cout << "Unaligned new " << ptr << "\n";
    large_uses+= s;
  }
#ifdef DEBUG_ON
  char* mem                        = (char*) ptr;
  *((size_t*) ptr)                 = s;
  ptr                              = ((char*) ptr) + WORD_LENGTH;
  *((size_t*) ptr)                 = s;
  ptr                              = ((char*) ptr) + WORD_LENGTH;
  *((size_t*) ptr)                 = ~s;
  ptr                              = ((char*) ptr) + WORD_LENGTH;
  *((int*) (mem + s - WORD_LENGTH))= 0x55aa;
  return (void*) ptr;
#else
  *((size_t*) ptr)= s;
  return (void*) (((char*) ptr) + WORD_LENGTH);
#endif
}

fast_delete()

void fast_delete ( void * ptr )

extern

Definition at line 203 of file fast_alloc.cpp.

                        {
#ifdef DEBUG_ON
  size_t s;
  ptr= alloc_check ("fast_delete", ptr, &s);
#else
  ptr     = (void*) (((char*) ptr) - WORD_LENGTH);
  size_t s= *((size_t*) ptr);
#endif
  if (s < MAX_FAST) {
#ifdef DEBUG_ON
    break_stub (ptr);
    break_stub (alloc_ptr (s));
#endif
    ind (ptr)    = alloc_ptr (s);
    alloc_ptr (s)= ptr;
  }
  else {
    if (MEM_DEBUG >= 3) cout << "Big free of " << s << " bytes\n";
    // if ((((int) ptr) & 15) != 0) cout << "Unaligned delete " << ptr << "\n";
    free (ptr);
    large_uses-= s;
    if (MEM_DEBUG >= 3) cout << "Memory used: " << mem_used () << " bytes\n";
  }
}

mem_used()

int mem_used ( )

extern

Definition at line 267 of file fast_alloc.cpp.

            {
  int free_bytes= alloc_remains;
  int chunks_use= BLOCK_SIZE * fast_chunks;
  int i;
  for (i= WORD_LENGTH; i < MAX_FAST; i+= WORD_LENGTH)
    free_bytes+= i * compute_free (alloc_table + i);
  int small_uses= chunks_use - free_bytes;
  return small_uses + large_uses;
}

mem_info()

void mem_info ( )

extern

Definition at line 278 of file fast_alloc.cpp.

            {
  cout << "\n---------------- memory statistics ----------------\n";
  int free_bytes= alloc_remains;
  int chunks_use= BLOCK_SIZE * fast_chunks;
  int i;
  for (i= WORD_LENGTH; i < MAX_FAST; i+= WORD_LENGTH)
    free_bytes+= i * compute_free (alloc_table + i);
  int small_uses= chunks_use - free_bytes;
  int total_uses= small_uses + large_uses;
  // cout << "Fast chunks   : " << chunks_use << " bytes\n";
  // cout << "Free on chunks: " << alloc_remains << " bytes\n";
  cout << "User          : " << total_uses << " bytes\n";
  cout << "Allocator     : " << chunks_use + large_uses << " bytes\n";
  cout << "Small mallocs : "
       << ((100 * ((float) small_uses)) / ((float) total_uses)) << "%\n";
}

mem_init()

void mem_init ( )

extern

Definition at line 308 of file fast_alloc.cpp.

{}

alloc_check()

void * alloc_check	(	const char *	msg,
		void *	ptr,
		size_t *	sp )

tm_new() [1/30]

template<typename C >

C * tm_new ( )

inline

Definition at line 59 of file fast_alloc.hpp.

          {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C ();
  return (C*) ptr;
}

tm_new() [2/30]

template<typename C , typename A1 >

C * tm_new ( const A1 & a1 )

inline

Definition at line 67 of file fast_alloc.hpp.

                      {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1);
  return (C*) ptr;
}

tm_new() [3/30]

template<typename C , typename A1 , typename A2 >

C * tm_new ( const A1 & a1, const A2 & a2 )

inline

Definition at line 75 of file fast_alloc.hpp.

                                    {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2);
  return (C*) ptr;
}

tm_new() [4/30]

template<typename C , typename A1 , typename A2 >

C * tm_new ( const A1 & a1, A2 & a2 )

inline

Definition at line 83 of file fast_alloc.hpp.

                              {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2);
  return (C*) ptr;
}

tm_new() [5/30]

template<typename C , typename A1 , typename A2 >

C * tm_new ( A1 & a1, const A2 & a2 )

inline

Definition at line 91 of file fast_alloc.hpp.

                              {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2);
  return (C*) ptr;
}

tm_new() [6/30]

template<typename C , typename A1 , typename A2 >

C * tm_new ( A1 & a1, A2 & a2 )

inline

Definition at line 99 of file fast_alloc.hpp.

                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2);
  return (C*) ptr;
}

tm_new() [7/30]

template<typename C , typename A1 , typename A2 , typename A3 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3 )

inline

Definition at line 107 of file fast_alloc.hpp.

                                                  {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3);
  return (C*) ptr;
}

tm_new() [8/30]

template<typename C , typename A1 , typename A2 , typename A3 >

C * tm_new ( const A1 & a1, A2 & a2, A3 & a3 )

inline

Definition at line 115 of file fast_alloc.hpp.

                                      {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3);
  return (C*) ptr;
}

tm_new() [9/30]

template<typename C , typename A1 , typename A2 , typename A3 >

C * tm_new ( A1 & a1, A2 & a2, const A3 & a3 )

inline

Definition at line 123 of file fast_alloc.hpp.

                                      {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3);
  return (C*) ptr;
}

tm_new() [10/30]

template<typename C , typename A1 , typename A2 , typename A3 >

C * tm_new ( A1 & a1, A2 & a2, A3 & a3 )

inline

Definition at line 131 of file fast_alloc.hpp.

                                {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3);
  return (C*) ptr;
}

tm_new() [11/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4 )

inline

Definition at line 139 of file fast_alloc.hpp.

                                                                {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4);
  return (C*) ptr;
}

tm_new() [12/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 >

C * tm_new ( const A1 & a1, A2 & a2, A3 & a3, A4 & a4 )

inline

Definition at line 147 of file fast_alloc.hpp.

                                              {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4);
  return (C*) ptr;
}

tm_new() [13/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5 )

inline

Definition at line 156 of file fast_alloc.hpp.

                                                                              {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5);
  return (C*) ptr;
}

tm_new() [14/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >

C * tm_new ( const A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 )

inline

Definition at line 165 of file fast_alloc.hpp.

                                                      {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5);
  return (C*) ptr;
}

tm_new() [15/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >

C * tm_new ( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 )

inline

Definition at line 174 of file fast_alloc.hpp.

                                                {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5);
  return (C*) ptr;
}

tm_new() [16/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6 )

inline

Definition at line 183 of file fast_alloc.hpp.

                      {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6);
  return (C*) ptr;
}

tm_new() [17/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >

C * tm_new ( A1 & a1, const A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6 )

inline

Definition at line 193 of file fast_alloc.hpp.

                                                              {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6);
  return (C*) ptr;
}

tm_new() [18/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7 )

inline

Definition at line 202 of file fast_alloc.hpp.

                                    {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7);
  return (C*) ptr;
}

tm_new() [19/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7 )

inline

Definition at line 212 of file fast_alloc.hpp.

                                    {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7);
  return (C*) ptr;
}

tm_new() [20/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8 )

inline

Definition at line 222 of file fast_alloc.hpp.

                                                  {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8);
  return (C*) ptr;
}

tm_new() [21/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >

C * tm_new ( A1 & a1, const A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8 )

inline

Definition at line 232 of file fast_alloc.hpp.

                                                                              {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8);
  return (C*) ptr;
}

tm_new() [22/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9 )

inline

Definition at line 241 of file fast_alloc.hpp.

                                                                {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8, a9);
  return (C*) ptr;
}

tm_new() [23/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10 )

inline

Definition at line 252 of file fast_alloc.hpp.

                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
  return (C*) ptr;
}

tm_new() [24/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10, const A11 & a11 )

inline

Definition at line 264 of file fast_alloc.hpp.

                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
  return (C*) ptr;
}

tm_new() [25/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10, const A11 & a11, const A12 & a12 )

inline

Definition at line 276 of file fast_alloc.hpp.

                                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
  return (C*) ptr;
}

tm_new() [26/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10, const A11 & a11, const A12 & a12, const A13 & a13 )

inline

Definition at line 288 of file fast_alloc.hpp.

                                                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
  return (C*) ptr;
}

tm_new() [27/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10, const A11 & a11, const A12 & a12, const A13 & a13, const A14 & a14 )

inline

Definition at line 300 of file fast_alloc.hpp.

                                                                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr)
      C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
  return (C*) ptr;
}

tm_new() [28/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10, const A11 & a11, const A12 & a12, const A13 & a13, const A14 & a14, const A15 & a15 )

inline

Definition at line 314 of file fast_alloc.hpp.

                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr)
      C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
  return (C*) ptr;
}

tm_new() [29/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10, const A11 & a11, const A12 & a12, const A13 & a13, const A14 & a14, const A15 & a15, const A16 & a16, const A17 & a17 )

inline

Definition at line 329 of file fast_alloc.hpp.

                                                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
                      a14, a15, a16, a17);
  return (C*) ptr;
}

tm_new() [30/30]

template<typename C , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 >

C * tm_new ( const A1 & a1, const A2 & a2, const A3 & a3, const A4 & a4, const A5 & a5, const A6 & a6, const A7 & a7, const A8 & a8, const A9 & a9, const A10 & a10, const A11 & a11, const A12 & a12, const A13 & a13, const A14 & a14, const A15 & a15, const A16 & a16, const A17 & a17, const A18 & a18, const A19 & a19, const A20 & a20, const A21 & a21 )

inline

Definition at line 345 of file fast_alloc.hpp.

                                                        {
  void* ptr= fast_new (sizeof (C));
  (void) new (ptr) C (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
                      a14, a15, a16, a17, a18, a19, a20, a21);
  return (C*) ptr;
}

tm_delete()

template<typename C >

void tm_delete ( C * ptr )

inline

Definition at line 358 of file fast_alloc.hpp.

                   {
  ptr->~C ();
  fast_delete ((void*) ptr);
}

tm_new_array()

template<typename C >

C * tm_new_array ( int n )

inline

Definition at line 408 of file fast_alloc.hpp.

                     {
  void* ptr    = fast_alloc (n * sizeof (C) + WORD_LENGTH);
  *((int*) ptr)= n;
  ptr          = (void*) (((char*) ptr) + WORD_LENGTH);
  C* ctr       = (C*) ptr;
  for (int i= 0; i < n; i++, ctr++)
    (void) new ((void*) ctr) C ();
  return (C*) ptr;
}

tm_resize_array()

template<typename C >

C * tm_resize_array ( int new_num, C * Ptr )

inline

Definition at line 419 of file fast_alloc.hpp.

                                      {
  void* old_arr    = (void*) Ptr;
  old_arr          = (void*) (((char*) old_arr) - WORD_LENGTH);
  int   old_num    = *((int*) old_arr);
  void* new_arr    = fast_realloc (old_arr, old_num * sizeof (C) + WORD_LENGTH,
                                   new_num * sizeof (C) + WORD_LENGTH);
  *((int*) new_arr)= new_num;
  new_arr          = (void*) (((char*) new_arr) + WORD_LENGTH);
  C* ctr           = (C*) new_arr + old_num;
  for (int i= old_num; i < new_num; i++, ctr++)
    (void) new ((void*) ctr) C ();
  return (C*) new_arr;
}

tm_delete_array()

template<typename C >

void tm_delete_array ( C * Ptr )

inline

Definition at line 435 of file fast_alloc.hpp.

                         {
  void* ptr= (void*) Ptr;
  ptr      = (void*) (((char*) ptr) - WORD_LENGTH);
  int n    = *((int*) ptr);
  C*  ctr  = Ptr + n - 1;
  for (int i= 0; i < n; i++, ctr--)
    ctr->~C ();
  fast_free (ptr, n * sizeof (C) + WORD_LENGTH);
}