[#BloombergLP-bdlma]
= xref:BloombergLP.adoc[BloombergLP]::bdlma
:relfileprefix: ../
:mrdocs:

Namespace for managed allocator components&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlma/AlignedAllocator.adoc[`AlignedAllocator`] 
| Protocol for clients and suppliers of raw aligned memory&period;
| xref:BloombergLP/bdlma/AligningAllocator.adoc[`AligningAllocator`] 
| Allocator wrapper that guarantees a specified minimum alignment&period;
| xref:BloombergLP/bdlma/AutoReleaser.adoc[`AutoReleaser`] 
| This class implements a proctor that invokes the `release` method of its managed allocator or pool at destruction unless the proctor&apos;s `release` method is invoked&period;
| xref:BloombergLP/bdlma/BlockList.adoc[`BlockList`] 
| Low&hyphen;level memory manager that allocates and manages a sequence of memory blocks&period;
| xref:BloombergLP/bdlma/BufferImpUtil.adoc[`BufferImpUtil`] 
| This `struct` provides a namespace for a suite of pure procedures for allocating memory from a buffer&period;
| xref:BloombergLP/bdlma/BufferManager.adoc[`BufferManager`] 
| Memory manager that dispenses heterogeneous blocks from an external buffer&period;
| xref:BloombergLP/bdlma/BufferedSequentialAllocator.adoc[`BufferedSequentialAllocator`] 
| Fast allocator that dispenses heterogeneous blocks from an external buffer&period;
| xref:BloombergLP/bdlma/BufferedSequentialPool.adoc[`BufferedSequentialPool`] 
| Fast memory pool dispensing blocks from an external buffer&period;
| xref:BloombergLP/bdlma/ConcurrentAllocatorAdapter.adoc[`ConcurrentAllocatorAdapter`] 
| Thread&hyphen;enabled adapter that synchronizes access to a decorated allocator&period;
| xref:BloombergLP/bdlma/ConcurrentFixedPool.adoc[`ConcurrentFixedPool`] 
| Thread&hyphen;safe pool of a fixed number of uniformly sized memory blocks&period;
| xref:BloombergLP/bdlma/ConcurrentFixedPool_Node.adoc[`ConcurrentFixedPool&lowbar;Node`] 
| The component&hyphen;private `struct` provides a header for blocks that are allocated from `ConcurrentFixedPool` objects&period;
| xref:BloombergLP/bdlma/ConcurrentMultipool.adoc[`ConcurrentMultipool`] 
| Thread&hyphen;safe multipool that manages memory via size&hyphen;tiered pools&period;
| xref:BloombergLP/bdlma/ConcurrentMultipoolAllocator.adoc[`ConcurrentMultipoolAllocator`] 
| Thread&hyphen;safe allocator managing pools of varying block sizes&period;
| xref:BloombergLP/bdlma/ConcurrentPool.adoc[`ConcurrentPool`] 
| Thread&hyphen;safe memory pool that allocates and manages uniformly sized blocks&period;
| xref:BloombergLP/bdlma/ConcurrentPoolAllocator.adoc[`ConcurrentPoolAllocator`] 
| Thread&hyphen;safe allocator that manages pooled memory blocks of uniform size&period;
| xref:BloombergLP/bdlma/CountingAllocator.adoc[`CountingAllocator`] 
| Concrete allocator that counts bytes currently in use and ever allocated&period;
| xref:BloombergLP/bdlma/DefaultDeleter.adoc[`DefaultDeleter`] 
| Provide a default concrete implementation of the `Deleter` protocol&period;
| xref:BloombergLP/bdlma/Deleter.adoc[`Deleter`] 
| Provide a protocol (or pure interface) for a thread&hyphen;safe object deleter&period;
| xref:BloombergLP/bdlma/Factory.adoc[`Factory`] 
| Provide a protocol for a thread&hyphen;safe object creator and deleter&period;
| xref:BloombergLP/bdlma/GuardingAllocator.adoc[`GuardingAllocator`] 
| Concrete thread&hyphen;safe guarding allocator that adjoins a protected guard page to each allocated block&period;
| xref:BloombergLP/bdlma/HeapBypassAllocator.adoc[`HeapBypassAllocator`] 
| Memory allocator that obtains storage directly from virtual memory&period;
| xref:BloombergLP/bdlma/InfrequentDeleteBlockList.adoc[`InfrequentDeleteBlockList`] 
| Low&hyphen;level memory manager that allocates and manages a sequence of memory blocks&period;
| xref:BloombergLP/bdlma/LocalBufferedObject.adoc[`LocalBufferedObject`] 
| Holds a `t&lowbar;TYPE` object with a local sequential allocator arena&period;
| xref:BloombergLP/bdlma/LocalSequentialAllocator.adoc[`LocalSequentialAllocator`] 
| Fast allocator that dispenses heterogeneous blocks from a local buffer&period;
| xref:BloombergLP/bdlma/ManagedAllocator.adoc[`ManagedAllocator`] 
| Protocol for allocators that support releasing all allocated memory&period;
| xref:BloombergLP/bdlma/MemoryBlockDescriptor.adoc[`MemoryBlockDescriptor`] 
| In&hyphen;core value&hyphen;semantic class describing the size and address of a memory block&period;
| xref:BloombergLP/bdlma/Multipool.adoc[`Multipool`] 
| Memory manager that maintains a configurable number of size&hyphen;tiered pools&period;
| xref:BloombergLP/bdlma/MultipoolAllocator.adoc[`MultipoolAllocator`] 
| Allocator that manages pools of memory blocks of varying sizes&period;
| xref:BloombergLP/bdlma/Pool.adoc[`Pool`] 
| This class implements a memory pool that allocates and manages memory blocks of some uniform size specified at construction&period;
| xref:BloombergLP/bdlma/SequentialAllocator.adoc[`SequentialAllocator`] 
| Fast allocator that dispenses heterogeneous blocks from dynamically allocated buffers&period;
| xref:BloombergLP/bdlma/SequentialPool.adoc[`SequentialPool`] 
| Fast memory pool dispensing heterogeneous blocks from dynamic buffers&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlma/operator_eq.adoc[`operator&equals;&equals;`] 
| Return `true` if the specified `lhs` and `rhs` have the same value&period;
| xref:BloombergLP/bdlma/operator_not_eq.adoc[`operator!&equals;`] 
| Return `true` if the specified `lhs` and `rhs` do not have the same value&period;
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
