Direct3D 12 Memory Allocator
No Matches
General considerations

Thread safety

  • The library has no global state, so separate D3D12MA::Allocator objects can be used independently. In typical applications there should be no need to create multiple such objects though - one per ID3D12Device is enough.
  • All calls to methods of D3D12MA::Allocator class are safe to be made from multiple threads simultaneously because they are synchronized internally when needed.
  • When the allocator is created with D3D12MA::ALLOCATOR_FLAG_SINGLETHREADED, calls to methods of D3D12MA::Allocator class must be made from a single thread or synchronized by the user. Using this flag may improve performance.
  • D3D12MA::VirtualBlock is not safe to be used from multiple threads simultaneously.

Versioning and compatibility

The library uses Semantic Versioning, which means version numbers follow convention: Major.Minor.Patch (e.g. 2.3.0), where:

  • Incremented Patch version means a release is backward- and forward-compatible, introducing only some internal improvements, bug fixes, optimizations etc. or changes that are out of scope of the official API described in this documentation.
  • Incremented Minor version means a release is backward-compatible, so existing code that uses the library should continue to work, while some new symbols could have been added: new structures, functions, new values in existing enums and bit flags, new structure members, but not new function parameters.
  • Incrementing Major version means a release could break some backward compatibility.

All changes between official releases are documented in file "".

Backward compatiblity is considered on the level of C++ source code, not binary linkage. Adding new members to existing structures is treated as backward compatible if initializing the new members to binary zero results in the old behavior. You should always fully initialize all library structures to zeros and not rely on their exact binary size.

Features not supported

Features deliberately excluded from the scope of this library:

  • Descriptor allocation. Although also called "heaps", objects that represent descriptors are separate part of the D3D12 API from buffers and textures. You can still use Virtual allocator to manage descriptors and their ranges inside a descriptor heap.
  • Support for reserved (tiled) resources. We don't recommend using them.
  • Support for ID3D12Device::Evict and MakeResident. We don't recommend using them. You can call them on the D3D12 objects manually. Plese keep in mind, however, that eviction happens on the level of entire ID3D12Heap memory blocks and not individual buffers or textures which may be placed inside them.
  • Handling CPU memory allocation failures. When dynamically creating small C++ objects in CPU memory (not the GPU memory), allocation failures are not handled gracefully, because that would complicate code significantly and is usually not needed in desktop PC applications anyway. Success of an allocation is just checked with an assert.
  • Code free of any compiler warnings. There are many preprocessor macros that make some variables unused, function parameters unreferenced, or conditional expressions constant in some configurations. The code of this library should not be bigger or more complicated just to silence these warnings. It is recommended to disable such warnings instead.
  • This is a C++ library. Bindings or ports to any other programming languages are welcome as external projects but are not going to be included into this repository.