Want to host it on pgfoundry until 8.2 is released?

Mark Kirkwood wrote:
This patch implements a view to display the free space map contents - e.g :

    regression=# SELECT c.relname, m.relblocknumber, m.blockfreebytes
                 FROM pg_freespacemap m INNER JOIN pg_class c
                 ON c.relfilenode = m.relfilenode LIMIT 10;
        relname             | relblocknumber | blockfreebytes
    ------------------------+----------------+----------------
    sql_features            |              5 |           2696
    sql_implementation_info |              0 |           7104
    sql_languages           |              0 |           8016
    sql_packages            |              0 |           7376
    sql_sizing              |              0 |           6032
    pg_authid               |              0 |           7424
    pg_toast_2618           |             13 |           4588
    pg_toast_2618           |             12 |           1680
    pg_toast_2618           |             10 |           1436
    pg_toast_2618           |              7 |           1136
    (10 rows)

[I found being able to display the FSM pretty cool, even if I say so
myself....].

It is written as a contrib module (similar to pg_buffercache) so as to
make any revisions non-initdb requiring.

The code needs to know about several of the (currently) internal data
structures in freespace.c, so I moved these into freespace.h. Similarly
for the handy macros to actually compute the free space. Let me know if this was the wrong way to proceed!

Additionally access to the FSM pointer itself is required, I added a
function in freespace.c to return this, rather than making it globally
visible, again if the latter is a better approach, it is easily changed.

cheers

Mark

P.s : Currently don't have access to a windows box, so had to just 'take a stab' at what DLLIMPORTs were required.



