rvserialmem.c

h.248协议源码

/******************************************************************************
Filename:    rvserialmem.c
Description: serial memory allocator
*******************************************************************************
                Copyright (c) 2001 RADVision Inc.
*******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision Inc.
No part of this publication may be reproduced in any form whatsoever without
written prior approval by RADVision Inc.

RADVision Inc. reserves the right to revise this publication and make changes
without obligation to notify any person of such revisions or changes.
******************************************************************************/

#include "rvserialmem.h"
#include "rvutil.h"

typedef struct RvSerialMemBlock_
{
	char *next;
	size_t count;
} RvSerialMemBlock;

RvSerialMem* rvSerialMemConstruct(RvSerialMem *x, size_t blockSize)
{
	rvMutexConstruct(&x->mutex);
	rvPoolConstruct(&x->pool, blockSize);
	x->curBlock = NULL;
	x->maxSize = blockSize - (sizeof(RvSerialMemBlock) + sizeof(RvSerialMemBlock *));
	x->bigAlloc = &rvDefaultAlloc;
	return x;
}

RvSerialMem* rvSerialMemConstructEx(RvSerialMem *x, size_t blockSize, RvAlloc *bigAlloc)
{
	rvSerialMemConstruct(x, blockSize);
	x->bigAlloc = bigAlloc;
	return x;
}

void rvSerialMemDestruct(RvSerialMem *x)
{
	rvMutexDestruct(&x->mutex);
	rvPoolDestruct(&x->pool);
}

void *rvSerialMemAlloc(void *data, size_t sz)
{
	RvSerialMem *x = (RvSerialMem *)data;
	sz = rvAlign(sz);
	
	if(sz <= x->maxSize)
	{
		/* Allocate memory serially from blocks.
		   The beginning of each allocated buffer will contain
		   a pointer to the header of the current block. */

		RvSerialMemBlock *block, **bufHdr;
		char *end;

		rvMutexLock(&x->mutex);

		block = x->curBlock;
		
		if(block == NULL || 
			(end = block->next + sizeof(RvSerialMemBlock *) + sz) >
			(char *)block + rvPoolGetBlockSize(&x->pool))
		{
			/* No current block or not enough room in current block, so get a new block */
			block = x->curBlock = (RvSerialMemBlock *)rvPoolAllocate(&x->pool);
			bufHdr = (RvSerialMemBlock **)((char *)block + sizeof(RvSerialMemBlock));
			block->next = (char *)block + (sizeof(RvSerialMemBlock) + sizeof(RvSerialMemBlock *)) + sz;
			block->count = 1;
		}
		else
		{
			/* There is room in current block, update header */
			bufHdr = (RvSerialMemBlock **)block->next;
			block->next = end;
			block->count++;
		}

		*bufHdr = block; /* top of buffer points back to header */

		rvMutexUnlock(&x->mutex);
		
		return bufHdr + 1;
	}

	return x->bigAlloc == NULL ? NULL : rvAllocAllocate(x->bigAlloc, sz);
}

void rvSerialMemDealloc(void *data, size_t sz, void *ptr)
{
	RvSerialMem *x = (RvSerialMem *)data;
	sz = rvAlign(sz);
	if(sz <= x->maxSize)
	{
		RvSerialMemBlock *block = *((RvSerialMemBlock **)ptr - 1);

		rvMutexLock(&x->mutex);
		
		if(--block->count == 0)
		{
			rvPoolDeallocate(&x->pool, block);

			if(x->curBlock == block)
				x->curBlock = NULL;
		}

		rvMutexUnlock(&x->mutex);
	}
	else
	{
		rvAllocDeallocate(x->bigAlloc, sz, ptr);
	}
}