dbmf.c File Reference

#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include "valgrind/valgrind.h"
#include "cantProceed.h"
#include "epicsMutex.h"
#include "ellLib.h"
#include "dbmf.h"

Include dependency graph for dbmf.c:

Go to the source code of this file.

Classes
struct	chunkNode
struct	itemHeader
struct	dbmfPrivate

Macros
#define	REDZONE   sizeof(double)
#define	DBMF_SIZE   64
#define	DBMF_INITIAL_ITEMS   10

Typedefs
typedef struct chunkNode	chunkNode
typedef struct itemHeader	itemHeader
typedef struct dbmfPrivate	dbmfPrivate

Functions
int	dbmfInit (size_t size, int chunkItems)
	Initialize the facility. More...
void *	dbmfMalloc (size_t size)
	Allocate memory. More...
char *	dbmfStrdup (const char *str)
	Duplicate a string. More...
char *	dbmfStrndup (const char *str, size_t len)
	Duplicate a string (up to len bytes). More...
void	dbmfFree (void *mem)
	Free the memory allocated by dbmfMalloc. More...
int	dbmfShow (int level)
	Show the status of the dbmf memory pool. More...
void	dbmfFreeChunks (void)
	Free all chunks that contain only free items. More...
char *	dbmfStrcat3 (const char *lhs, const char *mid, const char *rhs)
	Concatenate three strings. More...

Variables
dbmfPrivate	dbmfPvt
int	dbmfDebug =0

Macro Definition Documentation

#define DBMF_INITIAL_ITEMS   10

Definition at line 42 of file dbmf.c.

#define DBMF_SIZE   64

Definition at line 41 of file dbmf.c.

#define REDZONE   sizeof(double)

Definition at line 26 of file dbmf.c.

Typedef Documentation

typedef struct chunkNode chunkNode

typedef struct dbmfPrivate dbmfPrivate

typedef struct itemHeader itemHeader

Function Documentation

void dbmfFree

(

void *

bytes

)

Free the memory allocated by dbmfMalloc.

Parameters

bytes

Pointer to memory obtained from dbmfMalloc(), dbmfStrdup(), dbmfStrndup() or dbmfStrcat3().

Definition at line 175 of file dbmf.c.

{
    char       *pmem = (char *)mem;
    chunkNode  *pchunkNode;
    itemHeader *pitemHeader;

    if(!mem) return;
    if(!pdbmfPvt) {
        printf("dbmfFree called but dbmfInit never called\n");
        return;
    }
    VALGRIND_MEMPOOL_FREE(pdbmfPvt, mem);
    pmem -= sizeof(itemHeader) + REDZONE;
    epicsMutexMustLock(pdbmfPvt->lock);
    pitemHeader = (itemHeader *)pmem;
    if(!pitemHeader->pchunkNode) {
        if(dbmfDebug) printf("dbmfGree: mem %p\n",pmem);
        free((void *)pmem); pdbmfPvt->nAlloc--;
    }else {
        void **pfreeList = &pdbmfPvt->freeList;
        void **pnextFree = &pitemHeader->pnextFree;

        pchunkNode = pitemHeader->pchunkNode;
        pchunkNode->nNotFree--;
        *pnextFree = *pfreeList; *pfreeList = pnextFree;
        pdbmfPvt->nAlloc--; pdbmfPvt->nFree++;
    }
    epicsMutexUnlock(pdbmfPvt->lock);
}

void dbmfFreeChunks

(

void

)

Free all chunks that contain only free items.

Definition at line 241 of file dbmf.c.

{
    chunkNode  *pchunkNode;
    chunkNode  *pnext;;

    if(!pdbmfPvt) {
        printf("dbmfFreeChunks called but dbmfInit never called\n");
        return;
    }
    epicsMutexMustLock(pdbmfPvt->lock);
    if(pdbmfPvt->nFree
            != (pdbmfPvt->chunkItems * ellCount(&pdbmfPvt->chunkList))) {
        printf("dbmfFinish: not all free\n");
        epicsMutexUnlock(pdbmfPvt->lock);
        return;
    }
    pchunkNode = (chunkNode *)ellFirst(&pdbmfPvt->chunkList);
    while(pchunkNode) {
        pnext = (chunkNode *)ellNext(&pchunkNode->node);
        ellDelete(&pdbmfPvt->chunkList,&pchunkNode->node);
        free(pchunkNode->pchunk);
        pchunkNode = pnext;
    }
    pdbmfPvt->nFree = 0; pdbmfPvt->freeList = NULL;
    epicsMutexUnlock(pdbmfPvt->lock);
}

