fast_alloc.cpp File Reference

#include "fast_alloc.hpp"
#include "tm_ostream.hpp"
#include <cstring>

Include dependency graph for fast_alloc.cpp:

Go to the source code of this file.

Macros
#define	alloc_ptr(i)   alloc_table[i]
#define	ind(ptr)   (*((void**) ptr))

Functions
bool	break_stub (void *ptr)
int	mem_used ()
void *	safe_malloc (size_t sz)
void *	enlarge_malloc (size_t sz)
void *	fast_alloc (size_t sz)
void	fast_free (void *ptr, size_t sz)
void *	fast_realloc (void *ptr, size_t old_size, size_t new_size)
void *	fast_new (size_t s)
void	fast_delete (void *ptr)
void *	fast_alloc_mw (size_t s)
void	fast_free_mw (void *ptr, size_t s)
int	compute_free (void *ptr)
void	mem_info ()
void	mem_init ()

Variables
void *	alloc_table [MAX_FAST]
char *	alloc_mem = NULL
size_t	alloc_remains = 0
int	allocated = 0
int	fast_chunks = 0
int	large_uses = 0
int	MEM_DEBUG = 0

Macro Definition Documentation

alloc_ptr

#define alloc_ptr

(

i

)

alloc_table[i]

Definition at line 41 of file fast_alloc.cpp.

ind

#define ind

(

ptr

)

(*((void**) ptr))

Definition at line 42 of file fast_alloc.cpp.

Function Documentation

break_stub()

bool break_stub

(

void *

ptr

)

mem_used()

int mem_used

(

)

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;
}

safe_malloc()

void * safe_malloc

(

size_t

sz

)

Definition at line 48 of file fast_alloc.cpp.

                        {
  void* ptr= malloc (sz);
  if (ptr == NULL) {
    cerr << "Fatal error: out of memory\n";
    abort ();
  }
  return ptr;
}

enlarge_malloc()

void * enlarge_malloc

(

size_t

sz

)

Definition at line 58 of file fast_alloc.cpp.

                           {
  if (alloc_remains < sz) {
    if (alloc_remains > 0) {
      ind (alloc_mem)          = alloc_ptr (alloc_remains);
      alloc_ptr (alloc_remains)= alloc_mem;
    }
    alloc_mem= (char*) safe_malloc (BLOCK_SIZE);
#ifdef DEBUG_ON
    alloc_mem_top= alloc_mem_top >= alloc_mem + BLOCK_SIZE
                       ? alloc_mem_top
                       : (alloc_mem + BLOCK_SIZE);
    alloc_mem_bottom=
        alloc_mem_bottom > alloc_mem ? alloc_mem : alloc_mem_bottom;
#endif
    alloc_remains= BLOCK_SIZE;
    fast_chunks++;
  }
  void* ptr= alloc_mem;
  alloc_mem+= sz;
  alloc_remains-= sz;
  return ptr;
}

fast_alloc()

void * fast_alloc

(

size_t

sz

)

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	sz )

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 )

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

)

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

)

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";
  }
}

fast_alloc_mw()

void * fast_alloc_mw

(

size_t

s

)

Definition at line 233 of file fast_alloc.cpp.

                         {
  if (s < MAX_FAST) {
    void* ptr= alloc_ptr (s);
    if (ptr == NULL) return enlarge_malloc (s);
    alloc_ptr (s)= ind (ptr);
    return ptr;
  }
  else return safe_malloc (s);
}

fast_free_mw()

void fast_free_mw	(	void *	ptr,
		size_t	s )

Definition at line 244 of file fast_alloc.cpp.

                                   {
  if (s < MAX_FAST) {
    ind (ptr)    = alloc_ptr (s);
    alloc_ptr (s)= ptr;
  }
  else free (ptr);
}

compute_free()

int compute_free

(

void *

ptr

)

Definition at line 257 of file fast_alloc.cpp.

                         {
  int i= -1;
  while (ptr != NULL) {
    i++;
    ptr= ind (ptr);
  }
  return i;
}

mem_info()

void mem_info

(

)

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

(

)

Definition at line 308 of file fast_alloc.cpp.

{}

Variable Documentation

alloc_table

void* alloc_table[MAX_FAST]

Definition at line 25 of file fast_alloc.cpp.

alloc_mem

char* alloc_mem = NULL

Definition at line 26 of file fast_alloc.cpp.

alloc_remains

size_t alloc_remains = 0

Definition at line 31 of file fast_alloc.cpp.

allocated

int allocated = 0

Definition at line 32 of file fast_alloc.cpp.

fast_chunks

int fast_chunks = 0

Definition at line 33 of file fast_alloc.cpp.

large_uses

int large_uses = 0

Definition at line 34 of file fast_alloc.cpp.

MEM_DEBUG

int MEM_DEBUG = 0

Definition at line 35 of file fast_alloc.cpp.