gh-133136: Limit excess memory held by QSBR - #135107
Conversation
Sorry, something went wrong.
The free threading build uses QSBR to delay the freeing of dictionary keys and list arrays when the objects are accessed by multiple threads in order to allow concurrent reads to proceeed with holding the object lock. The requests are processed in batches to reduce execution overhead, but for large memory blocks this can lead to excess memory usage. Take into account the size of the memory block when deciding when to process QSBR requests.
| should_advance_qsbr(_PyThreadStateImpl *tstate, size_t size) | ||
| { | ||
| // If the deferred memory exceeds 1 MiB, we force an advance in the | ||
| // shared QSBR sequence number to limit excess memory usage. | ||
| static const size_t QSBR_DEFERRED_LIMIT = 1024 * 1024; | ||
| if (size > QSBR_DEFERRED_LIMIT) { | ||
| tstate->qsbr->memory_deferred = 0; | ||
| return 1; | ||
| } | ||
|
|
||
| tstate->qsbr->memory_deferred += size; | ||
| if (tstate->qsbr->memory_deferred > QSBR_DEFERRED_LIMIT) { | ||
| tstate->qsbr->memory_deferred = 0; | ||
| return 1; | ||
| } | ||
| return 0; | ||
| } |
There was a problem hiding this comment.
Do we need early return here?
It looks like it will be same eventually.
| should_advance_qsbr(_PyThreadStateImpl *tstate, size_t size) | |
| { | |
| // If the deferred memory exceeds 1 MiB, we force an advance in the | |
| // shared QSBR sequence number to limit excess memory usage. | |
| static const size_t QSBR_DEFERRED_LIMIT = 1024 * 1024; | |
| if (size > QSBR_DEFERRED_LIMIT) { | |
| tstate->qsbr->memory_deferred = 0; | |
| return 1; | |
| } | |
| tstate->qsbr->memory_deferred += size; | |
| if (tstate->qsbr->memory_deferred > QSBR_DEFERRED_LIMIT) { | |
| tstate->qsbr->memory_deferred = 0; | |
| return 1; | |
| } | |
| return 0; | |
| } | |
| should_advance_qsbr(_PyThreadStateImpl *tstate, size_t size) | |
| { | |
| // If the deferred memory exceeds 1 MiB, we force an advance in the | |
| // shared QSBR sequence number to limit excess memory usage. | |
| static const size_t QSBR_DEFERRED_LIMIT = 1024 * 1024; | |
| tstate->qsbr->memory_deferred += size; | |
| if (tstate->qsbr->memory_deferred > QSBR_DEFERRED_LIMIT) { | |
| tstate->qsbr->memory_deferred = 0; | |
| return 1; | |
| } | |
| return 0; | |
| } |
Sorry, something went wrong.
|
Benchmarking script, based on issue. The reported numbers are the RSS (resident-set-size) of the process on 5 second intervals, in MB.
The last item shows about as good as we can expect to do by making the QSBR processing more aggressive at freeing. |
Sorry, something went wrong.
|
This PR definitely helps reduce the memory held by QSBR. But, I think we might do better without adding a lot of runtime performance cost. I'm working on a revised version of this PR, currently running some benchmarks on it. |
Sorry, something went wrong.
The free threading build uses QSBR to delay the freeing of dictionary keys and list arrays when the objects are accessed by multiple threads in order to allow concurrent reads to proceeed with holding the object lock. The requests are processed in batches to reduce execution overhead, but for large memory blocks this can lead to excess memory usage.
Take into account the size of the memory block when deciding when to process QSBR requests.