#include <stdlib.h>
#include <sys/types.h>

Include dependency graph for memory.h:

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

Data Structures
struct	memSegment

Macros
#define	TR_MEM_FREE(seg) (TR_free((void **)&(seg)))

#define	LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n

Functions
int	TR_bitwidth (size_t value)

struct memSegment *	_getMemInfo (void *mem)

size_t	TR_getSize (void *mem)

size_t	TR_getUsableSize (void *mem)

int	TR_getIdx (void *mem)

void *	TR_malloc (size_t)

void *	TR_calloc (size_t, size_t)

void *	TR_reference (void *)

void	TR_free (void **)

void	TR_cleanup ()

char *	TR_strdup (const char *)

Detailed Description

Author: Georg Hopp

Copyright: Copyright © 2014 Georg Hopp

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file memory.h.

Data Structure Documentation

struct memSegment

Definition at line 31 of file memory.h.

Collaboration diagram for memSegment:

Data Fields
int	idx
struct memSegment *	next
void *	ptr
size_t	ref_count
size_t	size

Macro Definition Documentation

#define LT ( n ) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n

Referenced by TR_bitwidth().

#define TR_MEM_FREE ( seg ) (TR_free((void **)&(seg)))

Definition at line 26 of file memory.h.

Referenced by sizedDataDtor(), TR_loggerLog(), and TR_sizedDataSetData().

Function Documentation

struct memSegment* _getMemInfo ( void * mem )

Definition at line 84 of file memory.h.

 {
     if (NULL == mem) {
         return 0;
     }
 
     return (struct memSegment *)(mem - sizeof(struct memSegment));
 }

int TR_bitwidth ( size_t value )

inline

I found this at stanford.edu: https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogLookup

Really cool way of dealing with this. The oneat stanford.edu is slightly different as ist deals only with 32bit values. I need a 64bit version because on a 64bit system size_t is also 64bit and thus it is possible to allocate that much amount of memory theoretically.

Definition at line 52 of file memory.h.

References LT.

Referenced by TR_malloc().

 {
     static const char LogTable256[256] = {
         -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
 #define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
         LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6),
         LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7)
     };
 #undef LT
 
     int             r;          // r will be lg(v)
     register size_t t1, t2, t3; // temporaries
 
     if (sizeof(value) == 8 && (t3 = value >> 32)) {
         if ((t2 = t3 >> 16)) {
             r = (t1 = t2 >> 8) ? 56 + LogTable256[t1] : 48 + LogTable256[t2];
         } else {
             r = (t1 = t3 >> 8) ? 40 + LogTable256[t1] : 32 + LogTable256[t3];
         }
     } else {
         if ((t2 = value >> 16)) {
             r = (t1 = t2 >> 8) ? 24 + LogTable256[t1] : 16 + LogTable256[t2];
         } else {
             r = (t1 = value >> 8) ? 8 + LogTable256[t1] : LogTable256[value];
         }
     }
 
     return r;
 }

Here is the caller graph for this function:

void* TR_calloc	(	size_t	nmemb,
		size_t	size
	)

this is a really memory wasting solution....just to be able to use calloc, which might be faster then malloc/memset solution.

Maybe this is a bad idea, as we need to memset the buffer anyway if it comes from our tree, which hopefully should be the majority of cases.

Definition at line 242 of file memory.c.

References memSegment::size, TR_getUsableSize(), and TR_malloc().

 {
     size_t   _size = nmemb * size;
     void   * mem   = TR_malloc(_size);
 
     memset(mem, 0, TR_getUsableSize(mem));
 
     return mem;
 }

Here is the call graph for this function:

void TR_cleanup ( )

Definition at line 276 of file memory.c.

References memSegment::next.

 {
 #ifdef MEM_OPT
     int i;
 
     for (i=0; i<TR_MAX_MEM_IDX; i++) {
         while(segments[i]) {
             struct memSegment * next = segments[i]->next;
             free(segments[i]);
             segments[i] = next;
         }
     }
 #endif
 }

