Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit1a3458b

Browse files
committed
Allow using huge TLB pages on Linux (MAP_HUGETLB)
This patch adds an option, huge_tlb_pages, which allows requesting theshared memory segment to be allocated using huge pages, by using theMAP_HUGETLB flag in mmap(). This can improve performance.The default is 'try', which means that we will attempt using huge pages,and fall back to non-huge pages if it doesn't work. Currently, only Linuxhas MAP_HUGETLB. On other platforms, the default 'try' behaves the same as'off'.In the passing, don't try to round the mmap() size to a multiple ofpagesize. mmap() doesn't require that, and there's no particular reason forPostgreSQL to do that either. When using MAP_HUGETLB, however, round therequest size up to nearest 2MB boundary. This is to work around a bug insome Linux kernel versions, but also to avoid wasting memory, because thekernel will round the size up anyway.Many people were involved in writing this patch, including Christian Kruse,Richard Poole, Abhijit Menon-Sen, reviewed by Peter Geoghegan, Andres Freundand me.
1 parentb7643b1 commit1a3458b

File tree

6 files changed

+183
-39
lines changed

6 files changed

+183
-39
lines changed

‎doc/src/sgml/config.sgml

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1107,6 +1107,43 @@ include 'filename'
11071107
</listitem>
11081108
</varlistentry>
11091109

1110+
<varlistentry id="guc-huge-tlb-pages" xreflabel="huge_tlb_pages">
1111+
<term><varname>huge_tlb_pages</varname> (<type>enum</type>)</term>
1112+
<indexterm>
1113+
<primary><varname>huge_tlb_pages</> configuration parameter</primary>
1114+
</indexterm>
1115+
<listitem>
1116+
<para>
1117+
Enables/disables the use of huge TLB pages. Valid values are
1118+
<literal>try</literal> (the default), <literal>on</literal>,
1119+
and <literal>off</literal>.
1120+
</para>
1121+
1122+
<para>
1123+
At present, this feature is supported only on Linux. The setting
1124+
is ignored on other systems.
1125+
</para>
1126+
1127+
<para>
1128+
The use of huge TLB pages results in smaller page tables and
1129+
less CPU time spent on memory management, increasing performance. For
1130+
more details, see
1131+
<ulink url="https://wiki.debian.org/Hugepages">the Debian wiki</ulink>.
1132+
Remember that you will need at least shared_buffers / huge page size +
1133+
1 huge TLB pages. So for example for a system with 6GB shared buffers
1134+
and a hugepage size of 2kb of you will need at least 3156 huge pages.
1135+
</para>
1136+
1137+
<para>
1138+
With <varname>huge_tlb_pages</varname> set to <literal>try</literal>,
1139+
the server will try to use huge pages, but fall back to using
1140+
normal allocation if that fails. With <literal>on</literal, failure
1141+
to use huge pages will prevent the server from starting up. With
1142+
<literal>off</literal>, huge pages will not be used.
1143+
</para>
1144+
</listitem>
1145+
</varlistentry>
1146+
11101147
<varlistentry id="guc-temp-buffers" xreflabel="temp_buffers">
11111148
<term><varname>temp_buffers</varname> (<type>integer</type>)</term>
11121149
<indexterm>

‎src/backend/port/sysv_shmem.c

Lines changed: 96 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@
3232
#include"portability/mem.h"
3333
#include"storage/ipc.h"
3434
#include"storage/pg_shmem.h"
35+
#include"utils/guc.h"
3536

3637

3738
typedefkey_tIpcMemoryKey;/* shared memory key passed to shmget(2) */
@@ -41,7 +42,7 @@ typedef int IpcMemoryId;/* shared memory ID returned by shmget(2) */
4142
unsigned longUsedShmemSegID=0;
4243
void*UsedShmemSegAddr=NULL;
4344
staticSizeAnonymousShmemSize;
44-
staticvoid*AnonymousShmem;
45+
staticvoid*AnonymousShmem=NULL;
4546

