freeListLib.c File Reference

#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include "valgrind/valgrind.h"
#include "cantProceed.h"
#include "epicsMutex.h"
#include "freeList.h"
#include "adjustment.h"

Include dependency graph for freeListLib.c:

Go to the source code of this file.

Classes
struct	allocMem
struct	FREELISTPVT

Macros
#define	REDZONE   sizeof(double)

Typedefs
typedef struct allocMem	allocMem

Functions
LIBCOM_API void epicsStdCall	freeListInitPvt (void **ppvt, int size, int nmalloc)
LIBCOM_API void *epicsStdCall	freeListCalloc (void *pvt)
LIBCOM_API void *epicsStdCall	freeListMalloc (void *pvt)
LIBCOM_API void epicsStdCall	freeListFree (void *pvt, void *pmem)
LIBCOM_API void epicsStdCall	freeListCleanup (void *pvt)
LIBCOM_API size_t epicsStdCall	freeListItemsAvail (void *pvt)

Macro Definition Documentation

#define REDZONE   sizeof(double)

Definition at line 20 of file freeListLib.c.

Typedef Documentation

typedef struct allocMem allocMem

Function Documentation

LIBCOM_API void* epicsStdCall freeListCalloc

(

void *

pvt

)

Definition at line 60 of file freeListLib.c.

{
    FREELISTPVT *pfl = pvt;
#   ifdef EPICS_FREELIST_DEBUG
    return callocMustSucceed(1,pfl->size,"freeList Debug Calloc");
#   else
    void        *ptemp;

    ptemp = freeListMalloc(pvt);
    if(ptemp) memset((char *)ptemp,0,pfl->size);
    return(ptemp);
#   endif
}

LIBCOM_API void epicsStdCall freeListCleanup

(

void *

pvt

)

Definition at line 152 of file freeListLib.c.

{
    FREELISTPVT *pfl = pvt;
    allocMem    *phead;
    allocMem    *pnext;

    VALGRIND_DESTROY_MEMPOOL(pvt);

    phead = pfl->mallochead;
    while(phead) {
        pnext = phead->next;
        free(phead->memory);
        free(phead);
        phead = pnext;
    }
    epicsMutexDestroy(pfl->lock);
    free(pvt);
}

LIBCOM_API void epicsStdCall freeListFree	(	void *	pvt,
		void *	pmem
	)

Definition at line 131 of file freeListLib.c.

{
    FREELISTPVT *pfl = pvt;
#   ifdef EPICS_FREELIST_DEBUG
    memset ( pmem, 0xdd, pfl->size );
    free(pmem);
#   else
    void        **ppnext;

    VALGRIND_MEMPOOL_FREE(pvt, pmem);
    VALGRIND_MEMPOOL_ALLOC(pvt, pmem, sizeof(void*));

    epicsMutexMustLock(pfl->lock);
    ppnext = pmem;
    *ppnext = pfl->head;
    pfl->head = pmem;
    pfl->nBlocksAvailable++;
    epicsMutexUnlock(pfl->lock);
#   endif
}

LIBCOM_API void epicsStdCall freeListInitPvt	(	void **	ppvt,
		int	size,
		int	nmalloc
	)

Definition at line 44 of file freeListLib.c.

{
    FREELISTPVT *pfl;

    pfl = callocMustSucceed(1,sizeof(FREELISTPVT), "freeListInitPvt");
    pfl->size = adjustToWorstCaseAlignment(size);
    pfl->nmalloc = nmalloc;
    pfl->head = NULL;
    pfl->mallochead = NULL;
    pfl->nBlocksAvailable = 0u;
    pfl->lock = epicsMutexMustCreate();
    *ppvt = (void *)pfl;
    VALGRIND_CREATE_MEMPOOL(pfl, REDZONE, 0);
    return;
}

LIBCOM_API size_t epicsStdCall freeListItemsAvail

(

void *

pvt

)

Definition at line 171 of file freeListLib.c.

{
    FREELISTPVT *pfl = pvt;
    size_t nBlocksAvailable;
    epicsMutexMustLock(pfl->lock);
    nBlocksAvailable = pfl->nBlocksAvailable;
    epicsMutexUnlock(pfl->lock);
    return nBlocksAvailable;
}

LIBCOM_API void* epicsStdCall freeListMalloc

(

void *

pvt

)

Definition at line 74 of file freeListLib.c.

{
    FREELISTPVT *pfl = pvt;
#   ifdef EPICS_FREELIST_DEBUG
    return callocMustSucceed(1,pfl->size,"freeList Debug Malloc");
#   else
    void        *ptemp;
    void        **ppnext;
    allocMem    *pallocmem;
    int         i;

    epicsMutexMustLock(pfl->lock);
    ptemp = pfl->head;
    if(ptemp==0) {
        /* layout of each block. nmalloc+1 REDZONEs for nmallocs.
         * The first sizeof(void*) bytes are used to store a pointer
         * to the next free block.
         *
         * | RED | size0 ------ | RED | size1 | ... | RED |
         * |     | next | ----- |
         */
        ptemp = (void *)malloc(pfl->nmalloc*(pfl->size+REDZONE)+REDZONE);
        if(ptemp==0) {
            epicsMutexUnlock(pfl->lock);
            return(0);
        }
        pallocmem = (allocMem *)calloc(1,sizeof(allocMem));
        if(pallocmem==0) {
            epicsMutexUnlock(pfl->lock);
            free(ptemp);
            return(0);
        }
        pallocmem->memory = ptemp; /* real allocation */
        ptemp = REDZONE + (char *) ptemp; /* skip first REDZONE */
        if(pfl->mallochead)
            pallocmem->next = pfl->mallochead;
        pfl->mallochead = pallocmem;
        for(i=0; i<pfl->nmalloc; i++) {
            ppnext = ptemp;
            VALGRIND_MEMPOOL_ALLOC(pfl, ptemp, sizeof(void*));
            *ppnext = pfl->head;
            pfl->head = ptemp;
            ptemp = ((char *)ptemp) + pfl->size+REDZONE;
        }
        ptemp = pfl->head;
        pfl->nBlocksAvailable += pfl->nmalloc;
    }
    ppnext = pfl->head;
    pfl->head = *ppnext;
    pfl->nBlocksAvailable--;
    epicsMutexUnlock(pfl->lock);
    VALGRIND_MEMPOOL_FREE(pfl, ptemp);
    VALGRIND_MEMPOOL_ALLOC(pfl, ptemp, pfl->size);
    return(ptemp);
#   endif
}