</listitem>

</varlistentry>

<varlistentry id="guc-huge-page-size" xreflabel="huge_page_size">

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

<indexterm>

<primary><varname>huge_page_size</varname> configuration parameter</primary>

</indexterm>

</term>

<listitem>

<para>

Controls the size of huge pages, when they are enabled with

<xref linkend="guc-huge-pages"/>.

The default is zero (<literal>0</literal>).

When set to <literal>0</literal>, the default huge page size on the

system will be used.

</para>

<para>

Some commonly available page sizes on modern 64 bit server architectures include:

<literal>2MB</literal> and <literal>1GB</literal> (Intel and AMD), <literal>16MB</literal> and

<literal>16GB</literal> (IBM POWER), and <literal>64kB</literal>, <literal>2MB</literal>,

<literal>32MB</literal> and <literal>1GB</literal> (ARM). For more information

about usage and support, see <xref linkend="linux-huge-pages"/>.

</para>

<para>

Non-default settings are currently supported only on Linux.

</para>

</listitem>

</varlistentry>

<varlistentry id="guc-temp-buffers" xreflabel="temp_buffers">

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

<indexterm>

using large values of <xref linkend="guc-shared-buffers"/>. To use this

feature in <productname>PostgreSQL</productname> you need a kernel

with <varname>CONFIG_HUGETLBFS=y</varname> and

<varname>CONFIG_HUGETLB_PAGE=y</varname>. You will also have to adjust

the kernel setting <varname>vm.nr_hugepages</varname>. To estimate the

number of huge pages needed, start <productname>PostgreSQL</productname>

without huge pages enabled and check the

postmaster's anonymous shared memory segment size, as well as the system's

huge page size, using the <filename>/proc</filename> file system. This might

look like:

<varname>CONFIG_HUGETLB_PAGE=y</varname>. You will also have to configure

the operating system to provide enough huge pages of the desired size.

To estimate the number of huge pages needed, start

<productname>PostgreSQL</productname> without huge pages enabled and check

the postmaster's anonymous shared memory segment size, as well as the

system's default and supported huge page sizes, using the

<filename>/proc</filename> and <filename>/sys</filename> file systems.

This might look like:

<programlisting>

$ <userinput>head -1 $PGDATA/postmaster.pid</userinput>

4170

$ <userinput>pmap 4170 | awk '/rw-s/ &amp;&amp; /zero/ {print $2}'</userinput>

6490428K

$ <userinput>grep ^Hugepagesize /proc/meminfo</userinput>

Hugepagesize: 2048 kB

$ <userinput>ls /sys/kernel/mm/hugepages</userinput>

hugepages-1048576kB hugepages-2048kB

</programlisting>

In this example the default is 2MB, but you can also explicitly request

either 2MB or 1GB with <xref linkend="guc-huge-page-size"/>.

Assuming <literal>2MB</literal> huge pages,

<literal>6490428</literal> / <literal>2048</literal> gives approximately

<literal>3169.154</literal>, so in this example we need at

least <literal>3170</literal> huge pages, which we can set with:

least <literal>3170</literal> huge pages. A larger setting would be

appropriate if other programs on the machine also need huge pages.

We can set this with:

<programlisting>

# <userinput>sysctl -w vm.nr_hugepages=3170</userinput>

</programlisting>

Don't forget to add this setting to <filename>/etc/sysctl.conf</filename>

so that it is reapplied after reboots. For non-default huge page sizes,

we can instead use:

<programlisting>

$ <userinput>sysctl -w vm.nr_hugepages=3170</userinput>

# <userinput>echo 3170 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages</userinput>

</programlisting>

A larger setting would be appropriate if other programs on the machine

also need huge pages. Don't forget to add this setting

to <filename>/etc/sysctl.conf</filename> so that it will be reapplied

after reboots.

It is also possible to provide these settings at boot time using

kernel parameters such as <literal>hugepagesz=2M hugepages=3170</literal>.

</para>

<para>

Sometimes the kernel is not able to allocate the desired number of huge

pages immediately, so it might be necessary to repeat the command or to

