open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add huge_page_size setting for use on Linux.

Browse Source 
This allows the huge page size to be set explicitly.  The default is 0,
meaning it will use the system default, as before.

Author: Odin Ugedal <odin@ugedal.com>
Discussion: https://postgr.es/m/20200608154639.20254-1-odin%40ugedal.com
pull/55/head
Thomas Munro 6 years ago
parent d66b23b032
commit d2bddc2500
6 changed files with 141 additions and 38 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 27
      doc/src/sgml/config.sgml
  2. 55
      doc/src/sgml/runtime.sgml
  3. 62
      src/backend/port/sysv_shmem.c
  4. 32
      src/backend/utils/misc/guc.c
  5. 2
      src/backend/utils/misc/postgresql.conf.sample
  6. 1
      src/include/storage/pg_shmem.h

27
doc/src/sgml/config.sgml
Unescape View File

@ -1582,6 +1582,33 @@ include_dir 'conf.d'
</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>

55
doc/src/sgml/runtime.sgml
Unescape View File

@ -1391,13 +1391,14 @@ export PG_OOM_ADJUST_VALUE=0
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
@ -1405,27 +1406,40 @@ $ <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 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 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>
@ -1438,8 +1452,9 @@ $ <userinput>grep Huge /proc/meminfo</userinput>
<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

62
src/backend/port/sysv_shmem.c
Unescape View File

@ -32,6 +32,7 @@
#endif
#include "miscadmin.h"
#include "port/pg_bitutils.h"
#include "portability/mem.h"
#include "storage/dsm.h"
#include "storage/fd.h"
@ -448,7 +449,7 @@ PGSharedMemoryAttach(IpcMemoryId shmId,
#ifdef MAP_HUGETLB
/*
* Identify the huge page size to use.
* Identify the huge page size to use, and compute the related mmap flags.
*
* Some Linux kernel versions have a bug causing mmap() to fail on requests
* that are not a multiple of the hugepage size. Versions without that bug
@ -464,25 +465,13 @@ PGSharedMemoryAttach(IpcMemoryId shmId,
* hugepage sizes, we might want to think about more invasive strategies,
* such as increasing shared_buffers to absorb the extra space.
*
* Returns the (real or assumed) page size into *hugepagesize,
* Returns the (real, assumed or config provided) page size into *hugepagesize,
* and the hugepage-related mmap flags to use into *mmap_flags.
*
* Currently *mmap_flags is always just MAP_HUGETLB. Someday, on systems
* that support it, we might OR in additional bits to specify a particular
* non-default huge page size.
*/
static void
GetHugePageSize(Size *hugepagesize, int *mmap_flags)
{
/*
* If we fail to find out the system's default huge page size, assume it
* is 2MB. This will work fine when the actual size is less. If it's
* more, we might get mmap() or munmap() failures due to unaligned
* requests; but at this writing, there are no reports of any non-Linux
* systems being picky about that.
*/
*hugepagesize = 2 * 1024 * 1024;
*mmap_flags = MAP_HUGETLB;
Size default_hugepagesize = 0;
/*
* System-dependent code to find out the default huge page size.
@ -491,6 +480,7 @@ GetHugePageSize(Size *hugepagesize, int *mmap_flags)
* nnnn kB". Ignore any failures, falling back to the preset default.
*/
#ifdef __linux__
{
FILE *fp = AllocateFile("/proc/meminfo", "r");
char buf[128];
@ -505,7 +495,7 @@ GetHugePageSize(Size *hugepagesize, int *mmap_flags)
{
if (ch == 'k')
{
*hugepagesize = sz * (Size) 1024;
default_hugepagesize = sz * (Size) 1024;
break;
}
/* We could accept other units besides kB, if needed */
@ -515,6 +505,44 @@ GetHugePageSize(Size *hugepagesize, int *mmap_flags)
}
}
#endif /* __linux__ */
if (huge_page_size != 0)
{
/* If huge page size is requested explicitly, use that. */
*hugepagesize = (Size) huge_page_size * 1024;
}
else if (default_hugepagesize != 0)
{
/* Otherwise use the system default, if we have it. */
*hugepagesize = default_hugepagesize;
}
else
{
/*
* If we fail to find out the system's default huge page size, or no
* huge page size is requested explicitly, assume it is 2MB. This will
* work fine when the actual size is less. If it's more, we might get
* mmap() or munmap() failures due to unaligned requests; but at this
* writing, there are no reports of any non-Linux systems being picky
* about that.
*/
*hugepagesize = 2 * 1024 * 1024;
}
*mmap_flags = MAP_HUGETLB;
/*
* On recent enough Linux, also include the explicit page size, if
* necessary.
*/
#if defined(MAP_HUGE_MASK) && defined(MAP_HUGE_SHIFT)
if (*hugepagesize != default_hugepagesize)
{
int shift = pg_ceil_log2_64(*hugepagesize);
*mmap_flags |= (shift & MAP_HUGE_MASK) << MAP_HUGE_SHIFT;
}
#endif
}
#endif /* MAP_HUGETLB */
@ -583,7 +611,7 @@ CreateAnonymousSegment(Size *size)
"(currently %zu bytes), reduce PostgreSQL's shared "
"memory usage, perhaps by reducing shared_buffers or "
"max_connections.",
*size) : 0));
allocsize) : 0));
}
*size = allocsize;

