Pool allocators are found in many programming languages, and in many variations.
The beginnings of many implementations may be found in common programming
literature; some of these are given below. Note that none of these are complete
implementations of a Pool; most of these leave some aspects of a Pool as
a user exercise. However, in each case, even though some aspects are missing,
these examples use the same underlying concept of a Simple Segregated Storage
described in this document.
-
The C++ Programming Language, 3rd ed., by Bjarne
Stroustrup, Section 19.4.2. Missing aspects:
-
Not portable.
-
Cannot handle allocations of arbitrary numbers of objects (this
was left as an exercise).
-
Not thread-safe.
-
Suffers from the static initialization problem.
-
MicroC/OS-II: The Real-Time Kernel, by Jean J. Labrosse,
Chapter 7 and Appendix B.04.
-
An example of the Simple Segregated Storage scheme at work in the
internals of an actual OS.
-
Missing aspects:
-
Not portable (though this is OK, since it's part of its own OS).
-
Cannot handle allocations of arbitrary numbers of blocks (which
is also OK, since this feature is not needed).
-
Requires non-intuitive user code to create and destroy the Pool.
-
Efficient C++: Performance Programming Techniques,
by Dov Bulka and David Mayhew, Chapters 6 and 7.
-
This is a good example of iteratively developing a Pool solutio.
-
however, their premise (that the system-supplied allocation mechanism
is hopelessly inefficient) is flawed on every system I've tested
on.
-
Run their timings on your system before you accept their conclusions.
-
Missing aspect: Requires non-intuitive user code to create and
destroy the Pool.
-
Advanced C++: Programming Styles and Idioms, by
James O. Coplien, Section 3.6.
-
Has examples of both static and dynamic pooling, but missing aspects:
-
Not thread-safe.
-
The static pooling example is not portable.