int dbmfInit	(	size_t	size,
		int	chunkItems
	)

Initialize the facility.

Parameters

size	The maximum size request from dbmfMalloc() that will be allocated from the dbmf pool (Size is always made a multiple of 8).
chunkItems	Each time malloc() must be called size*chunkItems bytes are allocated.

Returns

0 on success, -1 if already initialized

Note

If dbmfInit() is not called before one of the other routines then it is automatically called with size=64 and chunkItems=10

Definition at line 71 of file dbmf.c.

{
    if(pdbmfPvt) {
        printf("dbmfInit: Already initialized\n");
        return(-1);
    }
    pdbmfPvt = &dbmfPvt;
    ellInit(&pdbmfPvt->chunkList);
    pdbmfPvt->lock = epicsMutexMustCreate();
    /*allign to at least a double*/
    pdbmfPvt->size = size + size%sizeof(double);
    /* layout is
     * | itemHeader | REDZONE | size | REDZONE |
     */
    pdbmfPvt->allocSize = pdbmfPvt->size + sizeof(itemHeader) + 2*REDZONE;
    pdbmfPvt->chunkItems = chunkItems;
    pdbmfPvt->chunkSize = pdbmfPvt->allocSize * pdbmfPvt->chunkItems;
    pdbmfPvt->nAlloc = 0;
    pdbmfPvt->nFree = 0;
    pdbmfPvt->nGtSize = 0;
    pdbmfPvt->freeList = NULL;
    VALGRIND_CREATE_MEMPOOL(pdbmfPvt, REDZONE, 0);
    return(0);
}

void* dbmfMalloc

(

size_t

bytes

)

Allocate memory.

Parameters

bytes

If bytes > size then malloc() is used to allocate the memory.

Returns

Pointer to the newly-allocated memory, or NULL on failure.

Definition at line 97 of file dbmf.c.

{
    void      **pnextFree;
    void      **pfreeList;
    char       *pmem = NULL;
    chunkNode  *pchunkNode;
    itemHeader *pitemHeader;

    if(!pdbmfPvt) dbmfInit(DBMF_SIZE,DBMF_INITIAL_ITEMS);
    epicsMutexMustLock(pdbmfPvt->lock);
    pfreeList = &pdbmfPvt->freeList;
    if(*pfreeList == NULL) {
        int         i;
        size_t      nbytesTotal;

        if(dbmfDebug) printf("dbmfMalloc allocating new storage\n");
        nbytesTotal = pdbmfPvt->chunkSize + sizeof(chunkNode);
        pmem = (char *)malloc(nbytesTotal);
        if(!pmem) {
            epicsMutexUnlock(pdbmfPvt->lock);
            cantProceed("dbmfMalloc malloc failed\n");
            return(NULL);
        }
        pchunkNode = (chunkNode *)(pmem + pdbmfPvt->chunkSize);
        pchunkNode->pchunk = pmem;
        pchunkNode->nNotFree=0;
        ellAdd(&pdbmfPvt->chunkList,&pchunkNode->node);
        for(i=0; i<pdbmfPvt->chunkItems; i++) {
            pitemHeader = (itemHeader *)pmem;
            pitemHeader->pchunkNode = pchunkNode;
            pnextFree = &pitemHeader->pnextFree;
            *pnextFree = *pfreeList; *pfreeList = (void *)pmem;
            pdbmfPvt->nFree++;
            pmem += pdbmfPvt->allocSize;
        }
    }
    if(size<=pdbmfPvt->size) {
        pnextFree = *pfreeList; *pfreeList = *pnextFree;
        pmem = (void *)pnextFree;
        pdbmfPvt->nAlloc++; pdbmfPvt->nFree--;
        pitemHeader = (itemHeader *)pnextFree;
        pitemHeader->pchunkNode->nNotFree += 1;
    } else {
        pmem = malloc(sizeof(itemHeader) + 2*REDZONE + size);
        if(!pmem) {
            epicsMutexUnlock(pdbmfPvt->lock);
            cantProceed("dbmfMalloc malloc failed\n");
            return(NULL);
        }
        pdbmfPvt->nAlloc++;
        pdbmfPvt->nGtSize++;
        pitemHeader = (itemHeader *)pmem;
        pitemHeader->pchunkNode = NULL; /* not part of free list */
        if(dbmfDebug) printf("dbmfMalloc: size %lu mem %p\n",
                             (unsigned long)size,pmem);
    }
    epicsMutexUnlock(pdbmfPvt->lock);
    pmem += sizeof(itemHeader) + REDZONE;
    VALGRIND_MEMPOOL_ALLOC(pdbmfPvt, pmem, size);
    return((void *)pmem);
}

