Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
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 a local clone.

# std.experimental.allocator.building_blocks.bucketizer

Source std/experimental/allocator/building_blocks/bucketizer.d

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
      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 pure nothrow @nogc @safe 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 `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`.
  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.

Copyright © 1999-2023 by the D Language Foundation | Page generated by Ddoc on Wed Mar 1 14:57:22 2023