reboot. (Immediately after a reboot, most of the machine's memory

should be available to convert into huge pages.) To verify the huge

page allocation situation, use:

pages immediately due to fragmentation, so it might be necessary

to repeat the command or toreboot. (Immediately after a reboot, most of

the machine's memoryshould be available to convert into huge pages.)

To verify the hugepage allocation situation for a given size, use:

<programlisting>

$ <userinput>grep Huge /proc/meminfo</userinput>

$ <userinput>cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages</userinput>

</programlisting>

</para>

<para>

The default behavior for huge pages in

<productname>PostgreSQL</productname> is to use them when possible and

to fall back to normal pages when failing. To enforce the use of huge

<productname>PostgreSQL</productname> is to use them when possible, with

the system's default huge page size, and

to fall back to normal pages on failure. To enforce the use of huge

pages, you can set <xref linkend="guc-huge-pages"/>

to <literal>on</literal> in <filename>postgresql.conf</filename>.

Note that with this setting <productname>PostgreSQL</productname> will fail to

GetHugePageSize(Size*hugepagesize,int*mmap_flags)

{

*hugepagesize=2*1024*1024;

*mmap_flags=MAP_HUGETLB;

Sizedefault_hugepagesize=0;

{

FILE*fp=AllocateFile("/proc/meminfo","r");

charbuf[128];

{

if (ch=='k')

{

*hugepagesize=sz* (Size)1024;

default_hugepagesize=sz* (Size)1024;

break;

}

}

}

if (huge_page_size!=0)

{

*hugepagesize= (Size)huge_page_size*1024;

}

elseif (default_hugepagesize!=0)

{

*hugepagesize=default_hugepagesize;

}

{

*hugepagesize=2*1024*1024;

}

*mmap_flags=MAP_HUGETLB;

#if defined(MAP_HUGE_MASK)&& defined(MAP_HUGE_SHIFT)

if (*hugepagesize!=default_hugepagesize)

{

intshift=pg_ceil_log2_64(*hugepagesize);

*mmap_flags |= (shift&MAP_HUGE_MASK) <<MAP_HUGE_SHIFT;

}

}

"max_connections.",

*size) :0));

allocsize) :0));

}

*size=allocsize;

staticboolcheck_autovacuum_work_mem(int*newval,void**extra,GucSourcesource);

staticboolcheck_effective_io_concurrency(int*newval,void**extra,GucSourcesource);

staticboolcheck_maintenance_io_concurrency(int*newval,void**extra,GucSourcesource);

staticboolcheck_huge_page_size(int*newval,void**extra,GucSourcesource);

staticvoidassign_pgstat_temp_directory(constchar*newval,void*extra);

staticboolcheck_application_name(char**newval,void**extra,GucSourcesource);

staticvoidassign_application_name(constchar*newval,void*extra);

inthuge_pages;

inthuge_page_size;

NULL,assign_tcp_user_timeout,show_tcp_user_timeout

},

{

{"huge_page_size",PGC_POSTMASTER,RESOURCES_MEM,

gettext_noop("The size of huge page that should be requested."),

NULL,

},

&huge_page_size,

0,0,INT_MAX,

check_huge_page_size,NULL,NULL

},

{

{NULL,0,0,NULL,NULL},NULL,0,0,0,NULL,NULL,NULL

return true;

}

check_huge_page_size(int*newval,void**extra,GucSourcesource)

{

#if !(defined(MAP_HUGE_MASK)&& defined(MAP_HUGE_SHIFT))

if (*newval!=0)

{

GUC_check_errdetail("huge_page_size must be 0 on this platform.");

return false;

}

return true;

}

assign_pgstat_temp_directory(constchar*newval,void*extra)

{

# (change requires restart)

#huge_pages = try# on, off, or try

# (change requires restart)

#huge_page_size = 0# zero for system default

# (change requires restart)

#temp_buffers = 8MB# min 800kB

#max_prepared_transactions = 0# zero disables the feature

# (change requires restart)

externintshared_memory_type;

externinthuge_pages;

externinthuge_page_size;