4647
staticvoid*InternalIpcMemoryCreate(IpcMemoryKeymemKey,Sizesize);
4748
staticvoidIpcMemoryDetach(intstatus,Datumshmaddr);
@@ -317,6 +318,80 @@ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
317318
return true;
318319
}
319320

321+
/*
322+
* Creates an anonymous mmap()ed shared memory segment.
323+
*
324+
* Pass the requested size in *size. This function will modify *size to the
325+
* actual size of the allocation, if it ends up allocating a segment that is
326+
* larger than requested.
327+
*/
328+
#ifndefEXEC_BACKEND
329+
staticvoid*
330+
CreateAnonymousSegment(Size*size)
331+
{
332+
Sizeallocsize;
333+
void*ptr=MAP_FAILED;
334+
335+
#ifndefMAP_HUGETLB
336+
if (huge_tlb_pages==HUGE_TLB_ON)
337+
ereport(ERROR,
338+
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
339+
errmsg("huge TLB pages not supported on this platform")));
340+
#else
341+
if (huge_tlb_pages==HUGE_TLB_ON||huge_tlb_pages==HUGE_TLB_TRY)
342+
{
343+
/*
344+
* Round up the request size to a suitable large value.
345+
*
346+
* Some Linux kernel versions are known to have a bug, which causes
347+
* mmap() with MAP_HUGETLB to fail if the request size is not a
348+
* multiple of any supported huge page size. To work around that, we
349+
* round up the request size to nearest 2MB. 2MB is the most common
350+
* huge page page size on affected systems.
351+
*
352+
* Aside from that bug, even with a kernel that does the allocation
353+
* correctly, rounding it up ourselves avoids wasting memory. Without
354+
* it, if we for example make an allocation of 2MB + 1 bytes, the
355+
* kernel might decide to use two 2MB huge pages for that, and waste 2
356+
* MB - 1 of memory. When we do the rounding ourselves, we can use
357+
* that space for allocations.
358+
*/
359+
inthugepagesize=2*1024*1024;
360+
361+
allocsize=*size;
362+
if (allocsize %hugepagesize!=0)
363+
allocsize+=hugepagesize- (allocsize %hugepagesize);
364+
365+
ptr=mmap(NULL,*size,PROT_READ |PROT_WRITE,
366+
PG_MMAP_FLAGS |MAP_HUGETLB,-1,0);
367+
if (huge_tlb_pages==HUGE_TLB_TRY&&ptr==MAP_FAILED)
368+
elog(DEBUG1,"mmap with MAP_HUGETLB failed, huge pages disabled: %m");
369+
}
370+
#endif
371+
372+
if (huge_tlb_pages==HUGE_TLB_OFF||
373+
(huge_tlb_pages==HUGE_TLB_TRY&&ptr==MAP_FAILED))
374+
{
375+
allocsize=*size;
376+
ptr=mmap(NULL,*size,PROT_READ |PROT_WRITE,PG_MMAP_FLAGS,-1,0);
377+
}
378+
379+
if (ptr==MAP_FAILED)
380+
ereport(FATAL,
381+
(errmsg("could not map anonymous shared memory: %m"),
382+
(errno==ENOMEM) ?
383+
errhint("This error usually means that PostgreSQL's request "
384+
"for a shared memory segment exceeded available memory, "
385+
"swap space or huge pages. To reduce the request size "
386+
"(currently %zu bytes), reduce PostgreSQL's shared "
387+
"memory usage, perhaps by reducing shared_buffers or "
388+
"max_connections.",
389+
*size) :0));
390+
391+
*size=allocsize;
392+
returnptr;
393+
}
394+
#endif
320395

321396
/*
322397
* PGSharedMemoryCreate
@@ -344,7 +419,14 @@ PGSharedMemoryCreate(Size size, bool makePrivate, int port)
344419
PGShmemHeader*hdr;
345420
IpcMemoryIdshmid;
346421
structstatstatbuf;
347-
Sizesysvsize=size;
422+
Sizesysvsize;
423+
424+
#if defined(EXEC_BACKEND)|| !defined(MAP_HUGETLB)
425+
if (huge_tlb_pages==HUGE_TLB_ON)
426+
ereport(ERROR,
427+
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
428+
errmsg("huge TLB pages not supported on this platform")));
429+
#endif
348430

349431
/* Room for a header? */
350432
Assert(size>MAXALIGN(sizeof(PGShmemHeader)));
@@ -359,51 +441,26 @@ PGSharedMemoryCreate(Size size, bool makePrivate, int port)
359441
* to run many copies of PostgreSQL without needing to adjust system
360442
* settings.
361443
*
444+
* We assume that no one will attempt to run PostgreSQL 9.3 or later on
445+
* systems that are ancient enough that anonymous shared memory is not
446+
* supported, such as pre-2.4 versions of Linux. If that turns out to be
447+
* false, we might need to add a run-time test here and do this only if
448+
* the running kernel supports it.
449+
*
362450
* However, we disable this logic in the EXEC_BACKEND case, and fall back
363451
* to the old method of allocating the entire segment using System V
364452
* shared memory, because there's no way to attach an mmap'd segment to a
365453
* process after exec(). Since EXEC_BACKEND is intended only for
366454
* developer use, this shouldn't be a big problem.
367455
*/
368456
#ifndefEXEC_BACKEND
369-
{
370-
longpagesize=sysconf(_SC_PAGE_SIZE);
371-
372-
/*
373-
* Ensure request size is a multiple of pagesize.
374-
*
375-
* pagesize will, for practical purposes, always be a power of two.
376-
* But just in case it isn't, we do it this way instead of using
377-
* TYPEALIGN().
378-
*/
379-
if (pagesize>0&&size %pagesize!=0)
380-
size+=pagesize- (size %pagesize);
457+
AnonymousShmem=CreateAnonymousSegment(&size);
458+
AnonymousShmemSize=size;
381459

382-
/*
383-
* We assume that no one will attempt to run PostgreSQL 9.3 or later
384-
* on systems that are ancient enough that anonymous shared memory is
385-
* not supported, such as pre-2.4 versions of Linux. If that turns
386-
* out to be false, we might need to add a run-time test here and do
387-
* this only if the running kernel supports it.
388-
*/
389-
AnonymousShmem=mmap(NULL,size,PROT_READ |PROT_WRITE,PG_MMAP_FLAGS,
390-
-1,0);
391-
if (AnonymousShmem==MAP_FAILED)
392-
ereport(FATAL,
393-
(errmsg("could not map anonymous shared memory: %m"),
394-
(errno==ENOMEM) ?
395-
errhint("This error usually means that PostgreSQL's request "
396-
"for a shared memory segment exceeded available memory "
397-
"or swap space. To reduce the request size (currently "
398-
"%zu bytes), reduce PostgreSQL's shared memory usage, "
399-
"perhaps by reducing shared_buffers or "
400-
"max_connections.",
401-
size) :0));
402-
AnonymousShmemSize=size;
403-
404-
/* Now we need only allocate a minimal-sized SysV shmem block. */
405-
sysvsize=sizeof(PGShmemHeader);
406-
}
460+
/* Now we need only allocate a minimal-sized SysV shmem block. */
461+
sysvsize=sizeof(PGShmemHeader);
462+
#else
463+
sysvsize=size;
407464
#endif
408465

409466
/* Make sure PGSharedMemoryAttach doesn't fail without need */

‎src/backend/port/win32_shmem.c

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -128,6 +128,11 @@ PGSharedMemoryCreate(Size size, bool makePrivate, int port)
128128
DWORDsize_high;
129129
DWORDsize_low;
130130

