Skip to content

P
Postgres FD Implementation
Commit 07dfe977 authored by Tom Lane's avatar Tom Lane
Browse files
Options

Don't run in CacheMemoryContext more than necessary.

parent d0032132
Hide whitespace changes
Inline Side-by-side
Showing with 34 additions and 150 deletions
src/backend/utils/cache/catcache.c
View file @ 07dfe977
......@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.68 2000/06/28 03:32:24 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.69 2000/07/02 05:38:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
......@@ -190,57 +190,32 @@ CatalogCacheInitializeCache(CatCache * cache,
Relation relation)
{
MemoryContext oldcxt;
short didopen = 0;
bool didopen = false;
short i;
TupleDesc tupdesc;
CatalogCacheInitializeCache_DEBUG1;
/* ----------------
* first switch to the cache context so our allocations
* do not vanish at the end of a transaction
* ----------------
*/
if (!CacheMemoryContext)
CreateCacheMemoryContext();
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
/* ----------------
* If no relation was passed we must open it to get access to
* its fields. If one of the other caches has already opened
* it we use heap_open() instead of heap_openr().
* XXX is that really worth the trouble of checking?
* its fields.
* ----------------
*/
if (!RelationIsValid(relation))
{
CatCache *cp;
/* ----------------
* scan the caches to see if any other cache has opened the relation
* ----------------
*/
for (cp = Caches; cp; cp = cp->cc_next)
{
if (strncmp(cp->cc_relname, cache->cc_relname, NAMEDATALEN) == 0)
{
if (cp->relationId != InvalidOid)
break;
}
}
relation = heap_openr(cache->cc_relname, NoLock);
didopen = true;
}
/* ----------------
* open the relation by name or by id
* ----------------
*/
if (cp)
relation = heap_open(cp->relationId, NoLock);
else
relation = heap_openr(cache->cc_relname, NoLock);
/* ----------------
* switch to the cache context so our allocations
* do not vanish at the end of a transaction
* ----------------
*/
if (!CacheMemoryContext)
CreateCacheMemoryContext();
didopen = 1;
}
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
/* ----------------
* initialize the cache's relation id and tuple descriptor
......@@ -285,6 +260,12 @@ CatalogCacheInitializeCache(CatCache * cache,
}
}
/* ----------------
* return to the caller's memory context
* ----------------
*/
MemoryContextSwitchTo(oldcxt);
/* ----------------
* close the relation if we opened it
* ----------------
......@@ -313,12 +294,6 @@ CatalogCacheInitializeCache(CatCache * cache,
else
cache->cc_indname = NULL;
}
/* ----------------
* return to the proper memory context
* ----------------
*/
MemoryContextSwitchTo(oldcxt);
}
/* --------------------------------
......@@ -433,8 +408,6 @@ CatalogCacheComputeTupleHashIndex(CatCache * cacheInOutP,
/* --------------------------------
* CatCacheRemoveCTup
*
* NB: assumes caller has switched to CacheMemoryContext
* --------------------------------
*/
static void
......@@ -482,7 +455,6 @@ CatalogCacheIdInvalidate(int cacheId, /* XXX */
CatCache *ccp;
CatCTup *ct;
Dlelem *elt;
MemoryContext oldcxt;
/* ----------------
* sanity checks
......@@ -492,15 +464,6 @@ CatalogCacheIdInvalidate(int cacheId, /* XXX */
Assert(ItemPointerIsValid(pointer));
CACHE1_elog(DEBUG, "CatalogCacheIdInvalidate: called");
/* ----------------
* switch to the cache context for our memory allocations
* ----------------
*/
if (!CacheMemoryContext)
CreateCacheMemoryContext();
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
/* ----------------
* inspect every cache that could contain the tuple
* ----------------
......@@ -537,12 +500,6 @@ CatalogCacheIdInvalidate(int cacheId, /* XXX */
if (cacheId != InvalidCatalogCacheId)
break;
}
/* ----------------
* return to the proper memory context
* ----------------
*/
MemoryContextSwitchTo(oldcxt);
}
/* ----------------------------------------------------------------
......@@ -562,21 +519,10 @@ CatalogCacheIdInvalidate(int cacheId, /* XXX */
void
ResetSystemCache()
{
MemoryContext oldcxt;
CatCache *cache;
CACHE1_elog(DEBUG, "ResetSystemCache called");
/* ----------------
* first switch to the cache context so our allocations
* do not vanish at the end of a transaction
* ----------------
*/
if (!CacheMemoryContext)
CreateCacheMemoryContext();
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
/* ----------------
* here we purge the contents of all the caches
*
......@@ -609,12 +555,6 @@ ResetSystemCache()
}
CACHE1_elog(DEBUG, "end of ResetSystemCache call");
/* ----------------
* back to the old context before we return...
* ----------------
*/
MemoryContextSwitchTo(oldcxt);
}
/* --------------------------------
......@@ -682,7 +622,7 @@ do { \
CatCache *
InitSysCache(char *relname,
char *iname,
char *indname,
int id,
int nkeys,
int *key,
......@@ -692,10 +632,6 @@ InitSysCache(char *relname,
int i;
MemoryContext oldcxt;
char *indname;
indname = (iname) ? iname : NULL;
/* ----------------
* first switch to the cache context so our allocations
* do not vanish at the end of a transaction
......@@ -805,6 +741,7 @@ InitSysCache(char *relname,
* ----------------
*/
MemoryContextSwitchTo(oldcxt);
return cp;
}
......@@ -927,7 +864,7 @@ SearchSysCache(CatCache * cache,
CatCTup *nct;
CatCTup *nct2;
Dlelem *elt;
HeapTuple ntp = NULL;
HeapTuple ntp;
Relation relation;
MemoryContext oldcxt;
......@@ -950,7 +887,7 @@ SearchSysCache(CatCache * cache,
/*
* resolve self referencing informtion
*/
if ((ntp = SearchSelfReferences(cache)))
if ((ntp = SearchSelfReferences(cache)) != NULL)
return ntp;
/* ----------------
......@@ -1034,16 +971,6 @@ SearchSysCache(CatCache * cache,
CACHE2_elog(DEBUG, "SearchSysCache(%s)",
RelationGetRelationName(relation));
/* ----------------
* Switch to the cache memory context.
* ----------------
*/
if (!CacheMemoryContext)
CreateCacheMemoryContext();
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
/* ----------------
* Scan the relation to find the tuple. If there's an index, and
* if this isn't bootstrap (initdb) time, use the index.
......@@ -1056,14 +983,6 @@ SearchSysCache(CatCache * cache,
{
HeapTuple indextp;
/* ----------
* Switch back to old memory context so memory not freed
* in the scan function will go away at transaction end.
* wieck - 10/18/1996
* ----------
*/
MemoryContextSwitchTo(oldcxt);
/* We call the scanfunc with all four arguments to satisfy the
* declared prototype, even though the function will likely not
* use all four.
......@@ -1071,53 +990,39 @@ SearchSysCache(CatCache * cache,
indextp = cache->cc_iscanfunc(relation, v1, v2, v3, v4);
/* ----------
* Back to Cache context. If we got a tuple copy it
* into our context. wieck - 10/18/1996
* If we got a tuple copy it into our context. wieck - 10/18/1996
* And free the tuple that was allocated in the
* transaction's context. tgl - 02/03/2000
* ----------
*/
if (HeapTupleIsValid(indextp))
{
MemoryContextSwitchTo(CacheMemoryContext);
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
ntp = heap_copytuple(indextp);
/* this switch is probably not needed anymore: */
MemoryContextSwitchTo(oldcxt);
heap_freetuple(indextp);
}
MemoryContextSwitchTo(CacheMemoryContext);
}
else
{
HeapScanDesc sd;
/* ----------
* As above do the lookup in the callers memory
* context.
* wieck - 10/18/1996
* ----------
*/
MemoryContextSwitchTo(oldcxt);
sd = heap_beginscan(relation, 0, SnapshotNow,
cache->cc_nkeys, cache->cc_skey);
ntp = heap_getnext(sd, 0);
MemoryContextSwitchTo(CacheMemoryContext);
if (HeapTupleIsValid(ntp))
{
CACHE1_elog(DEBUG, "SearchSysCache: found tuple");
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
ntp = heap_copytuple(ntp);
MemoryContextSwitchTo(oldcxt);
/* We should not free the result of heap_getnext... */
}
MemoryContextSwitchTo(oldcxt);
heap_endscan(sd);
MemoryContextSwitchTo(CacheMemoryContext);
}
cache->busy = false;
......@@ -1136,6 +1041,8 @@ SearchSysCache(CatCache * cache,
*/
Dlelem *lru_elt;
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
/*
* this is a little cumbersome here because we want the Dlelem's
* in both doubly linked lists to point to one another. That makes
......@@ -1154,6 +1061,8 @@ SearchSysCache(CatCache * cache,
DLAddHead(cache->cc_lrulist, lru_elt);
DLAddHead(cache->cc_cache[hash], elt);
MemoryContextSwitchTo(oldcxt);
/* ----------------
* If we've exceeded the desired size of this cache,
* throw away the least recently used entry.
......@@ -1183,14 +1092,11 @@ SearchSysCache(CatCache * cache,
}
/* ----------------
* close the relation, switch back to the original memory context
* and return the tuple we found (or NULL)
* close the relation and return the tuple we found (or NULL)
* ----------------
*/
heap_close(relation, AccessShareLock);
MemoryContextSwitchTo(oldcxt);
return ntp;
}
......@@ -1208,8 +1114,7 @@ RelationInvalidateCatalogCacheTuple(Relation relation,
HeapTuple tuple,
void (*function) (int, Index, ItemPointer))
{
CatCache *ccp;
MemoryContext oldcxt;
CatCache *ccp;
Oid relationId;
/* ----------------
......@@ -1221,15 +1126,6 @@ RelationInvalidateCatalogCacheTuple(Relation relation,
Assert(PointerIsValid(function));
CACHE1_elog(DEBUG, "RelationInvalidateCatalogCacheTuple: called");
/* ----------------
* switch to the cache memory context
* ----------------
*/
if (!CacheMemoryContext)
CreateCacheMemoryContext();
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
/* ----------------
* for each cache
* if the cache contains tuples from the specified relation
......@@ -1244,20 +1140,8 @@ RelationInvalidateCatalogCacheTuple(Relation relation,
if (relationId != ccp->relationId)
continue;
#ifdef NOT_USED
/* OPT inline simplification of CatalogCacheIdInvalidate */
if (!PointerIsValid(function))
function = CatalogCacheIdInvalidate;
#endif
(*function) (ccp->id,
CatalogCacheComputeTupleHashIndex(ccp, relation, tuple),
&tuple->t_self);
}
/* ----------------
* return to the proper memory context
* ----------------
*/
MemoryContextSwitchTo(oldcxt);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment