#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <search.h>
#include <unistd.h>
#include <stdint.h>
#include "tr/memory.h"

Include dependency graph for memory.c:

Macros
#define	_GNU_SOURCE

#define	MIN_BITS 8

Functions
int	TR_bitwidth (size_t)

size_t	TR_getSize (void *)

size_t	TR_getUsableSize (void *)

int	TR_getIdx (void *)

static struct memSegment *	newElement (size_t size, int idx)

void *	TR_reference (void *mem)

void *	TR_malloc (size_t size)

void *	TR_calloc (size_t nmemb, size_t size)

void	TR_free (void **mem)

void	TR_cleanup ()

char *	TR_strdup (const char *src)

Macro Definition Documentation

#define _GNU_SOURCE

Definition at line 47 of file memory.c.

#define MIN_BITS 8

Referenced by TR_malloc().

Function Documentation

static struct memSegment* newElement	(	size_t	size,
		int	idx
	)

static

Definition at line 80 of file memory.c.

References memSegment::idx, memSegment::next, memSegment::ptr, memSegment::ref_count, and memSegment::size.

Referenced by TR_malloc().

 {
     struct memSegment * element = malloc(size);
 
     element->ref_count = 1;
     element->size      = size;
     element->idx       = idx;
     element->ptr       = (void*)element + sizeof(struct memSegment);
 
     element->next      = NULL;
 
     return element;
 }

Here is the caller graph for this function:

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 ** mem )

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

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

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

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

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 * mem )

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 * src )

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:

Macros

Functions

Macro Definition Documentation

Function Documentation