Bucketizer

A Bucketizer uses distinct allocators for handling allocations of sizes in the intervals [min, min + step - 1], [min + step, min + 2 * step - 1], [min + 2 * step, min + 3 * step - 1], ..., [max - step + 1, max].

Bucketizer holds a fixed-size array of allocators and dispatches calls to them appropriately. The size of the array is (max + 1 - min) / step, which must be an exact division.

Allocations for sizes smaller than min or larger than max are illegal for Bucketizer. To handle them separately, Segregator may be of use.

struct Bucketizer (

Allocator

size_t min

size_t max

size_t step

) {

eponymoustemplate hasMember(T, string name) via import std.traits : hasMember;;

struct Ternary via import std.typecons : Ternary;;

Allocator[(max + 1 - min) / step] buckets;

enum uint alignment;

size_t goodAllocSize(size_t bytes);

void[] allocate(size_t bytes);

static if(hasMember!(Allocator, "alignedAllocate"))

void[] alignedAllocate(size_t bytes, uint alignment);

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

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

static if(hasMember!(Allocator, "alignedReallocate"))

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

static if(hasMember!(Allocator, "owns"))

Ternary owns(void[] b);

static if(hasMember!(Allocator, "deallocate"))

bool deallocate(void[] b);

static if(hasMember!(Allocator, "deallocateAll"))

bool deallocateAll();

static if(hasMember!(Allocator, "resolveInternalPointer"))

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

}

Members

Functions

alignedAllocate void[] alignedAllocate(size_t bytes, uint alignment): Allocates the requested bytes of memory with specified alignment. Directs the call to either one of the buckets allocators. Defined only if Allocator defines alignedAllocate.
alignedReallocate bool alignedReallocate(void[] b, size_t size, uint a): Similar to reallocate, with alignment. Defined only if Allocator defines alignedReallocate.
allocate void[] allocate(size_t bytes): Directs the call to either one of the buckets allocators.
deallocate bool deallocate(void[] b): This method is only defined if Allocator defines deallocate.
deallocateAll bool deallocateAll(): This method is only defined if all allocators involved define deallocateAll, and calls it for each bucket in turn. Returns true if all allocators could deallocate all.
expand bool expand(void[] b, size_t delta): This method allows expansion within the respective bucket range. It succeeds if both b.length and b.length + delta fall in a range of the form [min + k * step, min + (k + 1) * step - 1].
goodAllocSize size_t goodAllocSize(size_t bytes): Rounds up to the maximum size of the bucket in which bytes falls.
owns Ternary owns(void[] b): Defined only if Allocator defines owns. Finds the owner of b and forwards the call to it.
reallocate bool reallocate(void[] b, size_t size): This method allows reallocation within the respective bucket range. If both b.length and size fall in a range of the form [min + k * step, min + (k + 1) * step - 1], then reallocation is in place. Otherwise, reallocation with moving is attempted.
resolveInternalPointer Ternary resolveInternalPointer(void* p, void[] result): This method is only defined if all allocators involved define resolveInternalPointer, and tries it for each bucket in turn.

Variables

alignment enum uint alignment;: The alignment offered is the same as Allocator.alignment.
buckets Allocator[(max + 1 - min) / step] buckets;: The array of allocators is publicly available for e.g. initialization and inspection.

Examples

import std.algorithm.comparison : max;
import std.experimental.allocator.building_blocks.allocator_list : AllocatorList;
import std.experimental.allocator.building_blocks.free_list : FreeList;
import std.experimental.allocator.building_blocks.region : Region;
import std.experimental.allocator.common : unbounded;
import std.experimental.allocator.mallocator : Mallocator;
import std.typecons : Ternary;
Bucketizer!(
    FreeList!(
        AllocatorList!(
            (size_t n) => Region!Mallocator(max(n, 1024 * 1024))),
        0, unbounded),
    65, 512, 64) a;
auto b = a.allocate(400);
assert(b.length == 400);
assert(a.owns(b) == Ternary.yes);
a.deallocate(b);

The OpenD Programming Language

Bucketizer

Members

Functions

Variables

Examples

Meta

Source