<varlistentry id="guc-vacuum-freeze-strategy-threshold" xreflabel="vacuum_freeze_strategy_threshold">

<term><varname>vacuum_freeze_strategy_threshold</varname> (<type>integer</type>)

<indexterm>

<primary><varname>vacuum_freeze_strategy_threshold</varname> configuration parameter</primary>

</indexterm>

</term>

<listitem>

<para>

Specifies the cutoff storage size that

<command>VACUUM</command> should use to determine its freezing

strategy. This is applied by comparing it to the size of the

target table's <glossterm linkend="glossary-fork">main

fork</glossterm> at the beginning of each <command>VACUUM</command>.

Eager freezing strategy is used by <command>VACUUM</command>

when the table's main fork size exceeds this value.

<command>VACUUM</command> <emphasis>always</emphasis> uses

eager freezing strategy when processing <glossterm

linkend="glossary-unlogged">unlogged</glossterm> tables,

regardless of this setting. Otherwise <command>VACUUM</command>

uses lazy freezing strategy. For more information see <xref

linkend="vacuum-for-wraparound"/>.

</para>

<para>

If this value is specified without units, it is taken as

megabytes. The default is four gigabytes

(<literal>4GB</literal>).

</para>

</listitem>

</varlistentry>

<xref linkend="guc-vacuum-freeze-strategy-threshold"/> controls

<command>VACUUM</command>'s freezing strategy. The

<firstterm>eager freezing strategy</firstterm> makes

<command>VACUUM</command> freeze all rows on a page whenever each

and every row on the page is considered visible to all current

transactions (immediately after dead row versions are removed).

Freezing pages early and in batch often spreads out the overhead

of freezing over time. <command>VACUUM</command> consistently

avoids allowing unfrozen all-visible pages to build up, improving

system level performance stability. The <firstterm>lazy freezing

strategy</firstterm> makes <command>VACUUM</command> determine

whether pages should be frozen on the basis of the age of the

oldest XID on the page. Freezing pages lazily sometimes avoids

the overhead of freezing that turns out to have been unnecessary

because the rows were modified soon after freezing took place.

</para>

<para>

<xref linkend="guc-vacuum-freeze-min-age"/> controls how old an

XID value has to be before pages with rows bearing that XID are

frozen. This setting is an additional trigger criteria for

freezing a page's tuples. It is used by both freezing strategies,

though it typically has little impact when <command>VACUUM</command>

uses the eager freezing strategy.

<para>

Controlling the overhead of freezing existing all-visible pages

during aggressive vacuuming is the goal of the eager freezing

strategy. Increasing <varname>vacuum_freeze_strategy_threshold</varname>

may avoid unnecessary work, but it increases the risk of an

eventual aggressive vacuum that performs an excessive amount of

<quote>catch up</quote> freezing all at once.

</para>

unvacuumed for longer than that, the system could temporarily refuse to

allocate new transaction IDs. To ensure that this never happens,

One disadvantage of increasing <varname>autovacuum_freeze_max_age</varname>

<xref linkend="reloption-autovacuum-freeze-strategy-threshold"/>

to allow freezing to take place proactively. The number of obsolete tuples and

<varlistentry id="reloption-autovacuum-freeze-strategy-threshold" xreflabel="autovacuum_freeze_strategy_threshold">

<term><literal>autovacuum_freeze_strategy_threshold</literal>, <literal>toast.autovacuum_freeze_strategy_threshold</literal> (<type>integer</type>)

<indexterm>

<primary><varname>autovacuum_freeze_strategy_threshold</varname> storage parameter</primary>

</indexterm>

</term>

<listitem>

<para>

Per-table value for <xref linkend="guc-vacuum-freeze-strategy-threshold"/>

parameter.

</para>

</listitem>

</varlistentry>

{

{

"autovacuum_freeze_strategy_threshold",

"Table size at which VACUUM freezes using eager strategy, in megabytes.",

RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,

ShareUpdateExclusiveLock

}, -1, 0, MAX_KILOBYTES

},

{"autovacuum_freeze_strategy_threshold", RELOPT_TYPE_INT,

offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_strategy_threshold)},

cutoffs.freeze_strategy_threshold_pages = 0;

/* Eagerly freeze pages that are eligible to become all-frozen? */

bool eager_freeze_strategy;

static void lazy_scan_strategy(LVRelState *vacrel);

/*

lazy_scan_strategy(vacrel);

static void

lazy_scan_strategy(LVRelState *vacrel)

{

BlockNumber rel_pages = vacrel->rel_pages;

/*

vacrel->eager_freeze_strategy =

(rel_pages > vacrel->cutoffs.freeze_strategy_threshold_pages ||

!RelationIsPermanent(vacrel->rel));

}

(fpi_before != pgWalUsage.wal_fpi || vacrel->eager_freeze_strategy)))

int vacuum_freeze_strategy_threshold;

params.freeze_strategy_threshold = 0;

params.freeze_strategy_threshold = -1;

effective_multixact_freeze_max_age,

freeze_strategy_threshold;

uint64 threshold_strategy_pages;

freeze_strategy_threshold = params->freeze_strategy_threshold;

/*

if (freeze_strategy_threshold < 0)

freeze_strategy_threshold = vacuum_freeze_strategy_threshold;

Assert(freeze_strategy_threshold >= 0);

/*

threshold_strategy_pages =

((uint64) freeze_strategy_threshold * 1024 * 1024) / BLCKSZ;

threshold_strategy_pages = Min(threshold_strategy_pages, MaxBlockNumber);

cutoffs->freeze_strategy_threshold_pages = threshold_strategy_pages;

static int default_freeze_strategy_threshold;

default_freeze_strategy_threshold = 0;

default_freeze_strategy_threshold = vacuum_freeze_strategy_threshold;

int freeze_strategy_threshold;

freeze_strategy_threshold = (avopts &&

avopts->freeze_strategy_threshold >= 0)

? avopts->freeze_strategy_threshold

: default_freeze_strategy_threshold;

tab->at_params.freeze_strategy_threshold = freeze_strategy_threshold;

{

{"vacuum_freeze_strategy_threshold", PGC_USERSET, CLIENT_CONN_STATEMENT,

gettext_noop("Table size at which VACUUM freezes using eager strategy, in megabytes."),

gettext_noop("This is applied by comparing it to the size of a table's main fork at "

"the beginning of each VACUUM. Eager freezing strategy is used when size "

"exceeds the threshold, or when table is a temporary or unlogged table. "

"Otherwise lazy freezing strategy is used."),

GUC_UNIT_MB

},

&vacuum_freeze_strategy_threshold,

4096, 0, MAX_KILOBYTES,

NULL, NULL, NULL

},