Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commitc04cda9

Browse files
robertmhaaspull[bot]
authored andcommitted
Include RelFileLocator fields individually in BufferTag.
This is preparatory work for a project to increase the number of bitsin a RelFileNumber from 32 to 56.Along the way, introduce static inline accessor functions for a coupleof BufferTag fields.Dilip Kumar, reviewed by me. The overall patch series has also hadreview at various times from Andres Freund, Ashutosh Sharma, HannuKrosing, Vignesh C, Álvaro Herrera, and Tom Lane.Discussion:http://postgr.es/m/CAFiTN-trubju5YbWAq-BSpZ90-Z6xCVBQE8BVqXqANOZAF1Znw@mail.gmail.com
1 parentddbce8a commitc04cda9

File tree

5 files changed

+145
-73
lines changed

5 files changed

+145
-73
lines changed

‎contrib/pg_buffercache/pg_buffercache_pages.c‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -153,10 +153,10 @@ pg_buffercache_pages(PG_FUNCTION_ARGS)
153153
buf_state=LockBufHdr(bufHdr);
154154

155155
fctx->record[i].bufferid=BufferDescriptorGetBuffer(bufHdr);
156-
fctx->record[i].relfilenumber=bufHdr->tag.rlocator.relNumber;
157-
fctx->record[i].reltablespace=bufHdr->tag.rlocator.spcOid;
158-
fctx->record[i].reldatabase=bufHdr->tag.rlocator.dbOid;
159-
fctx->record[i].forknum=bufHdr->tag.forkNum;
156+
fctx->record[i].relfilenumber=BufTagGetRelNumber(&bufHdr->tag);
157+
fctx->record[i].reltablespace=bufHdr->tag.spcOid;
158+
fctx->record[i].reldatabase=bufHdr->tag.dbOid;
159+
fctx->record[i].forknum=BufTagGetForkNum(&bufHdr->tag);
160160
fctx->record[i].blocknum=bufHdr->tag.blockNum;
161161
fctx->record[i].usagecount=BUF_STATE_GET_USAGECOUNT(buf_state);
162162
fctx->record[i].pinning_backends=BUF_STATE_GET_REFCOUNT(buf_state);

‎contrib/pg_prewarm/autoprewarm.c‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -630,10 +630,12 @@ apw_dump_now(bool is_bgworker, bool dump_unlogged)
630630
if (buf_state&BM_TAG_VALID&&
631631
((buf_state&BM_PERMANENT)||dump_unlogged))
632632
{
633-
block_info_array[num_blocks].database=bufHdr->tag.rlocator.dbOid;
634-
block_info_array[num_blocks].tablespace=bufHdr->tag.rlocator.spcOid;
635-
block_info_array[num_blocks].filenumber=bufHdr->tag.rlocator.relNumber;
636-
block_info_array[num_blocks].forknum=bufHdr->tag.forkNum;
633+
block_info_array[num_blocks].database=bufHdr->tag.dbOid;
634+
block_info_array[num_blocks].tablespace=bufHdr->tag.spcOid;
635+
block_info_array[num_blocks].filenumber=
636+
BufTagGetRelNumber(&bufHdr->tag);
637+
block_info_array[num_blocks].forknum=
638+
BufTagGetForkNum(&bufHdr->tag);
637639
block_info_array[num_blocks].blocknum=bufHdr->tag.blockNum;
638640
++num_blocks;
639641
}

‎src/backend/storage/buffer/bufmgr.c‎

