W3cubDocs

/D

std.experimental.allocator.building_blocks.bucketizer

struct Bucketizer(Allocator, size_t min, size_t max, size_t step)

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.

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);
writeln(b.length); // 400
writeln(a.owns(b)); // Ternary.yes
void[] p;
a.deallocate(b);
Allocator[(max + 1 - min) / step] buckets

The array of allocators is publicly available for e.g. initialization and inspection.

enum uint alignment

The alignment offered is the same as Allocator.alignment.

const size_t goodAllocSize(size_t bytes)

Rounds up to the maximum size of the bucket in which bytes falls.

void[] allocate(size_t bytes)

Directs the call to either one of the buckets allocators.

void[] alignedAllocate(size_t bytes, uint a)

Directs the call to either one of the buckets allocators. Defined only if Allocator defines alignedAllocate.

bool expand(ref 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].

bool reallocate(ref 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.

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

Similar to reallocate, with alignment. Defined only if Allocator defines alignedReallocate.

Ternary owns(void[] b)

Defined only if Allocator defines owns. Finds the owner of b and forwards the call to it.

bool deallocate(void[] b)

This method is only defined if Allocator defines deallocate.

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.

Ternary resolveInternalPointer(const void* p, ref void[] result)

This method is only defined if all allocators involved define resolveInternalPointer, and tries it for each bucket in turn.

© 1999–2017 The D Language Foundation
Licensed under the Boost License 1.0.
https://dlang.org/phobos/std_experimental_allocator_building_blocks_bucketizer.html