#
# pageinspect Makefile
#
-# $PostgreSQL: pgsql/contrib/pageinspect/Makefile,v 1.3 2007/11/10 23:59:51 momjian Exp $
+# $PostgreSQL: pgsql/contrib/pageinspect/Makefile,v 1.4 2008/09/30 10:52:09 heikki Exp $
#
#-------------------------------------------------------------------------
MODULE_big = pageinspect
-OBJS = rawpage.o heapfuncs.o btreefuncs.o
+OBJS = rawpage.o heapfuncs.o btreefuncs.o fsmfuncs.o
DATA_built = pageinspect.sql
DATA = uninstall_pageinspect.sql
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fsmfuncs.c
+ * Functions to investigate FSM pages
+ *
+ * These functions are restricted to superusers for the fear of introducing
+ * security holes if the input checking isn't as water-tight as it should.
+ * You'd need to be superuser to obtain a raw page image anyway, so
+ * there's hardly any use case for using these without superuser-rights
+ * anyway.
+ *
+ * Copyright (c) 2007-2008, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ * $PostgreSQL: pgsql/contrib/pageinspect/fsmfuncs.c,v 1.1 2008/09/30 10:52:09 heikki Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+#include "lib/stringinfo.h"
+#include "storage/fsm_internals.h"
+#include "utils/builtins.h"
+#include "miscadmin.h"
+#include "funcapi.h"
+
+Datum fsm_page_contents(PG_FUNCTION_ARGS);
+
+/*
+ * Dumps the contents of a FSM page.
+ */
+PG_FUNCTION_INFO_V1(fsm_page_contents);
+
+Datum
+fsm_page_contents(PG_FUNCTION_ARGS)
+{
+ bytea *raw_page = PG_GETARG_BYTEA_P(0);
+ int raw_page_size;
+ StringInfoData sinfo;
+ FSMPage fsmpage;
+ int i;
+
+ if (!superuser())
+ ereport(ERROR,
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ (errmsg("must be superuser to use raw page functions"))));
+
+ raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
+ fsmpage = (FSMPage) PageGetContents(VARDATA(raw_page));
+
+ initStringInfo(&sinfo);
+
+ for(i=0; i < NodesPerPage; i++)
+ {
+ if (fsmpage->fp_nodes[i] != 0)
+ appendStringInfo(&sinfo, "%d: %d\n", i, fsmpage->fp_nodes[i]);
+ }
+ appendStringInfo(&sinfo, "fp_next_slot: %d\n", fsmpage->fp_next_slot);
+
+ PG_RETURN_TEXT_P(cstring_to_text(sinfo.data));
+}
-/* $PostgreSQL: pgsql/contrib/pageinspect/pageinspect.sql.in,v 1.4 2007/11/13 04:24:28 momjian Exp $ */
+/* $PostgreSQL: pgsql/contrib/pageinspect/pageinspect.sql.in,v 1.5 2008/09/30 10:52:09 heikki Exp $ */
-- Adjust this setting to control where the objects get created.
SET search_path = public;
--
-- get_raw_page()
--
-CREATE OR REPLACE FUNCTION get_raw_page(text, int4)
+CREATE OR REPLACE FUNCTION get_raw_page(text, int4, int4)
RETURNS bytea
AS 'MODULE_PATHNAME', 'get_raw_page'
LANGUAGE C STRICT;
+CREATE OR REPLACE FUNCTION get_raw_page(text, int4)
+RETURNS bytea
+AS $$ SELECT get_raw_page($1, 0, $2); $$
+LANGUAGE SQL STRICT;
+
--
-- page_header()
--
RETURNS SETOF record
AS 'MODULE_PATHNAME', 'bt_page_items'
LANGUAGE C STRICT;
+
+--
+-- fsm_page_contents()
+--
+CREATE OR REPLACE FUNCTION fsm_page_contents(IN page bytea)
+RETURNS text
+AS 'MODULE_PATHNAME', 'fsm_page_contents'
+LANGUAGE C STRICT;
* Copyright (c) 2007-2008, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/contrib/pageinspect/rawpage.c,v 1.6 2008/05/12 00:00:43 alvherre Exp $
+ * $PostgreSQL: pgsql/contrib/pageinspect/rawpage.c,v 1.7 2008/09/30 10:52:09 heikki Exp $
*
*-------------------------------------------------------------------------
*/
get_raw_page(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
- uint32 blkno = PG_GETARG_UINT32(1);
+ uint32 forknum = PG_GETARG_UINT32(1);
+ uint32 blkno = PG_GETARG_UINT32(2);
Relation rel;
RangeVar *relrv;
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use raw functions"))));
+ if (forknum > MAX_FORKNUM)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("invalid fork number")));
+
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
/* Take a verbatim copy of the page */
- buf = ReadBuffer(rel, blkno);
+ buf = ReadBufferWithFork(rel, forknum, blkno);
LockBuffer(buf, BUFFER_LOCK_SHARE);
memcpy(raw_page_data, BufferGetPage(buf), BLCKSZ);
-/* $PostgreSQL: pgsql/contrib/pg_freespacemap/pg_freespacemap.sql.in,v 1.8 2007/11/13 04:24:28 momjian Exp $ */
+/* $PostgreSQL: pgsql/contrib/pg_freespacemap/pg_freespacemap.sql.in,v 1.9 2008/09/30 10:52:09 heikki Exp $ */
-- Adjust this setting to control where the objects get created.
SET search_path = public;
--- Register the functions.
-CREATE OR REPLACE FUNCTION pg_freespacemap_pages()
-RETURNS SETOF RECORD
-AS 'MODULE_PATHNAME', 'pg_freespacemap_pages'
+-- Register the C function.
+CREATE OR REPLACE FUNCTION pg_freespace(regclass, int4)
+RETURNS int2
+AS 'MODULE_PATHNAME', 'pg_freespace'
LANGUAGE C;
-CREATE OR REPLACE FUNCTION pg_freespacemap_relations()
+-- pg_freespace shows the recorded space avail at each block in a relation
+CREATE OR REPLACE FUNCTION
+ pg_freespace(rel regclass, blkno OUT int4, avail OUT int2)
RETURNS SETOF RECORD
-AS 'MODULE_PATHNAME', 'pg_freespacemap_relations'
-LANGUAGE C;
+AS $$
+ SELECT blkno::int4, pg_freespace($1, blkno::int4) AS avail
+ FROM generate_series(0, pg_relation_size($1) / current_setting('block_size')::bigint - 1) AS blkno;
+$$
+LANGUAGE SQL;
--- 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 bigint,
- bytes integer);
-
-CREATE VIEW pg_freespacemap_relations AS
- SELECT P.* FROM pg_freespacemap_relations() AS P
- (reltablespace oid,
- reldatabase oid,
- relfilenode oid,
- avgrequest integer,
- interestingpages integer,
- storedpages integer,
- nextpage integer);
-
-
-- Don't want these to be available to 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;
+REVOKE ALL ON FUNCTION pg_freespace(regclass, int4) FROM PUBLIC;
+REVOKE ALL ON FUNCTION pg_freespace(regclass) FROM PUBLIC;
-<!-- $PostgreSQL: pgsql/doc/src/sgml/acronyms.sgml,v 1.5 2008/03/18 16:05:07 mha Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/acronyms.sgml,v 1.6 2008/09/30 10:52:09 heikki Exp $ -->
<appendix id="acronyms">
<title>Acronyms</title>
<term><acronym>FSM</acronym></term>
<listitem>
<para>
- <link linkend="runtime-config-resource-fsm">Free Space Map</link>
+ <link linkend="storage-fsm">Free Space Map</link>
</para>
</listitem>
</varlistentry>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/config.sgml,v 1.190 2008/08/25 19:03:37 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/config.sgml,v 1.191 2008/09/30 10:52:09 heikki Exp $ -->
<chapter Id="runtime-config">
<title>Server Configuration</title>
</varlistentry>
</variablelist>
- </sect2>
- <sect2 id="runtime-config-resource-fsm">
- <title>Free Space Map</title>
-
- <indexterm>
- <primary>free space map</primary>
- </indexterm>
-
- <para>
- These parameters control the size of the shared <firstterm>free space
- map</> (<acronym>FSM</>), which tracks the locations of unused space in the database.
- An undersized free space map can cause the database to consume
- increasing amounts of disk space over time, because free space that
- is not in the map cannot be re-used; instead <productname>PostgreSQL</>
- will request more disk space from the operating system when it needs
- to store new data.
- The last few lines displayed by a database-wide <command>VACUUM VERBOSE</>
- command can help in determining if the current settings are adequate.
- A <literal>NOTICE</> message is also printed during such an operation
- if the current settings are too low.
- </para>
-
- <para>
- Increasing these parameters might cause <productname>PostgreSQL</>
- to request more <systemitem class="osname">System V</> shared
- memory than your operating system's default configuration
- allows. See <xref linkend="sysvipc"> for information on how to
- adjust those parameters, if necessary.
- </para>
-
- <variablelist>
- <varlistentry id="guc-max-fsm-pages" xreflabel="max_fsm_pages">
- <term><varname>max_fsm_pages</varname> (<type>integer</type>)</term>
- <indexterm>
- <primary><varname>max_fsm_pages</> configuration parameter</primary>
- </indexterm>
- <listitem>
- <para>
- Sets the maximum number of disk pages for which free space will
- be tracked in the shared free-space map. Six bytes of shared memory
- are consumed for each page slot. This setting must be at least
- 16 * <varname>max_fsm_relations</varname>. The default is chosen
- by <application>initdb</> depending on the amount of available memory,
- and can range from 20k to 200k pages.
- This parameter can only be set at server start.
- </para>
- </listitem>
- </varlistentry>
-
- <varlistentry id="guc-max-fsm-relations" xreflabel="max_fsm_relations">
- <term><varname>max_fsm_relations</varname> (<type>integer</type>)</term>
- <indexterm>
- <primary><varname>max_fsm_relations</> configuration parameter</primary>
- </indexterm>
- <listitem>
- <para>
- Sets the maximum number of relations (tables and indexes) for which
- free space will be tracked in the shared free-space map. Roughly
- seventy bytes of shared memory are consumed for each slot.
- The default is one thousand relations.
- This parameter can only be set at server start.
- </para>
- </listitem>
- </varlistentry>
-
- </variablelist>
-
- <note>
- <para>
- See the <xref linkend="sql-vacuum" endterm="sql-vacuum-title">
- command for information on setting this parameter.
- </para>
- </note>
-
</sect2>
<sect2 id="runtime-config-resource-kernel">
-<!-- $PostgreSQL: pgsql/doc/src/sgml/pageinspect.sgml,v 1.3 2007/12/10 05:32:51 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/pageinspect.sgml,v 1.4 2008/09/30 10:52:09 heikki Exp $ -->
<sect1 id="pageinspect">
<title>pageinspect</title>
<variablelist>
<varlistentry>
<term>
- <function>get_raw_page(text, int) returns bytea</function>
+ <function>get_raw_page(relname text, forknum int, blkno int) returns bytea</function>
</term>
<listitem>
<function>get_raw_page</function> reads the specified block of the named
table and returns a copy as a <type>bytea</> value. This allows a
single time-consistent copy of the block to be obtained.
+ <literal>forknum</literal> should be 0 for the main data fork, or 1 for
+ the FSM.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
- <function>page_header(bytea) returns record</function>
+ <function>get_raw_page(relname text, blkno int) returns bytea</function>
+ </term>
+
+ <listitem>
+ <para>
+ A shorthand of above, for reading from the main fork. Equal to
+ <literal>get_raw_page(relname, 0, blkno)</literal>
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <function>page_header(page bytea) returns record</function>
</term>
<listitem>
<varlistentry>
<term>
- <function>heap_page_items(bytea) returns setof record</function>
+ <function>heap_page_items(page bytea) returns setof record</function>
</term>
<listitem>
<varlistentry>
<term>
- <function>bt_metap(text) returns record</function>
+ <function>bt_metap(relname text) returns record</function>
</term>
<listitem>
<varlistentry>
<term>
- <function>bt_page_stats(text, int) returns record</function>
+ <function>bt_page_stats(relname text, blkno int) returns record</function>
</term>
<listitem>
<varlistentry>
<term>
- <function>bt_page_items(text, int) returns setof record</function>
+ <function>bt_page_items(relname text, blkno int) returns setof record</function>
</term>
<listitem>
</programlisting>
</listitem>
</varlistentry>
+
+ <varlistentry>
+ <term>
+ <function>fsm_page_contents(page bytea) returns text</function>
+ </term>
+
+ <listitem>
+ <para>
+ <function>fsm_page_contents</function> shows the internal node structure
+ of a FSM page. The output is a multi-line string, with one line per
+ node in the binary tree within the page. Only those nodes that are not
+ zero are printed. The so-called "next" pointer, which points to the
+ next slot to be returned from the page, is also printed.
+ </para>
+ <para>
+ See <filename>src/backend/storage/freespace/README</> for more
+ information on the structure of an FSM page.
+ </para>
+ </listitem>
+ </varlistentry>
</variablelist>
</sect2>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/pgfreespacemap.sgml,v 2.2 2007/12/10 05:32:51 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/pgfreespacemap.sgml,v 2.3 2008/09/30 10:52:09 heikki Exp $ -->
<sect1 id="pgfreespacemap">
<title>pg_freespacemap</title>
<para>
The <filename>pg_freespacemap</> module provides a means for examining the
- free space map (FSM). It provides two C functions:
- <function>pg_freespacemap_relations</function> and
- <function>pg_freespacemap_pages</function> that each return a set of
- records, plus two views <structname>pg_freespacemap_relations</structname>
- and <structname>pg_freespacemap_pages</structname> that wrap the functions
- for convenient use.
+ free space map (FSM). It provides a function called
+ <function>pg_freespacemap</function>, or two overloaded functions, to be
+ precise. The functions show the value recorded in the free space map for
+ a given page, or for all pages in the relation.
</para>
<para>
- By default public access is revoked from the functions and views, just in
- case there are security issues lurking.
+ By default public access is revoked from the functions, just in case
+ there are security issues lurking.
</para>
<sect2>
- <title>The <filename>pg_freespacemap</> views</title>
+ <title>Functions</title>
+
+ <variablelist>
+ <varlistentry>
+ <term>
+ <function>pg_freespacemap(rel regclass IN, blkno bigint IN) returns int2</function>
+ </term>
+
+ <listitem>
+ <para>
+ Returns the amount of free space on the page of the relation, specified
+ by <literal>blkno</>, according to the FSM.
+ (blkno).
+ </para>
+ </listitem>
+ </varlistentry>
+
+
+ <varlistentry>
+ <term>
+ <function>pg_freespacemap(rel regclass IN, blkno OUT int4, avail OUT int2)</function>
+ </term>
+
+ <listitem>
+ <para>
+ Displays the the amount of free space on each page of the relation,
+ according to the FSM. A set of <literal>(blkno int4, avail int2)</>
+ tuples is returned, one tuple for each page in the relation.
+ </para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
<para>
- The definitions of the columns exposed by the views are:
- </para>
-
- <table>
- <title><structname>pg_freespacemap_relations</> Columns</title>
-
- <tgroup cols="4">
- <thead>
- <row>
- <entry>Name</entry>
- <entry>Type</entry>
- <entry>References</entry>
- <entry>Description</entry>
- </row>
- </thead>
- <tbody>
-
- <row>
- <entry><structfield>reltablespace</structfield></entry>
- <entry><type>oid</type></entry>
- <entry><literal>pg_tablespace.oid</literal></entry>
- <entry>Tablespace OID of the relation</entry>
- </row>
- <row>
- <entry><structfield>reldatabase</structfield></entry>
- <entry><type>oid</type></entry>
- <entry><literal>pg_database.oid</literal></entry>
- <entry>Database OID of the relation</entry>
- </row>
- <row>
- <entry><structfield>relfilenode</structfield></entry>
- <entry><type>oid</type></entry>
- <entry><literal>pg_class.relfilenode</literal></entry>
- <entry>Relfilenode of the relation</entry>
- </row>
- <row>
- <entry><structfield>avgrequest</structfield></entry>
- <entry><type>integer</type></entry>
- <entry></entry>
- <entry>Moving average of free space requests (NULL for indexes)</entry>
- </row>
- <row>
- <entry><structfield>interestingpages</structfield></entry>
- <entry><type>integer</type></entry>
- <entry></entry>
- <entry>Count of pages last reported as containing useful free space</entry>
- </row>
- <row>
- <entry><structfield>storedpages</structfield></entry>
- <entry><type>integer</type></entry>
- <entry></entry>
- <entry>Count of pages actually stored in free space map</entry>
- </row>
- <row>
- <entry><structfield>nextpage</structfield></entry>
- <entry><type>integer</type></entry>
- <entry></entry>
- <entry>Page index (from 0) to start next search at</entry>
- </row>
-
- </tbody>
- </tgroup>
- </table>
-
- <table>
- <title><structname>pg_freespacemap_pages</> Columns</title>
-
- <tgroup cols="4">
- <thead>
- <row>
- <entry>Name</entry>
- <entry>Type</entry>
- <entry>References</entry>
- <entry>Description</entry>
- </row>
- </thead>
- <tbody>
-
- <row>
- <entry><structfield>reltablespace</structfield></entry>
- <entry><type>oid</type></entry>
- <entry><literal>pg_tablespace.oid</literal></entry>
- <entry>Tablespace OID of the relation</entry>
- </row>
- <row>
- <entry><structfield>reldatabase</structfield></entry>
- <entry><type>oid</type></entry>
- <entry><literal>pg_database.oid</literal></entry>
- <entry>Database OID of the relation</entry>
- </row>
- <row>
- <entry><structfield>relfilenode</structfield></entry>
- <entry><type>oid</type></entry>
- <entry><literal>pg_class.relfilenode</literal></entry>
- <entry>Relfilenode of the relation</entry>
- </row>
- <row>
- <entry><structfield>relblocknumber</structfield></entry>
- <entry><type>bigint</type></entry>
- <entry></entry>
- <entry>Page number within the relation</entry>
- </row>
- <row>
- <entry><structfield>bytes</structfield></entry>
- <entry><type>integer</type></entry>
- <entry></entry>
- <entry>Free bytes in the page, or NULL for an index page (see below)</entry>
- </row>
-
- </tbody>
- </tgroup>
- </table>
-
- <para>
- For <structname>pg_freespacemap_relations</structname>, there is one row
- for each relation in the free space map.
- <structfield>storedpages</structfield> is the number of pages actually
- stored in the map, while <structfield>interestingpages</structfield> is the
- number of pages the last <command>VACUUM</> thought had useful amounts of
- free space.
- </para>
-
- <para>
- If <structfield>storedpages</structfield> is consistently less than
- <structfield>interestingpages</> then it'd be a good idea to increase
- <varname>max_fsm_pages</varname>. Also, if the number of rows in
- <structname>pg_freespacemap_relations</structname> is close to
- <varname>max_fsm_relations</varname>, then you should consider increasing
- <varname>max_fsm_relations</varname>.
- </para>
-
- <para>
- For <structname>pg_freespacemap_pages</structname>, there is one row for
- each page in the free space map. The number of rows for a relation will
- match the <structfield>storedpages</structfield> column in
- <structname>pg_freespacemap_relations</structname>.
+ The values stored in the free space map are not exact. They're rounded
+ to precision of 1/256th of BLCKSZ (32 bytes with default BLCKSZ), and
+ they're not kept fully up-to-date as tuples are inserted and updated.
</para>
<para>
For indexes, what is tracked is entirely-unused pages, rather than free
- space within pages. Therefore, the average request size and free bytes
- within a page are not meaningful, and are shown as NULL.
+ space within pages. Therefore, the values are not meaningful, just
+ whether a page is full or empty.
</para>
<para>
- Because the map is shared by all the databases, there will normally be
- entries for relations not belonging to the current database. This means
- that there may not be matching join rows in <structname>pg_class</> for
- some rows, or that there could even be incorrect joins. If you are
- trying to join against <structname>pg_class</>, it's a good idea to
- restrict the join to rows having <structfield>reldatabase</> equal to
- the current database's OID or zero.
- </para>
-
- <para>
- When either of the views is accessed, internal free space map locks are
- taken for long enough to copy all the state data that the view will 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.
+ NOTE: The interface was changed in version 8.4, to reflect the new FSM
+ implementation introduced in the same version.
</para>
</sect2>
<title>Sample output</title>
<programlisting>
-regression=# SELECT c.relname, r.avgrequest, r.interestingpages, r.storedpages
- FROM pg_freespacemap_relations r INNER JOIN pg_class c
- ON r.relfilenode = c.relfilenode AND
- r.reldatabase IN (0, (SELECT oid FROM pg_database
- WHERE datname = current_database()))
- ORDER BY r.storedpages DESC LIMIT 10;
- relname | avgrequest | interestingpages | storedpages
----------------------------------+------------+------------------+-------------
- onek | 256 | 109 | 109
- pg_attribute | 167 | 93 | 93
- pg_class | 191 | 49 | 49
- pg_attribute_relid_attnam_index | | 48 | 48
- onek2 | 256 | 37 | 37
- pg_depend | 95 | 26 | 26
- pg_type | 199 | 16 | 16
- pg_rewrite | 1011 | 13 | 13
- pg_class_relname_nsp_index | | 10 | 10
- pg_proc | 302 | 8 | 8
-(10 rows)
-
-regression=# SELECT c.relname, p.relblocknumber, p.bytes
- FROM pg_freespacemap_pages p INNER JOIN pg_class c
- ON p.relfilenode = c.relfilenode AND
- p.reldatabase IN (0, (SELECT oid FROM pg_database
- WHERE 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)
+postgres=# SELECT * FROM pg_freespace('foo');
+ blkno | avail
+-------+-------
+ 0 | 0
+ 1 | 0
+ 2 | 0
+ 3 | 32
+ 4 | 704
+ 5 | 704
+ 6 | 704
+ 7 | 1216
+ 8 | 704
+ 9 | 704
+ 10 | 704
+ 11 | 704
+ 12 | 704
+ 13 | 704
+ 14 | 704
+ 15 | 704
+ 16 | 704
+ 17 | 704
+ 18 | 704
+ 19 | 3648
+(20 rows)
+
+postgres=# SELECT * FROM pg_freespace('foo', 7);
+ pg_freespace
+--------------
+ 1216
+(1 row)
+
</programlisting>
</sect2>
<title>Author</title>
<para>
- Mark Kirkwood <email>markir@paradise.net.nz</email>
+ Original version by Mark Kirkwood <email>markir@paradise.net.nz</email>.
+ Rewritten in version 8.4 to suit new FSM implementation by Heikki
+ Linnakangas <email>heikki@enterprisedb.com</email>
</para>
</sect2>
<!--
-$PostgreSQL: pgsql/doc/src/sgml/ref/vacuum.sgml,v 1.51 2008/02/03 16:24:08 tgl Exp $
+$PostgreSQL: pgsql/doc/src/sgml/ref/vacuum.sgml,v 1.52 2008/09/30 10:52:10 heikki Exp $
PostgreSQL documentation
-->
<term><literal>VERBOSE</literal></term>
<listitem>
<para>
- Prints a detailed vacuum activity report for each table. Can be used
- to help determine appropriate settings for
- <xref linkend="guc-max-fsm-pages">,
- <xref linkend="guc-max-fsm-relations">, and
- <xref linkend="guc-default-statistics-target">.
+ Prints a detailed vacuum activity report for each table.
</para>
</listitem>
</varlistentry>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/release.sgml,v 1.585 2008/09/17 20:57:35 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/release.sgml,v 1.586 2008/09/30 10:52:09 heikki Exp $ -->
<!--
Typical markup:
<para>
Increase default values for <link
linkend="guc-shared-buffers"><varname>shared_buffers</></link>
- and <link
- linkend="guc-max-fsm-pages"><varname>max_fsm_pages</></link>
+ and <varname>max_fsm_pages</>
(Andrew)
</para>
</listitem>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/runtime.sgml,v 1.417 2008/09/23 09:20:34 heikki Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/runtime.sgml,v 1.418 2008/09/30 10:52:10 heikki Exp $ -->
<chapter Id="runtime">
<title>Operating System Environment</title>
<entry>8200 (assuming 8 kB <symbol>XLOG_BLCKSZ</>)</entry>
</row>
- <row>
- <entry><xref linkend="guc-max-fsm-relations"></>
- <entry>70</>
- </row>
-
- <row>
- <entry><xref linkend="guc-max-fsm-pages"></>
- <entry>6</>
- </row>
-
<row>
<entry>Fixed space requirements</>
<entry>770 kB</entry>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/storage.sgml,v 1.24 2008/08/05 12:09:30 mha Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/storage.sgml,v 1.25 2008/09/30 10:52:10 heikki Exp $ -->
<chapter id="storage">
<para>
Each table and index is stored in a separate file, named after the table
or index's <firstterm>filenode</> number, which can be found in
-<structname>pg_class</>.<structfield>relfilenode</>.
+<structname>pg_class</>.<structfield>relfilenode</>. In addition to the
+main file (aka. main fork), a <firstterm>free space map</> (see
+<xref linkend="storage-fsm">) that stores information about free space
+available in the relation, is stored in a file named after the filenode
+number, with the the _1 suffix. For example, if the table's filenode number
+is 12345, the FSM file is named <filename>12345_1</>.
</para>
<caution>
</sect1>
+<sect1 id="storage-fsm">
+
+<title>Free Space Map</title>
+
+ <indexterm>
+ <primary>Free Space Map</primary>
+ </indexterm>
+ <indexterm><primary>FSM</><see>Free Space Map</></indexterm>
+
+<para>
+A Free Space Map is stored with every heap and index relation, except for
+hash indexes, to keep track of available space in the relation. It's stored
+along the main relation data, in a separate FSM relation fork, named after
+relfilenode of the relation, but with a <literal>_1</> suffix. For example,
+if the relfilenode of a relation is 12345, the FSM is stored in a file called
+<filename>12345_1</>, in the same directory as the main relation file.
+</para>
+
+<para>
+The Free Space Map is organized as a tree of <acronym>FSM</> pages. The
+bottom level <acronym>FSM</> pages stores the free space available on every
+heap (or index) page, using one byte to represent each heap page. The upper
+levels aggregate information from the lower levels.
+</para>
+
+<para>
+Within each <acronym>FSM</> page is a binary tree, stored in an array with
+one byte per node. Each leaf node represents a heap page, or a lower level
+<acronym>FSM</> page. In each non-leaf node, the higher of its children's
+values is stored. The maximum value in the leaf nodes is therefore stored
+at the root.
+</para>
+
+<para>
+See <filename>src/backend/storage/freespace/README</> for more details on
+how the <acronym>FSM</> is structured, and how it's updated and searched.
+<xref linkend="pgfreespacemap"> contrib module can be used to view the
+information stored in free space maps.
+</para>
+
+</sect1>
+
<sect1 id="storage-page-layout">
<title>Database Page Layout</title>
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/gin/gininsert.c,v 1.14 2008/07/11 21:06:29 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/gin/gininsert.c,v 1.15 2008/09/30 10:52:10 heikki Exp $
*-------------------------------------------------------------------------
*/
#include "catalog/index.h"
#include "miscadmin.h"
#include "storage/bufmgr.h"
+#include "storage/indexfsm.h"
#include "utils/memutils.h"
elog(ERROR, "index \"%s\" already contains data",
RelationGetRelationName(index));
+ /* Initialize FSM */
+ InitIndexFreeSpaceMap(index);
+
initGinState(&buildstate.ginstate, index);
/* initialize the root page */
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/gin/ginutil.c,v 1.16 2008/07/11 21:06:29 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/gin/ginutil.c,v 1.17 2008/09/30 10:52:10 heikki Exp $
*-------------------------------------------------------------------------
*/
#include "catalog/pg_type.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
+#include "storage/indexfsm.h"
#include "storage/lmgr.h"
void
/* First, try to get a page from FSM */
for (;;)
{
- BlockNumber blkno = GetFreeIndexPage(&index->rd_node);
+ BlockNumber blkno = GetFreeIndexPage(index);
if (blkno == InvalidBlockNumber)
break;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/gin/ginvacuum.c,v 1.21 2008/07/11 21:06:29 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/gin/ginvacuum.c,v 1.22 2008/09/30 10:52:10 heikki Exp $
*-------------------------------------------------------------------------
*/
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
+#include "storage/indexfsm.h"
#include "storage/lmgr.h"
typedef struct
bool needLock;
BlockNumber npages,
blkno;
- BlockNumber totFreePages,
- nFreePages,
- *freePages,
- maxFreePages;
+ BlockNumber totFreePages;
BlockNumber lastBlock = GIN_ROOT_BLKNO,
lastFilledBlock = GIN_ROOT_BLKNO;
if (needLock)
UnlockRelationForExtension(index, ExclusiveLock);
- maxFreePages = npages;
- if (maxFreePages > MaxFSMPages)
- maxFreePages = MaxFSMPages;
-
- totFreePages = nFreePages = 0;
- freePages = (BlockNumber *) palloc(sizeof(BlockNumber) * maxFreePages);
+ totFreePages = 0;
for (blkno = GIN_ROOT_BLKNO + 1; blkno < npages; blkno++)
{
if (GinPageIsDeleted(page))
{
- if (nFreePages < maxFreePages)
- freePages[nFreePages++] = blkno;
+ RecordFreeIndexPage(index, blkno);
totFreePages++;
}
else
}
lastBlock = npages - 1;
- if (info->vacuum_full && nFreePages > 0)
+ if (info->vacuum_full && lastBlock > lastFilledBlock)
{
/* try to truncate index */
- int i;
-
- for (i = 0; i < nFreePages; i++)
- if (freePages[i] >= lastFilledBlock)
- {
- totFreePages = nFreePages = i;
- break;
- }
-
- if (lastBlock > lastFilledBlock)
- RelationTruncate(index, lastFilledBlock + 1);
+ FreeSpaceMapTruncateRel(index, lastFilledBlock + 1);
+ RelationTruncate(index, lastFilledBlock + 1);
stats->pages_removed = lastBlock - lastFilledBlock;
+ totFreePages = totFreePages - stats->pages_removed;
}
- RecordIndexFreeSpace(&index->rd_node, totFreePages, nFreePages, freePages);
stats->pages_free = totFreePages;
if (needLock)
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/gist/gist.c,v 1.151 2008/06/12 09:12:29 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/access/gist/gist.c,v 1.152 2008/09/30 10:52:10 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/index.h"
#include "miscadmin.h"
#include "storage/bufmgr.h"
+#include "storage/indexfsm.h"
#include "utils/memutils.h"
const XLogRecPtr XLogRecPtrForTemp = {1, 1};
elog(ERROR, "index \"%s\" already contains data",
RelationGetRelationName(index));
+ /* Initialize FSM */
+ InitIndexFreeSpaceMap(index);
+
/* no locking is needed */
initGISTstate(&buildstate.giststate, index);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/gist/gistutil.c,v 1.30 2008/07/13 20:45:46 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/gist/gistutil.c,v 1.31 2008/09/30 10:52:10 heikki Exp $
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/gist_private.h"
#include "access/reloptions.h"
#include "storage/freespace.h"
+#include "storage/indexfsm.h"
#include "storage/lmgr.h"
#include "storage/bufmgr.h"
#include "utils/rel.h"
/* First, try to get a page from FSM */
for (;;)
{
- BlockNumber blkno = GetFreeIndexPage(&r->rd_node);
+ BlockNumber blkno = GetFreeIndexPage(r);
if (blkno == InvalidBlockNumber)
break; /* nothing left in FSM */
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/gist/gistvacuum.c,v 1.36 2008/06/12 09:12:30 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/access/gist/gistvacuum.c,v 1.37 2008/09/30 10:52:10 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
+#include "storage/indexfsm.h"
#include "storage/lmgr.h"
#include "utils/memutils.h"
Relation rel = info->index;
BlockNumber npages,
blkno;
- BlockNumber totFreePages,
- nFreePages,
- *freePages,
- maxFreePages;
+ BlockNumber totFreePages;
BlockNumber lastBlock = GIST_ROOT_BLKNO,
lastFilledBlock = GIST_ROOT_BLKNO;
bool needLock;
if (needLock)
UnlockRelationForExtension(rel, ExclusiveLock);
- maxFreePages = npages;
- if (maxFreePages > MaxFSMPages)
- maxFreePages = MaxFSMPages;
-
- totFreePages = nFreePages = 0;
- freePages = (BlockNumber *) palloc(sizeof(BlockNumber) * maxFreePages);
-
+ totFreePages = 0;
for (blkno = GIST_ROOT_BLKNO + 1; blkno < npages; blkno++)
{
Buffer buffer;
if (PageIsNew(page) || GistPageIsDeleted(page))
{
- if (nFreePages < maxFreePages)
- freePages[nFreePages++] = blkno;
totFreePages++;
+ RecordFreeIndexPage(rel, blkno);
}
else
lastFilledBlock = blkno;
}
lastBlock = npages - 1;
- if (info->vacuum_full && nFreePages > 0)
+ if (info->vacuum_full && lastFilledBlock < lastBlock)
{ /* try to truncate index */
- int i;
+ FreeSpaceMapTruncateRel(rel, lastFilledBlock + 1);
+ RelationTruncate(rel, lastFilledBlock + 1);
- for (i = 0; i < nFreePages; i++)
- if (freePages[i] >= lastFilledBlock)
- {
- totFreePages = nFreePages = i;
- break;
- }
-
- if (lastBlock > lastFilledBlock)
- RelationTruncate(rel, lastFilledBlock + 1);
stats->std.pages_removed = lastBlock - lastFilledBlock;
+ totFreePages = totFreePages - stats->std.pages_removed;
}
- RecordIndexFreeSpace(&rel->rd_node, totFreePages, nFreePages, freePages);
- pfree(freePages);
-
/* return statistics */
stats->std.pages_free = totFreePages;
if (needLock)
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/heap/heapam.c,v 1.263 2008/09/11 14:01:09 alvherre Exp $
+ * $PostgreSQL: pgsql/src/backend/access/heap/heapam.c,v 1.264 2008/09/30 10:52:10 heikki Exp $
*
*
* INTERFACE ROUTINES
/* FlushRelationBuffers will have opened rd_smgr */
smgrimmedsync(rel->rd_smgr, MAIN_FORKNUM);
+ /* sync FSM as well */
+ smgrimmedsync(rel->rd_smgr, FSM_FORKNUM);
+
/* toast heap, if any */
if (OidIsValid(rel->rd_rel->reltoastrelid))
{
toastrel = heap_open(rel->rd_rel->reltoastrelid, AccessShareLock);
FlushRelationBuffers(toastrel);
smgrimmedsync(toastrel->rd_smgr, MAIN_FORKNUM);
+ smgrimmedsync(toastrel->rd_smgr, FSM_FORKNUM);
heap_close(toastrel, AccessShareLock);
}
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/heap/hio.c,v 1.72 2008/07/13 20:45:47 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/heap/hio.c,v 1.73 2008/09/30 10:52:10 heikki Exp $
*
*-------------------------------------------------------------------------
*/
* We have no cached target page, so ask the FSM for an initial
* target.
*/
- targetBlock = GetPageWithFreeSpace(&relation->rd_node,
- len + saveFreeSpace);
+ targetBlock = GetPageWithFreeSpace(relation, len + saveFreeSpace);
/*
* If the FSM knows nothing of the rel, try the last page before we
* Update FSM as to condition of this page, and ask for another page
* to try.
*/
- targetBlock = RecordAndGetPageWithFreeSpace(&relation->rd_node,
+ targetBlock = RecordAndGetPageWithFreeSpace(relation,
targetBlock,
pageFreeSpace,
len + saveFreeSpace);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtpage.c,v 1.110 2008/07/13 20:45:47 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtpage.c,v 1.111 2008/09/30 10:52:10 heikki Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
+#include "storage/indexfsm.h"
#include "storage/lmgr.h"
#include "utils/inval.h"
#include "utils/snapmgr.h"
*/
for (;;)
{
- blkno = GetFreeIndexPage(&rel->rd_node);
+ blkno = GetFreeIndexPage(rel);
if (blkno == InvalidBlockNumber)
break;
buf = ReadBuffer(rel, blkno);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtree.c,v 1.161 2008/06/19 00:46:03 alvherre Exp $
+ * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtree.c,v 1.162 2008/09/30 10:52:10 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
+#include "storage/indexfsm.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "utils/memutils.h"
IndexBulkDeleteCallback callback;
void *callback_state;
BTCycleId cycleid;
- BlockNumber *freePages;
- int nFreePages; /* number of entries in freePages[] */
- int maxFreePages; /* allocated size of freePages[] */
+ BlockNumber lastUsedPage;
BlockNumber totFreePages; /* true total # of free pages */
MemoryContext pagedelcontext;
} BTVacState;
elog(ERROR, "index \"%s\" already contains data",
RelationGetRelationName(index));
+ /* Initialize FSM */
+ InitIndexFreeSpaceMap(index);
+
buildstate.spool = _bt_spoolinit(index, indexInfo->ii_Unique, false);
/*
vstate.callback = callback;
vstate.callback_state = callback_state;
vstate.cycleid = cycleid;
- vstate.freePages = NULL; /* temporarily */
- vstate.nFreePages = 0;
- vstate.maxFreePages = 0;
+ vstate.lastUsedPage = BTREE_METAPAGE;
vstate.totFreePages = 0;
/* Create a temporary memory context to run _bt_pagedel in */
if (needLock)
UnlockRelationForExtension(rel, ExclusiveLock);
- /* Allocate freePages after we read num_pages the first time */
- if (vstate.freePages == NULL)
- {
- /* No point in remembering more than MaxFSMPages pages */
- vstate.maxFreePages = MaxFSMPages;
- if ((BlockNumber) vstate.maxFreePages > num_pages)
- vstate.maxFreePages = (int) num_pages;
- vstate.freePages = (BlockNumber *)
- palloc(vstate.maxFreePages * sizeof(BlockNumber));
- }
-
/* Quit if we've scanned the whole relation */
if (blkno >= num_pages)
break;
* acquiring exclusive lock on the index and then rechecking all the
* pages; doesn't seem worth it.
*/
- if (info->vacuum_full && vstate.nFreePages > 0)
+ if (info->vacuum_full && vstate.lastUsedPage < num_pages - 1)
{
- BlockNumber new_pages = num_pages;
-
- while (vstate.nFreePages > 0 &&
- vstate.freePages[vstate.nFreePages - 1] == new_pages - 1)
- {
- new_pages--;
- stats->pages_deleted--;
- vstate.nFreePages--;
- vstate.totFreePages = vstate.nFreePages; /* can't be more */
- }
- if (new_pages != num_pages)
- {
- /*
- * Okay to truncate.
- */
- RelationTruncate(rel, new_pages);
+ BlockNumber new_pages = vstate.lastUsedPage + 1;
- /* update statistics */
- stats->pages_removed += num_pages - new_pages;
+ /*
+ * Okay to truncate.
+ */
+ FreeSpaceMapTruncateRel(rel, new_pages);
+ RelationTruncate(rel, new_pages);
- num_pages = new_pages;
- }
+ /* update statistics */
+ stats->pages_removed += num_pages - new_pages;
+ vstate.totFreePages -= (num_pages - new_pages);
+ num_pages = new_pages;
}
- /*
- * Update the shared Free Space Map with the info we now have about free
- * pages in the index, discarding any old info the map may have. We do not
- * need to sort the page numbers; they're in order already.
- */
- RecordIndexFreeSpace(&rel->rd_node, vstate.totFreePages,
- vstate.nFreePages, vstate.freePages);
-
- pfree(vstate.freePages);
-
MemoryContextDelete(vstate.pagedelcontext);
/* update statistics */
/*
* If we are recursing, the only case we want to do anything with is a
* live leaf page having the current vacuum cycle ID. Any other state
- * implies we already saw the page (eg, deleted it as being empty). In
- * particular, we don't want to risk adding it to freePages twice.
+ * implies we already saw the page (eg, deleted it as being empty).
*/
if (blkno != orig_blkno)
{
}
}
+ /* If the page is in use, update lastUsedPage */
+ if (!_bt_page_recyclable(page) && vstate->lastUsedPage < blkno)
+ vstate->lastUsedPage = blkno;
+
/* Page is valid, see what to do with it */
if (_bt_page_recyclable(page))
{
/* Okay to recycle this page */
- if (vstate->nFreePages < vstate->maxFreePages)
- vstate->freePages[vstate->nFreePages++] = blkno;
+ RecordFreeIndexPage(rel, blkno);
vstate->totFreePages++;
stats->pages_deleted++;
}
*/
if (ndel && info->vacuum_full)
{
- if (vstate->nFreePages < vstate->maxFreePages)
- vstate->freePages[vstate->nFreePages++] = blkno;
+ RecordFreeIndexPage(rel, blkno);
vstate->totFreePages++;
}
* we log the completed index pages to WAL if and only if WAL archiving is
* active.
*
+ * This code isn't concerned about the FSM at all. The caller is responsible
+ * for initializing that.
*
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtsort.c,v 1.117 2008/08/11 11:05:10 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtsort.c,v 1.118 2008/09/30 10:52:10 heikki Exp $
*
*-------------------------------------------------------------------------
*/
*
* Resource managers definition
*
- * $PostgreSQL: pgsql/src/backend/access/transam/rmgr.c,v 1.25 2006/11/05 22:42:07 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/transam/rmgr.c,v 1.26 2008/09/30 10:52:11 heikki Exp $
*/
#include "postgres.h"
#include "commands/dbcommands.h"
#include "commands/sequence.h"
#include "commands/tablespace.h"
+#include "storage/freespace.h"
#include "storage/smgr.h"
{"Database", dbase_redo, dbase_desc, NULL, NULL, NULL},
{"Tablespace", tblspc_redo, tblspc_desc, NULL, NULL, NULL},
{"MultiXact", multixact_redo, multixact_desc, NULL, NULL, NULL},
- {"Reserved 7", NULL, NULL, NULL, NULL, NULL},
+ {"FreeSpaceMap", fsm_redo, fsm_desc, NULL, NULL, NULL},
{"Reserved 8", NULL, NULL, NULL, NULL, NULL},
{"Heap2", heap2_redo, heap2_desc, NULL, NULL, NULL},
{"Heap", heap_redo, heap_desc, NULL, NULL, NULL},
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/backend/access/transam/xlogutils.c,v 1.58 2008/08/11 11:05:10 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/access/transam/xlogutils.c,v 1.59 2008/09/30 10:52:11 heikki Exp $
*
*-------------------------------------------------------------------------
*/
rel->rd_lockInfo.lockRelId.relId = rnode.relNode;
rel->rd_targblock = InvalidBlockNumber;
+ rel->rd_fsm_nblocks_cache = InvalidBlockNumber;
rel->rd_smgr = NULL;
return rel;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.245 2008/09/01 20:42:43 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.246 2008/09/30 10:52:11 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "postmaster/bgwriter.h"
#include "postmaster/walwriter.h"
#include "storage/bufmgr.h"
-#include "storage/freespace.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "tcop/tcopprot.h"
case StartupProcess:
bootstrap_signals();
StartupXLOG();
- LoadFreeSpaceMap();
BuildFlatFiles(false);
proc_exit(0); /* startup done */
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/heap.c,v 1.339 2008/08/28 23:09:45 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/heap.c,v 1.340 2008/09/30 10:52:12 heikki Exp $
*
*
* INTERFACE ROUTINES
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "storage/bufmgr.h"
+#include "storage/freespace.h"
#include "storage/smgr.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
/*
* Have the storage manager create the relation's disk file, if needed.
*
- * We only create storage for the main fork here. The caller is
- * responsible for creating any additional forks if needed.
+ * We create storage for the main fork here, and also for the FSM for a
+ * heap or toast relation. The caller is responsible for creating any
+ * additional forks if needed.
*/
if (create_storage)
{
Assert(rel->rd_smgr == NULL);
RelationOpenSmgr(rel);
smgrcreate(rel->rd_smgr, MAIN_FORKNUM, rel->rd_istemp, false);
+
+ /*
+ * For a real heap, create FSM fork as well. Indexams are
+ * responsible for creating any extra forks themselves.
+ */
+ if (relkind == RELKIND_RELATION || relkind == RELKIND_TOASTVALUE)
+ smgrcreate(rel->rd_smgr, FSM_FORKNUM, rel->rd_istemp, false);
}
return rel;
/* Fetch info needed for index_build */
indexInfo = BuildIndexInfo(currentIndex);
- /* Now truncate the actual file (and discard buffers) */
+ /*
+ * Now truncate the actual file (and discard buffers). The indexam
+ * is responsible for truncating the FSM in index_build(), if
+ * applicable.
+ */
RelationTruncate(currentIndex, 0);
/* Initialize the index and rebuild */
{
Relation rel = lfirst(cell);
- /* Truncate the actual file (and discard buffers) */
+ /* Truncate the FSM and actual file (and discard buffers) */
+ FreeSpaceMapTruncateRel(rel, 0);
RelationTruncate(rel, 0);
/* If this relation has indexes, truncate the indexes too */
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/index.c,v 1.304 2008/09/15 18:43:41 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/index.c,v 1.305 2008/09/30 10:52:12 heikki Exp $
*
*
* INTERFACE ROUTINES
RelationOpenSmgr(userIndexRelation);
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
if (smgrexists(userIndexRelation->rd_smgr, forknum))
- smgrscheduleunlink(userIndexRelation->rd_smgr, forknum,
+ smgrscheduleunlink(userIndexRelation->rd_smgr, forknum,
userIndexRelation->rd_istemp);
RelationCloseSmgr(userIndexRelation);
/*
* ... and create storage for corresponding forks in the new relfilenode.
*
- * NOTE: any conflict in relfilenode value will be caught here
+ * NOTE: any conflict in relfilenode value will be caught here
*/
newrnode = relation->rd_node;
newrnode.relNode = newrelfilenode;
/* Create the main fork, like heap_create() does */
smgrcreate(srel, MAIN_FORKNUM, relation->rd_istemp, false);
+ /*
+ * For a heap, create FSM fork as well. Indexams are responsible for
+ * creating any extra forks themselves.
+ */
+ if (relation->rd_rel->relkind == RELKIND_RELATION ||
+ relation->rd_rel->relkind == RELKIND_TOASTVALUE)
+ smgrcreate(srel, FSM_FORKNUM, relation->rd_istemp, false);
+
/* schedule unlinking old files */
for (i = 0; i <= MAX_FORKNUM; i++)
{
if (inplace)
{
- /* Truncate the actual file (and discard buffers) */
+ /*
+ * Truncate the actual file (and discard buffers). The indexam
+ * is responsible for truncating the FSM, if applicable
+ */
RelationTruncate(iRel, 0);
}
else
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/dbcommands.c,v 1.212 2008/09/23 10:58:03 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/dbcommands.c,v 1.213 2008/09/30 10:52:12 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "postmaster/bgwriter.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
-#include "storage/freespace.h"
#include "storage/ipc.h"
#include "storage/procarray.h"
#include "storage/smgr.h"
*/
DropDatabaseBuffers(db_id);
- /*
- * Also, clean out any entries in the shared free space map.
- */
- FreeSpaceMapForgetDatabase(db_id);
-
/*
* Tell the stats collector to forget it immediately, too.
*/
/* Drop pages for this database that are in the shared buffer cache */
DropDatabaseBuffers(xlrec->db_id);
- /* Also, clean out any entries in the shared free space map */
- FreeSpaceMapForgetDatabase(xlrec->db_id);
-
/* Also, clean out any fsync requests that might be pending in md.c */
ForgetDatabaseFsyncRequests(xlrec->db_id);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/vacuum.c,v 1.377 2008/09/11 14:01:09 alvherre Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/vacuum.c,v 1.378 2008/09/30 10:52:12 heikki Exp $
*
*-------------------------------------------------------------------------
*/
* (autovacuum.c does this for itself.)
*/
vac_update_datfrozenxid();
-
- /*
- * If it was a database-wide VACUUM, print FSM usage statistics (we
- * don't make you be superuser to see these). We suppress this in
- * autovacuum, too.
- */
- if (all_rels)
- PrintFreeSpaceMapStatistics(elevel);
}
/*
}
}
- /* update shared free space map with final free space info */
+ /* update thefree space map with final free space info, and vacuum it */
vac_update_fsm(onerel, &fraged_pages, vacrelstats->rel_pages);
+ FreeSpaceMapVacuum(onerel);
/* update statistics in pg_class */
vac_update_relstats(RelationGetRelid(onerel), vacrelstats->rel_pages,
/* Truncate relation, if needed */
if (blkno < nblocks)
{
+ FreeSpaceMapTruncateRel(onerel, blkno);
RelationTruncate(onerel, blkno);
vacrelstats->rel_pages = blkno; /* set new number of blocks */
}
(errmsg("\"%s\": truncated %u to %u pages",
RelationGetRelationName(onerel),
vacrelstats->rel_pages, relblocks)));
+ FreeSpaceMapTruncateRel(onerel, relblocks);
RelationTruncate(onerel, relblocks);
vacrelstats->rel_pages = relblocks; /* set new number of blocks */
}
}
/*
- * Update the shared Free Space Map with the info we now have about
- * free space in the relation, discarding any old info the map may have.
+ * Update the Free Space Map with the info we now have about free space in
+ * the relation.
*/
static void
vac_update_fsm(Relation onerel, VacPageList fraged_pages,
{
int nPages = fraged_pages->num_pages;
VacPage *pagedesc = fraged_pages->pagedesc;
- Size threshold;
- FSMPageData *pageSpaces;
- int outPages;
int i;
- /*
- * We only report pages with free space at least equal to the average
- * request size --- this avoids cluttering FSM with uselessly-small bits
- * of space. Although FSM would discard pages with little free space
- * anyway, it's important to do this prefiltering because (a) it reduces
- * the time spent holding the FSM lock in RecordRelationFreeSpace, and (b)
- * FSM uses the number of pages reported as a statistic for guiding space
- * management. If we didn't threshold our reports the same way
- * vacuumlazy.c does, we'd be skewing that statistic.
- */
- threshold = GetAvgFSMRequestSize(&onerel->rd_node);
-
- pageSpaces = (FSMPageData *) palloc(nPages * sizeof(FSMPageData));
- outPages = 0;
-
for (i = 0; i < nPages; i++)
{
/*
if (pagedesc[i]->blkno >= rel_pages)
break;
- if (pagedesc[i]->free >= threshold)
- {
- FSMPageSetPageNum(&pageSpaces[outPages], pagedesc[i]->blkno);
- FSMPageSetSpace(&pageSpaces[outPages], pagedesc[i]->free);
- outPages++;
- }
+ RecordPageWithFreeSpace(onerel, pagedesc[i]->blkno, pagedesc[i]->free);
}
- RecordRelationFreeSpace(&onerel->rd_node, outPages, outPages, pageSpaces);
-
- pfree(pageSpaces);
}
/* Copy a VacPage structure */
* index cleanup and page compaction, then resume the heap scan with an empty
* TID array.
*
- * We can limit the storage for page free space to MaxFSMPages entries,
- * since that's the most the free space map will be willing to remember
- * anyway. If the relation has fewer than that many pages with free space,
- * life is easy: just build an array of per-page info. If it has more,
- * we store the free space info as a heap ordered by amount of free space,
- * so that we can discard the pages with least free space to ensure we never
- * have more than MaxFSMPages entries in all. The surviving page entries
- * are passed to the free space map at conclusion of the scan.
- *
* If we're processing a table with no indexes, we can just vacuum each page
* as we go; there's no need to save up multiple tuples to minimize the number
* of index scans performed. So we don't use maintenance_work_mem memory for
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/vacuumlazy.c,v 1.107 2008/05/12 00:00:48 alvherre Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/vacuumlazy.c,v 1.108 2008/09/30 10:52:12 heikki Exp $
*
*-------------------------------------------------------------------------
*/
BlockNumber pages_removed;
double tuples_deleted;
BlockNumber nonempty_pages; /* actually, last nonempty page + 1 */
- Size threshold; /* minimum interesting free space */
/* List of TIDs of tuples we intend to delete */
/* NB: this list is ordered by TID address */
int num_dead_tuples; /* current # of entries */
int max_dead_tuples; /* # slots allocated in array */
ItemPointer dead_tuples; /* array of ItemPointerData */
- /* Array or heap of per-page info about free space */
- /* We use a simple array until it fills up, then convert to heap */
- bool fs_is_heap; /* are we using heap organization? */
- int num_free_pages; /* current # of entries */
- int max_free_pages; /* # slots allocated in array */
- FSMPageData *free_pages; /* array or heap of blkno/avail */
- BlockNumber tot_free_pages; /* total pages with >= threshold space */
int num_index_scans;
} LVRelStats;
static void lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks);
static void lazy_record_dead_tuple(LVRelStats *vacrelstats,
ItemPointer itemptr);
-static void lazy_record_free_space(LVRelStats *vacrelstats,
- BlockNumber page, Size avail);
static bool lazy_tid_reaped(ItemPointer itemptr, void *state);
-static void lazy_update_fsm(Relation onerel, LVRelStats *vacrelstats);
static int vac_cmp_itemptr(const void *left, const void *right);
-static int vac_cmp_page_spaces(const void *left, const void *right);
/*
vacrelstats = (LVRelStats *) palloc0(sizeof(LVRelStats));
- /* Set threshold for interesting free space = average request size */
- /* XXX should we scale it up or down? Adjust vacuum.c too, if so */
- vacrelstats->threshold = GetAvgFSMRequestSize(&onerel->rd_node);
-
vacrelstats->num_index_scans = 0;
/* Open all indexes of the relation */
possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION)
lazy_truncate_heap(onerel, vacrelstats);
- /* Update shared free space map with final free space info */
- lazy_update_fsm(onerel, vacrelstats);
-
- if (vacrelstats->tot_free_pages > MaxFSMPages)
- ereport(WARNING,
- (errmsg("relation \"%s.%s\" contains more than \"max_fsm_pages\" pages with useful free space",
- get_namespace_name(RelationGetNamespace(onerel)),
- RelationGetRelationName(onerel)),
- /* Only suggest VACUUM FULL if > 20% free */
- (vacrelstats->tot_free_pages > vacrelstats->rel_pages * 0.20) ?
- errhint("Consider using VACUUM FULL on this relation or increasing the configuration parameter \"max_fsm_pages\".") :
- errhint("Consider increasing the configuration parameter \"max_fsm_pages\".")));
+ /* Vacuum the Free Space Map */
+ FreeSpaceMapVacuum(onerel);
/* Update statistics in pg_class */
vac_update_relstats(RelationGetRelid(onerel),
int prev_dead_count;
OffsetNumber frozen[MaxOffsetNumber];
int nfrozen;
+ Size freespace;
vacuum_delay_point();
relname, blkno)));
PageInit(page, BufferGetPageSize(buf), 0);
empty_pages++;
- lazy_record_free_space(vacrelstats, blkno,
- PageGetHeapFreeSpace(page));
}
+ freespace = PageGetHeapFreeSpace(page);
MarkBufferDirty(buf);
UnlockReleaseBuffer(buf);
+
+ RecordPageWithFreeSpace(onerel, blkno, freespace);
continue;
}
if (PageIsEmpty(page))
{
empty_pages++;
- lazy_record_free_space(vacrelstats, blkno,
- PageGetHeapFreeSpace(page));
+ freespace = PageGetHeapFreeSpace(page);
UnlockReleaseBuffer(buf);
+ RecordPageWithFreeSpace(onerel, blkno, freespace);
continue;
}
vacuumed_pages++;
}
+ freespace = PageGetHeapFreeSpace(page);
+
+ /* Remember the location of the last page with nonremovable tuples */
+ if (hastup)
+ vacrelstats->nonempty_pages = blkno + 1;
+
+ UnlockReleaseBuffer(buf);
+
/*
* If we remembered any tuples for deletion, then the page will be
* visited again by lazy_vacuum_heap, which will compute and record
* taken if there are no indexes.)
*/
if (vacrelstats->num_dead_tuples == prev_dead_count)
- {
- lazy_record_free_space(vacrelstats, blkno,
- PageGetHeapFreeSpace(page));
- }
-
- /* Remember the location of the last page with nonremovable tuples */
- if (hastup)
- vacrelstats->nonempty_pages = blkno + 1;
-
- UnlockReleaseBuffer(buf);
+ RecordPageWithFreeSpace(onerel, blkno, freespace);
}
/* save stats for use later */
tups_vacuumed, num_tuples, nblocks),
errdetail("%.0f dead row versions cannot be removed yet.\n"
"There were %.0f unused item pointers.\n"
- "%u pages contain useful free space.\n"
"%u pages are entirely empty.\n"
"%s.",
nkeep,
nunused,
- vacrelstats->tot_free_pages,
empty_pages,
pg_rusage_show(&ru0))));
}
BlockNumber tblk;
Buffer buf;
Page page;
+ Size freespace;
vacuum_delay_point();
buf = ReadBufferWithStrategy(onerel, tblk, vac_strategy);
LockBufferForCleanup(buf);
tupindex = lazy_vacuum_page(onerel, tblk, buf, tupindex, vacrelstats);
+
/* Now that we've compacted the page, record its available space */
page = BufferGetPage(buf);
- lazy_record_free_space(vacrelstats, tblk,
- PageGetHeapFreeSpace(page));
+ freespace = PageGetHeapFreeSpace(page);
+
UnlockReleaseBuffer(buf);
+ RecordPageWithFreeSpace(onerel, tblk, freespace);
npages++;
}
{
BlockNumber old_rel_pages = vacrelstats->rel_pages;
BlockNumber new_rel_pages;
- FSMPageData *pageSpaces;
- int n;
- int i,
- j;
PGRUsage ru0;
pg_rusage_init(&ru0);
/*
* Okay to truncate.
*/
+ FreeSpaceMapTruncateRel(onerel, new_rel_pages);
RelationTruncate(onerel, new_rel_pages);
/*
* the table again.
*/
- /*
- * Drop free-space info for removed blocks; these must not get entered
- * into the FSM!
- */
- pageSpaces = vacrelstats->free_pages;
- n = vacrelstats->num_free_pages;
- j = 0;
- for (i = 0; i < n; i++)
- {
- if (FSMPageGetPageNum(&pageSpaces[i]) < new_rel_pages)
- {
- pageSpaces[j] = pageSpaces[i];
- j++;
- }
- }
- vacrelstats->num_free_pages = j;
-
- /*
- * If tot_free_pages was more than num_free_pages, we can't tell for sure
- * what its correct value is now, because we don't know which of the
- * forgotten pages are getting truncated. Conservatively set it equal to
- * num_free_pages.
- */
- vacrelstats->tot_free_pages = j;
-
- /* We destroyed the heap ordering, so mark array unordered */
- vacrelstats->fs_is_heap = false;
-
/* update statistics */
vacrelstats->rel_pages = new_rel_pages;
vacrelstats->pages_removed = old_rel_pages - new_rel_pages;
lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)
{
long maxtuples;
- int maxpages;
if (vacrelstats->hasindex)
{
vacrelstats->max_dead_tuples = (int) maxtuples;
vacrelstats->dead_tuples = (ItemPointer)
palloc(maxtuples * sizeof(ItemPointerData));
-
- maxpages = MaxFSMPages;
- maxpages = Min(maxpages, MaxAllocSize / sizeof(FSMPageData));
- /* No need to allocate more pages than the relation has blocks */
- if (relblocks < (BlockNumber) maxpages)
- maxpages = (int) relblocks;
-
- vacrelstats->fs_is_heap = false;
- vacrelstats->num_free_pages = 0;
- vacrelstats->max_free_pages = maxpages;
- vacrelstats->free_pages = (FSMPageData *)
- palloc(maxpages * sizeof(FSMPageData));
- vacrelstats->tot_free_pages = 0;
}
/*
}
}
-/*
- * lazy_record_free_space - remember free space on one page
- */
-static void
-lazy_record_free_space(LVRelStats *vacrelstats,
- BlockNumber page,
- Size avail)
-{
- FSMPageData *pageSpaces;
- int n;
-
- /*
- * A page with less than stats->threshold free space will be forgotten
- * immediately, and never passed to the free space map. Removing the
- * uselessly small entries early saves cycles, and in particular reduces
- * the amount of time we spend holding the FSM lock when we finally call
- * RecordRelationFreeSpace. Since the FSM will probably drop pages with
- * little free space anyway, there's no point in making this really small.
- *
- * XXX Is it worth trying to measure average tuple size, and using that to
- * adjust the threshold? Would be worthwhile if FSM has no stats yet for
- * this relation. But changing the threshold as we scan the rel might
- * lead to bizarre behavior, too. Also, it's probably better if vacuum.c
- * has the same thresholding behavior as we do here.
- */
- if (avail < vacrelstats->threshold)
- return;
-
- /* Count all pages over threshold, even if not enough space in array */
- vacrelstats->tot_free_pages++;
-
- /* Copy pointers to local variables for notational simplicity */
- pageSpaces = vacrelstats->free_pages;
- n = vacrelstats->max_free_pages;
-
- /* If we haven't filled the array yet, just keep adding entries */
- if (vacrelstats->num_free_pages < n)
- {
- FSMPageSetPageNum(&pageSpaces[vacrelstats->num_free_pages], page);
- FSMPageSetSpace(&pageSpaces[vacrelstats->num_free_pages], avail);
- vacrelstats->num_free_pages++;
- return;
- }
-
- /*----------
- * The rest of this routine works with "heap" organization of the
- * free space arrays, wherein we maintain the heap property
- * avail[(j-1) div 2] <= avail[j] for 0 < j < n.
- * In particular, the zero'th element always has the smallest available
- * space and can be discarded to make room for a new page with more space.
- * See Knuth's discussion of heap-based priority queues, sec 5.2.3;
- * but note he uses 1-origin array subscripts, not 0-origin.
- *----------
- */
-
- /* If we haven't yet converted the array to heap organization, do it */
- if (!vacrelstats->fs_is_heap)
- {
- /*
- * Scan backwards through the array, "sift-up" each value into its
- * correct position. We can start the scan at n/2-1 since each entry
- * above that position has no children to worry about.
- */
- int l = n / 2;
-
- while (--l >= 0)
- {
- BlockNumber R = FSMPageGetPageNum(&pageSpaces[l]);
- Size K = FSMPageGetSpace(&pageSpaces[l]);
- int i; /* i is where the "hole" is */
-
- i = l;
- for (;;)
- {
- int j = 2 * i + 1;
-
- if (j >= n)
- break;
- if (j + 1 < n && FSMPageGetSpace(&pageSpaces[j]) > FSMPageGetSpace(&pageSpaces[j + 1]))
- j++;
- if (K <= FSMPageGetSpace(&pageSpaces[j]))
- break;
- pageSpaces[i] = pageSpaces[j];
- i = j;
- }
- FSMPageSetPageNum(&pageSpaces[i], R);
- FSMPageSetSpace(&pageSpaces[i], K);
- }
-
- vacrelstats->fs_is_heap = true;
- }
-
- /* If new page has more than zero'th entry, insert it into heap */
- if (avail > FSMPageGetSpace(&pageSpaces[0]))
- {
- /*
- * Notionally, we replace the zero'th entry with the new data, and
- * then sift-up to maintain the heap property. Physically, the new
- * data doesn't get stored into the arrays until we find the right
- * location for it.
- */
- int i = 0; /* i is where the "hole" is */
-
- for (;;)
- {
- int j = 2 * i + 1;
-
- if (j >= n)
- break;
- if (j + 1 < n && FSMPageGetSpace(&pageSpaces[j]) > FSMPageGetSpace(&pageSpaces[j + 1]))
- j++;
- if (avail <= FSMPageGetSpace(&pageSpaces[j]))
- break;
- pageSpaces[i] = pageSpaces[j];
- i = j;
- }
- FSMPageSetPageNum(&pageSpaces[i], page);
- FSMPageSetSpace(&pageSpaces[i], avail);
- }
-}
-
/*
* lazy_tid_reaped() -- is a particular tid deletable?
*
return (res != NULL);
}
-/*
- * Update the shared Free Space Map with the info we now have about
- * free space in the relation, discarding any old info the map may have.
- */
-static void
-lazy_update_fsm(Relation onerel, LVRelStats *vacrelstats)
-{
- FSMPageData *pageSpaces = vacrelstats->free_pages;
- int nPages = vacrelstats->num_free_pages;
-
- /*
- * Sort data into order, as required by RecordRelationFreeSpace.
- */
- if (nPages > 1)
- qsort(pageSpaces, nPages, sizeof(FSMPageData),
- vac_cmp_page_spaces);
-
- RecordRelationFreeSpace(&onerel->rd_node, vacrelstats->tot_free_pages,
- nPages, pageSpaces);
-}
-
/*
* Comparator routines for use with qsort() and bsearch().
*/
return 0;
}
-
-static int
-vac_cmp_page_spaces(const void *left, const void *right)
-{
- FSMPageData *linfo = (FSMPageData *) left;
- FSMPageData *rinfo = (FSMPageData *) right;
- BlockNumber lblkno = FSMPageGetPageNum(linfo);
- BlockNumber rblkno = FSMPageGetPageNum(rinfo);
-
- if (lblkno < rblkno)
- return -1;
- else if (lblkno > rblkno)
- return 1;
- return 0;
-}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/postmaster/bgwriter.c,v 1.51 2008/08/11 11:05:11 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/postmaster/bgwriter.c,v 1.52 2008/09/30 10:52:13 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "postmaster/bgwriter.h"
#include "storage/bufmgr.h"
#include "storage/fd.h"
-#include "storage/freespace.h"
#include "storage/ipc.h"
#include "storage/lwlock.h"
#include "storage/pmsignal.h"
ExitOnAnyError = true;
/* Close down the database */
ShutdownXLOG(0, 0);
- DumpFreeSpaceMap(0, 0);
/* Normal exit from the bgwriter is here */
proc_exit(0); /* done */
}
# Makefile for storage/freespace
#
# IDENTIFICATION
-# $PostgreSQL: pgsql/src/backend/storage/freespace/Makefile,v 1.4 2008/02/19 10:30:08 petere Exp $
+# $PostgreSQL: pgsql/src/backend/storage/freespace/Makefile,v 1.5 2008/09/30 10:52:13 heikki Exp $
#
#-------------------------------------------------------------------------
top_builddir = ../../../..
include $(top_builddir)/src/Makefile.global
-OBJS = freespace.o
+OBJS = freespace.o fsmpage.o indexfsm.o
include $(top_srcdir)/src/backend/common.mk
--- /dev/null
+$PostgreSQL: pgsql/src/backend/storage/freespace/README,v 1.1 2008/09/30 10:52:13 heikki Exp $
+
+Free Space Map
+--------------
+
+The purpose of the free space map is to quickly locate a page with enough
+free space to hold a tuple to be stored; or to determine that no such page
+exists and the relation must be extended by one page. As of PostgreSQL 8.4
+each relation has its own, extensible free space map stored in a separate
+"fork" of its relation. This eliminates the disadvantages of the former
+fixed-size FSM.
+
+It is important to keep the map small so that it can be searched rapidly.
+Therefore, we don't attempt to record the exact free space on a page.
+We allocate one map byte to each page, allowing us to record free space
+at a granularity of 1/256th of a page. Another way to say it is that
+the stored value is the free space divided by BLCKSZ/256 (rounding down).
+We assume that the free space must always be less than BLCKSZ, since
+all pages have some overhead; so the maximum map value is 255.
+
+To assist in fast searching, the map isn't simply an array of per-page
+entries, but has a tree structure above those entries. There is a tree
+structure of pages, and a tree structure within each page, as described
+below.
+
+FSM page structure
+------------------
+
+Within each FSM page, we use a binary tree structure where leaf nodes store
+the amount of free space on heap pages (or lower level FSM pages, see
+"Higher-level structure" below), with one leaf node per heap page. A non-leaf
+node stores the max amount of free space on any of its children.
+
+For example:
+
+ 4
+ 4 2
+3 4 0 2 <- This level represents heap pages
+
+We need two basic operations: search and update.
+
+To search for a page with X amount of free space, traverse down the tree
+along a path where n >= X, until you hit the bottom. If both children of a
+node satisfy the condition, you can pick either one arbitrarily.
+
+To update the amount of free space on a page to X, first update the leaf node
+corresponding to the heap page, then "bubble up" the change to upper nodes,
+by walking up to each parent and recomputing its value as the max of its
+two children. Repeat until reaching the root or a parent whose value
+doesn't change.
+
+This data structure has a couple of nice properties:
+- to discover that there is no page with X bytes of free space, you only
+ need to look at the root node
+- by varying which child to traverse to in the search algorithm, when you have
+ a choice, we can implement various strategies, like preferring pages closer
+ to a given page, or spreading the load across the table.
+
+Higher-level routines that use FSM pages access them through the fsm_set_avail()
+and fsm_search_avail() functions. The interface to those functions hides the
+page's internal tree structure, treating the FSM page as a black box that has
+a certain number of "slots" for storing free space information. (However,
+the higher routines have to be aware of the tree structure of the whole map.)
+
+The binary tree is stored on each FSM page as an array. Because the page
+header takes some space on a page, the binary tree isn't perfect. That is,
+a few right-most leaf nodes are missing, and there are some useless non-leaf
+nodes at the right. So the tree looks something like this:
+
+ 0
+ 1 2
+ 3 4 5 6
+7 8 9 A B
+
+where the numbers denote each node's position in the array. Note that the
+tree is guaranteed complete above the leaf level; only some leaf nodes are
+missing. This is reflected in the number of usable "slots" per page not
+being an exact power of 2.
+
+A FSM page also has a next slot pointer, fp_next_slot, that determines where
+to start the next search for free space within that page. The reason for that
+is to spread out the pages that are returned by FSM searches. When several
+backends are concurrently inserting into a relation, contention can be avoided
+by having them insert into different pages. But it is also desirable to fill
+up pages in sequential order, to get the benefit of OS prefetching and batched
+writes. The FSM is responsible for making that happen, and the next slot
+pointer helps provide the desired behavior.
+
+Higher-level structure
+----------------------
+
+To scale up the data structure described above beyond a single page, we
+maintain a similar tree-structure across pages. Leaf nodes in higher level
+pages correspond to lower level FSM pages. The root node within each page
+has the same value as the corresponding leaf node on its parent page.
+
+The root page is always stored at physical block 0.
+
+For example, assuming each FSM page can hold information about 4 pages (in
+reality, it holds (BLCKSZ - headers) / 2, or ~4000 with default BLCKSZ),
+we get a disk layout like this:
+
+ 0 <-- page 0 at level 2 (root page)
+ 0 <-- page 0 at level 1
+ 0 <-- page 0 at level 0
+ 1 <-- page 1 at level 0
+ 2 <-- ...
+ 3
+ 1 <-- page 1 at level 1
+ 4
+ 5
+ 6
+ 7
+ 2
+ 8
+ 9
+ 10
+ 11
+ 3
+ 12
+ 13
+ 14
+ 15
+
+where the numbers are page numbers *at that level*, starting from 0.
+
+To find the physical block # corresponding to leaf page n, we need to
+count the number number of leaf and upper-level pages preceding page n.
+This turns out to be
+
+y = n + (n / F + 1) + (n / F^2 + 1) + ... + 1
+
+where F is the fanout (4 in the above example). The first term n is the number
+of preceding leaf pages, the second term is the number of pages at level 1,
+and so forth.
+
+To keep things simple, the tree is always constant height. To cover the
+maximum relation size of 2^32-1 blocks, three levels is enough with the default
+BLCKSZ (4000^3 > 2^32).
+
+Addressing
+----------
+
+The higher-level routines operate on "logical" addresses, consisting of
+- level,
+- logical page number, and
+- slot (if applicable)
+
+Bottom level FSM pages have level of 0, the level above that 1, and root 2.
+As in the diagram above, logical page number is the page number at that level,
+starting from 0.
+
+Locking
+-------
+
+When traversing down to search for free space, only one page is locked at a
+time: the parent page is released before locking the child. If the child page
+is concurrently modified, and there no longer is free space on the child page
+when you land on it, you need to start from scratch (after correcting the
+parent page, so that you don't get into an infinite loop).
+
+We use shared buffer locks when searching, but exclusive buffer lock when
+updating a page. However, the next slot search pointer is updated during
+searches even though we have only a shared lock. fp_next_slot is just a hint
+and we can easily reset it if it gets corrupted; so it seems better to accept
+some risk of that type than to pay the overhead of exclusive locking.
+
+Recovery
+--------
+
+The FSM is not explicitly WAL-logged. Instead, we rely on a bunch of
+self-correcting measures to repair possible corruption.
+
+First of all, whenever a value is set on an FSM page, the root node of the
+page is compared against the new value after bubbling up the change is
+finished. It should be greater than or equal to the value just set, or we
+have a corrupted page, with a parent somewhere with too small a value.
+Secondly, if we detect corrupted pages while we search, traversing down
+the tree. That check will notice if a parent node is set to too high a value.
+In both cases, the upper nodes on the page are immediately rebuilt, fixing
+the corruption.
+
+Vacuum updates all the bottom level pages with correct amount of free space
+on the heap pages, fixing any outdated values there. After the heap and
+index passes are done, FreeSpaceMapVacuum is called, and the FSM tree is
+scanned in depth-first order. This fixes any discrepancies between upper
+and lower level FSM pages.
+
+TODO
+----
+
+- fastroot to avoid traversing upper nodes with just 1 child
+- use a different system for tables that fit into one FSM page, with a
+ mechanism to switch to the real thing as it grows.
+
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/storage/freespace/freespace.c,v 1.60 2008/03/10 02:04:09 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/storage/freespace/freespace.c,v 1.61 2008/09/30 10:52:13 heikki Exp $
*
*
* NOTES:
*
- * The only really interesting aspect of this code is the heuristics for
- * deciding how much information we can afford to keep about each relation,
- * given that we have a limited amount of workspace in shared memory.
- * These currently work as follows:
- *
- * The number of distinct relations tracked is limited by a configuration
- * variable (MaxFSMRelations). When this would be exceeded, we discard the
- * least recently used relation. A doubly-linked list with move-to-front
- * behavior keeps track of which relation is least recently used.
- *
- * For each known relation, we track the average request size given to
- * GetPageWithFreeSpace() as well as the most recent number of pages reported
- * to RecordRelationFreeSpace(). The average request size is not directly
- * used in this module, but we expect VACUUM to use it to filter out
- * uninteresting amounts of space before calling RecordRelationFreeSpace().
- * The sum of the RRFS page counts is thus the total number of "interesting"
- * pages that we would like to track; this is called DesiredFSMPages.
- *
- * The number of pages actually tracked is limited by a configuration variable
- * (MaxFSMPages). When this is less than DesiredFSMPages, each relation
- * gets to keep a fraction MaxFSMPages/DesiredFSMPages of its free pages.
- * We discard pages with less free space to reach this target.
- *
- * Actually, our space allocation is done in "chunks" of CHUNKPAGES pages,
- * with each relation guaranteed at least one chunk. This reduces thrashing
- * of the storage allocations when there are small changes in the RRFS page
- * counts from one VACUUM to the next. (XXX it might also be worthwhile to
- * impose some kind of moving-average smoothing on the RRFS page counts?)
- *
- * So the actual arithmetic is: for each relation compute myRequest as the
- * number of chunks needed to hold its RRFS page count (not counting the
- * first, guaranteed chunk); compute sumRequests as the sum of these values
- * over all relations; then for each relation figure its target allocation
- * as
- * 1 + round(spareChunks * myRequest / sumRequests)
- * where spareChunks = totalChunks - numRels is the number of chunks we have
- * a choice what to do with. We round off these numbers because truncating
- * all of them would waste significant space. But because of roundoff, it's
- * possible for the last few relations to get less space than they should;
- * the target allocation must be checked against remaining available space.
+ * Free Space Map keeps track of the amount of free space on pages, and
+ * allows quickly searching for a page with enough free space. The FSM is
+ * stored in a dedicated relation fork of all heap relations, and those
+ * index access methods that need it (see also indexfsm.c). See README for
+ * more information.
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
-#include <limits.h>
-#include <math.h>
-#include <unistd.h>
-
-#include "storage/fd.h"
+#include "access/htup.h"
+#include "access/xlogutils.h"
+#include "storage/bufpage.h"
+#include "storage/bufmgr.h"
#include "storage/freespace.h"
+#include "storage/fsm_internals.h"
+#include "storage/lmgr.h"
#include "storage/lwlock.h"
-#include "storage/shmem.h"
+#include "storage/smgr.h"
+#include "utils/rel.h"
+#include "utils/inval.h"
+#include "miscadmin.h"
-
-/*----------
- * 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
- * transient condition where FSM isn't really functioning.
+/*
+ * We use just one byte to store the amount of free space on a page, so we
+ * divide the amount of free space a page can have into 256 different
+ * categories. The highest category, 255, represents a page with at least
+ * MaxFSMRequestSize bytes of free space, and the second highest category
+ * represents the range from 254 * FSM_CAT_STEP, inclusive, to
+ * MaxFSMRequestSize, exclusive.
*
- * The file format is:
- * label "FSM\0"
- * endian constant 0x01020304 for detecting endianness problems
- * version#
- * numRels
- * -- for each rel, in *reverse* usage order:
- * relfilenode
- * isIndex
- * avgRequest
- * interestingPages
- * storedPages
- * arena data array of storedPages FSMPageData or IndexFSMPageData
- *----------
+ * MaxFSMRequestSize depends on the architecture and BLCKSZ, but assuming
+ * default 8k BLCKSZ, and that MaxFSMRequestSize is 24 bytes, the categories
+ * look like this
+ *
+ *
+ * Range Category
+ * 0 - 31 0
+ * 32 - 63 1
+ * ... ... ...
+ * 8096 - 8127 253
+ * 8128 - 8163 254
+ * 8164 - 8192 255
+ *
+ * The reason that MaxFSMRequestSize is special is that if MaxFSMRequestSize
+ * isn't equal to a range boundary, a page with exactly MaxFSMRequestSize
+ * bytes of free space wouldn't satisfy a request for MaxFSMRequestSize
+ * bytes. If there isn't more than MaxFSMRequestSize bytes of free space on a
+ * completely empty page, that would mean that we could never satisfy a
+ * request of exactly MaxFSMRequestSize bytes.
*/
-
-/* Name of FSM cache file (relative to $PGDATA) */
-#define FSM_CACHE_FILENAME "global/pg_fsm.cache"
-
-/* Fixed values in header */
-#define FSM_CACHE_LABEL "FSM"
-#define FSM_CACHE_ENDIAN 0x01020304
-#define FSM_CACHE_VERSION 20030305
-
-/* File header layout */
-typedef struct FsmCacheFileHeader
-{
- char label[4];
- uint32 endian;
- uint32 version;
- int32 numRels;
-} FsmCacheFileHeader;
-
-/* Per-relation header */
-typedef struct FsmCacheRelHeader
-{
- RelFileNode key; /* hash key (must be first) */
- bool isIndex; /* if true, we store only page numbers */
- uint32 avgRequest; /* moving average of space requests */
- BlockNumber interestingPages; /* # of pages with useful free space */
- int32 storedPages; /* # of pages stored in arena */
-} FsmCacheRelHeader;
-
-int MaxFSMRelations; /* these are set by guc.c */
-int MaxFSMPages;
-
-static FSMHeader *FreeSpaceMap; /* points to FSMHeader in shared memory */
-static HTAB *FreeSpaceMapRelHash; /* points to (what used to be)
- * FSMHeader->relHash */
-
-
-static void CheckFreeSpaceMapStatistics(int elevel, int numRels,
- double needed);
-static FSMRelation *lookup_fsm_rel(RelFileNode *rel);
-static FSMRelation *create_fsm_rel(RelFileNode *rel);
-static void delete_fsm_rel(FSMRelation *fsmrel);
-static int realloc_fsm_rel(FSMRelation *fsmrel, BlockNumber interestingPages,
- bool isIndex);
-static void link_fsm_rel_usage(FSMRelation *fsmrel);
-static void unlink_fsm_rel_usage(FSMRelation *fsmrel);
-static void link_fsm_rel_storage(FSMRelation *fsmrel);
-static void unlink_fsm_rel_storage(FSMRelation *fsmrel);
-static BlockNumber find_free_space(FSMRelation *fsmrel, Size spaceNeeded);
-static BlockNumber find_index_free_space(FSMRelation *fsmrel);
-static void fsm_record_free_space(FSMRelation *fsmrel, BlockNumber page,
- Size spaceAvail);
-static bool lookup_fsm_page_entry(FSMRelation *fsmrel, BlockNumber page,
- int *outPageIndex);
-static void compact_fsm_storage(void);
-static void push_fsm_rels_after(FSMRelation *afterRel);
-static void pack_incoming_pages(FSMPageData *newLocation, int newPages,
- FSMPageData *pageSpaces, int nPages);
-static void pack_existing_pages(FSMPageData *newLocation, int newPages,
- FSMPageData *oldLocation, int oldPages);
-static int fsm_calc_request(FSMRelation *fsmrel);
-static int fsm_calc_request_unclamped(FSMRelation *fsmrel);
-static int fsm_calc_target_allocation(int myRequest);
-static int fsm_current_chunks(FSMRelation *fsmrel);
-static int fsm_current_allocation(FSMRelation *fsmrel);
-
+#define FSM_CATEGORIES 256
+#define FSM_CAT_STEP (BLCKSZ / FSM_CATEGORIES)
+#define MaxFSMRequestSize MaxHeapTupleSize
/*
- * Exported routines
+ * Depth of the on-disk tree. We need to be able to address 2^32-1 blocks,
+ * and 1626 is the smallest number that satisfies X^3 >= 2^32-1. Likewise,
+ * 216 is the smallest number that satisfies X^4 >= 2^32-1. In practice,
+ * this means that 4096 bytes is the smallest BLCKSZ that we can get away
+ * with a 3-level tree, and 512 is the smallest we support.
*/
+#define FSM_TREE_DEPTH ((SlotsPerFSMPage >= 1626) ? 3 : 4)
+#define FSM_ROOT_LEVEL (FSM_TREE_DEPTH - 1)
+#define FSM_BOTTOM_LEVEL 0
/*
- * InitFreeSpaceMap -- Initialize the freespace module.
- *
- * This must be called once during shared memory initialization.
- * It builds the empty free space map table. FreeSpaceLock must also be
- * initialized at some point, but is not touched here --- we assume there is
- * no need for locking, since only the calling process can be accessing shared
- * memory as yet.
+ * The internal FSM routines work on a logical addressing scheme. Each
+ * level of the tree can be thought of as a separately addressable file.
*/
-void
-InitFreeSpaceMap(void)
+typedef struct
{
- HASHCTL info;
- int nchunks;
- bool found;
-
- /* Create table header */
- FreeSpaceMap = (FSMHeader *) ShmemInitStruct("Free Space Map Header",
- sizeof(FSMHeader),
- &found);
- if (FreeSpaceMap == NULL)
- ereport(FATAL,
- (errcode(ERRCODE_OUT_OF_MEMORY),
- errmsg("insufficient shared memory for free space map")));
- if (!found)
- MemSet(FreeSpaceMap, 0, sizeof(FSMHeader));
-
- /* Create hashtable for FSMRelations */
- info.keysize = sizeof(RelFileNode);
- info.entrysize = sizeof(FSMRelation);
- info.hash = tag_hash;
-
- FreeSpaceMapRelHash = ShmemInitHash("Free Space Map Hash",
- MaxFSMRelations + 1,
- MaxFSMRelations + 1,
- &info,
- (HASH_ELEM | HASH_FUNCTION));
-
- if (!FreeSpaceMapRelHash)
- ereport(FATAL,
- (errcode(ERRCODE_OUT_OF_MEMORY),
- errmsg("insufficient shared memory for free space map")));
-
- if (found)
- return;
-
-
- /* Allocate page-storage arena */
- nchunks = (MaxFSMPages - 1) / CHUNKPAGES + 1;
- /* This check ensures spareChunks will be greater than zero */
- if (nchunks <= MaxFSMRelations)
- ereport(FATAL,
- (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("max_fsm_pages must exceed max_fsm_relations * %d",
- CHUNKPAGES)));
-
- FreeSpaceMap->arena = (char *) ShmemAlloc((Size) nchunks * CHUNKBYTES);
- if (FreeSpaceMap->arena == NULL)
- ereport(FATAL,
- (errcode(ERRCODE_OUT_OF_MEMORY),
- errmsg("insufficient shared memory for free space map")));
-
- FreeSpaceMap->totalChunks = nchunks;
- FreeSpaceMap->usedChunks = 0;
- FreeSpaceMap->sumRequests = 0;
-}
+ int level; /* level */
+ int logpageno; /* page number within the level */
+} FSMAddress;
-/*
- * Estimate amount of shmem space needed for FSM.
- */
-Size
-FreeSpaceShmemSize(void)
+/* Address of the root page. */
+static const FSMAddress FSM_ROOT_ADDRESS = { FSM_ROOT_LEVEL, 0 };
+
+/* XLOG record types */
+#define XLOG_FSM_TRUNCATE 0x00 /* truncate */
+
+typedef struct
{
- Size size;
- int nchunks;
+ RelFileNode node; /* truncated relation */
+ BlockNumber nheapblocks; /* new number of blocks in the heap */
+} xl_fsm_truncate;
- /* table header */
- size = MAXALIGN(sizeof(FSMHeader));
+/* functions to navigate the tree */
+static FSMAddress fsm_get_child(FSMAddress parent, uint16 slot);
+static FSMAddress fsm_get_parent(FSMAddress child, uint16 *slot);
+static FSMAddress fsm_get_location(BlockNumber heapblk, uint16 *slot);
+static BlockNumber fsm_get_heap_blk(FSMAddress addr, uint16 slot);
+static BlockNumber fsm_logical_to_physical(FSMAddress addr);
- /* hash table, including the FSMRelation objects */
- size = add_size(size, hash_estimate_size(MaxFSMRelations + 1,
- sizeof(FSMRelation)));
+static Buffer fsm_readbuf(Relation rel, FSMAddress addr, bool extend);
+static void fsm_extend(Relation rel, BlockNumber nfsmblocks);
- /* page-storage arena */
- nchunks = (MaxFSMPages - 1) / CHUNKPAGES + 1;
- size = add_size(size, mul_size(nchunks, CHUNKBYTES));
+/* functions to convert amount of free space to a FSM category */
+static uint8 fsm_space_avail_to_cat(Size avail);
+static uint8 fsm_space_needed_to_cat(Size needed);
+static Size fsm_space_cat_to_avail(uint8 cat);
+
+/* workhorse functions for various operations */
+static int fsm_set_and_search(Relation rel, FSMAddress addr, uint16 slot,
+ uint8 newValue, uint8 minValue);
+static BlockNumber fsm_search(Relation rel, uint8 min_cat);
+static uint8 fsm_vacuum_page(Relation rel, FSMAddress addr, bool *eof);
- return size;
-}
+
+/******** Public API ********/
/*
* GetPageWithFreeSpace - try to find a page in the given relation with
* extend the relation.
*/
BlockNumber
-GetPageWithFreeSpace(RelFileNode *rel, Size spaceNeeded)
+GetPageWithFreeSpace(Relation rel, Size spaceNeeded)
{
- FSMRelation *fsmrel;
- BlockNumber freepage;
-
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
-
- /*
- * We always add a rel to the hashtable when it is inquired about.
- */
- fsmrel = create_fsm_rel(rel);
-
- /*
- * Update the moving average of space requests. This code implements an
- * exponential moving average with an equivalent period of about 63
- * requests. Ignore silly requests, however, to ensure that the average
- * stays sane.
- */
- if (spaceNeeded > 0 && spaceNeeded < BLCKSZ)
- {
- int cur_avg = (int) fsmrel->avgRequest;
-
- cur_avg += ((int) spaceNeeded - cur_avg) / 32;
- fsmrel->avgRequest = (Size) cur_avg;
- }
- freepage = find_free_space(fsmrel, spaceNeeded);
- LWLockRelease(FreeSpaceLock);
- return freepage;
+ uint8 min_cat = fsm_space_needed_to_cat(spaceNeeded);
+ return fsm_search(rel, min_cat);
}
/*
* RecordAndGetPageWithFreeSpace - update info about a page and try again.
*
- * We provide this combo form, instead of a separate Record operation,
- * to save one lock and hash table lookup cycle.
+ * We provide this combo form to save some locking overhead, compared to
+ * separate RecordPageWithFreeSpace + GetPageWithFreeSpace calls. There's
+ * also some effort to return a page close to the old page; if there's a
+ * page with enough free space on the same FSM page where the old one page
+ * is located, it is preferred.
*/
BlockNumber
-RecordAndGetPageWithFreeSpace(RelFileNode *rel,
- BlockNumber oldPage,
- Size oldSpaceAvail,
- Size spaceNeeded)
+RecordAndGetPageWithFreeSpace(Relation rel, BlockNumber oldPage,
+ Size oldSpaceAvail, Size spaceNeeded)
{
- FSMRelation *fsmrel;
- BlockNumber freepage;
+ int old_cat = fsm_space_avail_to_cat(oldSpaceAvail);
+ int search_cat = fsm_space_needed_to_cat(spaceNeeded);
+ FSMAddress addr;
+ uint16 slot;
+ int search_slot;
- /* Sanity check: ensure spaceAvail will fit into OffsetNumber */
- AssertArg(oldSpaceAvail < BLCKSZ);
+ /* Get the location of the FSM byte representing the heap block */
+ addr = fsm_get_location(oldPage, &slot);
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
+ search_slot = fsm_set_and_search(rel, addr, slot, old_cat, search_cat);
/*
- * We always add a rel to the hashtable when it is inquired about.
+ * If fsm_set_and_search found a suitable new block, return that.
+ * Otherwise, search as usual.
*/
- fsmrel = create_fsm_rel(rel);
-
- /* Do the Record */
- fsm_record_free_space(fsmrel, oldPage, oldSpaceAvail);
-
- /*
- * Update the moving average of space requests, same as in
- * GetPageWithFreeSpace.
- */
- if (spaceNeeded > 0 && spaceNeeded < BLCKSZ)
- {
- int cur_avg = (int) fsmrel->avgRequest;
-
- cur_avg += ((int) spaceNeeded - cur_avg) / 32;
- fsmrel->avgRequest = (Size) cur_avg;
- }
- /* Do the Get */
- freepage = find_free_space(fsmrel, spaceNeeded);
- LWLockRelease(FreeSpaceLock);
- return freepage;
-}
-
-/*
- * GetAvgFSMRequestSize - get average FSM request size for a relation.
- *
- * If the relation is not known to FSM, return a default value.
- */
-Size
-GetAvgFSMRequestSize(RelFileNode *rel)
-{
- Size result;
- FSMRelation *fsmrel;
-
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
- fsmrel = lookup_fsm_rel(rel);
- if (fsmrel)
- result = fsmrel->avgRequest;
+ if (search_slot != -1)
+ return fsm_get_heap_blk(addr, search_slot);
else
- result = INITIAL_AVERAGE;
- LWLockRelease(FreeSpaceLock);
- return result;
+ return fsm_search(rel, search_cat);
}
/*
- * RecordRelationFreeSpace - record available-space info about a relation.
- *
- * Any pre-existing info about the relation is assumed obsolete and discarded.
- *
- * interestingPages is the total number of pages in the relation that have
- * at least threshold free space; nPages is the number actually reported in
- * pageSpaces[] (may be less --- in particular, callers typically clamp their
- * space usage to MaxFSMPages).
+ * RecordPageWithFreeSpace - update info about a page.
*
- * The given pageSpaces[] array must be sorted in order by blkno. Note that
- * the FSM is at liberty to discard some or all of the data.
+ * Note that if the new spaceAvail value is higher than the old value stored
+ * in the FSM, the space might not become visible to searchers until the next
+ * FreeSpaceMapVacuum call, which updates the upper level pages.
*/
void
-RecordRelationFreeSpace(RelFileNode *rel,
- BlockNumber interestingPages,
- int nPages,
- FSMPageData *pageSpaces)
+RecordPageWithFreeSpace(Relation rel, BlockNumber heapBlk, Size spaceAvail)
{
- FSMRelation *fsmrel;
+ int new_cat = fsm_space_avail_to_cat(spaceAvail);
+ FSMAddress addr;
+ uint16 slot;
- /* Limit nPages to something sane */
- if (nPages < 0)
- nPages = 0;
- else if (nPages > MaxFSMPages)
- nPages = MaxFSMPages;
+ /* Get the location of the FSM byte representing the heap block */
+ addr = fsm_get_location(heapBlk, &slot);
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
-
- /*
- * Note we don't record info about a relation unless there's already an
- * FSM entry for it, implying someone has done GetPageWithFreeSpace for
- * it. Inactive rels thus will not clutter the map simply by being
- * vacuumed.
- */
- fsmrel = lookup_fsm_rel(rel);
- if (fsmrel)
- {
- int curAlloc;
- int curAllocPages;
- FSMPageData *newLocation;
-
- curAlloc = realloc_fsm_rel(fsmrel, interestingPages, false);
- curAllocPages = curAlloc * CHUNKPAGES;
-
- /*
- * If the data fits in our current allocation, just copy it; otherwise
- * must compress.
- */
- newLocation = (FSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- if (nPages <= curAllocPages)
- {
- int i;
-
- for (i = 0; i < nPages; i++)
- {
- BlockNumber page = FSMPageGetPageNum(&pageSpaces[i]);
-
- /* Check caller provides sorted data */
- if (i > 0 && page <= FSMPageGetPageNum(&pageSpaces[i - 1]))
- elog(ERROR, "free-space data is not in page order");
- *newLocation = pageSpaces[i];
- newLocation++;
- }
- fsmrel->storedPages = nPages;
- }
- else
- {
- pack_incoming_pages(newLocation, curAllocPages,
- pageSpaces, nPages);
- fsmrel->storedPages = curAllocPages;
- }
- }
- LWLockRelease(FreeSpaceLock);
+ fsm_set_and_search(rel, addr, slot, new_cat, 0);
}
/*
- * GetFreeIndexPage - like GetPageWithFreeSpace, but for indexes
+ * GetRecordedFreePage - return the amount of free space on a particular page,
+ * according to the FSM.
*/
-BlockNumber
-GetFreeIndexPage(RelFileNode *rel)
+Size
+GetRecordedFreeSpace(Relation rel, BlockNumber heapBlk)
{
- FSMRelation *fsmrel;
- BlockNumber freepage;
+ FSMAddress addr;
+ uint16 slot;
+ Buffer buf;
+ uint8 cat;
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
+ /* Get the location of the FSM byte representing the heap block */
+ addr = fsm_get_location(heapBlk, &slot);
- /*
- * We always add a rel to the hashtable when it is inquired about.
- */
- fsmrel = create_fsm_rel(rel);
+ buf = fsm_readbuf(rel, addr, false);
+ if (!BufferIsValid(buf))
+ return 0;
+ cat = fsm_get_avail(BufferGetPage(buf), slot);
+ ReleaseBuffer(buf);
- freepage = find_index_free_space(fsmrel);
- LWLockRelease(FreeSpaceLock);
- return freepage;
+ return fsm_space_cat_to_avail(cat);
}
/*
- * RecordIndexFreeSpace - like RecordRelationFreeSpace, but for indexes
+ * FreeSpaceMapTruncateRel - adjust for truncation of a relation.
+ *
+ * The caller must hold AccessExclusiveLock on the relation, to ensure
+ * that other backends receive the relcache invalidation event that this
+ * function sends, before accessing the FSM again.
+ *
+ * nblocks is the new size of the heap.
*/
void
-RecordIndexFreeSpace(RelFileNode *rel,
- BlockNumber interestingPages,
- int nPages,
- BlockNumber *pages)
+FreeSpaceMapTruncateRel(Relation rel, BlockNumber nblocks)
{
- FSMRelation *fsmrel;
+ BlockNumber new_nfsmblocks;
+ FSMAddress first_removed_address;
+ uint16 first_removed_slot;
+ Buffer buf;
- /* Limit nPages to something sane */
- if (nPages < 0)
- nPages = 0;
- else if (nPages > MaxFSMPages)
- nPages = MaxFSMPages;
+ RelationOpenSmgr(rel);
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
+ /* Get the location in the FSM of the first removed heap block */
+ first_removed_address = fsm_get_location(nblocks, &first_removed_slot);
/*
- * Note we don't record info about a relation unless there's already an
- * FSM entry for it, implying someone has done GetFreeIndexPage for it.
- * Inactive rels thus will not clutter the map simply by being vacuumed.
+ * Zero out the tail of the last remaining FSM page. If the slot
+ * representing the first removed heap block is at a page boundary, as
+ * the first slot on the FSM page that first_removed_address points to,
+ * we can just truncate that page altogether.
*/
- fsmrel = lookup_fsm_rel(rel);
- if (fsmrel)
+ if (first_removed_slot > 0)
{
- int curAlloc;
- int curAllocPages;
- int i;
- IndexFSMPageData *newLocation;
+ buf = fsm_readbuf(rel, first_removed_address, false);
+ if (!BufferIsValid(buf))
+ return; /* nothing to do; the FSM was already smaller */
+ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+ fsm_truncate_avail(BufferGetPage(buf), first_removed_slot);
+ MarkBufferDirty(buf);
+ UnlockReleaseBuffer(buf);
- curAlloc = realloc_fsm_rel(fsmrel, interestingPages, true);
- curAllocPages = curAlloc * INDEXCHUNKPAGES;
+ new_nfsmblocks = fsm_logical_to_physical(first_removed_address) + 1;
+ }
+ else
+ {
+ new_nfsmblocks = fsm_logical_to_physical(first_removed_address);
+ if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM) <= new_nfsmblocks)
+ return; /* nothing to do; the FSM was already smaller */
+ }
- /*
- * If the data fits in our current allocation, just copy it; otherwise
- * must compress. But compression is easy: we merely forget extra
- * pages.
- */
- newLocation = (IndexFSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- if (nPages > curAllocPages)
- nPages = curAllocPages;
+ /* Truncate the unused FSM pages */
+ smgrtruncate(rel->rd_smgr, FSM_FORKNUM, new_nfsmblocks, rel->rd_istemp);
- for (i = 0; i < nPages; i++)
- {
- BlockNumber page = pages[i];
+ /*
+ * FSM truncations are WAL-logged, because we must never return a block
+ * that doesn't exist in the heap, not even if we crash before the FSM
+ * truncation has made it to disk. smgrtruncate() writes its own WAL
+ * record, but that's not enough to zero out the last remaining FSM page.
+ * (if we didn't need to zero out anything above, we can skip this)
+ */
+ if (!rel->rd_istemp && !InRecovery && first_removed_slot != 0)
+ {
+ xl_fsm_truncate xlrec;
+ XLogRecData rdata;
+ XLogRecPtr recptr;
- /* Check caller provides sorted data */
- if (i > 0 && page <= pages[i - 1])
- elog(ERROR, "free-space data is not in page order");
- IndexFSMPageSetPageNum(newLocation, page);
- newLocation++;
- }
- fsmrel->storedPages = nPages;
- }
- LWLockRelease(FreeSpaceLock);
-}
+ xlrec.node = rel->rd_node;
+ xlrec.nheapblocks = nblocks;
-/*
- * FreeSpaceMapTruncateRel - adjust for truncation of a relation.
- *
- * We need to delete any stored data past the new relation length, so that
- * we don't bogusly return removed block numbers.
- */
-void
-FreeSpaceMapTruncateRel(RelFileNode *rel, BlockNumber nblocks)
-{
- FSMRelation *fsmrel;
+ rdata.data = (char *) &xlrec;
+ rdata.len = sizeof(xl_fsm_truncate);
+ rdata.buffer = InvalidBuffer;
+ rdata.next = NULL;
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
- fsmrel = lookup_fsm_rel(rel);
- if (fsmrel)
- {
- int pageIndex;
+ recptr = XLogInsert(RM_FREESPACE_ID, XLOG_FSM_TRUNCATE, &rdata);
- /* Use lookup to locate first entry >= nblocks */
- (void) lookup_fsm_page_entry(fsmrel, nblocks, &pageIndex);
- /* Delete all such entries */
- fsmrel->storedPages = pageIndex;
- /* XXX should we adjust rel's interestingPages and sumRequests? */
+ /*
+ * Flush, because otherwise the truncation of the main relation
+ * might hit the disk before the WAL record of truncating the
+ * FSM is flushed. If we crashed during that window, we'd be
+ * left with a truncated heap, without a truncated FSM.
+ */
+ XLogFlush(recptr);
}
- LWLockRelease(FreeSpaceLock);
+
+ /*
+ * Need to invalidate the relcache entry, because rd_fsm_nblocks_cache
+ * seen by other backends is no longer valid.
+ */
+ if (!InRecovery)
+ CacheInvalidateRelcache(rel);
+ rel->rd_fsm_nblocks_cache = new_nfsmblocks;
}
/*
- * FreeSpaceMapForgetRel - forget all about a relation.
- *
- * This is called when a relation is deleted. Although we could just let
- * the rel age out of the map, it's better to reclaim and reuse the space
- * sooner.
+ * FreeSpaceMapVacuum - scan and fix any inconsistencies in the FSM
*/
void
-FreeSpaceMapForgetRel(RelFileNode *rel)
+FreeSpaceMapVacuum(Relation rel)
{
- FSMRelation *fsmrel;
+ bool dummy;
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
- fsmrel = lookup_fsm_rel(rel);
- if (fsmrel)
- delete_fsm_rel(fsmrel);
- LWLockRelease(FreeSpaceLock);
+ /*
+ * Traverse the tree in depth-first order. The tree is stored physically
+ * in depth-first order, so this should be pretty I/O efficient.
+ */
+ fsm_vacuum_page(rel, FSM_ROOT_ADDRESS, &dummy);
}
+/******** Internal routines ********/
+
/*
- * FreeSpaceMapForgetDatabase - forget all relations of a database.
- *
- * This is called during DROP DATABASE. As above, might as well reclaim
- * map space sooner instead of later.
+ * Return category corresponding x bytes of free space
*/
-void
-FreeSpaceMapForgetDatabase(Oid dbid)
+static uint8
+fsm_space_avail_to_cat(Size avail)
{
- FSMRelation *fsmrel,
- *nextrel;
+ int cat;
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
- for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = nextrel)
- {
- nextrel = fsmrel->nextUsage; /* in case we delete it */
- if (fsmrel->key.dbNode == dbid)
- delete_fsm_rel(fsmrel);
- }
- LWLockRelease(FreeSpaceLock);
-}
+ Assert(avail < BLCKSZ);
-/*
- * PrintFreeSpaceMapStatistics - print statistics about FSM contents
- *
- * The info is sent to ereport() with the specified message level. This is
- * intended for use during VACUUM.
- */
-void
-PrintFreeSpaceMapStatistics(int elevel)
-{
- FSMRelation *fsmrel;
- int storedPages = 0;
- double sumRequests = 0;
- int numRels;
- double needed;
+ if (avail >= MaxFSMRequestSize)
+ return 255;
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
+ cat = avail / FSM_CAT_STEP;
/*
- * Count total space actually used, as well as the unclamped request total
+ * The highest category, 255, is reserved for MaxFSMRequestSize bytes or
+ * more.
*/
- for (fsmrel = FreeSpaceMap->firstRel;
- fsmrel != NULL;
- fsmrel = fsmrel->nextPhysical)
- {
- storedPages += fsmrel->storedPages;
- sumRequests += fsm_calc_request_unclamped(fsmrel);
- }
+ if (cat > 254)
+ cat = 254;
- /* Copy other stats before dropping lock */
- numRels = FreeSpaceMap->numRels;
- LWLockRelease(FreeSpaceLock);
-
- /* Convert stats to actual number of page slots needed */
- needed = (sumRequests + numRels) * CHUNKPAGES;
-
- ereport(elevel,
- (errmsg("free space map contains %d pages in %d relations",
- storedPages, numRels),
- errdetail("A total of %.0f page slots are in use (including overhead).\n"
- "%.0f page slots are required to track all free space.\n"
- "Current limits are: %d page slots, %d relations, using %.0f kB.",
- Min(needed, MaxFSMPages),
- needed,
- MaxFSMPages, MaxFSMRelations,
- (double) FreeSpaceShmemSize() / 1024.0)));
-
- CheckFreeSpaceMapStatistics(NOTICE, numRels, needed);
- /* Print to server logs too because is deals with a config variable. */
- CheckFreeSpaceMapStatistics(LOG, numRels, needed);
+ return (uint8) cat;
}
-static void
-CheckFreeSpaceMapStatistics(int elevel, int numRels, double needed)
+/*
+ * Return the lower bound of the range of free space represented by given
+ * category.
+ */
+static Size
+fsm_space_cat_to_avail(uint8 cat)
{
- if (numRels == MaxFSMRelations)
- ereport(elevel,
- (errmsg("max_fsm_relations(%d) equals the number of relations checked",
- MaxFSMRelations),
- errhint("You have at least %d relations. "
- "Consider increasing the configuration parameter \"max_fsm_relations\".",
- numRels)));
- else if (needed > MaxFSMPages)
- ereport(elevel,
- (errmsg("number of page slots needed (%.0f) exceeds max_fsm_pages (%d)",
- needed, MaxFSMPages),
- errhint("Consider increasing the configuration parameter \"max_fsm_pages\" "
- "to a value over %.0f.", needed)));
+ /* The highest category represents exactly MaxFSMRequestSize bytes. */
+ if (cat == 255)
+ return MaxFSMRequestSize;
+ else
+ return cat * FSM_CAT_STEP;
}
/*
- * DumpFreeSpaceMap - dump contents of FSM into a disk file for later reload
- *
- * This is expected to be called during database shutdown, after updates to
- * the FSM have stopped. We lock the FreeSpaceLock but that's purely pro
- * forma --- if anyone else is still accessing FSM, there's a problem.
+ * Which category does a page need to have, to accommodate x bytes of data?
+ * While fsm_size_to_avail_cat() rounds down, this needs to round up.
*/
-void
-DumpFreeSpaceMap(int code, Datum arg)
+static uint8
+fsm_space_needed_to_cat(Size needed)
{
- FILE *fp;
- FsmCacheFileHeader header;
- FSMRelation *fsmrel;
-
- /* Try to create file */
- unlink(FSM_CACHE_FILENAME); /* in case it exists w/wrong permissions */
-
- fp = AllocateFile(FSM_CACHE_FILENAME, PG_BINARY_W);
- if (fp == NULL)
- {
- elog(LOG, "could not write \"%s\": %m", FSM_CACHE_FILENAME);
- return;
- }
-
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
-
- /* Write file header */
- MemSet(&header, 0, sizeof(header));
- strcpy(header.label, FSM_CACHE_LABEL);
- header.endian = FSM_CACHE_ENDIAN;
- header.version = FSM_CACHE_VERSION;
- header.numRels = FreeSpaceMap->numRels;
- if (fwrite(&header, 1, sizeof(header), fp) != sizeof(header))
- goto write_failed;
-
- /* For each relation, in order from least to most recently used... */
- for (fsmrel = FreeSpaceMap->usageListTail;
- fsmrel != NULL;
- fsmrel = fsmrel->priorUsage)
- {
- FsmCacheRelHeader relheader;
- int nPages;
-
- /* Write relation header */
- MemSet(&relheader, 0, sizeof(relheader));
- relheader.key = fsmrel->key;
- relheader.isIndex = fsmrel->isIndex;
- relheader.avgRequest = fsmrel->avgRequest;
- relheader.interestingPages = fsmrel->interestingPages;
- relheader.storedPages = fsmrel->storedPages;
- if (fwrite(&relheader, 1, sizeof(relheader), fp) != sizeof(relheader))
- goto write_failed;
-
- /* Write the per-page data directly from the arena */
- nPages = fsmrel->storedPages;
- if (nPages > 0)
- {
- Size len;
- char *data;
-
- if (fsmrel->isIndex)
- len = nPages * sizeof(IndexFSMPageData);
- else
- len = nPages * sizeof(FSMPageData);
- data = (char *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- if (fwrite(data, 1, len, fp) != len)
- goto write_failed;
- }
- }
-
- /* Clean up */
- LWLockRelease(FreeSpaceLock);
-
- if (FreeFile(fp))
- {
- elog(LOG, "could not write \"%s\": %m", FSM_CACHE_FILENAME);
- /* Remove busted cache file */
- unlink(FSM_CACHE_FILENAME);
- }
+ int cat;
- return;
+ /* Can't ask for more space than the highest category represents */
+ if (needed > MaxFSMRequestSize)
+ elog(ERROR, "invalid FSM request size %d", needed);
-write_failed:
- elog(LOG, "could not write \"%s\": %m", FSM_CACHE_FILENAME);
+ if (needed == 0)
+ return 1;
- /* Clean up */
- LWLockRelease(FreeSpaceLock);
+ cat = (needed + FSM_CAT_STEP - 1) / FSM_CAT_STEP;
- FreeFile(fp);
+ if (cat > 255)
+ cat = 255;
- /* Remove busted cache file */
- unlink(FSM_CACHE_FILENAME);
+ return (uint8) cat;
}
/*
- * LoadFreeSpaceMap - load contents of FSM from a disk file
- *
- * This is expected to be called during database startup, before any FSM
- * updates begin. We lock the FreeSpaceLock but that's purely pro
- * forma --- if anyone else is accessing FSM yet, there's a problem.
- *
- * Notes: no complaint is issued if no cache file is found. If the file is
- * found, it is deleted after reading. Thus, if we crash without a clean
- * shutdown, the next cycle of life starts with no FSM data. To do otherwise,
- * we'd need to do significantly more validation in this routine, because of
- * the likelihood that what is in the dump file would be out-of-date, eg
- * there might be entries for deleted or truncated rels.
+ * Returns the physical block number an FSM page
*/
-void
-LoadFreeSpaceMap(void)
+static BlockNumber
+fsm_logical_to_physical(FSMAddress addr)
{
- FILE *fp;
- FsmCacheFileHeader header;
- int relno;
-
- /* Try to open file */
- fp = AllocateFile(FSM_CACHE_FILENAME, PG_BINARY_R);
- if (fp == NULL)
- {
- if (errno != ENOENT)
- elog(LOG, "could not read \"%s\": %m", FSM_CACHE_FILENAME);
- return;
- }
+ BlockNumber pages;
+ int leafno;
+ int l;
- LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE);
+ /*
+ * Calculate the logical page number of the first leaf page below the
+ * given page.
+ */
+ leafno = addr.logpageno;
+ for (l = 0; l < addr.level; l++)
+ leafno *= SlotsPerFSMPage;
- /* Read and verify file header */
- if (fread(&header, 1, sizeof(header), fp) != sizeof(header) ||
- strcmp(header.label, FSM_CACHE_LABEL) != 0 ||
- header.endian != FSM_CACHE_ENDIAN ||
- header.version != FSM_CACHE_VERSION ||
- header.numRels < 0)
+ /* Count upper level nodes required to address the leaf page */
+ pages = 0;
+ for (l = 0; l < FSM_TREE_DEPTH; l++)
{
- elog(LOG, "bogus file header in \"%s\"", FSM_CACHE_FILENAME);
- goto read_failed;
+ pages += leafno + 1;
+ leafno /= SlotsPerFSMPage;
}
- /* For each relation, in order from least to most recently used... */
- for (relno = 0; relno < header.numRels; relno++)
- {
- FsmCacheRelHeader relheader;
- Size len;
- char *data;
- FSMRelation *fsmrel;
- int nPages;
- int curAlloc;
- int curAllocPages;
-
- /* Read and verify relation header, as best we can */
- if (fread(&relheader, 1, sizeof(relheader), fp) != sizeof(relheader) ||
- (relheader.isIndex != false && relheader.isIndex != true) ||
- relheader.avgRequest >= BLCKSZ ||
- relheader.storedPages < 0)
- {
- elog(LOG, "bogus rel header in \"%s\"", FSM_CACHE_FILENAME);
- goto read_failed;
- }
-
- /* Read the per-page data */
- nPages = relheader.storedPages;
- if (relheader.isIndex)
- len = nPages * sizeof(IndexFSMPageData);
- else
- len = nPages * sizeof(FSMPageData);
- data = (char *) palloc(len);
- if (fread(data, 1, len, fp) != len)
- {
- elog(LOG, "premature EOF in \"%s\"", FSM_CACHE_FILENAME);
- pfree(data);
- goto read_failed;
- }
-
- /*
- * Okay, create the FSM entry and insert data into it. Since the rels
- * were stored in reverse usage order, at the end of the loop they
- * will be correctly usage-ordered in memory; and if MaxFSMRelations
- * is less than it used to be, we will correctly drop the least
- * recently used ones.
- */
- fsmrel = create_fsm_rel(&relheader.key);
- fsmrel->avgRequest = relheader.avgRequest;
-
- curAlloc = realloc_fsm_rel(fsmrel, relheader.interestingPages,
- relheader.isIndex);
- if (relheader.isIndex)
- {
- IndexFSMPageData *newLocation;
-
- curAllocPages = curAlloc * INDEXCHUNKPAGES;
-
- /*
- * If the data fits in our current allocation, just copy it;
- * otherwise must compress. But compression is easy: we merely
- * forget extra pages.
- */
- newLocation = (IndexFSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- if (nPages > curAllocPages)
- nPages = curAllocPages;
- memcpy(newLocation, data, nPages * sizeof(IndexFSMPageData));
- fsmrel->storedPages = nPages;
- }
- else
- {
- FSMPageData *newLocation;
-
- curAllocPages = curAlloc * CHUNKPAGES;
-
- /*
- * If the data fits in our current allocation, just copy it;
- * otherwise must compress.
- */
- newLocation = (FSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- if (nPages <= curAllocPages)
- {
- memcpy(newLocation, data, nPages * sizeof(FSMPageData));
- fsmrel->storedPages = nPages;
- }
- else
- {
- pack_existing_pages(newLocation, curAllocPages,
- (FSMPageData *) data, nPages);
- fsmrel->storedPages = curAllocPages;
- }
- }
-
- pfree(data);
- }
-
-read_failed:
-
- /* Clean up */
- LWLockRelease(FreeSpaceLock);
-
- FreeFile(fp);
+ /*
+ * If the page we were asked for wasn't at the bottom level, subtract
+ * the additional lower level pages we counted above.
+ */
+ pages -= addr.level;
- /* Remove cache file before it can become stale; see notes above */
- unlink(FSM_CACHE_FILENAME);
+ /* Turn the page count into 0-based block number */
+ return pages - 1;
}
-
-/*
- * Internal routines. These all assume the caller holds the FreeSpaceLock.
- */
-
/*
- * Lookup a relation in the hash table. If not present, return NULL.
- *
- * The relation's position in the LRU list is not changed.
+ * Return the FSM location corresponding to given heap block.
*/
-static FSMRelation *
-lookup_fsm_rel(RelFileNode *rel)
+static FSMAddress
+fsm_get_location(BlockNumber heapblk, uint16 *slot)
{
- FSMRelation *fsmrel;
+ FSMAddress addr;
- fsmrel = (FSMRelation *) hash_search(FreeSpaceMapRelHash,
- (void *) rel,
- HASH_FIND,
- NULL);
- if (!fsmrel)
- return NULL;
+ addr.level = FSM_BOTTOM_LEVEL;
+ addr.logpageno = heapblk / SlotsPerFSMPage;
+ *slot = heapblk % SlotsPerFSMPage;
- return fsmrel;
+ return addr;
}
/*
- * Lookup a relation in the hash table, creating an entry if not present.
- *
- * On successful lookup, the relation is moved to the front of the LRU list.
+ * Return the heap block number corresponding to given location in the FSM.
*/
-static FSMRelation *
-create_fsm_rel(RelFileNode *rel)
+static BlockNumber
+fsm_get_heap_blk(FSMAddress addr, uint16 slot)
{
- FSMRelation *fsmrel;
- bool found;
-
- fsmrel = (FSMRelation *) hash_search(FreeSpaceMapRelHash,
- (void *) rel,
- HASH_ENTER,
- &found);
-
- if (!found)
- {
- /* New hashtable entry, initialize it (hash_search set the key) */
- fsmrel->isIndex = false; /* until we learn different */
- fsmrel->avgRequest = INITIAL_AVERAGE;
- fsmrel->interestingPages = 0;
- fsmrel->firstChunk = -1; /* no space allocated */
- fsmrel->storedPages = 0;
- fsmrel->nextPage = 0;
-
- /* Discard lowest-priority existing rel, if we are over limit */
- if (FreeSpaceMap->numRels >= MaxFSMRelations)
- delete_fsm_rel(FreeSpaceMap->usageListTail);
-
- /* Add new entry at front of LRU list */
- link_fsm_rel_usage(fsmrel);
- fsmrel->nextPhysical = NULL; /* not in physical-storage list */
- fsmrel->priorPhysical = NULL;
- FreeSpaceMap->numRels++;
- /* sumRequests is unchanged because request must be zero */
- }
- else
- {
- /* Existing entry, move to front of LRU list */
- if (fsmrel->priorUsage != NULL)
- {
- unlink_fsm_rel_usage(fsmrel);
- link_fsm_rel_usage(fsmrel);
- }
- }
-
- return fsmrel;
+ Assert(addr.level == FSM_BOTTOM_LEVEL);
+ return ((unsigned int) addr.logpageno) * SlotsPerFSMPage + slot;
}
/*
- * Remove an existing FSMRelation entry.
+ * Given a logical address of a child page, get the logical page number of
+ * the parent, and the slot within the parent corresponding to the child.
*/
-static void
-delete_fsm_rel(FSMRelation *fsmrel)
+static FSMAddress
+fsm_get_parent(FSMAddress child, uint16 *slot)
{
- FSMRelation *result;
-
- FreeSpaceMap->sumRequests -= fsm_calc_request(fsmrel);
- unlink_fsm_rel_usage(fsmrel);
- unlink_fsm_rel_storage(fsmrel);
- FreeSpaceMap->numRels--;
- result = (FSMRelation *) hash_search(FreeSpaceMapRelHash,
- (void *) &(fsmrel->key),
- HASH_REMOVE,
- NULL);
- if (!result)
- elog(ERROR, "FreeSpaceMap hashtable corrupted");
-}
+ FSMAddress parent;
-/*
- * Reallocate space for a FSMRelation.
- *
- * This is shared code for RecordRelationFreeSpace and RecordIndexFreeSpace.
- * The return value is the actual new allocation, in chunks.
- */
-static int
-realloc_fsm_rel(FSMRelation *fsmrel, BlockNumber interestingPages,
- bool isIndex)
-{
- int myRequest;
- int myAlloc;
- int curAlloc;
+ Assert(child.level < FSM_ROOT_LEVEL);
- /*
- * Delete any existing entries, and update request status.
- */
- fsmrel->storedPages = 0;
- FreeSpaceMap->sumRequests -= fsm_calc_request(fsmrel);
- fsmrel->interestingPages = interestingPages;
- fsmrel->isIndex = isIndex;
- myRequest = fsm_calc_request(fsmrel);
- FreeSpaceMap->sumRequests += myRequest;
- myAlloc = fsm_calc_target_allocation(myRequest);
+ parent.level = child.level + 1;
+ parent.logpageno = child.logpageno / SlotsPerFSMPage;
+ *slot = child.logpageno % SlotsPerFSMPage;
- /*
- * Need to reallocate space if (a) my target allocation is more than my
- * current allocation, AND (b) my actual immediate need (myRequest+1
- * chunks) is more than my current allocation. Otherwise just store the
- * new data in-place.
- */
- curAlloc = fsm_current_allocation(fsmrel);
- if (myAlloc > curAlloc && (myRequest + 1) > curAlloc && interestingPages > 0)
- {
- /* Remove entry from storage list, and compact */
- unlink_fsm_rel_storage(fsmrel);
- compact_fsm_storage();
- /* Reattach to end of storage list */
- link_fsm_rel_storage(fsmrel);
- /* And allocate storage */
- fsmrel->firstChunk = FreeSpaceMap->usedChunks;
- FreeSpaceMap->usedChunks += myAlloc;
- curAlloc = myAlloc;
- /* Watch out for roundoff error */
- if (FreeSpaceMap->usedChunks > FreeSpaceMap->totalChunks)
- {
- FreeSpaceMap->usedChunks = FreeSpaceMap->totalChunks;
- curAlloc = FreeSpaceMap->totalChunks - fsmrel->firstChunk;
- }
- }
- return curAlloc;
+ return parent;
}
/*
- * Link a FSMRelation into the LRU list (always at the head).
+ * Given a logical address of a parent page, and a slot number get the
+ * logical address of the corresponding child page.
*/
-static void
-link_fsm_rel_usage(FSMRelation *fsmrel)
+static FSMAddress
+fsm_get_child(FSMAddress parent, uint16 slot)
{
- fsmrel->priorUsage = NULL;
- fsmrel->nextUsage = FreeSpaceMap->usageList;
- FreeSpaceMap->usageList = fsmrel;
- if (fsmrel->nextUsage != NULL)
- fsmrel->nextUsage->priorUsage = fsmrel;
- else
- FreeSpaceMap->usageListTail = fsmrel;
-}
+ FSMAddress child;
-/*
- * Delink a FSMRelation from the LRU list.
- */
-static void
-unlink_fsm_rel_usage(FSMRelation *fsmrel)
-{
- if (fsmrel->priorUsage != NULL)
- fsmrel->priorUsage->nextUsage = fsmrel->nextUsage;
- else
- FreeSpaceMap->usageList = fsmrel->nextUsage;
- if (fsmrel->nextUsage != NULL)
- fsmrel->nextUsage->priorUsage = fsmrel->priorUsage;
- else
- FreeSpaceMap->usageListTail = fsmrel->priorUsage;
+ Assert(parent.level > FSM_BOTTOM_LEVEL);
- /*
- * We don't bother resetting fsmrel's links, since it's about to be
- * deleted or relinked at the head.
- */
-}
+ child.level = parent.level - 1;
+ child.logpageno = parent.logpageno * SlotsPerFSMPage + slot;
-/*
- * Link a FSMRelation into the storage-order list (always at the tail).
- */
-static void
-link_fsm_rel_storage(FSMRelation *fsmrel)
-{
- fsmrel->nextPhysical = NULL;
- fsmrel->priorPhysical = FreeSpaceMap->lastRel;
- if (FreeSpaceMap->lastRel != NULL)
- FreeSpaceMap->lastRel->nextPhysical = fsmrel;
- else
- FreeSpaceMap->firstRel = fsmrel;
- FreeSpaceMap->lastRel = fsmrel;
+ return child;
}
/*
- * Delink a FSMRelation from the storage-order list, if it's in it.
+ * Read a FSM page.
+ *
+ * If the page doesn't exist, InvalidBuffer is returned, or if 'extend' is
+ * true, the FSM file is extended.
*/
-static void
-unlink_fsm_rel_storage(FSMRelation *fsmrel)
+static Buffer
+fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
{
- if (fsmrel->priorPhysical != NULL || FreeSpaceMap->firstRel == fsmrel)
+ BlockNumber blkno = fsm_logical_to_physical(addr);
+
+ RelationOpenSmgr(rel);
+
+ if (rel->rd_fsm_nblocks_cache == InvalidBlockNumber ||
+ rel->rd_fsm_nblocks_cache <= blkno)
+ rel->rd_fsm_nblocks_cache = smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+
+ if (blkno >= rel->rd_fsm_nblocks_cache)
{
- if (fsmrel->priorPhysical != NULL)
- fsmrel->priorPhysical->nextPhysical = fsmrel->nextPhysical;
+ if (extend)
+ fsm_extend(rel, blkno + 1);
else
- FreeSpaceMap->firstRel = fsmrel->nextPhysical;
- if (fsmrel->nextPhysical != NULL)
- fsmrel->nextPhysical->priorPhysical = fsmrel->priorPhysical;
- else
- FreeSpaceMap->lastRel = fsmrel->priorPhysical;
+ return InvalidBuffer;
}
- /* mark as not in list, since we may not put it back immediately */
- fsmrel->nextPhysical = NULL;
- fsmrel->priorPhysical = NULL;
- /* Also mark it as having no storage */
- fsmrel->firstChunk = -1;
- fsmrel->storedPages = 0;
+ return ReadBufferWithFork(rel, FSM_FORKNUM, blkno);
}
/*
- * Look to see if a page with at least the specified amount of space is
- * available in the given FSMRelation. If so, return its page number,
- * and advance the nextPage counter so that the next inquiry will return
- * a different page if possible; also update the entry to show that the
- * requested space is not available anymore. Return InvalidBlockNumber
- * if no success.
+ * Ensure that the FSM fork is at least n_fsmblocks long, extending
+ * it if necessary with empty pages. And by empty, I mean pages filled
+ * with zeros, meaning there's no free space.
*/
-static BlockNumber
-find_free_space(FSMRelation *fsmrel, Size spaceNeeded)
+static void
+fsm_extend(Relation rel, BlockNumber n_fsmblocks)
{
- FSMPageData *info;
- int pagesToCheck, /* outer loop counter */
- pageIndex; /* current page index */
-
- if (fsmrel->isIndex)
- elog(ERROR, "find_free_space called for an index relation");
- info = (FSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- pageIndex = fsmrel->nextPage;
- /* Last operation may have left nextPage pointing past end */
- if (pageIndex >= fsmrel->storedPages)
- pageIndex = 0;
-
- for (pagesToCheck = fsmrel->storedPages; pagesToCheck > 0; pagesToCheck--)
- {
- FSMPageData *page = info + pageIndex;
- Size spaceAvail = FSMPageGetSpace(page);
-
- /* Check this page */
- if (spaceAvail >= spaceNeeded)
- {
- /*
- * Found what we want --- adjust the entry, and update nextPage.
- */
- FSMPageSetSpace(page, spaceAvail - spaceNeeded);
- fsmrel->nextPage = pageIndex + 1;
- return FSMPageGetPageNum(page);
- }
- /* Advance pageIndex, wrapping around if needed */
- if (++pageIndex >= fsmrel->storedPages)
- pageIndex = 0;
- }
+ BlockNumber n_fsmblocks_now;
+ Page pg;
- return InvalidBlockNumber; /* nothing found */
-}
-
-/*
- * As above, but for index case --- we only deal in whole pages.
- */
-static BlockNumber
-find_index_free_space(FSMRelation *fsmrel)
-{
- IndexFSMPageData *info;
- BlockNumber result;
+ pg = (Page) palloc(BLCKSZ);
+ PageInit(pg, BLCKSZ, 0);
/*
- * If isIndex isn't set, it could be that RecordIndexFreeSpace() has never
- * yet been called on this relation, and we're still looking at the
- * default setting from create_fsm_rel(). If so, just act as though
- * there's no space.
+ * We use the relation extension lock to lock out other backends
+ * trying to extend the FSM at the same time. It also locks out
+ * extension of the main fork, unnecessarily, but extending the
+ * FSM happens seldom enough that it doesn't seem worthwhile to
+ * have a separate lock tag type for it.
+ *
+ * Note that another backend might have extended the relation
+ * before we get the lock.
*/
- if (!fsmrel->isIndex)
+ LockRelationForExtension(rel, ExclusiveLock);
+
+ n_fsmblocks_now = smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+ while (n_fsmblocks_now < n_fsmblocks)
{
- if (fsmrel->storedPages == 0)
- return InvalidBlockNumber;
- elog(ERROR, "find_index_free_space called for a non-index relation");
+ smgrextend(rel->rd_smgr, FSM_FORKNUM, n_fsmblocks_now,
+ (char *) pg, rel->rd_istemp);
+ n_fsmblocks_now++;
}
- /*
- * For indexes, there's no need for the nextPage state variable; we just
- * remove and return the first available page. (We could save cycles here
- * by returning the last page, but it seems better to encourage re-use of
- * lower-numbered pages.)
- */
- if (fsmrel->storedPages <= 0)
- return InvalidBlockNumber; /* no pages available */
- info = (IndexFSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- result = IndexFSMPageGetPageNum(info);
- fsmrel->storedPages--;
- memmove(info, info + 1, fsmrel->storedPages * sizeof(IndexFSMPageData));
- return result;
-}
-
-/*
- * fsm_record_free_space - guts of RecordFreeSpace operation (now only
- * provided as part of RecordAndGetPageWithFreeSpace).
- */
-static void
-fsm_record_free_space(FSMRelation *fsmrel, BlockNumber page, Size spaceAvail)
-{
- int pageIndex;
+ UnlockRelationForExtension(rel, ExclusiveLock);
- if (fsmrel->isIndex)
- elog(ERROR, "fsm_record_free_space called for an index relation");
- if (lookup_fsm_page_entry(fsmrel, page, &pageIndex))
- {
- /* Found an existing entry for page; update it */
- FSMPageData *info;
+ pfree(pg);
- info = (FSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- info += pageIndex;
- FSMPageSetSpace(info, spaceAvail);
- }
- else
- {
- /*
- * No existing entry; ignore the call. We used to add the page to the
- * FSM --- but in practice, if the page hasn't got enough space to
- * satisfy the caller who's kicking it back to us, then it's probably
- * uninteresting to everyone else as well.
- */
- }
+ /* update the cache with the up-to-date size */
+ rel->rd_fsm_nblocks_cache = n_fsmblocks_now;
}
/*
- * Look for an entry for a specific page (block number) in a FSMRelation.
- * Returns TRUE if a matching entry exists, else FALSE.
+ * Set value in given FSM page and slot.
*
- * The output argument *outPageIndex is set to indicate where the entry exists
- * (if TRUE result) or could be inserted (if FALSE result).
+ * If minValue > 0, the updated page is also searched for a page with at
+ * least minValue of free space. If one is found, its slot number is
+ * returned, -1 otherwise.
*/
-static bool
-lookup_fsm_page_entry(FSMRelation *fsmrel, BlockNumber page,
- int *outPageIndex)
+static int
+fsm_set_and_search(Relation rel, FSMAddress addr, uint16 slot,
+ uint8 newValue, uint8 minValue)
{
- /* Check for empty relation */
- if (fsmrel->storedPages <= 0)
- {
- *outPageIndex = 0;
- return false;
- }
+ Buffer buf;
+ Page page;
+ int newslot = -1;
- /* Do binary search */
- if (fsmrel->isIndex)
- {
- IndexFSMPageData *info;
- int low,
- high;
-
- info = (IndexFSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- low = 0;
- high = fsmrel->storedPages - 1;
- while (low <= high)
- {
- int middle;
- BlockNumber probe;
+ buf = fsm_readbuf(rel, addr, true);
+ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- middle = low + (high - low) / 2;
- probe = IndexFSMPageGetPageNum(info + middle);
- if (probe == page)
- {
- *outPageIndex = middle;
- return true;
- }
- else if (probe < page)
- low = middle + 1;
- else
- high = middle - 1;
- }
- *outPageIndex = low;
- return false;
- }
- else
- {
- FSMPageData *info;
- int low,
- high;
-
- info = (FSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- low = 0;
- high = fsmrel->storedPages - 1;
- while (low <= high)
- {
- int middle;
- BlockNumber probe;
+ page = BufferGetPage(buf);
- middle = low + (high - low) / 2;
- probe = FSMPageGetPageNum(info + middle);
- if (probe == page)
- {
- *outPageIndex = middle;
- return true;
- }
- else if (probe < page)
- low = middle + 1;
- else
- high = middle - 1;
- }
- *outPageIndex = low;
- return false;
+ if (fsm_set_avail(page, slot, newValue))
+ MarkBufferDirty(buf);
+
+ if (minValue != 0)
+ {
+ /* Search while we still hold the lock */
+ newslot = fsm_search_avail(buf, minValue,
+ addr.level == FSM_BOTTOM_LEVEL,
+ true);
}
+
+ UnlockReleaseBuffer(buf);
+
+ return newslot;
}
/*
- * Re-pack the FSM storage arena, dropping data if necessary to meet the
- * current allocation target for each relation. At conclusion, all available
- * space in the arena will be coalesced at the end.
+ * Search the tree for a heap page with at least min_cat of free space
*/
-static void
-compact_fsm_storage(void)
+static BlockNumber
+fsm_search(Relation rel, uint8 min_cat)
{
- int nextChunkIndex = 0;
- bool did_push = false;
- FSMRelation *fsmrel;
+ int restarts = 0;
+ FSMAddress addr = FSM_ROOT_ADDRESS;
- for (fsmrel = FreeSpaceMap->firstRel;
- fsmrel != NULL;
- fsmrel = fsmrel->nextPhysical)
+ for (;;)
{
- int newAlloc;
- int newAllocPages;
- int newChunkIndex;
- int oldChunkIndex;
- int curChunks;
- char *newLocation;
- char *oldLocation;
+ int slot;
+ Buffer buf;
+ uint8 max_avail;
/*
- * Calculate target allocation, make sure we don't overrun due to
- * roundoff error
+ * Read the FSM page. The root page is created if it doesn't exist
+ * yet, to save future searchers the effort of having to call
+ * smgrnblocks() in fsm_readbuf(), only to see that the FSM is
+ * completely empty.
*/
- newAlloc = fsm_calc_target_allocation(fsm_calc_request(fsmrel));
- if (newAlloc > FreeSpaceMap->totalChunks - nextChunkIndex)
- newAlloc = FreeSpaceMap->totalChunks - nextChunkIndex;
- if (fsmrel->isIndex)
- newAllocPages = newAlloc * INDEXCHUNKPAGES;
- else
- newAllocPages = newAlloc * CHUNKPAGES;
-
- /*
- * Determine current size, current and new locations
- */
- curChunks = fsm_current_chunks(fsmrel);
- oldChunkIndex = fsmrel->firstChunk;
- oldLocation = FreeSpaceMap->arena + oldChunkIndex * CHUNKBYTES;
- newChunkIndex = nextChunkIndex;
- newLocation = FreeSpaceMap->arena + newChunkIndex * CHUNKBYTES;
+ buf = fsm_readbuf(rel, addr, (addr.level != FSM_ROOT_LEVEL));
- /*
- * It's possible that we have to move data down, not up, if the
- * allocations of previous rels expanded. This normally means that
- * our allocation expanded too (or at least got no worse), and ditto
- * for later rels. So there should be room to move all our data down
- * without dropping any --- but we might have to push down following
- * rels to acquire the room. We don't want to do the push more than
- * once, so pack everything against the end of the arena if so.
- *
- * In corner cases where we are on the short end of a roundoff choice
- * that we were formerly on the long end of, it's possible that we
- * have to move down and compress our data too. In fact, even after
- * pushing down the following rels, there might not be as much space
- * as we computed for this rel above --- that would imply that some
- * following rel(s) are also on the losing end of roundoff choices. We
- * could handle this fairly by doing the per-rel compactions
- * out-of-order, but that seems like way too much complexity to deal
- * with a very infrequent corner case. Instead, we simply drop pages
- * from the end of the current rel's data until it fits.
- */
- if (newChunkIndex > oldChunkIndex)
+ /* Search within the page */
+ if (BufferIsValid(buf))
{
- int limitChunkIndex;
-
- if (newAllocPages < fsmrel->storedPages)
- {
- /* move and compress --- just drop excess pages */
- fsmrel->storedPages = newAllocPages;
- curChunks = fsm_current_chunks(fsmrel);
- }
- /* is there enough space? */
- if (fsmrel->nextPhysical != NULL)
- limitChunkIndex = fsmrel->nextPhysical->firstChunk;
- else
- limitChunkIndex = FreeSpaceMap->totalChunks;
- if (newChunkIndex + curChunks > limitChunkIndex)
- {
- /* not enough space, push down following rels */
- if (!did_push)
- {
- push_fsm_rels_after(fsmrel);
- did_push = true;
- }
- /* now is there enough space? */
- if (fsmrel->nextPhysical != NULL)
- limitChunkIndex = fsmrel->nextPhysical->firstChunk;
- else
- limitChunkIndex = FreeSpaceMap->totalChunks;
- if (newChunkIndex + curChunks > limitChunkIndex)
- {
- /* uh-oh, forcibly cut the allocation to fit */
- newAlloc = limitChunkIndex - newChunkIndex;
-
- /*
- * If newAlloc < 0 at this point, we are moving the rel's
- * firstChunk into territory currently assigned to a later
- * rel. This is okay so long as we do not copy any data.
- * The rels will be back in nondecreasing firstChunk order
- * at completion of the compaction pass.
- */
- if (newAlloc < 0)
- newAlloc = 0;
- if (fsmrel->isIndex)
- newAllocPages = newAlloc * INDEXCHUNKPAGES;
- else
- newAllocPages = newAlloc * CHUNKPAGES;
- fsmrel->storedPages = newAllocPages;
- curChunks = fsm_current_chunks(fsmrel);
- }
- }
- memmove(newLocation, oldLocation, curChunks * CHUNKBYTES);
+ LockBuffer(buf, BUFFER_LOCK_SHARE);
+ slot = fsm_search_avail(buf, min_cat,
+ (addr.level == FSM_BOTTOM_LEVEL),
+ false);
+ if (slot == -1)
+ max_avail = fsm_get_max_avail(BufferGetPage(buf));
+ UnlockReleaseBuffer(buf);
+ }
+ else
+ {
+ slot = -1;
+ max_avail = 0;
}
- else if (newAllocPages < fsmrel->storedPages)
+
+ if (slot != -1)
{
/*
- * Need to compress the page data. For an index, "compression"
- * just means dropping excess pages; otherwise we try to keep the
- * ones with the most space.
+ * Descend the tree, or return the found block if we're at the
+ * bottom.
*/
- if (fsmrel->isIndex)
- {
- fsmrel->storedPages = newAllocPages;
- /* may need to move data */
- if (newChunkIndex != oldChunkIndex)
- memmove(newLocation, oldLocation, newAlloc * CHUNKBYTES);
- }
- else
- {
- pack_existing_pages((FSMPageData *) newLocation,
- newAllocPages,
- (FSMPageData *) oldLocation,
- fsmrel->storedPages);
- fsmrel->storedPages = newAllocPages;
- }
+ if (addr.level == FSM_BOTTOM_LEVEL)
+ return fsm_get_heap_blk(addr, slot);
+
+ addr = fsm_get_child(addr, slot);
}
- else if (newChunkIndex != oldChunkIndex)
+ else if (addr.level == FSM_ROOT_LEVEL)
{
/*
- * No compression needed, but must copy the data up
+ * At the root, failure means there's no page with enough free
+ * space in the FSM. Give up.
*/
- memmove(newLocation, oldLocation, curChunks * CHUNKBYTES);
+ return InvalidBlockNumber;
}
- fsmrel->firstChunk = newChunkIndex;
- nextChunkIndex += newAlloc;
- }
- Assert(nextChunkIndex <= FreeSpaceMap->totalChunks);
- FreeSpaceMap->usedChunks = nextChunkIndex;
-}
-
-/*
- * Push all FSMRels physically after afterRel to the end of the storage arena.
- *
- * We sometimes have to do this when deletion or truncation of a relation
- * causes the allocations of remaining rels to expand markedly. We must
- * temporarily push existing data down to the end so that we can move it
- * back up in an orderly fashion.
- */
-static void
-push_fsm_rels_after(FSMRelation *afterRel)
-{
- int nextChunkIndex = FreeSpaceMap->totalChunks;
- FSMRelation *fsmrel;
-
- FreeSpaceMap->usedChunks = FreeSpaceMap->totalChunks;
+ else
+ {
+ uint16 parentslot;
+ FSMAddress parent;
- for (fsmrel = FreeSpaceMap->lastRel;
- fsmrel != NULL;
- fsmrel = fsmrel->priorPhysical)
- {
- int chunkCount;
- int newChunkIndex;
- int oldChunkIndex;
- char *newLocation;
- char *oldLocation;
+ /*
+ * At lower level, failure can happen if the value in the upper-
+ * level node didn't reflect the value on the lower page. Update
+ * the upper node, to avoid falling into the same trap again, and
+ * start over.
+ *
+ * There's a race condition here, if another backend updates this
+ * page right after we release it, and gets the lock on the parent
+ * page before us. We'll then update the parent page with the now
+ * stale information we had. It's OK, because it should happen
+ * rarely, and will be fixed by the next vacuum.
+ */
+ parent = fsm_get_parent(addr, &parentslot);
+ fsm_set_and_search(rel, parent, parentslot, max_avail, 0);
- if (fsmrel == afterRel)
- break;
+ /*
+ * If the upper pages are badly out of date, we might need to
+ * loop quite a few times, updating them as we go. Any
+ * inconsistencies should eventually be corrected and the loop
+ * should end. Looping indefinitely is nevertheless scary, so
+ * provide an emergency valve.
+ */
+ if (restarts++ > 10000)
+ return InvalidBlockNumber;
- chunkCount = fsm_current_chunks(fsmrel);
- nextChunkIndex -= chunkCount;
- newChunkIndex = nextChunkIndex;
- oldChunkIndex = fsmrel->firstChunk;
- if (newChunkIndex < oldChunkIndex)
- {
- /* we're pushing down, how can it move up? */
- elog(PANIC, "inconsistent entry sizes in FSM");
- }
- else if (newChunkIndex > oldChunkIndex)
- {
- /* need to move it */
- newLocation = FreeSpaceMap->arena + newChunkIndex * CHUNKBYTES;
- oldLocation = FreeSpaceMap->arena + oldChunkIndex * CHUNKBYTES;
- memmove(newLocation, oldLocation, chunkCount * CHUNKBYTES);
- fsmrel->firstChunk = newChunkIndex;
+ /* Start search all over from the root */
+ addr = FSM_ROOT_ADDRESS;
}
}
- Assert(nextChunkIndex >= 0);
}
+
/*
- * Pack a set of per-page freespace data into a smaller amount of space.
- *
- * The method is to compute a low-resolution histogram of the free space
- * amounts, then determine which histogram bin contains the break point.
- * We then keep all pages above that bin, none below it, and just enough
- * of the pages in that bin to fill the output area exactly.
+ * Recursive guts of FreeSpaceMapVacuum
*/
-#define HISTOGRAM_BINS 64
-
-static void
-pack_incoming_pages(FSMPageData *newLocation, int newPages,
- FSMPageData *pageSpaces, int nPages)
+static uint8
+fsm_vacuum_page(Relation rel, FSMAddress addr, bool *eof_p)
{
- int histogram[HISTOGRAM_BINS];
- int above,
- binct,
- i;
- Size thresholdL,
- thresholdU;
-
- Assert(newPages < nPages); /* else I shouldn't have been called */
- /* Build histogram */
- MemSet(histogram, 0, sizeof(histogram));
- for (i = 0; i < nPages; i++)
- {
- Size avail = FSMPageGetSpace(&pageSpaces[i]);
-
- if (avail >= BLCKSZ)
- elog(ERROR, "bogus freespace amount");
- avail /= (BLCKSZ / HISTOGRAM_BINS);
- histogram[avail]++;
- }
- /* Find the breakpoint bin */
- above = 0;
- for (i = HISTOGRAM_BINS - 1; i >= 0; i--)
- {
- int sum = above + histogram[i];
+ Buffer buf;
+ Page page;
+ uint8 max_avail;
- if (sum > newPages)
- break;
- above = sum;
- }
- Assert(i >= 0);
- thresholdL = i * BLCKSZ / HISTOGRAM_BINS; /* low bound of bp bin */
- thresholdU = (i + 1) * BLCKSZ / HISTOGRAM_BINS; /* hi bound */
- binct = newPages - above; /* number to take from bp bin */
- /* And copy the appropriate data */
- for (i = 0; i < nPages; i++)
+ /* Read the page if it exists, or return EOF */
+ buf = fsm_readbuf(rel, addr, false);
+ if (!BufferIsValid(buf))
{
- BlockNumber page = FSMPageGetPageNum(&pageSpaces[i]);
- Size avail = FSMPageGetSpace(&pageSpaces[i]);
-
- /* Check caller provides sorted data */
- if (i > 0 && page <= FSMPageGetPageNum(&pageSpaces[i - 1]))
- elog(ERROR, "free-space data is not in page order");
- /* Save this page? */
- if (avail >= thresholdU ||
- (avail >= thresholdL && (--binct >= 0)))
- {
- *newLocation = pageSpaces[i];
- newLocation++;
- newPages--;
- }
+ *eof_p = true;
+ return 0;
}
- Assert(newPages == 0);
-}
-
-/*
- * Pack a set of per-page freespace data into a smaller amount of space.
- *
- * This is algorithmically identical to pack_incoming_pages(), but accepts
- * a different input representation. Also, we assume the input data has
- * previously been checked for validity (size in bounds, pages in order).
- *
- * Note: it is possible for the source and destination arrays to overlap.
- * The caller is responsible for making sure newLocation is at lower addresses
- * so that we can copy data moving forward in the arrays without problem.
- */
-static void
-pack_existing_pages(FSMPageData *newLocation, int newPages,
- FSMPageData *oldLocation, int oldPages)
-{
- int histogram[HISTOGRAM_BINS];
- int above,
- binct,
- i;
- Size thresholdL,
- thresholdU;
-
- Assert(newPages < oldPages); /* else I shouldn't have been called */
- /* Build histogram */
- MemSet(histogram, 0, sizeof(histogram));
- for (i = 0; i < oldPages; i++)
- {
- Size avail = FSMPageGetSpace(oldLocation + i);
+ else
+ *eof_p = false;
- /* Shouldn't happen, but test to protect against stack clobber */
- if (avail >= BLCKSZ)
- elog(ERROR, "bogus freespace amount");
- avail /= (BLCKSZ / HISTOGRAM_BINS);
- histogram[avail]++;
- }
- /* Find the breakpoint bin */
- above = 0;
- for (i = HISTOGRAM_BINS - 1; i >= 0; i--)
- {
- int sum = above + histogram[i];
+ page = BufferGetPage(buf);
- if (sum > newPages)
- break;
- above = sum;
- }
- Assert(i >= 0);
- thresholdL = i * BLCKSZ / HISTOGRAM_BINS; /* low bound of bp bin */
- thresholdU = (i + 1) * BLCKSZ / HISTOGRAM_BINS; /* hi bound */
- binct = newPages - above; /* number to take from bp bin */
- /* And copy the appropriate data */
- for (i = 0; i < oldPages; i++)
+ /*
+ * Recurse into children, and fix the information stored about them
+ * at this level.
+ */
+ if (addr.level > FSM_BOTTOM_LEVEL)
{
- BlockNumber page = FSMPageGetPageNum(oldLocation + i);
- Size avail = FSMPageGetSpace(oldLocation + i);
+ int slot;
+ bool eof = false;
- /* Save this page? */
- if (avail >= thresholdU ||
- (avail >= thresholdL && (--binct >= 0)))
+ for (slot = 0; slot < SlotsPerFSMPage; slot++)
{
- FSMPageSetPageNum(newLocation, page);
- FSMPageSetSpace(newLocation, avail);
- newLocation++;
- newPages--;
- }
- }
- Assert(newPages == 0);
-}
+ int child_avail;
-/*
- * Calculate number of chunks "requested" by a rel. The "request" is
- * anything beyond the rel's one guaranteed chunk.
- *
- * Rel's interestingPages and isIndex settings must be up-to-date when called.
- *
- * See notes at top of file for details.
- */
-static int
-fsm_calc_request(FSMRelation *fsmrel)
-{
- int req;
+ /* After we hit end-of-file, just clear the rest of the slots */
+ if (!eof)
+ child_avail = fsm_vacuum_page(rel, fsm_get_child(addr, slot), &eof);
+ else
+ child_avail = 0;
- /* Convert page count to chunk count */
- if (fsmrel->isIndex)
- {
- /* test to avoid unsigned underflow at zero */
- if (fsmrel->interestingPages <= INDEXCHUNKPAGES)
- return 0;
- /* quotient will fit in int, even if interestingPages doesn't */
- req = (fsmrel->interestingPages - 1) / INDEXCHUNKPAGES;
- }
- else
- {
- if (fsmrel->interestingPages <= CHUNKPAGES)
- return 0;
- req = (fsmrel->interestingPages - 1) / CHUNKPAGES;
+ /* Update information about the child */
+ if (fsm_get_avail(page, slot) != child_avail)
+ {
+ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+ fsm_set_avail(BufferGetPage(buf), slot, child_avail);
+ MarkBufferDirty(buf);
+ LockBuffer(buf, BUFFER_LOCK_UNLOCK);
+ }
+ }
}
+ max_avail = fsm_get_max_avail(BufferGetPage(buf));
+
/*
- * We clamp the per-relation requests to at most half the arena size; this
- * is intended to prevent a single bloated relation from crowding out FSM
- * service for every other rel.
+ * Reset the next slot pointer. This encourages the use of low-numbered
+ * pages, increasing the chances that a later vacuum can truncate the
+ * relation.
*/
- req = Min(req, FreeSpaceMap->totalChunks / 2);
-
- return req;
-}
+ ((FSMPage) PageGetContents(page))->fp_next_slot = 0;
-/*
- * Same as above, but without the clamp ... this is just intended for
- * reporting the total space needed to store all information.
- */
-static int
-fsm_calc_request_unclamped(FSMRelation *fsmrel)
-{
- int req;
-
- /* Convert page count to chunk count */
- if (fsmrel->isIndex)
- {
- /* test to avoid unsigned underflow at zero */
- if (fsmrel->interestingPages <= INDEXCHUNKPAGES)
- return 0;
- /* quotient will fit in int, even if interestingPages doesn't */
- req = (fsmrel->interestingPages - 1) / INDEXCHUNKPAGES;
- }
- else
- {
- if (fsmrel->interestingPages <= CHUNKPAGES)
- return 0;
- req = (fsmrel->interestingPages - 1) / CHUNKPAGES;
- }
+ ReleaseBuffer(buf);
- return req;
+ return max_avail;
}
-/*
- * Calculate target allocation (number of chunks) for a rel
- *
- * Parameter is the result from fsm_calc_request(). The global sumRequests
- * and numRels totals must be up-to-date already.
- *
- * See notes at top of file for details.
- */
-static int
-fsm_calc_target_allocation(int myRequest)
-{
- double spareChunks;
- int extra;
- spareChunks = FreeSpaceMap->totalChunks - FreeSpaceMap->numRels;
- Assert(spareChunks > 0);
- if (spareChunks >= FreeSpaceMap->sumRequests)
- {
- /* We aren't oversubscribed, so allocate exactly the request */
- extra = myRequest;
- }
- else
- {
- extra = (int) rint(spareChunks * myRequest / FreeSpaceMap->sumRequests);
- if (extra < 0) /* shouldn't happen, but make sure */
- extra = 0;
- }
- return 1 + extra;
-}
+/****** WAL-logging ******/
-/*
- * Calculate number of chunks actually used to store current data
- */
-static int
-fsm_current_chunks(FSMRelation *fsmrel)
+void
+fsm_redo(XLogRecPtr lsn, XLogRecord *record)
{
- int chunkCount;
-
- /* Make sure storedPages==0 produces right answer */
- if (fsmrel->storedPages <= 0)
- return 0;
- /* Convert page count to chunk count */
- if (fsmrel->isIndex)
- chunkCount = (fsmrel->storedPages - 1) / INDEXCHUNKPAGES + 1;
- else
- chunkCount = (fsmrel->storedPages - 1) / CHUNKPAGES + 1;
- return chunkCount;
-}
+ uint8 info = record->xl_info & ~XLR_INFO_MASK;
-/*
- * Calculate current actual allocation (number of chunks) for a rel
- */
-static int
-fsm_current_allocation(FSMRelation *fsmrel)
-{
- if (fsmrel->nextPhysical != NULL)
- return fsmrel->nextPhysical->firstChunk - fsmrel->firstChunk;
- else if (fsmrel == FreeSpaceMap->lastRel)
- return FreeSpaceMap->usedChunks - fsmrel->firstChunk;
- else
+ switch (info)
{
- /* it's not in the storage-order list */
- Assert(fsmrel->firstChunk < 0 && fsmrel->storedPages == 0);
- return 0;
- }
-}
-
-
-/*
- * Return the FreeSpaceMap structure for examination.
- */
-FSMHeader *
-GetFreeSpaceMap(void)
-{
+ case XLOG_FSM_TRUNCATE:
+ {
+ xl_fsm_truncate *xlrec;
+ Relation rel;
- return FreeSpaceMap;
+ xlrec = (xl_fsm_truncate *) XLogRecGetData(record);
+ rel = CreateFakeRelcacheEntry(xlrec->node);
+ FreeSpaceMapTruncateRel(rel, xlrec->nheapblocks);
+ FreeFakeRelcacheEntry(rel);
+ }
+ break;
+ default:
+ elog(PANIC, "fsm_redo: unknown op code %u", info);
+ }
}
-
-#ifdef FREESPACE_DEBUG
-/*
- * Dump contents of freespace map for debugging.
- *
- * We assume caller holds the FreeSpaceLock, or is otherwise unconcerned
- * about other processes.
- */
void
-DumpFreeSpace(void)
+fsm_desc(StringInfo buf, uint8 xl_info, char *rec)
{
- FSMRelation *fsmrel;
- FSMRelation *prevrel = NULL;
- int relNum = 0;
- int nPages;
+ uint8 info = xl_info & ~XLR_INFO_MASK;
- for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage)
+ switch (info)
{
- relNum++;
- fprintf(stderr, "Map %d: rel %u/%u/%u isIndex %d avgRequest %u interestingPages %u nextPage %d\nMap= ",
- relNum,
- fsmrel->key.spcNode, fsmrel->key.dbNode, fsmrel->key.relNode,
- (int) fsmrel->isIndex, fsmrel->avgRequest,
- fsmrel->interestingPages, fsmrel->nextPage);
- if (fsmrel->isIndex)
- {
- IndexFSMPageData *page;
-
- page = (IndexFSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- for (nPages = 0; nPages < fsmrel->storedPages; nPages++)
- {
- fprintf(stderr, " %u",
- IndexFSMPageGetPageNum(page));
- page++;
- }
- }
- else
+ case XLOG_FSM_TRUNCATE:
{
- FSMPageData *page;
+ xl_fsm_truncate *xlrec = (xl_fsm_truncate *) rec;
- page = (FSMPageData *)
- (FreeSpaceMap->arena + fsmrel->firstChunk * CHUNKBYTES);
- for (nPages = 0; nPages < fsmrel->storedPages; nPages++)
- {
- fprintf(stderr, " %u:%u",
- FSMPageGetPageNum(page),
- FSMPageGetSpace(page));
- page++;
- }
+ appendStringInfo(buf, "truncate: rel %u/%u/%u; nheapblocks %u;",
+ xlrec->node.spcNode, xlrec->node.dbNode,
+ xlrec->node.relNode, xlrec->nheapblocks);
+ break;
}
- fprintf(stderr, "\n");
- /* Cross-check list links */
- if (prevrel != fsmrel->priorUsage)
- fprintf(stderr, "DumpFreeSpace: broken list links\n");
- prevrel = fsmrel;
+ default:
+ appendStringInfo(buf, "UNKNOWN");
+ break;
}
- if (prevrel != FreeSpaceMap->usageListTail)
- fprintf(stderr, "DumpFreeSpace: broken list links\n");
- /* Cross-check global counters */
- if (relNum != FreeSpaceMap->numRels)
- fprintf(stderr, "DumpFreeSpace: %d rels in list, but numRels = %d\n",
- relNum, FreeSpaceMap->numRels);
}
-
-#endif /* FREESPACE_DEBUG */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fsmpage.c
+ * routines to search and manipulate one FSM page.
+ *
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ * $PostgreSQL: pgsql/src/backend/storage/freespace/fsmpage.c,v 1.1 2008/09/30 10:52:13 heikki Exp $
+ *
+ * NOTES:
+ *
+ * The public functions in this file form an API that hides the internal
+ * structure of a FSM page. This allows freespace.c to treat each FSM page
+ * as a black box with SlotsPerPage "slots". fsm_set_avail() and
+ * fsm_get_avail() let's you get/set the value of a slot, and
+ * fsm_search_avail() let's you search for a slot with value >= X.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/fsm_internals.h"
+
+/* macros to navigate the tree within a page. */
+#define leftchild(x) (2 * (x) + 1)
+#define rightchild(x) (2 * (x) + 2)
+#define parentof(x) (((x) - 1) / 2)
+
+/* returns right sibling of x, wrapping around within the level */
+static int
+rightsibling(int x)
+{
+ /*
+ * Move right. This might wrap around, stepping to the leftmost node at
+ * the next level.
+ */
+ x++;
+
+ /*
+ * Check if we stepped to the leftmost node at next level, and correct
+ * if so. The leftmost nodes at each level are of form x = 2^level - 1, so
+ * check if (x + 1) is a power of two.
+ */
+ if (((x + 1) & x) == 0)
+ x = parentof(x);
+
+ return x;
+}
+
+/*
+ * Sets the value of a slot on page. Returns true if the page was
+ * modified.
+ *
+ * The caller must hold an exclusive lock on the page.
+ */
+bool
+fsm_set_avail(Page page, int slot, uint8 value)
+{
+ int nodeno = NonLeafNodesPerPage + slot;
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ uint8 oldvalue;
+
+ Assert(slot < LeafNodesPerPage);
+
+ oldvalue = fsmpage->fp_nodes[nodeno];
+
+ /* If the value hasn't changed, we don't need to do anything */
+ if (oldvalue == value && value <= fsmpage->fp_nodes[0])
+ return false;
+
+ fsmpage->fp_nodes[nodeno] = value;
+
+ /*
+ * Propagate up, until we hit the root or a node that doesn't
+ * need to be updated.
+ */
+ do
+ {
+ uint8 newvalue = 0;
+ int lchild;
+ int rchild;
+
+ nodeno = parentof(nodeno);
+ lchild = leftchild(nodeno);
+ rchild = lchild + 1;
+
+ newvalue = fsmpage->fp_nodes[lchild];
+ if (rchild < NodesPerPage)
+ newvalue = Max(newvalue,
+ fsmpage->fp_nodes[rchild]);
+
+ oldvalue = fsmpage->fp_nodes[nodeno];
+ if (oldvalue == newvalue)
+ break;
+
+ fsmpage->fp_nodes[nodeno] = newvalue;
+ } while (nodeno > 0);
+
+ /*
+ * sanity check: if the new value value is higher than the value
+ * at the top, the tree is corrupt.
+ */
+ if (value > fsmpage->fp_nodes[0])
+ fsm_rebuild_page(page);
+
+ return true;
+}
+
+/*
+ * Returns the value of given slot on page.
+ *
+ * Since this is just a read-only access of a single byte, the page doesn't
+ * need to be locked.
+ */
+uint8
+fsm_get_avail(Page page, int slot)
+{
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+
+ return fsmpage->fp_nodes[NonLeafNodesPerPage + slot];
+}
+
+/*
+ * Returns the value at the root of a page.
+ * Since this is just a read-only access of a single byte, the page doesn't
+ * need to be locked.
+ */
+uint8
+fsm_get_max_avail(Page page)
+{
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ return fsmpage->fp_nodes[0];
+}
+
+/*
+ * Searches for a slot with min. category. Returns slot number, or -1 if
+ * none found.
+ *
+ * The caller must hold at least a shared lock on the page, and this
+ * function can unlock and lock the page again in exclusive mode if it
+ * needs to be updated. exclusive_lock_held should be set to true if the
+ * caller is already holding an exclusive lock, to avoid extra work.
+ *
+ * If advancenext is false, fp_next_slot is set to point to the returned
+ * slot, and if it's true, to the slot next to the returned slot.
+ */
+int
+fsm_search_avail(Buffer buf, uint8 minvalue, bool advancenext,
+ bool exclusive_lock_held)
+{
+ Page page = BufferGetPage(buf);
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ int nodeno;
+ int target;
+ uint16 slot;
+
+ restart:
+ /*
+ * Check the root first, and exit quickly if there's no page with
+ * enough free space
+ */
+ if (fsmpage->fp_nodes[0] < minvalue)
+ return -1;
+
+
+ /* fp_next_slot is just a hint, so check that it's sane */
+ target = fsmpage->fp_next_slot;
+ if (target < 0 || target >= LeafNodesPerPage)
+ target = 0;
+ target += NonLeafNodesPerPage;
+
+ /*
+ * Start the search from the target slot. At every step, move one
+ * node to the right, and climb up to the parent. Stop when we reach a
+ * node with enough free space. (note that moving to the right only
+ * makes a difference if we're on the right child of the parent)
+ *
+ * The idea is to graduall expand our "search triangle", that is, all
+ * nodes covered by the current node. In the beginning, just the target
+ * node is included, and more nodes to the right of the target node,
+ * taking wrap-around into account, is included at each step. Nodes are
+ * added to the search triangle in left-to-right order, starting from
+ * the target node. This ensures that we'll find the first suitable node
+ * to the right of the target node, and not some other node with enough
+ * free space.
+ *
+ * For example, consider this tree:
+ *
+ * 7
+ * 7 6
+ * 5 7 6 5
+ * 4 5 5 7 2 6 5 2
+ * T
+ *
+ * Imagine that target node is the node indicated by the letter T, and
+ * we're searching for a node with value of 6 or higher. The search
+ * begins at T. At first iteration, we move to the right, and to the
+ * parent, arriving the rightmost 5. At the 2nd iteration, we move to the
+ * right, wrapping around, and climb up, arriving at the 7 at the 2nd
+ * level. 7 satisfies our search, so we descend down to the bottom,
+ * following the path of sevens.
+ */
+ nodeno = target;
+ while (nodeno > 0)
+ {
+ if (fsmpage->fp_nodes[nodeno] >= minvalue)
+ break;
+
+ /*
+ * Move to the right, wrapping around at the level if necessary, and
+ * climb up.
+ */
+ nodeno = parentof(rightsibling(nodeno));
+ }
+
+ /*
+ * We're now at a node with enough free space, somewhere in the middle of
+ * the tree. Descend to the bottom, following a path with enough free
+ * space, preferring to move left if there's a choice.
+ */
+ while (nodeno < NonLeafNodesPerPage)
+ {
+ int leftnodeno = leftchild(nodeno);
+ int rightnodeno = leftnodeno + 1;
+ bool leftok = (leftnodeno < NodesPerPage) &&
+ (fsmpage->fp_nodes[leftnodeno] >= minvalue);
+ bool rightok = (rightnodeno < NodesPerPage) &&
+ (fsmpage->fp_nodes[rightnodeno] >= minvalue);
+
+ if (leftok)
+ nodeno = leftnodeno;
+ else if (rightok)
+ nodeno = rightnodeno;
+ else
+ {
+ /*
+ * Oops. The parent node promised that either left or right
+ * child has enough space, but neither actually did. This can
+ * happen in case of a "torn page", IOW if we crashed earlier
+ * while writing the page to disk, and only part of the page
+ * made it to disk.
+ *
+ * Fix the corruption and restart.
+ */
+ RelFileNode rnode;
+ ForkNumber forknum;
+ BlockNumber blknum;
+
+ BufferGetTag(buf, &rnode, &forknum, &blknum);
+ elog(DEBUG1, "fixing corrupt FSM block %u, relation %u/%u/%u",
+ blknum, rnode.spcNode, rnode.dbNode, rnode.relNode);
+
+ /* make sure we hold an exclusive lock */
+ if (!exclusive_lock_held)
+ {
+ LockBuffer(buf, BUFFER_LOCK_UNLOCK);
+ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+ exclusive_lock_held = true;
+ }
+ fsm_rebuild_page(page);
+ MarkBufferDirty(buf);
+ goto restart;
+ }
+ }
+
+ /* We're now at the bottom level, at a node with enough space. */
+ slot = nodeno - NonLeafNodesPerPage;
+
+ /*
+ * Update the next slot pointer. Note that we do this even if we're only
+ * holding a shared lock, on the grounds that it's better to use a shared
+ * lock and get a garbled next pointer every now and then, than take the
+ * concurrency hit of an exlusive lock.
+ *
+ * Wrap-around is handled at the beginning of this function.
+ */
+ fsmpage->fp_next_slot = slot + (advancenext ? 1 : 0);
+
+ return slot;
+}
+
+/*
+ * Sets the available space to zero for all slots numbered >= nslots.
+ * Returns true if the page was modified.
+ */
+bool
+fsm_truncate_avail(Page page, int nslots)
+{
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ uint8 *ptr;
+ bool changed = false;
+
+ Assert(nslots >= 0 && nslots < LeafNodesPerPage);
+
+ /* Clear all truncated leaf nodes */
+ ptr = &fsmpage->fp_nodes[NonLeafNodesPerPage + nslots];
+ for (; ptr < &fsmpage->fp_nodes[NodesPerPage]; ptr++)
+ {
+ if (*ptr != 0)
+ changed = true;
+ *ptr = 0;
+ }
+
+ /* Fix upper nodes. */
+ if (changed)
+ fsm_rebuild_page(page);
+
+ return changed;
+}
+
+/*
+ * Reconstructs the upper levels of a page. Returns true if the page
+ * was modified.
+ */
+bool
+fsm_rebuild_page(Page page)
+{
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ bool changed = false;
+ int nodeno;
+
+ /*
+ * Start from the lowest non-leaflevel, at last node, working our way
+ * backwards, through all non-leaf nodes at all levels, up to the root.
+ */
+ for (nodeno = NonLeafNodesPerPage - 1; nodeno >= 0; nodeno--)
+ {
+ int lchild = leftchild(nodeno);
+ int rchild = lchild + 1;
+ uint8 newvalue = 0;
+
+ if (lchild < NodesPerPage)
+ newvalue = fsmpage->fp_nodes[lchild];
+
+ if (rchild < NodesPerPage)
+ newvalue = Max(newvalue,
+ fsmpage->fp_nodes[rchild]);
+
+ if (fsmpage->fp_nodes[nodeno] != newvalue)
+ {
+ fsmpage->fp_nodes[nodeno] = newvalue;
+ changed = true;
+ }
+ }
+
+ return changed;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * indexfsm.c
+ * POSTGRES free space map for quickly finding free pages in relations
+ *
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ * $PostgreSQL: pgsql/src/backend/storage/freespace/indexfsm.c,v 1.1 2008/09/30 10:52:13 heikki Exp $
+ *
+ *
+ * NOTES:
+ *
+ * This is similar to the FSM used for heap, in freespace.c, but instead
+ * of tracking the amount of free space on pages, we only track whether
+ * pages are completely free or in-use. We use the same FSM implementation
+ * as for heaps, using BLCKSZ - 1 to denote used pages, and 0 for unused.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/freespace.h"
+#include "storage/indexfsm.h"
+#include "storage/smgr.h"
+
+/*
+ * Exported routines
+ */
+
+/*
+ * InitIndexFreeSpaceMap - Create or reset the FSM fork for relation.
+ */
+void
+InitIndexFreeSpaceMap(Relation rel)
+{
+ /* Create FSM fork if it doesn't exist yet, or truncate it if it does */
+ RelationOpenSmgr(rel);
+ if (!smgrexists(rel->rd_smgr, FSM_FORKNUM))
+ smgrcreate(rel->rd_smgr, FSM_FORKNUM, rel->rd_istemp, false);
+ else
+ smgrtruncate(rel->rd_smgr, FSM_FORKNUM, 0, rel->rd_istemp);
+}
+
+/*
+ * GetFreeIndexPage - return a free page from the FSM
+ *
+ * As a side effect, the page is marked as used in the FSM.
+ */
+BlockNumber
+GetFreeIndexPage(Relation rel)
+{
+ BlockNumber blkno = GetPageWithFreeSpace(rel, BLCKSZ/2);
+
+ if (blkno != InvalidBlockNumber)
+ RecordUsedIndexPage(rel, blkno);
+
+ return blkno;
+}
+
+/*
+ * RecordFreeIndexPage - mark a page as free in the FSM
+ */
+void
+RecordFreeIndexPage(Relation rel, BlockNumber freeBlock)
+{
+ RecordPageWithFreeSpace(rel, freeBlock, BLCKSZ - 1);
+}
+
+
+/*
+ * RecordUsedIndexPage - mark a page as used in the FSM
+ */
+void
+RecordUsedIndexPage(Relation rel, BlockNumber usedBlock)
+{
+ RecordPageWithFreeSpace(rel, usedBlock, 0);
+}
+
+/*
+ * IndexFreeSpaceMapTruncate - adjust for truncation of a relation.
+ *
+ * We need to delete any stored data past the new relation length, so that
+ * we don't bogusly return removed block numbers.
+ */
+void
+IndexFreeSpaceMapTruncate(Relation rel, BlockNumber nblocks)
+{
+ FreeSpaceMapTruncateRel(rel, nblocks);
+}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/storage/ipc/ipci.c,v 1.96 2008/05/12 00:00:50 alvherre Exp $
+ * $PostgreSQL: pgsql/src/backend/storage/ipc/ipci.c,v 1.97 2008/09/30 10:52:13 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "postmaster/bgwriter.h"
#include "postmaster/postmaster.h"
#include "storage/bufmgr.h"
-#include "storage/freespace.h"
#include "storage/ipc.h"
#include "storage/pg_shmem.h"
#include "storage/pmsignal.h"
size = add_size(size, ProcArrayShmemSize());
size = add_size(size, BackendStatusShmemSize());
size = add_size(size, SInvalShmemSize());
- size = add_size(size, FreeSpaceShmemSize());
size = add_size(size, BgWriterShmemSize());
size = add_size(size, AutoVacuumShmemSize());
size = add_size(size, BTreeShmemSize());
*/
CreateSharedInvalidationState();
- /*
- * Set up free-space map
- */
- InitFreeSpaceMap();
-
/*
* Set up interprocess signaling mechanisms
*/
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/storage/smgr/smgr.c,v 1.111 2008/08/11 11:05:11 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/storage/smgr/smgr.c,v 1.112 2008/09/30 10:52:13 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/xlogutils.h"
#include "commands/tablespace.h"
#include "storage/bufmgr.h"
-#include "storage/freespace.h"
#include "storage/ipc.h"
#include "storage/smgr.h"
#include "utils/hsearch.h"
*/
DropRelFileNodeBuffers(rnode, forknum, isTemp, 0);
- /*
- * Tell the free space map to forget this relation. It won't be accessed
- * any more anyway, but we may as well recycle the map space quickly.
- */
- if (forknum == MAIN_FORKNUM)
- FreeSpaceMapForgetRel(&rnode);
-
/*
* It'd be nice to tell the stats collector to forget it immediately, too.
* But we can't because we don't know the OID (and in cases involving
*/
DropRelFileNodeBuffers(reln->smgr_rnode, forknum, isTemp, nblocks);
- /*
- * Tell the free space map to forget anything it may have stored for the
- * about-to-be-deleted blocks. We want to be sure it won't return bogus
- * block numbers later on.
- */
- FreeSpaceMapTruncateRel(&reln->smgr_rnode, nblocks);
-
/* Do the truncation */
(*(smgrsw[reln->smgr_which].smgr_truncate)) (reln, forknum, nblocks,
isTemp);
DropRelFileNodeBuffers(xlrec->rnode, xlrec->forknum, false,
xlrec->blkno);
- /*
- * Tell the free space map to forget anything it may have stored for
- * the about-to-be-deleted blocks. We want to be sure it won't return
- * bogus block numbers later on.
- */
- FreeSpaceMapTruncateRel(&reln->smgr_rnode, xlrec->blkno);
-
/* Do the truncation */
(*(smgrsw[reln->smgr_which].smgr_truncate)) (reln,
xlrec->forknum,
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.556 2008/08/19 18:30:04 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.557 2008/09/30 10:52:13 heikki Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
#include "postmaster/autovacuum.h"
#include "rewrite/rewriteHandler.h"
#include "storage/bufmgr.h"
-#include "storage/freespace.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/sinval.h"
StartupXLOG();
on_shmem_exit(ShutdownXLOG, 0);
- /*
- * Read any existing FSM cache file, and register to write one out at
- * exit.
- */
- LoadFreeSpaceMap();
- on_shmem_exit(DumpFreeSpaceMap, 0);
-
/*
* We have to build the flat file for pg_database, but not for the
* user and group tables, since we won't try to do authentication.
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/cache/relcache.c,v 1.273 2008/08/10 19:02:33 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/cache/relcache.c,v 1.274 2008/09/30 10:52:13 heikki Exp $
*
*-------------------------------------------------------------------------
*/
*/
MemSet(relation, 0, sizeof(RelationData));
relation->rd_targblock = InvalidBlockNumber;
+ relation->rd_fsm_nblocks_cache = InvalidBlockNumber;
/* make sure relation is marked as having no open file yet */
relation->rd_smgr = NULL;
*/
relation = (Relation) palloc0(sizeof(RelationData));
relation->rd_targblock = InvalidBlockNumber;
+ relation->rd_fsm_nblocks_cache = InvalidBlockNumber;
/* make sure relation is marked as having no open file yet */
relation->rd_smgr = NULL;
heap_freetuple(pg_class_tuple);
/* We must recalculate physical address in case it changed */
RelationInitPhysicalAddr(relation);
- /* Make sure targblock is reset in case rel was truncated */
+ /* Must reset targblock and fsm_nblocks_cache in case rel was truncated */
relation->rd_targblock = InvalidBlockNumber;
+ relation->rd_fsm_nblocks_cache = InvalidBlockNumber;
/* Must free any AM cached data, too */
if (relation->rd_amcache)
pfree(relation->rd_amcache);
if (relation->rd_isnailed)
{
relation->rd_targblock = InvalidBlockNumber;
+ relation->rd_fsm_nblocks_cache = InvalidBlockNumber;
if (relation->rd_rel->relkind == RELKIND_INDEX)
{
relation->rd_isvalid = false; /* needs to be revalidated */
rel = (Relation) palloc0(sizeof(RelationData));
rel->rd_targblock = InvalidBlockNumber;
+ rel->rd_fsm_nblocks_cache = InvalidBlockNumber;
/* make sure relation is marked as having no open file yet */
rel->rd_smgr = NULL;
*/
rel->rd_smgr = NULL;
rel->rd_targblock = InvalidBlockNumber;
+ rel->rd_fsm_nblocks_cache = InvalidBlockNumber;
if (rel->rd_isnailed)
rel->rd_refcnt = 1;
else
* Written by Peter Eisentraut <peter_e@gmx.net>.
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.473 2008/09/23 21:12:03 mha Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.474 2008/09/30 10:52:13 heikki Exp $
*
*--------------------------------------------------------------------
*/
#include "regex/regex.h"
#include "storage/bufmgr.h"
#include "storage/fd.h"
-#include "storage/freespace.h"
#include "tcop/tcopprot.h"
#include "tsearch/ts_cache.h"
#include "utils/builtins.h"
gettext_noop("Resource Usage"),
/* RESOURCES_MEM */
gettext_noop("Resource Usage / Memory"),
- /* RESOURCES_FSM */
- gettext_noop("Resource Usage / Free Space Map"),
/* RESOURCES_KERNEL */
gettext_noop("Resource Usage / Kernel Resources"),
/* WAL */
100000000, 0, 1000000000, NULL, NULL
},
- {
- {"max_fsm_relations", PGC_POSTMASTER, RESOURCES_FSM,
- gettext_noop("Sets the maximum number of tables and indexes for which free space is tracked."),
- NULL
- },
- &MaxFSMRelations,
- 1000, 100, INT_MAX, NULL, NULL
- },
- {
- {"max_fsm_pages", PGC_POSTMASTER, RESOURCES_FSM,
- gettext_noop("Sets the maximum number of disk pages for which free space is tracked."),
- NULL
- },
- &MaxFSMPages,
- 20000, 1000, INT_MAX, NULL, NULL
- },
-
{
{"max_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT,
gettext_noop("Sets the maximum number of locks per transaction."),
#maintenance_work_mem = 16MB # min 1MB
#max_stack_depth = 2MB # min 100kB
-# - Free Space Map -
-
-#max_fsm_pages = 204800 # min max_fsm_relations*16, 6 bytes each
- # (change requires restart)
-#max_fsm_relations = 1000 # min 100, ~70 bytes each
- # (change requires restart)
-
# - Kernel Resource Usage -
#max_files_per_process = 1000 # min 25
* Portions Copyright (c) 1994, Regents of the University of California
* Portions taken from FreeBSD.
*
- * $PostgreSQL: pgsql/src/bin/initdb/initdb.c,v 1.161 2008/09/23 10:58:03 heikki Exp $
+ * $PostgreSQL: pgsql/src/bin/initdb/initdb.c,v 1.162 2008/09/30 10:52:13 heikki Exp $
*
*-------------------------------------------------------------------------
*/
/* defaults */
static int n_connections = 10;
static int n_buffers = 50;
-static int n_fsm_pages = 20000;
/*
* Warning messages for authentication methods
test_config_settings(void)
{
/*
- * These macros define the minimum shared_buffers we want for a given
- * max_connections value, and the max_fsm_pages setting to be used for a
- * given shared_buffers value. The arrays show the settings to try.
+ * This macro defines the minimum shared_buffers we want for a given
+ * max_connections value. The arrays show the settings to try.
*/
-
#define MIN_BUFS_FOR_CONNS(nconns) ((nconns) * 10)
-#define FSM_FOR_BUFS(nbuffers) ((nbuffers) > 1000 ? 50 * (nbuffers) : 20000)
static const int trial_conns[] = {
100, 50, 40, 30, 20, 10
status,
test_conns,
test_buffs,
- test_max_fsm,
ok_buffers = 0;
{
test_conns = trial_conns[i];
test_buffs = MIN_BUFS_FOR_CONNS(test_conns);
- test_max_fsm = FSM_FOR_BUFS(test_buffs);
snprintf(cmd, sizeof(cmd),
SYSTEMQUOTE "\"%s\" --boot -x0 %s "
"-c max_connections=%d "
"-c shared_buffers=%d "
- "-c max_fsm_pages=%d "
"< \"%s\" > \"%s\" 2>&1" SYSTEMQUOTE,
backend_exec, boot_options,
- test_conns, test_buffs, test_max_fsm,
+ test_conns, test_buffs,
DEVNULL, DEVNULL);
status = system(cmd);
if (status == 0)
printf("%d\n", n_connections);
- printf(_("selecting default shared_buffers/max_fsm_pages ... "));
+ printf(_("selecting default shared_buffers ... "));
fflush(stdout);
for (i = 0; i < bufslen; i++)
test_buffs = ok_buffers;
break;
}
- test_max_fsm = FSM_FOR_BUFS(test_buffs);
snprintf(cmd, sizeof(cmd),
SYSTEMQUOTE "\"%s\" --boot -x0 %s "
"-c max_connections=%d "
"-c shared_buffers=%d "
- "-c max_fsm_pages=%d "
"< \"%s\" > \"%s\" 2>&1" SYSTEMQUOTE,
backend_exec, boot_options,
- n_connections, test_buffs, test_max_fsm,
+ n_connections, test_buffs,
DEVNULL, DEVNULL);
status = system(cmd);
if (status == 0)
break;
}
n_buffers = test_buffs;
- n_fsm_pages = FSM_FOR_BUFS(n_buffers);
if ((n_buffers * (BLCKSZ / 1024)) % 1024 == 0)
- printf("%dMB/%d\n", (n_buffers * (BLCKSZ / 1024)) / 1024, n_fsm_pages);
+ printf("%dMB\n", (n_buffers * (BLCKSZ / 1024)) / 1024);
else
- printf("%dkB/%d\n", n_buffers * (BLCKSZ / 1024), n_fsm_pages);
+ printf("%dkB\n", n_buffers * (BLCKSZ / 1024));
}
/*
n_buffers * (BLCKSZ / 1024));
conflines = replace_token(conflines, "#shared_buffers = 32MB", repltok);
- snprintf(repltok, sizeof(repltok), "max_fsm_pages = %d", n_fsm_pages);
- conflines = replace_token(conflines, "#max_fsm_pages = 204800", repltok);
-
#if DEF_PGPORT != 5432
snprintf(repltok, sizeof(repltok), "#port = %d", DEF_PGPORT);
conflines = replace_token(conflines, "#port = 5432", repltok);
*
* Resource managers definition
*
- * $PostgreSQL: pgsql/src/include/access/rmgr.h,v 1.17 2006/11/05 22:42:10 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/access/rmgr.h,v 1.18 2008/09/30 10:52:13 heikki Exp $
*/
#ifndef RMGR_H
#define RMGR_H
#define RM_DBASE_ID 4
#define RM_TBLSPC_ID 5
#define RM_MULTIXACT_ID 6
+#define RM_FREESPACE_ID 7
#define RM_HEAP2_ID 9
#define RM_HEAP_ID 10
#define RM_BTREE_ID 11
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/storage/freespace.h,v 1.28 2008/03/10 02:04:10 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/storage/freespace.h,v 1.29 2008/09/30 10:52:13 heikki Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef FREESPACE_H_
#define FREESPACE_H_
-#include "storage/relfilenode.h"
-#include "storage/itemptr.h"
+#include "utils/rel.h"
+#include "storage/bufpage.h"
+#include "access/xlog.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)
-
-/*
- * 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 */
- BlockNumber interestingPages; /* # of pages with useful free space */
- 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 PGDLLIMPORT int MaxFSMRelations;
-extern PGDLLIMPORT int MaxFSMPages;
-
-
-/*
- * function prototypes
- */
-extern void InitFreeSpaceMap(void);
-extern Size FreeSpaceShmemSize(void);
-extern FSMHeader *GetFreeSpaceMap(void);
-
-extern BlockNumber GetPageWithFreeSpace(RelFileNode *rel, Size spaceNeeded);
-extern BlockNumber RecordAndGetPageWithFreeSpace(RelFileNode *rel,
+/* prototypes for public functions in freespace.c */
+extern Size GetRecordedFreeSpace(Relation rel, BlockNumber heapBlk);
+extern BlockNumber GetPageWithFreeSpace(Relation rel, Size spaceNeeded);
+extern BlockNumber RecordAndGetPageWithFreeSpace(Relation rel,
BlockNumber oldPage,
Size oldSpaceAvail,
Size spaceNeeded);
-extern Size GetAvgFSMRequestSize(RelFileNode *rel);
-extern void RecordRelationFreeSpace(RelFileNode *rel,
- BlockNumber interestingPages,
- int nPages,
- FSMPageData *pageSpaces);
-
-extern BlockNumber GetFreeIndexPage(RelFileNode *rel);
-extern void RecordIndexFreeSpace(RelFileNode *rel,
- BlockNumber interestingPages,
- int nPages,
- BlockNumber *pages);
-
-extern void FreeSpaceMapTruncateRel(RelFileNode *rel, BlockNumber nblocks);
-extern void FreeSpaceMapForgetRel(RelFileNode *rel);
-extern void FreeSpaceMapForgetDatabase(Oid dbid);
-
-extern void PrintFreeSpaceMapStatistics(int elevel);
+extern void RecordPageWithFreeSpace(Relation rel, BlockNumber heapBlk,
+ Size spaceAvail);
-extern void DumpFreeSpaceMap(int code, Datum arg);
-extern void LoadFreeSpaceMap(void);
+extern void FreeSpaceMapTruncateRel(Relation rel, BlockNumber nblocks);
+extern void FreeSpaceMapVacuum(Relation rel);
-#ifdef FREESPACE_DEBUG
-extern void DumpFreeSpace(void);
-#endif
+/* WAL prototypes */
+extern void fsm_desc(StringInfo buf, uint8 xl_info, char *rec);
+extern void fsm_redo(XLogRecPtr lsn, XLogRecord *record);
#endif /* FREESPACE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fsm_internal.h
+ * internal functions for free space map
+ *
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $PostgreSQL: pgsql/src/include/storage/fsm_internals.h,v 1.1 2008/09/30 10:52:14 heikki Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FSM_INTERNALS_H
+#define FSM_INTERNALS_H
+
+#include "storage/buf.h"
+#include "storage/bufpage.h"
+#include "lib/stringinfo.h"
+
+/*
+ * Structure of a FSM page. See src/backend/storage/freespace/README for
+ * details.
+ */
+typedef struct
+{
+ /*
+ * fsm_search_avail() tries to spread the load of multiple backends
+ * by returning different pages to different backends in a round-robin
+ * fashion. fp_next_slot points to the next slot to be returned
+ * (assuming there's enough space on it for the request). It's defined
+ * as an int, because it's updated without an exclusive lock. uint16
+ * would be more appropriate, but int is more likely to be atomically
+ * fetchable/storable.
+ */
+ int fp_next_slot;
+
+ /*
+ * fp_nodes contains the binary tree, stored in array. The first
+ * NonLeafNodesPerPage elements are upper nodes, and the following
+ * LeafNodesPerPage elements are leaf nodes. Unused nodes are zero.
+ */
+ uint8 fp_nodes[1];
+} FSMPageData;
+
+typedef FSMPageData *FSMPage;
+
+/*
+ * Number of non-leaf and leaf nodes, and nodes in total, on an FSM page.
+ * These definitions are internal to fsmpage.c.
+ */
+#define NodesPerPage (BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - \
+ offsetof(FSMPageData, fp_nodes))
+
+#define NonLeafNodesPerPage (BLCKSZ / 2 - 1)
+#define LeafNodesPerPage (NodesPerPage - NonLeafNodesPerPage)
+
+/*
+ * Number of FSM "slots" on a FSM page. This is what should be used
+ * outside fsmpage.c.
+ */
+#define SlotsPerFSMPage LeafNodesPerPage
+
+/* Prototypes for functions in fsmpage.c */
+extern int fsm_search_avail(Buffer buf, uint8 min_cat, bool advancenext,
+ bool exclusive_lock_held);
+extern uint8 fsm_get_avail(Page page, int slot);
+extern uint8 fsm_get_max_avail(Page page);
+extern bool fsm_set_avail(Page page, int slot, uint8 value);
+extern bool fsm_truncate_avail(Page page, int nslots);
+extern bool fsm_rebuild_page(Page page);
+
+#endif /* FSM_INTERNALS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * indexfsm.h
+ * POSTGRES free space map for quickly finding an unused page in index
+ *
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $PostgreSQL: pgsql/src/include/storage/indexfsm.h,v 1.1 2008/09/30 10:52:14 heikki Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INDEXFSM_H_
+#define INDEXFSM_H_
+
+#include "utils/rel.h"
+
+extern void InitIndexFreeSpaceMap(Relation rel);
+
+extern BlockNumber GetFreeIndexPage(Relation rel);
+extern void RecordFreeIndexPage(Relation rel, BlockNumber page);
+extern void RecordUsedIndexPage(Relation rel, BlockNumber page);
+
+extern void IndexFreeSpaceMapTruncate(Relation rel, BlockNumber nblocks);
+
+#endif /* INDEXFSM_H */
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/storage/lwlock.h,v 1.39 2008/06/19 21:32:56 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/storage/lwlock.h,v 1.40 2008/09/30 10:52:14 heikki Exp $
*
*-------------------------------------------------------------------------
*/
* by allowing values not listed in the enum declaration to be assigned.
* The extra value MaxDynamicLWLock is there to keep the compiler from
* deciding that the enum can be represented as char or short ...
+ *
+ * If you remove a lock, please replace it with a placeholder like was done
+ * for FreeSpaceMapLock. This retains the lock numbering, which is helpful for
+ * DTrace and other external debugging scripts.
*/
typedef enum LWLockId
{
ProcArrayLock,
SInvalReadLock,
SInvalWriteLock,
- FreeSpaceLock,
+ UnusedLock1, /* FreeSpaceMapLock used to be here */
WALInsertLock,
WALWriteLock,
ControlFileLock,
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/storage/relfilenode.h,v 1.16 2008/08/11 11:05:11 heikki Exp $
+ * $PostgreSQL: pgsql/src/include/storage/relfilenode.h,v 1.17 2008/09/30 10:52:14 heikki Exp $
*
*-------------------------------------------------------------------------
*/
typedef enum ForkNumber
{
InvalidForkNumber = -1,
- MAIN_FORKNUM = 0
- /* NOTE: change NUM_FORKS below when you add new forks */
+ MAIN_FORKNUM = 0,
+ FSM_FORKNUM
+ /* NOTE: change MAX_FORKNUM below when you add new forks */
} ForkNumber;
-#define MAX_FORKNUM MAIN_FORKNUM
+#define MAX_FORKNUM FSM_FORKNUM
/*
* RelFileNode must provide all that we need to know to physically access
*
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/include/utils/guc_tables.h,v 1.42 2008/09/10 18:09:20 alvherre Exp $
+ * $PostgreSQL: pgsql/src/include/utils/guc_tables.h,v 1.43 2008/09/30 10:52:14 heikki Exp $
*
*-------------------------------------------------------------------------
*/
CONN_AUTH_SECURITY,
RESOURCES,
RESOURCES_MEM,
- RESOURCES_FSM,
RESOURCES_KERNEL,
WAL,
WAL_SETTINGS,
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/utils/rel.h,v 1.107 2008/06/19 00:46:06 alvherre Exp $
+ * $PostgreSQL: pgsql/src/include/utils/rel.h,v 1.108 2008/09/30 10:52:14 heikki Exp $
*
*-------------------------------------------------------------------------
*/
List *rd_indpred; /* index predicate tree, if any */
void *rd_amcache; /* available for use by index AM */
+ /* Cached last-seen size of the FSM */
+ BlockNumber rd_fsm_nblocks_cache;
+
/* use "struct" here to avoid needing to include pgstat.h: */
struct PgStat_TableStatus *pgstat_info; /* statistics collection area */
} RelationData;
projects / postgresql / commitdiff