Lines changed: 68 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -1657,8 +1657,8 @@ ReleaseAndReadBuffer(Buffer buffer,
16571657
{
16581658
bufHdr=GetLocalBufferDescriptor(-buffer-1);
16591659
if (bufHdr->tag.blockNum==blockNum&&
1660-
RelFileLocatorEquals(bufHdr->tag.rlocator,relation->rd_locator)&&
1661-
bufHdr->tag.forkNum==forkNum)
1660+
BufTagMatchesRelFileLocator(&bufHdr->tag,&relation->rd_locator)&&
1661+
BufTagGetForkNum(&bufHdr->tag)==forkNum)
16621662
returnbuffer;
16631663
ResourceOwnerForgetBuffer(CurrentResourceOwner,buffer);
16641664
LocalRefCount[-buffer-1]--;
@@ -1668,8 +1668,8 @@ ReleaseAndReadBuffer(Buffer buffer,
16681668
bufHdr=GetBufferDescriptor(buffer-1);
16691669
/* we have pin, so it's ok to examine tag without spinlock */
16701670
if (bufHdr->tag.blockNum==blockNum&&
1671-
RelFileLocatorEquals(bufHdr->tag.rlocator,relation->rd_locator)&&
1672-
bufHdr->tag.forkNum==forkNum)
1671+
BufTagMatchesRelFileLocator(&bufHdr->tag,&relation->rd_locator)&&
1672+
BufTagGetForkNum(&bufHdr->tag)==forkNum)
16731673
returnbuffer;
16741674
UnpinBuffer(bufHdr, true);
16751675
}
@@ -2010,9 +2010,9 @@ BufferSync(int flags)
20102010

20112011
item=&CkptBufferIds[num_to_scan++];
20122012
item->buf_id=buf_id;
2013-
item->tsId=bufHdr->tag.rlocator.spcOid;
2014-
item->relNumber=bufHdr->tag.rlocator.relNumber;
2015-
item->forkNum=bufHdr->tag.forkNum;
2013+
item->tsId=bufHdr->tag.spcOid;
2014+
item->relNumber=BufTagGetRelNumber(&bufHdr->tag);
2015+
item->forkNum=BufTagGetForkNum(&bufHdr->tag);
20162016
item->blockNum=bufHdr->tag.blockNum;
20172017
}
20182018

@@ -2718,7 +2718,8 @@ PrintBufferLeakWarning(Buffer buffer)
27182718
}
27192719

