std.experimental.allocator.building_blocks.bucketizer - D Programming Language

D Programming Language
Report a bug If you spot a problem with this page, click here to create a Bugzilla issue. Improve this page Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

# 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.experimental.allocator.building_blocks.free_list : FreeList;
      import std.experimental.allocator.mallocator : Mallocator;
      import std.experimental.allocator.common : unbounded;
      Bucketizer!(FreeList!(Mallocator, 0, unbounded),
          65, 512, 64) a;
      auto b = a.allocate(400);
      assert(b.length == 400);
      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.
  void[] resolveInternalPointer(void* p);
    This method is only defined if all allocators involved define resolveInternalPointer, and tries it for each bucket in turn.

Copyright © 1999-2015 by Digital Mars ®, All Rights Reserved | Page generated by Ddoc on Thu Dec 3 01:39:48 2015