upstream/postgresql
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2026-05-27 03:42:28 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Make local buffers pin limit more conservative

Browse source 
GetLocalPinLimit() and GetAdditionalLocalPinLimit(), currently in use
only by the read stream, previously allowed a backend to pin all
num_temp_buffers local buffers. This meant that the read stream could
use every available local buffer for read-ahead, leaving none for other
concurrent pin-holders like other read streams and related buffers like
the visibility map buffer needed during on-access pruning.

This became more noticeable since b46e1e54d0, which allows on-access
pruning to set the visibility map, which meant that some scans also
needed to pin a page of the VM. It caused a test in
src/test/regress/sql/temp.sql to fail in some cases.

Cap the local pin limit to num_temp_buffers / 4, providing some
headroom. This doesn't guarantee that all needed pins will be available
— for example, a backend can still open more cursors than there are
buffers — but it makes it less likely that read-ahead will exhaust the
pool.

Note that these functions are not limited by definition to use in the
read stream; however, this cap should be appropriate in other contexts.

Reported-by: Alexander Lakhin <exclusion@gmail.com>
Author: Melanie Plageman <melanieplageman@gmail.com>
Reviewed-by: Andres Freund <andres@anarazel.de>
Discussion: https://postgr.es/m/97529f5a-ec10-46b1-ab50-4653126c6889%40gmail.com
This commit is contained in:
Melanie Plageman 2026-04-21 11:01:57 -04:00
parent 1cd3cd372a
commit da6874635d
1 changed files with 11 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/backend/storage/buffer/localbuf.c
View file

@ -307,16 +307,24 @@ GetLocalVictimBuffer(void)
uint32
GetLocalPinLimit(void)
{
/* Every backend has its own temporary buffers, and can pin them all. */
return num_temp_buffers;
/*
* Every backend has its own temporary buffers, but we leave headroom for
* concurrent pin-holders -- like multiple scans in the same query.
*/
return num_temp_buffers / 4;
}
/* see GetAdditionalPinLimit() */
uint32
GetAdditionalLocalPinLimit(void)
{
uint32 total = GetLocalPinLimit();
Assert(NLocalPinnedBuffers <= num_temp_buffers);
return num_temp_buffers - NLocalPinnedBuffers;
if (NLocalPinnedBuffers >= total)
return 0;
return total - NLocalPinnedBuffers;
}
/* see LimitAdditionalPins() */