You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
perf: let the recycling frame allocator cache a wide fan-out - #485
Each size class used to keep at most 16 blocks per thread and 16 more in the shared pool. A fan-out with more live frames than that sent every further allocation and free through the shared pool's mutex to the upstream allocator.
Changes
Intrusive free lists. Cached blocks are linked through their own storage, so a bucket's capacity no longer depends on a fixed array. Each pool caches up to 256 KiB per size class: 4096 blocks of 64 bytes, down to 128 of 2048 bytes.
Refill is a pointer swap. A thread that runs out still takes the shared pool's whole bucket, but no longer copies its entries under the lock.
Decay. A thread keeps a burst's blocks only while it goes on using them.
Each bucket tracks the fewest blocks it held since the last check: that many sat unused all period.
Every 4096 frees plus refilled blocks on the thread, half of those idle blocks move to the shared pool, or go back to ::operator delete when the shared pool has no room.
Allocations served from the thread's own pool aren't counted, so that path is unchanged.
The walk through the blocks happens outside the lock.
Worst-case cached memory is bounded by the caps: (threads + 1) × 1.5 MiB.
Tests
New tests cover a fan-out wider than the old caps, an idle burst that decays, a recurring burst that stays cached, an idle burst while the shared pool is full, and a thread that only allocates.
Each size class kept at most 16 blocks per thread and 16 more in the
shared pool. A fan-out with more live frames than that sent every
further allocation and free through the shared pool's mutex to the
upstream allocator.
Cached blocks are now linked through their own storage, so a bucket's
capacity no longer depends on a fixed array. Each pool caches up to
256 KiB per size class.
A thread keeps a burst's blocks only while it goes on using them. Each
bucket tracks the fewest blocks it held since its last check. Every few
thousand frees and refilled blocks on the thread, half of those idle
blocks move to the shared pool, where any thread can reuse them, or go
back to the upstream allocator when the shared pool has no room.
No actionable comments were generated in the recent review.
Walkthrough
The recycling memory resource now stores cached blocks in intrusive per-size-class lists with capacity derived from a 256 KiB limit. It tracks arrivals and periodically moves idle blocks to the global pool or releases them.
Changes: Thread-local cache lifecycle
Layer / File(s)
Summary
Per-class bucket model include/boost/capy/ex/recycling_memory_resource.hpp
The fixed pointer arrays are replaced by intrusive lists with count and low-water tracking. Each size class has a calculated capacity based on the 256 KiB limit.
Cache operations and decay include/boost/capy/ex/recycling_memory_resource.hpp, src/ex/recycling_memory_resource.cpp
Allocation and deallocation update local and global buckets. After the arrival threshold is reached, decay removes half of each bucket’s low-water count. It transfers a share only when the global bucket can accept it in full; otherwise, it releases the share with operator delete.
sequenceDiagram
participant LocalPool
participant GlobalPool
participant OperatorDelete as operator delete
LocalPool->>LocalPool: Unlink half of each bucket's low-water count
LocalPool->>GlobalPool: Lock and check whether each share fits
alt Entire share fits
LocalPool->>GlobalPool: Transfer cached blocks
else Share does not fit
LocalPool->>OperatorDelete: Release cached blocks outside the lock
end
Loading
Suggested reviewers:vinniefalco, mvandeberg
Merge Risk: Minimal · up to d1da1
This change lets the recycling frame allocator cache more blocks per size class and gradually release idle ones. The review found no concrete defect that should block merging, and the description reports no test results.
Pre-merge checks: 4
Check name
Status
Explanation
Title check
The title names the main change: letting the recycling frame allocator cache a wide fan-out. The objectives confirm the change raises the per-size-class cache from 16 blocks to up to 256 KiB, using in…
Linked Issues check
Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check
Check skipped because no linked issues were found for this pull request.
Description Check
Check skipped - CodeRabbit’s high-level summary is enabled.
Full details: Title check
Explanation
The title names the main change: letting the recycling frame allocator cache a wide fan-out. The objectives confirm the change raises the per-size-class cache from 16 blocks to up to 256 KiB, using intrusive free lists and a decay policy. The title is concise, specific, and matches the changeset. The conventional 'perf:' prefix is acceptable.
Finishing Touches
Generate unit tests (beta)
Create a new PR
Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts
A rabbit checks the buckets in the morning light Intrusive lists keep cached blocks in sight The local pool counts arrivals as they flow Half the idle blocks move when decay says so The global pool takes what fits its space The rest returns to its allocated place
Included review availability: This review used your included allowance. Your plan provides up to 1 included review per hour; 0 remain after this review.
[Medium impact] The PR appears safe to merge; no actionable issues were found.
Summary
Replaces fixed pointer arrays with linked lists stored inside cached blocks and raises each size class's cache limit to 256 KiB.
Wide frame bursts stay in the recycling pools.
Idle cached blocks flow back for reuse.
Diagram
%%{init: {'theme': 'neutral'}}%%
flowchart TD
A[Allocate] --> B{Local bucket has a block?}
B -->|Yes| C[Return one block]
B -->|No| D[Take shared bucket under lock]
D --> E{Got a block?}
E -->|Yes| F[Count refill and check decay]
E -->|No| G[Allocate upstream]
H[Free] --> I[Count arrival and check decay]
I --> J{Local bucket has room?}
J -->|Yes| K[Cache locally]
J -->|No| L{Shared bucket has room?}
L -->|Yes| M[Cache under lock]
L -->|No| N[Release upstream]
F --> O[Move half the idle blocks]
I --> O
O --> P[Share under lock or release outside lock]
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Each size class used to keep at most 16 blocks per thread and 16 more in the shared pool. A fan-out with more live frames than that sent every further allocation and free through the shared pool's mutex to the upstream allocator.
Changes
::operator deletewhen the shared pool has no room.Worst-case cached memory is bounded by the caps: (threads + 1) × 1.5 MiB.
Tests
New tests cover a fan-out wider than the old caps, an idle burst that decays, a recurring burst that stays cached, an idle burst while the shared pool is full, and a thread that only allocates.
Related
cppalliance/corosio#416 pairs with this branch for its benchmarks.
Summary by CodeRabbit