recycle.c

写程序是经常遇到内存不足,这个程序可以自动释放不用的内存

/*
______________________________________________________________________________________

					Designed by: 
					Niraj Kedar,
					Systems Engineer,
					L&T Infotech Ltd,
					Bangalore, India.

					e-mail: [e-mail]

					Date:	July, 2001.

______________________________________________________________________________________
*/

#include <stdio.h>
#include <malloc.h>

#include "recycle.h"

// data maintained in stack
typedef struct MEM_DATA_T
{
    func_scope              fn_scope;	// function scope
    Alloc_Status            al_status;	// allocation status
    void*                   pMem;		// pointer to allocated memory
    size                    size;		// size of allocated memory

}mem_data;


// stack node
typedef struct STACK
{
    mem_data        mData;
    struct STACK*   pUpperNode;
    struct STACK*   pLowerNode;
}Stack;


// release memory
#define FREE_DATA(data, size) \
    if(data) \
    { \
        free(data); \
		memset(data, 0x00, size); \
        data = 0; \
    }

// copy data into stack
#define COPY_DATA(data, node) \
    node->mData.fn_scope    = data.fn_scope; \
    node->mData.al_status   = data.al_status; \
    node->mData.pMem        = data.pMem; \
    node->mData.size        = data.size

// push data on stack
void PUSH(mem_data data);

// pop data/node from stack
void POP(func_scope fn_scope, RETURN_E retval);

extern DECL_STACK_HANDLE; 


void PUSH(mem_data data)
{
        
	#ifdef ENABLE_PRINT
	printf("In PUSH...\n");
	#endif

    if(stk_handle.pBottomNode == 0)
    {
        stk_handle.pBottomNode = (Stack*)malloc(sizeof(Stack));
        if(stk_handle.pBottomNode != 0)
        {
			memset(stk_handle.pBottomNode, 0x00, sizeof(Stack));
            COPY_DATA(data, stk_handle.pBottomNode);
            stk_handle.pTopNode = stk_handle.pBottomNode;
        }
    }
    else
    {
        stk_handle.pTopNode->pUpperNode = (Stack*)malloc(sizeof(Stack));
        if(stk_handle.pTopNode->pUpperNode != 0)
        {
			memset(stk_handle.pTopNode->pUpperNode, 0x00, sizeof(Stack));
            COPY_DATA(data, stk_handle.pTopNode->pUpperNode);
            stk_handle.pTopNode->pUpperNode->pLowerNode = stk_handle.pTopNode;
            stk_handle.pTopNode = stk_handle.pTopNode->pUpperNode;
            stk_handle.pTopNode->pUpperNode = 0;
        }
    }

	#ifdef ENABLE_PRINT
    printf("Out of PUSH...\n");
	#endif
}	


void POP(func_scope fn_scope, RETURN_E retval)
{
    void* data = 0;

    #ifdef ENABLE_PRINT
	printf("In POP...\n");
	#endif

    if(stk_handle.pTopNode != 0)
    {
        while(stk_handle.pTopNode->mData.fn_scope == fn_scope)
        {
			if(stk_handle.pTopNode->pLowerNode == 0)
			{
				if(retval != MALLOC_SUCCESS ||
					stk_handle.pTopNode->mData.al_status == OUT_OF_SCOPE) 
				{
						FREE_DATA(stk_handle.pTopNode->mData.pMem, \
							stk_handle.pTopNode->mData.size);
				}
                
                FREE_DATA((stk_handle.pTopNode), sizeof(Stack));
                stk_handle.pBottomNode = stk_handle.pTopNode;
                break;
            }
            else
            {
                Stack* data = stk_handle.pTopNode;
                stk_handle.pTopNode = stk_handle.pTopNode->pLowerNode;

                if(retval != MALLOC_SUCCESS || 
				 data->mData.al_status == OUT_OF_SCOPE)
				{
					FREE_DATA(((void*)data->mData.pMem), \
						data->mData.size);
				}

                FREE_DATA(((void*)data), sizeof(Stack));
			}
        }
    }

	#ifdef ENABLE_PRINT
    printf("Out of POP\n");
	#endif
}


Alloc_Status Allocate(size size, void** pMem,
   func_scope fn_scope, Alloc_Status al_outOfScp)
{
    Alloc_Status            alloc_stat;
    mem_data                mdata;
    RETURN_E                retval;

	#ifdef ENABLE_PRINT
	printf("In Allocate...\n");
	#endif

    if((*pMem = ALLOC_MEM(size)) == 0)
    {
            retval = alloc_stat     = MALLOC_FAIL;
    }
    else
    {
        retval          = MALLOC_SUCCESS;
        alloc_stat      = MALLOC_SUCCESS;

        if(al_outOfScp == OUT_OF_SCOPE)
                alloc_stat = OUT_OF_SCOPE;
    }

    mdata.fn_scope  =       fn_scope;
    mdata.al_status =       alloc_stat;
    mdata.pMem      =       *pMem;
    mdata.size      =       size;

    memset(*pMem, 0x00, size);

	PUSH(mdata);

	#ifdef ENABLE_PRINT
	printf("Out of Allocate...\n");
	#endif
	
	return retval;
}