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

Commit013ebc0

Browse files
committed
Microvacuum for GIST
Mark index tuple as dead if it's pointed by kill_prior_tuple duringordinary (search) scan and remove it during insert process if there is noenough space for new tuple to insert. This improves select performancebecause index will not return tuple marked as dead and improves insertperformance because it reduces number of page split.Anastasia Lubennikova <a.lubennikova@postgrespro.ru> with minor editorialization by me
1 parent96f6a0c commit013ebc0

File tree

5 files changed

+241
-3
lines changed

5 files changed

+241
-3
lines changed

‎src/backend/access/gist/gist.c

Lines changed: 82 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,7 @@ static bool gistinserttuples(GISTInsertState *state, GISTInsertStack *stack,
3636
boolunlockbuf,boolunlockleftchild);
3737
staticvoidgistfinishsplit(GISTInsertState*state,GISTInsertStack*stack,
3838
GISTSTATE*giststate,List*splitinfo,boolreleasebuf);
39+
staticvoidgistvacuumpage(Relationrel,Pagepage,Bufferbuffer);
3940

4041

4142
#defineROTATEDIST(d) do { \
@@ -209,6 +210,17 @@ gistplacetopage(Relation rel, Size freespace, GISTSTATE *giststate,
209210
* because the tuple vector passed to gistSplit won't include this tuple.
210211
*/
211212
is_split=gistnospace(page,itup,ntup,oldoffnum,freespace);
213+
214+
/*
215+
* If leaf page is full, try at first to delete dead tuples. And then
216+
* check again.
217+
*/
218+
if (is_split&&GistPageIsLeaf(page)&&GistPageHasGarbage(page))
219+
{
220+
gistvacuumpage(rel,page,buffer);
221+
is_split=gistnospace(page,itup,ntup,oldoffnum,freespace);
222+
}
223+
212224
if (is_split)
213225
{
214226
/* no space for insertion */
@@ -1440,3 +1452,73 @@ freeGISTstate(GISTSTATE *giststate)
14401452
/* It's sufficient to delete the scanCxt */
14411453
MemoryContextDelete(giststate->scanCxt);
14421454
}
1455+
1456+
/*
1457+
* gistvacuumpage() -- try to remove LP_DEAD items from the given page.
1458+
* Function assumes that buffer is exclusively locked.
1459+
*/
1460+
staticvoid
1461+
gistvacuumpage(Relationrel,Pagepage,Bufferbuffer)
1462+
{
1463+
OffsetNumberdeletable[MaxIndexTuplesPerPage];
1464+
intndeletable=0;
1465+
OffsetNumberoffnum,maxoff;
1466+
1467+
Assert(GistPageIsLeaf(page));
1468+
1469+
/*
1470+
* Scan over all items to see which ones need to be deleted according to
1471+
* LP_DEAD flags.
1472+
*/
1473+
maxoff=PageGetMaxOffsetNumber(page);
1474+
for (offnum=FirstOffsetNumber;
1475+
offnum <=maxoff;
1476+
offnum=OffsetNumberNext(offnum))
1477+
{
1478+
ItemIditemId=PageGetItemId(page,offnum);
1479+
1480+
if (ItemIdIsDead(itemId))
1481+
deletable[ndeletable++]=offnum;
1482+
}
1483+
1484+
if (ndeletable>0)
1485+
{
1486+
START_CRIT_SECTION();
1487+
1488+
PageIndexMultiDelete(page,deletable,ndeletable);
1489+
1490+
/*
1491+
* Mark the page as not containing any LP_DEAD items. This is not
1492+
* certainly true (there might be some that have recently been marked,
1493+
* but weren't included in our target-item list), but it will almost
1494+
* always be true and it doesn't seem worth an additional page scan to
1495+
* check it. Remember that F_HAS_GARBAGE is only a hint anyway.
1496+
*/
1497+
GistClearPageHasGarbage(page);
1498+
1499+
MarkBufferDirty(buffer);
1500+
1501+
/* XLOG stuff */
1502+
if (RelationNeedsWAL(rel))
1503+
{
1504+
XLogRecPtrrecptr;
1505+
1506+
recptr=gistXLogUpdate(rel->rd_node,buffer,
1507+
deletable,ndeletable,
1508+
NULL,0,InvalidBuffer);
1509+
1510+
PageSetLSN(page,recptr);
1511+
}
1512+
else
1513+
PageSetLSN(page,gistGetFakeLSN(rel));
1514+
1515+
END_CRIT_SECTION();
1516+
}
1517+
1518+
/*
1519+
* Note: if we didn't find any LP_DEAD items, then the page's
1520+
* F_HAS_GARBAGE hint bit is falsely set. We do not bother expending a
1521+
* separate write to clear it, however. We will clear it when we split
1522+
* the page.
1523+
*/
1524+
}

‎src/backend/access/gist/gistget.c

Lines changed: 136 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,77 @@
2424
#include"utils/memutils.h"
2525
#include"utils/rel.h"
2626

27+
/*
28+
* gistkillitems() -- set LP_DEAD state for items an indexscan caller has
29+
* told us were killed.
30+
*
31+
* We re-read page here, so it's important to check page LSN. If the page
32+
* has been modified since the last read (as determined by LSN), we cannot
33+
* flag any entries because it is possible that the old entry was vacuumed
34+
* away and the TID was re-used by a completely different heap tuple.
35+
*/
36+
staticvoid
37+
gistkillitems(IndexScanDescscan)
38+
{
39+
GISTScanOpaqueso= (GISTScanOpaque)scan->opaque;
40+
Bufferbuffer;
41+
Pagepage;
42+
OffsetNumberoffnum;
43+
ItemIdiid;
44+
inti;
45+
boolkilledsomething= false;
46+
47+
Assert(so->curBlkno!=InvalidBlockNumber);
48+
Assert(!XLogRecPtrIsInvalid(so->curPageLSN));
49+
Assert(so->killedItems!=NULL);
50+
51+
buffer=ReadBuffer(scan->indexRelation,so->curBlkno);
52+
if (!BufferIsValid(buffer))
53+
return;
54+
55+
LockBuffer(buffer,GIST_SHARE);
56+
gistcheckpage(scan->indexRelation,buffer);
57+
page=BufferGetPage(buffer);
58+
59+
/*
60+
* If page LSN differs it means that the page was modified since the last read.
61+
* killedItems could be not valid so LP_DEAD hints applying is not safe.
62+
*/
63+
if(PageGetLSN(page)!=so->curPageLSN)
64+
{
65+
UnlockReleaseBuffer(buffer);
66+
so->numKilled=0;/* reset counter */
67+
return;
68+
}
69+
70+
Assert(GistPageIsLeaf(page));
71+
72+
/*
73+
* Mark all killedItems as dead. We need no additional recheck,
74+
* because, if page was modified, pageLSN must have changed.
75+
*/
76+
for (i=0;i<so->numKilled;i++)
77+
{
78+
offnum=so->killedItems[i];
79+
iid=PageGetItemId(page,offnum);
80+
ItemIdMarkDead(iid);
81+
killedsomething= true;
82+
}
83+
84+
if (killedsomething)
85+
{
86+
GistMarkPageHasGarbage(page);
87+
MarkBufferDirtyHint(buffer, true);
88+
}
89+
90+
UnlockReleaseBuffer(buffer);
91+
92+
/*
93+
* Always reset the scan state, so we don't look for same items on other
94+
* pages.
95+
*/
96+
so->numKilled=0;
97+
}
2798

2899
/*
29100
* gistindex_keytest() -- does this index tuple satisfy the scan key(s)?
@@ -305,17 +376,33 @@ gistScanPage(IndexScanDesc scan, GISTSearchItem *pageItem, double *myDistances,
305376
if (so->pageDataCxt)
306377
MemoryContextReset(so->pageDataCxt);
307378

379+
/*
380+
* We save the LSN of the page as we read it, so that we know whether it
381+
* safe to apply LP_DEAD hints to the page later. This allows us to drop
382+
* the pin for MVCC scans, which allows vacuum to avoid blocking.
383+
*/
384+
so->curPageLSN=PageGetLSN(page);
385+
308386
/*
309387
* check all tuples on page
310388
*/
311389
maxoff=PageGetMaxOffsetNumber(page);
312390
for (i=FirstOffsetNumber;i <=maxoff;i=OffsetNumberNext(i))
313391
{
314-
IndexTupleit= (IndexTuple)PageGetItem(page,PageGetItemId(page,i));
392+
ItemIdiid=PageGetItemId(page,i);
393+
IndexTupleit;
315394
boolmatch;
316395
boolrecheck;
317396
boolrecheck_distances;
318397

398+
/*
399+
* If the scan specifies not to return killed tuples, then we treat a
400+
* killed tuple as not passing the qual.
401+
*/
402+
if(scan->ignore_killed_tuples&&ItemIdIsDead(iid))
403+
continue;
404+
405+
it= (IndexTuple)PageGetItem(page,iid);
319406
/*
320407
* Must call gistindex_keytest in tempCxt, and clean up any leftover
321408
* junk afterward.
@@ -348,6 +435,7 @@ gistScanPage(IndexScanDesc scan, GISTSearchItem *pageItem, double *myDistances,
348435
*/
349436
so->pageData[so->nPageData].heapPtr=it->t_tid;
350437
so->pageData[so->nPageData].recheck=recheck;
438+
so->pageData[so->nPageData].offnum=i;
351439

352440
/*
353441
* In an index-only scan, also fetch the data from the tuple.
@@ -572,7 +660,24 @@ gistgettuple(PG_FUNCTION_ARGS)
572660
{
573661
if (so->curPageData<so->nPageData)
574662
{
663+
if (scan->kill_prior_tuple&&so->curPageData>0)
664+
{
665+
666+
if (so->killedItems==NULL)
667+
{
668+
MemoryContextoldCxt=
669+
MemoryContextSwitchTo(so->giststate->scanCxt);
670+
671+
so->killedItems=
672+
(OffsetNumber*)palloc(MaxIndexTuplesPerPage
673+
*sizeof(OffsetNumber));
575674

675+
MemoryContextSwitchTo(oldCxt);
676+
}
677+
if (so->numKilled<MaxIndexTuplesPerPage)
678+
so->killedItems[so->numKilled++]=
679+
so->pageData[so->curPageData-1].offnum;
680+
}
576681
/* continuing to return tuples from a leaf page */
577682
scan->xs_ctup.t_self=so->pageData[so->curPageData].heapPtr;
578683
scan->xs_recheck=so->pageData[so->curPageData].recheck;
@@ -586,16 +691,46 @@ gistgettuple(PG_FUNCTION_ARGS)
586691
PG_RETURN_BOOL(true);
587692
}
588693

694+
/*
695+
* Check the last returned tuple and add it to killitems if
696+
* necessary
697+
*/
698+
if (scan->kill_prior_tuple
699+
&&so->curPageData>0
700+
&&so->curPageData==so->nPageData)
701+
{
702+
703+
if (so->killedItems==NULL)
704+
{
705+
MemoryContextoldCxt=
706+
MemoryContextSwitchTo(so->giststate->scanCxt);
707+
708+
so->killedItems=
709+
(OffsetNumber*)palloc(MaxIndexTuplesPerPage
710+
*sizeof(OffsetNumber));
711+
712+
MemoryContextSwitchTo(oldCxt);
713+
}
714+
if (so->numKilled<MaxIndexTuplesPerPage)
715+
so->killedItems[so->numKilled++]=
716+
so->pageData[so->curPageData-1].offnum;
717+
}
589718
/* find and process the next index page */
590719
do
591720
{
721+
if ((so->curBlkno!=InvalidBlockNumber)&& (so->numKilled>0))
722+
gistkillitems(scan);
723+
592724
GISTSearchItem*item=getNextGISTSearchItem(so);
593725

594726
if (!item)
595727
PG_RETURN_BOOL(false);
596728

597729
CHECK_FOR_INTERRUPTS();
598730

731+
/* save current item BlockNumber for next gistkillitems() call */
732+
so->curBlkno=item->blkno;
733+
599734
/*
600735
* While scanning a leaf page, ItemPointers of matching heap
601736
* tuples are stored in so->pageData. If there are any on

‎src/backend/access/gist/gistscan.c

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,11 @@ gistbeginscan(PG_FUNCTION_ARGS)
9393
memset(scan->xs_orderbynulls, true,sizeof(bool)*scan->numberOfOrderBys);
9494
}
9595

96+
so->killedItems=NULL;/* until needed */
97+
so->numKilled=0;
98+
so->curBlkno=InvalidBlockNumber;
99+
so->curPageLSN=InvalidXLogRecPtr;
100+
96101
scan->opaque=so;
97102

98103
/*

‎src/include/access/gist.h

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -41,8 +41,11 @@
4141
*/
4242
#defineF_LEAF(1 << 0)/* leaf page */
4343
#defineF_DELETED(1 << 1)/* the page has been deleted */
44-
#defineF_TUPLES_DELETED(1 << 2)/* some tuples on the page are dead */
44+
#defineF_TUPLES_DELETED(1 << 2)/* some tuples on the page were
45+
* deleted */
4546
#defineF_FOLLOW_RIGHT(1 << 3)/* page to the right has no downlink */
47+
#defineF_HAS_GARBAGE(1 << 4)/* some tuples on the page are dead,
48+
* but not deleted yet */
4649

4750
typedefXLogRecPtrGistNSN;
4851

@@ -137,6 +140,10 @@ typedef struct GISTENTRY
137140
#defineGistMarkTuplesDeleted(page) ( GistPageGetOpaque(page)->flags |= F_TUPLES_DELETED)
138141
#defineGistClearTuplesDeleted(page)( GistPageGetOpaque(page)->flags &= ~F_TUPLES_DELETED)
139142

143+
#defineGistPageHasGarbage(page) ( GistPageGetOpaque(page)->flags & F_HAS_GARBAGE)
144+
#defineGistMarkPageHasGarbage(page) ( GistPageGetOpaque(page)->flags |= F_HAS_GARBAGE)
145+
#defineGistClearPageHasGarbage(page)( GistPageGetOpaque(page)->flags &= ~F_HAS_GARBAGE)
146+
140147
#defineGistFollowRight(page) ( GistPageGetOpaque(page)->flags & F_FOLLOW_RIGHT)
141148
#defineGistMarkFollowRight(page) ( GistPageGetOpaque(page)->flags |= F_FOLLOW_RIGHT)
142149
#defineGistClearFollowRight(page)( GistPageGetOpaque(page)->flags &= ~F_FOLLOW_RIGHT)

‎src/include/access/gist_private.h

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
#include"storage/bufmgr.h"
2323
#include"storage/buffile.h"
2424
#include"utils/hsearch.h"
25+
#include"access/genam.h"
2526

2627
/*
2728
* Maximum number of "halves" a page can be split into in one operation.
@@ -121,9 +122,11 @@ typedef struct GISTSearchHeapItem
121122
{
122123
ItemPointerDataheapPtr;
123124
boolrecheck;/* T if quals must be rechecked */
124-
boolrecheckDistances;/* T if distances must be rechecked */
125+
boolrecheckDistances;/* T if distances must be rechecked */
125126
IndexTupleftup;/* data fetched back from the index, used in
126127
* index-only scans */
128+
OffsetNumberoffnum;/* track offset in page to mark tuple as
129+
* LP_DEAD */
127130
}GISTSearchHeapItem;
128131

129132
/* Unvisited item, either index page or heap tuple */
@@ -161,6 +164,12 @@ typedef struct GISTScanOpaqueData
161164
/* pre-allocated workspace arrays */
162165
double*distances;/* output area for gistindex_keytest */
163166

167+
/* info about killed items if any (killedItems is NULL if never used) */
168+
OffsetNumber*killedItems;/* offset numbers of killed items */
169+
intnumKilled;/* number of currently stored items */
170+
BlockNumbercurBlkno;/* current number of block */
171+
GistNSNcurPageLSN;/* pos in the WAL stream when page was read */
172+
164173
/* In a non-ordered search, returnable heap items are stored here: */
165174
GISTSearchHeapItempageData[BLCKSZ /sizeof(IndexTupleData)];
166175
OffsetNumbernPageData;/* number of valid items in array */

0 commit comments

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