32
src/backend/utils/misc/guc.c
Unescape View File

@ -20,11 +20,14 @@
#include <float.h>
#include <math.h>
#include <limits.h>
#include <unistd.h>
#ifndef WIN32
#include <sys/mman.h>
#endif
#include <sys/stat.h>
#ifdef HAVE_SYSLOG
#include <syslog.h>
#endif
#include <unistd.h>
#include "access/commit_ts.h"
#include "access/gin.h"
@ -198,6 +201,7 @@ static bool check_max_wal_senders(int *newval, void **extra, GucSource source);
static bool check_autovacuum_work_mem(int *newval, void **extra, GucSource source);
static bool check_effective_io_concurrency(int *newval, void **extra, GucSource source);
static bool check_maintenance_io_concurrency(int *newval, void **extra, GucSource source);
static bool check_huge_page_size(int *newval, void **extra, GucSource source);
static void assign_pgstat_temp_directory(const char *newval, void *extra);
static bool check_application_name(char **newval, void **extra, GucSource source);
static void assign_application_name(const char *newval, void *extra);
@ -576,6 +580,7 @@ int ssl_renegotiation_limit;
* need to be duplicated in all the different implementations of pg_shmem.c.
*/
int huge_pages;
int huge_page_size;
/*
* These variables are all dummies that don't do anything, except in some
@ -3381,6 +3386,17 @@ static struct config_int ConfigureNamesInt[] =
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,
GUC_UNIT_KB
},
&huge_page_size,
0, 0, INT_MAX,
check_huge_page_size, NULL, NULL
},
/* End-of-list marker */
{
{NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
@ -11565,6 +11581,20 @@ check_maintenance_io_concurrency(int *newval, void **extra, GucSource source)
return true;
}
static bool
check_huge_page_size(int *newval, void **extra, GucSource source)
{
#if !(defined(MAP_HUGE_MASK) && defined(MAP_HUGE_SHIFT))
/* Recent enough Linux only, for now. See GetHugePageSize(). */
if (*newval != 0)
{
GUC_check_errdetail("huge_page_size must be 0 on this platform.");
return false;
}
#endif
return true;
}
static void
assign_pgstat_temp_directory(const char *newval, void *extra)
{

2
src/backend/utils/misc/postgresql.conf.sample
Unescape View File

@ -122,6 +122,8 @@
# (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)

1
src/include/storage/pg_shmem.h
Unescape View File

@ -44,6 +44,7 @@ typedef struct PGShmemHeader /* standard header for all Postgres shmem */
/* GUC variables */
extern int shared_memory_type;
extern int huge_pages;
extern int huge_page_size;
/* Possible values for huge_pages */
typedef enum

Write Preview
Loading…
Cancel
Save