AffixAllocator

Allocator that adds some extra data before (of type Prefix) and/or after (of type Suffix) any allocation made with its parent allocator. This is useful for uses where additional allocation-related information is needed, such as mutexes, reference counts, or walls for debugging memory corruption errors.

If Prefix is not void, Allocator must guarantee an alignment at least as large as Prefix.alignof.

Suffixes are slower to get at because of alignment rounding, so prefixes should be preferred. However, small prefixes blunt the alignment so if a large alignment with a small affix is needed, suffixes should be chosen.

The following methods are defined if Allocator defines them, and forward to it: deallocateAll, empty, owns.

struct AffixAllocator (

Allocator

Prefix

Suffix = void

) {

import mir.utility : min;;

import mir.conv : emplace;;

import stdx.allocator : IAllocator, theAllocator;;

import stdx.allocator.common : stateSize, forwardToMember, roundUpToMultipleOf, alignedAt, alignDownTo, roundUpToMultipleOf, hasStaticallyKnownAlignment;;

import stdx.allocator.internal : isPowerOf2;;

import stdx.allocator.internal : Ternary;;

static if(hasStaticallyKnownAlignment!Allocator)

enum uint alignment;

static if(!(hasStaticallyKnownAlignment!Allocator))

static if(is(Prefix == void))

enum uint alignment;

static if(!(hasStaticallyKnownAlignment!Allocator))

static if(!(is(Prefix == void)))

enum uint alignment;

static if(stateSize!Allocator)

Allocator _parent;

static if(stateSize!Allocator)
static if(is(Allocator == IAllocator))

Allocator parent();

alias parent = _parent;

alias parent = Allocator.instance;

version(StdDdoc)

size_t goodAllocSize(size_t );

version(StdDdoc)

void[] allocate(size_t );

version(StdDdoc)

Ternary owns(void[] );

version(StdDdoc)

bool expand(void[] b, size_t delta);

version(StdDdoc)

bool reallocate(void[] b, size_t s);

version(StdDdoc)

bool deallocate(void[] b);

version(StdDdoc)

bool deallocateAll();

version(StdDdoc)

Ternary empty();

version(StdDdoc)

AffixAllocator instance;

version(StdDdoc)

static auto ref prefix(T[] b);

version(StdDdoc)

auto ref suffix(T[] b);

mixin Impl!true ;

version(!StdDdoc)

static if(!(is(typeof(Allocator.instance) == shared)))

static if(stateSize!Allocator == 0)

enum AffixAllocator instance;

mixin Impl!true ;

mixin Impl!false ;

}

Members

Aliases

parent alias parent = _parent: Undocumented in source.
parent alias parent = Allocator.instance: Undocumented in source.

Functions

allocate void[] allocate(size_t )
deallocate bool deallocate(void[] b)
deallocateAll bool deallocateAll()
empty Ternary empty()
expand bool expand(void[] b, size_t delta): Standard allocator methods. Each is defined if and only if the parent allocator defines the homonym method (except for goodAllocSize, which may use the global default). Also, the methods will be shared if the parent allocator defines them as such.
goodAllocSize size_t goodAllocSize(size_t )
owns Ternary owns(void[] ): Standard allocator methods. Each is defined if and only if the parent allocator defines the homonym method (except for goodAllocSize, which may use the global default). Also, the methods will be shared if the parent allocator defines them as such.
parent Allocator parent(): Undocumented in source. Be warned that the author may not have intended to support it.
reallocate bool reallocate(void[] b, size_t s): Standard allocator methods. Each is defined if and only if the parent allocator defines the homonym method (except for goodAllocSize, which may use the global default). Also, the methods will be shared if the parent allocator defines them as such.
suffix auto ref suffix(T[] b): Affix access functions offering references to the affixes of a block b previously allocated with this allocator. b may not be null. They are defined if and only if the corresponding affix is not void.

Mixins

__anonymous mixin Impl!true: Undocumented in source.
__anonymous mixin Impl!true: Undocumented in source.
__anonymous mixin Impl!false: Undocumented in source.

Static functions

prefix auto ref prefix(T[] b): Affix access functions offering references to the affixes of a block b previously allocated with this allocator. b may not be null. They are defined if and only if the corresponding affix is not void.

Static variables

instance AffixAllocator instance;: The instance singleton is defined if and only if the parent allocator has no state and defines its own it object.

Variables

_parent Allocator _parent;: If the parent allocator Allocator is stateful, an instance of it is stored as a member. Otherwise, AffixAllocator uses Allocator.instance. In either case, the name _parent is uniformly used for accessing the parent allocator.
alignment enum uint alignment;: If Prefix is void, the alignment is that of the parent. Otherwise, the alignment is the same as the Prefix's alignment.
alignment enum uint alignment;: Undocumented in source.
alignment enum uint alignment;: Undocumented in source.
instance enum AffixAllocator instance;: Undocumented in source.

Examples

import stdx.allocator.mallocator : Mallocator;
// One word before and after each allocation.
alias A = AffixAllocator!(Mallocator, size_t, size_t);
auto b = A.instance.allocate(11);
A.instance.prefix(b) = 0xCAFE_BABE;
A.instance.suffix(b) = 0xDEAD_BEEF;
assert(A.instance.prefix(b) == 0xCAFE_BABE
    && A.instance.suffix(b) == 0xDEAD_BEEF);

Meta

Source

See Implementation

stdx allocator building_blocks affix_allocator structs

AffixAllocator