How to configure the SingleBufferAllocationLimitBytes in MemoryAllocator

[Socolin]

Hello,

I need to increase the size of SingleBufferAllocationLimitBytes but I cannot find any option to do this, since this line is always forcing it to be lower or equals to the default value of SingleBufferAllocationLimitBytes that is 1GB

 this.SingleBufferAllocationLimitBytes = (int)Math.Min(this.SingleBufferAllocationLimitBytes, this.MemoryGroupAllocationLimitBytes);

internal int SingleBufferAllocationLimitBytes { get; private protected set; } = OneGigabyte;

Also just some feedback on implementing a custom MemoryAllocator, I tried to create my own allocator class to workaround this but there are a lot of private and internal things that make it hard, and I found a blocker: ApplyOptions cannot be called at all, so it's not possible to create it's own allocator

[Socolin]

Also the SingleBufferAllocationLimitBytes is an int would it be possible to increase this to a long to allocate image bigger than 2GB ?

[JimBobSquarePants]

Thanks for the detailed feedback; all three points were fair, and #3165 addresses them.

Configuring SingleBufferAllocationLimitBytes. MemoryAllocatorOptions now has a SingleBufferAllocationLimitMegabytes option, so you can raise the 1 GB default without writing an allocator:

MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions
{
    // Raise the contiguous single-buffer cap from the 1 GB default to the 2 GB ceiling.
    SingleBufferAllocationLimitMegabytes = 2047,

    // Optional: the total per-image limit for discontiguous groups. Default is 4 GB on 64-bit.
    AllocationLimitMegabytes = 8192
});

Configuration.Default.MemoryAllocator = allocator;

The line you found no longer clamps unconditionally: an explicit single-buffer value wins, capped only by the group limit, because one buffer can never exceed the total allocation budget.

Custom allocators. The extensibility gaps are closed. MemoryGroupAllocationLimitBytes, SingleBufferAllocationLimitBytes, and AccumulativeAllocationLimitBytes are now public with protected setters, and ApplyOptions is now protected, so your constructor can accept a MemoryAllocatorOptions the same way the built-in allocators do. A complete external allocator is: derive from MemoryAllocator, implement GetBufferCapacityInBytes and AllocateCore, and return your own AllocationTrackedMemoryManager<T> subclass — the base class handles validation and allocation tracking for you. We also have a dedicated public-API test project that implements a full allocator outside the ImageSharp assembly, so these seams cannot silently regress again.

int versus long for the single-buffer limit. This one stays int by design. A single contiguous buffer flows through Memory<T>/Span<T>, and our buffer internals size in bytes as int, so one buffer tops out just under 2 GB. Images larger than that already work: they allocate as discontiguous memory groups, governed by AllocationLimitMegabytes, and the processing pipeline handles multi-buffer images throughout. If you can, leave Configuration.PreferContiguousImageBuffers off for very large images and let the group allocator do its job.

[Socolin]

Thanks you for the fixes and the detailed answer ! I'll check when I have the opportunity (in a few weeks)