From c5f8bac945a622d4c8965f202b4dddc84438595c Mon Sep 17 00:00:00 2001 From: Nazir Bilal Yavuz Date: Thu, 27 Nov 2025 10:08:27 +0300 Subject: [PATCH v10 1/2] Add internal APIs for marking buffers dirty efficiently This commit introduces new internal bufmgr APIs for marking shared buffers as dirty: - MarkDirtyUnpinnedBufferInternal() - MarkDirtyUnpinnedBuffer() - MarkDirtyRelUnpinnedBuffers() - MarkDirtyAllUnpinnedBuffers() These functions provide efficient mechanisms to mark one buffer, all buffers of a relation, or the entire shared buffer pool as dirty. These APIs are intended primarily for developer tooling, debugging, and extensions that need to manipulate buffer dirtiness in bulk. They are not exposed through SQL in this commit and there are no user-visible changes. They will be used in the pg_buffercache extension in the subsequent commit. Author: Nazir Bilal Yavuz Reviewed-by: Aidar Imamov Reviewed-by: Andres Freund Reviewed-by: Amit Kapila Reviewed-by: Joseph Koshakow Reviewed-by: Xuneng Zhou Reviewed-by: Yuhang Qiu Discussion: https://postgr.es/m/CAN55FZ0h_YoSqqutxV6DES1RW8ig6wcA8CR9rJk358YRMxZFmw%40mail.gmail.com --- src/include/storage/bufmgr.h | 8 ++ src/backend/storage/buffer/bufmgr.c | 192 ++++++++++++++++++++++++++++ 2 files changed, 200 insertions(+) diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h index b5f8f3c5d42..9f6785910e0 100644 --- a/src/include/storage/bufmgr.h +++ b/src/include/storage/bufmgr.h @@ -323,6 +323,14 @@ extern void EvictRelUnpinnedBuffers(Relation rel, int32 *buffers_evicted, int32 *buffers_flushed, int32 *buffers_skipped); +extern bool MarkDirtyUnpinnedBuffer(Buffer buf, bool *buffer_already_dirty); +extern void MarkDirtyRelUnpinnedBuffers(Relation rel, + int32 *buffers_dirtied, + int32 *buffers_already_dirty, + int32 *buffers_skipped); +extern void MarkDirtyAllUnpinnedBuffers(int32 *buffers_dirtied, + int32 *buffers_already_dirty, + int32 *buffers_skipped); /* in buf_init.c */ extern void BufferManagerShmemInit(void); diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 327ddb7adc8..cd34c8146df 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -6776,6 +6776,198 @@ EvictRelUnpinnedBuffers(Relation rel, int32 *buffers_evicted, } } +/* + * Helper function to mark unpinned buffer dirty whose buffer header lock is + * already acquired. + */ +static bool +MarkDirtyUnpinnedBufferInternal(Buffer buf, BufferDesc *desc, + bool *buffer_already_dirty) +{ + uint32 buf_state; + bool result = false; + + *buffer_already_dirty = false; + + buf_state = pg_atomic_read_u32(&(desc->state)); + Assert(buf_state & BM_LOCKED); + + if ((buf_state & BM_VALID) == 0) + { + UnlockBufHdr(desc); + return false; + } + + /* Check that it's not pinned already. */ + if (BUF_STATE_GET_REFCOUNT(buf_state) > 0) + { + UnlockBufHdr(desc); + return false; + } + + /* Pin the buffer and then release the buffer spinlock */ + PinBuffer_Locked(desc); + + /* If it was not already dirty, mark it as dirty. */ + if (!(buf_state & BM_DIRTY)) + { + LWLockAcquire(BufferDescriptorGetContentLock(desc), LW_EXCLUSIVE); + MarkBufferDirty(buf); + result = true; + LWLockRelease(BufferDescriptorGetContentLock(desc)); + } + else + *buffer_already_dirty = true; + + UnpinBuffer(desc); + + return result; +} + +/* + * Try to mark the provided shared buffer as dirty. + * + * This function is intended for testing/development use only! + * + * Same as EvictUnpinnedBuffer() but with MarkBufferDirty() call inside. + * + * The buffer_already_dirty parameter is mandatory and indicate if the buffer + * could not be dirtied because it is already dirty. + * + * Returns true if the buffer has successfully been marked as dirty. + */ +bool +MarkDirtyUnpinnedBuffer(Buffer buf, bool *buffer_already_dirty) +{ + BufferDesc *desc; + bool buffer_dirtied = false; + + Assert(!BufferIsLocal(buf)); + + /* Make sure we can pin the buffer. */ + ResourceOwnerEnlarge(CurrentResourceOwner); + ReservePrivateRefCountEntry(); + + desc = GetBufferDescriptor(buf - 1); + LockBufHdr(desc); + + buffer_dirtied = MarkDirtyUnpinnedBufferInternal(buf, desc, buffer_already_dirty); + /* Both can not be true at the same time */ + Assert(!(buffer_dirtied && *buffer_already_dirty)); + + return buffer_dirtied; +} + +/* + * Try to mark all the shared buffers containing provided relation's pages as + * dirty. + * + * This function is intended for testing/development use only! See + * MarkDirtyUnpinnedBuffer(). + * + * The buffers_* parameters are mandatory and indicate the total count of + * buffers that: + * - buffers_dirtied - were dirtied + * - buffers_already_dirty - were already dirty + * - buffers_skipped - could not be dirtied because of the reasons different + * than buffer being already dirty + */ +void +MarkDirtyRelUnpinnedBuffers(Relation rel, + int32 *buffers_dirtied, + int32 *buffers_already_dirty, + int32 *buffers_skipped) +{ + Assert(!RelationUsesLocalBuffers(rel)); + + *buffers_dirtied = 0; + *buffers_already_dirty = 0; + *buffers_skipped = 0; + + for (int buf = 1; buf <= NBuffers; buf++) + { + BufferDesc *desc = GetBufferDescriptor(buf - 1); + uint32 buf_state = pg_atomic_read_u32(&(desc->state)); + bool buffer_already_dirty; + + CHECK_FOR_INTERRUPTS(); + + /* An unlocked precheck should be safe and saves some cycles. */ + if ((buf_state & BM_VALID) == 0 || + !BufTagMatchesRelFileLocator(&desc->tag, &rel->rd_locator)) + continue; + + /* Make sure we can pin the buffer. */ + ResourceOwnerEnlarge(CurrentResourceOwner); + ReservePrivateRefCountEntry(); + + buf_state = LockBufHdr(desc); + + /* recheck, could have changed without the lock */ + if ((buf_state & BM_VALID) == 0 || + !BufTagMatchesRelFileLocator(&desc->tag, &rel->rd_locator)) + { + UnlockBufHdr(desc); + continue; + } + + if (MarkDirtyUnpinnedBufferInternal(buf, desc, &buffer_already_dirty)) + (*buffers_dirtied)++; + else if (buffer_already_dirty) + (*buffers_already_dirty)++; + else + (*buffers_skipped)++; + } +} + +/* + * Try to mark all the shared buffers as dirty. + * + * This function is intended for testing/development use only! See + * MarkDirtyUnpinnedBuffer(). + * + * The buffers_* parameters are mandatory and indicate the total count of + * buffers that: + * - buffers_dirtied - were dirtied + * - buffers_already_dirty - were already dirty + * - buffers_skipped - could not be dirtied because of the reasons different + * than buffer being already dirty + */ +void +MarkDirtyAllUnpinnedBuffers(int32 *buffers_dirtied, + int32 *buffers_already_dirty, + int32 *buffers_skipped) +{ + *buffers_dirtied = 0; + *buffers_already_dirty = 0; + *buffers_skipped = 0; + + for (int buf = 1; buf <= NBuffers; buf++) + { + BufferDesc *desc = GetBufferDescriptor(buf - 1); + uint32 buf_state; + bool buffer_already_dirty; + + CHECK_FOR_INTERRUPTS(); + + buf_state = pg_atomic_read_u32(&desc->state); + if (!(buf_state & BM_VALID)) + continue; + + ResourceOwnerEnlarge(CurrentResourceOwner); + ReservePrivateRefCountEntry(); + + LockBufHdr(desc); + + if (MarkDirtyUnpinnedBufferInternal(buf, desc, &buffer_already_dirty)) + (*buffers_dirtied)++; + else if (buffer_already_dirty) + (*buffers_already_dirty)++; + else + (*buffers_skipped)++; + } +} + /* * Generic implementation of the AIO handle staging callback for readv/writev * on local/shared buffers. -- 2.51.0