------------------------------------------------------------------------

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      Thu Oct 27 17:52:10 2005
***************
*** 0 ****
--- 1,17 ----
+ # $PostgreSQL$
+ + 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        Thu Oct 27 
18:06:20 2005
***************
*** 0 ****
--- 1,98 ----
+ Pg_freespacemap - Real time queries on the free space map (FSM).
+ ---------------
+ + This module consists of a C function 'pg_freespacemap()' that returns + a set of records, and a view 'pg_freespacemap' to wrapper the function. + + 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 both of these, just in case there
+   are security issues lurking.
+ + + Installation
+ ------------
+ + Build and install the main Postgresql source, then this contrib module: + + $ cd contrib/pg_freespacemap
+   $ gmake
+   $ gmake install
+ + + To register the functions: + + $ psql -d <database> -f pg_freespacemap.sql + + + Notes
+ -----
+ + The definition of the columns exposed in the view is: + + Column | references | Description
+   ----------------+----------------------+------------------------------------
+    blockid        |                      | Id, 1.. max_fsm_pages
+    relfilenode    | pg_class.relfilenode | Refilenode of the relation.
+    reltablespace  | pg_tablespace.oid    | Tablespace oid of the relation.
+    reldatabase    | pg_database.oid      | Database for the relation.
+    relblocknumber |                      | Offset of the page in the relation.
+    blockfreebytes |                      | Free bytes in the block/page.
+ + + There is one row for each page in the free space map. + + Because the map is shared by all the databases, there are pages from
+   relations not belonging to the current database.
+ + When the pg_freespacemap view is accessed, internal free space map locks are + taken, and a copy of the map data is made for the view to display. + This ensures that the view produces a consistent set of results, while not + blocking normal activity longer than necessary. Nonetheless there + could be some impact on database performance if this view is read often. + + + Sample output
+ -------------
+ + regression=# \d pg_freespacemap
+       View "public.pg_freespacemap"
+ Column | Type | Modifiers + ---------------+---------+----------- + blockid | integer | + relfilenode | oid | + reltablespace | oid | + reldatabase | oid | + relblocknumber | bigint | + blockfreebytes | integer | + View definition:
+   SELECT p.blockid, p.relfilenode, p.reltablespace, p.reldatabase, 
p.relblocknumber, p.blockfreebytes
+     FROM pg_freespacemap() p(blockid integer, relfilenode oid, reltablespace 
oid, reldatabase oid, relblocknumber bigint, blockfreebytes integer);
+ + regression=# SELECT c.relname, m.relblocknumber, m.blockfreebytes + FROM pg_freespacemap m INNER JOIN pg_class c + ON c.relfilenode = m.relfilenode LIMIT 10; + relname | relblocknumber | blockfreebytes + ------------------------+----------------+----------------
+   sql_features            |              5 |           2696
+   sql_implementation_info |              0 |           7104
+   sql_languages           |              0 |           8016
+   sql_packages            |              0 |           7376
+   sql_sizing              |              0 |           6032
+   pg_authid               |              0 |           7424
+   pg_toast_2618           |             13 |           4588
+   pg_toast_2618           |             12 |           1680
+   pg_toast_2618           |             10 |           1436
+   pg_toast_2618           |              7 |           1136
+   (10 rows)
+ + regression=# + + + Author
+ ------
+ + * Mark Kirkwood <[EMAIL PROTECTED]> + 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     Thu Oct 27 18:07:05 2005
***************
*** 0 ****
--- 1,231 ----
+ /*-------------------------------------------------------------------------
+  *
+  * pg_freespacemap.c
+  *      display some contents of the free space map.
+  *
+  *      $PostgreSQL$
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ #include "funcapi.h"
+ #include "catalog/pg_type.h"
+ #include "storage/freespace.h"
+ #include "utils/relcache.h"
+ + #define NUM_FREESPACE_PAGES_ELEM 6 + + #if defined(WIN32) || defined(__CYGWIN__)
+ extern DLLIMPORT volatile uint32 InterruptHoldoffCount;
+ #endif
+ + Datum pg_freespacemap(PG_FUNCTION_ARGS); + + + /*
+  * Record structure holding the to be exposed free space data.
+  */
+ typedef struct
+ {
+ + uint32 blockid;
+       uint32                          relfilenode;
+       uint32                          reltablespace;
+       uint32                          reldatabase;
+       uint32                          relblocknumber;
+       uint32                          blockfreebytes;
+ + } FreeSpacePagesRec; + + + /*
+  * Function context for data persisting over repeated calls.
+  */
+ typedef struct
+ {
+ + AttInMetadata *attinmeta;
+       FreeSpacePagesRec       *record;
+       char                            *values[NUM_FREESPACE_PAGES_ELEM];
+ + } FreeSpacePagesContext; + + + /*
+  * Function returning data from the Free Space Map (FSM).
+  */
+ PG_FUNCTION_INFO_V1(pg_freespacemap);
+ Datum
+ pg_freespacemap(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, "blockid",
+                                                  INT4OID, -1, 0);
+               TupleDescInitEntry(tupledesc, (AttrNumber) 2, "relfilenode",
+                                                  OIDOID, -1, 0);
+               TupleDescInitEntry(tupledesc, (AttrNumber) 3, "reltablespace",
+                                                  OIDOID, -1, 0);
+               TupleDescInitEntry(tupledesc, (AttrNumber) 4, "reldatabase",
+                                                  OIDOID, -1, 0);
+               TupleDescInitEntry(tupledesc, (AttrNumber) 5, "relblocknumber",
+                                                  INT8OID, -1, 0);
+               TupleDescInitEntry(tupledesc, (AttrNumber) 6, "blockfreebytes",
+                                                  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);
+               fctx->values[5] = (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].blockid = i;
+                                       fctx->record[i].relfilenode = 
fsmrel->key.relNode;
+                                       fctx->record[i].reltablespace = 
fsmrel->key.spcNode;
+                                       fctx->record[i].reldatabase = 
fsmrel->key.dbNode;
+                                       fctx->record[i].relblocknumber = 
IndexFSMPageGetPageNum(page);       
+                                       fctx->record[i].blockfreebytes = 0;  /* 
index.*/
+ + page++;
+                                       i++;
+                               }
+                       }
+                       else
+                       {       /* Heap relation. */
+                               FSMPageData *page;
+ + page = (FSMPageData *)
+                                               (FreeSpaceMap->arena + 
fsmrel->firstChunk * CHUNKBYTES);
+ + for (nPages = 0; nPages < fsmrel->storedPages; nPages++)
+                               {
+                                       fctx->record[i].blockid = i;
+                                       fctx->record[i].relfilenode = 
fsmrel->key.relNode;
+                                       fctx->record[i].reltablespace = 
fsmrel->key.spcNode;
+                                       fctx->record[i].reldatabase = 
fsmrel->key.dbNode;
+                                       fctx->record[i].relblocknumber = 
FSMPageGetPageNum(page);
+                                       fctx->record[i].blockfreebytes = 
FSMPageGetSpace(page);      
+                                       
+                                       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;
+ + + sprintf(fctx->values[0], "%u", fctx->record[i].blockid);
+               sprintf(fctx->values[1], "%u", fctx->record[i].relfilenode);
+               sprintf(fctx->values[2], "%u", fctx->record[i].reltablespace);
+               sprintf(fctx->values[3], "%u", fctx->record[i].reldatabase);
+               sprintf(fctx->values[4], "%u", fctx->record[i].relblocknumber);
+               sprintf(fctx->values[5], "%u", fctx->record[i].blockfreebytes);
+ + + + /* Build and return the tuple. */
+               tuple = BuildTupleFromCStrings(funcctx->attinmeta, 
fctx->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        Thu Oct 27 
18:07:43 2005
***************
*** 0 ****
--- 1,17 ----
+ -- Adjust this setting to control where the objects get created.
+ SET search_path = public;
+ + -- Register the function.
+ CREATE OR REPLACE FUNCTION pg_freespacemap()
+ RETURNS SETOF RECORD
+ AS 'MODULE_PATHNAME', 'pg_freespacemap'
+ LANGUAGE 'C';
+ + -- Create a view for convenient access.
+ CREATE VIEW pg_freespacemap AS
+       SELECT P.* FROM pg_freespacemap() AS P
+       (blockid int4, relfilenode oid, reltablespace oid, reldatabase oid, 
relblocknumber int8, blockfreebytes int4);
+ + -- Don't want these to be available at public.
+ REVOKE ALL ON FUNCTION pg_freespacemap() FROM PUBLIC;
+ REVOKE ALL ON pg_freespacemap FROM PUBLIC;
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);



------------------------------------------------------------------------


---------------------------(end of broadcast)---------------------------
TIP 1: if posting/reading through Usenet, please send an appropriate
       subscribe-nomail command to [EMAIL PROTECTED] so that your
       message can get through to the mailing list cleanly


---------------------------(end of broadcast)---------------------------
TIP 9: In versions below 8.0, the planner will ignore your desire to
      choose an index scan if your joining column's datatypes do not
      match

Reply via email to