27202720
/* theoretically we should lock the bufhdr here */
2721-
path=relpathbackend(buf->tag.rlocator,backend,buf->tag.forkNum);
2721+
path=relpathbackend(BufTagGetRelFileLocator(&buf->tag),backend,
2722+
BufTagGetForkNum(&buf->tag));
27222723
buf_state=pg_atomic_read_u32(&buf->state);
27232724
elog(WARNING,
27242725
"buffer refcount leak: [%03d] "
@@ -2797,8 +2798,8 @@ BufferGetTag(Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum,
27972798
bufHdr=GetBufferDescriptor(buffer-1);
27982799

27992800
/* pinned, so OK to read tag without spinlock */
2800-
*rlocator=bufHdr->tag.rlocator;
2801-
*forknum=bufHdr->tag.forkNum;
2801+
*rlocator=BufTagGetRelFileLocator(&bufHdr->tag);
2802+
*forknum=BufTagGetForkNum(&bufHdr->tag);
28022803
*blknum=bufHdr->tag.blockNum;
28032804
}
28042805

@@ -2848,9 +2849,9 @@ FlushBuffer(BufferDesc *buf, SMgrRelation reln)
28482849

28492850
/* Find smgr relation for buffer */
28502851
if (reln==NULL)
2851-
reln=smgropen(buf->tag.rlocator,InvalidBackendId);
2852+
reln=smgropen(BufTagGetRelFileLocator(&buf->tag),InvalidBackendId);
28522853

2853-
TRACE_POSTGRESQL_BUFFER_FLUSH_START(buf->tag.forkNum,
2854+
TRACE_POSTGRESQL_BUFFER_FLUSH_START(BufTagGetForkNum(&buf->tag),
28542855
buf->tag.blockNum,
28552856
reln->smgr_rlocator.locator.spcOid,
28562857
reln->smgr_rlocator.locator.dbOid,
@@ -2909,7 +2910,7 @@ FlushBuffer(BufferDesc *buf, SMgrRelation reln)
29092910
* bufToWrite is either the shared buffer or a copy, as appropriate.
29102911
*/
29112912
smgrwrite(reln,
2912-
buf->tag.forkNum,
2913+
BufTagGetForkNum(&buf->tag),
29132914
buf->tag.blockNum,
29142915
bufToWrite,
29152916
false);
@@ -2930,7 +2931,7 @@ FlushBuffer(BufferDesc *buf, SMgrRelation reln)
29302931
*/
29312932
TerminateBufferIO(buf, true,0);
29322933

2933-
TRACE_POSTGRESQL_BUFFER_FLUSH_DONE(buf->tag.forkNum,
2934+
TRACE_POSTGRESQL_BUFFER_FLUSH_DONE(BufTagGetForkNum(&buf->tag),
29342935
buf->tag.blockNum,
29352936
reln->smgr_rlocator.locator.spcOid,
29362937
reln->smgr_rlocator.locator.dbOid,
@@ -3151,15 +3152,15 @@ DropRelationBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
31513152
* We could check forkNum and blockNum as well as the rlocator, but
31523153
* the incremental win from doing so seems small.
31533154
*/
3154-
if (!RelFileLocatorEquals(bufHdr->tag.rlocator,rlocator.locator))
3155+
if (!BufTagMatchesRelFileLocator(&bufHdr->tag,&rlocator.locator))
31553156
continue;
31563157

31573158
buf_state=LockBufHdr(bufHdr);
31583159

31593160
for (j=0;j<nforks;j++)
31603161
{
3161-
if (RelFileLocatorEquals(bufHdr->tag.rlocator,rlocator.locator)&&
3162-
bufHdr->tag.forkNum==forkNum[j]&&
3162+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,&rlocator.locator)&&
3163+
BufTagGetForkNum(&bufHdr->tag)==forkNum[j]&&
31633164
bufHdr->tag.blockNum >=firstDelBlock[j])
31643165
{
31653166
InvalidateBuffer(bufHdr);/* releases spinlock */
@@ -3309,7 +3310,7 @@ DropRelationsAllBuffers(SMgrRelation *smgr_reln, int nlocators)
33093310

33103311
for (j=0;j<n;j++)
33113312
{
3312-
if (RelFileLocatorEquals(bufHdr->tag.rlocator,locators[j]))
3313+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,&locators[j]))
33133314
{
33143315
rlocator=&locators[j];
33153316
break;
@@ -3318,7 +3319,10 @@ DropRelationsAllBuffers(SMgrRelation *smgr_reln, int nlocators)
33183319
}
33193320
else
33203321
{
3321-
rlocator=bsearch((constvoid*)&(bufHdr->tag.rlocator),
3322+
RelFileLocatorlocator;
3323+
3324+
locator=BufTagGetRelFileLocator(&bufHdr->tag);
3325+
rlocator=bsearch((constvoid*)&(locator),
33223326
locators,n,sizeof(RelFileLocator),
33233327
rlocator_comparator);
33243328
}
@@ -3328,7 +3332,7 @@ DropRelationsAllBuffers(SMgrRelation *smgr_reln, int nlocators)
33283332
continue;
33293333

33303334
buf_state=LockBufHdr(bufHdr);
3331-
if (RelFileLocatorEquals(bufHdr->tag.rlocator, (*rlocator)))
3335+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,rlocator))
33323336
InvalidateBuffer(bufHdr);/* releases spinlock */
33333337
else
33343338
UnlockBufHdr(bufHdr,buf_state);
@@ -3388,8 +3392,8 @@ FindAndDropRelationBuffers(RelFileLocator rlocator, ForkNumber forkNum,
33883392
*/
33893393
buf_state=LockBufHdr(bufHdr);
33903394

3391-
if (RelFileLocatorEquals(bufHdr->tag.rlocator,rlocator)&&
3392-
bufHdr->tag.forkNum==forkNum&&
3395+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,&rlocator)&&
3396+
BufTagGetForkNum(&bufHdr->tag)==forkNum&&
33933397
bufHdr->tag.blockNum >=firstDelBlock)
33943398
InvalidateBuffer(bufHdr);/* releases spinlock */
33953399
else
@@ -3427,11 +3431,11 @@ DropDatabaseBuffers(Oid dbid)
34273431
* As in DropRelationBuffers, an unlocked precheck should be
34283432
* safe and saves some cycles.
34293433
*/
3430-
if (bufHdr->tag.rlocator.dbOid!=dbid)
3434+
if (bufHdr->tag.dbOid!=dbid)
34313435
continue;
34323436

34333437
buf_state=LockBufHdr(bufHdr);
3434-
if (bufHdr->tag.rlocator.dbOid==dbid)
3438+
if (bufHdr->tag.dbOid==dbid)
34353439
InvalidateBuffer(bufHdr);/* releases spinlock */
34363440
else
34373441
UnlockBufHdr(bufHdr,buf_state);
@@ -3461,7 +3465,8 @@ PrintBufferDescs(void)
34613465
"[%02d] (freeNext=%d, rel=%s, "
34623466
"blockNum=%u, flags=0x%x, refcount=%u %d)",
34633467
i,buf->freeNext,
3464-
relpathbackend(buf->tag.rlocator,InvalidBackendId,buf->tag.forkNum),
3468+
relpathbackend(BufTagGetRelFileLocator(&buf->tag),
3469+
InvalidBackendId,BufTagGetForkNum(&buf->tag)),
34653470
buf->tag.blockNum,buf->flags,
34663471
buf->refcount,GetPrivateRefCount(b));
34673472
}
@@ -3486,7 +3491,8 @@ PrintPinnedBufs(void)
34863491
"[%02d] (freeNext=%d, rel=%s, "
34873492
"blockNum=%u, flags=0x%x, refcount=%u %d)",
34883493
i,buf->freeNext,
3489-
relpathperm(buf->tag.rlocator,buf->tag.forkNum),
3494+
relpathperm(BufTagGetRelFileLocator(&buf->tag),
3495+
BufTagGetForkNum(&buf->tag)),
34903496
buf->tag.blockNum,buf->flags,
34913497
buf->refcount,GetPrivateRefCount(b));
34923498
}
@@ -3525,7 +3531,7 @@ FlushRelationBuffers(Relation rel)
35253531
uint32buf_state;
35263532

