I wrote this code and writeup some time ago and have used it in
several projects for building parse trees quickly. Using the pool is
faster than making a system call with
malloc each time you add a new
node. In fact, one of my programs ran 25% faster when I dropped in the
this memory allocation pool. This code is very solid and reliable.
I read about memory allocation pools in the Subversion manual and
decided to write one for fun. So here it is. Included is a small
driver I ran over night to test for memory leaks.
lint will complain
about memory leaks on this code, however. I also added thread safety,
but I don’t suggest you use it.
A memory allocation pool is good for speeding up a program that needs
to make many small memory requests quickly (many system calls).
Instead, one system call is made in place of many.
It is also useful for semi-automatic memory management. Let’s say you
build some large tree structure somewhere in your program. If you want
to free all this memory used by the tree, you will need to traverse it
to take it down. This takes time and code. If you use a memory pool,
you can free all of the memory at once by freeing the entire memory
The pool works by allocating a large chunk of memory and dishes it out
as requested (a subpool). If a request is too large to take out of the
current chunk, it allocates another chunk twice as large as the
previous one (another subpool). This doubling allows the pool to
quickly scale up to whatever size is needed. Memory will still be
allocated from the old pool until that pool has too many misses in a
row (hard coded to 10 in my sources). Once this happens, the subpool
remains untouched and your pool will have some slight internal