void TR_free ( void ** )

Definition at line 253 of file memory.c.

References memSegment::idx, and memSegment::ref_count.

 {
     if (NULL != *mem) {
         struct memSegment * seg = (*mem - sizeof(struct memSegment));
 
         if (1 < seg->ref_count) {
             seg->ref_count--;
         } else {
 #ifdef MEM_OPT
             if (-1 != seg->idx) {
                 insertElement(&(segments[seg->idx]), seg);
             } else
 #endif
             {
                 free(seg);
             }
         }
 
         *mem = NULL;
     }
 }

int TR_getIdx ( void * mem )

inline

Definition at line 114 of file memory.h.

References memSegment::idx.

 {
     struct memSegment * segment =
         (struct memSegment *)(mem - sizeof(struct memSegment));
 
     return segment ? segment->idx : -1;
 }

size_t TR_getSize ( void * mem )

inline

Definition at line 95 of file memory.h.

References memSegment::size.

Referenced by TR_getUsableSize(), and TR_sizedDataSetData().

 {
     struct memSegment * segment =
         (struct memSegment *)(mem - sizeof(struct memSegment));
 
     return segment ? segment->size : 0;
 }

Here is the caller graph for this function:

size_t TR_getUsableSize ( void * mem )

inline

Definition at line 105 of file memory.h.

References memSegment::size, and TR_getSize().

Referenced by TR_calloc().

 {
     size_t size = TR_getSize(mem);
 
     return size ? size - sizeof(struct memSegment) : 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* TR_malloc ( size_t )

Definition at line 178 of file memory.c.

References memSegment::idx, MIN_BITS, newElement(), memSegment::ptr, and TR_bitwidth().

Referenced by sizedDataCtor(), TR_calloc(), TR_loggerLog(), TR_sizedDataSetData(), and TR_strdup().

 {
     struct memSegment * seg         = NULL;
     long                psize       = sysconf(_SC_PAGESIZE);
     static int          psize_width = 0;
     int                 idx;
 
     psize_width = psize_width ? psize_width : TR_bitwidth(psize);
 
     size += sizeof(struct memSegment);
 
 #define MIN_BITS   8
 
     if (size >= psize) {
         // get a multiple of pagesize
         idx = size / psize;
 
         if (0 != (size % psize)) {
             // size if not a multiple of pagesize so bring it to one.
             idx++;
             size = idx * psize;
         }
 
         idx += psize_width - MIN_BITS;
     } else {
         if (size <= 1 << (MIN_BITS - 1)) {
             size = 1 << (MIN_BITS - 1);
             idx = 0;
         } else {
             // size-1 to ensure that powers of two will not be
             // changed to the next power of two
             idx   = TR_bitwidth(size-1) + 1;
             size  = 1 << idx;
             idx  -= (MIN_BITS - 1);
         }
     }
 
 #undef MIN_BITS
 
 #ifdef MEM_OPT
     if (idx < TR_MAX_MEM_IDX) {
         seg = deleteElement(&(segments[idx]));
     } else
 #endif
     {
         idx = -1;
     }
 
     if (NULL == seg) {
         seg = newElement(size, idx);
     }
 
     return seg->ptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* TR_reference ( void * )

Definition at line 141 of file memory.c.

References memSegment::ref_count.

 {
     struct memSegment * seg = (mem - sizeof(struct memSegment));
 
     seg->ref_count++;
 
     return mem;
 }

char* TR_strdup ( const char * )

Definition at line 292 of file memory.c.

References TR_malloc().

 {
     char * dup;
 
     if (NULL == src) {
         return NULL;
     }
 
     dup = TR_malloc(strlen(src)+1);
     strcpy(dup, src);
 
     return dup;
 }

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Data Structure Documentation

Macro Definition Documentation

Function Documentation