int dbmfShow

(

int

level

)

Show the status of the dbmf memory pool.

Parameters

level

Detail level.

Returns

0.

Definition at line 205 of file dbmf.c.

{
    if(pdbmfPvt==NULL) {
        printf("Never initialized\n");
        return(0);
    }
    printf("size %lu allocSize %lu chunkItems %d ",
        (unsigned long)pdbmfPvt->size,
        (unsigned long)pdbmfPvt->allocSize,pdbmfPvt->chunkItems);
    printf("nAlloc %d nFree %d nChunks %d nGtSize %d\n",
        pdbmfPvt->nAlloc,pdbmfPvt->nFree,
        ellCount(&pdbmfPvt->chunkList),pdbmfPvt->nGtSize);
    if(level>0) {
        chunkNode  *pchunkNode;

        pchunkNode = (chunkNode *)ellFirst(&pdbmfPvt->chunkList);
        while(pchunkNode) {
            printf("pchunkNode %p nNotFree %d\n",
                (void*)pchunkNode,pchunkNode->nNotFree);
            pchunkNode = (chunkNode *)ellNext(&pchunkNode->node);
        }
    }
    if(level>1) {
        void **pnextFree;;

        epicsMutexMustLock(pdbmfPvt->lock);
        pnextFree = (void**)pdbmfPvt->freeList;
        while(pnextFree) {
            printf("%p\n",*pnextFree);
            pnextFree = (void**)*pnextFree;
        }
        epicsMutexUnlock(pdbmfPvt->lock);
    }
    return(0);
}

char* dbmfStrcat3	(	const char *	lhs,
		const char *	mid,
		const char *	rhs
	)

Concatenate three strings.

Returns a pointer to a null-terminated string made by concatenating the three input strings.

Parameters

lhs	Start string to which the others get concatenated to (left part).
mid	Next string to be concatenated to the lhs (mid part).
rhs	Last string to be concatenated to the lhs+mid (right part).

Returns

A pointer to the new string, or NULL on failure.

Definition at line 289 of file dbmf.c.

{
        size_t len = strlen(lhs) + strlen(mid) + strlen(rhs) + 1;
        char *buf = dbmfMalloc(len);
        strcpy(buf, lhs);
        strcat(buf, mid);
        strcat(buf, rhs);
        return buf;
}

char* dbmfStrdup

(

const char *

str

)

Duplicate a string.

Create a copy of the input string.

Parameters

str	Pointer to the null-terminated string to be copied.

Returns

A pointer to the new copy, or NULL on failure.

Definition at line 159 of file dbmf.c.

{
    size_t len = strlen(str);
    char *buf = dbmfMalloc(len + 1);    /* FIXME Can return NULL */

    return strcpy(buf, str);
}

char* dbmfStrndup	(	const char *	str,
		size_t	len
	)

Duplicate a string (up to len bytes).

Copy at most len bytes of the input string into a new buffer. If no nil terminator is seen in the first len bytes a nil terminator is added.

Parameters

str	Pointer to the null-terminated string to be copied.
len	Max number of bytes to copy.

Returns

A pointer to the new string, or NULL on failure.

Definition at line 167 of file dbmf.c.

{
    char *buf = dbmfMalloc(len + 1);    /* FIXME Can return NULL */

    buf[len] = '\0';
    return strncpy(buf, str, len);
}

Variable Documentation

int dbmfDebug =0

Definition at line 69 of file dbmf.c.

dbmfPrivate dbmfPvt

Definition at line 67 of file dbmf.c.