ISharedAllocator

Dynamic shared allocator interface. Code that defines allocators shareable across threads ultimately implements this interface. This should be used wherever a uniform type is required for encapsulating various allocator implementations.

Composition of allocators is not recommended at this level due to inflexibility of dynamic interfaces and inefficiencies caused by cascaded multiple calls. Instead, compose allocators using the static interface defined in $(A std_experimental_allocator_building_blocks.html, `stdx.allocator.building_blocks`), then adapt the composed allocator to ISharedAllocator (possibly by using CSharedAllocatorImpl below).

Methods returning Ternary return Ternary.yes upon success, Ternary.no upon failure, and Ternary.unknown if the primitive is not implemented by the allocator instance.

version(HasDRuntime)

interface ISharedAllocator {

uint alignment [@property getter];

size_t goodAllocSize(size_t s);

void[] allocate(size_t , TypeInfo ti);

void[] alignedAllocate(size_t n, uint a);

void[] allocateAll();

bool expand(void[] , size_t );

bool reallocate(void[] , size_t );

bool alignedReallocate(void[] b, size_t size, uint alignment);

Ternary owns(void[] b);

Ternary resolveInternalPointer(void* p, void[] result);

bool deallocate(void[] b);

bool deallocateAll();

Ternary empty();

}

Members

Functions

alignedAllocate void[] alignedAllocate(size_t n, uint a): Allocates n bytes of memory with specified alignment a. Implementations that do not support this primitive should always return null.
alignedReallocate bool alignedReallocate(void[] b, size_t size, uint alignment): Reallocates a memory block with specified alignment.
allocate void[] allocate(size_t , TypeInfo ti): Allocates n bytes of memory.
allocateAll void[] allocateAll(): Allocates and returns all memory available to this allocator. Implementations that do not support this primitive should always return null.
deallocate bool deallocate(void[] b): Deallocates a memory block. Implementations that don't support this primitive should always return false. A simple way to check that an allocator supports deallocation is to call deallocate(null).
deallocateAll bool deallocateAll(): Deallocates all memory. Implementations that don't support this primitive should always return false.
empty Ternary empty(): Returns Ternary.yes if no memory is currently allocated from this allocator, Ternary.no if some allocations are currently active, or Ternary.unknown if not supported.
expand bool expand(void[] , size_t ): Expands a memory block in place and returns true if successful. Implementations that don't support this primitive should always return false.
goodAllocSize size_t goodAllocSize(size_t s): Returns the good allocation size that guarantees zero internal fragmentation.
owns Ternary owns(void[] b): Returns Ternary.yes if the allocator owns b, Ternary.no if the allocator doesn't own b, and Ternary.unknown if ownership cannot be determined. Implementations that don't support this primitive should always return Ternary.unknown.
reallocate bool reallocate(void[] , size_t ): Reallocates a memory block.
resolveInternalPointer Ternary resolveInternalPointer(void* p, void[] result): Resolves an internal pointer to the full block allocated. Implementations that don't support this primitive should always return Ternary.unknown.

Properties

alignment uint alignment [@property getter]: Returns the alignment offered.

ISharedAllocator

Members

Functions

Properties

Meta

Source