35273533
bufHdr=GetLocalBufferDescriptor(i);
3528-
if (RelFileLocatorEquals(bufHdr->tag.rlocator,rel->rd_locator)&&
3534+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,&rel->rd_locator)&&
35293535
((buf_state=pg_atomic_read_u32(&bufHdr->state))&
35303536
(BM_VALID |BM_DIRTY))== (BM_VALID |BM_DIRTY))
35313537
{
@@ -3543,7 +3549,7 @@ FlushRelationBuffers(Relation rel)
35433549
PageSetChecksumInplace(localpage,bufHdr->tag.blockNum);
35443550

35453551
smgrwrite(RelationGetSmgr(rel),
3546-
bufHdr->tag.forkNum,
3552+
BufTagGetForkNum(&bufHdr->tag),
35473553
bufHdr->tag.blockNum,
35483554
localpage,
35493555
false);
@@ -3572,13 +3578,13 @@ FlushRelationBuffers(Relation rel)
35723578
* As in DropRelationBuffers, an unlocked precheck should be
35733579
* safe and saves some cycles.
35743580
*/
3575-
if (!RelFileLocatorEquals(bufHdr->tag.rlocator,rel->rd_locator))
3581+
if (!BufTagMatchesRelFileLocator(&bufHdr->tag,&rel->rd_locator))
35763582
continue;
35773583

35783584
ReservePrivateRefCountEntry();
35793585

35803586
buf_state=LockBufHdr(bufHdr);
3581-
if (RelFileLocatorEquals(bufHdr->tag.rlocator,rel->rd_locator)&&
3587+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,&rel->rd_locator)&&
35823588
(buf_state& (BM_VALID |BM_DIRTY))== (BM_VALID |BM_DIRTY))
35833589
{
35843590
PinBuffer_Locked(bufHdr);
@@ -3652,7 +3658,7 @@ FlushRelationsAllBuffers(SMgrRelation *smgrs, int nrels)
36523658

36533659
for (j=0;j<nrels;j++)
36543660
{
3655-
if (RelFileLocatorEquals(bufHdr->tag.rlocator,srels[j].rlocator))
3661+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,&srels[j].rlocator))
36563662
{
36573663
srelent=&srels[j];
36583664
break;
@@ -3661,7 +3667,10 @@ FlushRelationsAllBuffers(SMgrRelation *smgrs, int nrels)
36613667
}
36623668
else
36633669
{
3664-
srelent=bsearch((constvoid*)&(bufHdr->tag.rlocator),
3670+
RelFileLocatorrlocator;
3671+
3672+
rlocator=BufTagGetRelFileLocator(&bufHdr->tag);
3673+
srelent=bsearch((constvoid*)&(rlocator),
36653674
srels,nrels,sizeof(SMgrSortArray),
36663675
rlocator_comparator);
36673676
}
@@ -3673,7 +3682,7 @@ FlushRelationsAllBuffers(SMgrRelation *smgrs, int nrels)
36733682
ReservePrivateRefCountEntry();
36743683

36753684
buf_state=LockBufHdr(bufHdr);
3676-
if (RelFileLocatorEquals(bufHdr->tag.rlocator,srelent->rlocator)&&
3685+
if (BufTagMatchesRelFileLocator(&bufHdr->tag,&srelent->rlocator)&&
36773686
(buf_state& (BM_VALID |BM_DIRTY))== (BM_VALID |BM_DIRTY))
36783687
{
36793688
PinBuffer_Locked(bufHdr);
@@ -3877,13 +3886,13 @@ FlushDatabaseBuffers(Oid dbid)
38773886
* As in DropRelationBuffers, an unlocked precheck should be
38783887
* safe and saves some cycles.
38793888
*/
3880-
if (bufHdr->tag.rlocator.dbOid!=dbid)
3889+
if (bufHdr->tag.dbOid!=dbid)
38813890
continue;
38823891

38833892
ReservePrivateRefCountEntry();
38843893

38853894
buf_state=LockBufHdr(bufHdr);
3886-
if (bufHdr->tag.rlocator.dbOid==dbid&&
3895+
if (bufHdr->tag.dbOid==dbid&&
38873896
(buf_state& (BM_VALID |BM_DIRTY))== (BM_VALID |BM_DIRTY))
38883897
{
38893898
PinBuffer_Locked(bufHdr);
@@ -4052,7 +4061,7 @@ MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
40524061
* See src/backend/storage/page/README for longer discussion.
40534062
*/
40544063
if (RecoveryInProgress()||
4055-
RelFileLocatorSkippingWAL(bufHdr->tag.rlocator))
4064+
RelFileLocatorSkippingWAL(BufTagGetRelFileLocator(&bufHdr->tag)))
40564065
return;
40574066

40584067
/*
@@ -4661,7 +4670,8 @@ AbortBufferIO(void)
46614670
/* Buffer is pinned, so we can read tag without spinlock */
46624671
char*path;
46634672

4664-
path=relpathperm(buf->tag.rlocator,buf->tag.forkNum);
4673+
path=relpathperm(BufTagGetRelFileLocator(&buf->tag),
4674+
BufTagGetForkNum(&buf->tag));
46654675
ereport(WARNING,
46664676
(errcode(ERRCODE_IO_ERROR),
46674677
errmsg("could not write block %u of %s",
@@ -4685,7 +4695,8 @@ shared_buffer_write_error_callback(void *arg)
46854695
/* Buffer is pinned, so we can read the tag without locking the spinlock */
46864696
if (bufHdr!=NULL)
46874697
{
4688-
char*path=relpathperm(bufHdr->tag.rlocator,bufHdr->tag.forkNum);
4698+
char*path=relpathperm(BufTagGetRelFileLocator(&bufHdr->tag),
4699+
BufTagGetForkNum(&bufHdr->tag));
46894700

46904701
errcontext("writing block %u of relation %s",
46914702
bufHdr->tag.blockNum,path);
@@ -4703,8 +4714,9 @@ local_buffer_write_error_callback(void *arg)
47034714

47044715
if (bufHdr!=NULL)
47054716
{
4706-
char*path=relpathbackend(bufHdr->tag.rlocator,MyBackendId,
4707-
bufHdr->tag.forkNum);
4717+
char*path=relpathbackend(BufTagGetRelFileLocator(&bufHdr->tag),
4718+
MyBackendId,
4719+
BufTagGetForkNum(&bufHdr->tag));
47084720

47094721
errcontext("writing block %u of relation %s",
47104722
bufHdr->tag.blockNum,path);
@@ -4798,15 +4810,20 @@ static inline int
47984810
buffertag_comparator(constBufferTag*ba,constBufferTag*bb)
47994811
{
48004812
intret;
4813+
RelFileLocatorrlocatora;
4814+
RelFileLocatorrlocatorb;
48014815

4802-
ret=rlocator_comparator(&ba->rlocator,&bb->rlocator);
4816+
rlocatora=BufTagGetRelFileLocator(ba);
4817+
rlocatorb=BufTagGetRelFileLocator(bb);
4818+
4819+
ret=rlocator_comparator(&rlocatora,&rlocatorb);
48034820

48044821
if (ret!=0)
48054822
returnret;
48064823

4807-
if (ba->forkNum<bb->forkNum)
4824+
if (BufTagGetForkNum(ba)<BufTagGetForkNum(bb))
48084825
return-1;
4809-
if (ba->forkNum>bb->forkNum)
4826+
if (BufTagGetForkNum(ba)>BufTagGetForkNum(bb))
48104827
return1;
48114828

48124829
if (ba->blockNum<bb->blockNum)
@@ -4956,22 +4973,26 @@ IssuePendingWritebacks(WritebackContext *context)
49564973
SMgrRelationreln;
49574974
intahead;
49584975
BufferTagtag;
4976+
RelFileLocatorcurrlocator;
49594977
Sizenblocks=1;
49604978

49614979
cur=&context->pending_writebacks[i];
49624980
tag=cur->tag;
4981+
currlocator=BufTagGetRelFileLocator(&tag);
49634982

49644983
/*
49654984
* Peek ahead, into following writeback requests, to see if they can
49664985
* be combined with the current one.
49674986
*/
49684987
for (ahead=0;i+ahead+1<context->nr_pending;ahead++)
49694988
{
4989+
49704990
next=&context->pending_writebacks[i+ahead+1];
49714991

49724992
/* different file, stop */
4973-
if (!RelFileLocatorEquals(cur->tag.rlocator,next->tag.rlocator)||
4974-
cur->tag.forkNum!=next->tag.forkNum)
4993+
if (!RelFileLocatorEquals(currlocator,
4994+
BufTagGetRelFileLocator(&next->tag))||
4995+
BufTagGetForkNum(&cur->tag)!=BufTagGetForkNum(&next->tag))
49754996
break;
49764997

49774998
/* ok, block queued twice, skip */
@@ -4989,8 +5010,8 @@ IssuePendingWritebacks(WritebackContext *context)
49895010
i+=ahead;
49905011

49915012
/* and finally tell the kernel to write the data to storage */
4992-
reln=smgropen(tag.rlocator,InvalidBackendId);
4993-
smgrwriteback(reln,tag.forkNum,tag.blockNum,nblocks);
5013+
reln=smgropen(currlocator,InvalidBackendId);
5014+
smgrwriteback(reln,BufTagGetForkNum(&tag),tag.blockNum,nblocks);
49945015
}
49955016

49965017
context->nr_pending=0;

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp