CGAL 5.2.2 - Manual
|
One of the design goals of CGAL (Section Primary design goals ) is efficiency, and this means not only implementing efficient algorithms but also implementing them efficiently. One way to improve the efficiency of an implementation is through efficient memory management. This can be done by making the library data structures independent of the underlying memory model. However, to avoid unacceptable efficiency degradations complete abstraction of the memory model should be avoided. Here we describe one way to address this using allocators. An allocator encapsulates the information about an allocation model.
We adopted the definition of the Standard C++ allocator [4]. The std::allocator
is the only predefined and required allocator imposed by [C++] on all C++ compiler implementations. The exact specification can also be found at https://en.wikipedia.org/wiki/Allocator_(C++)
.
Objects of type std::allocator<T>
can be used to obtain small, typed chunks of memory to be used, for example, as static members of a class. This is especially interesting with classes of a constant size that are frequently allocated and deallocated (e.g., points, lines, circles), since a memory allocator can maintain the corresponding memory chunks in local blocks and thus can answer allocation and deallocation calls much faster than the corresponding system calls.
The macro CGAL_ALLOCATOR(T)
is defined as std::allocator<T>
in the file <CGAL/memory.h>
. CGAL_ALLOCATOR
is used as the default allocator for all CGAL components. You can redefine it, for example, if LEDA is present, you can define it (before including any CGAL header file) as follows:
How should a data structure use the allocator mechanism? Just make the allocator one of the template arguments of the data structure. Then use a static member object to allocate items on the heap that you want to keep optimized regarding allocation and deallocation. We show an example using a trivial list structure:
Recommendations:
CGAL_ALLOCATOR
) for data structures for which an optimization with regard to allocation and deallocation is beneficial.