database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-26 12:21:12 +03:00
Code Activity

ExtendBufferedWhat -> BufferManagerRelation.

Browse Source 
Commit 31966b15 invented a way for functions dealing with relation
extension to accept a Relation in online code and an SMgrRelation in
recovery code.  It seems highly likely that future bufmgr.c interfaces
will face the same problem, and need to do something similar.
Generalize the names so that each interface doesn't have to re-invent
the wheel.

Back-patch to 16.  Since extension AM authors might start using the
constructor macros once 16 ships, we agreed to do the rename in 16
rather than waiting for 17.

Reviewed-by: Peter Geoghegan <pg@bowt.ie>
Reviewed-by: Andres Freund <andres@anarazel.de>
Discussion: https://postgr.es/m/CA%2BhUKG%2B6tLD2BhpRWycEoti6LVLyQq457UL4ticP5xd8LqHySA%40mail.gmail.com
This commit is contained in:
Thomas Munro
2023-08-23 12:10:18 +12:00
parent 37188cea0c
commit 7114791158
20 changed files with 90 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/backend/storage/buffer/bufmgr.c
View File

@ -451,7 +451,7 @@ static Buffer ReadBuffer_common(SMgrRelation smgr, char relpersistence,
ForkNumber forkNum, BlockNumber blockNum,
ReadBufferMode mode, BufferAccessStrategy strategy,
bool *hit);
static BlockNumber ExtendBufferedRelCommon(ExtendBufferedWhat eb,
static BlockNumber ExtendBufferedRelCommon(BufferManagerRelation bmr,
ForkNumber fork,
BufferAccessStrategy strategy,
uint32 flags,
@ -459,7 +459,7 @@ static BlockNumber ExtendBufferedRelCommon(ExtendBufferedWhat eb,
BlockNumber extend_upto,
Buffer *buffers,
uint32 *extended_by);
static BlockNumber ExtendBufferedRelShared(ExtendBufferedWhat eb,
static BlockNumber ExtendBufferedRelShared(BufferManagerRelation bmr,
ForkNumber fork,
BufferAccessStrategy strategy,
uint32 flags,
@ -809,7 +809,7 @@ ReadBufferWithoutRelcache(RelFileLocator rlocator, ForkNumber forkNum,
* Convenience wrapper around ExtendBufferedRelBy() extending by one block.
*/
Buffer
ExtendBufferedRel(ExtendBufferedWhat eb,
ExtendBufferedRel(BufferManagerRelation bmr,
ForkNumber forkNum,
BufferAccessStrategy strategy,
uint32 flags)
@ -817,7 +817,7 @@ ExtendBufferedRel(ExtendBufferedWhat eb,
Buffer buf;
uint32 extend_by = 1;
ExtendBufferedRelBy(eb, forkNum, strategy, flags, extend_by,
ExtendBufferedRelBy(bmr, forkNum, strategy, flags, extend_by,
&buf, &extend_by);
return buf;
@ -841,7 +841,7 @@ ExtendBufferedRel(ExtendBufferedWhat eb,
* be empty.
*/
BlockNumber
ExtendBufferedRelBy(ExtendBufferedWhat eb,
ExtendBufferedRelBy(BufferManagerRelation bmr,
ForkNumber fork,
BufferAccessStrategy strategy,
uint32 flags,
@ -849,17 +849,17 @@ ExtendBufferedRelBy(ExtendBufferedWhat eb,
Buffer *buffers,
uint32 *extended_by)
{
Assert((eb.rel != NULL) != (eb.smgr != NULL));
Assert(eb.smgr == NULL || eb.relpersistence != 0);
Assert((bmr.rel != NULL) != (bmr.smgr != NULL));
Assert(bmr.smgr == NULL || bmr.relpersistence != 0);
Assert(extend_by > 0);
if (eb.smgr == NULL)
if (bmr.smgr == NULL)
{
eb.smgr = RelationGetSmgr(eb.rel);
eb.relpersistence = eb.rel->rd_rel->relpersistence;
bmr.smgr = RelationGetSmgr(bmr.rel);
bmr.relpersistence = bmr.rel->rd_rel->relpersistence;
}
return ExtendBufferedRelCommon(eb, fork, strategy, flags,
return ExtendBufferedRelCommon(bmr, fork, strategy, flags,
extend_by, InvalidBlockNumber,
buffers, extended_by);
}
@ -873,7 +873,7 @@ ExtendBufferedRelBy(ExtendBufferedWhat eb,
* crash recovery).
*/
Buffer
ExtendBufferedRelTo(ExtendBufferedWhat eb,
ExtendBufferedRelTo(BufferManagerRelation bmr,
ForkNumber fork,
BufferAccessStrategy strategy,
uint32 flags,
@ -885,14 +885,14 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
Buffer buffer = InvalidBuffer;
Buffer buffers[64];
Assert((eb.rel != NULL) != (eb.smgr != NULL));
Assert(eb.smgr == NULL || eb.relpersistence != 0);
Assert((bmr.rel != NULL) != (bmr.smgr != NULL));
Assert(bmr.smgr == NULL || bmr.relpersistence != 0);
Assert(extend_to != InvalidBlockNumber && extend_to > 0);
if (eb.smgr == NULL)
if (bmr.smgr == NULL)
{
eb.smgr = RelationGetSmgr(eb.rel);
eb.relpersistence = eb.rel->rd_rel->relpersistence;
bmr.smgr = RelationGetSmgr(bmr.rel);
bmr.relpersistence = bmr.rel->rd_rel->relpersistence;
}
/*
@ -901,21 +901,21 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
* an smgrexists call.
*/
if ((flags & EB_CREATE_FORK_IF_NEEDED) &&
(eb.smgr->smgr_cached_nblocks[fork] == 0 ||
eb.smgr->smgr_cached_nblocks[fork] == InvalidBlockNumber) &&
!smgrexists(eb.smgr, fork))
(bmr.smgr->smgr_cached_nblocks[fork] == 0 ||
bmr.smgr->smgr_cached_nblocks[fork] == InvalidBlockNumber) &&
!smgrexists(bmr.smgr, fork))
{
LockRelationForExtension(eb.rel, ExclusiveLock);
LockRelationForExtension(bmr.rel, ExclusiveLock);
/* could have been closed while waiting for lock */
if (eb.rel)
eb.smgr = RelationGetSmgr(eb.rel);
if (bmr.rel)
bmr.smgr = RelationGetSmgr(bmr.rel);
/* recheck, fork might have been created concurrently */
if (!smgrexists(eb.smgr, fork))
smgrcreate(eb.smgr, fork, flags & EB_PERFORMING_RECOVERY);
if (!smgrexists(bmr.smgr, fork))
smgrcreate(bmr.smgr, fork, flags & EB_PERFORMING_RECOVERY);
UnlockRelationForExtension(eb.rel, ExclusiveLock);
UnlockRelationForExtension(bmr.rel, ExclusiveLock);
}
/*
@ -923,13 +923,13 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
* kernel.
*/
if (flags & EB_CLEAR_SIZE_CACHE)
eb.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
bmr.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
/*
* Estimate how many pages we'll need to extend by. This avoids acquiring
* unnecessarily many victim buffers.
*/
current_size = smgrnblocks(eb.smgr, fork);
current_size = smgrnblocks(bmr.smgr, fork);
/*
* Since no-one else can be looking at the page contents yet, there is no
@ -948,7 +948,7 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
if ((uint64) current_size + num_pages > extend_to)
num_pages = extend_to - current_size;
first_block = ExtendBufferedRelCommon(eb, fork, strategy, flags,
first_block = ExtendBufferedRelCommon(bmr, fork, strategy, flags,
num_pages, extend_to,
buffers, &extended_by);
@ -975,7 +975,7 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
bool hit;
Assert(extended_by == 0);
buffer = ReadBuffer_common(eb.smgr, eb.relpersistence,
buffer = ReadBuffer_common(bmr.smgr, bmr.relpersistence,
fork, extend_to - 1, mode, strategy,
&hit);
}
@ -1019,7 +1019,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
if (mode == RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK)
flags |= EB_LOCK_FIRST;
return ExtendBufferedRel(EB_SMGR(smgr, relpersistence),
return ExtendBufferedRel(BMR_SMGR(smgr, relpersistence),
forkNum, strategy, flags);
}
@ -1779,7 +1779,7 @@ LimitAdditionalPins(uint32 *additional_pins)
* avoid duplicating the tracing and relpersistence related logic.
*/
static BlockNumber
ExtendBufferedRelCommon(ExtendBufferedWhat eb,
ExtendBufferedRelCommon(BufferManagerRelation bmr,
ForkNumber fork,
BufferAccessStrategy strategy,
uint32 flags,
@ -1791,27 +1791,27 @@ ExtendBufferedRelCommon(ExtendBufferedWhat eb,
BlockNumber first_block;
TRACE_POSTGRESQL_BUFFER_EXTEND_START(fork,
eb.smgr->smgr_rlocator.locator.spcOid,
eb.smgr->smgr_rlocator.locator.dbOid,
eb.smgr->smgr_rlocator.locator.relNumber,
eb.smgr->smgr_rlocator.backend,
bmr.smgr->smgr_rlocator.locator.spcOid,
bmr.smgr->smgr_rlocator.locator.dbOid,
bmr.smgr->smgr_rlocator.locator.relNumber,
bmr.smgr->smgr_rlocator.backend,
extend_by);
if (eb.relpersistence == RELPERSISTENCE_TEMP)
first_block = ExtendBufferedRelLocal(eb, fork, flags,
if (bmr.relpersistence == RELPERSISTENCE_TEMP)
first_block = ExtendBufferedRelLocal(bmr, fork, flags,
extend_by, extend_upto,
buffers, &extend_by);
else
first_block = ExtendBufferedRelShared(eb, fork, strategy, flags,
first_block = ExtendBufferedRelShared(bmr, fork, strategy, flags,
extend_by, extend_upto,
buffers, &extend_by);
*extended_by = extend_by;
TRACE_POSTGRESQL_BUFFER_EXTEND_DONE(fork,
eb.smgr->smgr_rlocator.locator.spcOid,
eb.smgr->smgr_rlocator.locator.dbOid,
eb.smgr->smgr_rlocator.locator.relNumber,
eb.smgr->smgr_rlocator.backend,
bmr.smgr->smgr_rlocator.locator.spcOid,
bmr.smgr->smgr_rlocator.locator.dbOid,
bmr.smgr->smgr_rlocator.locator.relNumber,
bmr.smgr->smgr_rlocator.backend,
*extended_by,
first_block);
@ -1823,7 +1823,7 @@ ExtendBufferedRelCommon(ExtendBufferedWhat eb,
* shared buffers.
*/
static BlockNumber
ExtendBufferedRelShared(ExtendBufferedWhat eb,
ExtendBufferedRelShared(BufferManagerRelation bmr,
ForkNumber fork,
BufferAccessStrategy strategy,
uint32 flags,
@ -1874,9 +1874,9 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
*/
if (!(flags & EB_SKIP_EXTENSION_LOCK))
{
LockRelationForExtension(eb.rel, ExclusiveLock);
if (eb.rel)
eb.smgr = RelationGetSmgr(eb.rel);
LockRelationForExtension(bmr.rel, ExclusiveLock);
if (bmr.rel)
bmr.smgr = RelationGetSmgr(bmr.rel);
}
/*
@ -1884,9 +1884,9 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
* kernel.
*/
if (flags & EB_CLEAR_SIZE_CACHE)
eb.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
bmr.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
first_block = smgrnblocks(eb.smgr, fork);
first_block = smgrnblocks(bmr.smgr, fork);
/*
* Now that we have the accurate relation size, check if the caller wants
@ -1918,7 +1918,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
if (extend_by == 0)
{
if (!(flags & EB_SKIP_EXTENSION_LOCK))
UnlockRelationForExtension(eb.rel, ExclusiveLock);
UnlockRelationForExtension(bmr.rel, ExclusiveLock);
*extended_by = extend_by;
return first_block;
}
@ -1929,7 +1929,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg("cannot extend relation %s beyond %u blocks",
relpath(eb.smgr->smgr_rlocator, fork),
relpath(bmr.smgr->smgr_rlocator, fork),
MaxBlockNumber)));
/*
@ -1947,7 +1947,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
LWLock *partition_lock;
int existing_id;
InitBufferTag(&tag, &eb.smgr->smgr_rlocator.locator, fork, first_block + i);
InitBufferTag(&tag, &bmr.smgr->smgr_rlocator.locator, fork, first_block + i);
hash = BufTableHashCode(&tag);
partition_lock = BufMappingPartitionLock(hash);
@ -1996,7 +1996,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
if (valid && !PageIsNew((Page) buf_block))
ereport(ERROR,
(errmsg("unexpected data beyond EOF in block %u of relation %s",
existing_hdr->tag.blockNum, relpath(eb.smgr->smgr_rlocator, fork)),
existing_hdr->tag.blockNum, relpath(bmr.smgr->smgr_rlocator, fork)),
errhint("This has been seen to occur with buggy kernels; consider updating your system.")));
/*
@ -2030,7 +2030,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
victim_buf_hdr->tag = tag;
buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
if (eb.relpersistence == RELPERSISTENCE_PERMANENT || fork == INIT_FORKNUM)
if (bmr.relpersistence == RELPERSISTENCE_PERMANENT || fork == INIT_FORKNUM)
buf_state |= BM_PERMANENT;
UnlockBufHdr(victim_buf_hdr, buf_state);
@ -2054,7 +2054,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
*
* We don't need to set checksum for all-zero pages.
*/
smgrzeroextend(eb.smgr, fork, first_block, extend_by, false);
smgrzeroextend(bmr.smgr, fork, first_block, extend_by, false);
/*
* Release the file-extension lock; it's now OK for someone else to extend
@ -2064,7 +2064,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
* take noticeable time.
*/
if (!(flags & EB_SKIP_EXTENSION_LOCK))
UnlockRelationForExtension(eb.rel, ExclusiveLock);
UnlockRelationForExtension(bmr.rel, ExclusiveLock);
pgstat_count_io_op_time(IOOBJECT_RELATION, io_context, IOOP_EXTEND,
io_start, extend_by);