Category : C Source Code
Archive : GRAFGEM3.ZIP
Filename : ALLOC.C
Output of file : ALLOC.C contained in archive : GRAFGEM3.ZIP
*
* A simple fast memory allocation package.
*
* AllocInit() - create an alloc pool, returns the old pool handle.
* Alloc() - allocate memory.
* AllocReset() - reset the current pool.
* AllocSetPool() - set the current pool.
* AllocFree() - free the memory used by the current pool.
*
*/
#include
#include "alloc.h"
/* ALLOC_BLOCK_SIZE - adjust this size to suit your installation - it should
* be reasonably * large otherwise you will be mallocing a lot.
*/
#define ALLOC_BLOCK_SIZE (100*1024)
/* alloc_hdr_t - Header for each block of memory
*/
typedef
struct alloc_hdr_s
{
struct alloc_hdr_s *next; /* Next Block */
char *block, /* Start of block */
*free, /* Next free in block */
*end; /* block + block size */
}
alloc_hdr_t;
/* alloc_root_t - Header for the whole pool
*/
typedef
struct alloc_root_s
{
alloc_hdr_t *first, /* First header in pool */
*current; /* Current header */
}
alloc_root_t;
/* root - Pointer to the the current pool
*/
static alloc_root_t *root;
/* AllocHdr()
*
* Private routine to allocate a header and memory block.
*/
static
alloc_hdr_t *
AllocHdr()
{
alloc_hdr_t *hdr;
char *block;
block = (char *) malloc(ALLOC_BLOCK_SIZE);
hdr = (alloc_hdr_t *) malloc(sizeof(alloc_hdr_t));
if (hdr == NULL || block == NULL)
{
fprintf(stderr, "Out of memory\n");
exit(1);
}
hdr->block = block;
hdr->free = block;
hdr->next = NULL;
hdr->end = block + ALLOC_BLOCK_SIZE;
return(hdr);
}
/* AllocInit()
*
* Create a new memory pool with one block.
* Returns pointer to the previous pool.
*/
alloc_handle_t *
AllocInit()
{
alloc_handle_t *old = (alloc_handle_t *) root;
root = (alloc_root_t *) malloc(sizeof(alloc_root_t));
root->first = AllocHdr();
root->current = root->first;
return(old);
}
/* Alloc()
*
* Use as a direct replacement for malloc(). Allocates memory
* from the current pool.
*/
char *
Alloc(size)
int size;
{
alloc_hdr_t *hdr = root->current;
char *ptr;
/* Align to 4 byte boundary - should be OK for most machines.
* Change this if your machine has wierd alignment requirements
*/
size = (size + 3) & 0xfffffffc;
ptr = hdr->free;
hdr->free += size;
/* Check if the current block is exhausted */
if (hdr->free >= hdr->end)
{
/* Is the next block already allocated? */
if (hdr->next != NULL)
{
/* re-use block */
hdr->next->free = hdr->next->block;
root->current = hdr->next;
}
else
{
/* extend the pool with a new block */
hdr->next = AllocHdr();
root->current = hdr->next;
}
/* set ptr to the first location in the next block */
ptr = root->current->free;
root->current->free += size;
}
/* Return pointer to allocated memory */
return(ptr);
}
/* AllocSetPool()
*
* Change the current pool. Return the old pool.
*/
alloc_handle_t *
AllocSetPool(new)
alloc_handle_t *new;
{
alloc_handle_t *old = (alloc_handle_t *) root;
root = (alloc_root_t *) new;
return(old);
}
/* AllocReset()
*
* Reset the current pool for re-use. No memory is freed, so
* this is very fast.
*/
void
AllocReset()
{
root->current = root->first;
root->current->free = root->current->block;
}
/* AllocFreePool()
*
* Free the memory used by the current pool.
* Don't use where AllocReset() could be used.
*/
void
AllocFreePool()
{
alloc_hdr_t *hdr = root->first;
while (hdr != NULL)
{
free((char *) hdr->block);
free((char *) hdr);
hdr = hdr->next;
}
free((char *) root);
root = NULL;
}
Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!
This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.
But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/