131+
if (huge_tlb_pages==HUGE_TLB_ON)
132+
ereport(ERROR,
133+
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
134+
errmsg("huge TLB pages not supported on this platform")));
135+
131136
/* Room for a header? */
132137
Assert(size>MAXALIGN(sizeof(PGShmemHeader)));
133138

‎src/backend/utils/misc/guc.c

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,7 @@
6464
#include"storage/dsm_impl.h"
6565
#include"storage/standby.h"
6666
#include"storage/fd.h"
67+
#include"storage/pg_shmem.h"
6768
#include"storage/proc.h"
6869
#include"storage/predicate.h"
6970
#include"tcop/tcopprot.h"
@@ -387,6 +388,23 @@ static const struct config_enum_entry synchronous_commit_options[] = {
387388
{NULL,0, false}
388389
};
389390

391+
/*
392+
* Although only "on", "off", "try" are documented, we accept all the likely
393+
* variants of "on" and "off".
394+
*/
395+
staticconststructconfig_enum_entryhuge_tlb_options[]= {
396+
{"off",HUGE_TLB_OFF, false},
397+
{"on",HUGE_TLB_ON, false},
398+
{"try",HUGE_TLB_TRY, false},
399+
{"true",HUGE_TLB_ON, true},
400+
{"false",HUGE_TLB_OFF, true},
401+
{"yes",HUGE_TLB_ON, true},
402+
{"no",HUGE_TLB_OFF, true},
403+
{"1",HUGE_TLB_ON, true},
404+
{"0",HUGE_TLB_OFF, true},
405+
{NULL,0, false}
406+
};
407+
390408
/*
391409
* Options for enum values stored in other modules
392410
*/
@@ -447,6 +465,12 @@ inttcp_keepalives_idle;
447465
inttcp_keepalives_interval;
448466
inttcp_keepalives_count;
449467

468+
/*
469+
* This really belongs in pg_shmem.c, but is defined here so that it doesn't
470+
* need to be duplicated in all the different implementations of pg_shmem.c.
471+
*/
472+
inthuge_tlb_pages;
473+
450474
/*
451475
* These variables are all dummies that don't do anything, except in some
452476
* cases provide the value for SHOW to display. The real state is elsewhere
@@ -3430,6 +3454,15 @@ static struct config_enum ConfigureNamesEnum[] =
34303454
NULL,NULL,NULL
34313455
},
34323456

3457+
{
3458+
{"huge_tlb_pages",PGC_POSTMASTER,RESOURCES_MEM,
3459+
gettext_noop("Use of huge TLB pages on Linux"),
3460+
NULL
3461+
},
3462+
&huge_tlb_pages,
3463+
HUGE_TLB_TRY,huge_tlb_options,
3464+
NULL,NULL,NULL
3465+
},
34333466

34343467
/* End-of-list marker */
34353468
{

‎src/backend/utils/misc/postgresql.conf.sample

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -115,6 +115,8 @@
115115

116116
#shared_buffers = 32MB# min 128kB
117117
# (change requires restart)
118+
#huge_tlb_pages = try# on, off, or try
119+
# (change requires restart)
118120
#temp_buffers = 8MB# min 800kB
119121
#max_prepared_transactions = 0# zero disables the feature
120122
# (change requires restart)

‎src/include/storage/pg_shmem.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,16 @@ typedef struct PGShmemHeader/* standard header for all Postgres shmem */
3838
#endif
3939
}PGShmemHeader;
4040

41+
/* GUC variable */
42+
externinthuge_tlb_pages;
43+
44+
/* Possible values for huge_tlb_pages */
45+
typedefenum
46+
{
47+
HUGE_TLB_OFF,
48+
HUGE_TLB_ON,
49+
HUGE_TLB_TRY
50+
}HugeTlbType;
4151

4252
#ifdefEXEC_BACKEND
4353
#ifndefWIN32

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp