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

Commitf60d176

Browse files
committed
Tweak catalog cache management algorithms to reduce cost of
SearchCatCacheList and ReleaseCatCacheList. Previously, we incrementedand decremented the refcounts of list member tuples along with the listitself, but that's unnecessary, and very expensive when the list is big.It's cheaper to change only the list refcount. When we are consideringdeleting a cache entry, we have to check not only its own refcount butits parent list's ... but it's easy to arrange the code so that thischeck is not made in any commonly-used paths, so the cost is really nil.The bigger gain though is to refrain from DLMoveToFront'ing each individualmember tuple each time the list is referenced. To keep some semblanceof fair space management, lists are just marked as used or not since thelast cache cleanout search, and we do a MoveToFront pass only when aboutto run a cleanout. In combination, these changes reduce the costs ofSearchCatCacheList and ReleaseCatCacheList from about 4.5% of pgbenchruntime to under 1%, according to my gprof results.
1 parent2af9a44 commitf60d176

File tree

2 files changed

+132
-73
lines changed

2 files changed

+132
-73
lines changed

‎src/backend/utils/cache/catcache.c‎

Lines changed: 117 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/utils/cache/catcache.c,v 1.122 2005/08/08 19:17:22 tgl Exp $
11+
* $PostgreSQL: pgsql/src/backend/utils/cache/catcache.c,v 1.123 2005/08/13 22:18:07 tgl Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -97,6 +97,7 @@ static void CatalogCacheInitializeCache(CatCache *cache);
9797
staticCatCTup*CatalogCacheCreateEntry(CatCache*cache,HeapTuplentp,
9898
uint32hashValue,IndexhashIndex,
9999
boolnegative);
100+
staticvoidCatalogCacheCleanup(CatCTup*savect);
100101
staticHeapTuplebuild_dummy_tuple(CatCache*cache,intnkeys,ScanKeyskeys);
101102

102103

@@ -344,6 +345,7 @@ CatCachePrintStats(void)
344345
* Unlink and delete the given cache entry
345346
*
346347
* NB: if it is a member of a CatCList, the CatCList is deleted too.
348+
* Both the cache entry and the list had better have zero refcount.
347349
*/
348350
staticvoid
349351
CatCacheRemoveCTup(CatCache*cache,CatCTup*ct)
@@ -481,8 +483,13 @@ CatalogCacheIdInvalidate(int cacheId,
481483
if (ct->negative||
482484
ItemPointerEquals(pointer,&ct->tuple.t_self))
483485
{
484-
if (ct->refcount>0)
486+
if (ct->refcount>0||
487+
(ct->c_list&&ct->c_list->refcount>0))
488+
{
485489
ct->dead= true;
490+
/* list, if any, was marked dead above */
491+
Assert(ct->c_list==NULL||ct->c_list->dead);
492+
}
486493
else
487494
CatCacheRemoveCTup(ccp,ct);
488495
CACHE1_elog(DEBUG2,"CatalogCacheIdInvalidate: invalidated");
@@ -606,8 +613,13 @@ ResetCatalogCache(CatCache *cache)
606613

607614
nextelt=DLGetSucc(elt);
608615

609-
if (ct->refcount>0)
616+
if (ct->refcount>0||
617+
(ct->c_list&&ct->c_list->refcount>0))
618+
{
610619
ct->dead= true;
620+
/* list, if any, was marked dead above */
621+
Assert(ct->c_list==NULL||ct->c_list->dead);
622+
}
611623
else
612624
CatCacheRemoveCTup(cache,ct);
613625
#ifdefCATCACHE_STATS
@@ -718,8 +730,14 @@ CatalogCacheFlushRelation(Oid relId)
718730

719731
if (tupRelid==relId)
720732
{
721-
if (ct->refcount>0)
733+
if (ct->refcount>0||
734+
(ct->c_list&&ct->c_list->refcount>0))
735+
{
722736
ct->dead= true;
737+
/* parent list must be considered dead too */
738+
if (ct->c_list)
739+
ct->c_list->dead= true;
740+
}
723741
else
724742
CatCacheRemoveCTup(cache,ct);
725743
#ifdefCATCACHE_STATS
@@ -1279,11 +1297,12 @@ ReleaseCatCache(HeapTuple tuple)
12791297
ct->refcount--;
12801298
ResourceOwnerForgetCatCacheRef(CurrentResourceOwner,&ct->tuple);
12811299

1282-
if (ct->refcount==0
1300+
if (
12831301
#ifndefCATCACHE_FORCE_RELEASE
1284-
&&ct->dead
1302+
ct->dead&&
12851303
#endif
1286-
)
1304+
ct->refcount==0&&
1305+
(ct->c_list==NULL||ct->c_list->refcount==0))
12871306
CatCacheRemoveCTup(ct->my_cache,ct);
12881307
}
12891308

@@ -1377,24 +1396,18 @@ SearchCatCacheList(CatCache *cache,
13771396
continue;
13781397

13791398
/*
1380-
*we found a matching list:move each of its members tothefront
1381-
*of the global LRU list.Also move the list itself to the front
1382-
* of the cache's list-of-lists, to speed subsequent searches. (We
1383-
* do not move the members to the fronts of their hashbucket
1399+
*We found a matching list:mark it as touched sincethelast
1400+
*CatalogCacheCleanup() sweep.Also move the list to the front
1401+
* of the cache's list-of-lists, to speed subsequent searches.
1402+
*(Wedo not move the members to the fronts of their hashbucket
13841403
* lists, however, since there's no point in that unless they are
1385-
* searched for individually.)Also bump the members' refcounts.
1386-
* (member refcounts are NOT registered separately with the
1387-
* resource owner.)
1404+
* searched for individually.)
13881405
*/
1389-
ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
1390-
for (i=0;i<cl->n_members;i++)
1391-
{
1392-
cl->members[i]->refcount++;
1393-
DLMoveToFront(&cl->members[i]->lrulist_elem);
1394-
}
1406+
cl->touched= true;
13951407
DLMoveToFront(&cl->cache_elem);
13961408

13971409
/* Bump the list's refcount and return it */
1410+
ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);
13981411
cl->refcount++;
13991412
ResourceOwnerRememberCatCacheListRef(CurrentResourceOwner,cl);
14001413

@@ -1413,7 +1426,7 @@ SearchCatCacheList(CatCache *cache,
14131426
* relation. For each matching tuple found in the relation, use an
14141427
* existing cache entry if possible, else build a new one.
14151428
*
1416-
* We have to bump the member refcountsimmediately to ensure they
1429+
* We have to bump the member refcountstemporarily to ensure they
14171430
* won't get dropped from the cache while loading other members.
14181431
* We use a PG_TRY block to ensure we can undo those refcounts if
14191432
* we get an error before we finish constructing the CatCList.
@@ -1488,6 +1501,7 @@ SearchCatCacheList(CatCache *cache,
14881501
}
14891502

14901503
/* Careful here: add entry to ctlist, then bump its refcount */
1504+
/* This way leaves state correct if lappend runs out of memory */
14911505
ctlist=lappend(ctlist,ct);
14921506
ct->refcount++;
14931507
}
@@ -1526,11 +1540,12 @@ SearchCatCacheList(CatCache *cache,
15261540
Assert(ct->c_list==NULL);
15271541
Assert(ct->refcount>0);
15281542
ct->refcount--;
1529-
if (ct->refcount==0
1543+
if (
15301544
#ifndefCATCACHE_FORCE_RELEASE
1531-
&&ct->dead
1545+
ct->dead&&
15321546
#endif
1533-
)
1547+
ct->refcount==0&&
1548+
(ct->c_list==NULL||ct->c_list->refcount==0))
15341549
CatCacheRemoveCTup(cache,ct);
15351550
}
15361551

@@ -1544,6 +1559,7 @@ SearchCatCacheList(CatCache *cache,
15441559
cl->refcount=0;/* for the moment */
15451560
cl->dead= false;
15461561
cl->ordered=ordered;
1562+
cl->touched= false;/* we already moved members to front */
15471563
cl->nkeys=nkeys;
15481564
cl->hash_value=lHashValue;
15491565
cl->n_members=nmembers;
@@ -1554,6 +1570,9 @@ SearchCatCacheList(CatCache *cache,
15541570
cl->members[i++]=ct= (CatCTup*)lfirst(ctlist_item);
15551571
Assert(ct->c_list==NULL);
15561572
ct->c_list=cl;
1573+
/* release the temporary refcount on the member */
1574+
Assert(ct->refcount>0);
1575+
ct->refcount--;
15571576
/* mark list dead if any members already dead */
15581577
if (ct->dead)
15591578
cl->dead= true;
@@ -1575,38 +1594,22 @@ SearchCatCacheList(CatCache *cache,
15751594
/*
15761595
*ReleaseCatCacheList
15771596
*
1578-
*Decrement the referencecounts of a catcache list.
1597+
*Decrement the referencecount of a catcache list.
15791598
*/
15801599
void
15811600
ReleaseCatCacheList(CatCList*list)
15821601
{
1583-
inti;
1584-
15851602
/* Safety checks to ensure we were handed a cache entry */
15861603
Assert(list->cl_magic==CL_MAGIC);
15871604
Assert(list->refcount>0);
1588-
1589-
for (i=list->n_members;--i >=0;)
1590-
{
1591-
CatCTup*ct=list->members[i];
1592-
1593-
Assert(ct->refcount>0);
1594-
1595-
ct->refcount--;
1596-
1597-
if (ct->dead)
1598-
list->dead= true;
1599-
/* can't remove tuple before list is removed */
1600-
}
1601-
16021605
list->refcount--;
16031606
ResourceOwnerForgetCatCacheListRef(CurrentResourceOwner,list);
16041607

1605-
if (list->refcount==0
1608+
if (
16061609
#ifndefCATCACHE_FORCE_RELEASE
1607-
&&list->dead
1610+
list->dead&&
16081611
#endif
1609-
)
1612+
list->refcount==0)
16101613
CatCacheRemoveCList(list->my_cache,list);
16111614
}
16121615

@@ -1654,35 +1657,87 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp,
16541657

16551658
/*
16561659
* If we've exceeded the desired size of the caches, try to throw away
1657-
* the least recently used entry. NB: be careful not to throw away
1660+
* the least recently used entry(s). NB: be careful not to throw away
16581661
* the newly-built entry...
16591662
*/
16601663
if (CacheHdr->ch_ntup>CacheHdr->ch_maxtup)
1661-
{
1662-
Dlelem*elt,
1663-
*prevelt;
1664+
CatalogCacheCleanup(ct);
16641665

1665-
for (elt=DLGetTail(&CacheHdr->ch_lrulist);elt;elt=prevelt)
1666-
{
1667-
CatCTup*oldct= (CatCTup*)DLE_VAL(elt);
1666+
returnct;
1667+
}
1668+
1669+
/*
1670+
* CatalogCacheCleanup
1671+
*Try to reduce the size of the catcaches when they get too big
1672+
*
1673+
* savect can be NULL, or a specific CatCTup not to remove even if it
1674+
* has zero refcount.
1675+
*/
1676+
staticvoid
1677+
CatalogCacheCleanup(CatCTup*savect)
1678+
{
1679+
inttup_target;
1680+
CatCache*ccp;
1681+
Dlelem*elt,
1682+
*prevelt;
16681683

1669-
prevelt=DLGetPred(elt);
1684+
/*
1685+
* Each time we have to do this, try to cut the cache size down to
1686+
* about 90% of the maximum.
1687+
*/
1688+
tup_target= (CacheHdr->ch_maxtup*9) /10;
1689+
1690+
/*
1691+
* Our strategy for managing CatCLists is that, each time we have to
1692+
* throw away some cache entries, we first move-to-front all the members
1693+
* of CatCLists that have been touched since the last cleanup sweep.
1694+
* Then we do strict LRU elimination by individual tuples, zapping a list
1695+
* if any of its members gets zapped. Before PostgreSQL 8.1, we moved
1696+
* members to front each time their owning list was touched, which was
1697+
* arguably more fair in balancing list members against standalone tuples
1698+
* --- but the overhead for large lists was horrendous. This scheme is
1699+
* more heavily biased towards preserving lists, but that is not
1700+
* necessarily bad either.
1701+
*/
1702+
for (ccp=CacheHdr->ch_caches;ccp;ccp=ccp->cc_next)
1703+
{
1704+
for (elt=DLGetHead(&ccp->cc_lists);elt;elt=DLGetSucc(elt))
1705+
{
1706+
CatCList*cl= (CatCList*)DLE_VAL(elt);
16701707

1671-
if (oldct->refcount==0&&oldct!=ct)
1708+
Assert(cl->cl_magic==CL_MAGIC);
1709+
if (cl->touched&& !cl->dead)
16721710
{
1673-
CACHE2_elog(DEBUG2,"CatCacheCreateEntry(%s): Overflow, LRU removal",
1674-
cache->cc_relname);
1675-
#ifdefCATCACHE_STATS
1676-
oldct->my_cache->cc_discards++;
1677-
#endif
1678-
CatCacheRemoveCTup(oldct->my_cache,oldct);
1679-
if (CacheHdr->ch_ntup <=CacheHdr->ch_maxtup)
1680-
break;
1711+
inti;
1712+
1713+
for (i=0;i<cl->n_members;i++)
1714+
DLMoveToFront(&cl->members[i]->lrulist_elem);
16811715
}
1716+
cl->touched= false;
16821717
}
16831718
}
16841719

1685-
returnct;
1720+
/* Now get rid of unreferenced tuples in reverse global LRU order */
1721+
for (elt=DLGetTail(&CacheHdr->ch_lrulist);elt;elt=prevelt)
1722+
{
1723+
CatCTup*ct= (CatCTup*)DLE_VAL(elt);
1724+
1725+
prevelt=DLGetPred(elt);
1726+
1727+
if (ct->refcount==0&&
1728+
(ct->c_list==NULL||ct->c_list->refcount==0)&&
1729+
ct!=savect)
1730+
{
1731+
#ifdefCATCACHE_STATS
1732+
ct->my_cache->cc_discards++;
1733+
#endif
1734+
CatCacheRemoveCTup(ct->my_cache,ct);
1735+
1736+
/* Quit when we've removed enough tuples */
1737+
if (CacheHdr->ch_ntup <=tup_target)
1738+
break;
1739+
}
1740+
}
16861741
}
16871742

16881743
/*

‎src/include/utils/catcache.h‎

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@
1313
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
1414
* Portions Copyright (c) 1994, Regents of the University of California
1515
*
16-
* $PostgreSQL: pgsql/src/include/utils/catcache.h,v 1.54 2005/04/14 20:03:27 tgl Exp $
16+
* $PostgreSQL: pgsql/src/include/utils/catcache.h,v 1.55 2005/08/13 22:18:07 tgl Exp $
1717
*
1818
*-------------------------------------------------------------------------
1919
*/
@@ -79,21 +79,25 @@ typedef struct catctup
7979
* Each tuple in a cache is a member of two Dllists: one lists all the
8080
* elements in all the caches in LRU order, and the other lists just
8181
* the elements in one hashbucket of one cache, also in LRU order.
82-
*
82+
*/
83+
Dlelemlrulist_elem;/* list member of global LRU list */
84+
Dlelemcache_elem;/* list member of per-bucket list */
85+
86+
/*
8387
* The tuple may also be a member of at most one CatCList.(If a single
8488
* catcache is list-searched with varying numbers of keys, we may have
8589
* to make multiple entries for the same tuple because of this
8690
* restriction. Currently, that's not expected to be common, so we
8791
* accept the potential inefficiency.)
8892
*/
89-
Dlelemlrulist_elem;/* list member of global LRU list */
90-
Dlelemcache_elem;/* list member of per-bucket list */
91-
structcatclist*c_list;/* containing catclist, or NULL if none */
93+
structcatclist*c_list;/* containing CatCList, or NULL if none */
9294

9395
/*
9496
* A tuple marked "dead" must not be returned by subsequent searches.
9597
* However, it won't be physically deleted from the cache until its
96-
* refcount goes to zero.
98+
* refcount goes to zero. (If it's a member of a CatCList, the list's
99+
* refcount must go to zero, too; also, remember to mark the list dead
100+
* at the same time the tuple is marked.)
97101
*
98102
* A negative cache entry is an assertion that there is no tuple matching
99103
* a particular key. This is just as useful as a normal entry so far
@@ -123,14 +127,13 @@ typedef struct catclist
123127
* none of these will be negative cache entries.)
124128
*
125129
* A CatCList is only a member of a per-cache list; we do not do separate
126-
* LRU management for CatCLists. Instead, a CatCList is dropped from
127-
* the cache as soon as any one of its member tuples ages out due to
128-
* tuple-level LRU management.
130+
* LRU management for CatCLists. See CatalogCacheCleanup() for the
131+
* details of the management algorithm.
129132
*
130133
* A list marked "dead" must not be returned by subsequent searches.
131134
* However, it won't be physically deleted from the cache until its
132-
* refcount goes to zero. (Its member tuples must have refcounts at
133-
*least as large, so they won't go away either.)
135+
* refcount goes to zero. (A list should be marked dead if any of its
136+
*member entries are dead.)
134137
*
135138
* If "ordered" is true then the member tuples appear in the order of the
136139
* cache's underlying index. This will be true in normal operation,
@@ -141,6 +144,7 @@ typedef struct catclist
141144
intrefcount;/* number of active references */
142145
booldead;/* dead but not yet removed? */
143146
boolordered;/* members listed in index order? */
147+
booltouched;/* used since last CatalogCacheCleanup? */
144148
shortnkeys;/* number of lookup keys specified */
145149
uint32hash_value;/* hash value for lookup keys */
146150
HeapTupleDatatuple;/* header for tuple holding keys */

0 commit comments

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