Open fzhinkin opened 2 months ago
The first two points (not returning segments back to the pool and small pool size) are blockers for integration with Ktor (https://youtrack.jetbrains.com/issue/KTOR-6030, https://github.com/ktorio/ktor/pull/4032), so they need to be fixed.
It would be great to have a system property to adjust the pool size as well
As @bjhham pointed out, Buffer::close
should release segments (currently, it's no-op).
However, it could be problematic, as a typical Buffer use scenario is "allocate, use, and forget".
Maybe we can try to fix this by manual allocation buffer for writing using a different constructor method, so the buffers for channels and primitives in Ktor will be tracked
make sure every segment is returned to a pool once there are no users remaining
One of the scenarios when a segment is not returned to the pool is when is was shared between multiple buffers. Currently, it's tracked by a flag, so there's no way to check if a segment can be safely returned back to the pool.
Replacing a flag with a ref-counter solves the issue and the performance impact seems neglectable.
The issue with changing the default pool size is how this property is used: currently, the pool consists of multiple chunks (the number depends on CPU count), and the property applies to each chunk individually. In an unlucky scenario, we may end up with all buckets being filled up with pooled segments, but only one of them will be used.
This place is tricky in terms of performance, I need to research a bit more what could be done.
You may try using the same strategy as for connection pool with lazy allocation and releasing allocated buffers through time
Currently, I'm gravitating towards a solution with a two-tier segment pool:
Some of the issues from the summary are addressed here: #352
Currently, segment pools exist only on JVM (on other platforms, implementations are effectively no-op) and behave more like caches than pools.
There are a few directions in which we may/should develop segment pools:
This is an epic describing what could be done and tracking progress rather than an instruction to what should be implemented.