dbmf.h File Reference

A library to manage storage that is allocated and quickly freed. More...

#include <stdlib.h>
#include "libComAPI.h"

Include dependency graph for dbmf.h:

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

Go to the source code of this file.

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

Detailed Description

A library to manage storage that is allocated and quickly freed.

Author

Jim Kowalkowski, Marty Kraimer

Database Macro/Free describes a facility that prevents memory fragmentation when temporary storage is being allocated and freed a short time later, at the same time that much longer-lived storage is also being allocated, such as when parsing items for the IOC database while also creating records.

Routines whin iocCore like dbLoadDatabase() have the following attributes:

• They repeatedly call malloc() followed soon afterwards by a call to free() the temporaryily allocated storage.
• Between those calls to malloc() and free(), additional calls to malloc() are made that do NOT have an associated free().

Note

In some environment, e.g. vxWorks, this behavior causes severe memory fragmentation.

This facility should NOT be used by code that allocates storage and then keeps it for a considerable period of time before releasing. Such code should consider using the freeList library.

Definition in file dbmf.h.

Function Documentation

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

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

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

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

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

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

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

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