diff -Ncar pgsql.orig/contrib/pg_freespacemap/Makefile pgsql/contrib/pg_freespacemap/Makefile *** pgsql.orig/contrib/pg_freespacemap/Makefile Thu Jan 1 12:00:00 1970 --- pgsql/contrib/pg_freespacemap/Makefile Sun Feb 12 16:55:53 2006 *************** *** 0 **** --- 1,17 ---- + # $PostgreSQL: pgsql/contrib/pg_freespacemap/Makefile,v 1.1 2006/02/12 03:55:53 momjian Exp $ + + MODULE_big = pg_freespacemap + OBJS = pg_freespacemap.o + + DATA_built = pg_freespacemap.sql + DOCS = README.pg_freespacemap + + ifdef USE_PGXS + PGXS := $(shell pg_config --pgxs) + include $(PGXS) + else + subdir = contrib/pg_freespacemap + top_builddir = ../.. + include $(top_builddir)/src/Makefile.global + include $(top_srcdir)/contrib/contrib-global.mk + endif diff -Ncar pgsql.orig/contrib/pg_freespacemap/README.pg_freespacemap pgsql/contrib/pg_freespacemap/README.pg_freespacemap *** pgsql.orig/contrib/pg_freespacemap/README.pg_freespacemap Thu Jan 1 12:00:00 1970 --- pgsql/contrib/pg_freespacemap/README.pg_freespacemap Fri Apr 28 18:23:10 2006 *************** *** 0 **** --- 1,165 ---- + Pg_freespacemap - Real time queries on the free space map (FSM). + --------------- + + This module consists of two C functions: 'pg_freespacemap_relations()' and + 'pg_freespacemap_pages()' that return a set of records, plus two views + 'pg_freespacemap_relations' and 'pg_freespacemap_pages' for more + user-friendly access to the functions. + + The module provides the ability to examine the contents of the free space + map, without having to restart or rebuild the server with additional + debugging code. + + By default public access is REVOKED from the functions and views, just in + case there are security issues present in the code. + + + Installation + ------------ + + Build and install the main Postgresql source, then this contrib module: + + $ cd contrib/pg_freespacemap + $ gmake + $ gmake install + + + To register the functions and views: + + $ psql -d -f pg_freespacemap.sql + + + Notes + ----- + + The definitions for the columns exposed in the views are: + + pg_freespacemap_relations + + Column | references | Description + ----------------+----------------------+------------------------------------ + reltablespace | pg_tablespace.oid | Tablespace oid of the relation. + reldatabase | pg_database.oid | Database for the relation. + relfilenode | pg_class.relfilenode | Refilenode of the relation. + avgrequest | | Moving average of free space + | | requests. + lastpagecount | | Count of pages examined for useful + | | free space. + nextpage | | page index (from 0) to start next + | | search at. + + + pg_freespacemap_pages + + Column | references | Description + ----------------+----------------------+------------------------------------ + reltablespace | pg_tablespace.oid | Tablespace oid of the relation. + reldatabase | pg_database.oid | Database for the relation. + relfilenode | pg_class.relfilenode | Refilenode of the relation. + relblocknumber | | Page offset in the relation. + bytes | | Free bytes in the page, or NULL + | | for an index page (see below). + + + For pg_freespacemap_relations, there is one row for each relation in the free + space map. + + For pg_freespacemap_pages, there is one row for each page in the free space + map. + + Because the map is shared by all the databases, there are relations and pages + from relations not belonging to the current database. + + The view 'freespacemap_pages' can contain pages for btree indexes if they + were emptied by a vacuum process. The bytes field is set to NULL in this case. + + When either of the views are accessed, internal free space map locks are + taken, and a copy of the map data is made for them to display. + This ensures that the views produce a consistent set of results, while not + blocking normal activity longer than necessary. Nonetheless there + could be some impact on database performance if they are read often. + + + Sample output - pg_freespacemap_relations + ------------- + + regression=# \d pg_freespacemap_relations + View "public.pg_freespacemap_relations" + Column | Type | Modifiers + ---------------+---------+----------- + reltablespace | oid | + reldatabase | oid | + relfilenode | oid | + avgrequest | bigint | + lastpagecount | integer | + nextpage | integer | + View definition: + SELECT p.reltablespace, p.reldatabase, p.relfilenode, p.avgrequest, p.lastpagecount, p.nextpage + FROM pg_freespacemap_relations() p(reltablespace oid, reldatabase oid, relfilenode oid, avgrequest bigint, lastpagecount integer, nextpage integer); + + regression=# SELECT c.relname, r.avgrequest, r.lastpagecount, r.nextpage + FROM pg_freespacemap_relations r INNER JOIN pg_class c + ON c.relfilenode = r.relfilenode INNER JOIN pg_database d + ON r.reldatabase = d.oid AND (d.datname = current_database()) + ORDER BY c.relname LIMIT 10; + relname | avgrequest | lastpagecount | nextpage + --------------+------------+---------------+---------- + a_star | 250 | 1 | 0 + abstime_tbl | 249 | 1 | 0 + aggtest | 250 | 1 | 0 + altinhoid | 250 | 1 | 0 + altstartwith | 250 | 1 | 0 + arrtest | 254 | 1 | 0 + b_star | 250 | 1 | 0 + box_tbl | 250 | 1 | 0 + bt_f8_heap | 92 | 1 | 0 + bt_i4_heap | 94 | 1 | 0 + (10 rows) + + regression=# + + + Sample output - pg_freespacemap_pages + ------------- + + regression=# \d pg_freespacemap_pages; + View "public.pg_freespacemap_pages" + Column | Type | Modifiers + ----------------+---------+----------- + reltablespace | oid | + reldatabase | oid | + relfilenode | oid | + relblocknumber | bigint | + bytes | integer | + View definition: + SELECT p.reltablespace, p.reldatabase, p.relfilenode, p.relblocknumber, p.bytes + FROM pg_freespacemap_pages() p(reltablespace oid, reldatabase oid, relfilenode oid, relblocknumber bigint, bytes integer); + + regression=# SELECT c.relname, p.relblocknumber, p.bytes + FROM pg_freespacemap_pages p INNER JOIN pg_class c + ON c.relfilenode = p.relfilenode INNER JOIN pg_database d + ON (p.reldatabase = d.oid AND d.datname = current_database()) + ORDER BY c.relname LIMIT 10; + relname | relblocknumber | bytes + --------------+----------------+------- + a_star | 0 | 8040 + abstime_tbl | 0 | 7908 + aggtest | 0 | 8008 + altinhoid | 0 | 8128 + altstartwith | 0 | 8128 + arrtest | 0 | 7172 + b_star | 0 | 7976 + box_tbl | 0 | 7912 + bt_f8_heap | 54 | 7728 + bt_i4_heap | 49 | 8008 + (10 rows) + + regression=# + + + + Author + ------ + + * Mark Kirkwood + diff -Ncar pgsql.orig/contrib/pg_freespacemap/pg_freespacemap.c pgsql/contrib/pg_freespacemap/pg_freespacemap.c *** pgsql.orig/contrib/pg_freespacemap/pg_freespacemap.c Thu Jan 1 12:00:00 1970 --- pgsql/contrib/pg_freespacemap/pg_freespacemap.c Fri Apr 28 18:23:10 2006 *************** *** 0 **** --- 1,444 ---- + /*------------------------------------------------------------------------- + * + * pg_freespacemap.c + * display some contents of the free space relation and page maps. + * + * $PostgreSQL: pgsql/contrib/pg_freespacemap/pg_freespacemap.c,v 1.4 2006/04/26 22:46:09 momjian Exp $ + *------------------------------------------------------------------------- + */ + #include "postgres.h" + #include "funcapi.h" + #include "catalog/pg_type.h" + #include "storage/freespace.h" + #include "utils/relcache.h" + + #define NUM_FREESPACE_PAGES_ELEM 5 + #define NUM_FREESPACE_RELATIONS_ELEM 6 + + #if defined(WIN32) || defined(__CYGWIN__) + /* Need DLLIMPORT for some things that are not so marked in main headers */ + extern DLLIMPORT int MaxFSMPages; + extern DLLIMPORT int MaxFSMRelations; + extern DLLIMPORT volatile uint32 InterruptHoldoffCount; + #endif + + Datum pg_freespacemap_pages(PG_FUNCTION_ARGS); + Datum pg_freespacemap_relations(PG_FUNCTION_ARGS); + + + /* + * Record structure holding the to be exposed free space page data. + */ + typedef struct + { + + uint32 reltablespace; + uint32 reldatabase; + uint32 relfilenode; + uint32 relblocknumber; + uint32 bytes; + bool isindex; + + } FreeSpacePagesRec; + + + /* + * Record structure holding the to be exposed free space relation data. + */ + typedef struct + { + + uint32 reltablespace; + uint32 reldatabase; + uint32 relfilenode; + int64 avgrequest; + int lastpagecount; + int nextpage; + + } FreeSpaceRelationsRec; + + + + /* + * Function context for page data persisting over repeated calls. + */ + typedef struct + { + + AttInMetadata *attinmeta; + FreeSpacePagesRec *record; + char *values[NUM_FREESPACE_PAGES_ELEM]; + + } FreeSpacePagesContext; + + + /* + * Function context for relation data persisting over repeated calls. + */ + typedef struct + { + + AttInMetadata *attinmeta; + FreeSpaceRelationsRec *record; + char *values[NUM_FREESPACE_RELATIONS_ELEM]; + + } FreeSpaceRelationsContext; + + + /* + * Function returning page data from the Free Space Map (FSM). + */ + PG_FUNCTION_INFO_V1(pg_freespacemap_pages); + Datum + pg_freespacemap_pages(PG_FUNCTION_ARGS) + { + + FuncCallContext *funcctx; + Datum result; + MemoryContext oldcontext; + FreeSpacePagesContext *fctx; /* User function context. */ + TupleDesc tupledesc; + HeapTuple tuple; + + FSMHeader *FreeSpaceMap; /* FSM main structure. */ + FSMRelation *fsmrel; /* Individual relation. */ + + + if (SRF_IS_FIRSTCALL()) + { + uint32 i; + uint32 numPages; /* Max possible no. of pages in map. */ + int nPages; /* Mapped pages for a relation. */ + + /* + * Get the free space map data structure. + */ + FreeSpaceMap = GetFreeSpaceMap(); + + numPages = MaxFSMPages; + + funcctx = SRF_FIRSTCALL_INIT(); + + /* Switch context when allocating stuff to be used in later calls */ + oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); + + /* Construct a tuple to return. */ + tupledesc = CreateTemplateTupleDesc(NUM_FREESPACE_PAGES_ELEM, false); + TupleDescInitEntry(tupledesc, (AttrNumber) 1, "reltablespace", + OIDOID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 2, "reldatabase", + OIDOID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 3, "relfilenode", + OIDOID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 4, "relblocknumber", + INT8OID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 5, "bytes", + INT4OID, -1, 0); + + /* Generate attribute metadata needed later to produce tuples */ + funcctx->attinmeta = TupleDescGetAttInMetadata(tupledesc); + + /* + * Create a function context for cross-call persistence and initialize + * the counters. + */ + fctx = (FreeSpacePagesContext *) palloc(sizeof(FreeSpacePagesContext)); + funcctx->user_fctx = fctx; + + /* Set an upper bound on the calls */ + funcctx->max_calls = numPages; + + + /* Allocate numPages worth of FreeSpacePagesRec records, this is also + * an upper bound. + */ + fctx->record = (FreeSpacePagesRec *) palloc(sizeof(FreeSpacePagesRec) * numPages); + + /* allocate the strings for tuple formation */ + fctx->values[0] = (char *) palloc(3 * sizeof(uint32) + 1); + fctx->values[1] = (char *) palloc(3 * sizeof(uint32) + 1); + fctx->values[2] = (char *) palloc(3 * sizeof(uint32) + 1); + fctx->values[3] = (char *) palloc(3 * sizeof(uint32) + 1); + fctx->values[4] = (char *) palloc(3 * sizeof(uint32) + 1); + + + /* Return to original context when allocating transient memory */ + MemoryContextSwitchTo(oldcontext); + + + /* + * Lock free space map and scan though all the relations, + * for each relation, gets all its mapped pages. + */ + LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE); + + + i = 0; + + for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) + { + + if (fsmrel->isIndex) + { /* Index relation. */ + IndexFSMPageData *page; + + page = (IndexFSMPageData *) + (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES); + + for (nPages = 0; nPages < fsmrel->storedPages; nPages++) + { + + fctx->record[i].reltablespace = fsmrel->key.spcNode; + fctx->record[i].reldatabase = fsmrel->key.dbNode; + fctx->record[i].relfilenode = fsmrel->key.relNode; + fctx->record[i].relblocknumber = IndexFSMPageGetPageNum(page); + fctx->record[i].bytes = 0; + fctx->record[i].isindex = true; + + page++; + i++; + } + } + else + { /* Heap relation. */ + FSMPageData *page; + + page = (FSMPageData *) + (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES); + + for (nPages = 0; nPages < fsmrel->storedPages; nPages++) + { + fctx->record[i].reltablespace = fsmrel->key.spcNode; + fctx->record[i].reldatabase = fsmrel->key.dbNode; + fctx->record[i].relfilenode = fsmrel->key.relNode; + fctx->record[i].relblocknumber = FSMPageGetPageNum(page); + fctx->record[i].bytes = FSMPageGetSpace(page); + fctx->record[i].isindex = false; + + page++; + i++; + } + + } + + } + + /* Set the real no. of calls as we know it now! */ + funcctx->max_calls = i; + + /* Release free space map. */ + LWLockRelease(FreeSpaceLock); + } + + funcctx = SRF_PERCALL_SETUP(); + + /* Get the saved state */ + fctx = funcctx->user_fctx; + + + if (funcctx->call_cntr < funcctx->max_calls) + { + uint32 i = funcctx->call_cntr; + char *values[NUM_FREESPACE_PAGES_ELEM]; + int j; + + /* + * Use a temporary values array, initially pointing to fctx->values, + * so it can be reassigned w/o losing the storage for subsequent + * calls. + */ + for (j = 0; j < NUM_FREESPACE_PAGES_ELEM; j++) + { + values[j] = fctx->values[j]; + } + + + sprintf(values[0], "%u", fctx->record[i].reltablespace); + sprintf(values[1], "%u", fctx->record[i].reldatabase); + sprintf(values[2], "%u", fctx->record[i].relfilenode); + sprintf(values[3], "%u", fctx->record[i].relblocknumber); + + + /* + * Set (free) bytes to NULL for an index relation. + */ + if (fctx->record[i].isindex == true) + { + values[4] = NULL; + } + else + { + sprintf(values[4], "%u", fctx->record[i].bytes); + } + + + /* Build and return the tuple. */ + tuple = BuildTupleFromCStrings(funcctx->attinmeta, values); + result = HeapTupleGetDatum(tuple); + + + SRF_RETURN_NEXT(funcctx, result); + } + else + SRF_RETURN_DONE(funcctx); + + } + + + /* + * Function returning relation data from the Free Space Map (FSM). + */ + PG_FUNCTION_INFO_V1(pg_freespacemap_relations); + Datum + pg_freespacemap_relations(PG_FUNCTION_ARGS) + { + + FuncCallContext *funcctx; + Datum result; + MemoryContext oldcontext; + FreeSpaceRelationsContext *fctx; /* User function context. */ + TupleDesc tupledesc; + HeapTuple tuple; + + FSMHeader *FreeSpaceMap; /* FSM main structure. */ + FSMRelation *fsmrel; /* Individual relation. */ + + + if (SRF_IS_FIRSTCALL()) + { + uint32 i; + uint32 numRelations; /* Max no. of Relations in map. */ + + /* + * Get the free space map data structure. + */ + FreeSpaceMap = GetFreeSpaceMap(); + + numRelations = MaxFSMRelations; + + funcctx = SRF_FIRSTCALL_INIT(); + + /* Switch context when allocating stuff to be used in later calls */ + oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); + + /* Construct a tuple to return. */ + tupledesc = CreateTemplateTupleDesc(NUM_FREESPACE_RELATIONS_ELEM, false); + TupleDescInitEntry(tupledesc, (AttrNumber) 1, "reltablespace", + OIDOID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 2, "reldatabase", + OIDOID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 3, "relfilenode", + OIDOID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 4, "avgrequest", + INT8OID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 5, "lastpageCount", + INT4OID, -1, 0); + TupleDescInitEntry(tupledesc, (AttrNumber) 6, "nextpage", + INT4OID, -1, 0); + + /* Generate attribute metadata needed later to produce tuples */ + funcctx->attinmeta = TupleDescGetAttInMetadata(tupledesc); + + /* + * Create a function context for cross-call persistence and initialize + * the counters. + */ + fctx = (FreeSpaceRelationsContext *) palloc(sizeof(FreeSpaceRelationsContext)); + funcctx->user_fctx = fctx; + + /* Set an upper bound on the calls */ + funcctx->max_calls = numRelations; + + + /* Allocate numRelations worth of FreeSpaceRelationsRec records, + * this is also an upper bound. + */ + fctx->record = (FreeSpaceRelationsRec *) palloc(sizeof(FreeSpaceRelationsRec) * numRelations); + + /* allocate the strings for tuple formation */ + fctx->values[0] = (char *) palloc(3 * sizeof(uint32) + 1); + fctx->values[1] = (char *) palloc(3 * sizeof(uint32) + 1); + fctx->values[2] = (char *) palloc(3 * sizeof(uint32) + 1); + fctx->values[3] = (char *) palloc(3 * sizeof(int64) + 1); + fctx->values[4] = (char *) palloc(3 * sizeof(int32) + 1); + fctx->values[5] = (char *) palloc(3 * sizeof(int32) + 1); + + + /* Return to original context when allocating transient memory */ + MemoryContextSwitchTo(oldcontext); + + + /* + * Lock free space map and scan though all the relations, + */ + LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE); + + + i = 0; + + for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) + { + + fctx->record[i].reltablespace = fsmrel->key.spcNode; + fctx->record[i].reldatabase = fsmrel->key.dbNode; + fctx->record[i].relfilenode = fsmrel->key.relNode; + fctx->record[i].avgrequest = (int64)fsmrel->avgRequest; + fctx->record[i].lastpagecount = fsmrel->lastPageCount; + fctx->record[i].nextpage = fsmrel->nextPage; + + i++; + + + } + + /* Set the real no. of calls as we know it now! */ + funcctx->max_calls = i; + + /* Release free space map. */ + LWLockRelease(FreeSpaceLock); + } + + funcctx = SRF_PERCALL_SETUP(); + + /* Get the saved state */ + fctx = funcctx->user_fctx; + + + if (funcctx->call_cntr < funcctx->max_calls) + { + uint32 i = funcctx->call_cntr; + char *values[NUM_FREESPACE_RELATIONS_ELEM]; + int j; + + /* + * Use a temporary values array, initially pointing to fctx->values, + * so it can be reassigned w/o losing the storage for subsequent + * calls. + */ + for (j = 0; j < NUM_FREESPACE_RELATIONS_ELEM; j++) + { + values[j] = fctx->values[j]; + } + + + sprintf(values[0], "%u", fctx->record[i].reltablespace); + sprintf(values[1], "%u", fctx->record[i].reldatabase); + sprintf(values[2], "%u", fctx->record[i].relfilenode); + sprintf(values[3], INT64_FORMAT, fctx->record[i].avgrequest); + sprintf(values[4], "%d", fctx->record[i].lastpagecount); + sprintf(values[5], "%d", fctx->record[i].nextpage); + + + + /* Build and return the tuple. */ + tuple = BuildTupleFromCStrings(funcctx->attinmeta, values); + result = HeapTupleGetDatum(tuple); + + + SRF_RETURN_NEXT(funcctx, result); + } + else + SRF_RETURN_DONE(funcctx); + + + } diff -Ncar pgsql.orig/contrib/pg_freespacemap/pg_freespacemap.sql.in pgsql/contrib/pg_freespacemap/pg_freespacemap.sql.in *** pgsql.orig/contrib/pg_freespacemap/pg_freespacemap.sql.in Thu Jan 1 12:00:00 1970 --- pgsql/contrib/pg_freespacemap/pg_freespacemap.sql.in Fri Apr 28 18:23:10 2006 *************** *** 0 **** --- 1,35 ---- + -- Adjust this setting to control where the objects get created. + BEGIN; + SET search_path = public; + + + -- Register the functions. + CREATE OR REPLACE FUNCTION pg_freespacemap_pages() + RETURNS SETOF RECORD + AS 'MODULE_PATHNAME', 'pg_freespacemap_pages' + LANGUAGE C; + + CREATE OR REPLACE FUNCTION pg_freespacemap_relations() + RETURNS SETOF RECORD + AS 'MODULE_PATHNAME', 'pg_freespacemap_relations' + LANGUAGE C; + + + -- Create views for convenient access. + CREATE VIEW pg_freespacemap_pages AS + SELECT P.* FROM pg_freespacemap_pages() AS P + (reltablespace oid, reldatabase oid, relfilenode oid, relblocknumber int8, bytes int4); + + CREATE VIEW pg_freespacemap_relations AS + SELECT P.* FROM pg_freespacemap_relations() AS P + (reltablespace oid, reldatabase oid, relfilenode oid, avgrequest int8, lastpagecount integer, nextpage integer); + + + -- Don't want these to be available at public. + REVOKE ALL ON FUNCTION pg_freespacemap_pages() FROM PUBLIC; + REVOKE ALL ON pg_freespacemap_pages FROM PUBLIC; + + REVOKE ALL ON FUNCTION pg_freespacemap_relations() FROM PUBLIC; + REVOKE ALL ON pg_freespacemap_relations FROM PUBLIC; + + COMMIT; diff -Ncar pgsql.orig/src/backend/storage/freespace/freespace.c pgsql/src/backend/storage/freespace/freespace.c *** pgsql.orig/src/backend/storage/freespace/freespace.c Thu Oct 20 12:25:06 2005 --- pgsql/src/backend/storage/freespace/freespace.c Thu Oct 27 17:51:33 2005 *************** *** 71,114 **** #include "storage/shmem.h" - /* Initial value for average-request moving average */ - #define INITIAL_AVERAGE ((Size) (BLCKSZ / 32)) - - /* - * Number of pages and bytes per allocation chunk. Indexes can squeeze 50% - * more pages into the same space because they don't need to remember how much - * free space on each page. The nominal number of pages, CHUNKPAGES, is for - * regular rels, and INDEXCHUNKPAGES is for indexes. CHUNKPAGES should be - * even so that no space is wasted in the index case. - */ - #define CHUNKPAGES 16 - #define CHUNKBYTES (CHUNKPAGES * sizeof(FSMPageData)) - #define INDEXCHUNKPAGES ((int) (CHUNKBYTES / sizeof(IndexFSMPageData))) - - - /* - * Typedefs and macros for items in the page-storage arena. We use the - * existing ItemPointer and BlockId data structures, which are designed - * to pack well (they should be 6 and 4 bytes apiece regardless of machine - * alignment issues). Unfortunately we can't use the ItemPointer access - * macros, because they include Asserts insisting that ip_posid != 0. - */ - typedef ItemPointerData FSMPageData; - typedef BlockIdData IndexFSMPageData; - - #define FSMPageGetPageNum(ptr) \ - BlockIdGetBlockNumber(&(ptr)->ip_blkid) - #define FSMPageGetSpace(ptr) \ - ((Size) (ptr)->ip_posid) - #define FSMPageSetPageNum(ptr, pg) \ - BlockIdSet(&(ptr)->ip_blkid, pg) - #define FSMPageSetSpace(ptr, sz) \ - ((ptr)->ip_posid = (OffsetNumber) (sz)) - #define IndexFSMPageGetPageNum(ptr) \ - BlockIdGetBlockNumber(ptr) - #define IndexFSMPageSetPageNum(ptr, pg) \ - BlockIdSet(ptr, pg) - /*---------- * During database shutdown, we store the contents of FSM into a disk file, * which is re-read during startup. This way we don't have a startup --- 71,76 ---- *************** *** 156,218 **** int32 storedPages; /* # of pages stored in arena */ } FsmCacheRelHeader; - - /* - * Shared free-space-map objects - * - * The per-relation objects are indexed by a hash table, and are also members - * of two linked lists: one ordered by recency of usage (most recent first), - * and the other ordered by physical location of the associated storage in - * the page-info arena. - * - * Each relation owns one or more chunks of per-page storage in the "arena". - * The chunks for each relation are always consecutive, so that it can treat - * its page storage as a simple array. We further insist that its page data - * be ordered by block number, so that binary search is possible. - * - * Note: we handle pointers to these items as pointers, not as SHMEM_OFFSETs. - * This assumes that all processes accessing the map will have the shared - * memory segment mapped at the same place in their address space. - */ - typedef struct FSMHeader FSMHeader; - typedef struct FSMRelation FSMRelation; - - /* Header for whole map */ - struct FSMHeader - { - FSMRelation *usageList; /* FSMRelations in usage-recency order */ - FSMRelation *usageListTail; /* tail of usage-recency list */ - FSMRelation *firstRel; /* FSMRelations in arena storage order */ - FSMRelation *lastRel; /* tail of storage-order list */ - int numRels; /* number of FSMRelations now in use */ - double sumRequests; /* sum of requested chunks over all rels */ - char *arena; /* arena for page-info storage */ - int totalChunks; /* total size of arena, in chunks */ - int usedChunks; /* # of chunks assigned */ - /* NB: there are totalChunks - usedChunks free chunks at end of arena */ - }; - - /* - * Per-relation struct --- this is an entry in the shared hash table. - * The hash key is the RelFileNode value (hence, we look at the physical - * relation ID, not the logical ID, which is appropriate). - */ - struct FSMRelation - { - RelFileNode key; /* hash key (must be first) */ - FSMRelation *nextUsage; /* next rel in usage-recency order */ - FSMRelation *priorUsage; /* prior rel in usage-recency order */ - FSMRelation *nextPhysical; /* next rel in arena-storage order */ - FSMRelation *priorPhysical; /* prior rel in arena-storage order */ - bool isIndex; /* if true, we store only page numbers */ - Size avgRequest; /* moving average of space requests */ - int lastPageCount; /* pages passed to RecordRelationFreeSpace */ - int firstChunk; /* chunk # of my first chunk in arena */ - int storedPages; /* # of pages stored in arena */ - int nextPage; /* index (from 0) to start next search at */ - }; - - int MaxFSMRelations; /* these are set by guc.c */ int MaxFSMPages; --- 118,123 ---- *************** *** 1835,1840 **** --- 1740,1756 ---- Assert(fsmrel->firstChunk < 0 && fsmrel->storedPages == 0); return 0; } + } + + + /* + * Return the FreeSpaceMap structure for examination. + */ + FSMHeader * + GetFreeSpaceMap(void) + { + + return FreeSpaceMap; } diff -Ncar pgsql.orig/src/include/storage/freespace.h pgsql/src/include/storage/freespace.h *** pgsql.orig/src/include/storage/freespace.h Tue Aug 23 15:56:23 2005 --- pgsql/src/include/storage/freespace.h Thu Oct 27 17:51:33 2005 *************** *** 16,21 **** --- 16,22 ---- #include "storage/block.h" #include "storage/relfilenode.h" + #include "storage/itemptr.h" /* *************** *** 28,33 **** --- 29,129 ---- } PageFreeSpaceInfo; + /* Initial value for average-request moving average */ + #define INITIAL_AVERAGE ((Size) (BLCKSZ / 32)) + + /* + * Number of pages and bytes per allocation chunk. Indexes can squeeze 50% + * more pages into the same space because they don't need to remember how much + * free space on each page. The nominal number of pages, CHUNKPAGES, is for + * regular rels, and INDEXCHUNKPAGES is for indexes. CHUNKPAGES should be + * even so that no space is wasted in the index case. + */ + #define CHUNKPAGES 16 + #define CHUNKBYTES (CHUNKPAGES * sizeof(FSMPageData)) + #define INDEXCHUNKPAGES ((int) (CHUNKBYTES / sizeof(IndexFSMPageData))) + + + /* + * Typedefs and macros for items in the page-storage arena. We use the + * existing ItemPointer and BlockId data structures, which are designed + * to pack well (they should be 6 and 4 bytes apiece regardless of machine + * alignment issues). Unfortunately we can't use the ItemPointer access + * macros, because they include Asserts insisting that ip_posid != 0. + */ + typedef ItemPointerData FSMPageData; + typedef BlockIdData IndexFSMPageData; + + #define FSMPageGetPageNum(ptr) \ + BlockIdGetBlockNumber(&(ptr)->ip_blkid) + #define FSMPageGetSpace(ptr) \ + ((Size) (ptr)->ip_posid) + #define FSMPageSetPageNum(ptr, pg) \ + BlockIdSet(&(ptr)->ip_blkid, pg) + #define FSMPageSetSpace(ptr, sz) \ + ((ptr)->ip_posid = (OffsetNumber) (sz)) + #define IndexFSMPageGetPageNum(ptr) \ + BlockIdGetBlockNumber(ptr) + #define IndexFSMPageSetPageNum(ptr, pg) \ + BlockIdSet(ptr, pg) + + /* + * Shared free-space-map objects + * + * The per-relation objects are indexed by a hash table, and are also members + * of two linked lists: one ordered by recency of usage (most recent first), + * and the other ordered by physical location of the associated storage in + * the page-info arena. + * + * Each relation owns one or more chunks of per-page storage in the "arena". + * The chunks for each relation are always consecutive, so that it can treat + * its page storage as a simple array. We further insist that its page data + * be ordered by block number, so that binary search is possible. + * + * Note: we handle pointers to these items as pointers, not as SHMEM_OFFSETs. + * This assumes that all processes accessing the map will have the shared + * memory segment mapped at the same place in their address space. + */ + typedef struct FSMHeader FSMHeader; + typedef struct FSMRelation FSMRelation; + + /* Header for whole map */ + struct FSMHeader + { + FSMRelation *usageList; /* FSMRelations in usage-recency order */ + FSMRelation *usageListTail; /* tail of usage-recency list */ + FSMRelation *firstRel; /* FSMRelations in arena storage order */ + FSMRelation *lastRel; /* tail of storage-order list */ + int numRels; /* number of FSMRelations now in use */ + double sumRequests; /* sum of requested chunks over all rels */ + char *arena; /* arena for page-info storage */ + int totalChunks; /* total size of arena, in chunks */ + int usedChunks; /* # of chunks assigned */ + /* NB: there are totalChunks - usedChunks free chunks at end of arena */ + }; + + /* + * Per-relation struct --- this is an entry in the shared hash table. + * The hash key is the RelFileNode value (hence, we look at the physical + * relation ID, not the logical ID, which is appropriate). + */ + struct FSMRelation + { + RelFileNode key; /* hash key (must be first) */ + FSMRelation *nextUsage; /* next rel in usage-recency order */ + FSMRelation *priorUsage; /* prior rel in usage-recency order */ + FSMRelation *nextPhysical; /* next rel in arena-storage order */ + FSMRelation *priorPhysical; /* prior rel in arena-storage order */ + bool isIndex; /* if true, we store only page numbers */ + Size avgRequest; /* moving average of space requests */ + int lastPageCount; /* pages passed to RecordRelationFreeSpace */ + int firstChunk; /* chunk # of my first chunk in arena */ + int storedPages; /* # of pages stored in arena */ + int nextPage; /* index (from 0) to start next search at */ + }; + + + /* GUC variables */ extern int MaxFSMRelations; extern int MaxFSMPages; *************** *** 62,67 **** --- 158,164 ---- extern void DumpFreeSpaceMap(int code, Datum arg); extern void LoadFreeSpaceMap(void); + extern FSMHeader *GetFreeSpaceMap(void); #ifdef FREESPACE_DEBUG extern void DumpFreeSpace(void);